Changeset 3a0a4d8 in mainline for uspace/lib/c

Timestamp:

2013-09-12T07:54:05Z (12 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

95027b5

Parents:

47f5a77 (diff), 64f3d3b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge mainline changes

Location:

uspace/lib/c

Files:

• Makefile (modified) (1 diff)
• arch/sparc64/Makefile.common (modified) (1 diff)
• generic/adt/hash_table.c (modified) (2 diffs)
• generic/adt/list.c (modified) (1 diff)
• generic/async.c (modified) (2 diffs)
• generic/cfg.c (modified) (3 diffs)
• generic/corecfg.c (added)
• generic/ddi.c (modified) (4 diffs)
• generic/device/hw_res.c (modified) (3 diffs)
• generic/device/hw_res_parsed.c (modified) (6 diffs)
• generic/device/pio_window.c (added)
• generic/devman.c (modified) (8 diffs)
• generic/dnsr.c (modified) (2 diffs)
• generic/futex.c (modified) (4 diffs)
• generic/inet/addr.c (modified) (2 diffs)
• generic/pio_trace.c (modified) (2 diffs)
• generic/time.c (modified) (1 diff)
• generic/vfs/vfs.c (modified) (2 diffs)
• include/adt/list.h (modified) (4 diffs)
• include/async.h (modified) (2 diffs)
• include/cfg.h (modified) (2 diffs)
• include/corecfg.h (added)
• include/ddi.h (modified) (4 diffs)
• include/device/hw_res.h (modified) (2 diffs)
• include/device/hw_res_parsed.h (modified) (1 diff)
• include/device/pio_window.h (added)
• include/devman.h (modified) (2 diffs)
• include/inet/addr.h (modified) (1 diff)
• include/inet/dnsr.h (modified) (1 diff)
• include/ipc/corecfg.h (added)
• include/ipc/dev_iface.h (modified) (3 diffs)
• include/ipc/devman.h (modified) (3 diffs)
• include/ipc/services.h (modified) (1 diff)
• include/ipc/vfs.h (modified) (2 diffs)
• include/macros.h (modified) (1 diff)
• include/sys/statfs.h (added)
• include/vfs/vfs.h (modified) (2 diffs)

uspace/lib/c/Makefile

@@ -65 +65 @@
         generic/cfg.c \
         generic/clipboard.c \
+        generic/corecfg.c \
         generic/devman.c \
         generic/device/hw_res.c \
         generic/device/hw_res_parsed.c \
+        generic/device/pio_window.c \
         generic/device/char_dev.c \
         generic/device/clock_dev.c \

uspace/lib/c/arch/sparc64/Makefile.common

@@ -27 +27 @@
 #
 
-GCC_CFLAGS += -mcpu=ultrasparc -m64 -mcmodel=medlow
+ifeq ($(PROCESSOR),sun4v)
+GCC_CFLAGS += -mcpu=niagara -mno-vis
+else
+GCC_CFLAGS += -mcpu=ultrasparc
+endif
+
+GCC_CFLAGS += -m64 -mcmodel=medlow
+
 LFLAGS = -no-check-sections
 

uspace/lib/c/generic/adt/hash_table.c

@@ -227 +227 @@
         
         /* Check for duplicates. */
-        list_foreach(h->bucket[idx], cur) {
+        list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
                 /* 
                  * We could filter out items using their hashes first, but 
                  * calling equal() might very well be just as fast.
                  */
-                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
                 if (h->op->equal(cur_link, item))
                         return false;
@@ -258 +257 @@
         size_t idx = h->op->key_hash(key) % h->bucket_cnt;
 
-        list_foreach(h->bucket[idx], cur) {
-                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+        list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
                 /* 
                  * Is this is the item we are looking for? We could have first 

uspace/lib/c/generic/adt/list.c

@@ -102 +102 @@
         unsigned int count = 0;
         
-        list_foreach(*list, link) {
+        link_t *link = list_first(list);
+        while (link != NULL) {
                 count++;
+                link = list_next(link, list);
         }
         

uspace/lib/c/generic/async.c

@@ -2281 +2281 @@
 bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
 {
+        ipc_call_t data;
+        return async_data_read_receive_call(callid, &data, size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
+ * calls so that the user doesn't have to remember the meaning of each IPC
+ * argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid Storage for the hash of the IPC_M_DATA_READ.
+ * @param size   Storage for the maximum size. Can be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_read_receive_call(ipc_callid_t *callid, ipc_call_t *data,
+    size_t *size)
+{
         assert(callid);
-        
-        ipc_call_t data;
-        *callid = async_get_call(&data);
-        
-        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
+        assert(data);
+        
+        *callid = async_get_call(data);
+        
+        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
                 return false;
         
         if (size)
-                *size = (size_t) IPC_GET_ARG2(data);
+                *size = (size_t) IPC_GET_ARG2(*data);
         
         return true;
@@ -2385 +2406 @@
 bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
 {
+        ipc_call_t data;
+        return async_data_write_receive_call(callid, &data, size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
+ * calls so that the user doesn't have to remember the meaning of each IPC
+ * argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
+ * @param data   Storage for the ipc call data.
+ * @param size   Storage for the suggested size. May be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_write_receive_call(ipc_callid_t *callid, ipc_call_t *data,
+    size_t *size)
+{
         assert(callid);
-        
-        ipc_call_t data;
-        *callid = async_get_call(&data);
-        
-        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
+        assert(data);
+        
+        *callid = async_get_call(data);
+        
+        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
                 return false;
         
         if (size)
-                *size = (size_t) IPC_GET_ARG2(data);
+                *size = (size_t) IPC_GET_ARG2(*data);
         
         return true;

uspace/lib/c/generic/cfg.c

@@ -83 +83 @@
                 return true;
         
-        list_foreach(data->sections, link) {
-                const cfg_section_t *section = cfg_section_instance(link);
-                
+        cfg_file_foreach(data, section) {
                 if (!list_empty(&section->entries))
                         return false;
@@ -413 +411 @@
 const cfg_section_t *cfg_find_section(const cfg_file_t *data, const char *title)
 {
-        list_foreach(data->sections, link) {
-                const cfg_section_t *section = cfg_section_instance(link);
-                
+        cfg_file_foreach(data, section) {
                 if (str_cmp(section->title, title) == 0)
                         return section;
@@ -434 +430 @@
 const char *cfg_find_value(const cfg_section_t *section, const char *key)
 {
-        list_foreach(section->entries, link) {
-                const cfg_entry_t *entry = cfg_entry_instance(link);
-                
+        cfg_section_foreach(section, entry) {
                 if (str_cmp(entry->key, key) == 0)
                         return entry->value;

uspace/lib/c/generic/ddi.c

@@ -76 +76 @@
  *
  */
-int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
+int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
 {
         return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
@@ -83 +83 @@
 
 int dmamem_map(void *virt, size_t size, unsigned int map_flags,
-    unsigned int flags, void **phys)
+    unsigned int flags, uintptr_t *phys)
 {
         return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
@@ -90 +90 @@
 }
 
-int dmamem_map_anonymous(size_t size, unsigned int map_flags,
-    unsigned int flags, void **phys, void **virt)
-{
+int dmamem_map_anonymous(size_t size, uintptr_t constraint,
+    unsigned int map_flags, unsigned int flags, uintptr_t *phys, void **virt)
+{
+        *phys = constraint;
+        
         return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
             (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
@@ -158 +160 @@
         if (!virt)
                 return EINVAL;
-
-        void *phys_frame =
-            (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
-        size_t offset = pio_addr - phys_frame;
+        
+        uintptr_t phys_frame =
+            ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
+        size_t offset = (uintptr_t) pio_addr - phys_frame;
         size_t pages = SIZE2PAGES(offset + size);
         

uspace/lib/c/generic/device/hw_res.c

@@ -44 +44 @@
         
         async_exch_t *exch = async_exchange_begin(sess);
+        
         int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_GET_RESOURCE_LIST, &count);
@@ -77 +78 @@
 {
         async_exch_t *exch = async_exchange_begin(sess);
+        
         int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_ENABLE_INTERRUPT);
@@ -84 +86 @@
 }
 
+/** Setup DMA channel to specified place and mode.
+ *
+ * @param channel DMA channel.
+ * @param pa      Physical address of the buffer.
+ * @param size    DMA buffer size.
+ * @param mode    Mode of the DMA channel:
+ *                 - Read or Write
+ *                 - Allow automatic reset
+ *                 - Use address decrement instead of increment
+ *                 - Use SINGLE/BLOCK/ON DEMAND transfer mode
+ *
+ * @return Error code.
+ *
+ */
+int hw_res_dma_channel_setup(async_sess_t *sess,
+    unsigned channel, uint32_t pa, uint32_t size, uint8_t mode)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+        
+        const uint32_t packed = (channel & 0xffff) | (mode << 16);
+        const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
+        
+        async_exchange_end(exch);
+        
+        return ret;
+}
+
+/** Query remaining bytes in the buffer.
+ *
+ * @param channel DMA channel.
+ *
+ * @return Number of bytes remaining in the buffer if positive.
+ * @return Error code if negative.
+ *
+ */
+int hw_res_dma_channel_remain(async_sess_t *sess, unsigned channel)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+        
+        sysarg_t remain;
+        const int ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
+        
+        async_exchange_end(exch);
+        
+        if (ret == EOK)
+                return remain;
+        
+        return ret;
+}
+
 /** @}
  */

uspace/lib/c/generic/device/hw_res_parsed.c

@@ -38 +38 @@
 #include <errno.h>
 
-static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
-    int flags)
+static void hw_res_parse_add_dma_channel(hw_res_list_parsed_t *out,
+    const hw_resource_t *res, int flags)
+{
+        assert(res);
+        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
+        
+        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
+            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
+        const size_t count = out->dma_channels.count;
+        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
+        
+        if (!keep_duplicit) {
+                for (size_t i = 0; i < count; ++i) {
+                        if (out->dma_channels.channels[i] == channel)
+                                return;
+                }
+        }
+        
+        out->dma_channels.channels[count] = channel;
+        ++out->dma_channels.count;
+}
+
+static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == INTERRUPT));
@@ -59 +81 @@
 
 static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
