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

Timestamp:

2011-04-09T19:23:12Z (14 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

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

Children:

d260a95

Parents:

fc35e98

Message:

Full support for FAT12 file system. Correct creating directories and files. Fixing addressing issue.
Type of FAT (12,16,32) is determined only on the basis of the count of clusters(according to Microsoft FAT specification). I.e. FAT
with 4085 clusters or less will be determined as FAT12. FAT16 must contain more than 4085 clusters but less then 65525.

File:

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

uspace/srv/fs/fat/fat_fat.c

@@ -29 +29 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 /**
@@ -53 +53 @@
  * primitive boot sector members.
  */
-#define RDS(bs)         ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \
-                        (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0)
-#define SSA(bs)         (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs))
-
 #define CLBN2PBN(bs, cl, bn) \
         (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
@@ -64 +60 @@
  * during allocation of clusters. The lock does not have to be held durring
  * deallocation of clusters.
- */  
+ */
 static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock);
 
@@ -76 +72 @@
  * @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.    
+ * @param max_clusters  Maximum number of clusters to visit.
  *
  * @return              EOK on success or a negative error code.
  */
-int 
+int
 fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc,
     fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
@@ -105 +101 @@
 
                 /* read FAT1 */
-                /* We should use fat_get_cluster instead */
                 rc = fat_get_cluster(bs, devmap_handle, FAT1, clst, &clst);
                 if (rc != EOK)
@@ -145 +140 @@
                 return ELIMIT;
 
-        if (nodep->firstc == FAT_CLST_ROOT) 
+        if (nodep->firstc == FAT_CLST_ROOT)
                 goto fall_through;
 
@@ -172 +167 @@
         if (rc != EOK)
                 return rc;
-        
+
         /*
          * Update the "current" cluster cache.
@@ -192 +187 @@
  * @param clp           If not NULL, address where the cluster containing bn
  *                      will be stored.
- *                      stored 
+ *                      stored
  * @param bn            Block number.
  * @param flags         Flags passed to libblock.
@@ -269 +264 @@
                         return rc;
         }
-        
+
         if (o >= pos)
                 return EOK;
-        
+
         /* zero out the initial part of the new cluster chain */
         for (o = boundary; o < pos; o += BPS(bs)) {
@@ -302 +297 @@
     fat_cluster_t clst, fat_cluster_t *value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
-        aoff64_t fsec;  /* sector offset relative to FAT */
-        unsigned fidx;  /* entry index */
+        block_t *b, *b1;
+        aoff64_t offset;
         int rc;
 
         assert(fatno < FATCNT(bs));
 
-
         if (FATTYPE(bs) == 16)
-        {
-            fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
-            fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
+            offset = (clst * 2);
+        else
+            offset = (clst + clst/2);
+
+        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
+                       offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        /* This cluster access spans a sector boundary. Check only for FAT12 */
+        if (FATTYPE(bs) == 12 && (offset % BPS(bs)+1 == BPS(bs))) {
+            /* Is it last sector of FAT? */
+            if (offset / BPS(bs) < SF(bs)) { /* NO */
+                /* Reading next sector */
+                rc = block_get(&b1, devmap_handle, 1+RSCNT(bs)+SF(bs)*fatno +
+                               offset / BPS(bs), BLOCK_FLAGS_NONE);
+                if (rc != EOK) {
+                    block_put(b);
+                    return rc;
+                }
+                /*
+                 * Combining value with last byte of current sector and
+                 * first byte of next sector
+                 */
+                *value  = *(uint8_t *)(b->data + BPS(bs) - 1);
+                *value |= *(uint8_t *)(b1->data);
+
+                rc = block_put(b1);
+                if (rc != EOK) {
+                    block_put(b);
+                    return rc;
+                }
+            }
+            else {      /* YES */
+                block_put(b);
+                return ERANGE;
+            }
         }
         else
-        {
-            fsec = (clst + clst/2) / BPS(bs);
-            fidx = clst % (2 * BPS(bs) / 3 );
-        }
-
-        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
-                       fsec, BLOCK_FLAGS_NONE);
-        if (rc != EOK)
-                return rc;
-
-        if (FATTYPE(bs) == 16)
-            cp = &((fat_cluster_t *)b->data)[fidx];
-        else
-            cp = (fat_cluster_t *)(b->data + fidx);
-
-        *value = *cp;
-
-        if (FATTYPE(bs) == 12)
-        {
+            *value = *(fat_cluster_t *)(b->data + offset % BPS(bs));
+
+        if (FATTYPE(bs) == 12) {
             if (clst & 0x0001)
                 *value = (*value) >> 4;
@@ -344 +354 @@
         *value = uint16_t_le2host(*value);
         rc = block_put(b);
-        
+
         return rc;
 }
@@ -362 +372 @@
     fat_cluster_t clst, fat_cluster_t value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
-        int rc;
-        aoff64_t fsec;  /* sector offset relative to FAT */
-        unsigned fidx;  /* entry index */
+        block_t *b, *b1;
+        aoff64_t offset;
+        fat_cluster_t *cp, temp;
+        int rc;
+        int spans = 0;
 
         assert(fatno < FATCNT(bs));
 
         if (FATTYPE(bs) == 16)
-        {
-            fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
-            fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
+            offset = (clst * sizeof(fat_cluster_t));
+        else
+            offset = (clst + clst/2);
+
+        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
+                       offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        /* This cluster access spans a sector boundary. Check only for FAT12 */
+        if (FATTYPE(bs) == 12 && (offset % BPS(bs)+1 == BPS(bs))) {
+            /* Is it last sector of FAT? */
+            if (offset / BPS(bs) < SF(bs)) { /* NO */
+                /* Reading next sector */
+                rc = block_get(&b1, devmap_handle, 1+RSCNT(bs)+SF(bs)*fatno +
+                               offset / BPS(bs), BLOCK_FLAGS_NONE);
+                if (rc != EOK) {
+                    block_put(b);
+                    return rc;
+                }
+                /*
+                 * Combining value with last byte of current sector and
+                 * first byte of next sector
+                 */
+                spans=1;
+                cp = &temp;
+                *cp  = *(uint8_t *)(b->data + BPS(bs) - 1);
+                *cp |= *(uint8_t *)(b1->data);
+            }
+            else {      /* YES */
+                block_put(b);
+                return ERANGE;
+            }
         }
         else
-        {
-            fsec = (clst + clst/2) / BPS(bs);
-            fidx = clst % (2 * BPS(bs) / 3 );
-        }
-
-        rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
-                       fsec, BLOCK_FLAGS_NONE);
-        if (rc != EOK)
-                return rc;
-
-        if (FATTYPE(bs) == 12)
-        {
-            cp = (fat_cluster_t *)(b->data + fidx);
-            if (clst & 0x0001)
+            cp = (fat_cluster_t *)(b->data + offset % BPS(bs));
+
+        value = host2uint16_t_le(value);
+        if (FATTYPE(bs) == 12) {
+            if (clst & 0x0001) {
+                *cp &= 0x000f;
+                *cp |= value << 4;
+            }
+            else {
+                *cp &= 0xf000;
+                *cp |= value & 0x0fff;
+            }
+
+            if (spans)
             {
-                *cp &= 0x000f;
-                *cp |= host2uint16_t_le(value) << 4;
-            }
-            else
-            {
-                *cp &= 0xf000;
-                *cp |= host2uint16_t_le(value) & 0x0fff;
+                *(uint8_t *)(b->data + BPS(bs) - 1) = cp[0];
+                *(uint8_t *)(b1->data) = cp[1];
+
+                b1->dirty = true;
+                rc = block_put(b1);
+                if (rc != EOK) {
+                    block_put(b);
+                    return rc;
+                }
             }
         }
         else
-        {
-            cp = &((fat_cluster_t *)b->data)[fidx];
-            *cp = host2uint16_t_le(value);
-        }
+            *cp = value;
 
         b->dirty = true;                /* need to sync block */
@@ -464 +503 @@
         fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
         unsigned found = 0;     /* top of the free cluster number stack */
-        fat_cluster_t clst, max_clst, value;
+        fat_cluster_t clst, value;
         int rc = EOK;
         uint16_t clst_last1 = FATTYPE(bs) == 16 ? FAT16_CLST_LAST1 :
                                                   FAT12_CLST_LAST1;
 
-
         lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
         if (!lifo)
                 return ENOMEM;
-
         /*
          * Search FAT1 for unused clusters.
          */
-
-        if (FATTYPE(bs) == 16)
-            max_clst = SF(bs) * BPS(bs) / sizeof(fat_cluster_t);
-        else
-            max_clst = 2 *SF(bs) * BPS(bs) / 3;
-
         fibril_mutex_lock(&fat_alloc_lock);
-        for (clst=0; clst < max_clst && found < nclsts; clst++)
-        {
+        for (clst=FAT_CLST_FIRST; clst < CC(bs)+2 && found < nclsts; clst++) {
             rc = fat_get_cluster(bs, devmap_handle, FAT1, clst, &value);
             if (rc != EOK)
                 break;
-            /*
-            * Check if the entire 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
-            * or when the last cluster ends beyond the end of the
-            * device.
-            */
-            if ((clst >= FAT_CLST_FIRST) &&
-                CLBN2PBN(bs, clst, SPC(bs) - 1) >= TS(bs)) {
-                    rc = EIO;
-                    break;
-            }
+
             if (value == FAT_CLST_RES0) {
                 /*
@@ -518 +536 @@
         }
 
-        if (rc == EOK && found == nclsts)
-        {
+        if (rc == EOK && found == nclsts) {
             rc = fat_alloc_shadow_clusters(bs, devmap_handle, lifo, nclsts);
-            if (rc == EOK)
-            {
+            if (rc == EOK) {
                 *mcl = lifo[found - 1];
                 *lcl = lifo[0];
@@ -532 +548 @@
 
         /* If something wrong - free the clusters */
-        if (found > 0)
-        {
+        if (found > 0) {
             while (found--) {
                 rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found],
@@ -735 +750 @@
 
         if (bs->totsec16 != 0 && bs->totsec32 != 0 &&
-            bs->totsec16 != bs->totsec32) 
+            bs->totsec16 != bs->totsec32)
                 return ENOTSUP;
 
@@ -775 +790 @@
                  * set to one.
                  */
-                /* Disabled for testing FAT12
-                if ((e0 >> 8) != 0xff || e1 != 0xffff)
+                if (FATTYPE(bs)!=12 && ((e0 >> 8) != 0xff || e1 != 0xffff))
                         return ENOTSUP;
-                */
         }
 
@@ -786 +799 @@
 /**
  * @}
- */ 
+ */