Changeset 15f3c3f in mainline for uspace/srv/fs/fat

Timestamp:

2011-06-22T22:00:52Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

86ffa27f

Parents:

ef09a7a

Message:

Rename devmap to loc, devfs to locfs.

Location:

uspace/srv/fs/fat

Files:

• fat.h (modified) (3 diffs)
• fat_fat.c (modified) (39 diffs)
• fat_fat.h (modified) (2 diffs)
• fat_idx.c (modified) (33 diffs)
• fat_ops.c (modified) (52 diffs)

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;
         /**
@@ -241 +241 @@
 extern void fat_sync(ipc_callid_t, ipc_call_t *);
 
-extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t);
-extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned);
-extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t);
+extern 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 *);
@@ -250 +250 @@
 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 *);
@@ -88 +88 @@
 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);
 
 /*
@@ -120 +120 @@
         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);
@@ -145 +145 @@
 }
 
-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;
@@ -169 +169 @@
                         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);
@@ -299 +299 @@
                 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) {
@@ -323 +323 @@
                  */
                 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) {
@@ -357 +357 @@
  */
 
-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);
 }
 
@@ -370 +370 @@
         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++) {
@@ -403 +403 @@
                                 /* 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) {
@@ -436 +436 @@
 
 /** 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;
@@ -442 +442 @@
         int rc;
 
-        idxp = fat_idx_get_by_index(devmap_handle, index);
+        idxp = fat_idx_get_by_index(service_id, index);
         if (!idxp) {
                 *rfn = NULL;
@@ -493 +493 @@
 }
 
-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;
@@ -501 +501 @@
         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;
                 }
@@ -517 +517 @@
         rc = fat_node_get_new(&nodep);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, devmap_handle, mcl);
+                (void) fat_free_clusters(bs, service_id, mcl);
                 return rc;
         }
-        rc = fat_idx_get_new(&idxp, devmap_handle);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, devmap_handle, mcl);       
+        rc = fat_idx_get_new(&idxp, service_id);
+        if (rc != EOK) {
+                (void) fat_free_clusters(bs, service_id, mcl);  
                 (void) fat_node_put(FS_NODE(nodep));
                 return rc;
@@ -571 +571 @@
         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);
         }
@@ -621 +621 @@
         
         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);
@@ -660 +660 @@
                 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);
-        if (rc != EOK) {
-                (void) fat_free_clusters(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->service_id, mcl);
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
@@ -673 +673 @@
         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;
@@ -790 +790 @@
         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);
@@ -842 +842 @@
         
         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);
@@ -916 +916 @@
 }
 
-devmap_handle_t fat_device_get(fs_node_t *node)
+service_id_t fat_device_get(fs_node_t *node)
 {
         return 0;
@@ -948 +948 @@
 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         enum cache_mode cmode;
         fat_bs_t *bs;
@@ -970 +970 @@
 
         /* initialize libblock */
-        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
+        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -977 +977 @@
 
         /* prepare the boot block */
-        rc = block_bb_read(devmap_handle, BS_BLOCK);
-        if (rc != EOK) {
-                block_fini(devmap_handle);
+        rc = block_bb_read(service_id, BS_BLOCK);
+        if (rc != EOK) {
+                block_fini(service_id);
                 async_answer_0(rid, rc);
                 return;
@@ -985 +985 @@
 
         /* 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);
                 async_answer_0(rid, ENOTSUP);
                 return;
@@ -994 +994 @@
 
         /* Initialize the block cache */
-        rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
-        if (rc != EOK) {
-                block_fini(devmap_handle);
+        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
+        if (rc != EOK) {
+                block_fini(service_id);
                 async_answer_0(rid, rc);
                 return;
@@ -1002 +1002 @@
 
         /* Do some simple sanity checks on the file system. */
-        rc = fat_sanity_check(bs, devmap_handle);
-        if (rc != EOK) {
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
+        rc = fat_sanity_check(bs, service_id);
+        if (rc != EOK) {
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
                 async_answer_0(rid, rc);
                 return;
         }
 
-        rc = fat_idx_init_by_devmap_handle(devmap_handle);
-        if (rc != EOK) {
-                (void) block_cache_fini(devmap_handle);
-                block_fini(devmap_handle);
+        rc = fat_idx_init_by_service_id(service_id);
+        if (rc != EOK) {
+                (void) block_cache_fini(service_id);
+                block_fini(service_id);
                 async_answer_0(rid, rc);
                 return;
@@ -1021 +1021 @@
         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);
                 async_answer_0(rid, ENOMEM);
                 return;
@@ -1031 +1031 @@
         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);
                 async_answer_0(rid, ENOMEM);
                 return;
@@ -1039 +1039 @@
         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);
                 async_answer_0(rid, ENOMEM);
                 return;
@@ -1074 +1074 @@
 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_node_t *fn;
         fat_node_t *nodep;
         int rc;
 
-        rc = fat_root_get(&fn, devmap_handle);
+        rc = fat_root_get(&fn, service_id);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -1107 +1107 @@
          * 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);
 
         async_answer_0(rid, EOK);
@@ -1127 +1127 @@
 void fat_read(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         aoff64_t pos =
@@ -1138 +1138 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -1158 +1158 @@
         }
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         if (nodep->type == FAT_FILE) {
@@ -1264 +1264 @@
 void fat_write(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         aoff64_t pos =
@@ -1277 +1277 @@
         int rc;
         
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -1297 +1297 @@
         }
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         /*
@@ -1359 +1359 @@
                 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 */
@@ -1370 +1370 @@
                 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);
@@ -1376 +1376 @@
                         return;
                 }
-                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);
@@ -1390 +1390 @@
                 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);
                         async_answer_0(rid, rc);
@@ -1401 +1401 @@
                 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);
                         async_answer_0(rid, rc);
@@ -1416 +1416 @@
 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         aoff64_t size =
@@ -1425 +1425 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -1436 +1436 @@
         nodep = FAT_NODE(fn);
 
-        bs = block_bb_get(devmap_handle);
+        bs = block_bb_get(service_id);
 
         if (nodep->size == size) {
@@ -1463 +1463 @@
                 } 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)
@@ -1488 +1488 @@
 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
         fs_node_t *fn;
@@ -1494 +1494 @@
         int rc;
 
-        rc = fat_node_get(&fn, devmap_handle, index);
+        rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -1527 +1527 @@
 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
         
         fs_node_t *fn;
-        int rc = fat_node_get(&fn, devmap_handle, index);
+        int rc = fat_node_get(&fn, service_id, index);
         if (rc != EOK) {
                 async_answer_0(rid, rc);