Changeset cb569e6 in mainline for uspace/lib

Timestamp:

2010-11-18T21:58:27Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

4e5c7ba

Parents:

69e0d6d (diff), 45f04f8 (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

Files:

• block/libblock.c (modified) (31 diffs)
• block/libblock.h (modified) (2 diffs)
• c/generic/adt/measured_strings.c (modified) (14 diffs)
• c/generic/devman.c (modified) (7 diffs)
• c/generic/devmap.c (modified) (8 diffs)
• c/generic/net/modules.c (modified) (5 diffs)
• c/generic/net/packet.c (modified) (4 diffs)
• c/generic/net/socket_client.c (modified) (14 diffs)
• c/generic/vfs/vfs.c (modified) (4 diffs)
• c/include/adt/generic_char_map.h (modified) (4 diffs)
• c/include/devman.h (modified) (1 diff)
• c/include/devmap.h (modified) (2 diffs)
• c/include/err.h (modified) (2 diffs)
• c/include/ipc/devman.h (modified) (1 diff)
• c/include/ipc/devmap.h (modified) (2 diffs)
• c/include/ipc/serial.h (deleted)
• c/include/stdio.h (modified) (1 diff)
• c/include/sys/stat.h (modified) (2 diffs)
• c/include/unistd.h (modified) (1 diff)
• c/include/vfs/vfs.h (modified) (1 diff)
• drv/generic/driver.c (modified) (3 diffs)
• drv/include/driver.h (modified) (1 diff)
• fs/libfs.c (modified) (18 diffs)
• fs/libfs.h (modified) (3 diffs)
• net/adt/module_map.c (modified) (3 diffs)
• net/generic/packet_remote.c (modified) (7 diffs)
• net/netif/netif_local.c (modified) (15 diffs)
• net/tl/socket_core.c (modified) (13 diffs)
• net/tl/tl_common.c (modified) (5 diffs)
• packet/generic/packet_server.c (modified) (3 diffs)

uspace/lib/block/libblock.c

@@ -75 +75 @@
 typedef struct {
         link_t link;
-        dev_handle_t dev_handle;
+        devmap_handle_t devmap_handle;
         int dev_phone;
         fibril_mutex_t comm_area_lock;
@@ -91 +91 @@
 static int get_num_blocks(int dev_phone, aoff64_t *nblocks);
 
-static devcon_t *devcon_search(dev_handle_t dev_handle)
+static devcon_t *devcon_search(devmap_handle_t devmap_handle)
 {
         link_t *cur;
@@ -98 +98 @@
         for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
                 devcon_t *devcon = list_get_instance(cur, devcon_t, link);
-                if (devcon->dev_handle == dev_handle) {
+                if (devcon->devmap_handle == devmap_handle) {
                         fibril_mutex_unlock(&dcl_lock);
                         return devcon;
@@ -107 +107 @@
 }
 
-static int devcon_add(dev_handle_t dev_handle, int dev_phone, size_t bsize,
+static int devcon_add(devmap_handle_t devmap_handle, int dev_phone, size_t bsize,
     void *comm_area, size_t comm_size)
 {
@@ -121 +121 @@
         
         link_initialize(&devcon->link);
-        devcon->dev_handle = dev_handle;
+        devcon->devmap_handle = devmap_handle;
         devcon->dev_phone = dev_phone;
         fibril_mutex_initialize(&devcon->comm_area_lock);
@@ -134 +134 @@
         for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
                 devcon_t *d = list_get_instance(cur, devcon_t, link);
-                if (d->dev_handle == dev_handle) {
+                if (d->devmap_handle == devmap_handle) {
                         fibril_mutex_unlock(&dcl_lock);
                         free(devcon);
@@ -152 +152 @@
 }
 
-int block_init(dev_handle_t dev_handle, size_t comm_size)
+int block_init(devmap_handle_t devmap_handle, size_t comm_size)
 {
         int rc;
@@ -165 +165 @@
         }
 
-        dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
+        dev_phone = devmap_device_connect(devmap_handle, IPC_FLAG_BLOCKING);
         if (dev_phone < 0) {
                 munmap(comm_area, comm_size);
@@ -185 +185 @@
         }
         
-        rc = devcon_add(dev_handle, dev_phone, bsize, comm_area, comm_size);
+        rc = devcon_add(devmap_handle, dev_phone, bsize, comm_area, comm_size);
         if (rc != EOK) {
                 munmap(comm_area, comm_size);
@@ -195 +195 @@
 }
 
-void block_fini(dev_handle_t dev_handle)
-{
-        devcon_t *devcon = devcon_search(dev_handle);
+void block_fini(devmap_handle_t devmap_handle)
+{
+        devcon_t *devcon = devcon_search(devmap_handle);
         assert(devcon);
         
         if (devcon->cache)
-                (void) block_cache_fini(dev_handle);
+                (void) block_cache_fini(devmap_handle);
 
         devcon_remove(devcon);
@@ -214 +214 @@
 }
 
-int block_bb_read(dev_handle_t dev_handle, aoff64_t ba)
+int block_bb_read(devmap_handle_t devmap_handle, aoff64_t ba)
 {
         void *bb_buf;
         int rc;
 
-        devcon_t *devcon = devcon_search(dev_handle);
+        devcon_t *devcon = devcon_search(devmap_handle);
         if (!devcon)
                 return ENOENT;
@@ -244 +244 @@
 }
 
-void *block_bb_get(dev_handle_t dev_handle)
-{
-        devcon_t *devcon = devcon_search(dev_handle);
+void *block_bb_get(devmap_handle_t devmap_handle)
+{
+        devcon_t *devcon = devcon_search(devmap_handle);
         assert(devcon);
         return devcon->bb_buf;
@@ -272 +272 @@
 };
 
-int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks,
+int block_cache_init(devmap_handle_t devmap_handle, size_t size, unsigned blocks,
     enum cache_mode mode)
 {
-        devcon_t *devcon = devcon_search(dev_handle);
+        devcon_t *devcon = devcon_search(devmap_handle);
         cache_t *cache;
         if (!devcon)
@@ -305 +305 @@
 }
 
-int block_cache_fini(dev_handle_t dev_handle)
-{
-        devcon_t *devcon = devcon_search(dev_handle);
+int block_cache_fini(devmap_handle_t devmap_handle)
+{
+        devcon_t *devcon = devcon_search(devmap_handle);
         cache_t *cache;
         int rc;
@@ -374 +374 @@
  * @param block                 Pointer to where the function will store the
  *                              block pointer on success.
- * @param dev_handle            Device handle of the block device.
+ * @param devmap_handle         Device handle of the block device.
  * @param boff                  Block offset.
  * @param flags                 If BLOCK_FLAGS_NOREAD is specified, block_get()
@@ -382 +382 @@
  * @return                      EOK on success or a negative error code.
  */
-int block_get(block_t **block, dev_handle_t dev_handle, aoff64_t boff, int flags)
+int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t boff, int flags)
 {
         devcon_t *devcon;
@@ -391 +391 @@
         int rc;
         
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
 
         assert(devcon);
@@ -500 +500 @@
 
                 block_initialize(b);
-                b->dev_handle = dev_handle;
+                b->devmap_handle = devmap_handle;
                 b->size = cache->lblock_size;
                 b->boff = boff;
@@ -549 +549 @@
 int block_put(block_t *block)
 {
-        devcon_t *devcon = devcon_search(block->dev_handle);
+        devcon_t *devcon = devcon_search(block->devmap_handle);
         cache_t *cache;
         unsigned blocks_cached;
@@ -645 +645 @@
 /** Read sequential data from a block device.
  *
- * @param dev_handle    Device handle of the block device.
+ * @param devmap_handle Device handle of the block device.
  * @param bufpos        Pointer to the first unread valid offset within the
  *                      communication buffer.
@@ -657 +657 @@
  * @return              EOK on success or a negative return code on failure.
  */
-int block_seqread(dev_handle_t dev_handle, size_t *bufpos, size_t *buflen,
+int block_seqread(devmap_handle_t devmap_handle, size_t *bufpos, size_t *buflen,
     aoff64_t *pos, void *dst, size_t size)
 {
@@ -665 +665 @@
         devcon_t *devcon;
 
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
         assert(devcon);
         block_size = devcon->pblock_size;
@@ -711 +711 @@
 /** Read blocks directly from device (bypass cache).
  *
- * @param dev_handle    Device handle of the block device.
+ * @param devmap_handle Device handle of the block device.
  * @param ba            Address of first block.
  * @param cnt           Number of blocks.
@@ -718 +718 @@
  * @return              EOK on success or negative error code on failure.
  */
-int block_read_direct(dev_handle_t dev_handle, aoff64_t ba, size_t cnt, void *buf)
+int block_read_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, void *buf)
 {
         devcon_t *devcon;
         int rc;
 
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
         assert(devcon);
         
@@ -739 +739 @@
 /** Write blocks directly to device (bypass cache).
  *
- * @param dev_handle    Device handle of the block device.
+ * @param devmap_handle Device handle of the block device.
  * @param ba            Address of first block.
  * @param cnt           Number of blocks.
@@ -746 +746 @@
  * @return              EOK on success or negative error code on failure.
  */
-int block_write_direct(dev_handle_t dev_handle, aoff64_t ba, size_t cnt,
+int block_write_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt,
     const void *data)
 {
@@ -752 +752 @@
         int rc;
 
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
         assert(devcon);
         
@@ -767 +767 @@
 /** Get device block size.
  *
- * @param dev_handle    Device handle of the block device.
+ * @param devmap_handle Device handle of the block device.
  * @param bsize         Output block size.
  *
  * @return              EOK on success or negative error code on failure.
  */
-int block_get_bsize(dev_handle_t dev_handle, size_t *bsize)
+int block_get_bsize(devmap_handle_t devmap_handle, size_t *bsize)
 {
         devcon_t *devcon;
 
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
         assert(devcon);
         
@@ -784 +784 @@
 /** Get number of blocks on device.
  *
- * @param dev_handle    Device handle of the block device.
+ * @param devmap_handle Device handle of the block device.
  * @param nblocks       Output number of blocks.
  *
  * @return              EOK on success or negative error code on failure.
  */
-int block_get_nblocks(dev_handle_t dev_handle, aoff64_t *nblocks)
+int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks)
 {
         devcon_t *devcon;
 
-        devcon = devcon_search(dev_handle);
+        devcon = devcon_search(devmap_handle);
         assert(devcon);
         
@@ -818 +818 @@
                 printf("Error %d reading %d blocks starting at block %" PRIuOFF64
                     " from device handle %d\n", rc, cnt, ba,
-                    devcon->dev_handle);
+                    devcon->devmap_handle);
 #ifndef NDEBUG
                 stacktrace_print();
@@ -844 +844 @@
         if (rc != EOK) {
                 printf("Error %d writing %d blocks starting at block %" PRIuOFF64
-                    " to device handle %d\n", rc, cnt, ba, devcon->dev_handle);
+                    " to device handle %d\n", rc, cnt, ba, devcon->devmap_handle);
 #ifndef NDEBUG
                 stacktrace_print();

uspace/lib/block/libblock.h

@@ -72 +72 @@
         fibril_rwlock_t contents_lock;
         /** Handle of the device where the block resides. */
-        dev_handle_t dev_handle;
+        devmap_handle_t devmap_handle;
         /** Block offset on the block device. Counted in 'size'-byte blocks. */
         aoff64_t boff;
@@ -93 +93 @@
 };
 
-extern int block_init(dev_handle_t, size_t);
-extern void block_fini(dev_handle_t);
+extern int block_init(devmap_handle_t, size_t);
+extern void block_fini(devmap_handle_t);
 
-extern int block_bb_read(dev_handle_t, aoff64_t);
-extern void *block_bb_get(dev_handle_t);
+extern int block_bb_read(devmap_handle_t, aoff64_t);
+extern void *block_bb_get(devmap_handle_t);
 
-extern int block_cache_init(dev_handle_t, size_t, unsigned, enum cache_mode);
-extern int block_cache_fini(dev_handle_t);
+extern int block_cache_init(devmap_handle_t, size_t, unsigned, enum cache_mode);
+extern int block_cache_fini(devmap_handle_t);
 
-extern int block_get(block_t **, dev_handle_t, aoff64_t, int);
+extern int block_get(block_t **, devmap_handle_t, aoff64_t, int);
 extern int block_put(block_t *);
 
-extern int block_seqread(dev_handle_t, size_t *, size_t *, aoff64_t *, void *,
+extern int block_seqread(devmap_handle_t, size_t *, size_t *, aoff64_t *, void *,
     size_t);
 
-extern int block_get_bsize(dev_handle_t, size_t *);
-extern int block_get_nblocks(dev_handle_t, aoff64_t *);
-extern int block_read_direct(dev_handle_t, aoff64_t, size_t, void *);
-extern int block_write_direct(dev_handle_t, aoff64_t, size_t, const void *);
+extern int block_get_bsize(devmap_handle_t, size_t *);
+extern int block_get_nblocks(devmap_handle_t, aoff64_t *);
+extern int block_read_direct(devmap_handle_t, aoff64_t, size_t, void *);
+extern int block_write_direct(devmap_handle_t, aoff64_t, size_t, const void *);
 
 #endif

uspace/lib/c/generic/adt/measured_strings.c

@@ -41 +41 @@
 #include <unistd.h>
 #include <errno.h>
-#include <err.h>
 #include <async.h>
 
@@ -135 +134 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
@@ -142 +139 @@
         char *next;
         ipc_callid_t callid;
+        int rc;
 
         if ((!strings) || (!data) || (count <= 0))
@@ -155 +153 @@
                 return EINVAL;
         }
-        if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
-            length))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_write_finalize(callid, lengths, length);
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -187 +185 @@
                                 return EINVAL;
                         }
-                        if (ERROR_OCCURRED(async_data_write_finalize(callid,
-                            next, lengths[index]))) {
+                        rc = async_data_write_finalize(callid, next,
+                            lengths[index]);
+                        if (rc != EOK) {
                                 free(*data);
                                 free(*strings);
                                 free(lengths);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         (*strings)[index].value = next;
@@ -251 +250 @@
 int measured_strings_reply(const measured_string_ref strings, size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
         size_t length;
         ipc_callid_t callid;
+        int rc;
 
         if ((!strings) || (count <= 0))
@@ -270 +268 @@
                 return EINVAL;
         }
-        if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_read_finalize(callid, lengths, length);
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
         free(lengths);
@@ -282 +281 @@
                                 return EINVAL;
                         }
-                        ERROR_PROPAGATE(async_data_read_finalize(callid,
-                            strings[index].value, strings[index].length));
+                        rc = async_data_read_finalize(callid,
+                            strings[index].value, strings[index].length);
+                        if (rc != EOK)
+                                return rc;
                 }
         }
@@ -313 +314 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
         char *next;
+        int rc;
 
         if ((phone < 0) || (!strings) || (!data) || (count <= 0))
@@ -326 +326 @@
                 return ENOMEM;
 
-        if (ERROR_OCCURRED(async_data_read_start(phone, lengths,
-            sizeof(size_t) * (count + 1)))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_read_start(phone, lengths,
+            sizeof(size_t) * (count + 1));
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -350 +351 @@
                 (*strings)[index].length = lengths[index];
                 if (lengths[index] > 0) {
-                        if (ERROR_OCCURRED(async_data_read_start(phone, next,
-                            lengths[index]))) {
+                        rc = async_data_read_start(phone, next, lengths[index]);
+                        if (rc != EOK) {
                                 free(lengths);
                                 free(data);
                                 free(strings);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         (*strings)[index].value = next;
@@ -387 +388 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
+        int rc;
 
         if ((phone < 0) || (!strings) || (count <= 0))
@@ -399 +399 @@
                 return ENOMEM;
 
-        if (ERROR_OCCURRED(async_data_write_start(phone, lengths,
-            sizeof(size_t) * (count + 1)))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_write_start(phone, lengths,
+            sizeof(size_t) * (count + 1));
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -409 +410 @@
         for (index = 0; index < count; index++) {
                 if (strings[index].length > 0) {
-                        ERROR_PROPAGATE(async_data_write_start(phone,
-                            strings[index].value, strings[index].length));
+                        rc = async_data_write_start(phone, strings[index].value,
+                            strings[index].length);
+                        if (rc != EOK)
+                                return rc;
                 }
         }

uspace/lib/c/generic/devman.c

@@ -141 +141 @@
 
 int devman_child_device_register(
-        const char *name, match_id_list_t *match_ids, device_handle_t parent_handle, device_handle_t *handle)
+        const char *name, match_id_list_t *match_ids, devman_handle_t parent_handle, devman_handle_t *handle)
 {               
         int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
@@ -180 +180 @@
 }
 
-int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name)
+int devman_add_device_to_class(devman_handle_t devman_handle, const char *class_name)
 {
         int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
@@ -189 +189 @@
         async_serialize_start();
         ipc_call_t answer;
-        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, dev_handle, &answer);
+        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
         
         ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
@@ -224 +224 @@
 }
 
-int devman_device_connect(device_handle_t handle, unsigned int flags)
+int devman_device_connect(devman_handle_t handle, unsigned int flags)
 {
         int phone;
@@ -239 +239 @@
 }
 
-int devman_parent_device_connect(device_handle_t handle, unsigned int flags)
+int devman_parent_device_connect(devman_handle_t handle, unsigned int flags)
 {
         int phone;
@@ -254 +254 @@
 }
 
-int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags)
+int devman_device_get_handle(const char *pathname, devman_handle_t *handle, unsigned int flags)
 {
         int phone = devman_get_phone(DEVMAN_CLIENT, flags);
@@ -280 +280 @@
         if (retval != EOK) {
                 if (handle != NULL)
-                        *handle = (device_handle_t) -1;
+                        *handle = (devman_handle_t) -1;
                 return retval;
         }
         
         if (handle != NULL)
-                *handle = (device_handle_t) IPC_GET_ARG1(answer);
+                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
         
         return retval;

uspace/lib/c/generic/devmap.c

@@ -132 +132 @@
  *
  */
-int devmap_device_register(const char *fqdn, dev_handle_t *handle)
+int devmap_device_register(const char *fqdn, devmap_handle_t *handle)
 {
         int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
@@ -163 +163 @@
         
         if (handle != NULL)
-                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
         
         return retval;
 }
 
-int devmap_device_get_handle(const char *fqdn, dev_handle_t *handle, unsigned int flags)
+int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
@@ -194 +194 @@
         if (retval != EOK) {
                 if (handle != NULL)
-                        *handle = (dev_handle_t) -1;
+                        *handle = (devmap_handle_t) -1;
                 return retval;
         }
         
         if (handle != NULL)
-                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
         
         return retval;
 }
 
-int devmap_namespace_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
+int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, unsigned int flags)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
@@ -230 +230 @@
         if (retval != EOK) {
                 if (handle != NULL)
-                        *handle = (dev_handle_t) -1;
+                        *handle = (devmap_handle_t) -1;
                 return retval;
         }
         
         if (handle != NULL)
-                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
         
         return retval;
 }
 
-devmap_handle_type_t devmap_handle_probe(dev_handle_t handle)
+devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
@@ -255 +255 @@
 }
 
-int devmap_device_connect(dev_handle_t handle, unsigned int flags)
+int devmap_device_connect(devmap_handle_t handle, unsigned int flags)
 {
         int phone;
@@ -305 +305 @@
 }
 
-static size_t devmap_count_devices_internal(int phone, dev_handle_t ns_handle)
+static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle)
 {
         ipcarg_t count;
@@ -325 +325 @@
 }
 
-size_t devmap_count_devices(dev_handle_t ns_handle)
+size_t devmap_count_devices(devmap_handle_t ns_handle)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
@@ -387 +387 @@
 }
 
-size_t devmap_get_devices(dev_handle_t ns_handle, dev_desc_t **data)
+size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);

uspace/lib/c/generic/net/modules.c

@@ -41 +41 @@
 #include <async.h>
 #include <malloc.h>
-#include <err.h>
+#include <errno.h>
 #include <sys/time.h>
 
@@ -137 +137 @@
     ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
 {
-        ERROR_DECLARE;
+        int rc;
         
         /* Connect to the needed service */
@@ -144 +144 @@
                 /* Request the bidirectional connection */
                 ipcarg_t phonehash;
-                if (ERROR_OCCURRED(ipc_connect_to_me(phone, arg1, arg2, arg3,
-                    &phonehash))) {
+                
+                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
+                if (rc != EOK) {
                         ipc_hangup(phone);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 async_new_connection(phonehash, 0, NULL, client_receiver);
@@ -212 +213 @@
 int data_receive(void **data, size_t *length)
 {
-        ERROR_DECLARE;
-
         ipc_callid_t callid;
+        int rc;
 
         if (!data || !length)
@@ -229 +229 @@
 
         // fetch the data
-        if (ERROR_OCCURRED(async_data_write_finalize(callid, *data, *length))) {
+        rc = async_data_write_finalize(callid, *data, *length);
+        if (rc != EOK) {
                 free(data);
-                return ERROR_CODE;
+                return rc;
         }
 

uspace/lib/c/generic/net/packet.c

@@ -41 +41 @@
 #include <unistd.h>
 #include <errno.h>
-#include <err.h>
 
 #include <sys/mman.h>
@@ -91 +90 @@
 int pm_init(void)
 {
-        ERROR_DECLARE;
+        int rc;
 
         fibril_rwlock_initialize(&pm_globals.lock);
+        
         fibril_rwlock_write_lock(&pm_globals.lock);
-        ERROR_PROPAGATE(gpm_initialize(&pm_globals.packet_map));
+        rc = gpm_initialize(&pm_globals.packet_map);
         fibril_rwlock_write_unlock(&pm_globals.lock);
-        return EOK;
+        
+        return rc;
 }
 
@@ -139 +140 @@
 int pm_add(packet_t packet)
 {
-        ERROR_DECLARE;
-
         packet_map_ref map;
+        int rc;
 
         if (!packet_is_valid(packet))
@@ -160 +160 @@
                         }
                         bzero(map, sizeof(packet_map_t));
-                        if ((ERROR_CODE =
-                            gpm_add(&pm_globals.packet_map, map)) < 0) {
+                        rc = gpm_add(&pm_globals.packet_map, map);
+                        if (rc < 0) {
                                 fibril_rwlock_write_unlock(&pm_globals.lock);
                                 free(map);
-                                return ERROR_CODE;
+                                return rc;
                         }
                 } while (PACKET_MAP_PAGE(packet->packet_id) >=

uspace/lib/c/generic/net/socket_client.c

@@ -43 +43 @@
 #include <stdlib.h>
 #include <errno.h>
-#include <err.h>
 
 #include <ipc/services.h>
@@ -212 +211 @@
 static void socket_connection(ipc_callid_t iid, ipc_call_t * icall)
 {
-        ERROR_DECLARE;
-
         ipc_callid_t callid;
         ipc_call_t call;
         socket_ref socket;
+        int rc;
 
 loop:
@@ -231 +229 @@
                     SOCKET_GET_SOCKET_ID(call));
                 if (!socket) {
-                        ERROR_CODE = ENOTSOCK;
+                        rc = ENOTSOCK;
                         fibril_rwlock_read_unlock(&socket_globals.lock);
                         break;
@@ -240 +238 @@
                         fibril_mutex_lock(&socket->receive_lock);
                         // push the number of received packet fragments
-                        if (!ERROR_OCCURRED(dyn_fifo_push(&socket->received,
+                        rc = dyn_fifo_push(&socket->received,
                             SOCKET_GET_DATA_FRAGMENTS(call),
-                            SOCKET_MAX_RECEIVED_SIZE))) {
+                            SOCKET_MAX_RECEIVED_SIZE);
+                        if (rc == EOK) {
                                 // signal the received packet
                                 fibril_condvar_signal(&socket->receive_signal);
@@ -252 +251 @@
                         // push the new socket identifier
                         fibril_mutex_lock(&socket->accept_lock);
-                        if (!ERROR_OCCURRED(dyn_fifo_push(&socket->accepted,
-                            1, SOCKET_MAX_ACCEPTED_SIZE))) {
+                        rc = dyn_fifo_push(&socket->accepted, 1,
+                            SOCKET_MAX_ACCEPTED_SIZE);
+                        if (rc == EOK) {
                                 // signal the accepted socket
                                 fibril_condvar_signal(&socket->accept_signal);
@@ -261 +261 @@
 
                 default:
-                        ERROR_CODE = ENOTSUP;
+                        rc = ENOTSUP;
                 }
 
@@ -280 +280 @@
 
         default:
-                ERROR_CODE = ENOTSUP;
-        }
-
-        ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
+                rc = ENOTSUP;
+        }
+
+        ipc_answer_0(callid, (ipcarg_t) rc);
         goto loop;
 }
@@ -405 +405 @@
 int socket(int domain, int type, int protocol)
 {
-        ERROR_DECLARE;
-
         socket_ref socket;
         int phone;
@@ -413 +411 @@
         ipcarg_t fragment_size;
         ipcarg_t header_size;
+        int rc;
 
         // find the appropriate service
@@ -479 +478 @@
         }
 
-        if (ERROR_OCCURRED((int) async_req_3_3(phone, NET_SOCKET, socket_id, 0,
-            service, NULL, &fragment_size, &header_size))) {
+        rc = (int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
+            &fragment_size, &header_size);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&socket_globals.lock);
                 free(socket);
-                return ERROR_CODE;
+                return rc;
         }
 
@@ -492 +492 @@
         socket_initialize(socket, socket_id, phone, service);
         // store the new socket
-        ERROR_CODE = sockets_add(socket_get_sockets(), socket_id, socket);
+        rc = sockets_add(socket_get_sockets(), socket_id, socket);
 
         fibril_rwlock_write_unlock(&socket_globals.lock);
-        if (ERROR_CODE < 0) {
+        if (rc < 0) {
                 dyn_fifo_destroy(&socket->received);
                 dyn_fifo_destroy(&socket->accepted);
@@ -501 +501 @@
                 async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
                     service);
-                return ERROR_CODE;
+                return rc;
         }
 
@@ -770 +770 @@
 int closesocket(int socket_id)
 {
-        ERROR_DECLARE;
-
         socket_ref socket;
+        int rc;
 
         fibril_rwlock_write_lock(&socket_globals.lock);
@@ -787 +786 @@
 
         // request close
-        ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
-            (ipcarg_t) socket->socket_id, 0, socket->service));
+        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
+            (ipcarg_t) socket->socket_id, 0, socket->service);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&socket_globals.lock);
+                return rc;
+        }
         // free the socket structure
         socket_destroy(socket);

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

@@ -136 +136 @@
         }
         
-        dev_handle_t dev_handle;
-        int res = devmap_device_get_handle(fqdn, &dev_handle, flags);
+        devmap_handle_t devmap_handle;
+        int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
         if (res != EOK) {
                 if (null_id != -1)
@@ -159 +159 @@
         
         ipcarg_t rc_orig;
-        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
+        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
         ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
@@ -328 +328 @@
         ipc_call_t answer;
         aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
-            node->dev_handle, node->index, oflag, &answer);
+            node->devmap_handle, node->index, oflag, &answer);
         
         ipcarg_t rc;
@@ -797 +797 @@
         if (rc == EOK) {
                 node->fs_handle = stat.fs_handle;
-                node->dev_handle = stat.dev_handle;
+                node->devmap_handle = stat.devmap_handle;
                 node->index = stat.index;
         }

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

@@ -40 +40 @@
 #include <unistd.h>
 #include <errno.h>
-#include <err.h>
 
 #include <adt/char_map.h>
@@ -85 +84 @@
              type *value) \
         { \
-                ERROR_DECLARE; \
+                int rc; \
                 int index; \
                 if (!name##_is_valid(map)) \
@@ -92 +91 @@
                 if (index < 0) \
                         return index; \
-                if (ERROR_OCCURRED(char_map_add(&map->names, name, length, \
-                    index))) { \
+                rc = char_map_add(&map->names, name, length, index); \
+                if (rc != EOK) { \
                         name##_items_exclude_index(&map->values, index); \
-                        return ERROR_CODE; \
+                        return rc; \
                 } \
                 return EOK; \
@@ -141 +140 @@
         int name##_initialize(name##_ref map) \
         { \
-                ERROR_DECLARE; \
+                int rc; \
                 if (!map) \
                         return EINVAL; \
-                ERROR_PROPAGATE(char_map_initialize(&map->names)); \
-                if (ERROR_OCCURRED(name##_items_initialize(&map->values))) { \
+                rc = char_map_initialize(&map->names); \
+                if (rc != EOK) \
+                        return rc; \
+                rc = name##_items_initialize(&map->values); \
+                if (rc != EOK) { \
                         char_map_destroy(&map->names); \
-                        return ERROR_CODE; \
+                        return rc; \
                 } \
                 map->magic = GENERIC_CHAR_MAP_MAGIC_VALUE; \

uspace/lib/c/include/devman.h

@@ -42 +42 @@
 
 
-int devman_get_phone(devman_interface_t, unsigned int);
-void devman_hangup_phone(devman_interface_t iface);
+extern int devman_get_phone(devman_interface_t, unsigned int);
+extern void devman_hangup_phone(devman_interface_t);
 
-int devman_driver_register(const char *, async_client_conn_t);
-int devman_child_device_register(const char *, match_id_list_t *, device_handle_t, device_handle_t *);
+extern int devman_driver_register(const char *, async_client_conn_t);
+extern int devman_child_device_register(const char *, match_id_list_t *,
+    devman_handle_t, devman_handle_t *);
 
-int devman_device_connect(device_handle_t handle, unsigned int flags);
-int devman_parent_device_connect(device_handle_t handle, unsigned int flags);
+extern int devman_device_connect(devman_handle_t, unsigned int);
+extern int devman_parent_device_connect(devman_handle_t, unsigned int);
 
-int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags);
+extern int devman_device_get_handle(const char *, devman_handle_t *,
+    unsigned int);
 
-int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name);
+extern int devman_add_device_to_class(devman_handle_t, const char *);
 
 #endif

uspace/lib/c/include/devmap.h

@@ -44 +44 @@
 
 extern int devmap_driver_register(const char *, async_client_conn_t);
-extern int devmap_device_register(const char *, dev_handle_t *);
+extern int devmap_device_register(const char *, devmap_handle_t *);
 
-extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int);
-extern int devmap_namespace_get_handle(const char *, dev_handle_t *, unsigned int);
-extern devmap_handle_type_t devmap_handle_probe(dev_handle_t);
+extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int);
+extern int devmap_namespace_get_handle(const char *, devmap_handle_t *, unsigned int);
+extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t);
 
-extern int devmap_device_connect(dev_handle_t, unsigned int);
+extern int devmap_device_connect(devmap_handle_t, unsigned int);
 
 extern int devmap_null_create(void);
@@ -56 +56 @@
 
 extern size_t devmap_count_namespaces(void);
-extern size_t devmap_count_devices(dev_handle_t);
+extern size_t devmap_count_devices(devmap_handle_t);
 
 extern size_t devmap_get_namespaces(dev_desc_t **);
-extern size_t devmap_get_devices(dev_handle_t, dev_desc_t **);
+extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **);
 
 #endif

uspace/lib/c/include/err.h

@@ -37 +37 @@
 
 #include <stdio.h>
-#include <errno.h>
-
-#ifdef CONFIG_DEBUG
-#include <str_error.h>
-#endif
 
 #define errx(status, fmt, ...) { \
@@ -48 +43 @@
 }
 
-
-/** An actual stored error code.  */
-#define ERROR_CODE  error_check_return_value
-
-/** An error processing routines declaration.
- *
- * This has to be declared in the block where the error processing
- * is desired.
- */
-#define ERROR_DECLARE  int ERROR_CODE
-
-/** Store the value as an error code and checks if an error occurred.
- *
- * @param[in] value     The value to be checked. May be a function call.
- * @return              False if the value indicates success (EOK).
- * @return              True otherwise.
- */
-#ifdef CONFIG_DEBUG
-
-#define ERROR_OCCURRED(value) \
-        (((ERROR_CODE = (value)) != EOK) && \
-        ({ \
-                fprintf(stderr, "libsocket error at %s:%d (%s)\n", \
-                __FILE__, __LINE__, str_error(ERROR_CODE)); \
-                1; \
-        }))
-
-#else
-
-#define ERROR_OCCURRED(value)   ((ERROR_CODE = (value)) != EOK)
-
-#endif
-
-#define ERROR_NONE(value)       !ERROR_OCCURRED((value))
-
-/** Error propagation
- *
- * Check if an error occurred and immediately exit the actual
- * function returning the error code.
- *
- * @param[in] value     The value to be checked. May be a function call.
- *
- */
-
-#define ERROR_PROPAGATE(value) \
-        if (ERROR_OCCURRED(value)) \
-                return ERROR_CODE
-
 #endif
 
 /** @}
  */
+

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

@@ -42 +42 @@
 #define DEVMAN_NAME_MAXLEN 256
 
-typedef ipcarg_t device_handle_t;
+typedef ipcarg_t devman_handle_t;
 
 /** Ids of device models used for device-to-driver matching.

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

@@ -40 +40 @@
 #define DEVMAP_NAME_MAXLEN  255
 
-typedef ipcarg_t dev_handle_t;
+typedef ipcarg_t devmap_handle_t;
 
 typedef enum {
@@ -81 +81 @@
 
 typedef struct {
-        dev_handle_t handle;
+        devmap_handle_t handle;
         char name[DEVMAP_NAME_MAXLEN + 1];
 } dev_desc_t;

uspace/lib/c/include/stdio.h

@@ -46 +46 @@
 #define BUFSIZ  4096
 
-#define DEBUG(fmt, ...)se\
+#define DEBUG(fmt, ...) \
         { \
                 char _buf[256]; \

uspace/lib/c/include/sys/stat.h

@@ -43 +43 @@
 struct stat {
         fs_handle_t fs_handle;
-        dev_handle_t dev_handle;
+        devmap_handle_t devmap_handle;
         fs_index_t index;
         unsigned int lnkcnt;
@@ -49 +49 @@
         bool is_directory;
         aoff64_t size;
-        dev_handle_t device;
+        devmap_handle_t device;
 };
 

uspace/lib/c/include/unistd.h

@@ -41 +41 @@
 
 #ifndef NULL
-        #define NULL  0
+        #define NULL  0UL
 #endif
 

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

@@ -47 +47 @@
 typedef struct {
         fs_handle_t fs_handle;
-        dev_handle_t dev_handle;
+        devmap_handle_t devmap_handle;
         fs_index_t index;
 } fdi_node_t;

uspace/lib/drv/generic/driver.c

@@ -139 +139 @@
 }
 
-static device_t * driver_get_device(link_t *devices, device_handle_t handle)
+static device_t * driver_get_device(link_t *devices, devman_handle_t handle)
 {
         device_t *dev = NULL;
@@ -163 +163 @@
         int res = EOK;
         
-        device_handle_t dev_handle =  IPC_GET_ARG1(*icall);
+        devman_handle_t dev_handle =  IPC_GET_ARG1(*icall);
         device_t *dev = create_device();
         dev->handle = dev_handle;
@@ -221 +221 @@
          * the device to which the client connected.
          */
-        device_handle_t handle = IPC_GET_ARG2(*icall);
+        devman_handle_t handle = IPC_GET_ARG2(*icall);
         device_t *dev = driver_get_device(&devices, handle);
 

uspace/lib/drv/include/driver.h

@@ -118 +118 @@
          * device manager).
          */
-        device_handle_t handle;
+        devman_handle_t handle;
         
         /**

uspace/lib/fs/libfs.c

@@ -150 +150 @@
     ipc_call_t *request)
 {
-        dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
         fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
-        dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
+        devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request);
         int res;
         ipcarg_t rc;
@@ -174 +174 @@
         
         fs_node_t *fn;
-        res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
+        res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
         if ((res != EOK) || (!fn)) {
                 ipc_hangup(mountee_phone);
@@ -201 +201 @@
         ipc_call_t answer;
         rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED,
-            mr_dev_handle, &answer);
+            mr_devmap_handle, &answer);
         
         if (rc == EOK) {
                 fn->mp_data.mp_active = true;
                 fn->mp_data.fs_handle = mr_fs_handle;
-                fn->mp_data.dev_handle = mr_dev_handle;
+                fn->mp_data.devmap_handle = mr_devmap_handle;
                 fn->mp_data.phone = mountee_phone;
         }
@@ -219 +219 @@
 void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
         fs_node_t *fn;
         int res;
 
-        res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
+        res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index);
         if ((res != EOK) || (!fn)) {
                 ipc_answer_0(rid, combine_rc(res, ENOENT));
@@ -243 +243 @@
          */
         res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED,
-            fn->mp_data.dev_handle);
+            fn->mp_data.devmap_handle);
 
         /*
@@ -252 +252 @@
                 fn->mp_data.mp_active = false;
                 fn->mp_data.fs_handle = 0;
-                fn->mp_data.dev_handle = 0;
+                fn->mp_data.devmap_handle = 0;
                 fn->mp_data.phone = 0;
                 /* Drop the reference created in libfs_mount(). */
