Changes in / [933cadf:3dbe4ca2] in mainline

Location:

uspace/srv/fs/fat

Files:

• fat_fat.c (modified) (22 diffs)
• fat_fat.h (modified) (3 diffs)
• fat_ops.c (modified) (32 diffs)

uspace/srv/fs/fat/fat_fat.c

@@ -29 +29 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 /**
@@ -54 +54 @@
  * 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)))
@@ -65 +61 @@
  * during allocation of clusters. The lock does not have to be held durring
  * deallocation of clusters.
- */  
+ */
 static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock);
 
@@ -77 +73 @@
  * @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)
 {
-        block_t *b;
         uint16_t clusters = 0;
-        fat_cluster_t clst = firstc;
+        fat_cluster_t clst = firstc, clst_last1 = FAT_CLST_LAST1(bs);
+        fat_cluster_t clst_bad = FAT_CLST_BAD(bs);
         int rc;
 
@@ -99 +95 @@
         }
 
-        while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
-                aoff64_t fsec;  /* sector offset relative to FAT1 */
-                unsigned fidx;  /* FAT1 entry index */
-
+        while (clst < clst_last1 && clusters < max_clusters) {
                 assert(clst >= FAT_CLST_FIRST);
                 if (lastc)
                         *lastc = clst;  /* remember the last cluster number */
-                fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
-                fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
+
                 /* read FAT1 */
-                rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec,
-                    BLOCK_FLAGS_NONE);
-                if (rc != EOK)
-                        return rc;
-                clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-                assert(clst != FAT_CLST_BAD);
-                rc = block_put(b);
-                if (rc != EOK)
-                        return rc;
+                rc = fat_get_cluster(bs, devmap_handle, FAT1, clst, &clst);
+                if (rc != EOK)
+                        return rc;
+
+                assert(clst != clst_bad);
                 clusters++;
         }
 
-        if (lastc && clst < FAT_CLST_LAST1)
+        if (lastc && clst < clst_last1)
                 *lastc = clst;
         if (numc)
@@ -151 +139 @@
                 return ELIMIT;
 
-        if (nodep->firstc == FAT_CLST_ROOT) 
+        if (nodep->firstc == FAT_CLST_ROOT)
                 goto fall_through;
 
@@ -178 +166 @@
         if (rc != EOK)
                 return rc;
