Changeset 1787e527 in mainline for uspace/srv/fs/fat/fat_fat.c

Timestamp:

2009-11-16T21:22:54Z (14 years ago)

Author:

Lenka Trochtova <trochtova.lenka@…>

Branches:

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

Children:

5ebdf94

Parents:

fcbd1be (diff), 9c70ed6 (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:

merged with head (unstable)

File:

• uspace/srv/fs/fat/fat_fat.c (modified) (27 diffs)

uspace/srv/fs/fat/fat_fat.c

@@ -61 +61 @@
  * @param dev_handle    Device handle of the device with the file.
  * @param firstc        First cluster to start the walk with.
- * @param lastc         If non-NULL, output argument hodling the last cluster number visited.
+ * @param lastc         If non-NULL, output argument hodling the last cluster
+ *                      number visited.
+ * @param numc          If non-NULL, output argument holding the number of
+ *                      clusters seen during the walk.
  * @param max_clusters  Maximum number of clusters to visit.    
  *
- * @return              Number of clusters seen during the walk.
- */
-uint16_t 
+ * @return              EOK on success or a negative error code.
+ */
+int 
 fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
-    fat_cluster_t *lastc, uint16_t max_clusters)
+    fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
 {
         block_t *b;
@@ -75 +78 @@
         uint16_t clusters = 0;
         fat_cluster_t clst = firstc;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
@@ -83 +87 @@
                 if (lastc)
                         *lastc = firstc;
-                return 0;
+                if (numc)
+                        *numc = 0;
+                return EOK;
         }
 
@@ -96 +102 @@
                 fidx = clst % (bps / sizeof(fat_cluster_t));
                 /* read FAT1 */
-                b = block_get(dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
+                rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
+                if (rc != EOK)
+                        return rc;
                 clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
                 assert(clst != FAT_CLST_BAD);
-                block_put(b);
+                rc = block_put(b);
+                if (rc != EOK)
+                        return rc;
                 clusters++;
         }
@@ -105 +115 @@
         if (lastc && clst < FAT_CLST_LAST1)
                 *lastc = clst;
-
-        return clusters;
+        if (numc)
+                *numc = clusters;
+
+        return EOK;
 }
 
 /** Read block from file located on a FAT file system.
  *
+ * @param block         Pointer to a block pointer for storing result.
  * @param bs            Buffer holding the boot sector of the file system.
  * @param dev_handle    Device handle of the file system.
@@ -118 +131 @@
  * @param flags         Flags passed to libblock.
  *
- * @return              Block structure holding the requested block.
- */
-block_t *
-_fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
-    bn_t bn, int flags)
-{
-        block_t *b;
+ * @return              EOK on success or a negative error code.
+ */
+int
+_fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
+    fat_cluster_t firstc, bn_t bn, int flags)
+{
         unsigned bps;
         unsigned rscnt;         /* block address of the first FAT */
@@ -131 +143 @@
         unsigned sf;
         unsigned ssa;           /* size of the system area */
-        unsigned clusters, max_clusters;
+        uint16_t clusters;
+        unsigned max_clusters;
         fat_cluster_t lastc;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
@@ -146 +160 @@
                 /* root directory special case */
                 assert(bn < rds);
-                b = block_get(dev_handle, rscnt + bs->fatcnt * sf + bn, flags);
-                return b;
+                rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
+                    flags);
+                return rc;
         }
 
         max_clusters = bn / bs->spc;
-        clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
+        rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
             max_clusters);
+        if (rc != EOK)
+                return rc;
         assert(clusters == max_clusters);
 
-        b = block_get(dev_handle, ssa + (lastc - FAT_CLST_FIRST) * bs->spc +
-            bn % bs->spc, flags);
-
-        return b;
+        rc = block_get(block, dev_handle,
+            ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
+
+        return rc;
 }
 
@@ -170 +187 @@
  *                      this argument is ignored.
  * @param pos           Position in the last node block.
- */
-void fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
 {
         uint16_t bps;
@@ -177 +196 @@
         block_t *b;
         off_t o, boundary;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
@@ -188 +208 @@
                 int flags = (o % bps == 0) ?
                     BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
-                b = fat_block_get(bs, nodep, o / bps, flags);
+                rc = fat_block_get(&b, bs, nodep, o / bps, flags);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data + o % bps, 0, bps - o % bps);
                 b->dirty = true;                /* need to sync node */
-                block_put(b);
+                rc = block_put(b);
+                if (rc != EOK)
+                        return rc;
         }
         
         if (o >= pos)