-    hw_resource_t *res, int flags)
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == IO_RANGE));
@@ -90 +112 @@
 
 static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
-    hw_resource_t *res, int flags)
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == MEM_RANGE));
@@ -132 +154 @@
  *
  */
-int hw_res_list_parse(hw_resource_list_t *hw_resources,
+int hw_res_list_parse(const hw_resource_list_t *hw_resources,
     hw_res_list_parsed_t *out, int flags)
 {
@@ -141 +163 @@
         hw_res_list_parsed_clean(out);
         
-        out->irqs.irqs = malloc(res_count * sizeof(int));
-        out->io_ranges.ranges = malloc(res_count * sizeof(io_range_t));
-        out->mem_ranges.ranges = malloc(res_count * sizeof(mem_range_t));
+        out->irqs.irqs = calloc(res_count, sizeof(int));
+        out->dma_channels.channels = calloc(res_count, sizeof(int));
+        out->io_ranges.ranges = calloc(res_count, sizeof(io_range_t));
+        out->mem_ranges.ranges = calloc(res_count, sizeof(mem_range_t));
+        if (!out->irqs.irqs || !out->dma_channels.channels ||
+            !out->io_ranges.ranges || !out->mem_ranges.ranges) {
+                hw_res_list_parsed_clean(out);
+                return ENOMEM;
+        }
         
         for (size_t i = 0; i < res_count; ++i) {
-                hw_resource_t *resource = &(hw_resources->resources[i]);
+                const hw_resource_t *resource = &(hw_resources->resources[i]);
                 
                 switch (resource->type) {
@@ -158 +186 @@
                         hw_res_parse_add_mem_range(out, resource, flags);
                         break;
+                case DMA_CHANNEL_8:
+                case DMA_CHANNEL_16:
+                        hw_res_parse_add_dma_channel(out, resource, flags);
+                        break;
                 default:
+                        hw_res_list_parsed_clean(out);
                         return EINVAL;
                 }

uspace/lib/c/generic/devman.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2007 Josef Cejka
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2013 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * All rights reserved.
@@ -230 +230 @@
         }
         
-        match_id_t *match_id = NULL;
-        
-        list_foreach(match_ids->ids, link) {
-                match_id = list_get_instance(link, match_id_t, link);
-                
+        list_foreach(match_ids->ids, link, match_id_t, match_id) {
                 ipc_call_t answer2;
                 aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
@@ -405 +401 @@
 }
 
-static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
-    size_t buf_size)
+static int devman_get_str_internal(sysarg_t method, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t *r1, char *buf, size_t buf_size)
 {
         async_exch_t *exch;
@@ -416 +412 @@
         
         ipc_call_t answer;
-        aid_t req = async_send_1(exch, method, arg1, &answer);
+        aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
         aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
         async_wait_for(dreq, &dretval);
@@ -434 +430 @@
         }
         
+        if (r1 != NULL)
+                *r1 = IPC_GET_ARG1(answer);
         act_size = IPC_GET_ARG2(dreply);
         assert(act_size <= buf_size - 1);
@@ -443 +441 @@
 int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
 {
-        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
-            buf_size);
+        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, 0, NULL,
+            buf, buf_size);
+}
+
+int devman_fun_get_match_id(devman_handle_t handle, size_t index, char *buf,
+    size_t buf_size, unsigned int *rscore)
+{
+        int rc;
+        sysarg_t score = 0;
+
+        rc = devman_get_str_internal(DEVMAN_FUN_GET_MATCH_ID, handle, index,
+            &score, buf, buf_size);
+        if (rc != EOK)
+                return rc;
+
+        *rscore = score;
+        return rc;
 }
 
 int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
 {
-        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
-            buf_size);
+        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, 0, NULL,
+            buf, buf_size);
 }
 
 int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
 {
-        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
-            buf_size);
+        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, 0,
+            NULL, buf, buf_size);
 }
 
