Index: uspace/app/bdsh/cmds/modules/bdd/bdd.c
===================================================================
--- uspace/app/bdsh/cmds/modules/bdd/bdd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/app/bdsh/cmds/modules/bdd/bdd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -68,5 +68,5 @@
 	unsigned int argc;
 	unsigned int i, j;
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	uint8_t *blk;
 	size_t size, bytes, rows;
Index: uspace/app/init/init.c
===================================================================
--- uspace/app/init/init.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/app/init/init.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -185,5 +185,5 @@
 	
 	/* Wait for the input device to be ready */
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
 	if (rc != EOK) {
@@ -210,5 +210,5 @@
 	
 	/* Wait for the terminal device to be ready */
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
 	if (rc != EOK) {
Index: uspace/app/mkfat/mkfat.c
===================================================================
--- uspace/app/mkfat/mkfat.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/app/mkfat/mkfat.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -85,5 +85,5 @@
     struct fat_params *par);
 static int fat_blocks_write(struct fat_params const *par,
-    dev_handle_t handle);
+    devmap_handle_t handle);
 static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs);
 
@@ -95,5 +95,5 @@
 	int rc;
 	char *dev_path;
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	size_t block_size;
 	char *endptr;
@@ -234,5 +234,5 @@
 
 /** Create file system with the given parameters. */
-static int fat_blocks_write(struct fat_params const *par, dev_handle_t handle)
+static int fat_blocks_write(struct fat_params const *par, devmap_handle_t handle)
 {
 	aoff64_t addr;
Index: uspace/app/test_serial/test_serial.c
===================================================================
--- uspace/app/test_serial/test_serial.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/app/test_serial/test_serial.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -69,5 +69,5 @@
 	int res;
 	res = devman_get_phone(DEVMAN_CLIENT, IPC_FLAG_BLOCKING);
-	device_handle_t handle;
+	devman_handle_t handle;
 	
 	res = devman_device_get_handle("/hw/pci0/00:01.0/com1", &handle,
Index: uspace/lib/block/libblock.c
===================================================================
--- uspace/lib/block/libblock.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/block/libblock.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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/devman.c
===================================================================
--- uspace/lib/c/generic/devman.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/generic/devman.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -141,5 +141,5 @@
 
 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,5 +180,5 @@
 }
 
-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,5 +189,5 @@
 	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,5 +224,5 @@
 }
 
-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,5 +239,5 @@
 }
 
-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,5 +254,5 @@
 }
 
-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,10 +280,10 @@
 	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;
Index: uspace/lib/c/generic/devmap.c
===================================================================
--- uspace/lib/c/generic/devmap.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/generic/devmap.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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/devman.h
===================================================================
--- uspace/lib/c/include/devman.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/devman.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -42,16 +42,18 @@
 
 
-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
Index: uspace/lib/c/include/devmap.h
===================================================================
--- uspace/lib/c/include/devmap.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/devmap.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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/devman.h
===================================================================
--- uspace/lib/c/include/ipc/devman.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/c/include/ipc/devman.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -42,5 +42,5 @@
 #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.
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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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/drv/generic/driver.c
===================================================================
--- uspace/lib/drv/generic/driver.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/drv/generic/driver.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -139,5 +139,5 @@
 }
 
-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,5 +163,5 @@
 	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,5 +221,5 @@
 	 * 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);
 
Index: uspace/lib/drv/include/driver.h
===================================================================
--- uspace/lib/drv/include/driver.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/drv/include/driver.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -118,5 +118,5 @@
 	 * device manager).
 	 */
-	device_handle_t handle;
+	devman_handle_t handle;
 	
 	/**
Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/lib/fs/libfs.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -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;
 
Index: uspace/srv/bd/ata_bd/ata_bd.c
===================================================================
--- uspace/srv/bd/ata_bd/ata_bd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/ata_bd/ata_bd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -139,5 +139,5 @@
 		
 		snprintf(name, 16, "%s/disk%d", NAMESPACE, i);
-		rc = devmap_device_register(name, &disk[i].dev_handle);
+		rc = devmap_device_register(name, &disk[i].devmap_handle);
 		if (rc != EOK) {
 			devmap_hangup_phone(DEVMAP_DRIVER);
@@ -229,5 +229,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int flags;
 	int retval;
@@ -242,5 +242,5 @@
 	disk_id = -1;
 	for (i = 0; i < MAX_DISKS; i++)
-		if (disk[i].dev_handle == dh)
+		if (disk[i].devmap_handle == dh)
 			disk_id = i;
 
Index: uspace/srv/bd/ata_bd/ata_bd.h
===================================================================
--- uspace/srv/bd/ata_bd/ata_bd.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/ata_bd/ata_bd.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -287,5 +287,5 @@
 
 	fibril_mutex_t lock;
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 } disk_t;
 
Index: uspace/srv/bd/file_bd/file_bd.c
===================================================================
--- uspace/srv/bd/file_bd/file_bd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/file_bd/file_bd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -60,5 +60,5 @@
 static FILE *img;
 
-static dev_handle_t dev_handle;
+static devmap_handle_t devmap_handle;
 static fibril_mutex_t dev_lock;
 
@@ -82,5 +82,5 @@
 		return -1;
 
-	rc = devmap_device_register(argv[2], &dev_handle);
+	rc = devmap_device_register(argv[2], &devmap_handle);
 	if (rc != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
Index: uspace/srv/bd/gxe_bd/gxe_bd.c
===================================================================
--- uspace/srv/bd/gxe_bd/gxe_bd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/gxe_bd/gxe_bd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -93,5 +93,5 @@
 static gxe_bd_t *dev;
 
-static dev_handle_t dev_handle[MAX_DISKS];
+static devmap_handle_t devmap_handle[MAX_DISKS];
 
 static fibril_mutex_t dev_lock[MAX_DISKS];
@@ -143,5 +143,5 @@
 	for (i = 0; i < MAX_DISKS; i++) {
 		snprintf(name, 16, "%s/disk%d", NAMESPACE, i);
-		rc = devmap_device_register(name, &dev_handle[i]);
+		rc = devmap_device_register(name, &devmap_handle[i]);
 		if (rc != EOK) {
 			devmap_hangup_phone(DEVMAP_DRIVER);
@@ -161,5 +161,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int flags;
 	int retval;
@@ -174,5 +174,5 @@
 	disk_id = -1;
 	for (i = 0; i < MAX_DISKS; i++)
-		if (dev_handle[i] == dh)
+		if (devmap_handle[i] == dh)
 			disk_id = i;
 
Index: uspace/srv/bd/part/guid_part/guid_part.c
===================================================================
--- uspace/srv/bd/part/guid_part/guid_part.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/part/guid_part/guid_part.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -83,5 +83,5 @@
 	aoff64_t length;
 	/** Device representing the partition (outbound device) */
-	dev_handle_t dev;
+	devmap_handle_t dev;
 	/** Points to next partition structure. */
 	struct part *next;
@@ -91,5 +91,5 @@
 
 /** Partitioned device (inbound device) */
-static dev_handle_t indev_handle;
+static devmap_handle_t indev_handle;
 
 /** List of partitions. This structure is an empty head. */
@@ -130,5 +130,5 @@
 	int i;
 	char *name;
-	dev_handle_t dev;
+	devmap_handle_t dev;
 	uint64_t size_mb;
 	part_t *part;
@@ -316,5 +316,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int flags;
 	int retval;
Index: uspace/srv/bd/part/mbr_part/mbr_part.c
===================================================================
--- uspace/srv/bd/part/mbr_part/mbr_part.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/part/mbr_part/mbr_part.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -101,5 +101,5 @@
 	aoff64_t length;
 	/** Device representing the partition (outbound device) */
-	dev_handle_t dev;
+	devmap_handle_t dev;
 	/** Points to next partition structure. */
 	struct part *next;
@@ -142,5 +142,5 @@
 
 /** Partitioned device (inbound device) */
-static dev_handle_t indev_handle;
+static devmap_handle_t indev_handle;
 
 /** List of partitions. This structure is an empty head. */
@@ -181,5 +181,5 @@
 	int i;
 	char *name;
-	dev_handle_t dev;
+	devmap_handle_t dev;
 	uint64_t size_mb;
 	part_t *part;
@@ -394,5 +394,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int flags;
 	int retval;
Index: uspace/srv/bd/rd/rd.c
===================================================================
--- uspace/srv/bd/rd/rd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/bd/rd/rd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -238,6 +238,6 @@
 	}
 	
