Changeset 46c20c8 in mainline for uspace/srv/fs/fat/fat_ops.c

Timestamp:

2010-11-26T20:08:10Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

45df59a

Parents:

fb150d78 (diff), ffdd2b9 (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 mainline changes.

File:

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

uspace/srv/fs/fat/fat_ops.c

@@ -45 +45 @@
 #include <ipc/services.h>
 #include <ipc/devmap.h>
+#include <macros.h>
 #include <async.h>
 #include <errno.h>
-#include <string.h>
+#include <str.h>
 #include <byteorder.h>
 #include <adt/hash_table.h>
@@ -59 +60 @@
 #define FS_NODE(node)   ((node) ? (node)->bp : NULL)
 
+#define DPS(bs)         (BPS((bs)) / sizeof(fat_dentry_t))
+#define BPC(bs)         (BPS((bs)) * SPC((bs)))
+
 /** Mutex protecting the list of cached free FAT nodes. */
 static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
@@ -68 +72 @@
  * Forward declarations of FAT libfs operations.
  */
-static int fat_root_get(fs_node_t **, dev_handle_t);
+static int fat_root_get(fs_node_t **, devmap_handle_t);
 static int fat_match(fs_node_t **, fs_node_t *, const char *);
-static int fat_node_get(fs_node_t **, dev_handle_t, fs_index_t);
+static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
 static int fat_node_open(fs_node_t *);
 static int fat_node_put(fs_node_t *);
-static int fat_create_node(fs_node_t **, dev_handle_t, int);
+static int fat_create_node(fs_node_t **, devmap_handle_t, int);
 static int fat_destroy_node(fs_node_t *);
 static int fat_link(fs_node_t *, fs_node_t *, const char *);
@@ -79 +83 @@
 static int fat_has_children(bool *, fs_node_t *);
 static fs_index_t fat_index_get(fs_node_t *);
-static size_t fat_size_get(fs_node_t *);
+static aoff64_t fat_size_get(fs_node_t *);
 static unsigned fat_lnkcnt_get(fs_node_t *);
 static char fat_plb_get_char(unsigned);
 static bool fat_is_directory(fs_node_t *);
 static bool fat_is_file(fs_node_t *node);
-static dev_handle_t fat_device_get(fs_node_t *node);
+static devmap_handle_t fat_device_get(fs_node_t *node);
 
 /*
@@ -100 +104 @@
         node->refcnt = 0;
         node->dirty = false;
+        node->lastc_cached_valid = false;
+        node->lastc_cached_value = FAT_CLST_LAST1;
+        node->currc_cached_valid = false;
+        node->currc_cached_bn = 0;
+        node->currc_cached_value = FAT_CLST_LAST1;
 }
 
@@ -107 +116 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
-        uint16_t bps;
-        unsigned dps;
         int rc;
         
         assert(node->dirty);
 
-        bs = block_bb_get(node->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
+        bs = block_bb_get(node->idx->devmap_handle);
         
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
-            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
+        rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
+            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
+            BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
 
-        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
+        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % DPS(bs));
 
         d->firstc = host2uint16_t_le(node->firstc);
@@ -139 +145 @@
 }
 
-static int fat_node_fini_by_dev_handle(dev_handle_t dev_handle)
+static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
 {
         link_t *lnk;
@@ -164 +170 @@
                         goto restart;
                 }
-                if (nodep->idx->dev_handle != dev_handle) {
+                if (nodep->idx->devmap_handle != devmap_handle) {
                         fibril_mutex_unlock(&nodep->idx->lock);
                         fibril_mutex_unlock(&nodep->lock);
@@ -265 +271 @@
         fat_dentry_t *d;
         fat_node_t *nodep = NULL;
-        unsigned bps;
-        unsigned spc;
-        unsigned dps;
         int rc;
 
@@ -296 +299 @@
                 return rc;
 
-        bs = block_bb_get(idxp->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        dps = bps / sizeof(fat_dentry_t);
+        bs = block_bb_get(idxp->devmap_handle);
 
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
-            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
+        rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL,
+            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK) {
                 (void) fat_node_put(FS_NODE(nodep));
@@ -309 +309 @@
         }
 
-        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
+        d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
         if (d->attr & FAT_ATTR_SUBDIR) {
                 /* 
@@ -323 +323 @@
                  */
                 uint16_t clusters;
-                rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
+                rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle,
                     uint16_t_le2host(d->firstc));
                 if (rc != EOK) {
@@ -329 +329 @@
                         return rc;
                 }