@@ -583 +596 @@
 }
 
+int devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        sysarg_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
+            devh, funh);
+        
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+
 int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
 {
@@ -596 +622 @@
 }
 
+int devman_get_drivers(devman_handle_t **drvs,
+    size_t *count)
+{
+        return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
+}
+
+int devman_driver_get_devices(devman_handle_t drvh, devman_handle_t **devs,
+    size_t *count)
+{
+        return devman_get_handles_internal(DEVMAN_DRIVER_GET_DEVICES,
+            drvh, devs, count);
+}
+
+int devman_driver_get_handle(const char *drvname, devman_handle_t *handle)
+{
+        async_exch_t *exch;
+
+        exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
+        sysarg_t retval = async_data_write_start(exch, drvname,
+            str_size(drvname));
+        
+        devman_exchange_end(exch);
+        
+        if (retval != EOK) {
+                async_forget(req);
+                return retval;
+        }
+        
+        async_wait_for(req, &retval);
+        
+        if (retval != EOK) {
+                if (handle != NULL)
+                        *handle = (devman_handle_t) -1;
+                
+                return retval;
+        }
+        
+        if (handle != NULL)
+                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
+        
+        return retval;
+}
+
+int devman_driver_get_match_id(devman_handle_t handle, size_t index, char *buf,
+    size_t buf_size, unsigned int *rscore)
+{
+        int rc;
+        sysarg_t score = 0;
+
+        rc = devman_get_str_internal(DEVMAN_DRIVER_GET_MATCH_ID, handle, index,
+            &score, buf, buf_size);
+        if (rc != EOK)
+                return rc;
+
+        *rscore = score;
+        return rc;
+}
+
+int devman_driver_get_name(devman_handle_t handle, char *buf, size_t buf_size)
+{
+        return devman_get_str_internal(DEVMAN_DRIVER_GET_NAME, handle, 0, NULL,
+            buf, buf_size);
+}
+
+int devman_driver_get_state(devman_handle_t drvh, driver_state_t *rstate)
+{
+        sysarg_t state;
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        int rc = async_req_1_1(exch, DEVMAN_DRIVER_GET_STATE, drvh,
+            &state);
+        
+        devman_exchange_end(exch);
+        if (rc != EOK)
+                return rc;
+
+        *rstate = state;
+        return rc;
+}
+
+int devman_driver_load(devman_handle_t drvh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        
+        int rc = async_req_1_0(exch, DEVMAN_DRIVER_LOAD, drvh);
+        
+        devman_exchange_end(exch);
+        return rc;
+}
+
 /** @}
  */