-	dev_handle_t dev_handle;
-	if (devmap_device_register("bd/initrd", &dev_handle) != EOK) {
+	devmap_handle_t devmap_handle;
+	if (devmap_device_register("bd/initrd", &devmap_handle) != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
 		printf("%s: Unable to register device\n", NAME);
Index: uspace/srv/devman/devman.c
===================================================================
--- uspace/srv/devman/devman.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/devman/devman.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -52,5 +52,5 @@
 {
 	node_t *dev = hash_table_get_instance(item, node_t, devman_link);
-	return (dev->handle == (device_handle_t) key[0]);
+	return (dev->handle == (devman_handle_t) key[0]);
 }
 
@@ -59,5 +59,5 @@
 {
 	node_t *dev = hash_table_get_instance(item, node_t, devmap_link);
-	return (dev->devmap_handle == (dev_handle_t) key[0]);
+	return (dev->devmap_handle == (devmap_handle_t) key[0]);
 }
 
@@ -782,5 +782,5 @@
  * @return		The device node.
  */
-node_t *find_dev_node_no_lock(dev_tree_t *tree, device_handle_t handle)
+node_t *find_dev_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
 {
 	unsigned long key = handle;
@@ -795,5 +795,5 @@
  * @return		The device node.
  */
-node_t *find_dev_node(dev_tree_t *tree, device_handle_t handle)
+node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle)
 {
 	node_t *node = NULL;
@@ -1106,5 +1106,5 @@
 /* Devmap devices */
 
-node_t *find_devmap_tree_device(dev_tree_t *tree, dev_handle_t devmap_handle)
+node_t *find_devmap_tree_device(dev_tree_t *tree, devmap_handle_t devmap_handle)
 {
 	node_t *dev = NULL;
@@ -1122,5 +1122,5 @@
 
 node_t *find_devmap_class_device(class_list_t *classes,
-    dev_handle_t devmap_handle)
+    devmap_handle_t devmap_handle)
 {
 	node_t *dev = NULL;
Index: uspace/srv/devman/devman.h
===================================================================
--- uspace/srv/devman/devman.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/devman/devman.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -121,5 +121,5 @@
 struct node {
 	/** The global unique identifier of the device. */
-	device_handle_t handle;
+	devman_handle_t handle;
 	/** The name of the device specified by its parent. */
 	char *name;
@@ -157,5 +157,5 @@
 	link_t classes;
 	/** Devmap handle if the device is registered by devmapper. */
-	dev_handle_t devmap_handle;
+	devmap_handle_t devmap_handle;
 	
 	/**
@@ -179,5 +179,5 @@
 	 * manner.
 	 */
-	device_handle_t current_handle;
+	devman_handle_t current_handle;
 	
 	/** Synchronize access to the device tree. */
@@ -248,5 +248,5 @@
 	char *dev_name;
 	/** The handle of the device by device mapper in the class namespace. */
-	dev_handle_t devmap_handle;
+	devmap_handle_t devmap_handle;
 	
 	/**
@@ -309,6 +309,6 @@
 extern void delete_dev_node(node_t *node);
 extern node_t *find_dev_node_no_lock(dev_tree_t *tree,
-    device_handle_t handle);
-extern node_t *find_dev_node(dev_tree_t *tree, device_handle_t handle);
+    devman_handle_t handle);
+extern node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle);
 extern node_t *find_dev_node_by_path(dev_tree_t *, char *);
 extern node_t *find_node_child(node_t *, const char *);
@@ -337,6 +337,6 @@
 /* Devmap devices */
 
-extern node_t *find_devmap_tree_device(dev_tree_t *, dev_handle_t);
-extern node_t *find_devmap_class_device(class_list_t *, dev_handle_t);
+extern node_t *find_devmap_tree_device(dev_tree_t *, devmap_handle_t);
+extern node_t *find_devmap_class_device(class_list_t *, devmap_handle_t);
 
 extern void class_add_devmap_device(class_list_t *, dev_class_info_t *);
Index: uspace/srv/devman/main.c
===================================================================
--- uspace/srv/devman/main.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/devman/main.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -202,5 +202,5 @@
 static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
 {
-	device_handle_t parent_handle = IPC_GET_ARG1(*call);
+	devman_handle_t parent_handle = IPC_GET_ARG1(*call);
 	ipcarg_t match_count = IPC_GET_ARG2(*call);
 	dev_tree_t *tree = &device_tree;
@@ -271,5 +271,5 @@
 static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
 {
-	device_handle_t handle = IPC_GET_ARG1(*call);
+	devman_handle_t handle = IPC_GET_ARG1(*call);
 	
 	/* Get class name. */
@@ -414,5 +414,5 @@
     bool drv_to_parent)
 {
-	device_handle_t handle = IPC_GET_ARG2(*icall);
+	devman_handle_t handle = IPC_GET_ARG2(*icall);
 	
 	node_t *dev = find_dev_node(&device_tree, handle);
@@ -464,5 +464,5 @@
 static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall)
 {
-	dev_handle_t devmap_handle = IPC_GET_METHOD(*icall);
+	devmap_handle_t devmap_handle = IPC_GET_METHOD(*icall);
 	node_t *dev;
 
Index: uspace/srv/devmap/devmap.c
===================================================================
--- uspace/srv/devmap/devmap.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/devmap/devmap.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -75,5 +75,5 @@
 	link_t namespaces;
 	/** Unique namespace identifier */
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	/** Namespace name */
 	char *name;
@@ -92,5 +92,5 @@
 	link_t driver_devices;
 	/** Unique device identifier */
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	/** Device namespace */
 	devmap_namespace_t *namespace;
@@ -118,8 +118,8 @@
 static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
 
-static dev_handle_t last_handle = 0;
+static devmap_handle_t last_handle = 0;
 static devmap_device_t *null_devices[NULL_DEVICES];
 
-static dev_handle_t devmap_create_handle(void)
+static devmap_handle_t devmap_create_handle(void)
 {
 	/* TODO: allow reusing old handles after their unregistration
@@ -233,5 +233,5 @@
  *
  */
-static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
+static devmap_namespace_t *devmap_namespace_find_handle(devmap_handle_t handle)
 {
 	link_t *item;
@@ -275,5 +275,5 @@
  *
  */
-static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
+static devmap_device_t *devmap_device_find_handle(devmap_handle_t handle)
 {
 	link_t *item;
@@ -608,5 +608,5 @@
 	 * Get handle from request
 	 */
-	dev_handle_t handle = IPC_GET_ARG2(*call);
+	devmap_handle_t handle = IPC_GET_ARG2(*call);
 	devmap_device_t *dev = devmap_device_find_handle(handle);
 	
Index: uspace/srv/fs/devfs/devfs_ops.c
===================================================================
--- uspace/srv/fs/devfs/devfs_ops.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/devfs/devfs_ops.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -54,10 +54,10 @@
 typedef struct {
 	devmap_handle_type_t type;
-	dev_handle_t handle;
+	devmap_handle_t handle;
 } devfs_node_t;
 
 /** Opened devices structure */
 typedef struct {
-	dev_handle_t handle;
+	devmap_handle_t handle;
 	int phone;
 	size_t refcount;
@@ -84,5 +84,5 @@
 {
 	device_t *dev = hash_table_get_instance(item, device_t, link);
-	return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]);
+	return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]);
 }
 
@@ -99,5 +99,5 @@
 
 static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,
-    dev_handle_t handle)
+    devmap_handle_t handle)
 {
 	devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));
@@ -122,5 +122,5 @@
 }
 
-static int devfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
+static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
 {
 	return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);
@@ -154,5 +154,5 @@
 		
 		/* Search root namespace */
-		dev_handle_t namespace;
+		devmap_handle_t namespace;
 		if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
 			count = devmap_get_devices(namespace, &devs);
@@ -200,5 +200,5 @@
 }
 
-static int devfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
+static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
 {
 	return devfs_node_get_internal(rfn, devmap_handle_probe(index), index);
@@ -269,5 +269,5 @@
 }
 
-static int devfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
+static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
 {
 	assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
@@ -304,5 +304,5 @@
 		
 		/* Root namespace */
-		dev_handle_t namespace;
+		devmap_handle_t namespace;
 		if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
 			count = devmap_count_devices(namespace);
@@ -372,5 +372,5 @@
 }
 
-static dev_handle_t devfs_device_get(fs_node_t *fn)
+static devmap_handle_t devfs_device_get(fs_node_t *fn)
 {
 	devfs_node_t *node = (devfs_node_t *) fn->data;
@@ -501,5 +501,5 @@
 		
 		/* Search root namespace */
-		dev_handle_t namespace;
+		devmap_handle_t namespace;
 		if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
 			count = devmap_get_devices(namespace, &desc);
Index: uspace/srv/fs/fat/fat.h
===================================================================
--- uspace/srv/fs/fat/fat.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/fat/fat.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -176,5 +176,5 @@
 
 	fibril_mutex_t	lock;
-	dev_handle_t	dev_handle;
+	devmap_handle_t	devmap_handle;
 	fs_index_t	index;
 	/**
@@ -242,7 +242,7 @@
 extern void fat_sync(ipc_callid_t, ipc_call_t *);
 
-extern int fat_idx_get_new(fat_idx_t **, dev_handle_t);
-extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned);
-extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t);
+extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t);
+extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned);
+extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t);
 extern void fat_idx_destroy(fat_idx_t *);
 extern void fat_idx_hashin(fat_idx_t *);
@@ -251,6 +251,6 @@
 extern int fat_idx_init(void);
 extern void fat_idx_fini(void);
-extern int fat_idx_init_by_dev_handle(dev_handle_t);
-extern void fat_idx_fini_by_dev_handle(dev_handle_t);
+extern int fat_idx_init_by_devmap_handle(devmap_handle_t);
+extern void fat_idx_fini_by_devmap_handle(devmap_handle_t);
 
 #endif
Index: uspace/srv/fs/fat/fat_fat.c
===================================================================
--- uspace/srv/fs/fat/fat_fat.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/fat/fat_fat.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -70,5 +70,5 @@
  *
  * @param bs		Buffer holding the boot sector for the file.
- * @param dev_handle	Device handle of the device with the file.
+ * @param devmap_handle	Device handle of the device with the file.
  * @param firstc	First cluster to start the walk with.
  * @param lastc		If non-NULL, output argument hodling the last cluster
@@ -81,5 +81,5 @@
  */
 int 
-fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
+fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc,
     fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
 {
@@ -108,5 +108,5 @@
 		fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
 		/* read FAT1 */
-		rc = block_get(&b, dev_handle, RSCNT(bs) + fsec,
+		rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec,
 		    BLOCK_FLAGS_NONE);
 		if (rc != EOK)
@@ -159,5 +159,5 @@
 		 * when fortunately we have the last cluster number cached.
 		 */
-		return block_get(block, nodep->idx->dev_handle,
+		return block_get(block, nodep->idx->devmap_handle,
 		    CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
 	}
@@ -173,5 +173,5 @@
 
 fall_through:
-	rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc,
+	rc = _fat_block_get(block, bs, nodep->idx->devmap_handle, firstc,
 	    &currc, relbn, flags);
 	if (rc != EOK)
@@ -192,5 +192,5 @@
  * @param block		Pointer to a block pointer for storing result.
  * @param bs		Buffer holding the boot sector of the file system.
- * @param dev_handle	Device handle of the file system.
+ * @param devmap_handle	Device handle of the file system.
  * @param fcl		First cluster used by the file. Can be zero if the file
  *			is empty.
@@ -204,5 +204,5 @@
  */
 int
-_fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
+_fat_block_get(block_t **block, fat_bs_t *bs, devmap_handle_t devmap_handle,
     fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
 {
@@ -221,5 +221,5 @@
 		/* root directory special case */
 		assert(bn < RDS(bs));
-		rc = block_get(block, dev_handle,
+		rc = block_get(block, devmap_handle,
 		    RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
 		return rc;
@@ -227,10 +227,10 @@
 
 	max_clusters = bn / SPC(bs);
-	rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters);
+	rc = fat_cluster_walk(bs, devmap_handle, fcl, &c, &clusters, max_clusters);
 	if (rc != EOK)
 		return rc;
 	assert(clusters == max_clusters);
 
-	rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags);
+	rc = block_get(block, devmap_handle, CLBN2PBN(bs, c, bn), flags);
 
 	if (clp)
@@ -280,5 +280,5 @@
 	/* zero out the initial part of the new cluster chain */
 	for (o = boundary; o < pos; o += BPS(bs)) {
-		rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
+		rc = _fat_block_get(&b, bs, nodep->idx->devmap_handle, mcl,
 		    NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
 		if (rc != EOK)
@@ -297,5 +297,5 @@
  *
  * @param bs		Buffer holding the boot sector for the file system.
- * @param dev_handle	Device handle for the file system.
+ * @param devmap_handle	Device handle for the file system.
  * @param clst		Cluster which to get.
  * @param value		Output argument holding the value of the cluster.
@@ -304,5 +304,5 @@
  */
 int
-fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
+fat_get_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t *value)
 {
@@ -311,5 +311,5 @@
 	int rc;
 
-	rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
+	rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
 	    (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
 	if (rc != EOK)
@@ -326,5 +326,5 @@
  *
  * @param bs		Buffer holding the boot sector for the file system.
- * @param dev_handle	Device handle for the file system.
+ * @param devmap_handle	Device handle for the file system.
  * @param fatno		Number of the FAT instance where to make the change.
  * @param clst		Cluster which is to be set.
@@ -334,5 +334,5 @@
  */
 int
-fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
+fat_set_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t value)
 {
@@ -342,5 +342,5 @@
 
 	assert(fatno < FATCNT(bs));
-	rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
+	rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
 	    (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
 	if (rc != EOK)
@@ -357,5 +357,5 @@
  *
  * @param bs		Buffer holding the boot sector of the file system.
- * @param dev_handle	Device handle of the file system.
+ * @param devmap_handle	Device handle of the file system.
  * @param lifo		Chain of allocated clusters.
  * @param nclsts	Number of clusters in the lifo chain.
@@ -363,5 +363,5 @@
  * @return		EOK on success or a negative error code.
  */
-int fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
+int fat_alloc_shadow_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle,
     fat_cluster_t *lifo, unsigned nclsts)
 {
@@ -372,5 +372,5 @@
 	for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
 		for (c = 0; c < nclsts; c++) {
-			rc = fat_set_cluster(bs, dev_handle, fatno, lifo[c],
+			rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c],
 			    c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
 			if (rc != EOK)
@@ -390,5 +390,5 @@
  *
  * @param bs		Buffer holding the boot sector of the file system.
- * @param dev_handle	Device handle of the file system.
+ * @param devmap_handle	Device handle of the file system.
  * @param nclsts	Number of clusters to allocate.
  * @param mcl		Output parameter where the first cluster in the chain
@@ -400,5 +400,5 @@
  */
 int
-fat_alloc_clusters(fat_bs_t *bs, dev_handle_t dev_handle, unsigned nclsts,
+fat_alloc_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned nclsts,
     fat_cluster_t *mcl, fat_cluster_t *lcl)
 {
@@ -418,5 +418,5 @@
 	fibril_mutex_lock(&fat_alloc_lock);
 	for (b = 0, cl = 0; b < SF(bs); b++) {
-		rc = block_get(&blk, dev_handle, RSCNT(bs) + b,
+		rc = block_get(&blk, devmap_handle, RSCNT(bs) + b,
 		    BLOCK_FLAGS_NONE);
 		if (rc != EOK)
@@ -457,5 +457,5 @@
 					/* update the shadow copies of FAT */
 					rc = fat_alloc_shadow_clusters(bs,
-					    dev_handle, lifo, nclsts);
+					    devmap_handle, lifo, nclsts);
 					if (rc != EOK)
 						goto error;
@@ -484,5 +484,5 @@
 	 */
 	while (found--) {
-		rc = fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
+		rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found],
 		    FAT_CLST_RES0);
 		if (rc != EOK) {
@@ -499,5 +499,5 @@
  *
  * @param bs		Buffer hodling the boot sector of the file system.
- * @param dev_handle	Device handle of the file system.
+ * @param devmap_handle	Device handle of the file system.
  * @param firstc	First cluster in the chain which is to be freed.
  *
@@ -505,5 +505,5 @@
  */
 int
-fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc)
+fat_free_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc)
 {
 	unsigned fatno;
@@ -514,9 +514,9 @@
 	while (firstc < FAT_CLST_LAST1) {
 		assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
-		rc = fat_get_cluster(bs, dev_handle, FAT1, firstc, &nextc);
+		rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc);
 		if (rc != EOK)
 			return rc;
 		for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-			rc = fat_set_cluster(bs, dev_handle, fatno, firstc,
+			rc = fat_set_cluster(bs, devmap_handle, fatno, firstc,
 			    FAT_CLST_RES0);
 			if (rc != EOK)
@@ -543,5 +543,5 @@
     fat_cluster_t lcl)
 {
-	dev_handle_t dev_handle = nodep->idx->dev_handle;
+	devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
 	fat_cluster_t lastc;
 	uint8_t fatno;
@@ -557,5 +557,5 @@
 			nodep->lastc_cached_valid = false;
 		} else {
-			rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
+			rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
 			    &lastc, NULL, (uint16_t) -1);
 			if (rc != EOK)
@@ -564,5 +564,5 @@
 
 		for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-			rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno,
+			rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno,
 			    lastc, mcl);
 			if (rc != EOK)
@@ -590,5 +590,5 @@
 {
 	int rc;
-	dev_handle_t dev_handle = nodep->idx->dev_handle;
+	devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
 
 	/*
@@ -601,5 +601,5 @@
 	if (lcl == FAT_CLST_RES0) {
 		/* The node will have zero size and no clusters allocated. */
-		rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
+		rc = fat_free_clusters(bs, devmap_handle, nodep->firstc);
 		if (rc != EOK)
 			return rc;
@@ -610,5 +610,5 @@
 		unsigned fatno;
 
-		rc = fat_get_cluster(bs, dev_handle, FAT1, lcl, &nextc);
+		rc = fat_get_cluster(bs, devmap_handle, FAT1, lcl, &nextc);
 		if (rc != EOK)
 			return rc;
@@ -616,5 +616,5 @@
 		/* Terminate the cluster chain in all copies of FAT. */
 		for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-			rc = fat_set_cluster(bs, dev_handle, fatno, lcl,
+			rc = fat_set_cluster(bs, devmap_handle, fatno, lcl,
 			    FAT_CLST_LAST1);
 			if (rc != EOK)
@@ -623,5 +623,5 @@
 
 		/* Free all following clusters. */
-		rc = fat_free_clusters(bs, dev_handle, nextc);
+		rc = fat_free_clusters(bs, devmap_handle, nextc);
 		if (rc != EOK)
 			return rc;
@@ -638,5 +638,5 @@
 
 int
-fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
+fat_zero_cluster(struct fat_bs *bs, devmap_handle_t devmap_handle, fat_cluster_t c)
 {
 	int i;
@@ -645,5 +645,5 @@
 
 	for (i = 0; i < SPC(bs); i++) {
-		rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i,
+		rc = _fat_block_get(&b, bs, devmap_handle, c, NULL, i,
 		    BLOCK_FLAGS_NOREAD);
 		if (rc != EOK)
@@ -665,5 +665,5 @@
  * does not contain a fat file system.
  */
-int fat_sanity_check(fat_bs_t *bs, dev_handle_t dev_handle)
+int fat_sanity_check(fat_bs_t *bs, devmap_handle_t devmap_handle)
 {
 	fat_cluster_t e0, e1;
@@ -706,9 +706,9 @@
 
 	for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) {
-		rc = fat_get_cluster(bs, dev_handle, fat_no, 0, &e0);
+		rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0);
 		if (rc != EOK)
 			return EIO;
 
-		rc = fat_get_cluster(bs, dev_handle, fat_no, 1, &e1);
+		rc = fat_get_cluster(bs, devmap_handle, fat_no, 1, &e1);
 		if (rc != EOK)
 			return EIO;
Index: uspace/srv/fs/fat/fat_fat.h
===================================================================
--- uspace/srv/fs/fat/fat_fat.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/fat/fat_fat.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -61,10 +61,10 @@
 #define fat_clusters_get(numc, bs, dh, fc) \
     fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1)
-extern int fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t,
+extern int fat_cluster_walk(struct fat_bs *, devmap_handle_t, fat_cluster_t,
     fat_cluster_t *, uint16_t *, uint16_t);
 
 extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
     aoff64_t, int);
-extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
+extern int _fat_block_get(block_t **, struct fat_bs *, devmap_handle_t,
     fat_cluster_t, fat_cluster_t *, aoff64_t, int);
 
@@ -73,17 +73,17 @@
 extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
     fat_cluster_t);
-extern int fat_alloc_clusters(struct fat_bs *, dev_handle_t, unsigned,
+extern int fat_alloc_clusters(struct fat_bs *, devmap_handle_t, unsigned,
     fat_cluster_t *, fat_cluster_t *);
-extern int fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t);
-extern int fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t,
+extern int fat_free_clusters(struct fat_bs *, devmap_handle_t, fat_cluster_t);
+extern int fat_alloc_shadow_clusters(struct fat_bs *, devmap_handle_t,
     fat_cluster_t *, unsigned);
-extern int fat_get_cluster(struct fat_bs *, dev_handle_t, unsigned,
+extern int fat_get_cluster(struct fat_bs *, devmap_handle_t, unsigned,
     fat_cluster_t, fat_cluster_t *);
-extern int fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned,
+extern int fat_set_cluster(struct fat_bs *, devmap_handle_t, unsigned,
     fat_cluster_t, fat_cluster_t);
 extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
     aoff64_t);
-extern int fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
-extern int fat_sanity_check(struct fat_bs *, dev_handle_t);
+extern int fat_zero_cluster(struct fat_bs *, devmap_handle_t, fat_cluster_t);
+extern int fat_sanity_check(struct fat_bs *, devmap_handle_t);
 
 #endif
Index: uspace/srv/fs/fat/fat_idx.c
===================================================================
--- uspace/srv/fs/fat/fat_idx.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/fat/fat_idx.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -58,5 +58,5 @@
 typedef struct {
 	link_t		link;
-	dev_handle_t	dev_handle;
+	devmap_handle_t	devmap_handle;
 
 	/** Next unassigned index. */
@@ -75,8 +75,8 @@
 static LIST_INITIALIZE(unused_head);
 
-static void unused_initialize(unused_t *u, dev_handle_t dev_handle)
+static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
 {
 	link_initialize(&u->link);
-	u->dev_handle = dev_handle;
+	u->devmap_handle = devmap_handle;
 	u->next = 0;
 	u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
@@ -84,5 +84,5 @@
 }
 
-static unused_t *unused_find(dev_handle_t dev_handle, bool lock)
+static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock)
 {
 	unused_t *u;
@@ -93,5 +93,5 @@
 	for (l = unused_head.next; l != &unused_head; l = l->next) {
 		u = list_get_instance(l, unused_t, link);
-		if (u->dev_handle == dev_handle) 
+		if (u->devmap_handle == devmap_handle) 
 			return u;
 	}
@@ -106,5 +106,5 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the dev_handle, parent node's first
+ * The index structures are hashed by the devmap_handle, parent node's first
  * cluster and index within the parent directory.
  */ 
@@ -120,5 +120,5 @@
 static hash_index_t pos_hash(unsigned long key[])
 {
-	dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY];
+	devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
 	fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
 	unsigned pdi = (unsigned)key[UPH_PDI_KEY];
@@ -140,5 +140,5 @@
 	h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
 	    (UPH_BUCKETS_LOG / 2); 
-	h |= (dev_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
+	h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
 	    (3 * (UPH_BUCKETS_LOG / 4));
 
@@ -148,5 +148,5 @@
 static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-	dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY];
+	devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
 	fat_cluster_t pfc;
 	unsigned pdi;
@@ -155,9 +155,9 @@
 	switch (keys) {
 	case 1:
-		return (dev_handle == fidx->dev_handle);
+		return (devmap_handle == fidx->devmap_handle);
 	case 3:
 		pfc = (fat_cluster_t) key[UPH_PFC_KEY];
 		pdi = (unsigned) key[UPH_PDI_KEY];
-		return (dev_handle == fidx->dev_handle) && (pfc == fidx->pfc) &&
+		return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) &&
 		    (pdi == fidx->pdi);
 	default:
@@ -181,5 +181,5 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the dev_handle and index.
+ * The index structures are hashed by the devmap_handle and index.
  */
 static hash_table_t ui_hash;
@@ -193,10 +193,10 @@
 static hash_index_t idx_hash(unsigned long key[])
 {
-	dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY];
+	devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
 	fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
 
 	hash_index_t h;
 
-	h = dev_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
+	h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
 	h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) <<
 	    (UIH_BUCKETS_LOG / 2);
@@ -207,5 +207,5 @@
 static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-	dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY];
+	devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
 	fs_index_t index;
 	fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
@@ -213,8 +213,8 @@
 	switch (keys) {
 	case 1:
-		return (dev_handle == fidx->dev_handle);
+		return (devmap_handle == fidx->devmap_handle);
 	case 2:
 		index = (fs_index_t) key[UIH_INDEX_KEY];
-		return (dev_handle == fidx->dev_handle) &&
+		return (devmap_handle == fidx->devmap_handle) &&
 		    (index == fidx->index);
 	default:
@@ -239,10 +239,10 @@
 
 /** Allocate a VFS index which is not currently in use. */
-static bool fat_index_alloc(dev_handle_t dev_handle, fs_index_t *index)
+static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index)
 {
 	unused_t *u;
 	
 	assert(index);
-	u = unused_find(dev_handle, true);
+	u = unused_find(devmap_handle, true);
 	if (!u)
 		return false;	
@@ -301,9 +301,9 @@
 
 /** Free a VFS index, which is no longer in use. */
-static void fat_index_free(dev_handle_t dev_handle, fs_index_t index)
+static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index)
 {
 	unused_t *u;
 
-	u = unused_find(dev_handle, true);
+	u = unused_find(devmap_handle, true);
 	assert(u);
 
@@ -363,5 +363,5 @@
 }
 
-static int fat_idx_create(fat_idx_t **fidxp, dev_handle_t dev_handle)
+static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
 {
 	fat_idx_t *fidx;
@@ -370,5 +370,5 @@
 	if (!fidx) 
 		return ENOMEM;
-	if (!fat_index_alloc(dev_handle, &fidx->index)) {
+	if (!fat_index_alloc(devmap_handle, &fidx->index)) {
 		free(fidx);
 		return ENOSPC;
@@ -378,5 +378,5 @@
 	link_initialize(&fidx->uih_link);
 	fibril_mutex_initialize(&fidx->lock);
-	fidx->dev_handle = dev_handle;
+	fidx->devmap_handle = devmap_handle;
 	fidx->pfc = FAT_CLST_RES0;	/* no parent yet */
 	fidx->pdi = 0;
@@ -387,5 +387,5 @@
 }
 
-int fat_idx_get_new(fat_idx_t **fidxp, dev_handle_t dev_handle)
+int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
 {
 	fat_idx_t *fidx;
@@ -393,5 +393,5 @@
 
 	fibril_mutex_lock(&used_lock);
-	rc = fat_idx_create(&fidx, dev_handle);
+	rc = fat_idx_create(&fidx, devmap_handle);
 	if (rc != EOK) {
 		fibril_mutex_unlock(&used_lock);
@@ -400,5 +400,5 @@
 		
 	unsigned long ikey[] = {
-		[UIH_DH_KEY] = dev_handle,
+		[UIH_DH_KEY] = devmap_handle,
 		[UIH_INDEX_KEY] = fidx->index,
 	};
@@ -413,10 +413,10 @@
 
 fat_idx_t *
-fat_idx_get_by_pos(dev_handle_t dev_handle, fat_cluster_t pfc, unsigned pdi)
+fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi)
 {
 	fat_idx_t *fidx;
 	link_t *l;
 	unsigned long pkey[] = {
-		[UPH_DH_KEY] = dev_handle,
+		[UPH_DH_KEY] = devmap_handle,
 		[UPH_PFC_KEY] = pfc,
 		[UPH_PDI_KEY] = pdi,
@@ -430,5 +430,5 @@
 		int rc;
 
-		rc = fat_idx_create(&fidx, dev_handle);
+		rc = fat_idx_create(&fidx, devmap_handle);
 		if (rc != EOK) {
 			fibril_mutex_unlock(&used_lock);
@@ -437,5 +437,5 @@
 		
 		unsigned long ikey[] = {
-			[UIH_DH_KEY] = dev_handle,
+			[UIH_DH_KEY] = devmap_handle,
 			[UIH_INDEX_KEY] = fidx->index,
 		};
@@ -456,5 +456,5 @@
 {
 	unsigned long pkey[] = {
-		[UPH_DH_KEY] = idx->dev_handle,
+		[UPH_DH_KEY] = idx->devmap_handle,
 		[UPH_PFC_KEY] = idx->pfc,
 		[UPH_PDI_KEY] = idx->pdi,
@@ -469,5 +469,5 @@
 {
 	unsigned long pkey[] = {
-		[UPH_DH_KEY] = idx->dev_handle,
+		[UPH_DH_KEY] = idx->devmap_handle,
 		[UPH_PFC_KEY] = idx->pfc,
 		[UPH_PDI_KEY] = idx->pdi,
@@ -480,10 +480,10 @@
 
 fat_idx_t *
-fat_idx_get_by_index(dev_handle_t dev_handle, fs_index_t index)
+fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index)
 {
 	fat_idx_t *fidx = NULL;
 	link_t *l;
 	unsigned long ikey[] = {
-		[UIH_DH_KEY] = dev_handle,
+		[UIH_DH_KEY] = devmap_handle,
 		[UIH_INDEX_KEY] = index,
 	};
@@ -507,8 +507,8 @@
 {
 	unsigned long ikey[] = {
-		[UIH_DH_KEY] = idx->dev_handle,
+		[UIH_DH_KEY] = idx->devmap_handle,
 		[UIH_INDEX_KEY] = idx->index,
 	};
-	dev_handle_t dev_handle = idx->dev_handle;
+	devmap_handle_t devmap_handle = idx->devmap_handle;
 	fs_index_t index = idx->index;
 
@@ -524,5 +524,5 @@
 	fibril_mutex_unlock(&used_lock);
 	/* Release the VFS index. */
-	fat_index_free(dev_handle, index);
+	fat_index_free(devmap_handle, index);
 	/* The index structure itself is freed in idx_remove_callback(). */
 }
@@ -546,5 +546,5 @@
 }
 
-int fat_idx_init_by_dev_handle(dev_handle_t dev_handle)
+int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle)
 {
 	unused_t *u;
@@ -554,7 +554,7 @@
 	if (!u)
 		return ENOMEM;
-	unused_initialize(u, dev_handle);
+	unused_initialize(u, devmap_handle);
 	fibril_mutex_lock(&unused_lock);
-	if (!unused_find(dev_handle, false)) {
+	if (!unused_find(devmap_handle, false)) {
 		list_append(&u->link, &unused_head);
 	} else {
@@ -566,11 +566,11 @@
 }
 
-void fat_idx_fini_by_dev_handle(dev_handle_t dev_handle)
+void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle)
 {
 	unsigned long ikey[] = {
-		[UIH_DH_KEY] = dev_handle
+		[UIH_DH_KEY] = devmap_handle
 	};
 	unsigned long pkey[] = {
-		[UPH_DH_KEY] = dev_handle
+		[UPH_DH_KEY] = devmap_handle
 	};
 
@@ -588,5 +588,5 @@
 	 * Free the unused and freed structures for this instance.
 	 */
-	unused_t *u = unused_find(dev_handle, true);
+	unused_t *u = unused_find(devmap_handle, true);
 	assert(u);
 	list_remove(&u->link);
Index: uspace/srv/fs/fat/fat_ops.c
===================================================================
--- uspace/srv/fs/fat/fat_ops.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/fat/fat_ops.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -72,10 +72,10 @@
  * Forward declarations of FAT libfs operations.
  */
-static int fat_root_get(fs_node_t **, dev_handle_t);
+static int fat_root_get(fs_node_t **, devmap_handle_t);
 static int fat_match(fs_node_t **, fs_node_t *, const char *);
-static int fat_node_get(fs_node_t **, dev_handle_t, fs_index_t);
+static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
 static int fat_node_open(fs_node_t *);
 static int fat_node_put(fs_node_t *);
-static int fat_create_node(fs_node_t **, dev_handle_t, int);
+static int fat_create_node(fs_node_t **, devmap_handle_t, int);
 static int fat_destroy_node(fs_node_t *);
 static int fat_link(fs_node_t *, fs_node_t *, const char *);
@@ -88,5 +88,5 @@
 static bool fat_is_directory(fs_node_t *);
 static bool fat_is_file(fs_node_t *node);
-static dev_handle_t fat_device_get(fs_node_t *node);
+static devmap_handle_t fat_device_get(fs_node_t *node);
 
 /*
@@ -120,8 +120,8 @@
 	assert(node->dirty);
 
-	bs = block_bb_get(node->idx->dev_handle);
+	bs = block_bb_get(node->idx->devmap_handle);
 	
 	/* Read the block that contains the dentry of interest. */
-	rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
+	rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
 	    NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
 	    BLOCK_FLAGS_NONE);
@@ -145,5 +145,5 @@
 }
 
-static int fat_node_fini_by_dev_handle(dev_handle_t dev_handle)
+static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
 {
 	link_t *lnk;
@@ -170,5 +170,5 @@
 			goto restart;
 		}
-		if (nodep->idx->dev_handle != dev_handle) {
+		if (nodep->idx->devmap_handle != devmap_handle) {
 			fibril_mutex_unlock(&nodep->idx->lock);
 			fibril_mutex_unlock(&nodep->lock);
@@ -299,8 +299,8 @@
 		return rc;
 
-	bs = block_bb_get(idxp->dev_handle);
+	bs = block_bb_get(idxp->devmap_handle);
 
 	/* Read the block that contains the dentry of interest. */
-	rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
+	rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
 	    (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
 	if (rc != EOK) {
@@ -323,5 +323,5 @@
 		 */
 		uint16_t clusters;
-		rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
+		rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
 		    uint16_t_le2host(d->firstc));
 		if (rc != EOK) {
@@ -356,7 +356,7 @@
  */
 
-int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
-{
-	return fat_node_get(rfn, dev_handle, 0);
+int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
+{
+	return fat_node_get(rfn, devmap_handle, 0);
 }
 
@@ -369,13 +369,13 @@
 	unsigned blocks;
 	fat_dentry_t *d;
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 	block_t *b;
 	int rc;
 
 	fibril_mutex_lock(&parentp->idx->lock);
-	dev_handle = parentp->idx->dev_handle;
+	devmap_handle = parentp->idx->devmap_handle;
 	fibril_mutex_unlock(&parentp->idx->lock);
 
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 	blocks = parentp->size / BPS(bs);
 	for (i = 0; i < blocks; i++) {
@@ -402,5 +402,5 @@
 				/* hit */
 				fat_node_t *nodep;
-				fat_idx_t *idx = fat_idx_get_by_pos(dev_handle,
+				fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
 				    parentp->firstc, i * DPS(bs) + j);
 				if (!idx) {
@@ -435,5 +435,5 @@
 
 /** Instantiate a FAT in-core node. */
-int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
+int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
 {
 	fat_node_t *nodep;
@@ -441,5 +441,5 @@
 	int rc;
 
-	idxp = fat_idx_get_by_index(dev_handle, index);
+	idxp = fat_idx_get_by_index(devmap_handle, index);
 	if (!idxp) {
 		*rfn = NULL;
@@ -492,5 +492,5 @@
 }
 
-int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags)
+int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
 {
 	fat_idx_t *idxp;
@@ -500,14 +500,14 @@
 	int rc;
 
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 	if (flags & L_DIRECTORY) {
 		/* allocate a cluster */
-		rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
+		rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
 		if (rc != EOK)
 			return rc;
 		/* populate the new cluster with unused dentries */
-		rc = fat_zero_cluster(bs, dev_handle, mcl);
+		rc = fat_zero_cluster(bs, devmap_handle, mcl);
 		if (rc != EOK) {
-			(void) fat_free_clusters(bs, dev_handle, mcl);
+			(void) fat_free_clusters(bs, devmap_handle, mcl);
 			return rc;
 		}
@@ -516,10 +516,10 @@
 	rc = fat_node_get_new(&nodep);
 	if (rc != EOK) {
-		(void) fat_free_clusters(bs, dev_handle, mcl);
+		(void) fat_free_clusters(bs, devmap_handle, mcl);
 		return rc;
 	}
-	rc = fat_idx_get_new(&idxp, dev_handle);
-	if (rc != EOK) {
-		(void) fat_free_clusters(bs, dev_handle, mcl);	
+	rc = fat_idx_get_new(&idxp, devmap_handle);
+	if (rc != EOK) {
+		(void) fat_free_clusters(bs, devmap_handle, mcl);	
 		(void) fat_node_put(FS_NODE(nodep));
 		return rc;
@@ -570,9 +570,9 @@
 	assert(!has_children);
 
-	bs = block_bb_get(nodep->idx->dev_handle);
+	bs = block_bb_get(nodep->idx->devmap_handle);
 	if (nodep->firstc != FAT_CLST_RES0) {
 		assert(nodep->size);
 		/* Free all clusters allocated to the node. */
-		rc = fat_free_clusters(bs, nodep->idx->dev_handle,
+		rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
 		    nodep->firstc);
 	}
@@ -620,5 +620,5 @@
 	
 	fibril_mutex_lock(&parentp->idx->lock);
-	bs = block_bb_get(parentp->idx->dev_handle);
+	bs = block_bb_get(parentp->idx->devmap_handle);
 
 	blocks = parentp->size / BPS(bs);
@@ -659,12 +659,12 @@
 		return ENOSPC;
 	}
-	rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
+	rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
 	if (rc != EOK) {
 		fibril_mutex_unlock(&parentp->idx->lock);
 		return rc;
 	}
-	rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
-	if (rc != EOK) {
-		(void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
+	rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
+	if (rc != EOK) {
+		(void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
 		fibril_mutex_unlock(&parentp->idx->lock);
 		return rc;
@@ -672,5 +672,5 @@
 	rc = fat_append_clusters(bs, parentp, mcl, lcl);
 	if (rc != EOK) {
-		(void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
+		(void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
 		fibril_mutex_unlock(&parentp->idx->lock);
 		return rc;
@@ -789,7 +789,7 @@
 	assert(childp->lnkcnt == 1);
 	fibril_mutex_lock(&childp->idx->lock);
-	bs = block_bb_get(childp->idx->dev_handle);
-
-	rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
+	bs = block_bb_get(childp->idx->devmap_handle);
+
+	rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
 	    NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
 	    BLOCK_FLAGS_NONE);
@@ -840,5 +840,5 @@
 	
 	fibril_mutex_lock(&nodep->idx->lock);
-	bs = block_bb_get(nodep->idx->dev_handle);
+	bs = block_bb_get(nodep->idx->devmap_handle);
 
 	blocks = nodep->size / BPS(bs);
@@ -914,5 +914,5 @@
 }
 
-dev_handle_t fat_device_get(fs_node_t *node)
+devmap_handle_t fat_device_get(fs_node_t *node)
 {
 	return 0;
@@ -946,5 +946,5 @@
 void fat_mounted(ipc_callid_t rid, 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);
 	enum cache_mode cmode;
 	fat_bs_t *bs;
@@ -968,5 +968,5 @@
 
 	/* initialize libblock */
-	rc = block_init(dev_handle, BS_SIZE);
+	rc = block_init(devmap_handle, BS_SIZE);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -975,7 +975,7 @@
 
 	/* prepare the boot block */
-	rc = block_bb_read(dev_handle, BS_BLOCK);
-	if (rc != EOK) {
-		block_fini(dev_handle);
+	rc = block_bb_read(devmap_handle, BS_BLOCK);
+	if (rc != EOK) {
+		block_fini(devmap_handle);
 		ipc_answer_0(rid, rc);
 		return;
@@ -983,8 +983,8 @@
 
 	/* get the buffer with the boot sector */
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 	
 	if (BPS(bs) != BS_SIZE) {
-		block_fini(dev_handle);
+		block_fini(devmap_handle);
 		ipc_answer_0(rid, ENOTSUP);
 		return;
@@ -992,7 +992,7 @@
 
 	/* Initialize the block cache */
-	rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
-	if (rc != EOK) {
-		block_fini(dev_handle);
+	rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
+	if (rc != EOK) {
+		block_fini(devmap_handle);
 		ipc_answer_0(rid, rc);
 		return;
@@ -1000,16 +1000,16 @@
 
 	/* Do some simple sanity checks on the file system. */
-	rc = fat_sanity_check(bs, dev_handle);
-	if (rc != EOK) {
-		(void) block_cache_fini(dev_handle);
-		block_fini(dev_handle);
+	rc = fat_sanity_check(bs, devmap_handle);
+	if (rc != EOK) {
+		(void) block_cache_fini(devmap_handle);
+		block_fini(devmap_handle);
 		ipc_answer_0(rid, rc);
 		return;
 	}
 
-	rc = fat_idx_init_by_dev_handle(dev_handle);
-	if (rc != EOK) {
-		(void) block_cache_fini(dev_handle);
-		block_fini(dev_handle);
+	rc = fat_idx_init_by_devmap_handle(devmap_handle);
+	if (rc != EOK) {
+		(void) block_cache_fini(devmap_handle);
+		block_fini(devmap_handle);
 		ipc_answer_0(rid, rc);
 		return;
@@ -1019,7 +1019,7 @@
 	fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
 	if (!rfn) {
-		(void) block_cache_fini(dev_handle);
-		block_fini(dev_handle);
-		fat_idx_fini_by_dev_handle(dev_handle);
+		(void) block_cache_fini(devmap_handle);
+		block_fini(devmap_handle);
+		fat_idx_fini_by_devmap_handle(devmap_handle);
 		ipc_answer_0(rid, ENOMEM);
 		return;
@@ -1029,7 +1029,7 @@
 	if (!rootp) {
 		free(rfn);
-		(void) block_cache_fini(dev_handle);
-		block_fini(dev_handle);
-		fat_idx_fini_by_dev_handle(dev_handle);
+		(void) block_cache_fini(devmap_handle);
+		block_fini(devmap_handle);
+		fat_idx_fini_by_devmap_handle(devmap_handle);
 		ipc_answer_0(rid, ENOMEM);
 		return;
@@ -1037,11 +1037,11 @@
 	fat_node_initialize(rootp);
 
-	fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
+	fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
 	if (!ridxp) {
 		free(rfn);
 		free(rootp);
-		(void) block_cache_fini(dev_handle);
-		block_fini(dev_handle);
-		fat_idx_fini_by_dev_handle(dev_handle);
+		(void) block_cache_fini(devmap_handle);
+		block_fini(devmap_handle);
+		fat_idx_fini_by_devmap_handle(devmap_handle);
 		ipc_answer_0(rid, ENOMEM);
 		return;
@@ -1072,10 +1072,10 @@
 void fat_unmounted(ipc_callid_t rid, 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_node_t *fn;
 	fat_node_t *nodep;
 	int rc;
 
-	rc = fat_root_get(&fn, dev_handle);
+	rc = fat_root_get(&fn, devmap_handle);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -1105,8 +1105,8 @@
 	 * stop using libblock for this instance.
 	 */
-	(void) fat_node_fini_by_dev_handle(dev_handle);
-	fat_idx_fini_by_dev_handle(dev_handle);
-	(void) block_cache_fini(dev_handle);
-	block_fini(dev_handle);
+	(void) fat_node_fini_by_devmap_handle(devmap_handle);
+	fat_idx_fini_by_devmap_handle(devmap_handle);
+	(void) block_cache_fini(devmap_handle);
+	block_fini(devmap_handle);
 
 	ipc_answer_0(rid, EOK);
@@ -1125,5 +1125,5 @@
 void fat_read(ipc_callid_t rid, 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);
 	aoff64_t pos =
@@ -1136,5 +1136,5 @@
 	int rc;
 
-	rc = fat_node_get(&fn, dev_handle, index);
+	rc = fat_node_get(&fn, devmap_handle, index);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -1156,5 +1156,5 @@
 	}
 
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 
 	if (nodep->type == FAT_FILE) {
@@ -1262,5 +1262,5 @@
 void fat_write(ipc_callid_t rid, 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);
 	aoff64_t pos =
@@ -1275,5 +1275,5 @@
 	int rc;
 	
-	rc = fat_node_get(&fn, dev_handle, index);
+	rc = fat_node_get(&fn, devmap_handle, index);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -1295,5 +1295,5 @@
 	}
 
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 
 	/*
@@ -1357,5 +1357,5 @@
 		nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
 		/* create an independent chain of nclsts clusters in all FATs */
-		rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
+		rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
 		if (rc != EOK) {
 			/* could not allocate a chain of nclsts clusters */
@@ -1368,5 +1368,5 @@
 		rc = fat_fill_gap(bs, nodep, mcl, pos);
 		if (rc != EOK) {
-			(void) fat_free_clusters(bs, dev_handle, mcl);
+			(void) fat_free_clusters(bs, devmap_handle, mcl);
 			(void) fat_node_put(fn);
 			ipc_answer_0(callid, rc);
@@ -1374,8 +1374,8 @@
 			return;
 		}
-		rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
+		rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
 		    (pos / BPS(bs)) % SPC(bs), flags);
 		if (rc != EOK) {
-			(void) fat_free_clusters(bs, dev_handle, mcl);
+			(void) fat_free_clusters(bs, devmap_handle, mcl);
 			(void) fat_node_put(fn);
 			ipc_answer_0(callid, rc);
@@ -1388,5 +1388,5 @@
 		rc = block_put(b);
 		if (rc != EOK) {
-			(void) fat_free_clusters(bs, dev_handle, mcl);
+			(void) fat_free_clusters(bs, devmap_handle, mcl);
 			(void) fat_node_put(fn);
 			ipc_answer_0(rid, rc);
@@ -1399,5 +1399,5 @@
 		rc = fat_append_clusters(bs, nodep, mcl, lcl);
 		if (rc != EOK) {
-			(void) fat_free_clusters(bs, dev_handle, mcl);
+			(void) fat_free_clusters(bs, devmap_handle, mcl);
 			(void) fat_node_put(fn);
 			ipc_answer_0(rid, rc);
@@ -1414,5 +1414,5 @@
 void fat_truncate(ipc_callid_t rid, 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);
 	aoff64_t size =
@@ -1423,5 +1423,5 @@
 	int rc;
 
-	rc = fat_node_get(&fn, dev_handle, index);
+	rc = fat_node_get(&fn, devmap_handle, index);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -1434,5 +1434,5 @@
 	nodep = FAT_NODE(fn);
 
-	bs = block_bb_get(dev_handle);
+	bs = block_bb_get(devmap_handle);
 
 	if (nodep->size == size) {
@@ -1461,5 +1461,5 @@
 		} else {
 			fat_cluster_t lastc;
-			rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
+			rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
 			    &lastc, NULL, (size - 1) / BPC(bs));
 			if (rc != EOK)
@@ -1486,10 +1486,10 @@
 void fat_destroy(ipc_callid_t rid, 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;
 
-	rc = fat_node_get(&fn, dev_handle, index);
+	rc = fat_node_get(&fn, devmap_handle, index);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
@@ -1517,9 +1517,9 @@
 void fat_sync(ipc_callid_t rid, 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 = fat_node_get(&fn, dev_handle, index);
+	int rc = fat_node_get(&fn, devmap_handle, index);
 	if (rc != EOK) {
 		ipc_answer_0(rid, rc);
Index: uspace/srv/fs/tmpfs/tmpfs.h
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/tmpfs/tmpfs.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -62,5 +62,5 @@
 	fs_node_t *bp;		/**< Back pointer to the FS node. */
 	fs_index_t index;	/**< TMPFS node index. */
-	dev_handle_t dev_handle;/**< Device handle. */
+	devmap_handle_t devmap_handle;/**< Device handle. */
 	link_t nh_link;		/**< Nodes hash table link. */
 	tmpfs_dentry_type_t type;
@@ -91,5 +91,5 @@
 extern void tmpfs_sync(ipc_callid_t, ipc_call_t *);
 
-extern bool tmpfs_restore(dev_handle_t);
+extern bool tmpfs_restore(devmap_handle_t);
 
 #endif
Index: uspace/srv/fs/tmpfs/tmpfs_dump.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_dump.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/tmpfs/tmpfs_dump.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -55,5 +55,5 @@
 
 static bool
-tmpfs_restore_recursion(dev_handle_t dev, size_t *bufpos, size_t *buflen,
+tmpfs_restore_recursion(devmap_handle_t dev, size_t *bufpos, size_t *buflen,
     aoff64_t *pos, fs_node_t *pfn)
 {
@@ -161,5 +161,5 @@
 }
 
-bool tmpfs_restore(dev_handle_t dev)
+bool tmpfs_restore(devmap_handle_t dev)
 {
 	libfs_ops_t *ops = &tmpfs_libfs_ops;
Index: uspace/srv/fs/tmpfs/tmpfs_ops.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -70,8 +70,8 @@
 /* Forward declarations of static functions. */
 static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
-static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t);
+static int tmpfs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
 static int tmpfs_node_open(fs_node_t *);
 static int tmpfs_node_put(fs_node_t *);
-static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
+static int tmpfs_create_node(fs_node_t **, devmap_handle_t, int);
 static int tmpfs_destroy_node(fs_node_t *);
 static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
@@ -79,7 +79,7 @@
 
 /* Implementation of helper functions. */
-static int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
-{
-	return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT); 
+static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
+{
+	return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT); 
 }
 
@@ -120,5 +120,5 @@
 }
 
-static dev_handle_t tmpfs_device_get(fs_node_t *fn)
+static devmap_handle_t tmpfs_device_get(fs_node_t *fn)
 {
 	return 0;
@@ -165,7 +165,7 @@
 	switch (keys) {
 	case 1:
-		return (nodep->dev_handle == key[NODES_KEY_DEV]);
+		return (nodep->devmap_handle == key[NODES_KEY_DEV]);
 	case 2:	
-		return ((nodep->dev_handle == key[NODES_KEY_DEV]) &&
+		return ((nodep->devmap_handle == key[NODES_KEY_DEV]) &&
 		    (nodep->index == key[NODES_KEY_INDEX]));
 	default:
@@ -209,5 +209,5 @@
 	nodep->bp = NULL;
 	nodep->index = 0;
-	nodep->dev_handle = 0;
+	nodep->devmap_handle = 0;
 	nodep->type = TMPFS_NONE;
 	nodep->lnkcnt = 0;
@@ -233,10 +233,10 @@
 }
 
-static bool tmpfs_instance_init(dev_handle_t dev_handle)
+static bool tmpfs_instance_init(devmap_handle_t devmap_handle)
 {
 	fs_node_t *rfn;
 	int rc;
 	
-	rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
+	rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY);
 	if (rc != EOK || !rfn)
 		return false;
@@ -245,8 +245,8 @@
 }
 
-static void tmpfs_instance_done(dev_handle_t dev_handle)
+static void tmpfs_instance_done(devmap_handle_t devmap_handle)
 {
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle
+		[NODES_KEY_DEV] = devmap_handle
 	};
 	/*
@@ -279,8 +279,8 @@
 }
 
-int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
+int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
 {
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle,
+		[NODES_KEY_DEV] = devmap_handle,
 		[NODES_KEY_INDEX] = index
 	};
@@ -308,5 +308,5 @@
 }
 
-int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
+int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
 {
 	fs_node_t *rootfn;
@@ -327,5 +327,5 @@
 	nodep->bp->data = nodep;	/* link the FS and TMPFS nodes */
 
-	rc = tmpfs_root_get(&rootfn, dev_handle);
+	rc = tmpfs_root_get(&rootfn, devmap_handle);
 	assert(rc == EOK);
 	if (!rootfn)
@@ -333,5 +333,5 @@
 	else
 		nodep->index = tmpfs_next_index++;
-	nodep->dev_handle = dev_handle;
+	nodep->devmap_handle = devmap_handle;
 	if (lflag & L_DIRECTORY) 
 		nodep->type = TMPFS_DIRECTORY;
@@ -341,5 +341,5 @@
 	/* Insert the new node into the nodes hash table. */
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = nodep->dev_handle,
+		[NODES_KEY_DEV] = nodep->devmap_handle,
 		[NODES_KEY_INDEX] = nodep->index
 	};
@@ -357,5 +357,5 @@
 
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = nodep->dev_handle,
+		[NODES_KEY_DEV] = nodep->devmap_handle,
 		[NODES_KEY_INDEX] = nodep->index
 	};
@@ -442,5 +442,5 @@
 void tmpfs_mounted(ipc_callid_t rid, 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_node_t *rootfn;
 	int rc;
@@ -455,5 +455,5 @@
 
 	/* Check if this device is not already mounted. */
-	rc = tmpfs_root_get(&rootfn, dev_handle);
+	rc = tmpfs_root_get(&rootfn, devmap_handle);
 	if ((rc == EOK) && (rootfn)) {
 		(void) tmpfs_node_put(rootfn);
@@ -464,5 +464,5 @@
 
 	/* Initialize TMPFS instance. */
-	if (!tmpfs_instance_init(dev_handle)) {
+	if (!tmpfs_instance_init(devmap_handle)) {
 		free(opts);
 		ipc_answer_0(rid, ENOMEM);
@@ -470,9 +470,9 @@
 	}
 
-	rc = tmpfs_root_get(&rootfn, dev_handle);
+	rc = tmpfs_root_get(&rootfn, devmap_handle);
 	assert(rc == EOK);
 	tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
 	if (str_cmp(opts, "restore") == 0) {
-		if (tmpfs_restore(dev_handle))
+		if (tmpfs_restore(devmap_handle))
 			ipc_answer_3(rid, EOK, rootp->index, rootp->size,
 			    rootp->lnkcnt);
@@ -493,7 +493,7 @@
 void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
 {
-	dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-
-	tmpfs_instance_done(dev_handle);
+	devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+
+	tmpfs_instance_done(devmap_handle);
 	ipc_answer_0(rid, EOK);
 }
@@ -511,5 +511,5 @@
 void tmpfs_read(ipc_callid_t rid, 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);
 	aoff64_t pos =
@@ -521,5 +521,5 @@
 	link_t *hlp;
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle,
+		[NODES_KEY_DEV] = devmap_handle,
 		[NODES_KEY_INDEX] = index
 	};
@@ -586,5 +586,5 @@
 void tmpfs_write(ipc_callid_t rid, 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);
 	aoff64_t pos =
@@ -596,5 +596,5 @@
 	link_t *hlp;
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle,
+		[NODES_KEY_DEV] = devmap_handle,
 		[NODES_KEY_INDEX] = index
 	};
@@ -651,5 +651,5 @@
 void tmpfs_truncate(ipc_callid_t rid, 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);
 	aoff64_t size =
@@ -660,5 +660,5 @@
 	 */
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle,
+		[NODES_KEY_DEV] = devmap_handle,
 		[NODES_KEY_INDEX] = index
 	};
@@ -704,5 +704,5 @@
 void tmpfs_destroy(ipc_callid_t rid, 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);
 	int rc;
@@ -710,5 +710,5 @@
 	link_t *hlp;
 	unsigned long key[] = {
-		[NODES_KEY_DEV] = dev_handle,
+		[NODES_KEY_DEV] = devmap_handle,
 		[NODES_KEY_INDEX] = index
 	};
Index: uspace/srv/hid/adb_mouse/adb_mouse.c
===================================================================
--- uspace/srv/hid/adb_mouse/adb_mouse.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/adb_mouse/adb_mouse.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -78,6 +78,6 @@
 	snprintf(dev_path, DEVMAP_NAME_MAXLEN, "%s/mouse", NAMESPACE);
 
-	dev_handle_t dev_handle;
-	if (devmap_device_register(dev_path, &dev_handle) != EOK) {
+	devmap_handle_t devmap_handle;
+	if (devmap_device_register(dev_path, &devmap_handle) != EOK) {
 		printf(NAME ": Unable to register device %s\n", dev_path);
 		return -1;
Index: uspace/srv/hid/char_mouse/char_mouse.c
===================================================================
--- uspace/srv/hid/char_mouse/char_mouse.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/char_mouse/char_mouse.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -134,6 +134,6 @@
 	snprintf(dev_path, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
 
-	dev_handle_t dev_handle;
-	if (devmap_device_register(dev_path, &dev_handle) != EOK) {
+	devmap_handle_t devmap_handle;
+	if (devmap_device_register(dev_path, &devmap_handle) != EOK) {
 		printf(NAME ": Unable to register device %s\n", dev_path);
 		return -1;
Index: uspace/srv/hid/console/console.c
===================================================================
--- uspace/srv/hid/console/console.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/console/console.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -82,5 +82,5 @@
 	size_t index;             /**< Console index */
 	size_t refcount;          /**< Connection reference count */
-	dev_handle_t dev_handle;  /**< Device handle */
+	devmap_handle_t devmap_handle;  /**< Device handle */
 	keybuffer_t keybuffer;    /**< Buffer for incoming keys. */
 	screenbuffer_t scr;       /**< Screenbuffer for saving screen
@@ -571,5 +571,5 @@
 			continue;
 		
-		if (consoles[i].dev_handle == (dev_handle_t) IPC_GET_ARG1(*icall)) {
+		if (consoles[i].devmap_handle == (devmap_handle_t) IPC_GET_ARG1(*icall)) {
 			cons = &consoles[i];
 			break;
@@ -815,5 +815,5 @@
 			snprintf(vc, DEVMAP_NAME_MAXLEN, "%s/vc%u", NAMESPACE, i);
 			
-			if (devmap_device_register(vc, &consoles[i].dev_handle) != EOK) {
+			if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) {
 				devmap_hangup_phone(DEVMAP_DRIVER);
 				printf(NAME ": Unable to register device %s\n", vc);
Index: uspace/srv/hid/kbd/generic/kbd.c
===================================================================
--- uspace/srv/hid/kbd/generic/kbd.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/kbd/generic/kbd.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -250,6 +250,6 @@
 	snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME);
 	
-	dev_handle_t dev_handle;
-	if (devmap_device_register(kbd, &dev_handle) != EOK) {
+	devmap_handle_t devmap_handle;
+	if (devmap_device_register(kbd, &devmap_handle) != EOK) {
 		printf("%s: Unable to register device %s\n", NAME, kbd);
 		return -1;
Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c
===================================================================
--- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -99,5 +99,5 @@
 		return -1;
 
-	rc = devmap_device_register(NAMESPACE "/mouse", &ts->dev_handle);
+	rc = devmap_device_register(NAMESPACE "/mouse", &ts->devmap_handle);
 	if (rc != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h
===================================================================
--- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -125,5 +125,5 @@
 
 	/** Device handle */
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 
 	/** Device/driver state */
Index: uspace/srv/hw/bus/cuda_adb/cuda_adb.c
===================================================================
--- uspace/srv/hw/bus/cuda_adb/cuda_adb.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/bus/cuda_adb/cuda_adb.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -143,5 +143,5 @@
 int main(int argc, char *argv[])
 {
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 	int rc;
 	int i;
@@ -151,5 +151,5 @@
 	for (i = 0; i < ADB_MAX_ADDR; ++i) {
 		adb_dev[i].client_phone = -1;
-		adb_dev[i].dev_handle = 0;
+		adb_dev[i].devmap_handle = 0;
 	}
 
@@ -160,5 +160,5 @@
 	}
 
-	rc = devmap_device_register("adb/kbd", &dev_handle);
+	rc = devmap_device_register("adb/kbd", &devmap_handle);
 	if (rc != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
@@ -167,8 +167,8 @@
 	}
 
-	adb_dev[2].dev_handle = dev_handle;
-	adb_dev[8].dev_handle = dev_handle;
-
-	rc = devmap_device_register("adb/mouse", &dev_handle);
+	adb_dev[2].devmap_handle = devmap_handle;
+	adb_dev[8].devmap_handle = devmap_handle;
+
+	rc = devmap_device_register("adb/mouse", &devmap_handle);
 	if (rc != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
@@ -177,5 +177,5 @@
 	}
 
-	adb_dev[9].dev_handle = dev_handle;
+	adb_dev[9].devmap_handle = devmap_handle;
 
 	if (cuda_init() < 0) {
@@ -196,5 +196,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int retval;
 	int dev_addr, i;
@@ -206,5 +206,5 @@
 	dev_addr = -1;
 	for (i = 0; i < ADB_MAX_ADDR; i++) {
-		if (adb_dev[i].dev_handle == dh)
+		if (adb_dev[i].devmap_handle == dh)
 			dev_addr = i;
 	}
@@ -237,5 +237,5 @@
 			 */
 			for (i = 0; i < ADB_MAX_ADDR; ++i) {
-				if (adb_dev[i].dev_handle == dh) {
+				if (adb_dev[i].devmap_handle == dh) {
 					adb_dev[i].client_phone = IPC_GET_ARG5(call);
 				}
Index: uspace/srv/hw/bus/cuda_adb/cuda_adb.h
===================================================================
--- uspace/srv/hw/bus/cuda_adb/cuda_adb.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/bus/cuda_adb/cuda_adb.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -104,5 +104,5 @@
 
 typedef struct {
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 	int client_phone;
 } adb_dev_t;
Index: uspace/srv/hw/char/i8042/i8042.c
===================================================================
--- uspace/srv/hw/char/i8042/i8042.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/char/i8042/i8042.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -145,5 +145,5 @@
 
 		snprintf(name, 16, "%s/ps2%c", NAMESPACE, dchar[i]);
-		rc = devmap_device_register(name, &i8042_port[i].dev_handle);
+		rc = devmap_device_register(name, &i8042_port[i].devmap_handle);
 		if (rc != EOK) {
 			devmap_hangup_phone(DEVMAP_DRIVER);
@@ -218,5 +218,5 @@
 	ipc_call_t call;
 	ipcarg_t method;
-	dev_handle_t dh;
+	devmap_handle_t dh;
 	int retval;
 	int dev_id, i;
@@ -230,5 +230,5 @@
 	dev_id = -1;
 	for (i = 0; i < MAX_DEVS; i++) {
-		if (i8042_port[i].dev_handle == dh)
+		if (i8042_port[i].devmap_handle == dh)
 			dev_id = i;
 	}
Index: uspace/srv/hw/char/i8042/i8042.h
===================================================================
--- uspace/srv/hw/char/i8042/i8042.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/char/i8042/i8042.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -52,5 +52,5 @@
 /** Softstate structure, one for each serial port (primary and aux). */
 typedef struct {
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 	int client_phone;
 } i8042_port_t;
Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c
===================================================================
--- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -92,5 +92,5 @@
 		return -1;
 
-	rc = devmap_device_register(NAMESPACE "/" NAME, &uart->dev_handle);
+	rc = devmap_device_register(NAMESPACE "/" NAME, &uart->devmap_handle);
 	if (rc != EOK) {
 		devmap_hangup_phone(DEVMAP_DRIVER);
Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h
===================================================================
--- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -88,5 +88,5 @@
 
 	/** Device handle */
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 } s3c24xx_uart_t;
 
Index: uspace/srv/vfs/vfs.h
===================================================================
--- uspace/srv/vfs/vfs.h	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/vfs/vfs.h	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -62,5 +62,5 @@
 #define VFS_PAIR \
 	fs_handle_t fs_handle; \
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 
 /**
@@ -68,5 +68,5 @@
  * doesn't contain any state. For a stateful structure, see vfs_node_t.
  *
- * @note	fs_handle, dev_handle and index are meant to be returned in one
+ * @note	fs_handle, devmap_handle and index are meant to be returned in one
  *		IPC reply.
  */
@@ -182,5 +182,5 @@
 extern void vfs_node_put(vfs_node_t *);
 extern void vfs_node_forget(vfs_node_t *);
-extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, dev_handle_t);
+extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, devmap_handle_t);
 
 
Index: uspace/srv/vfs/vfs_lookup.c
===================================================================
--- uspace/srv/vfs/vfs_lookup.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/vfs/vfs_lookup.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -163,5 +163,5 @@
 	aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (ipcarg_t) first,
 	    (ipcarg_t) (first + len - 1) % PLB_SIZE,
-	    (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
+	    (ipcarg_t) root->devmap_handle, (ipcarg_t) lflag, (ipcarg_t) index,
 	    &answer);
 	
@@ -183,5 +183,5 @@
 	
 	result->triplet.fs_handle = (fs_handle_t) rc;
-	result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG1(answer);
+	result->triplet.devmap_handle = (devmap_handle_t) IPC_GET_ARG1(answer);
 	result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
 	result->size =
@@ -210,5 +210,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE,
-	    (ipcarg_t) result->triplet.dev_handle,
+	    (ipcarg_t) result->triplet.devmap_handle,
 	    (ipcarg_t) result->triplet.index, &answer);
 	
Index: uspace/srv/vfs/vfs_node.c
===================================================================
--- uspace/srv/vfs/vfs_node.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/vfs/vfs_node.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -113,5 +113,5 @@
 		unsigned long key[] = {
 			[KEY_FS_HANDLE] = node->fs_handle,
-			[KEY_DEV_HANDLE] = node->dev_handle,
+			[KEY_DEV_HANDLE] = node->devmap_handle,
 			[KEY_INDEX] = node->index
 		};
@@ -131,5 +131,5 @@
 		ipcarg_t rc;
 		rc = async_req_2_0(phone, VFS_OUT_DESTROY,
-		    (ipcarg_t)node->dev_handle, (ipcarg_t)node->index);
+		    (ipcarg_t)node->devmap_handle, (ipcarg_t)node->index);
 		assert(rc == EOK);
 		vfs_release_phone(node->fs_handle, phone);
@@ -151,5 +151,5 @@
 	unsigned long key[] = {
 		[KEY_FS_HANDLE] = node->fs_handle,
-		[KEY_DEV_HANDLE] = node->dev_handle,
+		[KEY_DEV_HANDLE] = node->devmap_handle,
 		[KEY_INDEX] = node->index
 	};
@@ -175,5 +175,5 @@
 	unsigned long key[] = {
 		[KEY_FS_HANDLE] = result->triplet.fs_handle,
-		[KEY_DEV_HANDLE] = result->triplet.dev_handle,
+		[KEY_DEV_HANDLE] = result->triplet.devmap_handle,
 		[KEY_INDEX] = result->triplet.index
 	};
@@ -191,5 +191,5 @@
 		memset(node, 0, sizeof(vfs_node_t));
 		node->fs_handle = result->triplet.fs_handle;
-		node->dev_handle = result->triplet.dev_handle;
+		node->devmap_handle = result->triplet.devmap_handle;
 		node->index = result->triplet.index;
 		node->size = result->size;
@@ -243,5 +243,5 @@
 	vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
 	return (node->fs_handle == (fs_handle_t) key[KEY_FS_HANDLE]) &&
-	    (node->dev_handle == key[KEY_DEV_HANDLE]) &&
+	    (node->devmap_handle == key[KEY_DEV_HANDLE]) &&
 	    (node->index == key[KEY_INDEX]);
 }
@@ -255,5 +255,5 @@
 	unsigned refcnt;
 	fs_handle_t fs_handle;
-	dev_handle_t dev_handle;
+	devmap_handle_t devmap_handle;
 };
 
@@ -264,15 +264,15 @@
 
 	if ((node->fs_handle == rd->fs_handle) &&
-	    (node->dev_handle == rd->dev_handle))
+	    (node->devmap_handle == rd->devmap_handle))
 		rd->refcnt += node->refcnt;
 }
 
 unsigned
-vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, dev_handle_t dev_handle)
+vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle)
 {
 	struct refcnt_data rd = {
 		.refcnt = 0,
 		.fs_handle = fs_handle,
-		.dev_handle = dev_handle
+		.devmap_handle = devmap_handle
 	};
 
Index: uspace/srv/vfs/vfs_ops.c
===================================================================
--- uspace/srv/vfs/vfs_ops.c	(revision 51a268fab894643a3bf8b035bc059e58759a3a53)
+++ uspace/srv/vfs/vfs_ops.c	(revision 45f04f8e21a1ba7e8ffebce4a63eff34021f179a)
@@ -55,5 +55,5 @@
 
 /* Forward declarations of static functions. */
-static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, aoff64_t);
+static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t, aoff64_t);
 
 /**
@@ -65,8 +65,8 @@
 vfs_pair_t rootfs = {
 	.fs_handle = 0,
-	.dev_handle = 0
+	.devmap_handle = 0
 };
 
-static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
+static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
     fs_handle_t fs_handle, char *mp, char *opts)
 {
@@ -125,5 +125,5 @@
 			phone = vfs_grab_phone(fs_handle);
 			msg = async_send_1(phone, VFS_OUT_MOUNTED,
-			    (ipcarg_t) dev_handle, &answer);
+			    (ipcarg_t) devmap_handle, &answer);
 			/* send the mount options */
 			rc = async_data_write_start(phone, (void *)opts,
@@ -150,5 +150,5 @@
 			
 			mr_res.triplet.fs_handle = fs_handle;
-			mr_res.triplet.dev_handle = dev_handle;
+			mr_res.triplet.devmap_handle = devmap_handle;
 			mr_res.triplet.index = rindex;
 			mr_res.size = rsize;
@@ -157,5 +157,5 @@
 			
 			rootfs.fs_handle = fs_handle;
-			rootfs.dev_handle = dev_handle;
+			rootfs.devmap_handle = devmap_handle;
 			
 			/* Add reference to the mounted root. */
@@ -187,8 +187,8 @@
 	phone = vfs_grab_phone(mp_res.triplet.fs_handle);
 	msg = async_send_4(phone, VFS_OUT_MOUNT,
-	    (ipcarg_t) mp_res.triplet.dev_handle,
+	    (ipcarg_t) mp_res.triplet.devmap_handle,
 	    (ipcarg_t) mp_res.triplet.index,
 	    (ipcarg_t) fs_handle,
-	    (ipcarg_t) dev_handle, &answer);
+	    (ipcarg_t) devmap_handle, &answer);
 	
 	/* send connection */
@@ -229,5 +229,5 @@
 	
 		mr_res.triplet.fs_handle = fs_handle;
-		mr_res.triplet.dev_handle = dev_handle;
+		mr_res.triplet.devmap_handle = devmap_handle;
 		mr_res.triplet.index = rindex;
 		mr_res.size = rsize;
@@ -255,5 +255,5 @@
 	 * in the 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);
 	
 	/*
@@ -343,5 +343,5 @@
 	
 	/* Do the mount */
-	vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
+	vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
 	free(mp);
 	free(fs_name);
@@ -402,5 +402,5 @@
 	 */
 	if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
-	    mr_node->dev_handle) != 2) {
+	    mr_node->devmap_handle) != 2) {
 		fibril_rwlock_write_unlock(&namespace_rwlock);
 		vfs_node_put(mr_node);
@@ -422,5 +422,5 @@
 		phone = vfs_grab_phone(mr_node->fs_handle);
 		rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
-		    mr_node->dev_handle);
+		    mr_node->devmap_handle);
 		vfs_release_phone(mr_node->fs_handle, phone);
 		if (rc != EOK) {
@@ -431,5 +431,5 @@
 		}
 		rootfs.fs_handle = 0;
-		rootfs.dev_handle = 0;
+		rootfs.devmap_handle = 0;
 	} else {
 
@@ -458,5 +458,5 @@
 
 		phone = vfs_grab_phone(mp_node->fs_handle);
-		rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle,
+		rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->devmap_handle,
 		    mp_node->index);
 		vfs_release_phone(mp_node->fs_handle, phone);
@@ -569,5 +569,5 @@
 		if (node->size) {
 			rc = vfs_truncate_internal(node->fs_handle,
-			    node->dev_handle, node->index, 0);
+			    node->devmap_handle, node->index, 0);
 			if (rc) {
 				fibril_rwlock_write_unlock(&node->contents_rwlock);
@@ -626,5 +626,5 @@
 	
 	lr.triplet.fs_handle = IPC_GET_ARG1(*request);
-	lr.triplet.dev_handle = IPC_GET_ARG2(*request);
+	lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
 	lr.triplet.index = IPC_GET_ARG3(*request);
 	int oflag = IPC_GET_ARG4(*request);
@@ -647,5 +647,5 @@
 		if (node->size) {
 			rc = vfs_truncate_internal(node->fs_handle,
-			    node->dev_handle, node->index, 0);
+			    node->devmap_handle, node->index, 0);
 			if (rc) {
 				fibril_rwlock_write_unlock(&node->contents_rwlock);
@@ -709,5 +709,5 @@
 	aid_t msg;
 	ipc_call_t answer;
-	msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
+	msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
 	    file->node->index, &answer);
 
@@ -740,5 +740,5 @@
 		aid_t msg;
 		ipc_call_t answer;
-		msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
+		msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->devmap_handle,
 		    file->node->index, &answer);
 		
@@ -838,9 +838,9 @@
 		
 		rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
-		    file->node->dev_handle, file->node->index, file->pos,
+		    file->node->devmap_handle, file->node->index, file->pos,
 		    &answer);
 	} else {
 		rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
-		    file->node->dev_handle, file->node->index, file->pos,
+		    file->node->devmap_handle, file->node->index, file->pos,
 		    &answer);
 	}
@@ -961,5 +961,5 @@
 }
 
-int vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
+int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     fs_index_t index, aoff64_t size)
 {
@@ -968,5 +968,5 @@
 	
 	fs_phone = vfs_grab_phone(fs_handle);
-	rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) dev_handle,
+	rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle,
 	    (ipcarg_t) index, LOWER32(size), UPPER32(size));
 	vfs_release_phone(fs_handle, fs_phone);
@@ -990,5 +990,5 @@
 	fibril_rwlock_write_lock(&file->node->contents_rwlock);
 	rc = vfs_truncate_internal(file->node->fs_handle,
-	    file->node->dev_handle, file->node->index, size);
+	    file->node->devmap_handle, file->node->index, size);
 	if (rc == EOK)
 		file->node->size = size;
@@ -1022,5 +1022,5 @@
 	
 	aid_t msg;
-	msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
+	msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
 	    file->node->index, true, NULL);
 	ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -1071,5 +1071,5 @@
 	int fs_phone = vfs_grab_phone(node->fs_handle);
 	aid_t msg;
-	msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
+	msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
 	    node->index, false, NULL);
 	ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -1245,5 +1245,5 @@
 	/* Check whether linking to the same file system instance. */
 	if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
-	    (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
+	    (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
 		fibril_rwlock_write_unlock(&namespace_rwlock);
 		ipc_answer_0(rid, EXDEV);	/* different file systems */
