Changeset 991f645 in mainline for uspace/lib

Timestamp:

2010-11-18T17:39:28Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

0b5a4131

Parents:

51a268f

Message:

Rename dev_handle_t to devmap_handle_t and make it explicitly clear that
dev_handle_t is a handle understood by devmap.

Location:

uspace/lib

Files:

• block/libblock.c (modified) (31 diffs)
• block/libblock.h (modified) (2 diffs)
• c/generic/devmap.c (modified) (8 diffs)
• c/generic/vfs/vfs.c (modified) (4 diffs)
• c/include/devmap.h (modified) (2 diffs)
• c/include/ipc/devmap.h (modified) (2 diffs)
• c/include/sys/stat.h (modified) (2 diffs)
• c/include/vfs/vfs.h (modified) (1 diff)
• fs/libfs.c (modified) (18 diffs)
• fs/libfs.h (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/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/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/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/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/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/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/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;