-                return;
+                return EOK;
         
         /* zero out the initial part of the new cluster chain */
         for (o = boundary; o < pos; o += bps) {
-                b = _fat_block_get(bs, nodep->idx->dev_handle, mcl,
+                rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
                     (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data, 0, min(bps, pos - o));
                 b->dirty = true;                /* need to sync node */
-                block_put(b);
-        }
+                rc = block_put(b);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
 }
 
@@ -212 +242 @@
  * @param dev_handle    Device handle for the file system.
  * @param clst          Cluster which to get.
- *
- * @return              Value found in the cluster.
- */
-fat_cluster_t
-fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst)
+ * @param value         Output argument holding the value of the cluster.
+ *
+ * @return              EOK or a negative error code.
+ */
+int
+fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst,
+    fat_cluster_t *value)
 {
         block_t *b;
         uint16_t bps;
         uint16_t rscnt;
-        fat_cluster_t *cp, value;
+        fat_cluster_t *cp;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
         rscnt = uint16_t_le2host(bs->rscnt);
 
-        b = block_get(dev_handle, rscnt + (clst * sizeof(fat_cluster_t)) / bps,
-            BLOCK_FLAGS_NONE);
+        rc = block_get(&b, dev_handle, rscnt +
+            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
         cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
-        value = uint16_t_le2host(*cp);
-        block_put(b);
-        
-        return value;
+        *value = uint16_t_le2host(*cp);
+        rc = block_put(b);
+        
+        return rc;
 }
 
@@ -242 +277 @@
  * @param clst          Cluster which is to be set.
  * @param value         Value to set the cluster with.
- */
-void
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int
 fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t value)
@@ -252 +289 @@
         uint16_t sf;
         fat_cluster_t *cp;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
@@ -258 +296 @@
 
         assert(fatno < bs->fatcnt);
-        b = block_get(dev_handle, rscnt + sf * fatno +
+        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
         cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
         *cp = host2uint16_t_le(value);
         b->dirty = true;                /* need to sync block */
-        block_put(b);
+        rc = block_put(b);
+        return rc;
 }
 
@@ -272 +313 @@
  * @param lifo          Chain of allocated clusters.
  * @param nclsts        Number of clusters in the lifo chain.
- */
-void fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
     fat_cluster_t *lifo, unsigned nclsts)
 {
         uint8_t fatno;
         unsigned c;
+        int rc;
 
         for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
                 for (c = 0; c < nclsts; c++) {
-                        fat_set_cluster(bs, dev_handle, fatno, lifo[c],
+                        rc = fat_set_cluster(bs, dev_handle, fatno, lifo[c],
                             c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
+                        if (rc != EOK)
+                                return rc;
                 }
         }
+
+        return EOK;
 }
 
@@ -311 +359 @@
         uint16_t rscnt;
         uint16_t sf;
+        uint16_t ts;
+        unsigned rde;
+        unsigned rds;
+        unsigned ssa;
         block_t *blk;
         fat_cluster_t *lifo;    /* stack for storing free cluster numbers */ 
         unsigned found = 0;     /* top of the free cluster number stack */
         unsigned b, c, cl; 
+        int rc;
 
         lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
@@ -323 +376 @@
         rscnt = uint16_t_le2host(bs->rscnt);
         sf = uint16_t_le2host(bs->sec_per_fat);
+        rde = uint16_t_le2host(bs->root_ent_max);
+        ts = uint16_t_le2host(bs->totsec16);
+
+        rds = (sizeof(fat_dentry_t) * rde) / bps;
+        rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+        ssa = rscnt + bs->fatcnt * sf + rds;
         
         /*
@@ -329 +388 @@
         fibril_mutex_lock(&fat_alloc_lock);
         for (b = 0, cl = 0; b < sf; b++) {
-                blk = block_get(dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
+                rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
+                if (rc != EOK)
+                        goto error;
                 for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
+                        /*
+                         * Check if the cluster is physically there. This check
+                         * becomes necessary when the file system is created
+                         * with fewer total sectors than how many is inferred
+                         * from the size of the file allocation table.
+                         */
+                        if ((cl - 2) * bs->spc + ssa >= ts) {
+                                rc = block_put(blk);
+                                if (rc != EOK)
+                                        goto error;
+                                goto out;
+                        }
+
                         fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
                         if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {
@@ -344 +418 @@
                                 if (++found == nclsts) {
                                         /* we are almost done */
-                                        block_put(blk);
+                                        rc = block_put(blk);
+                                        if (rc != EOK)
+                                                goto error;
                                         /* update the shadow copies of FAT */
-                                        fat_alloc_shadow_clusters(bs,
+                                        rc = fat_alloc_shadow_clusters(bs,
                                             dev_handle, lifo, nclsts);
+                                        if (rc != EOK)
+                                                goto error;
                                         *mcl = lifo[found - 1];
                                         *lcl = lifo[0];
@@ -356 +434 @@
                         }
                 }
-                block_put(blk);
-        }
+                rc = block_put(blk);
+                if (rc != EOK) {
+error:
+                        fibril_mutex_unlock(&fat_alloc_lock);
+                        free(lifo);
+                        return rc;
+                }
+        }
+out:
         fibril_mutex_unlock(&fat_alloc_lock);
 