uspace/lib/c/generic/dnsr.c

@@ -67 +67 @@
 }
 
-int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo)
+int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, uint16_t af)
 {
         dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
@@ -76 +76 @@
         
         ipc_call_t answer;
-        aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
+        aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) af,
+            &answer);
         
         int rc = async_data_write_start(exch, name, str_size(name));

uspace/lib/c/generic/futex.c

@@ -35 +35 @@
 #include <futex.h>
 #include <atomic.h>
+#include <libarch/barrier.h>
 #include <libc.h>
 #include <sys/types.h>
@@ -59 +60 @@
 int futex_trydown(futex_t *futex)
 {
-        return cas(futex, 1, 0);
+        int rc;
+
+        rc = cas(futex, 1, 0);
+        CS_ENTER_BARRIER();
+
+        return rc;
 }
 
@@ -73 +79 @@
 int futex_down(futex_t *futex)
 {
-        if ((atomic_signed_t) atomic_predec(futex) < 0)
+        atomic_signed_t nv;
+
+        nv = (atomic_signed_t) atomic_predec(futex);
+        CS_ENTER_BARRIER();
+        if (nv < 0)
                 return __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->count);
         
@@ -89 +99 @@
 int futex_up(futex_t *futex)
 {
+        CS_LEAVE_BARRIER();
+
         if ((atomic_signed_t) atomic_postinc(futex) < 0)
                 return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->count);

