Index: uspace/lib/block/libblock.c
===================================================================
--- uspace/lib/block/libblock.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/block/libblock.c	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -75,5 +75,5 @@
 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,5 +91,5 @@
 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,5 +98,5 @@
 	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,5 +107,5 @@
 }
 
-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,5 +121,5 @@
 	
 	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,5 +134,5 @@
 	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,5 +152,5 @@
 }
 
-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,5 +165,5 @@
 	}
 
-	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,5 +185,5 @@
 	}
 	
-	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,11 +195,11 @@
 }
 
-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,10 +214,10 @@
 }
 
-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,7 +244,7 @@
 }
 
-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,8 +272,8 @@
 };
 
-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,7 +305,7 @@
 }
 
-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,5 +374,5 @@
  * @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,5 +382,5 @@
  * @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,5 +391,5 @@
 	int rc;
 	
-	devcon = devcon_search(dev_handle);
+	devcon = devcon_search(devmap_handle);
 
 	assert(devcon);
@@ -500,5 +500,5 @@
 
 		block_initialize(b);
-		b->dev_handle = dev_handle;
+		b->devmap_handle = devmap_handle;
 		b->size = cache->lblock_size;
 		b->boff = boff;
@@ -549,5 +549,5 @@
 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,5 +645,5 @@
 /** 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,5 +657,5 @@
  * @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,5 +665,5 @@
 	devcon_t *devcon;
 
-	devcon = devcon_search(dev_handle);
+	devcon = devcon_search(devmap_handle);
 	assert(devcon);
 	block_size = devcon->pblock_size;
@@ -711,5 +711,5 @@
 /** 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,10 +718,10 @@
  * @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,5 +739,5 @@
 /** 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,5 +746,5 @@
  * @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,5 +752,5 @@
 	int rc;
 
-	devcon = devcon_search(dev_handle);
+	devcon = devcon_search(devmap_handle);
 	assert(devcon);
 	
@@ -767,14 +767,14 @@
 /** 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,14 +784,14 @@
 /** 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,5 +818,5 @@
 		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,5 +844,5 @@
 	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();
Index: uspace/lib/block/libblock.h
===================================================================
--- uspace/lib/block/libblock.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/block/libblock.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -72,5 +72,5 @@
 	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,23 +93,23 @@
 };
 
-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
Index: uspace/lib/c/generic/devmap.c
===================================================================
--- uspace/lib/c/generic/devmap.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/generic/devmap.c	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -132,5 +132,5 @@
  *
  */
-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,10 +163,10 @@
 	
 	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,15 +194,15 @@
 	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,15 +230,15 @@
 	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,5 +255,5 @@
 }
 
-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,5 +305,5 @@
 }
 
-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,5 +325,5 @@
 }
 
-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,5 +387,5 @@
 }
 
-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);
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -136,6 +136,6 @@
 	}
 	
-	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,5 +159,5 @@
 	
 	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,5 +328,5 @@
 	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,5 +797,5 @@
 	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;
 	}
Index: uspace/lib/c/include/devmap.h
===================================================================
--- uspace/lib/c/include/devmap.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/devmap.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -44,11 +44,11 @@
 
 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,8 +56,8 @@
 
 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
Index: uspace/lib/c/include/ipc/devmap.h
===================================================================
--- uspace/lib/c/include/ipc/devmap.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/ipc/devmap.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -40,5 +40,5 @@
 #define DEVMAP_NAME_MAXLEN  255
 
-typedef ipcarg_t dev_handle_t;
+typedef ipcarg_t devmap_handle_t;
 
 typedef enum {
@@ -81,5 +81,5 @@
 
 typedef struct {
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	char name[DEVMAP_NAME_MAXLEN + 1];
 } dev_desc_t;
Index: uspace/lib/c/include/sys/stat.h
===================================================================
--- uspace/lib/c/include/sys/stat.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/sys/stat.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -43,5 +43,5 @@
 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,5 +49,5 @@
 	bool is_directory;
 	aoff64_t size;
-	dev_handle_t device;
+	devmap_handle_t device;
 };
 
Index: uspace/lib/c/include/vfs/vfs.h
===================================================================
--- uspace/lib/c/include/vfs/vfs.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/vfs/vfs.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -47,5 +47,5 @@
 typedef struct {
 	fs_handle_t fs_handle;
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 	fs_index_t index;
 } fdi_node_t;
Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/fs/libfs.c	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -150,8 +150,8 @@
     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,5 +174,5 @@
 	
 	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,10 +201,10 @@
 	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,10 +219,10 @@
 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,5 +243,5 @@
 	 */
 	res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED,
-	    fn->mp_data.dev_handle);
+	    fn->mp_data.devmap_handle);
 
 	/*
@@ -252,5 +252,5 @@
 		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,5 +281,5 @@
 	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,10 +295,10 @@
 	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,5 +358,5 @@
 			
 			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,8 +385,8 @@
 				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,5 +401,5 @@
 						aoff64_t size = ops->size_get(fn);
 						ipc_answer_5(rid, fs_handle,
-						    dev_handle,
+						    devmap_handle,
 						    ops->index_get(fn),
 						    LOWER32(size),
@@ -469,7 +469,7 @@
 			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,5 +483,5 @@
 					aoff64_t size = ops->size_get(fn);
 					ipc_answer_5(rid, fs_handle,
-					    dev_handle,
+					    devmap_handle,
 					    ops->index_get(fn),
 					    LOWER32(size),
@@ -509,5 +509,5 @@
 		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,5 +547,5 @@
 		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,9 +571,9 @@
     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,5 +592,5 @@
 	
 	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,9 +617,9 @@
     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));
 	
Index: uspace/lib/fs/libfs.h
===================================================================
--- uspace/lib/fs/libfs.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/fs/libfs.h	(revision 991f645937e5e281d6996ad4623f9ab33c71916d)
@@ -47,5 +47,5 @@
 	int phone;
 	fs_handle_t fs_handle;
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 } mp_data_t;
 
@@ -61,10 +61,10 @@
 	 * 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,5 +81,5 @@
 	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;