Changes in uspace/srv/fs/fat/fat_fat.c [2f636b6:c91f2d1b] in mainline

File:

• uspace/srv/fs/fat/fat_fat.c (modified) (23 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 numc          If non-NULL, output argument holding the number of
- *                      clusters seen during the walk.
+ * @param lastc         If non-NULL, output argument hodling the last cluster number visited.
  * @param max_clusters  Maximum number of clusters to visit.    
  *
- * @return              EOK on success or a negative error code.
- */
-int 
+ * @return              Number of clusters seen during the walk.
+ */
+uint16_t 
 fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
-    fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
+    fat_cluster_t *lastc, uint16_t max_clusters)
 {
         block_t *b;
@@ -87 +84 @@
                 if (lastc)
                         *lastc = firstc;
-                if (numc)
-                        *numc = 0;
-                return EOK;
+                return 0;
         }
 
@@ -103 +98 @@
                 /* read FAT1 */
                 rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
-                if (rc != EOK)
-                        return rc;
+                assert(rc == EOK);
                 clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
                 assert(clst != FAT_CLST_BAD);
                 rc = block_put(b);
-                if (rc != EOK)
-                        return rc;
+                assert(rc == EOK);
                 clusters++;
         }
@@ -115 +108 @@
         if (lastc && clst < FAT_CLST_LAST1)
                 *lastc = clst;
-        if (numc)
-                *numc = clusters;
-
-        return EOK;
+
+        return clusters;
 }
 
 /** 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.
@@ -131 +121 @@
  * @param flags         Flags passed to libblock.
  *
- * @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)
-{
+ * @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;
         unsigned bps;
         unsigned rscnt;         /* block address of the first FAT */
@@ -143 +134 @@
         unsigned sf;
         unsigned ssa;           /* size of the system area */
-        uint16_t clusters;
-        unsigned max_clusters;
+        unsigned clusters, max_clusters;
         fat_cluster_t lastc;
         int rc;
@@ -160 +150 @@
                 /* root directory special case */
                 assert(bn < rds);
-                rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
+                rc = block_get(&b, dev_handle, rscnt + bs->fatcnt * sf + bn,
                     flags);
-                return rc;
+                assert(rc == EOK);
+                return b;
         }
 
         max_clusters = bn / bs->spc;
-        rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
+        clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
             max_clusters);
-        if (rc != EOK)
-                return rc;
         assert(clusters == max_clusters);
 
-        rc = block_get(block, dev_handle,
-            ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
-
-        return rc;
+        rc = block_get(&b, dev_handle, ssa +
+            (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
+        assert(rc == EOK);
+
+        return b;
 }
 
@@ -187 +177 @@
  *                      this argument is ignored.
  * @param pos           Position in the last node block.
- *
- * @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)
+ */
+void fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
 {
         uint16_t bps;
@@ -208 +196 @@
                 int flags = (o % bps == 0) ?
                     BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
-                rc = fat_block_get(&b, bs, nodep, o / bps, flags);
-                if (rc != EOK)
-                        return rc;
+                b = fat_block_get(bs, nodep, o / bps, flags);
                 memset(b->data + o % bps, 0, bps - o % bps);
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
-                if (rc != EOK)
-                        return rc;
+                assert(rc == EOK);
         }
         
         if (o >= pos)
-                return EOK;
+                return;
         
         /* zero out the initial part of the new cluster chain */
         for (o = boundary; o < pos; o += bps) {
-                rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
+                b = _fat_block_get(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 */
                 rc = block_put(b);
-                if (rc != EOK)
-                        return rc;
-        }
-
-        return EOK;
+                assert(rc == EOK);
+        }
 }
 
@@ -242 +222 @@
  * @param dev_handle    Device handle for the file system.
  * @param clst          Cluster which to get.
- * @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)
+ *
+ * @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)
 {
         block_t *b;
         uint16_t bps;
         uint16_t rscnt;
-        fat_cluster_t *cp;
+        fat_cluster_t *cp, value;
         int rc;
 
@@ -261 +239 @@
         rc = block_get(&b, dev_handle, rscnt +
             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
-        if (rc != EOK)
-                return rc;
+        assert(rc == EOK);
         cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
-        *value = uint16_t_le2host(*cp);
+        value = uint16_t_le2host(*cp);
         rc = block_put(b);
-        
-        return rc;
+        assert(rc == EOK);
+        
+        return value;
 }
 
@@ -277 +255 @@
  * @param clst          Cluster which is to be set.
  * @param value         Value to set the cluster with.
- *
- * @return              EOK on success or a negative error code.
- */
-int
+ */
+void
 fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t value)
@@ -298 +274 @@
         rc = block_get(&b, dev_handle, rscnt + sf * fatno +
             (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
-        if (rc != EOK)
-                return rc;
+        assert(rc == EOK);
         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);
-        return rc;
+        assert(rc == EOK);
 }
 
@@ -313 +288 @@
  * @param lifo          Chain of allocated clusters.
  * @param nclsts        Number of clusters in the lifo chain.