-        
+
         /*
          * Update the "current" cluster cache.
@@ -198 +186 @@
  * @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.
@@ -275 +263 @@
                         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)) {
@@ -308 +296 @@
     fat_cluster_t clst, fat_cluster_t *value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
-        int rc;
+        block_t *b, *b1;
+        aoff64_t offset;
+        int rc;
+
+        assert(fatno < FATCNT(bs));
+
+        if (FAT_IS_FAT12(bs))
+                offset = (clst + clst/2);
+        else
+                offset = (clst * sizeof(fat_cluster_t));
 
         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
-            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data +
-            clst % (BPS(bs) / sizeof(fat_cluster_t));
-        *value = uint16_t_le2host(*cp);
+
+        /* 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) {
+                                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 ERANGE;
+                }
+        }
+        else
+                *value = *(fat_cluster_t *)(b->data + offset % BPS(bs));
+
+        if (FAT_IS_FAT12(bs)) {
+                if (clst & 0x0001)
+                *value = (*value) >> 4;
+                else
+                *value = (*value) & 0x0fff;
+        }
+
+        *value = uint16_t_le2host(*value);
         rc = block_put(b);
-        
+
         return rc;
 }
@@ -338 +372 @@
     fat_cluster_t clst, fat_cluster_t value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
-        int rc;
+        block_t *b, *b1;
+        aoff64_t offset;
+        fat_cluster_t *cp, temp;
+        int rc;
+        int spans = 0;
 
         assert(fatno < FATCNT(bs));
+
+        if (FAT_IS_FAT12(bs))
+                offset = (clst + clst/2);
+        else
+                offset = (clst * sizeof(fat_cluster_t));
+
         rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno +
-            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data +
-            clst % (BPS(bs) / sizeof(fat_cluster_t));
-        *cp = host2uint16_t_le(value);
-        b->dirty = true;                /* need to sync block */
+
+        /* 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) {
+                                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. It is last sector of fat */
+                        block_put(b);
+                        return ERANGE;
+                }
+        }
+        else
+                cp = (fat_cluster_t *)(b->data + offset % BPS(bs));
+
+        value = host2uint16_t_le(value);
+        if (FAT_IS_FAT12(bs)) {
+                if (clst & 0x0001) {
+                        *cp &= 0x000f;
+                        *cp |= value << 4;
+                }
+                else {
+                        *cp &= 0xf000;
+                        *cp |= value & 0x0fff;
+                }
+
+                if (spans)
+                {
+                        *(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 = value;
+
+        b->dirty = true;        /* need to sync block */
         rc = block_put(b);
         return rc;
@@ -369 +465 @@
         uint8_t fatno;
         unsigned c;
+        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
         int rc;
 
@@ -374 +471 @@
                 for (c = 0; c < nclsts; c++) {
                         rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c],
-                            c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
+                            c == 0 ? clst_last1 : lifo[c - 1]);
                         if (rc != EOK)
                                 return rc;
@@ -404 +501 @@
     fat_cluster_t *mcl, fat_cluster_t *lcl)
 {
-        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;
+        fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
+        unsigned found = 0;     /* top of the free cluster number stack */
+        fat_cluster_t clst, value, clst_last1 = FAT_CLST_LAST1(bs);
+        int rc = EOK;
 
         lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
         if (!lifo)
                 return ENOMEM;
-        
         /*
          * Search FAT1 for unused clusters.
          */
         fibril_mutex_lock(&fat_alloc_lock);
-        for (b = 0, cl = 0; b < SF(bs); b++) {
-                rc = block_get(&blk, devmap_handle, RSCNT(bs) + b,
-                    BLOCK_FLAGS_NONE);
-                if (rc != EOK)
-                        goto error;
-                for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) {
-                        /*
-                         * 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 ((cl >= FAT_CLST_FIRST) &&
-                            CLBN2PBN(bs, cl, SPC(bs) - 1) >= TS(bs)) {
-                                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) {
-                                /*
-                                 * The cluster is free. Put it into our stack
-                                 * of found clusters and mark it as non-free.
-                                 */
-                                lifo[found] = cl;
-                                *clst = (found == 0) ?
-                                    host2uint16_t_le(FAT_CLST_LAST1) :
-                                    host2uint16_t_le(lifo[found - 1]);
-                                blk->dirty = true;      /* need to sync block */
-                                if (++found == nclsts) {
-                                        /* we are almost done */
-                                        rc = block_put(blk);
-                                        if (rc != EOK)
-                                                goto error;
-                                        /* update the shadow copies of FAT */
-                                        rc = fat_alloc_shadow_clusters(bs,
-                                            devmap_handle, lifo, nclsts);
-                                        if (rc != EOK)
-                                                goto error;
-                                        *mcl = lifo[found - 1];
-                                        *lcl = lifo[0];
-                                        free(lifo);
-                                        fibril_mutex_unlock(&fat_alloc_lock);
-                                        return EOK;
-                                }
-                        }
-                }
-                rc = block_put(blk);
-                if (rc != EOK) {
-error:
+        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;
+
+                if (value == FAT_CLST_RES0) {
+                /*
+                 * The cluster is free. Put it into our stack
+                 * of found clusters and mark it as non-free.
+                 */
+                lifo[found] = clst;
+                rc = fat_set_cluster(bs, devmap_handle, FAT1, clst,
+                    (found == 0) ?  clst_last1 : lifo[found - 1]);
+                if (rc != EOK)
+                        break;
+
+                found++;
+                }
+        }
+
+        if (rc == EOK && found == nclsts) {
+                rc = fat_alloc_shadow_clusters(bs, devmap_handle, lifo, nclsts);
+                if (rc == EOK) {
+                        *mcl = lifo[found - 1];
+                        *lcl = lifo[0];
+                        free(lifo);
                         fibril_mutex_unlock(&fat_alloc_lock);
-                        free(lifo);
-                        return rc;
-                }
-        }
-out:
-        fibril_mutex_unlock(&fat_alloc_lock);
-
-        /*
-         * We could not find enough clusters. Now we need to free the clusters
-         * we have allocated so far.
-         */
-        while (found--) {
+                        return EOK;
+                }
+        }
+
+        /* If something wrong - free the clusters */
+        if (found > 0) {
+                while (found--) {
                 rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found],
                     FAT_CLST_RES0);