uspace/lib/c/generic/inet/addr.c

@@ -52 +52 @@
 };
 
+static const addr48_t inet_addr48_solicited_node = {
+        0x33, 0x33, 0xff, 0, 0, 0
+};
+
 static const inet_addr_t inet_addr_any_addr = {
         .family = AF_INET,
@@ -72 +76 @@
 }
 
+int addr48_compare(const addr48_t a, const addr48_t b)
+{
+        return memcmp(a, b, 6);
+}
+
 int addr128_compare(const addr128_t a, const addr128_t b)
 {
         return memcmp(a, b, 16);
+}
+
+/** Compute solicited node MAC multicast address from target IPv6 address
+ *
+ * @param ip  Target IPv6 address
+ * @param mac Solicited MAC address to be assigned
+ *
+ */
+void addr48_solicited_node(const addr128_t ip, addr48_t mac)
+{
+        memcpy(mac, inet_addr48_solicited_node, 3);
+        memcpy(mac + 3, ip + 13, 3);
 }
 

uspace/lib/c/generic/pio_trace.c

@@ -95 +95 @@
         pio_regions_t *regions = get_regions();
         fibril_rwlock_read_lock(&regions->guard);
-        list_foreach(regions->list, it) {
-                assert(it);
-                region_t *reg = region_instance(it);
-                assert(reg);
+        list_foreach(regions->list, link, region_t, reg) {
                 if ((r >= reg->base) && (r < reg->base + reg->size)) {
                         if (reg->log)
@@ -131 +128 @@
         fibril_rwlock_write_lock(&regions->guard);
         list_foreach_safe(regions->list, it, next) {
-                assert(it);
                 region_t *reg = region_instance(it);
-                assert(reg);
                 if (r >= reg->base && (r < reg->base + reg->size)) {
-                                list_remove(&reg->link);
-                                region_destroy(reg);
+                        list_remove(&reg->link);
+                        region_destroy(reg);
                 }
         }

uspace/lib/c/generic/time.c

@@ -556 +556 @@
                 
                 void *addr;
-                rc = physmem_map((void *) faddr, 1,
-                    AS_AREA_READ | AS_AREA_CACHEABLE, &addr);
+                rc = physmem_map(faddr, 1, AS_AREA_READ | AS_AREA_CACHEABLE,
+                    &addr);
                 if (rc != EOK) {
                         as_area_destroy(addr);

uspace/lib/c/generic/vfs/vfs.c

@@ -43 +43 @@
 #include <stdio.h>
 #include <sys/stat.h>
+#include <sys/statfs.h>
 #include <sys/types.h>
 #include <ipc/services.h>
@@ -892 +893 @@
 }
 
+int statfs(const char *path, struct statfs *statfs)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t pa_size;
+        
+        char *pa = absolutize(path, &pa_size);
+        if (!pa)
+                return ENOMEM;
+        async_exch_t *exch = vfs_exchange_begin();
+        
+        req = async_send_0(exch, VFS_IN_STATFS, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_read_start(exch, (void *) statfs, sizeof(struct statfs));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc);
+        return rc;
+}
+
 /** @}
  */

uspace/lib/c/include/adt/list.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2013 Jiri Svoboda
  * All rights reserved.
  *
@@ -65 +65 @@
 
 #define list_get_instance(link, type, member) \
-        ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
-
-#define list_foreach(list, iterator) \
-        for (link_t *iterator = (list).head.next; \
-            iterator != &(list).head; iterator = iterator->next)
+        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
+
+#define list_foreach(list, member, itype, iterator) \
+        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
+            for (link_t *_link = (list).head.next; \
+            iterator = list_get_instance(_link, itype, member), \
+            _link != &(list).head; _link = _link->next)
 
 /** Unlike list_foreach(), allows removing items while traversing a list.
- * 
+ *
  * @code
  * list_t mylist;
@@ -238 +240 @@
 static inline link_t *list_last(list_t *list)
 {
-        return ((list->head.prev == &list->head) ? NULL : list->head.prev);
+        return (list->head.prev == &list->head) ? NULL : list->head.prev;
+}
+
+/** Get next item in list.
+ *
+ * @param link Current item link
+ * @param list List containing @a link
+ *
+ * @return Next item or NULL if @a link is the last item.
+ *
+ */
+static inline link_t *list_next(link_t *link, const list_t *list)
+{
+        return (link->next == &list->head) ? NULL : link->next;
+}
+
+/** Get previous item in list.
+ *
+ * @param link Current item link
+ * @param list List containing @a link
+ *
+ * @return Previous item or NULL if @a link is the first item.
+ *
+ */
+static inline link_t *list_prev(link_t *link, const list_t *list)
+{
+        return (link->prev == &list->head) ? NULL : link->prev;
 }
 
@@ -308 +336 @@
         unsigned int cnt = 0;
         
-        list_foreach(*list, link) {
+        link_t *link = list_first(list);
+        while (link != NULL) {
                 if (cnt == n)
                         return link;
                 
                 cnt++;
+                link = list_next(link, list);
         }
         
         return NULL;
+}
+
+/** Verify that argument type is a pointer to link_t (at compile time).
+ *
+ * This can be used to check argument type in a macro.
+ */
+static inline const void *list_link_to_void(const link_t *link)
+{
+        return link;
 }
 

uspace/lib/c/include/async.h

@@ -399 +399 @@
 extern int async_data_read_start(async_exch_t *, void *, size_t);
 extern bool async_data_read_receive(ipc_callid_t *, size_t *);
+extern bool async_data_read_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
 extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
 
@@ -437 +438 @@
 extern int async_data_write_start(async_exch_t *, const void *, size_t);
 extern bool async_data_write_receive(ipc_callid_t *, size_t *);
+extern bool async_data_write_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
 extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
 

uspace/lib/c/include/cfg.h

@@ -80 +80 @@
 
 #define cfg_file_foreach(file, cur) \
-        list_foreach((file)->sections, (cur))
+        list_foreach((file)->sections, link, const cfg_section_t, (cur))
 
 #define cfg_section_instance(cur) \
@@ -86 +86 @@
 
 #define cfg_section_foreach(section, cur) \
-        list_foreach((section)->entries, (cur))
+        list_foreach((section)->entries, link, const cfg_entry_t, (cur))
 
 #define cfg_entry_instance(cur) \

uspace/lib/c/include/ddi.h

@@ -42 +42 @@
 #include <task.h>
 
+#define DMAMEM_16MiB  ((uintptr_t) UINT64_C(0xffffffffff000000))
+#define DMAMEM_4GiB   ((uintptr_t) UINT64_C(0xffffffff00000000))
+
 extern int device_assign_devno(void);
 
-extern int physmem_map(void *, size_t, unsigned int, void **);
+extern int physmem_map(uintptr_t, size_t, unsigned int, void **);
 
-extern int dmamem_map(void *, size_t, unsigned int, unsigned int, void **);
-extern int dmamem_map_anonymous(size_t, unsigned int, unsigned int, void **,
-    void **);
+extern int dmamem_map(void *, size_t, unsigned int, unsigned int, uintptr_t *);
+extern int dmamem_map_anonymous(size_t, uintptr_t, unsigned int, unsigned int,
+    uintptr_t *, void **);
 extern int dmamem_unmap(void *, size_t);
 extern int dmamem_unmap_anonymous(void *);
@@ -69 +72 @@
 extern uint32_t pio_read_32(const ioport32_t *);
 
-static inline uint8_t pio_change_8(
-    ioport8_t *reg, uint8_t val, uint8_t mask, useconds_t delay)
+static inline uint8_t pio_change_8(ioport8_t *reg, uint8_t val, uint8_t mask,
+    useconds_t delay)
 {
         uint8_t v = pio_read_8(reg);
@@ -78 +81 @@
 }
 
-static inline uint16_t pio_change_16(
-    ioport16_t *reg, uint16_t val, uint16_t mask, useconds_t delay)
+static inline uint16_t pio_change_16(ioport16_t *reg, uint16_t val,
+    uint16_t mask, useconds_t delay)
 {
         uint16_t v = pio_read_16(reg);
@@ -87 +90 @@
 }
 
-static inline uint32_t pio_change_32(
-    ioport32_t *reg, uint32_t val, uint32_t mask, useconds_t delay)
+static inline uint32_t pio_change_32(ioport32_t *reg, uint32_t val,
+    uint32_t mask, useconds_t delay)
 {
         uint32_t v = pio_read_32(reg);

uspace/lib/c/include/device/hw_res.h

@@ -53 +53 @@
         HW_RES_ENABLE_INTERRUPT,
         HW_RES_DMA_CHANNEL_SETUP,
+        HW_RES_DMA_CHANNEL_REMAIN,
 } hw_res_method_t;
 
@@ -115 +116 @@
 
 extern int hw_res_dma_channel_setup(async_sess_t *, unsigned int, uint32_t,
-    uint16_t, uint8_t);
+    uint32_t, uint8_t);
+extern int hw_res_dma_channel_remain(async_sess_t *, unsigned);
 
 #endif

uspace/lib/c/include/device/hw_res_parsed.h

@@ -139 +139 @@
 }
 