@@ -281 +281 @@
         unsigned int last = IPC_GET_ARG2(*request);
         unsigned int next = first;
-        dev_handle_t dev_handle = IPC_GET_ARG3(*request);
+        devmap_handle_t devmap_handle = IPC_GET_ARG3(*request);
         int lflag = IPC_GET_ARG4(*request);
         fs_index_t index = IPC_GET_ARG5(*request);
@@ -295 +295 @@
         fs_node_t *tmp = NULL;
         
-        rc = ops->root_get(&cur, dev_handle);
+        rc = ops->root_get(&cur, devmap_handle);
         on_error(rc, goto out_with_answer);
         
         if (cur->mp_data.mp_active) {
                 ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
-                    next, last, cur->mp_data.dev_handle, lflag, index,
+                    next, last, cur->mp_data.devmap_handle, lflag, index,
                     IPC_FF_ROUTE_FROM_ME);
                 (void) ops->node_put(cur);
@@ -358 +358 @@
                         
                         ipc_forward_slow(rid, tmp->mp_data.phone,
-                            VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
+                            VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle,
                             lflag, index, IPC_FF_ROUTE_FROM_ME);
                         (void) ops->node_put(cur);
@@ -385 +385 @@
                                 fs_node_t *fn;
                                 if (lflag & L_CREATE)