-                if (rc != EOK) {
-                        free(lifo);
-                        return rc;
-                }
-        }
-        
+                }
+        }
+
         free(lifo);
+        fibril_mutex_unlock(&fat_alloc_lock);
         return ENOSPC;
 }
@@ -509 +569 @@
 {
         unsigned fatno;
-        fat_cluster_t nextc;
+        fat_cluster_t nextc, clst_bad = FAT_CLST_BAD(bs);
         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);
+        while (firstc < FAT_CLST_LAST1(bs)) {
+                assert(firstc >= FAT_CLST_FIRST && firstc < clst_bad);
                 rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc);
                 if (rc != EOK)
@@ -565 +625 @@
 
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno,
-                            lastc, mcl);
+                        rc = fat_set_cluster(bs, nodep->idx->devmap_handle,
+                            fatno, lastc, mcl);
                         if (rc != EOK)
                                 return rc;
@@ -590 +650 @@
 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
 {
+        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
         int rc;
         devmap_handle_t devmap_handle = nodep->idx->devmap_handle;
@@ -618 +679 @@
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
                         rc = fat_set_cluster(bs, devmap_handle, fatno, lcl,
-                            FAT_CLST_LAST1);
+                            clst_last1);
                         if (rc != EOK)
                                 return rc;
@@ -677 +738 @@
 
         /* Check total number of sectors. */
-
         if (bs->totsec16 == 0 && bs->totsec32 == 0)
                 return ENOTSUP;
 
         if (bs->totsec16 != 0 && bs->totsec32 != 0 &&
-            bs->totsec16 != bs->totsec32) 
+            bs->totsec16 != bs->totsec32)
                 return ENOTSUP;
 
@@ -705 +765 @@
 
         /* Check signature of each FAT. */
-
         for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) {
                 rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0);
@@ -723 +782 @@
                  * set to one.
                  */
-                if ((e0 >> 8) != 0xff || e1 != 0xffff)
+                if (!FAT_IS_FAT12(bs) && ((e0 >> 8) != 0xff || e1 != 0xffff))
                         return ENOTSUP;
         }
@@ -732 +791 @@
 /**
  * @}
- */ 
+ */

uspace/srv/fs/fat/fat_fat.h

@@ -29 +29 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 #ifndef FAT_FAT_FAT_H_
@@ -40 +40 @@
 #define FAT1            0
 
-#define FAT_CLST_RES0   0x0000
-#define FAT_CLST_RES1   0x0001
-#define FAT_CLST_FIRST  0x0002
-#define FAT_CLST_BAD    0xfff7
-#define FAT_CLST_LAST1  0xfff8
-#define FAT_CLST_LAST8  0xffff
+#define FAT_CLST_RES0     0x0000
+#define FAT_CLST_RES1     0x0001
+#define FAT_CLST_FIRST    0x0002
+
+#define FAT12_CLST_BAD    0x0ff7
+#define FAT12_CLST_LAST1  0x0ff8
+#define FAT12_CLST_LAST8  0x0fff
+#define FAT16_CLST_BAD    0xfff7
+#define FAT16_CLST_LAST1  0xfff8
+#define FAT16_CLST_LAST8  0xffff
+
+#define FAT12_CLST_MAX    4085
+#define FAT16_CLST_MAX    65525
 
 /* internally used to mark root directory's parent */
@@ -51 +58 @@
 /* internally used to mark root directory */
 #define FAT_CLST_ROOT           FAT_CLST_RES1