-                nodep->size = bps * spc * clusters;
+                nodep->size = BPS(bs) * SPC(bs) * clusters;
         } else {
                 nodep->type = FAT_FILE;
@@ -356 +356 @@
  */
 
-int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
-{
-        return fat_node_get(rfn, dev_handle, 0);
+int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
+{
+        return fat_node_get(rfn, devmap_handle, 0);
 }
 
@@ -367 +367 @@
         char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
         unsigned i, j;
-        unsigned bps;           /* bytes per sector */
-        unsigned dps;           /* dentries per sector */
         unsigned blocks;
         fat_dentry_t *d;
+        devmap_handle_t devmap_handle;
         block_t *b;
         int rc;
 
         fibril_mutex_lock(&parentp->idx->lock);
-        bs = block_bb_get(parentp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-        blocks = parentp->size / bps;
+        devmap_handle = parentp->idx->devmap_handle;
+        fibril_mutex_unlock(&parentp->idx->lock);
+
+        bs = block_bb_get(devmap_handle);
+        blocks = parentp->size / BPS(bs);
         for (i = 0; i < blocks; i++) {
                 rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&parentp->idx->lock);
+                if (rc != EOK)
                         return rc;
-                }
-                for (j = 0; j < dps; j++) { 
+                for (j = 0; j < DPS(bs); j++) { 
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -394 +392 @@
                                 /* miss */
                                 rc = block_put(b);
-                                fibril_mutex_unlock(&parentp->idx->lock);
                                 *rfn = NULL;
                                 return rc;
@@ -405 +402 @@
                                 /* hit */
                                 fat_node_t *nodep;
-                                /*
-                                 * Assume tree hierarchy for locking.  We
-                                 * already have the parent and now we are going
-                                 * to lock the child.  Never lock in the oposite
-                                 * order.
-                                 */
-                                fat_idx_t *idx = fat_idx_get_by_pos(
-                                    parentp->idx->dev_handle, parentp->firstc,
-                                    i * dps + j);
-                                fibril_mutex_unlock(&parentp->idx->lock);
+                                fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle,
+                                    parentp->firstc, i * DPS(bs) + j);
                                 if (!idx) {
                                         /*
@@ -437 +426 @@
                 }
                 rc = block_put(b);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&parentp->idx->lock);
+                if (rc != EOK)
                         return rc;
-                }
-        }
-
-        fibril_mutex_unlock(&parentp->idx->lock);
+        }
+
         *rfn = NULL;
         return EOK;
@@ -449 +435 @@
 
 /** Instantiate a FAT in-core node. */
-int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
+int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
 {
         fat_node_t *nodep;
@@ -455 +441 @@
         int rc;
 
-        idxp = fat_idx_get_by_index(dev_handle, index);
+        idxp = fat_idx_get_by_index(devmap_handle, index);
         if (!idxp) {
                 *rfn = NULL;
@@ -506 +492 @@
 }
 
-int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags)
+int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
 {
         fat_idx_t *idxp;
@@ -512 +498 @@
         fat_bs_t *bs;
         fat_cluster_t mcl, lcl;
-        uint16_t bps;
         int rc;
 
-        bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
+        bs = block_bb_get(devmap_handle);
         if (flags & L_DIRECTORY) {
                 /* allocate a cluster */
-                rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
+                rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl);
                 if (rc != EOK)
                         return rc;
                 /* populate the new cluster with unused dentries */
-                rc = fat_zero_cluster(bs, dev_handle, mcl);
+                rc = fat_zero_cluster(bs, devmap_handle, mcl);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, dev_handle, mcl);
+                        (void) fat_free_clusters(bs, devmap_handle, mcl);
                         return rc;
                 }
@@ -532 +516 @@
         rc = fat_node_get_new(&nodep);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, dev_handle, mcl);
+                (void) fat_free_clusters(bs, devmap_handle, mcl);
                 return rc;
         }
-        rc = fat_idx_get_new(&idxp, dev_handle);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, dev_handle, mcl);  
+        rc = fat_idx_get_new(&idxp, devmap_handle);
+        if (rc != EOK) {
+                (void) fat_free_clusters(bs, devmap_handle, mcl);       
                 (void) fat_node_put(FS_NODE(nodep));
                 return rc;
@@ -545 +529 @@
                 nodep->type = FAT_DIRECTORY;
                 nodep->firstc = mcl;
-                nodep->size = bps * bs->spc;
+                nodep->size = BPS(bs) * SPC(bs);
         } else {
                 nodep->type = FAT_FILE;
@@ -586 +570 @@
         assert(!has_children);
 
-        bs = block_bb_get(nodep->idx->dev_handle);
+        bs = block_bb_get(nodep->idx->devmap_handle);
         if (nodep->firstc != FAT_CLST_RES0) {
                 assert(nodep->size);
                 /* Free all clusters allocated to the node. */
-                rc = fat_free_clusters(bs, nodep->idx->dev_handle,
+                rc = fat_free_clusters(bs, nodep->idx->devmap_handle,
                     nodep->firstc);
         }
@@ -608 +592 @@
         block_t *b;
         unsigned i, j;
-        uint16_t bps;
-        unsigned dps;
         unsigned blocks;
         fat_cluster_t mcl, lcl;
@@ -638 +620 @@
         
         fibril_mutex_lock(&parentp->idx->lock);
-        bs = block_bb_get(parentp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-
-        blocks = parentp->size / bps;
+        bs = block_bb_get(parentp->idx->devmap_handle);
+
+        blocks = parentp->size / BPS(bs);
 
         for (i = 0; i < blocks; i++) {
@@ -650 +630 @@
                         return rc;
                 }
-                for (j = 0; j < dps; j++) {
+                for (j = 0; j < DPS(bs); j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -679 +659 @@
                 return ENOSPC;
         }
-        rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
+        rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl);
         if (rc != EOK) {
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
         }
-        rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
+        rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl);
+        if (rc != EOK) {
+                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
         }
-        rc = fat_append_clusters(bs, parentp, mcl);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
+        rc = fat_append_clusters(bs, parentp, mcl, lcl);
+        if (rc != EOK) {
+                (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl);
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
         }
-        parentp->size += bps * bs->spc;
+        parentp->size += BPS(bs) * SPC(bs);
         parentp->dirty = true;          /* need to sync node */
         rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
@@ -722 +702 @@
         fibril_mutex_lock(&childp->idx->lock);
         
-        /*
-         * If possible, create the Sub-directory Identifier Entry and the
-         * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
-         * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
-         * not use them anyway, so this is rather a sign of our good will.
-         */
-        rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
-        if (rc != EOK) {
+        if (childp->type == FAT_DIRECTORY) {
                 /*
-                 * Rather than returning an error, simply skip the creation of
-                 * these two entries.
+                 * If possible, create the Sub-directory Identifier Entry and
+                 * the Sub-directory Parent Pointer Entry (i.e. "." and "..").
+                 * These entries are not mandatory according to Standard
+                 * ECMA-107 and HelenOS VFS does not use them anyway, so this is
+                 * rather a sign of our good will.
                  */
-                goto skip_dots;
-        }
-        d = (fat_dentry_t *)b->data;
-        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-            str_cmp(d->name, FAT_NAME_DOT) == 0) {
-                memset(d, 0, sizeof(fat_dentry_t));
-                str_cpy(d->name, 8, FAT_NAME_DOT);
-                str_cpy(d->ext, 3, FAT_EXT_PAD);
-                d->attr = FAT_ATTR_SUBDIR;
-                d->firstc = host2uint16_t_le(childp->firstc);
-                /* TODO: initialize also the date/time members. */
-        }
-        d++;
-        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-            str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
-                memset(d, 0, sizeof(fat_dentry_t));
-                str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
-                str_cpy(d->ext, 3, FAT_EXT_PAD);
-                d->attr = FAT_ATTR_SUBDIR;
-                d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
-                    host2uint16_t_le(FAT_CLST_RES0) :
-                    host2uint16_t_le(parentp->firstc);
-                /* TODO: initialize also the date/time members. */
-        }
-        b->dirty = true;                /* need to sync block */
-        /*
-         * Ignore the return value as we would have fallen through on error
-         * anyway.
-         */
-        (void) block_put(b);
+                rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
+                if (rc != EOK) {
+                        /*
+                         * Rather than returning an error, simply skip the
+                         * creation of these two entries.
+                         */
+                        goto skip_dots;
+                }
+                d = (fat_dentry_t *) b->data;
+                if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
+                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
+                        memset(d, 0, sizeof(fat_dentry_t));
+                        str_cpy((char *) d->name, 8, FAT_NAME_DOT);
+                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
+                        d->attr = FAT_ATTR_SUBDIR;
+                        d->firstc = host2uint16_t_le(childp->firstc);
+                        /* TODO: initialize also the date/time members. */
+                }
+                d++;
+                if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
+                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
+                        memset(d, 0, sizeof(fat_dentry_t));
+                        str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
+                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
+                        d->attr = FAT_ATTR_SUBDIR;
+                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
+                            host2uint16_t_le(FAT_CLST_RES0) :
+                            host2uint16_t_le(parentp->firstc);
+                        /* TODO: initialize also the date/time members. */
+                }
+                b->dirty = true;                /* need to sync block */
+                /*
+                 * Ignore the return value as we would have fallen through on error
+                 * anyway.
+                 */
+                (void) block_put(b);
+        }
 skip_dots:
 
         childp->idx->pfc = parentp->firstc;