-                                        rc = ops->create(&fn, dev_handle,
+                                        rc = ops->create(&fn, devmap_handle,
                                             lflag);
                                 else
-                                        rc = ops->node_get(&fn, dev_handle,
+                                        rc = ops->node_get(&fn, devmap_handle,
                                             index);
                                 on_error(rc, goto out_with_answer);
@@ -401 +401 @@
                                                 aoff64_t size = ops->size_get(fn);
                                                 ipc_answer_5(rid, fs_handle,
-                                                    dev_handle,
+                                                    devmap_handle,
                                                     ops->index_get(fn),
                                                     LOWER32(size),
@@ -469 +469 @@
                         fs_node_t *fn;
                         if (lflag & L_CREATE)
-                                rc = ops->create(&fn, dev_handle, lflag);
+                                rc = ops->create(&fn, devmap_handle, lflag);
                         else
-                                rc = ops->node_get(&fn, dev_handle, index);
+                                rc = ops->node_get(&fn, devmap_handle, index);
                         on_error(rc, goto out_with_answer);
                         
@@ -483 +483 @@
                                         aoff64_t size = ops->size_get(fn);
                                         ipc_answer_5(rid, fs_handle,
-                                            dev_handle,
+                                            devmap_handle,
                                             ops->index_get(fn),
                                             LOWER32(size),
@@ -509 +509 @@
                 if (rc == EOK) {
                         aoff64_t size = ops->size_get(cur);
-                        ipc_answer_5(rid, fs_handle, dev_handle,
+                        ipc_answer_5(rid, fs_handle, devmap_handle,
                             ops->index_get(cur), LOWER32(size), UPPER32(size),
                             old_lnkcnt);
@@ -547 +547 @@
                 if (rc == EOK) {
                         aoff64_t size = ops->size_get(cur);
-                        ipc_answer_5(rid, fs_handle, dev_handle,
+                        ipc_answer_5(rid, fs_handle, devmap_handle,
                             ops->index_get(cur), LOWER32(size), UPPER32(size),
                             ops->lnkcnt_get(cur));
@@ -571 +571 @@
     ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         
         fs_node_t *fn;
-        int rc = ops->node_get(&fn, dev_handle, index);
+        int rc = ops->node_get(&fn, devmap_handle, index);
         on_error(rc, answer_and_return(rid, rc));
         
@@ -592 +592 @@
         
         stat.fs_handle = fs_handle;
-        stat.dev_handle = dev_handle;
+        stat.devmap_handle = devmap_handle;
         stat.index = index;
         stat.lnkcnt = ops->lnkcnt_get(fn);
@@ -617 +617 @@
     ipc_call_t *request)
 {
-        dev_handle_t dev_handle = IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = IPC_GET_ARG1(*request);
         fs_index_t index = IPC_GET_ARG2(*request);
         
         fs_node_t *fn;
-        int rc = ops->node_get(&fn, dev_handle, index);
+        int rc = ops->node_get(&fn, devmap_handle, index);
         on_error(rc, answer_and_return(rid, rc));
         

uspace/lib/fs/libfs.h

@@ -47 +47 @@
         int phone;
         fs_handle_t fs_handle;
-        dev_handle_t dev_handle;
+        devmap_handle_t devmap_handle;
 } mp_data_t;
 
@@ -61 +61 @@
          * argument holds the output argument.
          */
-        int (* root_get)(fs_node_t **, dev_handle_t);
+        int (* root_get)(fs_node_t **, devmap_handle_t);
         int (* match)(fs_node_t **, fs_node_t *, const char *);
-        int (* node_get)(fs_node_t **, dev_handle_t, fs_index_t);
+        int (* node_get)(fs_node_t **, devmap_handle_t, fs_index_t);
         int (* node_open)(fs_node_t *);
         int (* node_put)(fs_node_t *);
-        int (* create)(fs_node_t **, dev_handle_t, int);
+        int (* create)(fs_node_t **, devmap_handle_t, int);
         int (* destroy)(fs_node_t *);
         int (* link)(fs_node_t *, fs_node_t *, const char *);
@@ -81 +81 @@
         bool (* is_directory)(fs_node_t *);
         bool (* is_file)(fs_node_t *);
-        dev_handle_t (* device_get)(fs_node_t *);
+        devmap_handle_t (* device_get)(fs_node_t *);
 } libfs_ops_t;
 

uspace/lib/net/adt/module_map.c

@@ -38 +38 @@
 #include <task.h>
 #include <unistd.h>
-#include <err.h>
+#include <errno.h>
 
 #include <ipc/services.h>
@@ -67 +67 @@
     connect_module_t connect_module)
 {
-        ERROR_DECLARE;
-
         module_ref tmp_module;
+        int rc;
 
         tmp_module = (module_ref) malloc(sizeof(module_t));
@@ -83 +82 @@
         tmp_module->connect_module = connect_module;
 
-        if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
-            tmp_module))) {
+        rc = modules_add(modules, tmp_module->name, 0, tmp_module);
+        if (rc != EOK) {
                 free(tmp_module);
-                return ERROR_CODE;
+                return rc;
         }
         if (module)

uspace/lib/net/generic/packet_remote.c

@@ -38 +38 @@
 #include <async.h>
 #include <errno.h>
-#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/packet.h>
@@ -67 +66 @@
 packet_return(int phone, packet_ref packet, packet_id_t packet_id, size_t size)
 {
-        ERROR_DECLARE;
-        
         ipc_call_t answer;
-        aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
+        aid_t message;
+        int rc;
+        
+        message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
 
         *packet = (packet_t) as_get_mappable_page(size);
-        if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
-            ERROR_OCCURRED(pm_add(*packet))) {
+        rc = async_share_in_start_0_0(phone, *packet, size);
+        if (rc != EOK) {
                 munmap(*packet, size);
                 async_wait_for(message, NULL);
-                return ERROR_CODE;
+                return rc;
+        }
+        rc = pm_add(*packet);
+        if (rc != EOK) {
+                munmap(*packet, size);
+                async_wait_for(message, NULL);
+                return rc;
         }
         
@@ -103 +109 @@
 int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!packet)
@@ -112 +118 @@
                 ipcarg_t size;
                 
-                ERROR_PROPAGATE(async_req_1_1(phone, NET_PACKET_GET_SIZE,
-                    packet_id, &size));
-                ERROR_PROPAGATE(packet_return(phone, packet, packet_id, size));
+                rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
+                    &size);
+                if (rc != EOK)
+                        return rc;
+                rc = packet_return(phone, packet, packet_id, size);
+                if (rc != EOK)
+                        return rc;
         }
         if ((*packet)->next) {
@@ -141 +151 @@
     size_t max_prefix, size_t max_suffix)
 {
-        ERROR_DECLARE;
-        
         ipcarg_t packet_id;
         ipcarg_t size;
-        
-        if (ERROR_OCCURRED(async_req_4_2(phone, NET_PACKET_CREATE_4,
-            max_content, addr_len, max_prefix, max_suffix, &packet_id, &size)))
+        int rc;
+        
+        rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
+            max_prefix, max_suffix, &packet_id, &size);
+        if (rc != EOK)
                 return NULL;
         
@@ -153 +163 @@
         packet_t packet = pm_find(packet_id);
         if (!packet) {
-                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
-                    size)))
+                rc = packet_return(phone, &packet, packet_id, size);
+                if (rc != EOK)
                         return NULL;
         }