+
+/*
+ * Convenience macros for computing some frequently used values from the
+ * 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 DS(bs)    (TS(bs) - SSA(bs))
+#define CC(bs)    (DS(bs) / SPC(bs))
+
+#define FAT_IS_FAT12(bs)        (CC(bs) < FAT12_CLST_MAX)
+#define FAT_IS_FAT16(bs) \
+    ((CC(bs) >= FAT12_CLST_MAX) && (CC(bs) < FAT16_CLST_MAX))
+
+#define FAT_CLST_LAST1(bs) \
+    (FAT_IS_FAT12(bs) ? FAT12_CLST_LAST1 : FAT16_CLST_LAST1)
+#define FAT_CLST_LAST8(bs) \
+    (FAT_IS_FAT12(bs) ? FAT12_CLST_LAST8 : FAT16_CLST_LAST8)
+#define FAT_CLST_BAD(bs) \
+    (FAT_IS_FAT12(bs) ? FAT12_CLST_BAD : FAT16_CLST_BAD)
 
 /* forward declarations */

uspace/srv/fs/fat/fat_ops.c

@@ -29 +29 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 /**
@@ -105 +105 @@
         node->dirty = false;
         node->lastc_cached_valid = false;
-        node->lastc_cached_value = FAT_CLST_LAST1;
+        node->lastc_cached_value = FAT16_CLST_LAST1;
         node->currc_cached_valid = false;
         node->currc_cached_bn = 0;
-        node->currc_cached_value = FAT_CLST_LAST1;
+        node->currc_cached_value = FAT16_CLST_LAST1;
 }
 
@@ -117 +117 @@
         fat_dentry_t *d;
         int rc;
-        
+
         assert(node->dirty);
 
         bs = block_bb_get(node->idx->devmap_handle);
-        
+
         /* Read the block that contains the dentry of interest. */
         rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc,
@@ -137 +137 @@
                 d->attr = FAT_ATTR_SUBDIR;
         }
-        
+
         /* TODO: update other fields? (e.g time fields) */
-        
+
         b->dirty = true;                /* need to sync block */
         rc = block_put(b);
@@ -256 +256 @@
         fn->data = nodep;
         nodep->bp = fn;
-        
+
         *nodepp = nodep;
         return EOK;
@@ -292 +292 @@
          * We must instantiate the node from the file system.
          */
-        
+
         assert(idxp->pfc);
 
@@ -311 +311 @@
         d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
         if (d->attr & FAT_ATTR_SUBDIR) {
-                /* 
+                /*
                  * The only directory which does not have this bit set is the
                  * root directory itself. The root directory node is handled
@@ -317 +317 @@
                  */
                 nodep->type = FAT_DIRECTORY;
-                /*
+
+                /*
                  * Unfortunately, the 'size' field of the FAT dentry is not
                  * defined for the directory entry type. We must determine the
@@ -335 +336 @@
                 nodep->size = uint32_t_le2host(d->size);
         }
-        nodep->firstc = uint16_t_le2host(d->firstc);
+
+        nodep->firstc = uint16_t_le2host(d->firstc);
         nodep->lnkcnt = 1;
         nodep->refcnt = 1;
@@ -384 +386 @@
                 if (rc != EOK)
                         return rc;
-                for (j = 0; j < DPS(bs); j++) { 
+                for (j = 0; j < DPS(bs); j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -522 +524 @@
         rc = fat_idx_get_new(&idxp, devmap_handle);
         if (rc != EOK) {
-                (void) fat_free_clusters(bs, devmap_handle, mcl);       
+                (void) fat_free_clusters(bs, devmap_handle, mcl);
                 (void) fat_node_put(FS_NODE(nodep));
                 return rc;
@@ -619 +621 @@
          * a new one.
          */
-        
+
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->devmap_handle);
@@ -651 +653 @@
         }
         j = 0;
