Changeset 16dc887 in mainline for uspace/srv/fs

Timestamp:

2011-08-16T14:00:32Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

278ac72, b112055

Parents:

3751a08 (diff), cc574511 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge Location service.

Location:

uspace/srv/fs

Files:

• ext2fs/ext2fs_ops.c (modified) (26 diffs)
• fat/fat.h (modified) (3 diffs)
• fat/fat_fat.c (modified) (39 diffs)
• fat/fat_fat.h (modified) (2 diffs)
• fat/fat_idx.c (modified) (33 diffs)
• fat/fat_ops.c (modified) (47 diffs)
• locfs/Makefile (moved) (moved from uspace/srv/fs/devfs/Makefile ) (1 diff)
• locfs/locfs.c (moved) (moved from uspace/srv/fs/devfs/devfs.c ) (4 diffs)
• locfs/locfs.h (moved) (moved from uspace/srv/fs/devfs/devfs.h ) (1 diff)
• locfs/locfs_ops.c (moved) (moved from uspace/srv/fs/devfs/devfs_ops.c ) (39 diffs)
• locfs/locfs_ops.h (moved) (moved from uspace/srv/fs/devfs/devfs_ops.h ) (1 diff)
• tmpfs/tmpfs.h (modified) (2 diffs)
• tmpfs/tmpfs_dump.c (modified) (13 diffs)
• tmpfs/tmpfs_ops.c (modified) (24 diffs)

uspace/srv/fs/ext2fs/ext2fs_ops.c

@@ -42 +42 @@
 #include <libext2.h>
 #include <ipc/services.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <macros.h>
 #include <async.h>
@@ -69 +69 @@
 typedef struct ext2fs_instance {
         link_t link;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
         ext2_filesystem_t *filesystem;
         unsigned int open_nodes_count;
@@ -85 +85 @@
  * Forward declarations of auxiliary functions
  */
-static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_t **);
+static int ext2fs_instance_get(service_id_t, ext2fs_instance_t **);
 static int ext2fs_read_directory(ipc_callid_t, aoff64_t, size_t,
     ext2fs_instance_t *, ext2_inode_ref_t *, size_t *);
@@ -97 +97 @@
  * Forward declarations of EXT2 libfs operations.
  */
-static int ext2fs_root_get(fs_node_t **, devmap_handle_t);
+static int ext2fs_root_get(fs_node_t **, service_id_t);
 static int ext2fs_match(fs_node_t **, fs_node_t *, const char *);
-static int ext2fs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
+static int ext2fs_node_get(fs_node_t **, service_id_t, fs_index_t);
 static int ext2fs_node_open(fs_node_t *);
 static int ext2fs_node_put(fs_node_t *);
-static int ext2fs_create_node(fs_node_t **, devmap_handle_t, int);
+static int ext2fs_create_node(fs_node_t **, service_id_t, int);
 static int ext2fs_destroy_node(fs_node_t *);
 static int ext2fs_link(fs_node_t *, fs_node_t *, const char *);
@@ -112 +112 @@
 static bool ext2fs_is_directory(fs_node_t *);
 static bool ext2fs_is_file(fs_node_t *node);