-        childp->idx->pdi = i * dps + j;
+        childp->idx->pdi = i * DPS(bs) + j;
         fibril_mutex_unlock(&childp->idx->lock);
 
@@ -789 +772 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
-        uint16_t bps;
         block_t *b;
         bool has_children;
@@ -807 +789 @@
         assert(childp->lnkcnt == 1);
         fibril_mutex_lock(&childp->idx->lock);
-        bs = block_bb_get(childp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-
-        rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
-            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
+        bs = block_bb_get(childp->idx->devmap_handle);
+
+        rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc,
+            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
             BLOCK_FLAGS_NONE);
         if (rc != EOK) 
                 goto error;
         d = (fat_dentry_t *)b->data +
-            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
+            (childp->idx->pdi % (BPS(bs) / sizeof(fat_dentry_t)));
         /* mark the dentry as not-currently-used */
         d->name[0] = FAT_DENTRY_ERASED;
@@ -848 +829 @@
         fat_bs_t *bs;
         fat_node_t *nodep = FAT_NODE(fn);
-        unsigned bps;
-        unsigned dps;
         unsigned blocks;
         block_t *b;
@@ -861 +840 @@
         
         fibril_mutex_lock(&nodep->idx->lock);
-        bs = block_bb_get(nodep->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-
-        blocks = nodep->size / bps;
+        bs = block_bb_get(nodep->idx->devmap_handle);
+
+        blocks = nodep->size / BPS(bs);
 
         for (i = 0; i < blocks; i++) {
@@ -875 +852 @@
                         return rc;
                 }
-                for (j = 0; j < dps; j++) {
+                for (j = 0; j < DPS(bs); j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -912 +889 @@
 }
 
-size_t fat_size_get(fs_node_t *fn)
+aoff64_t fat_size_get(fs_node_t *fn)
 {
         return FAT_NODE(fn)->size;
@@ -937 +914 @@
 }
 
-dev_handle_t fat_device_get(fs_node_t *node)
+devmap_handle_t fat_device_get(fs_node_t *node)
 {
         return 0;
@@ -969 +946 @@
 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         enum cache_mode cmode;
         fat_bs_t *bs;
-        uint16_t bps;
-        uint16_t rde;
         
         /* Accept the mount options */
@@ -993 +968 @@
 
         /* initialize libblock */
-        rc = block_init(dev_handle, BS_SIZE);
+        rc = block_init(devmap_handle, BS_SIZE);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1000 +975 @@
 
         /* prepare the boot block */
-        rc = block_bb_read(dev_handle, BS_BLOCK);
-        if (rc != EOK) {
-                block_fini(dev_handle);
+        rc = block_bb_read(devmap_handle, BS_BLOCK);
+        if (rc != EOK) {
+                block_fini(devmap_handle);
                 ipc_answer_0(rid, rc);
                 return;
@@ -1008 +983 @@
 
         /* get the buffer with the boot sector */
-        bs = block_bb_get(dev_handle);
-        
-        /* Read the number of root directory entries. */
-        bps = uint16_t_le2host(bs->bps);
-        rde = uint16_t_le2host(bs->root_ent_max);
-
-        if (bps != BS_SIZE) {
-                block_fini(dev_handle);
+        bs = block_bb_get(devmap_handle);
+        
+        if (BPS(bs) != BS_SIZE) {
+                block_fini(devmap_handle);
                 ipc_answer_0(rid, ENOTSUP);
                 return;
@@ -1021 +992 @@
 
         /* Initialize the block cache */
-        rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
-        if (rc != EOK) {
-                block_fini(dev_handle);
+        rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode);
+        if (rc != EOK) {
+                block_fini(devmap_handle);
                 ipc_answer_0(rid, rc);
                 return;
@@ -1029 +1000 @@
 
         /* Do some simple sanity checks on the file system. */
-        rc = fat_sanity_check(bs, dev_handle);
-        if (rc != EOK) {
-                (void) block_cache_fini(dev_handle);
-                block_fini(dev_handle);
+        rc = fat_sanity_check(bs, devmap_handle);
+        if (rc != EOK) {
+                (void) block_cache_fini(devmap_handle);
+                block_fini(devmap_handle);
                 ipc_answer_0(rid, rc);
                 return;
         }
 
-        rc = fat_idx_init_by_dev_handle(dev_handle);
-        if (rc != EOK) {
-                (void) block_cache_fini(dev_handle);
-                block_fini(dev_handle);
+        rc = fat_idx_init_by_devmap_handle(devmap_handle);
+        if (rc != EOK) {
+                (void) block_cache_fini(devmap_handle);
+                block_fini(devmap_handle);
                 ipc_answer_0(rid, rc);
                 return;
@@ -1048 +1019 @@
         fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
         if (!rfn) {
-                (void) block_cache_fini(dev_handle);
-                block_fini(dev_handle);
-                fat_idx_fini_by_dev_handle(dev_handle);
+                (void) block_cache_fini(devmap_handle);
+                block_fini(devmap_handle);
+                fat_idx_fini_by_devmap_handle(devmap_handle);
                 ipc_answer_0(rid, ENOMEM);
                 return;
@@ -1058 +1029 @@
         if (!rootp) {
                 free(rfn);
-                (void) block_cache_fini(dev_handle);
-                block_fini(dev_handle);
-                fat_idx_fini_by_dev_handle(dev_handle);
+                (void) block_cache_fini(devmap_handle);
+                block_fini(devmap_handle);
+                fat_idx_fini_by_devmap_handle(devmap_handle);
                 ipc_answer_0(rid, ENOMEM);
                 return;
@@ -1066 +1037 @@
         fat_node_initialize(rootp);
 
-        fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
+        fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0);
         if (!ridxp) {
                 free(rfn);
                 free(rootp);
-                (void) block_cache_fini(dev_handle);
-                block_fini(dev_handle);
-                fat_idx_fini_by_dev_handle(dev_handle);
+                (void) block_cache_fini(devmap_handle);
+                block_fini(devmap_handle);
+                fat_idx_fini_by_devmap_handle(devmap_handle);
                 ipc_answer_0(rid, ENOMEM);
                 return;
@@ -1083 +1054 @@
         rootp->refcnt = 1;
         rootp->lnkcnt = 0;      /* FS root is not linked */
-        rootp->size = rde * sizeof(fat_dentry_t);
+        rootp->size = RDE(bs) * sizeof(fat_dentry_t);
         rootp->idx = ridxp;
         ridxp->nodep = rootp;
@@ -1101 +1072 @@
 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         fs_node_t *fn;
         fat_node_t *nodep;
         int rc;
 
-        rc = fat_root_get(&fn, dev_handle);
+        rc = fat_root_get(&fn, devmap_handle);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1134 +1105 @@
          * stop using libblock for this instance.
          */
-        (void) fat_node_fini_by_dev_handle(dev_handle);
-        fat_idx_fini_by_dev_handle(dev_handle);
-        (void) block_cache_fini(dev_handle);
-        block_fini(dev_handle);
+        (void) fat_node_fini_by_devmap_handle(devmap_handle);
+        fat_idx_fini_by_devmap_handle(devmap_handle);
+        (void) block_cache_fini(devmap_handle);
+        block_fini(devmap_handle);
 
         ipc_answer_0(rid, EOK);
@@ -1154 +1125 @@
 void fat_read(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        off_t pos = (off_t)IPC_GET_ARG3(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t pos =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;
         fat_bs_t *bs;
-        uint16_t bps;
         size_t bytes;
         block_t *b;
         int rc;
 
-        rc = fat_node_get(&fn, dev_handle, index);
+        rc = fat_node_get(&fn, devmap_handle, index);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1185 +1156 @@
         }
 
-        bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
+        bs = block_bb_get(devmap_handle);
 
         if (nodep->type == FAT_FILE) {
@@ -1199 +1169 @@
                         (void) async_data_read_finalize(callid, NULL, 0);
                 } else {
-                        bytes = min(len, bps - pos % bps);
+                        bytes = min(len, BPS(bs) - pos % BPS(bs));
                         bytes = min(bytes, nodep->size - pos);
-                        rc = fat_block_get(&b, bs, nodep, pos / bps,
+                        rc = fat_block_get(&b, bs, nodep, pos / BPS(bs),
                             BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
@@ -1209 +1179 @@
                                 return;
                         }
-                        (void) async_data_read_finalize(callid, b->data + pos % bps,
-                            bytes);
+                        (void) async_data_read_finalize(callid,
+                            b->data + pos % BPS(bs), bytes);
                         rc = block_put(b);
                         if (rc != EOK) {
@@ -1220 +1190 @@
         } else {
                 unsigned bnum;
-                off_t spos = pos;
+                aoff64_t spos = pos;
                 char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
                 fat_dentry_t *d;
 
                 assert(nodep->type == FAT_DIRECTORY);
-                assert(nodep->size % bps == 0);
-                assert(bps % sizeof(fat_dentry_t) == 0);
+                assert(nodep->size % BPS(bs) == 0);
+                assert(BPS(bs) % sizeof(fat_dentry_t) == 0);
 
                 /*
@@ -1234 +1204 @@
                  * the position pointer accordingly.
                  */
-                bnum = (pos * sizeof(fat_dentry_t)) / bps;
-                while (bnum < nodep->size / bps) {
-                        off_t o;
+                bnum = (pos * sizeof(fat_dentry_t)) / BPS(bs);
+                while (bnum < nodep->size / BPS(bs)) {
+                        aoff64_t o;
 
                         rc = fat_block_get(&b, bs, nodep, bnum,
@@ -1242 +1212 @@
                         if (rc != EOK)
                                 goto err;
-                        for (o = pos % (bps / sizeof(fat_dentry_t));
-                            o < bps / sizeof(fat_dentry_t);
+                        for (o = pos % (BPS(bs) / sizeof(fat_dentry_t));
+                            o < BPS(bs) / sizeof(fat_dentry_t);
                             o++, pos++) {
                                 d = ((fat_dentry_t *)b->data) + o;
@@ -1292 +1262 @@
 void fat_write(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        off_t pos = (off_t)IPC_GET_ARG3(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t pos =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;
@@ -1300 +1271 @@
         size_t bytes, size;
         block_t *b;
-        uint16_t bps;
-        unsigned spc;
-        unsigned bpc;           /* bytes per cluster */
-        off_t boundary;
+        aoff64_t boundary;
         int flags = BLOCK_FLAGS_NONE;
         int rc;
         
-        rc = fat_node_get(&fn, dev_handle, index);
+        rc = fat_node_get(&fn, devmap_handle, index);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1327 +1295 @@
         }
 
-        bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        bpc = bps * spc;
+        bs = block_bb_get(devmap_handle);
 
         /*
@@ -1339 +1304 @@
          * value signalizing a smaller number of bytes written. 
          */ 
-        bytes = min(len, bps - pos % bps);
-        if (bytes == bps)
+        bytes = min(len, BPS(bs) - pos % BPS(bs));
+        if (bytes == BPS(bs))
                 flags |= BLOCK_FLAGS_NOREAD;
         
-        boundary = ROUND_UP(nodep->size, bpc);
+        boundary = ROUND_UP(nodep->size, BPC(bs));
         if (pos < boundary) {
                 /*
@@ -1358 +1323 @@
                         return;
                 }
-                rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
+                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
                 if (rc != EOK) {
                         (void) fat_node_put(fn);
@@ -1365 +1330 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid, b->data + pos % bps,
-                    bytes);
+                (void) async_data_write_finalize(callid,
+                    b->data + pos % BPS(bs), bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
@@ -1390 +1355 @@
                 fat_cluster_t mcl, lcl; 
  
-                nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
+                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
                 /* create an independent chain of nclsts clusters in all FATs */
-                rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
+                rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl);
                 if (rc != EOK) {
                         /* could not allocate a chain of nclsts clusters */
@@ -1403 +1368 @@
                 rc = fat_fill_gap(bs, nodep, mcl, pos);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, dev_handle, mcl);
+                        (void) fat_free_clusters(bs, devmap_handle, mcl);
                         (void) fat_node_put(fn);
                         ipc_answer_0(callid, rc);
@@ -1409 +1374 @@
                         return;
                 }
-                rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
-                    flags);
+                rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL,
+                    (pos / BPS(bs)) % SPC(bs), flags);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, dev_handle, mcl);
+                        (void) fat_free_clusters(bs, devmap_handle, mcl);
                         (void) fat_node_put(fn);
                         ipc_answer_0(callid, rc);
@@ -1418 +1383 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid, b->data + pos % bps,
-                    bytes);
+                (void) async_data_write_finalize(callid,
+                    b->data + pos % BPS(bs), bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, dev_handle, mcl);
+                        (void) fat_free_clusters(bs, devmap_handle, mcl);
                         (void) fat_node_put(fn);
                         ipc_answer_0(rid, rc);
@@ -1432 +1397 @@
                  * node's cluster chain.
                  */
-                rc = fat_append_clusters(bs, nodep, mcl);
+                rc = fat_append_clusters(bs, nodep, mcl, lcl);
                 if (rc != EOK) {
-                        (void) fat_free_clusters(bs, dev_handle, mcl);
+                        (void) fat_free_clusters(bs, devmap_handle, mcl);
                         (void) fat_node_put(fn);
                         ipc_answer_0(rid, rc);
@@ -1449 +1414 @@
 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-        size_t size = (off_t)IPC_GET_ARG3(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        aoff64_t size =
+            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
         fs_node_t *fn;
         fat_node_t *nodep;
         fat_bs_t *bs;
-        uint16_t bps;
-        uint8_t spc;
-        unsigned bpc;   /* bytes per cluster */
         int rc;
 
-        rc = fat_node_get(&fn, dev_handle, index);
+        rc = fat_node_get(&fn, devmap_handle, index);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1471 +1434 @@
         nodep = FAT_NODE(fn);
 
-        bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        bpc = bps * spc;
+        bs = block_bb_get(devmap_handle);
 
         if (nodep->size == size) {
@@ -1484 +1444 @@
                  */
                 rc = EINVAL;
-        } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
+        } else if (ROUND_UP(nodep->size, BPC(bs)) == ROUND_UP(size, BPC(bs))) {
                 /*
                  * The node will be shrunk, but no clusters will be deallocated.
@@ -1501 +1461 @@
                 } else {
                         fat_cluster_t lastc;
-                        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
-                            &lastc, NULL, (size - 1) / bpc);
+                        rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc,
+                            &lastc, NULL, (size - 1) / BPC(bs));
                         if (rc != EOK)
                                 goto out;
@@ -1526 +1486 @@
 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
 {
-        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
         fs_node_t *fn;
         int rc;
 
-        rc = fat_node_get(&fn, dev_handle, index);
+        rc = fat_node_get(&fn, devmap_handle, index);
         if (rc != EOK) {
                 ipc_answer_0(rid, rc);
@@ -1557 +1517 @@
 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        /* Dummy implementation */
-        ipc_answer_0(rid, EOK);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        
+        fs_node_t *fn;
+        int rc = fat_node_get(&fn, devmap_handle, index);
+        if (rc != EOK) {
+                ipc_answer_0(rid, rc);
+                return;
+        }
+        if (!fn) {
+                ipc_answer_0(rid, ENOENT);
+                return;
+        }
+        
+        fat_node_t *nodep = FAT_NODE(fn);
+        
+        nodep->dirty = true;
+        rc = fat_node_sync(nodep);
+        
+        fat_node_put(fn);
+        ipc_answer_0(rid, rc);
 }