-extern int hw_res_list_parse(hw_resource_list_t *, hw_res_list_parsed_t *, int);
+extern int hw_res_list_parse(const hw_resource_list_t *,
+    hw_res_list_parsed_t *, int);
 extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
 

uspace/lib/c/include/devman.h

@@ -61 +61 @@
     unsigned int);
 extern int devman_fun_get_child(devman_handle_t, devman_handle_t *);
+extern int devman_dev_get_parent(devman_handle_t, devman_handle_t *);
 extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **,
     size_t *);
+extern int devman_fun_get_match_id(devman_handle_t, size_t, char *, size_t,
+    unsigned int *);
 extern int devman_fun_get_name(devman_handle_t, char *, size_t);
 extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
@@ -71 +74 @@
 extern int devman_add_device_to_category(devman_handle_t, const char *);
 extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
+extern int devman_get_drivers(devman_handle_t **, size_t *);
+extern int devman_driver_get_devices(devman_handle_t, devman_handle_t **,
+    size_t *);
+extern int devman_driver_get_handle(const char *, devman_handle_t *);
+extern int devman_driver_get_match_id(devman_handle_t, size_t, char *, size_t,
+    unsigned int *);
+extern int devman_driver_get_name(devman_handle_t, char *, size_t);
+extern int devman_driver_get_state(devman_handle_t, driver_state_t *);
+extern int devman_driver_load(devman_handle_t);
 
 #endif