-static devmap_handle_t ext2fs_device_get(fs_node_t *node);
+static service_id_t ext2fs_device_get(fs_node_t *node);
 
 /*
@@ -134 +134 @@
         ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
         assert(keys > 0);
-        if (enode->instance->devmap_handle !=
-            ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
+        if (enode->instance->service_id !=
+            ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
                 return false;
         }
@@ -180 +180 @@
 
 /**
- * Find an instance of filesystem for the given devmap_handle
- */
-int ext2fs_instance_get(devmap_handle_t devmap_handle, ext2fs_instance_t **inst)
-{
-        EXT2FS_DBG("(%" PRIun ", -)", devmap_handle);
+ * Find an instance of filesystem for the given service_id
+ */
+int ext2fs_instance_get(service_id_t service_id, ext2fs_instance_t **inst)
+{
+        EXT2FS_DBG("(%" PRIun ", -)", service_id);
         ext2fs_instance_t *tmp;
         
@@ -198 +198 @@
                 tmp = list_get_instance(link, ext2fs_instance_t, link);
                 
-                if (tmp->devmap_handle == devmap_handle) {
+                if (tmp->service_id == service_id) {
                         *inst = tmp;
                         fibril_mutex_unlock(&instance_list_mutex);
@@ -213 +213 @@
 
 
-int ext2fs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
-{
-        EXT2FS_DBG("(-, %" PRIun ")", devmap_handle);
-        return ext2fs_node_get(rfn, devmap_handle, EXT2_INODE_ROOT_INDEX);
+int ext2fs_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+        EXT2FS_DBG("(-, %" PRIun ")", service_id);
+        return ext2fs_node_get(rfn, service_id, EXT2_INODE_ROOT_INDEX);
 }
 
@@ -289 +289 @@
 
 /** Instantiate a EXT2 in-core node. */
-int ext2fs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
-{
-        EXT2FS_DBG("(-,%" PRIun ",%u)", devmap_handle, index);
+int ext2fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
+{
+        EXT2FS_DBG("(-,%" PRIun ",%u)", service_id, index);
         
         ext2fs_instance_t *inst = NULL;
         int rc;
         
-        rc = ext2fs_instance_get(devmap_handle, &inst);
+        rc = ext2fs_instance_get(service_id, &inst);
         if (rc != EOK) {
                 return rc;
@@ -317 +317 @@
         /* Check if the node is not already open */
         unsigned long key[] = {
-                [OPEN_NODES_DEV_HANDLE_KEY] = inst->devmap_handle,
+                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
                 [OPEN_NODES_INODE_KEY] = index,
         };
@@ -411 +411 @@
 
         unsigned long key[] = {
-                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->devmap_handle,
+                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
                 [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
         };
@@ -429 +429 @@
 }
 
-int ext2fs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
+int ext2fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
         EXT2FS_DBG("");
@@ -557 +557 @@
 }
 
-devmap_handle_t ext2fs_device_get(fs_node_t *fn)
+service_id_t ext2fs_device_get(fs_node_t *fn)
 {
         EXT2FS_DBG("");
         ext2fs_node_t *enode = EXT2FS_NODE(fn);
-        return enode->instance->devmap_handle;
+        return enode->instance->service_id;
 }
 
@@ -588 +588 @@
  */
 
-static int ext2fs_mounted(devmap_handle_t devmap_handle, const char *opts,
+static int ext2fs_mounted(service_id_t service_id, const char *opts,
    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
 {
@@ -610 +610 @@
         
         /* Initialize the filesystem  */
-        rc = ext2_filesystem_init(fs, devmap_handle);
+        rc = ext2_filesystem_init(fs, service_id);
         if (rc != EOK) {
                 free(fs);
@@ -637 +637 @@
         /* Initialize instance */
         link_initialize(&inst->link);
-        inst->devmap_handle = devmap_handle;
+        inst->service_id = service_id;
         inst->filesystem = fs;
         inst->open_nodes_count = 0;
@@ -666 +666 @@
 }
 
-static int ext2fs_unmounted(devmap_handle_t devmap_handle)
+static int ext2fs_unmounted(service_id_t service_id)
 {
         EXT2FS_DBG("");
@@ -672 +672 @@
         int rc;
         
-        rc = ext2fs_instance_get(devmap_handle, &inst);
+        rc = ext2fs_instance_get(service_id, &inst);
         
         if (rc != EOK)
@@ -698 +698 @@
 
 static int
-ext2fs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+ext2fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -717 +717 @@
         }
         
-        rc = ext2fs_instance_get(devmap_handle, &inst);
+        rc = ext2fs_instance_get(service_id, &inst);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
@@ -907 +907 @@
         
         /* Usual case - we need to read a block from device */
-        rc = block_get(&block, inst->devmap_handle, fs_block, BLOCK_FLAGS_NONE);
+        rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
@@ -925 +925 @@
 
 static int
-ext2fs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+ext2fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -933 +933 @@
 
 static int
-ext2fs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
+ext2fs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
 {
         EXT2FS_DBG("");
@@ -939 +939 @@
 }
 
-static int ext2fs_close(devmap_handle_t devmap_handle, fs_index_t index)
-{
-        EXT2FS_DBG("");
-        return EOK;
-}
-
-static int ext2fs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
+static int ext2fs_close(service_id_t service_id, fs_index_t index)
+{
+        EXT2FS_DBG("");
+        return EOK;
+}
+
+static int ext2fs_destroy(service_id_t service_id, fs_index_t index)
 {
         EXT2FS_DBG("");
@@ -951 +951 @@
 }
 
-static int ext2fs_sync(devmap_handle_t devmap_handle, fs_index_t index)
+static int ext2fs_sync(service_id_t service_id, fs_index_t index)
 {
         EXT2FS_DBG("");

uspace/srv/fs/fat/fat.h

@@ -175 +175 @@
 
         fibril_mutex_t  lock;
-        devmap_handle_t devmap_handle;
+        service_id_t    service_id;
         fs_index_t      index;
         /**
@@ -227 +227 @@
 extern libfs_ops_t fat_libfs_ops;
 
-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 int fat_idx_get_new(fat_idx_t **, service_id_t);
+extern fat_idx_t *fat_idx_get_by_pos(service_id_t, fat_cluster_t, unsigned);
+extern fat_idx_t *fat_idx_get_by_index(service_id_t, fs_index_t);
 extern void fat_idx_destroy(fat_idx_t *);
 extern void fat_idx_hashin(fat_idx_t *);
@@ -236 +236 @@
 extern int fat_idx_init(void);
 extern void fat_idx_fini(void);
-extern int fat_idx_init_by_devmap_handle(devmap_handle_t);
-extern void fat_idx_fini_by_devmap_handle(devmap_handle_t);
+extern int fat_idx_init_by_service_id(service_id_t);
+extern void fat_idx_fini_by_service_id(service_id_t);
 
 #endif

uspace/srv/fs/fat/fat_fat.c

@@ -71 +71 @@
  *
  * @param bs            Buffer holding the boot sector for the file.
- * @param devmap_handle Device handle of the device with the file.
+ * @param service_id    Service ID 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
@@ -82 +82 @@
  */
 int 
-fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc,
+fat_cluster_walk(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc,
     fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
 {
@@ -109 +109 @@
                 fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
                 /* read FAT1 */
-                rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec,
+                rc = block_get(&b, service_id, RSCNT(bs) + fsec,
                     BLOCK_FLAGS_NONE);
                 if (rc != EOK)
@@ -160 +160 @@
                  * when fortunately we have the last cluster number cached.
                  */
-                return block_get(block, nodep->idx->devmap_handle,
+                return block_get(block, nodep->idx->service_id,
                     CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
         }
@@ -174 +174 @@
 
 fall_through:
-        rc = _fat_block_get(block, bs, nodep->idx->devmap_handle, firstc,
+        rc = _fat_block_get(block, bs, nodep->idx->service_id, firstc,
             &currc, relbn, flags);
         if (rc != EOK)
@@ -193 +193 @@
  * @param block         Pointer to a block pointer for storing result.
  * @param bs            Buffer holding the boot sector of the file system.
- * @param devmap_handle Device handle of the file system.
+ * @param service_id    Service ID handle of the file system.
  * @param fcl           First cluster used by the file. Can be zero if the file
  *                      is empty.
@@ -205 +205 @@
  */
 int
-_fat_block_get(block_t **block, fat_bs_t *bs, devmap_handle_t devmap_handle,
+_fat_block_get(block_t **block, fat_bs_t *bs, service_id_t service_id,
     fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
 {
@@ -222 +222 @@
                 /* root directory special case */
                 assert(bn < RDS(bs));
-                rc = block_get(block, devmap_handle,
+                rc = block_get(block, service_id,
                     RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
                 return rc;
@@ -228 +228 @@
 
         max_clusters = bn / SPC(bs);
-        rc = fat_cluster_walk(bs, devmap_handle, fcl, &c, &clusters, max_clusters);
+        rc = fat_cluster_walk(bs, service_id, fcl, &c, &clusters, max_clusters);
         if (rc != EOK)
                 return rc;
         assert(clusters == max_clusters);
 
-        rc = block_get(block, devmap_handle, CLBN2PBN(bs, c, bn), flags);
+        rc = block_get(block, service_id, CLBN2PBN(bs, c, bn), flags);
 
         if (clp)
@@ -281 +281 @@
         /* 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->devmap_handle, mcl,
+                rc = _fat_block_get(&b, bs, nodep->idx->service_id, mcl,
                     NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
                 if (rc != EOK)
@@ -298 +298 @@
  *
  * @param bs            Buffer holding the boot sector for the file system.
- * @param devmap_handle Device handle for the file system.
+ * @param service_id    Service ID for the file system.
  * @param clst          Cluster which to get.
  * @param value         Output argument holding the value of the cluster.
@@ -305 +305 @@
  */
 int
-fat_get_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
+fat_get_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t *value)
 {
@@ -312 +312 @@
         int rc;
 
-        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
             (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
@@ -327 +327 @@
  *
  * @param bs            Buffer holding the boot sector for the file system.
- * @param devmap_handle Device handle for the file system.
+ * @param service_id    Device service ID for the file system.
  * @param fatno         Number of the FAT instance where to make the change.
  * @param clst          Cluster which is to be set.
@@ -335 +335 @@
  */
 int
-fat_set_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno,
+fat_set_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t value)
 {
@@ -343 +343 @@
 
         assert(fatno < FATCNT(bs));
-        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
             (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
@@ -358 +358 @@
  *
  * @param bs            Buffer holding the boot sector of the file system.
- * @param devmap_handle Device handle of the file system.
+ * @param service_id    Service ID of the file system.
  * @param lifo          Chain of allocated clusters.
  * @param nclsts        Number of clusters in the lifo chain.
@@ -364 +364 @@
  * @return              EOK on success or a negative error code.
  */
-int fat_alloc_shadow_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle,
+int fat_alloc_shadow_clusters(fat_bs_t *bs, service_id_t service_id,
     fat_cluster_t *lifo, unsigned nclsts)
 {
@@ -373 +373 @@
         for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
                 for (c = 0; c < nclsts; c++) {
-                        rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c],
+                        rc = fat_set_cluster(bs, service_id, fatno, lifo[c],
                             c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
                         if (rc != EOK)
@@ -391 +391 @@
  *
  * @param bs            Buffer holding the boot sector of the file system.
- * @param devmap_handle Device handle of the file system.
+ * @param service_id    Device service ID of the file system.
  * @param nclsts        Number of clusters to allocate.
  * @param mcl           Output parameter where the first cluster in the chain
@@ -401 +401 @@
  */
 int
-fat_alloc_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned nclsts,
+fat_alloc_clusters(fat_bs_t *bs, service_id_t service_id, unsigned nclsts,
     fat_cluster_t *mcl, fat_cluster_t *lcl)
 {
@@ -419 +419 @@
         fibril_mutex_lock(&fat_alloc_lock);
         for (b = 0, cl = 0; b < SF(bs); b++) {
-                rc = block_get(&blk, devmap_handle, RSCNT(bs) + b,
+                rc = block_get(&blk, service_id, RSCNT(bs) + b,
                     BLOCK_FLAGS_NONE);
                 if (rc != EOK)
@@ -458 +458 @@
                                         /* update the shadow copies of FAT */
                                         rc = fat_alloc_shadow_clusters(bs,
-                                            devmap_handle, lifo, nclsts);
+                                            service_id, lifo, nclsts);
                                         if (rc != EOK)
                                                 goto error;
@@ -485 +485 @@
          */
         while (found--) {
-                rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found],
+                rc = fat_set_cluster(bs, service_id, FAT1, lifo[found],
                     FAT_CLST_RES0);
                 if (rc != EOK) {
@@ -500 +500 @@
  *
  * @param bs            Buffer hodling the boot sector of the file system.
- * @param devmap_handle Device handle of the file system.
+ * @param service_id    Device service ID of the file system.
  * @param firstc        First cluster in the chain which is to be freed.
  *
@@ -506 +506 @@
  */
 int
-fat_free_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc)
+fat_free_clusters(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc)
 {
         unsigned fatno;
@@ -515 +515 @@
         while (firstc < FAT_CLST_LAST1) {
                 assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
-                rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc);
+                rc = fat_get_cluster(bs, service_id, FAT1, firstc, &nextc);
                 if (rc != EOK)
                         return rc;
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, devmap_handle, fatno, firstc,
+                        rc = fat_set_cluster(bs, service_id, fatno, firstc,
                             FAT_CLST_RES0);
                         if (rc != EOK)
@@ -544 +544 @@
     fat_cluster_t lcl)
 {
-        devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
+        service_id_t service_id = nodep->idx->service_id;
         fat_cluster_t lastc;
         uint8_t fatno;
@@ -558 +558 @@
                         nodep->lastc_cached_valid = false;
                 } else {
-                        rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
+                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
                             &lastc, NULL, (uint16_t) -1);
                         if (rc != EOK)
@@ -565 +565 @@
 
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno,
+                        rc = fat_set_cluster(bs, nodep->idx->service_id, fatno,
                             lastc, mcl);
                         if (rc != EOK)
@@ -591 +591 @@
 {
         int rc;
-        devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
+        service_id_t service_id = nodep->idx->service_id;
 
         /*
@@ -602 +602 @@
         if (lcl == FAT_CLST_RES0) {
                 /* The node will have zero size and no clusters allocated. */
-                rc = fat_free_clusters(bs, devmap_handle, nodep->firstc);
+                rc = fat_free_clusters(bs, service_id, nodep->firstc);
                 if (rc != EOK)
                         return rc;
@@ -611 +611 @@
                 unsigned fatno;
 
-                rc = fat_get_cluster(bs, devmap_handle, FAT1, lcl, &nextc);
+                rc = fat_get_cluster(bs, service_id, FAT1, lcl, &nextc);
                 if (rc != EOK)
                         return rc;
@@ -617 +617 @@
                 /* Terminate the cluster chain in all copies of FAT. */
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, devmap_handle, fatno, lcl,
+                        rc = fat_set_cluster(bs, service_id, fatno, lcl,
                             FAT_CLST_LAST1);
                         if (rc != EOK)
@@ -624 +624 @@
 
                 /* Free all following clusters. */
-                rc = fat_free_clusters(bs, devmap_handle, nextc);
+                rc = fat_free_clusters(bs, service_id, nextc);
                 if (rc != EOK)
                         return rc;
@@ -639 +639 @@
 
 int
-fat_zero_cluster(struct fat_bs *bs, devmap_handle_t devmap_handle, fat_cluster_t c)
+fat_zero_cluster(struct fat_bs *bs, service_id_t service_id, fat_cluster_t c)
 {
         int i;
@@ -646 +646 @@
 
         for (i = 0; i < SPC(bs); i++) {
-                rc = _fat_block_get(&b, bs, devmap_handle, c, NULL, i,
+                rc = _fat_block_get(&b, bs, service_id, c, NULL, i,
                     BLOCK_FLAGS_NOREAD);
                 if (rc != EOK)
@@ -666 +666 @@
  * does not contain a fat file system.
  */
-int fat_sanity_check(fat_bs_t *bs, devmap_handle_t devmap_handle)
+int fat_sanity_check(fat_bs_t *bs, service_id_t service_id)
 {
         fat_cluster_t e0, e1;
@@ -707 +707 @@
 
         for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) {
-                rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0);
+                rc = fat_get_cluster(bs, service_id, fat_no, 0, &e0);
                 if (rc != EOK)
                         return EIO;
 
-                rc = fat_get_cluster(bs, devmap_handle, fat_no, 1, &e1);
+                rc = fat_get_cluster(bs, service_id, fat_no, 1, &e1);
                 if (rc != EOK)
                         return EIO;

uspace/srv/fs/fat/fat_fat.h

@@ -61 +61 @@
 #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 *, devmap_handle_t, fat_cluster_t,
+extern int fat_cluster_walk(struct fat_bs *, service_id_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 *, devmap_handle_t,
+extern int _fat_block_get(block_t **, struct fat_bs *, service_id_t,
     fat_cluster_t, fat_cluster_t *, aoff64_t, int);
 
@@ -73 +73 @@
 extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
     fat_cluster_t);
-extern int fat_alloc_clusters(struct fat_bs *, devmap_handle_t, unsigned,
+extern int fat_alloc_clusters(struct fat_bs *, service_id_t, unsigned,
     fat_cluster_t *, fat_cluster_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,
+extern int fat_free_clusters(struct fat_bs *, service_id_t, fat_cluster_t);
+extern int fat_alloc_shadow_clusters(struct fat_bs *, service_id_t,
     fat_cluster_t *, unsigned);
-extern int fat_get_cluster(struct fat_bs *, devmap_handle_t, unsigned,
+extern int fat_get_cluster(struct fat_bs *, service_id_t, unsigned,
     fat_cluster_t, fat_cluster_t *);
-extern int fat_set_cluster(struct fat_bs *, devmap_handle_t, unsigned,
+extern int fat_set_cluster(struct fat_bs *, service_id_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 *, devmap_handle_t, fat_cluster_t);
-extern int fat_sanity_check(struct fat_bs *, devmap_handle_t);
+extern int fat_zero_cluster(struct fat_bs *, service_id_t, fat_cluster_t);
+extern int fat_sanity_check(struct fat_bs *, service_id_t);
 
 #endif

uspace/srv/fs/fat/fat_idx.c

@@ -59 +59 @@
 typedef struct {
         link_t          link;
-        devmap_handle_t devmap_handle;
+        service_id_t    service_id;
 
         /** Next unassigned index. */
@@ -76 +76 @@
 static LIST_INITIALIZE(unused_list);
 
-static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
+static void unused_initialize(unused_t *u, service_id_t service_id)
 {
         link_initialize(&u->link);
-        u->devmap_handle = devmap_handle;
+        u->service_id = service_id;
         u->next = 0;
         u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
@@ -85 +85 @@
 }
 
-static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock)
+static unused_t *unused_find(service_id_t service_id, bool lock)
 {
         unused_t *u;
@@ -94 +94 @@
         list_foreach(unused_list, l) {
                 u = list_get_instance(l, unused_t, link);
-                if (u->devmap_handle == devmap_handle) 
+                if (u->service_id == service_id) 
                         return u;
         }
@@ -108 +108 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the devmap_handle, parent node's first
+ * The index structures are hashed by the service_id, parent node's first
  * cluster and index within the parent directory.
  */ 
@@ -122 +122 @@
 static hash_index_t pos_hash(unsigned long key[])
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
         fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
         unsigned pdi = (unsigned)key[UPH_PDI_KEY];
@@ -142 +142 @@
         h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
             (UPH_BUCKETS_LOG / 2); 
-        h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
+        h |= (service_id & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
             (3 * (UPH_BUCKETS_LOG / 4));
 
@@ -150 +150 @@
 static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
         fat_cluster_t pfc;
         unsigned pdi;
@@ -157 +157 @@
         switch (keys) {
         case 1:
-                return (devmap_handle == fidx->devmap_handle);
+                return (service_id == fidx->service_id);
         case 3:
                 pfc = (fat_cluster_t) key[UPH_PFC_KEY];
                 pdi = (unsigned) key[UPH_PDI_KEY];
-                return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) &&
+                return (service_id == fidx->service_id) && (pfc == fidx->pfc) &&
                     (pdi == fidx->pdi);
         default:
@@ -183 +183 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the devmap_handle and index.
+ * The index structures are hashed by the service_id and index.
  */
 static hash_table_t ui_hash;
@@ -195 +195 @@
 static hash_index_t idx_hash(unsigned long key[])
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
         fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
 
         hash_index_t h;
 
-        h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
+        h = service_id & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
         h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) <<
             (UIH_BUCKETS_LOG / 2);
@@ -209 +209 @@
 static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
         fs_index_t index;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
@@ -215 +215 @@
         switch (keys) {
         case 1:
-                return (devmap_handle == fidx->devmap_handle);
+                return (service_id == fidx->service_id);
         case 2:
                 index = (fs_index_t) key[UIH_INDEX_KEY];
-                return (devmap_handle == fidx->devmap_handle) &&
+                return (service_id == fidx->service_id) &&
                     (index == fidx->index);
         default:
@@ -241 +241 @@
 
 /** Allocate a VFS index which is not currently in use. */
-static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index)
+static bool fat_index_alloc(service_id_t service_id, fs_index_t *index)
 {
         unused_t *u;
         
         assert(index);
-        u = unused_find(devmap_handle, true);
+        u = unused_find(service_id, true);
         if (!u)
                 return false;   
@@ -303 +303 @@
 
 /** Free a VFS index, which is no longer in use. */
-static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index)
+static void fat_index_free(service_id_t service_id, fs_index_t index)
 {
         unused_t *u;
 
-        u = unused_find(devmap_handle, true);
+        u = unused_find(service_id, true);
         assert(u);
 
@@ -365 +365 @@
 }
 
-static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
+static int fat_idx_create(fat_idx_t **fidxp, service_id_t service_id)
 {
         fat_idx_t *fidx;
@@ -372 +372 @@
         if (!fidx) 
                 return ENOMEM;
-        if (!fat_index_alloc(devmap_handle, &fidx->index)) {
+        if (!fat_index_alloc(service_id, &fidx->index)) {
                 free(fidx);
                 return ENOSPC;
@@ -380 +380 @@
         link_initialize(&fidx->uih_link);
         fibril_mutex_initialize(&fidx->lock);
-        fidx->devmap_handle = devmap_handle;
+        fidx->service_id = service_id;
         fidx->pfc = FAT_CLST_RES0;      /* no parent yet */
         fidx->pdi = 0;
@@ -389 +389 @@
 }
 
-int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
+int fat_idx_get_new(fat_idx_t **fidxp, service_id_t service_id)
 {
         fat_idx_t *fidx;
@@ -395 +395 @@
 
         fibril_mutex_lock(&used_lock);
-        rc = fat_idx_create(&fidx, devmap_handle);
+        rc = fat_idx_create(&fidx, service_id);
         if (rc != EOK) {
                 fibril_mutex_unlock(&used_lock);
@@ -402 +402 @@
                 
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = devmap_handle,
+                [UIH_DH_KEY] = service_id,
                 [UIH_INDEX_KEY] = fidx->index,
         };
@@ -415 +415 @@
 
 fat_idx_t *
-fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi)
+fat_idx_get_by_pos(service_id_t service_id, fat_cluster_t pfc, unsigned pdi)
 {
         fat_idx_t *fidx;
         link_t *l;
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = devmap_handle,
+                [UPH_DH_KEY] = service_id,
                 [UPH_PFC_KEY] = pfc,
                 [UPH_PDI_KEY] = pdi,
@@ -432 +432 @@
                 int rc;
 
-                rc = fat_idx_create(&fidx, devmap_handle);
+                rc = fat_idx_create(&fidx, service_id);
                 if (rc != EOK) {
                         fibril_mutex_unlock(&used_lock);
@@ -439 +439 @@
                 
                 unsigned long ikey[] = {
-                        [UIH_DH_KEY] = devmap_handle,
+                        [UIH_DH_KEY] = service_id,
                         [UIH_INDEX_KEY] = fidx->index,
                 };
@@ -458 +458 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->devmap_handle,
+                [UPH_DH_KEY] = idx->service_id,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -471 +471 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->devmap_handle,
+                [UPH_DH_KEY] = idx->service_id,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -482 +482 @@
 
 fat_idx_t *
-fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index)
+fat_idx_get_by_index(service_id_t service_id, fs_index_t index)
 {
         fat_idx_t *fidx = NULL;
         link_t *l;
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = devmap_handle,
+                [UIH_DH_KEY] = service_id,
                 [UIH_INDEX_KEY] = index,
         };
@@ -509 +509 @@
 {
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = idx->devmap_handle,
+                [UIH_DH_KEY] = idx->service_id,
                 [UIH_INDEX_KEY] = idx->index,
         };
-        devmap_handle_t devmap_handle = idx->devmap_handle;
+        service_id_t service_id = idx->service_id;
         fs_index_t index = idx->index;
 
@@ -526 +526 @@
         fibril_mutex_unlock(&used_lock);
         /* Release the VFS index. */
-        fat_index_free(devmap_handle, index);
+        fat_index_free(service_id, index);
         /* The index structure itself is freed in idx_remove_callback(). */
 }
@@ -548 +548 @@
 }
 
-int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle)
+int fat_idx_init_by_service_id(service_id_t service_id)
 {
         unused_t *u;
@@ -556 +556 @@
         if (!u)
                 return ENOMEM;
-        unused_initialize(u, devmap_handle);
+        unused_initialize(u, service_id);
         fibril_mutex_lock(&unused_lock);
-        if (!unused_find(devmap_handle, false)) {
+        if (!unused_find(service_id, false)) {
                 list_append(&u->link, &unused_list);
         } else {
@@ -568 +568 @@
 }
 
-void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle)
+void fat_idx_fini_by_service_id(service_id_t service_id)
 {
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = devmap_handle
+                [UIH_DH_KEY] = service_id
         };
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = devmap_handle
+                [UPH_DH_KEY] = service_id
         };
 
@@ -590 +590 @@
          * Free the unused and freed structures for this instance.
          */
-        unused_t *u = unused_find(devmap_handle, true);
+        unused_t *u = unused_find(service_id, true);
         assert(u);
         list_remove(&u->link);

uspace/srv/fs/fat/fat_ops.c

@@ -43 +43 @@
 #include <libblock.h>
 #include <ipc/services.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <macros.h>
 #include <async.h>
@@ -72 +72 @@
  * Forward declarations of FAT libfs operations.
  */
-static int fat_root_get(fs_node_t **, devmap_handle_t);
+static int fat_root_get(fs_node_t **, service_id_t);
 static int fat_match(fs_node_t **, fs_node_t *, const char *);
-static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
+static int fat_node_get(fs_node_t **, service_id_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 **, devmap_handle_t, int);
+static int fat_create_node(fs_node_t **, service_id_t, int);
 static int fat_destroy_node(fs_node_t *);
 static int fat_link(fs_node_t *, fs_node_t *, const char *);
@@ -87 +87 @@
 static bool fat_is_directory(fs_node_t *);
 static bool fat_is_file(fs_node_t *node);
-static devmap_handle_t fat_device_get(fs_node_t *node);
+static service_id_t fat_device_get(fs_node_t *node);
 
 /*
@@ -119 +119 @@
         assert(node->dirty);
 
-        bs = block_bb_get(node->idx->devmap_handle);
+        bs = block_bb_get(node->idx->service_id);
         
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
+        rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
             NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
             BLOCK_FLAGS_NONE);
@@ -144 +144 @@
 }
 
-static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
+static int fat_node_fini_by_service_id(service_id_t service_id)
 {
         fat_node_t *nodep;
@@ -168 +168 @@
                         goto restart;
                 }
-                if (nodep->idx->devmap_handle != devmap_handle) {
+                if (nodep->idx->service_id != service_id) {
                         fibril_mutex_unlock(&nodep->idx->lock);
                         fibril_mutex_unlock(&nodep->lock);
@@ -298 +298 @@
                 return rc;
 
-        bs = block_bb_get(idxp->devmap_handle);
+        bs = block_bb_get(idxp->service_id);
 
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
+        rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL,
             (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK) {
@@ -322 +322 @@
                  */
                 uint16_t clusters;
-                rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
+                rc = fat_clusters_get(&clusters, bs, idxp->service_id,
                     uint16_t_le2host(d->firstc));
                 if (rc != EOK) {
@@ -356 +356 @@
  */
 
-int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
-{
-        return fat_node_get(rfn, devmap_handle, 0);
+int fat_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+        return fat_node_get(rfn, service_id, 0);
 }
 
@@ -369 +369 @@
         unsigned blocks;
         fat_dentry_t *d;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
         block_t *b;
         int rc;
 
         fibril_mutex_lock(&parentp->idx->lock);
-        devmap_handle = parentp->idx->devmap_handle;
+        service_id = parentp->idx->service_id;
         fibril_mutex_unlock(&parentp->idx->lock);
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
         blocks = parentp->size / BPS(bs);
         for (i = 0; i < blocks; i++) {
@@ -402 +402 @@
                                 /* hit */
                                 fat_node_t *nodep;
-                                fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
+                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
                                     parentp->firstc, i * DPS(bs) + j);
                                 if (!idx) {
@@ -435 +435 @@
 
 /** Instantiate a FAT in-core node. */
-int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
+int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
 {
         fat_node_t *nodep;
@@ -441 +441 @@
         int rc;
 
-        idxp = fat_idx_get_by_index(devmap_handle, index);
+        idxp = fat_idx_get_by_index(service_id, index);
         if (!idxp) {
                 *rfn = NULL;
@@ -492 +492 @@
 }
 
-int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
+int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
         fat_idx_t *idxp;
@@ -500 +500 @@
         int rc;
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
         if (flags & L_DIRECTORY) {
                 /* allocate a cluster */
-                rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
+                rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl);
                 if (rc != EOK)
                         return rc;
                 /* populate the new cluster with unused dentries */
-                rc = fat_zero_cluster(bs, devmap_handle, mcl);
+                rc = fat_zero_cluster(bs, service_id, mcl);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, devmap_handle, mcl);
+                        (void) fat_free_clusters(bs, service_id, mcl);
                         return rc;
                 }
@@ -516 +516 @@
         rc = fat_node_get_new(&nodep);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, devmap_handle, mcl);
-                return rc;
-        }
-        rc = fat_idx_get_new(&idxp, devmap_handle);
+                (void) fat_free_clusters(bs, service_id, mcl);
+                return rc;
+        }
+        rc = fat_idx_get_new(&idxp, service_id);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, devmap_handle, mcl);       
+                (void) fat_free_clusters(bs, service_id, mcl);  
                 (void) fat_node_put(FS_NODE(nodep));
                 return rc;
@@ -570 +570 @@
         assert(!has_children);
 
-        bs = block_bb_get(nodep->idx->devmap_handle);
+        bs = block_bb_get(nodep->idx->service_id);
         if (nodep->firstc != FAT_CLST_RES0) {
                 assert(nodep->size);
                 /* Free all clusters allocated to the node. */
-                rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
+                rc = fat_free_clusters(bs, nodep->idx->service_id,
                     nodep->firstc);
         }
@@ -620 +620 @@
         
         fibril_mutex_lock(&parentp->idx->lock);
-        bs = block_bb_get(parentp->idx->devmap_handle);
+        bs = block_bb_get(parentp->idx->service_id);
 
         blocks = parentp->size / BPS(bs);
@@ -659 +659 @@
                 return ENOSPC;
         }
-        rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
+        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl);
         if (rc != EOK) {
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
         }
-        rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
+        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
+                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
@@ -672 +672 @@
         rc = fat_append_clusters(bs, parentp, mcl, lcl);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
+                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
@@ -789 +789 @@
         assert(childp->lnkcnt == 1);
         fibril_mutex_lock(&childp->idx->lock);
-        bs = block_bb_get(childp->idx->devmap_handle);
-
-        rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
+        bs = block_bb_get(childp->idx->service_id);
+
+        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
             NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
             BLOCK_FLAGS_NONE);
@@ -841 +841 @@
         
         fibril_mutex_lock(&nodep->idx->lock);
-        bs = block_bb_get(nodep->idx->devmap_handle);
+        bs = block_bb_get(nodep->idx->service_id);
 
         blocks = nodep->size / BPS(bs);
@@ -910 +910 @@
 }
 
-devmap_handle_t fat_device_get(fs_node_t *node)
+service_id_t fat_device_get(fs_node_t *node)
 {
         return 0;
@@ -940 +940 @@
 
 static int
-fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
+fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
     aoff64_t *size, unsigned *linkcnt)
 {
@@ -954 +954 @@
 
         /* initialize libblock */
-        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
+        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
         if (rc != EOK)
                 return rc;
 
         /* prepare the boot block */
-        rc = block_bb_read(devmap_handle, BS_BLOCK);
+        rc = block_bb_read(service_id, BS_BLOCK);
         if (rc != EOK) {
-                block_fini(devmap_handle);
+                block_fini(service_id);
                 return rc;
         }
 
         /* get the buffer with the boot sector */
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
         
         if (BPS(bs) != BS_SIZE) {
-                block_fini(devmap_handle);
+                block_fini(service_id);
                 return ENOTSUP;
         }
 
         /* Initialize the block cache */
-        rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
+        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
         if (rc != EOK) {
-                block_fini(devmap_handle);
+                block_fini(service_id);
                 return rc;
         }
 
         /* Do some simple sanity checks on the file system. */
-        rc = fat_sanity_check(bs, devmap_handle);
+        rc = fat_sanity_check(bs, service_id);
         if (rc != EOK) {
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
-                return rc;
-        }
-
-        rc = fat_idx_init_by_devmap_handle(devmap_handle);
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
+                return rc;
+        }
+
+        rc = fat_idx_init_by_service_id(service_id);
         if (rc != EOK) {
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
                 return rc;
         }
@@ -998 +998 @@
         fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
         if (!rfn) {
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
-                fat_idx_fini_by_devmap_handle(devmap_handle);
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
+                fat_idx_fini_by_service_id(service_id);
                 return ENOMEM;
         }
@@ -1007 +1007 @@
         if (!rootp) {
                 free(rfn);
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
-                fat_idx_fini_by_devmap_handle(devmap_handle);
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
+                fat_idx_fini_by_service_id(service_id);
                 return ENOMEM;
         }
         fat_node_initialize(rootp);
 
-        fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
+        fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0);
         if (!ridxp) {
                 free(rfn);
                 free(rootp);
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
-                fat_idx_fini_by_devmap_handle(devmap_handle);
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
+                fat_idx_fini_by_service_id(service_id);
                 return ENOMEM;
         }
@@ -1045 +1045 @@
 }
 
-static int fat_unmounted(devmap_handle_t devmap_handle)
+static int fat_unmounted(service_id_t service_id)
 {
         fs_node_t *fn;
@@ -1051 +1051 @@
         int rc;
 
-        rc = fat_root_get(&fn, devmap_handle);
+        rc = fat_root_get(&fn, service_id);
         if (rc != EOK)
                 return rc;
@@ -1076 +1076 @@
          * stop using libblock for this instance.
          */
-        (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);
+        (void) fat_node_fini_by_service_id(service_id);
+        fat_idx_fini_by_service_id(service_id);
+        (void) block_cache_fini(service_id);
+        block_fini(service_id);
 
         return EOK;
@@ -1085 +1085 @@
 
 static int
-fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -1095 +1095 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK)
                 return rc;
@@ -1110 +1110 @@
         }
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         if (nodep->type == FAT_FILE) {
@@ -1213 +1213 @@
 
 static int
-fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -1225 +1225 @@
         int rc;
         
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK)
                 return rc;
@@ -1240 +1240 @@
         }
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         /*
@@ -1299 +1299 @@
                 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, devmap_handle, nclsts, &mcl, &lcl);
+                rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl);
                 if (rc != EOK) {
                         /* could not allocate a chain of nclsts clusters */
@@ -1309 +1309 @@
                 rc = fat_fill_gap(bs, nodep, mcl, pos);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, devmap_handle, mcl);
+                        (void) fat_free_clusters(bs, service_id, mcl);
                         (void) fat_node_put(fn);
                         async_answer_0(callid, rc);
                         return rc;
                 }
-                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
+                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
                     (pos / BPS(bs)) % SPC(bs), flags);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, devmap_handle, mcl);
+                        (void) fat_free_clusters(bs, service_id, mcl);
                         (void) fat_node_put(fn);
                         async_answer_0(callid, rc);
@@ -1327 +1327 @@
                 rc = block_put(b);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, devmap_handle, mcl);
+                        (void) fat_free_clusters(bs, service_id, mcl);
                         (void) fat_node_put(fn);
                         return rc;
@@ -1337 +1337 @@
                 rc = fat_append_clusters(bs, nodep, mcl, lcl);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, devmap_handle, mcl);
+                        (void) fat_free_clusters(bs, service_id, mcl);
                         (void) fat_node_put(fn);
                         return rc;
@@ -1350 +1350 @@
 
 static int
-fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
+fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
 {
         fs_node_t *fn;
@@ -1357 +1357 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK)
                 return rc;
@@ -1364 +1364 @@
         nodep = FAT_NODE(fn);
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         if (nodep->size == size) {
@@ -1391 +1391 @@
                 } else {
                         fat_cluster_t lastc;
-                        rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
+                        rc = fat_cluster_walk(bs, service_id, nodep->firstc,
                             &lastc, NULL, (size - 1) / BPC(bs));
                         if (rc != EOK)
@@ -1408 +1408 @@
 }
 
-static int fat_close(devmap_handle_t devmap_handle, fs_index_t index)
+static int fat_close(service_id_t service_id, fs_index_t index)
 {
         return EOK;
 }
 
-static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
+static int fat_destroy(service_id_t service_id, fs_index_t index)
 {
         fs_node_t *fn;
@@ -1419 +1419 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK)
                 return rc;
@@ -1436 +1436 @@
 }
 
-static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index)
+static int fat_sync(service_id_t service_id, fs_index_t index)
 {
         fs_node_t *fn;
-        int rc = fat_node_get(&fn, devmap_handle, index);
+        int rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK)
                 return rc;

uspace/srv/fs/locfs/Makefile

@@ -31 +31 @@
 LIBS = $(LIBFS_PREFIX)/libfs.a
 EXTRA_CFLAGS += -I$(LIBFS_PREFIX)
-BINARY = devfs
+BINARY = locfs
 STATIC_NEEDED = y
 
 SOURCES = \
-        devfs.c \
-        devfs_ops.c
+        locfs.c \
+        locfs_ops.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/fs/locfs/locfs.c

@@ -32 +32 @@
 
 /**
- * @file devfs.c
- * @brief Devices file system.
+ * @file locfs.c
+ * @brief Location-service file system.
  *
- * Every device registered to device mapper is represented as a file in this
+ * Every service registered with location service is represented as a file in this
  * file system.
  */
@@ -46 +46 @@
 #include <task.h>
 #include <libfs.h>
-#include "devfs.h"
-#include "devfs_ops.h"
+#include "locfs.h"
+#include "locfs_ops.h"
 
-#define NAME  "devfs"
+#define NAME  "locfs"
 
-static vfs_info_t devfs_vfs_info = {
+static vfs_info_t locfs_vfs_info = {
         .name = NAME,
         .concurrent_read_write = false,
@@ -61 +61 @@
         printf("%s: HelenOS Device Filesystem\n", NAME);
         
-        if (!devfs_init()) {
-                printf("%s: failed to initialize devfs\n", NAME);
+        if (!locfs_init()) {
+                printf("%s: failed to initialize locfs\n", NAME);
                 return -1;
         }
@@ -73 +73 @@
         }
         
-        int rc = fs_register(vfs_sess, &devfs_vfs_info, &devfs_ops,
-            &devfs_libfs_ops);
+        int rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops,
+            &locfs_libfs_ops);
         if (rc != EOK) {
                 printf("%s: Failed to register file system (%d)\n", NAME, rc);

uspace/srv/fs/locfs/locfs.h

@@ -31 +31 @@
  */ 
 
-#ifndef DEVFS_DEVFS_H_
-#define DEVFS_DEVFS_H_
+#ifndef LOCFS_LOCFS_H_
+#define LOCFS_LOCFS_H_
 
 #include <libfs.h>
 
-extern vfs_out_ops_t devfs_ops;
-extern libfs_ops_t devfs_libfs_ops;
+extern vfs_out_ops_t locfs_ops;
+extern libfs_ops_t locfs_libfs_ops;
 
 #endif

uspace/srv/fs/locfs/locfs_ops.c

@@ -32 +32 @@
 
 /**
- * @file devfs_ops.c
- * @brief Implementation of VFS operations for the devfs file system server.
+ * @file locfs_ops.c
+ * @brief Implementation of VFS operations for the locfs file system server.
  */
 
@@ -44 +44 @@
 #include <fibril_synch.h>
 #include <adt/hash_table.h>
-#include <ipc/devmap.h>
+#include <ipc/loc.h>
 #include <sys/stat.h>
 #include <libfs.h>
 #include <assert.h>
-#include "devfs.h"
-#include "devfs_ops.h"
+#include "locfs.h"
+#include "locfs_ops.h"
 
 typedef struct {
-        devmap_handle_type_t type;
-        devmap_handle_t handle;
-} devfs_node_t;
-
-/** Opened devices structure */
+        loc_object_type_t type;
+        service_id_t service_id;
+} locfs_node_t;
+
+/** Opened services structure */
 typedef struct {
-        devmap_handle_t handle;
+        service_id_t service_id;
         async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
         size_t refcount;
         link_t link;
         fibril_condvar_t cv;      /**< Broadcast when completed. */
-} device_t;
-
-/** Hash table of opened devices */
-static hash_table_t devices;
+} service_t;
+
+/** Hash table of opened services */
+static hash_table_t services;
 
 /** Hash table mutex */
-static FIBRIL_MUTEX_INITIALIZE(devices_mutex);
-
-#define DEVICES_KEYS        1
-#define DEVICES_KEY_HANDLE  0
-#define DEVICES_BUCKETS     256
+static FIBRIL_MUTEX_INITIALIZE(services_mutex);
+
+#define SERVICES_KEYS        1
+#define SERVICES_KEY_HANDLE  0
+#define SERVICES_BUCKETS     256
 
 /* Implementation of hash table interface for the nodes hash table. */
-static hash_index_t devices_hash(unsigned long key[])
-{
-        return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS;
-}
-
-static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        device_t *dev = hash_table_get_instance(item, device_t, link);
-        return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]);
-}
-
-static void devices_remove_callback(link_t *item)
-{
-        free(hash_table_get_instance(item, device_t, link));
-}
-
-static hash_table_operations_t devices_ops = {
-        .hash = devices_hash,
-        .compare = devices_compare,
-        .remove_callback = devices_remove_callback
+static hash_index_t services_hash(unsigned long key[])
+{
+        return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS;
+}
+
+static int services_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        service_t *dev = hash_table_get_instance(item, service_t, link);
+        return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]);
+}
+
+static void services_remove_callback(link_t *item)
+{
+        free(hash_table_get_instance(item, service_t, link));
+}
+
+static hash_table_operations_t services_ops = {
+        .hash = services_hash,
+        .compare = services_compare,
+        .remove_callback = services_remove_callback
 };
 
-static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type,
-    devmap_handle_t handle)
-{
-        devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t));
+static int locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type,
+    service_id_t service_id)
+{
+        locfs_node_t *node = (locfs_node_t *) malloc(sizeof(locfs_node_t));
         if (node == NULL) {
                 *rfn = NULL;
@@ -116 +116 @@
         fs_node_initialize(*rfn);
         node->type = type;
-        node->handle = handle;
+        node->service_id = service_id;
         
         (*rfn)->data = node;
@@ -122 +122 @@
 }
 
-static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
-{
-        return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0);
-}
-
-static int devfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
-{
-        devfs_node_t *node = (devfs_node_t *) pfn->data;
+static int locfs_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+        return locfs_node_get_internal(rfn, LOC_OBJECT_NONE, 0);
+}
+
+static int locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
+{
+        locfs_node_t *node = (locfs_node_t *) pfn->data;
         int ret;
         
-        if (node->handle == 0) {
+        if (node->service_id == 0) {
                 /* Root directory */
                 
-                dev_desc_t *devs;
-                size_t count = devmap_get_namespaces(&devs);
+                loc_sdesc_t *nspaces;
+                size_t count = loc_get_namespaces(&nspaces);
                 
                 if (count > 0) {
@@ -142 +142 @@
                         for (pos = 0; pos < count; pos++) {
                                 /* Ignore root namespace */
-                                if (str_cmp(devs[pos].name, "") == 0)
+                                if (str_cmp(nspaces[pos].name, "") == 0)
                                         continue;
                                 
-                                if (str_cmp(devs[pos].name, component) == 0) {
-                                        ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
-                                        free(devs);
+                                if (str_cmp(nspaces[pos].name, component) == 0) {
+                                        ret = locfs_node_get_internal(rfn, LOC_OBJECT_NAMESPACE, nspaces[pos].id);
+                                        free(nspaces);
                                         return ret;
                                 }
                         }
                         
-                        free(devs);
+                        free(nspaces);
                 }
                 
                 /* Search root namespace */
-                devmap_handle_t namespace;
-                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
-                        count = devmap_get_devices(namespace, &devs);
+                service_id_t namespace;
+                loc_sdesc_t *svcs;
+                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
+                        count = loc_get_services(namespace, &svcs);
                         
                         if (count > 0) {
                                 size_t pos;
                                 for (pos = 0; pos < count; pos++) {
-                                        if (str_cmp(devs[pos].name, component) == 0) {
-                                                ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
-                                                free(devs);
+                                        if (str_cmp(svcs[pos].name, component) == 0) {
+                                                ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id);
+                                                free(svcs);
                                                 return ret;
                                         }
                                 }
                                 
-                                free(devs);
+                                free(svcs);
                         }
                 }
@@ -178 +179 @@
         }
         
-        if (node->type == DEV_HANDLE_NAMESPACE) {
+        if (node->type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 
-                dev_desc_t *devs;
-                size_t count = devmap_get_devices(node->handle, &devs);
+                loc_sdesc_t *svcs;
+                size_t count = loc_get_services(node->service_id, &svcs);
                 if (count > 0) {
                         size_t pos;
                         for (pos = 0; pos < count; pos++) {
-                                if (str_cmp(devs[pos].name, component) == 0) {
-                                        ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
-                                        free(devs);
+                                if (str_cmp(svcs[pos].name, component) == 0) {
+                                        ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id);
+                                        free(svcs);
                                         return ret;
                                 }
                         }
                         
-                        free(devs);
+                        free(svcs);
                 }
                 
@@ -204 +205 @@
 }
 
-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);
-}
-
-static int devfs_node_open(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        if (node->handle == 0) {
+static int locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
+{
+        return locfs_node_get_internal(rfn, loc_id_probe(index), index);
+}
+
+static int locfs_node_open(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        if (node->service_id == 0) {
                 /* Root directory */
                 return EOK;
         }
         
-        devmap_handle_type_t type = devmap_handle_probe(node->handle);
-        
-        if (type == DEV_HANDLE_NAMESPACE) {
+        loc_object_type_t type = loc_id_probe(node->service_id);
+        
+        if (type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 return EOK;
         }
         
-        if (type == DEV_HANDLE_DEVICE) {
+        if (type == LOC_OBJECT_SERVICE) {
                 /* Device node */
                 
                 unsigned long key[] = {
-                        [DEVICES_KEY_HANDLE] = (unsigned long) node->handle
+                        [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id
                 };
                 link_t *lnk;
                 
-                fibril_mutex_lock(&devices_mutex);
+                fibril_mutex_lock(&services_mutex);
 restart:
-                lnk = hash_table_find(&devices, key);
+                lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
-                        device_t *dev = (device_t *) malloc(sizeof(device_t));
+                        service_t *dev = (service_t *) malloc(sizeof(service_t));
                         if (dev == NULL) {
-                                fibril_mutex_unlock(&devices_mutex);
+                                fibril_mutex_unlock(&services_mutex);
                                 return ENOMEM;
                         }
                         
-                        dev->handle = node->handle;
+                        dev->service_id = node->service_id;
                         
                         /* Mark as incomplete */
@@ -255 +256 @@
                          * below.
                          */
-                        hash_table_insert(&devices, key, &dev->link);
+                        hash_table_insert(&services, key, &dev->link);
                         
                         /*
-                         * Drop the mutex to allow recursive devfs requests.
+                         * Drop the mutex to allow recursive locfs requests.
                          */
-                        fibril_mutex_unlock(&devices_mutex);
-                        
-                        async_sess_t *sess = devmap_device_connect(EXCHANGE_SERIALIZE,
-                            node->handle, 0);
-                        
-                        fibril_mutex_lock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
+                        
+                        async_sess_t *sess = loc_service_connect(
+                            EXCHANGE_SERIALIZE, node->service_id, 0);
+                        
+                        fibril_mutex_lock(&services_mutex);
                         
                         /*
@@ -278 +279 @@
                                  * entry and free the device structure.
                                  */
-                                hash_table_remove(&devices, key, DEVICES_KEYS);
-                                fibril_mutex_unlock(&devices_mutex);
+                                hash_table_remove(&services, key, SERVICES_KEYS);
+                                fibril_mutex_unlock(&services_mutex);
                                 
                                 return ENOENT;
@@ -287 +288 @@
                         dev->sess = sess;
                 } else {
-                        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                        service_t *dev = hash_table_get_instance(lnk, service_t, link);
                         
                         if (!dev->sess) {
@@ -297 +298 @@
                                  * fibril_condvar_wait().
                                  */
-                                fibril_condvar_wait(&dev->cv, &devices_mutex);
+                                fibril_condvar_wait(&dev->cv, &services_mutex);
                                 goto restart;
                         }
@@ -304 +305 @@
                 }
                 
-                fibril_mutex_unlock(&devices_mutex);
+                fibril_mutex_unlock(&services_mutex);
                 
                 return EOK;
@@ -312 +313 @@
 }
 
-static int devfs_node_put(fs_node_t *fn)
+static int locfs_node_put(fs_node_t *fn)
 {
         free(fn->data);
@@ -319 +320 @@
 }
 
-static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
+static int locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
 {
         assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
@@ -327 +328 @@
 }
 
-static int devfs_destroy_node(fs_node_t *fn)
+static int locfs_destroy_node(fs_node_t *fn)
 {
         return ENOTSUP;
 }
 
-static int devfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+static int locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
 {
         return ENOTSUP;
 }
 
-static int devfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+static int locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
 {
         return ENOTSUP;
 }
 
-static int devfs_has_children(bool *has_children, fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        if (node->handle == 0) {
-                size_t count = devmap_count_namespaces();
+static int locfs_has_children(bool *has_children, fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        if (node->service_id == 0) {
+                size_t count = loc_count_namespaces();
                 if (count > 0) {
                         *has_children = true;
@@ -354 +355 @@
                 
                 /* Root namespace */
-                devmap_handle_t namespace;
-                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
-                        count = devmap_count_devices(namespace);
+                service_id_t namespace;
+                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
+                        count = loc_count_services(namespace);
                         if (count > 0) {
                                 *has_children = true;
@@ -367 +368 @@
         }
         
-        if (node->type == DEV_HANDLE_NAMESPACE) {
-                size_t count = devmap_count_devices(node->handle);
+        if (node->type == LOC_OBJECT_NAMESPACE) {
+                size_t count = loc_count_services(node->service_id);
                 if (count > 0) {
                         *has_children = true;
@@ -382 +383 @@
 }
 
-static fs_index_t devfs_index_get(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        return node->handle;
-}
-
-static aoff64_t devfs_size_get(fs_node_t *fn)
+static fs_index_t locfs_index_get(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        return node->service_id;
+}
+
+static aoff64_t locfs_size_get(fs_node_t *fn)
 {
         return 0;
 }
 
-static unsigned int devfs_lnkcnt_get(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        if (node->handle == 0)
+static unsigned int locfs_lnkcnt_get(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        if (node->service_id == 0)
                 return 0;
         
@@ -403 +404 @@
 }
 
-static bool devfs_is_directory(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE));
-}
-
-static bool devfs_is_file(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        return (node->type == DEV_HANDLE_DEVICE);
-}
-
-static devmap_handle_t devfs_device_get(fs_node_t *fn)
-{
-        devfs_node_t *node = (devfs_node_t *) fn->data;
-        
-        if (node->type == DEV_HANDLE_DEVICE)
-                return node->handle;
+static bool locfs_is_directory(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE));
+}
+
+static bool locfs_is_file(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        return (node->type == LOC_OBJECT_SERVICE);
+}
+
+static service_id_t locfs_device_get(fs_node_t *fn)
+{
+        locfs_node_t *node = (locfs_node_t *) fn->data;
+        
+        if (node->type == LOC_OBJECT_SERVICE)
+                return node->service_id;
         
         return 0;
@@ -428 +429 @@
 
 /** libfs operations */
-libfs_ops_t devfs_libfs_ops = {
-        .root_get = devfs_root_get,
-        .match = devfs_match,
-        .node_get = devfs_node_get,
-        .node_open = devfs_node_open,
-        .node_put = devfs_node_put,
-        .create = devfs_create_node,
-        .destroy = devfs_destroy_node,
-        .link = devfs_link_node,
-        .unlink = devfs_unlink_node,
-        .has_children = devfs_has_children,
-        .index_get = devfs_index_get,
-        .size_get = devfs_size_get,
-        .lnkcnt_get = devfs_lnkcnt_get,
-        .is_directory = devfs_is_directory,
-        .is_file = devfs_is_file,
-        .device_get = devfs_device_get
+libfs_ops_t locfs_libfs_ops = {
+        .root_get = locfs_root_get,
+        .match = locfs_match,
+        .node_get = locfs_node_get,
+        .node_open = locfs_node_open,
+        .node_put = locfs_node_put,
+        .create = locfs_create_node,
+        .destroy = locfs_destroy_node,
+        .link = locfs_link_node,
+        .unlink = locfs_unlink_node,
+        .has_children = locfs_has_children,
+        .index_get = locfs_index_get,
+        .size_get = locfs_size_get,
+        .lnkcnt_get = locfs_lnkcnt_get,
+        .is_directory = locfs_is_directory,
+        .is_file = locfs_is_file,
+        .device_get = locfs_device_get
 };
 
-bool devfs_init(void)
-{
-        if (!hash_table_create(&devices, DEVICES_BUCKETS,
-            DEVICES_KEYS, &devices_ops))
+bool locfs_init(void)
+{
+        if (!hash_table_create(&services, SERVICES_BUCKETS,
+            SERVICES_KEYS, &services_ops))
                 return false;
         
@@ -456 +457 @@
 }
 
-static int devfs_mounted(devmap_handle_t devmap_handle, const char *opts,
+static int locfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
 {
@@ -465 +466 @@
 }
 
-static int devfs_unmounted(devmap_handle_t devmap_handle)
+static int locfs_unmounted(service_id_t service_id)
 {
         return ENOTSUP;
@@ -471 +472 @@
 
 static int
-devfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+locfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -482 +483 @@
                 }
                 
-                dev_desc_t *desc;
-                size_t count = devmap_get_namespaces(&desc);
+                loc_sdesc_t *desc;
+                size_t count = loc_get_namespaces(&desc);
                 
                 /* Get rid of root namespace */
@@ -507 +508 @@
                 
                 /* Search root namespace */
-                devmap_handle_t namespace;
-                if (devmap_namespace_get_handle("", &namespace, 0) == EOK) {
-                        count = devmap_get_devices(namespace, &desc);
+                service_id_t namespace;
+                if (loc_namespace_get_id("", &namespace, 0) == EOK) {
+                        count = loc_get_services(namespace, &desc);
                         
                         if (pos < count) {
@@ -525 +526 @@
         }
         
-        devmap_handle_type_t type = devmap_handle_probe(index);
-        
-        if (type == DEV_HANDLE_NAMESPACE) {
+        loc_object_type_t type = loc_id_probe(index);
+        
+        if (type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 ipc_callid_t callid;
@@ -536 +537 @@
                 }
                 
-                dev_desc_t *desc;
-                size_t count = devmap_get_devices(index, &desc);
+                loc_sdesc_t *desc;
+                size_t count = loc_get_services(index, &desc);
                 
                 if (pos < count) {
@@ -551 +552 @@
         }
         
-        if (type == DEV_HANDLE_DEVICE) {
+        if (type == LOC_OBJECT_SERVICE) {
                 /* Device node */
                 
                 unsigned long key[] = {
-                        [DEVICES_KEY_HANDLE] = (unsigned long) index
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
                 };
                 
-                fibril_mutex_lock(&devices_mutex);
-                link_t *lnk = hash_table_find(&devices, key);
+                fibril_mutex_lock(&services_mutex);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         return ENOENT;
                 }
                 
-                device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 
                 ipc_callid_t callid;
                 if (!async_data_read_receive(&callid, NULL)) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         async_answer_0(callid, EINVAL);
                         return EINVAL;
@@ -579 +580 @@
                 
                 ipc_call_t answer;
-                aid_t msg = async_send_4(exch, VFS_OUT_READ, devmap_handle,
+                aid_t msg = async_send_4(exch, VFS_OUT_READ, service_id,
                     index, LOWER32(pos), UPPER32(pos), &answer);
                 
@@ -587 +588 @@
                 async_exchange_end(exch);
                 
-                fibril_mutex_unlock(&devices_mutex);
+                fibril_mutex_unlock(&services_mutex);
                 
                 /* Wait for reply from the driver. */
@@ -601 +602 @@
 
 static int
-devfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+locfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -607 +608 @@
                 return ENOTSUP;
         
-        devmap_handle_type_t type = devmap_handle_probe(index);
-        
-        if (type == DEV_HANDLE_NAMESPACE) {
+        loc_object_type_t type = loc_id_probe(index);
+        
+        if (type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 return ENOTSUP;
         }
         
-        if (type == DEV_HANDLE_DEVICE) {
+        if (type == LOC_OBJECT_SERVICE) {
                 /* Device node */
                 unsigned long key[] = {
-                        [DEVICES_KEY_HANDLE] = (unsigned long) index
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
                 };
                 
-                fibril_mutex_lock(&devices_mutex);
-                link_t *lnk = hash_table_find(&devices, key);
+                fibril_mutex_lock(&services_mutex);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         return ENOENT;
                 }
                 
-                device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 
                 ipc_callid_t callid;
                 if (!async_data_write_receive(&callid, NULL)) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         async_answer_0(callid, EINVAL);
                         return EINVAL;
@@ -641 +642 @@
                 
                 ipc_call_t answer;
-                aid_t msg = async_send_4(exch, VFS_OUT_WRITE, devmap_handle,
+                aid_t msg = async_send_4(exch, VFS_OUT_WRITE, service_id,
                     index, LOWER32(pos), UPPER32(pos), &answer);
                 
@@ -649 +650 @@
                 async_exchange_end(exch);
                 
-                fibril_mutex_unlock(&devices_mutex);
+                fibril_mutex_unlock(&services_mutex);
                 
                 /* Wait for reply from the driver. */
@@ -664 +665 @@
 
 static int
-devfs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
+locfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
 {
         return ENOTSUP;
 }
 
-static int devfs_close(devmap_handle_t devmap_handle, fs_index_t index)
+static int locfs_close(service_id_t service_id, fs_index_t index)
 {
         if (index == 0)
                 return EOK;
         
-        devmap_handle_type_t type = devmap_handle_probe(index);
-        
-        if (type == DEV_HANDLE_NAMESPACE) {
+        loc_object_type_t type = loc_id_probe(index);
+        
+        if (type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 return EOK;
         }
         
-        if (type == DEV_HANDLE_DEVICE) {
+        if (type == LOC_OBJECT_SERVICE) {
                 unsigned long key[] = {
-                        [DEVICES_KEY_HANDLE] = (unsigned long) index
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
                 };
                 
-                fibril_mutex_lock(&devices_mutex);
-                link_t *lnk = hash_table_find(&devices, key);
+                fibril_mutex_lock(&services_mutex);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         return ENOENT;
                 }
                 
-                device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 dev->refcount--;
@@ -699 +700 @@
                 if (dev->refcount == 0) {
                         async_hangup(dev->sess);
-                        hash_table_remove(&devices, key, DEVICES_KEYS);
-                }
-                
-                fibril_mutex_unlock(&devices_mutex);
+                        hash_table_remove(&services, key, SERVICES_KEYS);
+                }
+                
+                fibril_mutex_unlock(&services_mutex);
                 
                 return EOK;
@@ -710 +711 @@
 }
 
-static int devfs_sync(devmap_handle_t devmap_handle, fs_index_t index)
+static int locfs_sync(service_id_t service_id, fs_index_t index)
 {
         if (index == 0)
                 return EOK;
         
-        devmap_handle_type_t type = devmap_handle_probe(index);
-        
-        if (type == DEV_HANDLE_NAMESPACE) {
+        loc_object_type_t type = loc_id_probe(index);
+        
+        if (type == LOC_OBJECT_NAMESPACE) {
                 /* Namespace directory */
                 return EOK;
         }
         
-        if (type == DEV_HANDLE_DEVICE) {
+        if (type == LOC_OBJECT_SERVICE) {
                 unsigned long key[] = {
-                        [DEVICES_KEY_HANDLE] = (unsigned long) index
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
                 };
                 
-                fibril_mutex_lock(&devices_mutex);
-                link_t *lnk = hash_table_find(&devices, key);
+                fibril_mutex_lock(&services_mutex);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
-                        fibril_mutex_unlock(&devices_mutex);
+                        fibril_mutex_unlock(&services_mutex);
                         return ENOENT;
                 }
                 
-                device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 
@@ -741 +742 @@
                 
                 ipc_call_t answer;
-                aid_t msg = async_send_2(exch, VFS_OUT_SYNC, devmap_handle,
+                aid_t msg = async_send_2(exch, VFS_OUT_SYNC, service_id,
                     index, &answer);
                 
                 async_exchange_end(exch);
                 
-                fibril_mutex_unlock(&devices_mutex);
+                fibril_mutex_unlock(&services_mutex);
                 
                 /* Wait for reply from the driver */
@@ -758 +759 @@
 }
 
-static int devfs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
+static int locfs_destroy(service_id_t service_id, fs_index_t index)
 {
         return ENOTSUP;
 }
 
-vfs_out_ops_t devfs_ops = {
-        .mounted = devfs_mounted,
-        .unmounted = devfs_unmounted,
-        .read = devfs_read,
-        .write = devfs_write,
-        .truncate = devfs_truncate,
-        .close = devfs_close,
-        .destroy = devfs_destroy,
-        .sync = devfs_sync,
+vfs_out_ops_t locfs_ops = {
+        .mounted = locfs_mounted,
+        .unmounted = locfs_unmounted,
+        .read = locfs_read,
+        .write = locfs_write,
+        .truncate = locfs_truncate,
+        .close = locfs_close,
+        .destroy = locfs_destroy,
+        .sync = locfs_sync,
 };
 

uspace/srv/fs/locfs/locfs_ops.h

@@ -31 +31 @@
  */
 
-#ifndef DEVFS_DEVFS_OPS_H_
-#define DEVFS_DEVFS_OPS_H_
+#ifndef LOCFS_LOCFS_OPS_H_
+#define LOCFS_LOCFS_OPS_H_
 
 #include <bool.h>
 
-extern bool devfs_init(void);
+extern bool locfs_init(void);
 
 #endif

uspace/srv/fs/tmpfs/tmpfs.h

@@ -61 +61 @@
         fs_node_t *bp;          /**< Back pointer to the FS node. */
         fs_index_t index;       /**< TMPFS node index. */
-        devmap_handle_t devmap_handle;/**< Device handle. */
+        service_id_t service_id;/**< Service ID of block device. */
         link_t nh_link;         /**< Nodes hash table link. */
         tmpfs_dentry_type_t type;
@@ -74 +74 @@
 
 extern bool tmpfs_init(void);
-extern bool tmpfs_restore(devmap_handle_t);
+extern bool tmpfs_restore(service_id_t);
 
 #endif

uspace/srv/fs/tmpfs/tmpfs_dump.c

@@ -55 +55 @@
 
 static bool
-tmpfs_restore_recursion(devmap_handle_t dev, size_t *bufpos, size_t *buflen,
+tmpfs_restore_recursion(service_id_t dsid, size_t *bufpos, size_t *buflen,
     aoff64_t *pos, fs_node_t *pfn)
 {
@@ -68 +68 @@
                 uint32_t size;
                 
-                if (block_seqread(dev, bufpos, buflen, pos, &entry,
+                if (block_seqread(dsid, bufpos, buflen, pos, &entry,
                     sizeof(entry)) != EOK)
                         return false;
@@ -82 +82 @@
                                 return false;
                         
-                        rc = ops->create(&fn, dev, L_FILE);
+                        rc = ops->create(&fn, dsid, L_FILE);
                         if (rc != EOK || fn == NULL) {
                                 free(fname);
@@ -88 +88 @@
                         }
                         
-                        if (block_seqread(dev, bufpos, buflen, pos, fname,
+                        if (block_seqread(dsid, bufpos, buflen, pos, fname,
                             entry.len) != EOK) {
                                 (void) ops->destroy(fn);
@@ -104 +104 @@
                         free(fname);
                         
-                        if (block_seqread(dev, bufpos, buflen, pos, &size,
+                        if (block_seqread(dsid, bufpos, buflen, pos, &size,
                             sizeof(size)) != EOK)
                                 return false;
@@ -116 +116 @@
                         
                         nodep->size = size;
-                        if (block_seqread(dev, bufpos, buflen, pos, nodep->data,
+                        if (block_seqread(dsid, bufpos, buflen, pos, nodep->data,
                             size) != EOK)
                                 return false;
@@ -126 +126 @@
                                 return false;
                         
-                        rc = ops->create(&fn, dev, L_DIRECTORY);
+                        rc = ops->create(&fn, dsid, L_DIRECTORY);
                         if (rc != EOK || fn == NULL) {
                                 free(fname);
@@ -132 +132 @@
                         }
                         
-                        if (block_seqread(dev, bufpos, buflen, pos, fname,
+                        if (block_seqread(dsid, bufpos, buflen, pos, fname,
                             entry.len) != EOK) {
                                 (void) ops->destroy(fn);
@@ -148 +148 @@
                         free(fname);
                         
-                        if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
+                        if (!tmpfs_restore_recursion(dsid, bufpos, buflen, pos,
                             fn))
                                 return false;
@@ -161 +161 @@
 }
 
-bool tmpfs_restore(devmap_handle_t dev)
+bool tmpfs_restore(service_id_t dsid)
 {
         libfs_ops_t *ops = &tmpfs_libfs_ops;
@@ -167 +167 @@
         int rc;
 
-        rc = block_init(EXCHANGE_SERIALIZE, dev, TMPFS_COMM_SIZE);
+        rc = block_init(EXCHANGE_SERIALIZE, dsid, TMPFS_COMM_SIZE);
         if (rc != EOK)
                 return false; 
@@ -176 +176 @@
         
         char tag[6];
-        if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5) != EOK)
+        if (block_seqread(dsid, &bufpos, &buflen, &pos, tag, 5) != EOK)
                 goto error;
         
@@ -183 +183 @@
                 goto error;
         
-        rc = ops->root_get(&fn, dev);
+        rc = ops->root_get(&fn, dsid);
         if (rc != EOK)
                 goto error;
 
-        if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, fn))
-                goto error;
-                
-        block_fini(dev);
+        if (!tmpfs_restore_recursion(dsid, &bufpos, &buflen, &pos, fn))
+                goto error;
+                
+        block_fini(dsid);
         return true;
         
 error:
-        block_fini(dev);
+        block_fini(dsid);
         return false;
 }

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -69 +69 @@
 /* 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 **, devmap_handle_t, fs_index_t);
+static int tmpfs_node_get(fs_node_t **, service_id_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 **, devmap_handle_t, int);
+static int tmpfs_create_node(fs_node_t **, service_id_t, int);
 static int tmpfs_destroy_node(fs_node_t *);
 static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
@@ -78 +78 @@
 
 /* Implementation of helper functions. */
-static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
-{
-        return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT); 
+static int tmpfs_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+        return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT); 
 }
 
@@ -114 +114 @@
 }
 
-static devmap_handle_t tmpfs_device_get(fs_node_t *fn)
+static service_id_t tmpfs_device_get(fs_node_t *fn)
 {
         return 0;
@@ -158 +158 @@
         switch (keys) {
         case 1:
-                return (nodep->devmap_handle == key[NODES_KEY_DEV]);
+                return (nodep->service_id == key[NODES_KEY_DEV]);
         case 2: 
-                return ((nodep->devmap_handle == key[NODES_KEY_DEV]) &&
+                return ((nodep->service_id == key[NODES_KEY_DEV]) &&
                     (nodep->index == key[NODES_KEY_INDEX]));
         default:
@@ -202 +202 @@
         nodep->bp = NULL;
         nodep->index = 0;
-        nodep->devmap_handle = 0;
+        nodep->service_id = 0;
         nodep->type = TMPFS_NONE;
         nodep->lnkcnt = 0;
@@ -226 +226 @@
 }
 
-static bool tmpfs_instance_init(devmap_handle_t devmap_handle)
+static bool tmpfs_instance_init(service_id_t service_id)
 {
         fs_node_t *rfn;
         int rc;
         
-        rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY);
+        rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY);
         if (rc != EOK || !rfn)
                 return false;
@@ -238 +238 @@
 }
 
-static void tmpfs_instance_done(devmap_handle_t devmap_handle)
-{
-        unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle
+static void tmpfs_instance_done(service_id_t service_id)
+{
+        unsigned long key[] = {
+                [NODES_KEY_DEV] = service_id
         };
         /*
@@ -270 +270 @@
 }
 
-int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
-{
-        unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle,
+int tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
+{
+        unsigned long key[] = {
+                [NODES_KEY_DEV] = service_id,
                 [NODES_KEY_INDEX] = index
         };
@@ -299 +299 @@
 }
 
-int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
+int tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
 {
         fs_node_t *rootfn;
@@ -318 +318 @@
         nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
 
-        rc = tmpfs_root_get(&rootfn, devmap_handle);
+        rc = tmpfs_root_get(&rootfn, service_id);
         assert(rc == EOK);
         if (!rootfn)
@@ -324 +324 @@
         else
                 nodep->index = tmpfs_next_index++;
-        nodep->devmap_handle = devmap_handle;
+        nodep->service_id = service_id;
         if (lflag & L_DIRECTORY) 
                 nodep->type = TMPFS_DIRECTORY;
@@ -332 +332 @@
         /* Insert the new node into the nodes hash table. */
         unsigned long key[] = {
-                [NODES_KEY_DEV] = nodep->devmap_handle,
+                [NODES_KEY_DEV] = nodep->service_id,
                 [NODES_KEY_INDEX] = nodep->index
         };
@@ -348 +348 @@
 
         unsigned long key[] = {
-                [NODES_KEY_DEV] = nodep->devmap_handle,
+                [NODES_KEY_DEV] = nodep->service_id,
                 [NODES_KEY_INDEX] = nodep->index
         };
@@ -432 +432 @@
 
 static int
-tmpfs_mounted(devmap_handle_t devmap_handle, const char *opts,
+tmpfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
 {
@@ -439 +439 @@
         
         /* Check if this device is not already mounted. */
-        rc = tmpfs_root_get(&rootfn, devmap_handle);
+        rc = tmpfs_root_get(&rootfn, service_id);
         if ((rc == EOK) && (rootfn)) {
                 (void) tmpfs_node_put(rootfn);
@@ -446 +446 @@
 
         /* Initialize TMPFS instance. */
-        if (!tmpfs_instance_init(devmap_handle))
+        if (!tmpfs_instance_init(service_id))
                 return ENOMEM;
 
-        rc = tmpfs_root_get(&rootfn, devmap_handle);
+        rc = tmpfs_root_get(&rootfn, service_id);
         assert(rc == EOK);
         tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
         if (str_cmp(opts, "restore") == 0) {
-                if (!tmpfs_restore(devmap_handle))
+                if (!tmpfs_restore(service_id))
                         return ELIMIT;
         }
@@ -464 +464 @@
 }
 
-static int tmpfs_unmounted(devmap_handle_t devmap_handle)
-{
-        tmpfs_instance_done(devmap_handle);
-        return EOK;
-}
-
-static int tmpfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+static int tmpfs_unmounted(service_id_t service_id)
+{
+        tmpfs_instance_done(service_id);
+        return EOK;
+}
+
+static int tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -478 +478 @@
         link_t *hlp;
         unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle,
+                [NODES_KEY_DEV] = service_id,
                 [NODES_KEY_INDEX] = index
         };
@@ -532 +532 @@
 
 static int
-tmpfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
+tmpfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -540 +540 @@
         link_t *hlp;
         unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle,
+                [NODES_KEY_DEV] = service_id,
                 [NODES_KEY_INDEX] = index
         };
@@ -594 +594 @@
 }
 
-static int tmpfs_truncate(devmap_handle_t devmap_handle, fs_index_t index,
+static int tmpfs_truncate(service_id_t service_id, fs_index_t index,
     aoff64_t size)
 {
@@ -601 +601 @@
          */
         unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle,
+                [NODES_KEY_DEV] = service_id,
                 [NODES_KEY_INDEX] = index
         };
@@ -629 +629 @@
 }
 
-static int tmpfs_close(devmap_handle_t devmap_handle, fs_index_t index)
-{
-        return EOK;
-}
-
-static int tmpfs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
+static int tmpfs_close(service_id_t service_id, fs_index_t index)
+{
+        return EOK;
+}
+
+static int tmpfs_destroy(service_id_t service_id, fs_index_t index)
 {
         link_t *hlp;
         unsigned long key[] = {
-                [NODES_KEY_DEV] = devmap_handle,
+                [NODES_KEY_DEV] = service_id,
                 [NODES_KEY_INDEX] = index
         };
@@ -649 +649 @@
 }
 
-static int tmpfs_sync(devmap_handle_t devmap_handle, fs_index_t index)
+static int tmpfs_sync(service_id_t service_id, fs_index_t index)
 {
         /*