Changeset 15f3c3f in mainline for uspace/srv/fs/fat/fat_ops.c

Timestamp:

2011-06-22T22:00:52Z (13 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.

File:

• uspace/srv/fs/fat/fat_ops.c (modified) (52 diffs)

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);