uspace/lib/c/include/inet/addr.h

@@ -73 +73 @@
 extern void addr128(const addr128_t, addr128_t);
 
+extern int addr48_compare(const addr48_t, const addr48_t);
 extern int addr128_compare(const addr128_t, const addr128_t);
+
+extern void addr48_solicited_node(const addr128_t, addr48_t);
 
 extern void host2addr128_t_be(const addr128_t, addr128_t);

uspace/lib/c/include/inet/dnsr.h

@@ -51 +51 @@
 
 extern int dnsr_init(void);
-extern int dnsr_name2host(const char *, dnsr_hostinfo_t **);
+extern int dnsr_name2host(const char *, dnsr_hostinfo_t **, uint16_t);
 extern void dnsr_hostinfo_destroy(dnsr_hostinfo_t *);
 extern int dnsr_get_srvaddr(inet_addr_t *);

uspace/lib/c/include/ipc/dev_iface.h

@@ -36 +36 @@
 typedef enum {
         HW_RES_DEV_IFACE = 0,
+        PIO_WINDOW_DEV_IFACE,
+
         /** Character device interface */
         CHAR_DEV_IFACE,
@@ -41 +43 @@
         /** Graphic device interface */
         GRAPH_DEV_IFACE,
+
+        /** Audio device mixer interface */
+        AUDIO_MIXER_IFACE,
+        /** Audio device pcm buffer interface */
+        AUDIO_PCM_BUFFER_IFACE,
         
         /** Network interface controller interface */
@@ -54 +61 @@
         /** Interface provided by USB HID devices. */
         USBHID_DEV_IFACE,
+
         /** Interface provided by Real Time Clock devices */
         CLOCK_DEV_IFACE,
+
         /** Interface provided by battery powered devices */
         BATTERY_DEV_IFACE,
+
         /** Interface provided by AHCI devices. */
         AHCI_DEV_IFACE,

uspace/lib/c/include/ipc/devman.h

@@ -42 +42 @@
 
 typedef sysarg_t devman_handle_t;
+
+typedef enum {
+        /** Driver has not been started. */
+        DRIVER_NOT_STARTED = 0,
+        
+        /**
+         * Driver has been started, but has not registered as running and ready
+         * to receive requests.
+         */
+        DRIVER_STARTING,
+        
+        /** Driver is running and prepared to serve incomming requests. */
+        DRIVER_RUNNING
+} driver_state_t;
 
 typedef enum {
@@ -155 +169 @@
         DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
         DEVMAN_DEV_GET_FUNCTIONS,
+        DEVMAN_DEV_GET_PARENT,
         DEVMAN_FUN_GET_CHILD,
+        DEVMAN_FUN_GET_MATCH_ID,
         DEVMAN_FUN_GET_NAME,
         DEVMAN_FUN_GET_DRIVER_NAME,
@@ -161 +177 @@
         DEVMAN_FUN_OFFLINE,
         DEVMAN_FUN_GET_PATH,
-        DEVMAN_FUN_SID_TO_HANDLE
+        DEVMAN_FUN_SID_TO_HANDLE,
+        DEVMAN_GET_DRIVERS,
+        DEVMAN_DRIVER_GET_DEVICES,
+        DEVMAN_DRIVER_GET_HANDLE,
+        DEVMAN_DRIVER_GET_MATCH_ID,
+        DEVMAN_DRIVER_GET_NAME,
+        DEVMAN_DRIVER_GET_STATE,
+        DEVMAN_DRIVER_LOAD
 } client_to_devman_t;
 

uspace/lib/c/include/ipc/services.h

@@ -53 +53 @@
 } services_t;
 