@@ -365 +450 @@
          */
         while (found--) {
-                fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
+                rc = fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
                     FAT_CLST_RES0);
+                if (rc != EOK) {
+                        free(lifo);
+                        return rc;
+                }
         }
         
@@ -378 +467 @@
  * @param dev_handle    Device handle of the file system.
  * @param firstc        First cluster in the chain which is to be freed.
- */
-void
+ *
+ * @return              EOK on success or a negative return code.
+ */
+int
 fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc)
 {
         unsigned fatno;
         fat_cluster_t nextc;
+        int rc;
 
         /* Mark all clusters in the chain as free in all copies of FAT. */
         while (firstc < FAT_CLST_LAST1) {
                 assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
-                nextc = fat_get_cluster(bs, dev_handle, firstc);
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
-                        fat_set_cluster(bs, dev_handle, fatno, firstc,
+                rc = fat_get_cluster(bs, dev_handle, firstc, &nextc);
+                if (rc != EOK)
+                        return rc;
+                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
+                        rc = fat_set_cluster(bs, dev_handle, fatno, firstc,
                             FAT_CLST_RES0);
+                        if (rc != EOK)
+                                return rc;
+                }
+
                 firstc = nextc;
         }
+
+        return EOK;
 }
 
@@ -401 +501 @@
  * @param nodep         Node representing the file.
  * @param mcl           First cluster of the cluster chain to append.
- */
-void fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
 {
         dev_handle_t dev_handle = nodep->idx->dev_handle;
         fat_cluster_t lcl;
+        uint16_t numc;
         uint8_t fatno;
-
-        if (fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl,
-            (uint16_t) -1) == 0) {
+        int rc;
+
+        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
+            (uint16_t) -1);
+        if (rc != EOK)
+                return rc;
+
+        if (numc == 0) {
                 /* No clusters allocated to the node yet. */
                 nodep->firstc = mcl;
                 nodep->dirty = true;            /* need to sync node */
-                return;
-        }
-
-        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
-                fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, mcl);
+                return EOK;
+        }
+
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
+                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl,
+                    mcl);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
 }
 
@@ -427 +541 @@
  *                      argument is FAT_CLST_RES0, then all clusters will
  *                      be chopped off.
- */
-void fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
-{
+ *
+ * @return              EOK on success or a negative return code.
+ */
+int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
+{
+        int rc;
+
         dev_handle_t dev_handle = nodep->idx->dev_handle;
         if (lastc == FAT_CLST_RES0) {
                 /* The node will have zero size and no clusters allocated. */
-                fat_free_clusters(bs, dev_handle, nodep->firstc);
+                rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
+                if (rc != EOK)
+                        return rc;
                 nodep->firstc = FAT_CLST_RES0;
                 nodep->dirty = true;            /* need to sync node */
@@ -440 +560 @@
                 unsigned fatno;
 
-                nextc = fat_get_cluster(bs, dev_handle, lastc);
+                rc = fat_get_cluster(bs, dev_handle, lastc, &nextc);
+                if (rc != EOK)
+                        return rc;
 
                 /* Terminate the cluster chain in all copies of FAT. */
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
-                        fat_set_cluster(bs, dev_handle, fatno, lastc, FAT_CLST_LAST1);
+                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
+                        rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
+                            FAT_CLST_LAST1);
+                        if (rc != EOK)
+                                return rc;
+                }
 
                 /* Free all following clusters. */
-                fat_free_clusters(bs, dev_handle, nextc);
-        }
-}
-
-void
+                rc = fat_free_clusters(bs, dev_handle, nextc);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
+}
+
+int
 fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
 {
@@ -457 +587 @@
         block_t *b;
         unsigned bps;
+        int rc;
 
         bps = uint16_t_le2host(bs->bps);
         
         for (i = 0; i < bs->spc; i++) {
-                b = _fat_block_get(bs, dev_handle, c, i, BLOCK_FLAGS_NOREAD);
+                rc = _fat_block_get(&b, bs, dev_handle, c, i,
+                    BLOCK_FLAGS_NOREAD);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data, 0, bps);
                 b->dirty = true;
-                block_put(b);
-        }
+                rc = block_put(b);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
 }