-        
+
         /*
          * We need to grow the parent in order to create a new unused dentry.
@@ -698 +700 @@
         rc = block_put(b);
         fibril_mutex_unlock(&parentp->idx->lock);
-        if (rc != EOK) 
+        if (rc != EOK)
                 return rc;
 
         fibril_mutex_lock(&childp->idx->lock);
-        
+
         if (childp->type == FAT_DIRECTORY) {
                 /*
@@ -779 +781 @@
         if (!parentp)
                 return EBUSY;
-        
+
         rc = fat_has_children(&has_children, cfn);
         if (rc != EOK)
@@ -795 +797 @@
             NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
             BLOCK_FLAGS_NONE);
-        if (rc != EOK) 
+        if (rc != EOK)
                 goto error;
         d = (fat_dentry_t *)b->data +
@@ -840 +842 @@
                 return EOK;
         }
-        
+
         fibril_mutex_lock(&nodep->idx->lock);
         bs = block_bb_get(nodep->idx->devmap_handle);
@@ -848 +850 @@
         for (i = 0; i < blocks; i++) {
                 fat_dentry_t *d;
-        
+
                 rc = fat_block_get(&b, bs, nodep, i, BLOCK_FLAGS_NONE);
                 if (rc != EOK) {
@@ -876 +878 @@
                 if (rc != EOK) {
                         fibril_mutex_unlock(&nodep->idx->lock);
-                        return rc;      
+                        return rc;
                 }
         }
@@ -951 +953 @@
         enum cache_mode cmode;
         fat_bs_t *bs;
-        
+
         /* Accept the mount options */
         char *opts;
         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
-        
+
         if (rc != EOK) {
                 async_answer_0(rid, rc);
@@ -986 +988 @@
         /* get the buffer with the boot sector */
         bs = block_bb_get(devmap_handle);
-        
+
         if (BPS(bs) != BS_SIZE) {
                 block_fini(devmap_handle);
@@ -998 +1000 @@
                 block_fini(devmap_handle);
                 async_answer_0(rid, rc);
+                return;
+        }
+
+        /* Return NOT SUPPORTED if try to mount FAT32  */
+        if (!FAT_IS_FAT12(bs) && !FAT_IS_FAT16(bs)) {
+                block_fini(devmap_handle);
+                async_answer_0(rid, ENOTSUP);
                 return;
         }
@@ -1061 +1070 @@
         rootp->bp = rfn;
         rfn->data = rootp;
-        
+
         fibril_mutex_unlock(&ridxp->lock);
 
@@ -1095 +1104 @@
                 return;
         }
-        
+
         /*
          * Put the root node and force it to the FAT free node list.
@@ -1276 +1285 @@
         int flags = BLOCK_FLAGS_NONE;
         int rc;
-        
+
         rc = fat_node_get(&fn, devmap_handle, index);
         if (rc != EOK) {
@@ -1287 +1296 @@
         }
         nodep = FAT_NODE(fn);
-        
+
         ipc_callid_t callid;
         size_t len;
@@ -1304 +1313 @@
          * but this one greatly simplifies fat_write(). Note that we can afford
          * to do this because the client must be ready to handle the return
-         * value signalizing a smaller number of bytes written. 
-         */ 
+         * value signalizing a smaller number of bytes written.
+         */
         bytes = min(len, BPS(bs) - pos % BPS(bs));
         if (bytes == BPS(bs))
                 flags |= BLOCK_FLAGS_NOREAD;
-        
+
         boundary = ROUND_UP(nodep->size, BPC(bs));
         if (pos < boundary) {
@@ -1355 +1364 @@
                  */
                 unsigned nclsts;
-                fat_cluster_t mcl, lcl; 
- 
+                fat_cluster_t mcl, lcl;
+
                 nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
                 /* create an independent chain of nclsts clusters in all FATs */
@@ -1452 +1461 @@
                 nodep->size = size;
                 nodep->dirty = true;            /* need to sync node */
-                rc = EOK;       
+                rc = EOK;
         } else {
                 /*
@@ -1473 +1482 @@
                 nodep->size = size;
                 nodep->dirty = true;            /* need to sync node */
-                rc = EOK;       
+                rc = EOK;
         }
 out:
@@ -1529 +1538 @@
         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-        
+
         fs_node_t *fn;
         int rc = fat_node_get(&fn, devmap_handle, index);
@@ -1540 +1549 @@
                 return;
         }
-        
+
         fat_node_t *nodep = FAT_NODE(fn);
-        
+
         nodep->dirty = true;
         rc = fat_node_sync(nodep);
-        
+
         fat_node_put(fn);
         async_answer_0(rid, rc);