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

Timestamp:

2009-09-03T14:46:17Z (16 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

2f636b6

Parents:

dc87ad11

Message:

Make fat_append_clusters(), fat_chop_clusters(), fat_free_clusters(),
fat_alloc_shadow_clusters(), fat_set_cluster(), fat_fill_gap() and
fat_zero_cluster() return an error code.

File:

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

uspace/srv/fs/fat/fat_fat.c

@@ -187 +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;
@@ -207 +209 @@
                     BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
                 rc = fat_block_get(&b, bs, nodep, o / bps, flags);
-                assert(rc == EOK);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data + o % bps, 0, bps - o % bps);
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
-                assert(rc == EOK);
+                if (rc != EOK)
+                        return rc;
         }
         
         if (o >= pos)
-                return;
+                return EOK;
         
         /* zero out the initial part of the new cluster chain */
@@ -221 +225 @@
                 rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
                     (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
-                assert(rc == EOK);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data, 0, min(bps, pos - o));
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
-                assert(rc == EOK);
-        }
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
 }
 
@@ -269 +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)
@@ -288 +298 @@
         rc = block_get(&b, dev_handle, rscnt + sf * fatno +
             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
-        assert(rc == EOK);
+        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 */
         rc = block_put(b);
-        assert(rc == EOK);
+        return rc;
 }
 
@@ -302 +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;
 }
 
@@ -378 +396 @@
                                         assert(rc == EOK);
                                         /* update the shadow copies of FAT */
-                                        fat_alloc_shadow_clusters(bs,
+                                        rc = fat_alloc_shadow_clusters(bs,
                                             dev_handle, lifo, nclsts);
+                                        assert(rc == EOK);
                                         *mcl = lifo[found - 1];
                                         *lcl = lifo[0];
@@ -398 +417 @@
          */
         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;
+                }
         }
         
@@ -411 +434 @@
  * @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)
 {
@@ -423 +448 @@
                 assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
                 rc = fat_get_cluster(bs, dev_handle, firstc, &nextc);
-                assert(rc == EOK);
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
-                        fat_set_cluster(bs, dev_handle, fatno, firstc,
+                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;
 }
 
@@ -436 +468 @@
  * @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;
@@ -447 +481 @@
         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
             (uint16_t) -1);
-        assert(rc == EOK);
+        if (rc != EOK)
+                return rc;
 
         if (numc == 0) {
@@ -453 +488 @@
                 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;
 }
 
@@ -467 +508 @@
  *                      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;
@@ -475 +518 @@
         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 */
@@ -483 +528 @@
 
                 rc = fat_get_cluster(bs, dev_handle, lastc, &nextc);
-                assert(rc == EOK);
+                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)
 {
@@ -507 +561 @@
                 rc = _fat_block_get(&b, bs, dev_handle, c, i,
                     BLOCK_FLAGS_NOREAD);
-                assert(rc == EOK);
+                if (rc != EOK)
+                        return rc;
                 memset(b->data, 0, bps);
                 b->dirty = true;
                 rc = block_put(b);
-                assert(rc == EOK);
-        }
+                if (rc != EOK)
+                        return rc;
+        }
+
+        return EOK;
 }