@@ -172 +182 @@
 packet_t packet_get_1_remote(int phone, size_t content)
 {
-        ERROR_DECLARE;
-        
         ipcarg_t packet_id;
         ipcarg_t size;
-        
-        if (ERROR_OCCURRED(async_req_1_2(phone, NET_PACKET_CREATE_1, content,
-            &packet_id, &size)))
+        int rc;
+        
+        rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
+            &size);
+        if (rc != EOK)
                 return NULL;
         
         packet_t packet = pm_find(packet_id);
         if (!packet) {
-                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
-                    size)))
+                rc = packet_return(phone, &packet, packet_id, size);
+                if (rc != EOK)
                         return NULL;
         }

uspace/lib/net/netif/netif_local.c

@@ -43 +43 @@
 #include <ipc/services.h>
 #include <ipc/netif.h>
-#include <err.h>
+#include <errno.h>
 
 #include <generic.h>
@@ -113 +113 @@
 int netif_start_req_local(int netif_phone, device_id_t device_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         fibril_rwlock_write_lock(&netif_globals.lock);
         
         netif_device_t *device;
-        if (ERROR_OCCURRED(find_device(device_id, &device))) {
+        rc = find_device(device_id, &device);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -148 +149 @@
 int netif_stop_req_local(int netif_phone, device_id_t device_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         fibril_rwlock_write_lock(&netif_globals.lock);
         
         netif_device_t *device;
-        if (ERROR_OCCURRED(find_device(device_id, &device))) {
+        rc = find_device(device_id, &device);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -203 +205 @@
     measured_string_ref *address, char **data)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!address || !data)
@@ -211 +213 @@
         
         measured_string_t translation;
-        if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) {
+        rc = netif_get_addr_message(device_id, &translation);
+        if (rc == EOK) {
                 *address = measured_string_copy(&translation);
-                ERROR_CODE = (*address) ? EOK : ENOMEM;
+                rc = (*address) ? EOK : ENOMEM;
         }
         
@@ -220 +223 @@
         *data = (**address).value;
         
-        return ERROR_CODE;
+        return rc;
 }
 
@@ -264 +267 @@
 int netif_init_module(async_client_conn_t client_connection)
 {
-        ERROR_DECLARE;
+        int rc;
         
         async_set_client_connection(client_connection);
@@ -271 +274 @@
         netif_device_map_initialize(&netif_globals.device_map);
         
-        ERROR_PROPAGATE(pm_init());
+        rc = pm_init();
+        if (rc != EOK)
+                return rc;
         
         fibril_rwlock_initialize(&netif_globals.lock);
-        if (ERROR_OCCURRED(netif_initialize())) {
+        
+        rc = netif_initialize();
+        if (rc != EOK) {
                 pm_destroy();
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -317 +324 @@
 static int register_message(const char *name, device_id_t device_id, int phone)
 {
-        ERROR_DECLARE;
-        
         netif_device_t *device;
-        ERROR_PROPAGATE(find_device(device_id, &device));
-        if(device->nil_phone > 0)
+        int rc;
+        
+        rc = find_device(device_id, &device);
+        if (rc != EOK)
+                return rc;
+        
+        if (device->nil_phone > 0)
                 return ELIMIT;
         
@@ -349 +359 @@
     ipc_call_t *call, ipc_call_t *answer, int *answer_count)
 {
-        ERROR_DECLARE;
-        
         size_t length;
         device_stats_t stats;
         packet_t packet;
         measured_string_t address;
+        int rc;
         
         *answer_count = 0;
@@ -367 +376 @@
         case IPC_M_CONNECT_TO_ME:
                 fibril_rwlock_write_lock(&netif_globals.lock);
-                ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
+                rc = register_message(name, IPC_GET_DEVICE(call),
                     IPC_GET_PHONE(call));
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
                 
         case NET_NETIF_SEND:
-                ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call)));
+                rc = packet_translate_remote(netif_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                if (rc != EOK)
+                        return rc;
                 return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
                     IPC_GET_SENDER(call));
-                    
+                
         case NET_NETIF_START:
                 return netif_start_req_local(0, IPC_GET_DEVICE(call));
@@ -384 +395 @@
                 fibril_rwlock_read_lock(&netif_globals.lock);
 
-                if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
+                rc = async_data_read_receive(&callid, &length);
+                if (rc != EOK) {
                         fibril_rwlock_read_unlock(&netif_globals.lock);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 if (length < sizeof(device_stats_t)) {
@@ -393 +405 @@
                 }
 
-                if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
-                    &stats))) {
-                        ERROR_CODE = async_data_read_finalize(callid, &stats,
+                rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats);
+                if (rc == EOK) {
+                        rc = async_data_read_finalize(callid, &stats,
                             sizeof(device_stats_t));
                 }
 
                 fibril_rwlock_read_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
 
         case NET_NETIF_STOP:
@@ -407 +419 @@
         case NET_NETIF_GET_ADDR:
                 fibril_rwlock_read_lock(&netif_globals.lock);
-                if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
-                    &address)))
-                        ERROR_CODE = measured_strings_reply(&address, 1);
+                rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address);
+                if (rc == EOK)
+                        rc = measured_strings_reply(&address, 1);
                 fibril_rwlock_read_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -431 +443 @@
 int netif_module_start_standalone(async_client_conn_t client_connection)
 {
-        ERROR_DECLARE;
-        
-        ERROR_PROPAGATE(netif_init_module(client_connection));
+        int rc;
+        
+        rc = netif_init_module(client_connection);
+        if (rc != EOK)
+                return rc;
         
         async_manager();

uspace/lib/net/tl/socket_core.c

@@ -48 +48 @@
 #include <stdlib.h>
 #include <errno.h>
-#include <err.h>
 
 #include <adt/dynamic_fifo.h>
@@ -164 +163 @@
     const char *key, size_t key_length)
 {
-        ERROR_DECLARE;
-
         socket_core_ref *socket_ref;
+        int rc;
 
         // create a wrapper
@@ -175 +173 @@
         *socket_ref = socket;
         // add the wrapper
-        if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
-            key_length, socket_ref))) {
+        rc = socket_port_map_add(&socket_port->map, key, key_length,
+            socket_ref);
+        if (rc != EOK) {
                 free(socket_ref);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -204 +203 @@
     int port)
 {
-        ERROR_DECLARE;
-
         socket_port_ref socket_port;
+        int rc;
 
         // create a wrapper
@@ -214 +212 @@
 
         socket_port->count = 0;
-        if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
-            ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
-            SOCKET_MAP_KEY_LISTENING, 0))) {
-                socket_port_map_destroy(&socket_port->map);
-                free(socket_port);
-                return ERROR_CODE;
-        }
+        rc = socket_port_map_initialize(&socket_port->map);
+        if (rc != EOK)
+                goto fail;
+        
+        rc = socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING,
+            0);
+        if (rc != EOK)
+                goto fail;
         
         // register the incomming port
