Changeset 875edff6 in mainline

Timestamp:

2011-04-30T11:22:28Z (13 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

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

Children:

aa2ea13

Parents:

cb052b4

Message:

It is possible to mount FAT32 file system.
Changes:

1. 32bit fat_cluster_t
2. Change macros SF(bs) to add support FAT32 sectors per fat value
3. New macros (FAT_CLST_SIZE) for determining size of FAT cluster (2 or 4 bytes)
4. New macros (FAT_MASK) for determining necessary mask for cluster value depending on FAT type
5. fat_get_cluster support FAT32 and correctly return cluster value
6. Change fat_sanity_check() to add support FAT32. Wrapping explicit use of br→(value) with macros.

TODO: need to wrap all explicit use of br→() with appropriated macros.

Location:

uspace/srv/fs/fat

Files:

• fat.h (modified) (1 diff)
• fat_fat.c (modified) (7 diffs)
• fat_fat.h (modified) (3 diffs)

uspace/srv/fs/fat/fat.h

@@ -55 +55 @@
 #define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
 #define FATCNT(bs)      (bs)->fatcnt
-#define SF(bs)          uint16_t_le2host((bs)->sec_per_fat)
+#define SF(bs)          (uint16_t_le2host((bs)->sec_per_fat) !=0 ? \
+    uint16_t_le2host((bs)->sec_per_fat) : \
+    uint32_t_le2host(bs->fat32.sectors_per_fat))
 #define RDE(bs)         uint16_t_le2host((bs)->root_ent_max)
 #define TS(bs)          (uint16_t_le2host((bs)->totsec16) != 0 ? \

uspace/srv/fs/fat/fat_fat.c

@@ -301 +301 @@
 
         assert(fatno < FATCNT(bs));
+        
+        *value = 0;
 
         if (FAT_IS_FAT12(bs))
                 offset = (clst + clst/2);
         else
-                offset = (clst * sizeof(fat_cluster_t));
+                offset = (clst * FAT_CLST_SIZE(bs));
 
         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
@@ -313 +315 @@
 
         /* This cluster access spans a sector boundary. Check only for FAT12 */
-        if (FAT_IS_FAT12(bs) && (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) {
+        if (FAT_IS_FAT12(bs)) {
+                if ((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. It is last sector of FAT */
                                 block_put(b);
-                                return rc;
+                                return ERANGE;
                         }
-                        /*
-                         * 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. It is last sector of FAT */
-                        block_put(b);
-                        return ERANGE;
-                }
-        }
-        else
-                *value = *(fat_cluster_t *)(b->data + offset % BPS(bs));
-
-        if (FAT_IS_FAT12(bs)) {
+                }
+
                 if (clst & 0x0001)
-                *value = (*value) >> 4;
+                        *value = (*value) >> 4;
                 else
-                *value = (*value) & 0x0fff;
+                        *value = (*value) & FAT12_MASK;
+        }
+        else {
+                if (FAT_IS_FAT32(bs))
+                        *value = *(uint32_t *)(b->data + offset % BPS(bs)) & FAT32_MASK;
+                else
+                        *value = *(uint16_t *)(b->data + offset % BPS(bs));
         }
 
@@ -383 +389 @@
                 offset = (clst + clst/2);
         else
-                offset = (clst * sizeof(fat_cluster_t));
+                offset = (clst * FAT_CLST_SIZE(bs));
 
         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
@@ -734 +740 @@
 
         /* Check number of FATs. */
-        if (bs->fatcnt == 0)
+        if (FATCNT(bs) == 0)
                 return ENOTSUP;
 
         /* Check total number of sectors. */
-        if (bs->totsec16 == 0 && bs->totsec32 == 0)
+        if (TS(bs) == 0)
                 return ENOTSUP;
 
@@ -750 +756 @@
 
         /* Check number of sectors per FAT. */
-        if (bs->sec_per_fat == 0)
+        if (SF(bs) == 0)
                 return ENOTSUP;
 
@@ -760 +766 @@
          * sanitized to support file systems with this property.
          */
-        if ((uint16_t_le2host(bs->root_ent_max) * sizeof(fat_dentry_t)) %
-            uint16_t_le2host(bs->bps) != 0)
+        if (!FAT_IS_FAT32(bs) && (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)
                 return ENOTSUP;
 
         /* Check signature of each FAT. */
-        for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) {
+        for (fat_no = 0; fat_no < FATCNT(bs); fat_no++) {
                 rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0);
                 if (rc != EOK)
@@ -782 +787 @@
                  * set to one.
                  */
-                if (!FAT_IS_FAT12(bs) && ((e0 >> 8) != 0xff || e1 != 0xffff))
+                if (!FAT_IS_FAT12(bs) && ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
                         return ENOTSUP;
         }

uspace/srv/fs/fat/fat_fat.h

@@ -54 +54 @@
 #define FAT32_CLST_LAST8  0x0fffffff
 
+#define FAT12_MASK                0x0fff
+#define FAT16_MASK                0xffff
+#define FAT32_MASK                0x0fffffff
+
 #define FAT12_CLST_MAX    4085
 #define FAT16_CLST_MAX    65525
+
+/* Size in bytes for cluster value of FAT */
+#define FAT12_CLST_SIZE   2
+#define FAT16_CLST_SIZE   2
+#define FAT32_CLST_SIZE   4
 
 /* internally used to mark root directory's parent */
@@ -84 +93 @@
     (FAT_IS_FAT12(bs) ? FAT12_CLST_BAD : (FAT_IS_FAT32(bs) ? FAT32_CLST_BAD : FAT16_CLST_BAD))
 
+#define FAT_CLST_SIZE(bs)       (FAT_IS_FAT32(bs) ? FAT32_CLST_SIZE : FAT16_CLST_SIZE)
+
+#define FAT_MASK(bs) \
+    (FAT_IS_FAT12(bs) ? FAT12_MASK : (FAT_IS_FAT32(bs) ? FAT32_MASK : FAT16_MASK))
+
 /* forward declarations */
 struct block;
@@ -89 +103 @@
 struct fat_bs;
 
-typedef uint16_t fat_cluster_t;
+typedef uint32_t fat_cluster_t;
 
 #define fat_clusters_get(numc, bs, dh, fc) \