- *
- * @return              EOK on success or a negative error code.
- */
-int fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
+ */
+void 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++) {
-                        rc = fat_set_cluster(bs, dev_handle, fatno, lifo[c],
+                        fat_set_cluster(bs, dev_handle, fatno, lifo[c],
                             c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
-                        if (rc != EOK)
-                                return rc;
                 }
         }
-
-        return EOK;
 }
 
@@ -379 +347 @@
         for (b = 0, cl = 0; b < sf; b++) {
                 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++) {
                         fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
@@ -396 +362 @@
                                         /* we are almost done */
                                         rc = block_put(blk);
-                                        if (rc != EOK)
-                                                goto error;
+                                        assert(rc == EOK);
                                         /* update the shadow copies of FAT */
-                                        rc = fat_alloc_shadow_clusters(bs,
+                                        fat_alloc_shadow_clusters(bs,
                                             dev_handle, lifo, nclsts);
-                                        if (rc != EOK)
-                                                goto error;
                                         *mcl = lifo[found - 1];
                                         *lcl = lifo[0];
@@ -412 +375 @@
                 }
                 rc = block_put(blk);
-                if (rc != EOK) {
-error:
-                        fibril_mutex_unlock(&fat_alloc_lock);
-                        free(lifo);
-                        return rc;
-                }
+                assert(rc == EOK);
         }
         fibril_mutex_unlock(&fat_alloc_lock);
@@ -426 +384 @@
          */
         while (found--) {
-                rc = fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
+                fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
                     FAT_CLST_RES0);
-                if (rc != EOK) {
-                        free(lifo);
-                        return rc;
-                }
         }
         
@@ -443 +397 @@
  * @param dev_handle    Device handle of the file system.
  * @param firstc        First cluster in the chain which is to be freed.
- *
- * @return              EOK on success or a negative return code.
- */
-int
+ */
+void
 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);
-                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,
+                nextc = fat_get_cluster(bs, dev_handle, firstc);
+                for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+                        fat_set_cluster(bs, dev_handle, fatno, firstc,
                             FAT_CLST_RES0);
-                        if (rc != EOK)
-                                return rc;
-                }
-
                 firstc = nextc;
         }
-
-        return EOK;
 }
 
@@ -477 +420 @@
  * @param nodep         Node representing the file.
  * @param mcl           First cluster of the cluster chain to append.
- *
- * @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)
+ */
+void 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;
-        int rc;
-
-        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
-            (uint16_t) -1);
-        if (rc != EOK)
-                return rc;
-
-        if (numc == 0) {
+
+        if (fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl,
+            (uint16_t) -1) == 0) {
                 /* No clusters allocated to the node yet. */
                 nodep->firstc = mcl;
                 nodep->dirty = true;            /* need to sync node */
-                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;
+                return;
+        }
+
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+                fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, mcl);
 }
 
@@ -517 +446 @@
  *                      argument is FAT_CLST_RES0, then all clusters will
  *                      be chopped off.
- *
- * @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;
-
+ */
+void fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
+{
         dev_handle_t dev_handle = nodep->idx->dev_handle;
         if (lastc == FAT_CLST_RES0) {
                 /* The node will have zero size and no clusters allocated. */
-                rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
-                if (rc != EOK)
-                        return rc;
+                fat_free_clusters(bs, dev_handle, nodep->firstc);
                 nodep->firstc = FAT_CLST_RES0;
                 nodep->dirty = true;            /* need to sync node */
@@ -536 +459 @@
                 unsigned fatno;
 
-                rc = fat_get_cluster(bs, dev_handle, lastc, &nextc);
-                if (rc != EOK)
-                        return rc;
+                nextc = fat_get_cluster(bs, dev_handle, lastc);
 
                 /* Terminate the cluster chain in all copies of FAT. */
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
-                            FAT_CLST_LAST1);
-                        if (rc != EOK)
-                                return rc;
-                }
+                for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+                        fat_set_cluster(bs, dev_handle, fatno, lastc, FAT_CLST_LAST1);
 
                 /* Free all following clusters. */
-                rc = fat_free_clusters(bs, dev_handle, nextc);
-                if (rc != EOK)
-                        return rc;
-        }
-
-        return EOK;
-}
-
-int
+                fat_free_clusters(bs, dev_handle, nextc);
+        }
+}
+
+void
 fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
 {
@@ -568 +481 @@
         
         for (i = 0; i < bs->spc; i++) {
-                rc = _fat_block_get(&b, bs, dev_handle, c, i,
-                    BLOCK_FLAGS_NOREAD);
-                if (rc != EOK)
-                        return rc;
+                b = _fat_block_get(bs, dev_handle, c, i, BLOCK_FLAGS_NOREAD);
                 memset(b->data, 0, bps);
                 b->dirty = true;
                 rc = block_put(b);
-                if (rc != EOK)
-                        return rc;
-        }
-
-        return EOK;
+                assert(rc == EOK);
+        }
 }