-        ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
-        if (ERROR_CODE < 0) {
-                socket_port_map_destroy(&socket_port->map);
-                free(socket_port);
-                return ERROR_CODE;
-        }
+        rc = socket_ports_add(global_sockets, port, socket_port);
+        if (rc < 0)
+                goto fail;
         
         socket->port = port;
         return EOK;
+
+fail:
+        socket_port_map_destroy(&socket_port->map);
+        free(socket_port);
+        return rc;
+        
 }
 
@@ -416 +418 @@
     void *specific_data, int *socket_id)
 {
-        ERROR_DECLARE;
-
         socket_core_ref socket;
-        int res;
         int positive;
+        int rc;
 
         if (!socket_id)
@@ -447 +447 @@
         socket->key_length = 0;
         socket->specific_data = specific_data;
-        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
-            SOCKET_INITIAL_RECEIVED_SIZE))) {
+        rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
+        if (rc != EOK) {
                 free(socket);
-                return ERROR_CODE;
-        }
-        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
-            SOCKET_INITIAL_ACCEPTED_SIZE))) {
+                return rc;
+        }
+        
+        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
+        if (rc != EOK) {
                 dyn_fifo_destroy(&socket->received);
                 free(socket);
-                return ERROR_CODE;
+                return rc;
         }
         socket->socket_id = *socket_id;