+#define SERVICE_NAME_CORECFG    "corecfg"
 #define SERVICE_NAME_DNSR       "net/dnsr"
 #define SERVICE_NAME_INET       "net/inet"

uspace/lib/c/include/ipc/vfs.h

@@ -82 +82 @@
         VFS_IN_WAIT_HANDLE,
         VFS_IN_MTAB_GET,
+        VFS_IN_STATFS
 } vfs_in_request_t;
 
@@ -98 +99 @@
         VFS_OUT_LOOKUP,
         VFS_OUT_DESTROY,
+        VFS_OUT_STATFS,
         VFS_OUT_LAST
 } vfs_out_request_t;

uspace/lib/c/include/macros.h

@@ -40 +40 @@
 #define abs(a)     ((a) >= 0 ? (a) : -(a))
 
+#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))
 
 #define KiB2SIZE(kb)  ((kb) << 10)

uspace/lib/c/include/vfs/vfs.h

@@ -44 +44 @@
 #include "vfs_mtab.h"
 
+
 enum vfs_change_state_type {
         VFS_PASS_HANDLE
 };
+
 
 extern char *absolutize(const char *, size_t *);
@@ -61 +63 @@
 extern async_exch_t *vfs_exchange_begin(void);
 extern void vfs_exchange_end(async_exch_t *);
-
 #endif