-        res = socket_cores_add(local_sockets, socket->socket_id, socket);
-        if (res < 0) {
+        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
+        if (rc < 0) {
                 dyn_fifo_destroy(&socket->received);
                 dyn_fifo_destroy(&socket->accepted);
                 free(socket);
-                return res;
+                return rc;
         }
         
@@ -523 +524 @@
 int socket_reply_packets(packet_t packet, size_t *length)
 {
-        ERROR_DECLARE;
-
         packet_t next_packet;
         size_t fragments;
         size_t *lengths;
         size_t index;
+        int rc;
 
         if (!length)
@@ -536 +536 @@
         if (!next_packet) {
                 // write all if only one fragment
-                ERROR_PROPAGATE(data_reply(packet_get_data(packet),
-                    packet_get_data_length(packet)));
+                rc = data_reply(packet_get_data(packet),
+                    packet_get_data_length(packet));
+                if (rc != EOK)
+                        return rc;
                 // store the total length
                 *length = packet_get_data_length(packet);
@@ -564 +566 @@
                 
                 // write the fragment lengths
-                if (ERROR_OCCURRED(data_reply(lengths,
-                    sizeof(int) * (fragments + 1)))) {
+                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
+                if (rc != EOK) {
                         free(lengths);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 next_packet = packet;
@@ -573 +575 @@
                 // write the fragments
                 for (index = 0; index < fragments; ++index) {
-                        ERROR_CODE = data_reply(packet_get_data(next_packet),
+                        rc = data_reply(packet_get_data(next_packet),
                             lengths[index]);
-                        if (ERROR_OCCURRED(ERROR_CODE)) {
+                        if (rc != EOK) {
                                 free(lengths);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         next_packet = pq_next(next_packet);
@@ -680 +682 @@
     socket_core_ref socket, const char *key, size_t key_length)
 {
-        ERROR_DECLARE;
-
         socket_port_ref socket_port;
+        int rc;
 
         // find ports
@@ -690 +691 @@
         
         // add the socket
-        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
-            key_length));
+        rc = socket_port_add_core(socket_port, socket, key, key_length);
+        if (rc != EOK)
+                return rc;
         
         socket->port = port;

uspace/lib/net/tl/tl_common.c

@@ -54 +54 @@
 #include <ipc/services.h>
 #include <errno.h>
-#include <err.h>
 
 DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
@@ -124 +123 @@
     packet_dimension_ref *packet_dimension)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!packet_dimension)
@@ -137 +136 @@
                         return ENOMEM;
                 
-                if (ERROR_OCCURRED(ip_packet_size_req(ip_phone, device_id,
-                    *packet_dimension))) {
+                rc = ip_packet_size_req(ip_phone, device_id, *packet_dimension);
+                if (rc != EOK) {
                         free(*packet_dimension);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 
-                ERROR_CODE = packet_dimensions_add(packet_dimensions, device_id,
+                rc = packet_dimensions_add(packet_dimensions, device_id,
                     *packet_dimension);
-                if (ERROR_CODE < 0) {
+                if (rc < 0) {
                         free(*packet_dimension);
-                        return ERROR_CODE;
+                        return rc;
                 }
         }
@@ -292 +291 @@
     socklen_t addrlen)
 {
-        ERROR_DECLARE;
-
         ipc_callid_t callid;
         size_t length;
-        void * data;
+        void *data;
+        int rc;
 
         if (!dimension)
@@ -319 +317 @@
 
         // read the data into the packet
-        if (ERROR_OCCURRED(async_data_write_finalize(callid, data, length)) ||
-            // set the packet destination address
-            ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr,
-            addrlen))) {
+        rc = async_data_write_finalize(callid, data, length);
+        if (rc != EOK) {
                 pq_release_remote(packet_phone, packet_get_id(*packet));
-                return ERROR_CODE;
+                return rc;
+        }
+        
+        // set the packet destination address
+        rc = packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen);
+        if (rc != EOK) {
+                pq_release_remote(packet_phone, packet_get_id(*packet));
+                return rc;
         }
 

uspace/lib/packet/generic/packet_server.c

@@ -42 +42 @@
 #include <async.h>
 #include <errno.h>
-#include <err.h>
 #include <fibril_synch.h>
 #include <unistd.h>
@@ -162 +161 @@
     size_t max_content, size_t max_suffix)
 {
-        ERROR_DECLARE;
-
         packet_t packet;
+        int rc;
 
         // already locked
@@ -177 +175 @@
         packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
         packet->magic_value = PACKET_MAGIC_VALUE;
-        if (ERROR_OCCURRED(pm_add(packet))) {
+        rc = pm_add(packet);
+        if (rc != EOK) {
                 munmap(packet, packet->length);
                 return NULL;