Changes in / [7fadb65:4cf5ed46] in mainline

Files:

• boot/Makefile.common (modified) (1 diff)
• uspace/Makefile (modified) (1 diff)
• uspace/app/mkfat/fat.h (modified) (1 diff)
• uspace/app/mkfat/mkfat.c (modified) (20 diffs)
• uspace/lib/c/generic/str.c (modified) (3 diffs)
• uspace/lib/c/include/str.h (modified) (2 diffs)
• uspace/srv/fs/exfat/Makefile (added)
• uspace/srv/fs/exfat/exfat.c (added)
• uspace/srv/fs/exfat/exfat.h (added)
• uspace/srv/fs/exfat/exfat_bitmap.c (added)
• uspace/srv/fs/exfat/exfat_bitmap.h (added)
• uspace/srv/fs/exfat/exfat_dentry.c (added)
• uspace/srv/fs/exfat/exfat_dentry.h (added)
• uspace/srv/fs/exfat/exfat_directory.c (added)
• uspace/srv/fs/exfat/exfat_directory.h (added)
• uspace/srv/fs/exfat/exfat_fat.c (added)
• uspace/srv/fs/exfat/exfat_fat.h (added)
• uspace/srv/fs/exfat/exfat_idx.c (added)
• uspace/srv/fs/exfat/exfat_ops.c (added)
• uspace/srv/fs/fat/Makefile (modified) (1 diff)
• uspace/srv/fs/fat/fat.c (modified) (1 diff)
• uspace/srv/fs/fat/fat.h (modified) (3 diffs)
• uspace/srv/fs/fat/fat_dentry.c (modified) (5 diffs)
• uspace/srv/fs/fat/fat_dentry.h (modified) (5 diffs)
• uspace/srv/fs/fat/fat_directory.c (added)
• uspace/srv/fs/fat/fat_directory.h (added)
• uspace/srv/fs/fat/fat_fat.c (modified) (29 diffs)
• uspace/srv/fs/fat/fat_fat.h (modified) (5 diffs)
• uspace/srv/fs/fat/fat_idx.c (modified) (13 diffs)
• uspace/srv/fs/fat/fat_ops.c (modified) (41 diffs)

boot/Makefile.common

@@ -102 +102 @@
         $(USPACE_PATH)/srv/fs/tmpfs/tmpfs \
         $(USPACE_PATH)/srv/fs/fat/fat \
+        $(USPACE_PATH)/srv/fs/exfat/exfat \
         $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \
         $(USPACE_PATH)/srv/taskmon/taskmon \

uspace/Makefile

@@ -79 +79 @@
         srv/bd/part/guid_part \
         srv/bd/part/mbr_part \
+        srv/fs/exfat \
         srv/fs/fat \
         srv/fs/tmpfs \

uspace/app/mkfat/fat.h

@@ -38 +38 @@
 #define BS_BLOCK                0
 #define BS_SIZE                 512
+#define DIRENT_SIZE             32
 
-#define DIRENT_SIZE             32
+#define FAT12_CLST_MAX    4085
+#define FAT16_CLST_MAX    65525
+
+#define FAT12   12
+#define FAT16   16
+#define FAT32   32
+
+#define FAT_SIZE(a) (((a) == FAT12) ? 1.5 : (((a) == FAT16) ? 2 : 4)) 
 
 typedef struct fat_bs {

uspace/app/mkfat/mkfat.c

@@ -35 +35 @@
  * @brief       Tool for creating new FAT file systems.
  *
- * Currently we can only create 16-bit FAT.
+ * Currently we can create 12/16/32-bit FAT.
  */
 
@@ -55 +55 @@
 #define div_round_up(a, b) (((a) + (b) - 1) / (b))
 
-/** Predefined file-system parameters */
+/** Default file-system parameters */
 enum {
-        sector_size             = 512,
-        sectors_per_cluster     = 8,
-        fat_count               = 2,
-        reserved_clusters       = 2,
-        media_descriptor        = 0xF8 /**< fixed disk */
+        default_sector_size             = 512,
+        default_sectors_per_cluster     = 4,
+        default_fat_count               = 2,
+        default_reserved_clusters       = 2,
+        default_media_descriptor        = 0xF8 /**< fixed disk */
 };
 
 /** Configurable file-system parameters */
 typedef struct fat_cfg {
+        int fat_type; /* FAT12 = 12, FAT16 = 16, FAT32 = 32 */
+        size_t sector_size;
         uint32_t total_sectors;
         uint16_t root_ent_max;
-        uint16_t addt_res_sectors;
+        uint32_t addt_res_sectors;
+        uint8_t sectors_per_cluster;
+
+        uint16_t reserved_sectors;
+        uint32_t rootdir_sectors;
+        uint32_t fat_sectors;
+        uint32_t total_clusters;
+        uint8_t fat_count;
 } fat_cfg_t;
 
-/** Derived file-system parameters */
-typedef struct fat_params {
-        struct fat_cfg cfg;
-        uint16_t reserved_sectors;
-        uint16_t rootdir_sectors;
-        uint32_t fat_sectors;
-        uint16_t total_clusters;
-} fat_params_t;
-
 static void syntax_print(void);
 
-static int fat_params_compute(struct fat_cfg const *cfg,
-    struct fat_params *par);
-static int fat_blocks_write(struct fat_params const *par,
-    service_id_t service_id);
-static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs);
+static int fat_params_compute(struct fat_cfg *cfg);
+static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id);
+static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs);
 
 int main(int argc, char **argv)
 {
-        struct fat_params par;
         struct fat_cfg cfg;
 
@@ -96 +93 @@
         char *dev_path;
         service_id_t service_id;
-        size_t block_size;
         char *endptr;
         aoff64_t dev_nblocks;
 
+        cfg.sector_size = default_sector_size;
+        cfg.sectors_per_cluster = default_sectors_per_cluster;
+        cfg.fat_count = default_fat_count;
         cfg.total_sectors = 0;
         cfg.addt_res_sectors = 0;
         cfg.root_ent_max = 128;
+        cfg.fat_type = FAT16;
 
         if (argc < 2) {
@@ -111 +111 @@
 
         --argc; ++argv;
-
         if (str_cmp(*argv, "--size") == 0) {
                 --argc; ++argv;
@@ -130 +129 @@
         }
 
+        if (str_cmp(*argv, "--type") == 0) {
+                --argc; ++argv;
+                if (*argv == NULL) {
+                        printf(NAME ": Error, argument missing.\n");
+                        syntax_print();
+                        return 1;
+                }
+
+                cfg.fat_type = strtol(*argv, &endptr, 10);
+                if (*endptr != '\0') {
+                        printf(NAME ": Error, invalid argument.\n");
+                        syntax_print();
+                        return 1;
+                }
+
+                --argc; ++argv;
+        }
+
         if (argc != 1) {
                 printf(NAME ": Error, unexpected argument.\n");
@@ -137 +154 @@
 
         dev_path = *argv;
+        printf("Device: %s\n", dev_path);
 
         rc = loc_service_get_id(dev_path, &service_id, 0);
@@ -150 +168 @@
         }
 
-        rc = block_get_bsize(service_id, &block_size);
+        rc = block_get_bsize(service_id, &cfg.sector_size);
         if (rc != EOK) {
                 printf(NAME ": Error determining device block size.\n");
@@ -162 +180 @@
                 printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
                     dev_nblocks);
-                cfg.total_sectors = dev_nblocks;
-        }
-
-        if (block_size != 512) {
-                printf(NAME ": Error. Device block size is not 512 bytes.\n");
-                return 2;
+                if (!cfg.total_sectors || dev_nblocks < cfg.total_sectors)
+                        cfg.total_sectors = dev_nblocks;
         }
 
@@ -175 +189 @@
         }
 
-        printf(NAME ": Creating FAT filesystem on device %s.\n", dev_path);
-
-        rc = fat_params_compute(&cfg, &par);
+        if (cfg.fat_type != FAT12 && cfg.fat_type != FAT16 && cfg.fat_type != FAT32) {
+                printf(NAME ": Error. Unknown FAT type.\n");
+                return 2;
+        }
+
+        printf(NAME ": Creating FAT%d filesystem on device %s.\n", cfg.fat_type, dev_path);
+
+        rc = fat_params_compute(&cfg);
         if (rc != EOK) {
                 printf(NAME ": Invalid file-system parameters.\n");
@@ -183 +202 @@
         }
 
-        rc = fat_blocks_write(&par, service_id);
+        rc = fat_blocks_write(&cfg, service_id);
         if (rc != EOK) {
                 printf(NAME ": Error writing device.\n");
@@ -197 +216 @@
 static void syntax_print(void)
 {
-        printf("syntax: mkfat [--size <num_blocks>] <device_name>\n");
+        printf("syntax: mkfat [--size <sectors>] [--type 12|16|32] <device_name>\n");
 }
 
@@ -205 +224 @@
  * file system params.
  */
-static int fat_params_compute(struct fat_cfg const *cfg, struct fat_params *par)
+static int fat_params_compute(struct fat_cfg *cfg)
 {
         uint32_t fat_bytes;
@@ -211 +230 @@
 
         /*
-         * Make a conservative guess on the FAT size needed for the file
-         * system. The optimum could be potentially smaller since we
-         * do not subtract size of the FAT itself when computing the
-         * size of the data region.
-         */
-
-        par->reserved_sectors = 1 + cfg->addt_res_sectors;
-        par->rootdir_sectors = div_round_up(cfg->root_ent_max * DIRENT_SIZE,
-            sector_size);
-        non_data_sectors_lb = par->reserved_sectors + par->rootdir_sectors;
-
-        par->total_clusters = div_round_up(cfg->total_sectors - non_data_sectors_lb,
-            sectors_per_cluster);
-
-        fat_bytes = (par->total_clusters + 2) * 2;
-        par->fat_sectors = div_round_up(fat_bytes, sector_size);
-
-        par->cfg = *cfg;
+         * Make a conservative guess on the FAT size needed for the file
+         * system. The optimum could be potentially smaller since we
+         * do not subtract size of the FAT itself when computing the
+         * size of the data region.
+         */
+
+        cfg->reserved_sectors = 1 + cfg->addt_res_sectors;
+        if (cfg->fat_type != FAT32) {
+                cfg->rootdir_sectors = div_round_up(cfg->root_ent_max * DIRENT_SIZE,
+                        cfg->sector_size);
+        } else
+                cfg->rootdir_sectors = 0;
+        non_data_sectors_lb = cfg->reserved_sectors + cfg->rootdir_sectors;
+
+        cfg->total_clusters = div_round_up(cfg->total_sectors - non_data_sectors_lb,
+            cfg->sectors_per_cluster);
+
+        if ((cfg->fat_type == FAT12 && cfg->total_clusters > FAT12_CLST_MAX) ||
+            (cfg->fat_type == FAT16 && (cfg->total_clusters <= FAT12_CLST_MAX ||
+            cfg->total_clusters > FAT16_CLST_MAX)) ||
+            (cfg->fat_type == FAT32 && cfg->total_clusters <= FAT16_CLST_MAX))
+                return ENOSPC;
+
+        fat_bytes = (cfg->total_clusters + 2) * FAT_SIZE(cfg->fat_type);
+        cfg->fat_sectors = div_round_up(fat_bytes, cfg->sector_size);
 
         return EOK;
@@ -234 +260 @@
 
 /** Create file system with the given parameters. */
-static int fat_blocks_write(struct fat_params const *par, service_id_t service_id)
+static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id)
 {
         aoff64_t addr;
@@ -243 +269 @@
         struct fat_bs bs;
 
-        fat_bootsec_create(par, &bs);
+        fat_bootsec_create(cfg, &bs);
 
         rc = block_write_direct(service_id, BS_BLOCK, 1, &bs);
@@ -251 +277 @@
         addr = BS_BLOCK + 1;
 
-        buffer = calloc(sector_size, 1);
+        buffer = calloc(cfg->sector_size, 1);
         if (buffer == NULL)
                 return ENOMEM;
+        memset(buffer, 0, cfg->sector_size);
 
         /* Reserved sectors */
-        for (i = 0; i < par->reserved_sectors - 1; ++i) {
+        for (i = 0; i < cfg->reserved_sectors - 1; ++i) {
                 rc = block_write_direct(service_id, addr, 1, buffer);
                 if (rc != EOK)
@@ -265 +292 @@
 
         /* File allocation tables */
-        for (i = 0; i < fat_count; ++i) {
+        for (i = 0; i < cfg->fat_count; ++i) {
                 printf("Writing allocation table %d.\n", i + 1);
 
-                for (j = 0; j < par->fat_sectors; ++j) {
-                        memset(buffer, 0, sector_size);
+                for (j = 0; j < cfg->fat_sectors; ++j) {
+                        memset(buffer, 0, cfg->sector_size);
                         if (j == 0) {
-                                buffer[0] = media_descriptor;
+                                buffer[0] = default_media_descriptor;
                                 buffer[1] = 0xFF;
                                 buffer[2] = 0xFF;
-                                buffer[3] = 0xFF;
+                                if (cfg->fat_type == FAT16) {
+                                        buffer[3] = 0xFF;
+                                } else if (cfg->fat_type == FAT32) {
+                                        buffer[3] = 0x0F;
+                                        buffer[4] = 0xFF;
+                                        buffer[5] = 0xFF;
+                                        buffer[6] = 0xFF;
+                                        buffer[7] = 0x0F;
+                                        buffer[8] = 0xF8;
+                                        buffer[9] = 0xFF;
+                                        buffer[10] = 0xFF;
+                                        buffer[11] = 0x0F;
+                                }
                         }
 
@@ -285 +324 @@
         }
 
+        /* Root directory */
         printf("Writing root directory.\n");
-
-        memset(buffer, 0, sector_size);
-
-        /* Root directory */
-        for (i = 0; i < par->rootdir_sectors; ++i) {
-                rc = block_write_direct(service_id, addr, 1, buffer);
-                if (rc != EOK)
-                        return EIO;
-
-                ++addr;
+        memset(buffer, 0, cfg->sector_size);
+        if (cfg->fat_type != FAT32) {
+                size_t idx;
+                for (idx = 0; idx < cfg->rootdir_sectors; ++idx) {
+                        rc = block_write_direct(service_id, addr, 1, buffer);
+                        if (rc != EOK)
+                                return EIO;
+
+                        ++addr;
+                }
+        } else {
+                for (i = 0; i < cfg->sectors_per_cluster; i++) {
+                        rc = block_write_direct(service_id, addr, 1, buffer);
+                        if (rc != EOK)
+                                return EIO;
+
+                        ++addr;
+                }       
         }
 
@@ -304 +352 @@
 
 /** Construct boot sector with the given parameters. */
-static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs)
+static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs)
 {
         memset(bs, 0, sizeof(*bs));
@@ -315 +363 @@
 
         /* BIOS Parameter Block */
-        bs->bps = host2uint16_t_le(sector_size);
-        bs->spc = sectors_per_cluster;
-        bs->rscnt = host2uint16_t_le(par->reserved_sectors);
-        bs->fatcnt = fat_count;
-        bs->root_ent_max = host2uint16_t_le(par->cfg.root_ent_max);
-
-        if (par->cfg.total_sectors < 0x10000)
-                bs->totsec16 = host2uint16_t_le(par->cfg.total_sectors);
-        else
-                bs->totsec16 = host2uint16_t_le(0);
-
-        bs->mdesc = media_descriptor;
-        bs->sec_per_fat = host2uint16_t_le(par->fat_sectors);
+        bs->bps = host2uint16_t_le(cfg->sector_size);
+        bs->spc = cfg->sectors_per_cluster;
+        bs->rscnt = host2uint16_t_le(cfg->reserved_sectors);
+        bs->fatcnt = cfg->fat_count;
+        bs->root_ent_max = host2uint16_t_le(cfg->root_ent_max);
+
+        if (cfg->total_sectors < 0x10000) {
+                bs->totsec16 = host2uint16_t_le(cfg->total_sectors);
+                bs->totsec32 = 0;
+        } else {
+                bs->totsec16 = 0;
+                bs->totsec32 = host2uint32_t_le(cfg->total_sectors);
+        }
+
+        bs->mdesc = default_media_descriptor;
         bs->sec_per_track = host2uint16_t_le(63);
+        bs->signature = host2uint16_t_be(0x55AA);
         bs->headcnt = host2uint16_t_le(6);
         bs->hidden_sec = host2uint32_t_le(0);
 
-        if (par->cfg.total_sectors >= 0x10000)
-                bs->totsec32 = host2uint32_t_le(par->cfg.total_sectors);
-        else
-                bs->totsec32 = host2uint32_t_le(0);
-
-        /* Extended BPB */
-        bs->pdn = 0x80;
-        bs->ebs = 0x29;
-        bs->id = host2uint32_t_be(0x12345678);
-
-        memcpy(bs->label, "HELENOS_NEW", 11);
-        memcpy(bs->type, "FAT16   ", 8);
-        bs->signature = host2uint16_t_be(0x55AA);
+        if (cfg->fat_type == FAT32) {
+                bs->sec_per_fat = 0;
+                bs->fat32.sectors_per_fat = host2uint32_t_le(cfg->fat_sectors);
+
+                bs->fat32.pdn = 0x80;
+                bs->fat32.ebs = 0x29;
+                bs->fat32.id = host2uint32_t_be(0x12345678);
+                bs->fat32.root_cluster = 2;
+
+                memcpy(bs->fat32.label, "HELENOS_NEW", 11);
+                memcpy(bs->fat32.type, "FAT32   ", 8);
+        } else {
+                bs->sec_per_fat = host2uint16_t_le(cfg->fat_sectors);
+                bs->pdn = 0x80;
+                bs->ebs = 0x29;
+                bs->id = host2uint32_t_be(0x12345678);
+
+                memcpy(bs->label, "HELENOS_NEW", 11);
+                memcpy(bs->type, "FAT   ", 8);
+        }
 }
 

uspace/lib/c/generic/str.c

@@ -3 +3 @@
  * Copyright (c) 2008 Jiri Svoboda
  * Copyright (c) 2011 Martin Sucha
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -640 +641 @@
 }
 
+/** Convert UTF16 string to string.
+ *
+ * Convert utf16 string @a src to string. The output is written to the buffer
+ * specified by @a dest and @a size. @a size must be non-zero and the string
+ * written will always be well-formed. Surrogate pairs also supported.
+ *
+ * @param dest  Destination buffer.
+ * @param size  Size of the destination buffer.
+ * @param src   Source utf16 string.
+ *
+ * @return EOK, if success, negative otherwise.
+ */
+int utf16_to_str(char *dest, size_t size, const uint16_t *src)
+{
+        size_t idx = 0, dest_off = 0;
+        wchar_t ch;
+        int rc = EOK;
+
+        /* There must be space for a null terminator in the buffer. */
+        assert(size > 0);
+
+        while (src[idx]) {
+                if ((src[idx] & 0xfc00) == 0xd800) {
+                        if (src[idx + 1] && (src[idx + 1] & 0xfc00) == 0xdc00) {
+                                ch = 0x10000;
+                                ch += (src[idx] & 0x03FF) << 10;
+                                ch += (src[idx + 1] & 0x03FF);
+                                idx += 2;
+                        }
+                        else
+                                break;
+                } else {
+                        ch = src[idx];
+                        idx++;
+                }
+                rc = chr_encode(ch, dest, &dest_off, size - 1);
+                if (rc != EOK)
+                        break;
+        }
+        dest[dest_off] = '\0';
+        return rc;
+}
+
+int str_to_utf16(uint16_t *dest, size_t size, const char *src)
+{
+        int rc = EOK;
+        size_t offset = 0;
+        size_t idx = 0;
+        wchar_t c;
+
+        assert(size > 0);
+        
+        while ((c = str_decode(src, &offset, STR_NO_LIMIT)) != 0) {
+                if (c > 0x10000) {
+                        if (idx + 2 >= size - 1) {
+                                rc = EOVERFLOW;
+                                break;
+                        }
+                        c = (c - 0x10000);
+                        dest[idx] = 0xD800 | (c >> 10);
+                        dest[idx + 1] = 0xDC00 | (c & 0x3FF);
+                        idx++;
+                } else {
+                         dest[idx] = c;
+                }
+
+                idx++;
+                if (idx >= size - 1) {
+                        rc = EOVERFLOW;
+                        break;
+                }
+        }
+
+        dest[idx] = '\0';
+        return rc;
+}
+
+
 /** Convert wide string to new string.
  *
@@ -1036 +1115 @@
         return dest;
 }
-
 
 /** Convert initial part of string to unsigned long according to given base.

uspace/lib/c/include/str.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2005 Martin Decky
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -84 +85 @@
 extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
 extern wchar_t *str_to_awstr(const char *src);
+extern int utf16_to_str(char *dest, size_t size, const uint16_t *src);
+extern int str_to_utf16(uint16_t *dest, size_t size, const char *src);
 
 extern char *str_chr(const char *str, wchar_t ch);

uspace/srv/fs/fat/Makefile

@@ -39 +39 @@
         fat_idx.c \
         fat_dentry.c \
+        fat_directory.c \
         fat_fat.c
 

uspace/srv/fs/fat/fat.c

@@ -2 +2 @@
  * Copyright (c) 2006 Martin Decky
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *

uspace/srv/fs/fat/fat.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -46 +47 @@
 #endif
 
-#define min(a, b)               ((a) < (b) ? (a) : (b))
+#define min(a, b)       ((a) < (b) ? (a) : (b))
 
 /*
@@ -55 +56 @@
 #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) ? \
+    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 ? \
-                        uint16_t_le2host((bs)->totsec16) : \
-                        uint32_t_le2host(bs->totsec32))
-
-#define BS_BLOCK                0
-#define BS_SIZE                 512
+
+#define TS(bs)          (uint16_t_le2host((bs)->totsec16) ? \
+    uint16_t_le2host((bs)->totsec16) : \
+    uint32_t_le2host(bs->totsec32))
+
+#define BS_BLOCK        0
+#define BS_SIZE         512
 
 typedef struct fat_bs {

uspace/srv/fs/fat/fat_dentry.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -39 +40 @@
 #include <ctype.h>
 #include <str.h>
-
-static bool is_d_char(const char ch)
-{
-        if (isalnum(ch) || ch == '_')
-                return true;
-        else
-                return false;
-}
+#include <errno.h>
+#include <byteorder.h>
+#include <assert.h>
 
 /** Compare path component with the name read from the dentry.
@@ -80 +76 @@
 }
 
-bool fat_dentry_name_verify(const char *name)
+void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
+{
+        unsigned int i;
+        
+        for (i = 0; i < FAT_NAME_LEN; i++) {
+                if (d->name[i] == FAT_PAD)
+                        break;
+                
+                if (d->name[i] == FAT_DENTRY_E5_ESC)
+                        *buf++ = 0xe5;
+                else {
+                        if (d->lcase & FAT_LCASE_LOWER_NAME)
+                                *buf++ = tolower(d->name[i]);
+                        else
+                                *buf++ = d->name[i];
+                }
+        }
+        
+        if (d->ext[0] != FAT_PAD)
+                *buf++ = '.';
+        
+        for (i = 0; i < FAT_EXT_LEN; i++) {
+                if (d->ext[i] == FAT_PAD) {
+                        *buf = '\0';
+                        return;
+                }
+                
+                if (d->ext[i] == FAT_DENTRY_E5_ESC)
+                        *buf++ = 0xe5;
+                else {
+                        if (d->lcase & FAT_LCASE_LOWER_EXT)
+                                *buf++ = tolower(d->ext[i]);
+                        else
+                                *buf++ = d->ext[i];
+                }
+        }
+        
+        *buf = '\0';
+}
+
+void fat_dentry_name_set(fat_dentry_t *d, const char *name)
+{
+        unsigned int i;
+        const char fake_ext[] = "   ";
+        bool lower_name = true;
+        bool lower_ext = true;
+        
+        for (i = 0; i < FAT_NAME_LEN; i++) {
+                switch ((uint8_t) *name) {
+                case 0xe5:
+                        d->name[i] = FAT_DENTRY_E5_ESC;
+                        name++;
+                        break;
+                case '\0':
+                case '.':
+                        d->name[i] = FAT_PAD;
+                        break;
+                default:
+                        if (isalpha(*name)) {
+                                if (!islower(*name))
+                                        lower_name = false;
+                        }
+                        
+                        d->name[i] = toupper(*name++);
+                        break;
+                }
+        }
+        
+        if (*name++ != '.')
+                name = fake_ext;
+        
+        for (i = 0; i < FAT_EXT_LEN; i++) {
+                switch ((uint8_t) *name) {
+                case 0xe5:
+                        d->ext[i] = FAT_DENTRY_E5_ESC;
+                        name++;
+                        break;
+                case '\0':
+                        d->ext[i] = FAT_PAD;
+                        break;
+                default:
+                        if (isalpha(*name)) {
+                                if (!islower(*name))
+                                        lower_ext = false;
+                        }
+                        
+                        d->ext[i] = toupper(*name++);
+                        break;
+                }
+        }
+        
+        if (lower_name)
+                d->lcase |= FAT_LCASE_LOWER_NAME;
+        else
+                d->lcase &= ~FAT_LCASE_LOWER_NAME;
+        
+        if (lower_ext)
+                d->lcase |= FAT_LCASE_LOWER_EXT;
+        else
+                d->lcase &= ~FAT_LCASE_LOWER_EXT;
+}
+
+fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
+{
+        if (d->attr == FAT_ATTR_LFN) {
+                /* long name entry */
+                if (FAT_LFN_ORDER(d) & FAT_LFN_ERASED)
+                        return FAT_DENTRY_FREE;
+                else
+                        return FAT_DENTRY_LFN;
+        }
+        if (d->attr & FAT_ATTR_VOLLABEL) {
+                /* volume label entry */
+                return FAT_DENTRY_SKIP;
+        }
+        if (d->name[0] == FAT_DENTRY_ERASED) {
+                /* not-currently-used entry */
+                return FAT_DENTRY_FREE;
+        }
+        if (d->name[0] == FAT_DENTRY_UNUSED) {
+                /* never used entry */
+                return FAT_DENTRY_LAST;
+        }
+        if (d->name[0] == FAT_DENTRY_DOT) {
+                /*
+                 * Most likely '.' or '..'.
+                 * It cannot occur in a regular file name.
+                 */
+                return FAT_DENTRY_SKIP;
+        }
+        return FAT_DENTRY_VALID;
+}
+
+/** Compute checksum of Node name.
+ *
+ * Returns an unsigned byte checksum computed on an unsigned byte
+ * array. The array must be 11 bytes long and is assumed to contain
+ * a name stored in the format of a MS-DOS directory entry.
+ *
+ * @param name          Node name read from the dentry.
+ *
+ * @return              An 8-bit unsigned checksum of the name.
+ */
+uint8_t fat_dentry_chksum(uint8_t *name)
+{
+        uint8_t i, sum = 0;
+
+        for (i = 0; i < (FAT_NAME_LEN + FAT_EXT_LEN); i++)
+                sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + name[i];
+
+        return sum;
+}
+
+/** Get number of bytes in a string with size limit.
+ *
+ * @param str  NULL-terminated (or not) string.
+ * @param size Maximum number of bytes to consider.
+ *
+ * @return Number of bytes in string (without 0 and ff).
+ *
+ */
+size_t fat_lfn_str_nlength(const uint16_t *str, size_t size)
+{
+        size_t offset = 0;
+
+        while (offset < size) {
+                if (str[offset] == 0 || str[offset] == FAT_LFN_PAD) 
+                        break;
+                offset++;
+        }
+        return offset;
+}
+
+/** Get number of bytes in a FAT long entry occuped by characters.
+ *
+ * @param d FAT long entry.
+ *
+ * @return Number of bytes.
+ *
+ */
+size_t fat_lfn_size(const fat_dentry_t *d)
+{
+        size_t size = 0;
+        
+        size += fat_lfn_str_nlength(FAT_LFN_PART1(d), FAT_LFN_PART1_SIZE);
+        size += fat_lfn_str_nlength(FAT_LFN_PART2(d), FAT_LFN_PART2_SIZE);
+        size += fat_lfn_str_nlength(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE);      
+        
+        return size;
+}
+
+size_t fat_lfn_get_entry(const fat_dentry_t *d, uint16_t *dst, size_t *offset)
+{
+        int i;
+        for (i = FAT_LFN_PART3_SIZE - 1; i >= 0 && *offset > 0; i--) {
+                if (d->lfn.part3[i] == 0 || d->lfn.part3[i] == FAT_LFN_PAD)
+                        continue;
+                (*offset)--;
+                dst[(*offset)] = uint16_t_le2host(d->lfn.part3[i]);
+        }
+        for (i = FAT_LFN_PART2_SIZE - 1; i >= 0 && *offset > 0; i--) {
+                if (d->lfn.part2[i] == 0 || d->lfn.part2[i] == FAT_LFN_PAD)
+                        continue;
+                (*offset)--;
+                dst[(*offset)] = uint16_t_le2host(d->lfn.part2[i]);
+        }
+        for (i = FAT_LFN_PART1_SIZE - 1; i >= 0 && *offset > 0; i--) {
+                if (d->lfn.part1[i] == 0 || d->lfn.part1[i] == FAT_LFN_PAD)
+                        continue;
+                (*offset)--;
+                dst[(*offset)] = uint16_t_le2host(d->lfn.part1[i]);
+        }
+        return *offset;
+}
+
+size_t fat_lfn_set_entry(const uint16_t *src, size_t *offset, size_t size,
+    fat_dentry_t *d)
+{
+        size_t idx;
+        for (idx = 0; idx < FAT_LFN_PART1_SIZE; idx++) {
+                if (*offset < size) {
+                        d->lfn.part1[idx] = host2uint16_t_le(src[*offset]);
+                        (*offset)++;
+                } else
+                        d->lfn.part1[idx] = FAT_LFN_PAD;
+        }
+        for (idx = 0; idx < FAT_LFN_PART2_SIZE; idx++) {
+                if (*offset < size) {
+                        d->lfn.part2[idx] = host2uint16_t_le(src[*offset]);
+                        (*offset)++;
+                } else
+                        d->lfn.part2[idx] = FAT_LFN_PAD;
+        }
+        for (idx = 0; idx < FAT_LFN_PART3_SIZE; idx++) {
+                if (*offset < size) {
+                        d->lfn.part3[idx] = host2uint16_t_le(src[*offset]);
+                        (*offset)++;
+                } else
+                        d->lfn.part3[idx] = FAT_LFN_PAD;
+        }
+
+        if (src[*offset] == 0)
+                offset++;
+        FAT_LFN_ATTR(d) = FAT_ATTR_LFN;
+        d->lfn.type = 0;
+        d->lfn.firstc_lo = 0;
+        
+        return *offset;
+}
+
+void str_to_ascii(char *dst, const char *src, size_t count, uint8_t pad)
+{
+        wchar_t ch;
+        size_t off = 0;
+        size_t i = 0;
+        
+        while (i < count) {
+                if ((ch = str_decode(src, &off, STR_NO_LIMIT)) != 0) {
+                        if (ascii_check(ch) & IS_D_CHAR(ch))
+                                *dst = toupper(ch);
+                        else
+                                *dst = pad;
+                } else
+                        break;
+
+                dst++;
+                i++;
+        }
+        *dst = '\0';
+}
+
+bool fat_valid_name(const char *name)
+{
+        wchar_t ch;
+        size_t offset=0;
+        bool result = true;
+        
+        while ((ch = str_decode(name, &offset, STR_NO_LIMIT)) != 0) {
+                if (str_chr(FAT_STOP_CHARS, ch) != NULL) {
+                        result = false;
+                        break;
+                }
+        }
+        return result;
+}
+
+bool fat_valid_short_name(const char *name)
 {
         unsigned int i;
         unsigned int dot = 0;
         bool dot_found = false;
-        
 
         for (i = 0; name[i]; i++) {
@@ -96 +377 @@
                         }
                 } else {
-                        if (!is_d_char(name[i]))
+                        if (!IS_D_CHAR(name[i]))
                                 return false;
                 }
@@ -114 +395 @@
 }
 
-void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
-{
-        unsigned int i;
-        
-        for (i = 0; i < FAT_NAME_LEN; i++) {
-                if (d->name[i] == FAT_PAD)
-                        break;
-                
-                if (d->name[i] == FAT_DENTRY_E5_ESC)
-                        *buf++ = 0xe5;
-                else {
-                        if (d->lcase & FAT_LCASE_LOWER_NAME)
-                                *buf++ = tolower(d->name[i]);
-                        else
-                                *buf++ = d->name[i];
-                }
-        }
-        
-        if (d->ext[0] != FAT_PAD)
-                *buf++ = '.';
-        
-        for (i = 0; i < FAT_EXT_LEN; i++) {
-                if (d->ext[i] == FAT_PAD) {
-                        *buf = '\0';
-                        return;
-                }
-                
-                if (d->ext[i] == FAT_DENTRY_E5_ESC)
-                        *buf++ = 0xe5;
-                else {
-                        if (d->lcase & FAT_LCASE_LOWER_EXT)
-                                *buf++ = tolower(d->ext[i]);
-                        else
-                                *buf++ = d->ext[i];
-                }
-        }
-        
-        *buf = '\0';
-}
-
-void fat_dentry_name_set(fat_dentry_t *d, const char *name)
-{
-        unsigned int i;
-        const char fake_ext[] = "   ";
-        bool lower_name = true;
-        bool lower_ext = true;
-        
-        for (i = 0; i < FAT_NAME_LEN; i++) {
-                switch ((uint8_t) *name) {
-                case 0xe5:
-                        d->name[i] = FAT_DENTRY_E5_ESC;
-                        name++;
-                        break;
-                case '\0':
-                case '.':
-                        d->name[i] = FAT_PAD;
-                        break;
-                default:
-                        if (isalpha(*name)) {
-                                if (!islower(*name))
-                                        lower_name = false;
-                        }
-                        
-                        d->name[i] = toupper(*name++);
-                        break;
-                }
-        }
-        
-        if (*name++ != '.')
-                name = fake_ext;
-        
-        for (i = 0; i < FAT_EXT_LEN; i++) {
-                switch ((uint8_t) *name) {
-                case 0xe5:
-                        d->ext[i] = FAT_DENTRY_E5_ESC;
-                        name++;
-                        break;
-                case '\0':
-                        d->ext[i] = FAT_PAD;
-                        break;
-                default:
-                        if (isalpha(*name)) {
-                                if (!islower(*name))
-                                        lower_ext = false;
-                        }
-                        
-                        d->ext[i] = toupper(*name++);
-                        break;
-                }
-        }
-        
-        if (lower_name)
-                d->lcase |= FAT_LCASE_LOWER_NAME;
-        else
-                d->lcase &= ~FAT_LCASE_LOWER_NAME;
-        
-        if (lower_ext)
-                d->lcase |= FAT_LCASE_LOWER_EXT;
-        else
-                d->lcase &= ~FAT_LCASE_LOWER_EXT;
-}
-
-fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
-{
-        if (d->attr & FAT_ATTR_VOLLABEL) {
-                /* volume label entry */
-                return FAT_DENTRY_SKIP;
-        }
-        if (d->name[0] == FAT_DENTRY_ERASED) {
-                /* not-currently-used entry */
-                return FAT_DENTRY_FREE;
-        }
-        if (d->name[0] == FAT_DENTRY_UNUSED) {
-                /* never used entry */
-                return FAT_DENTRY_LAST;
-        }
-        if (d->name[0] == FAT_DENTRY_DOT) {
-                /*
-                 * Most likely '.' or '..'.
-                 * It cannot occur in a regular file name.
-                 */
-                return FAT_DENTRY_SKIP;
-        }
-        return FAT_DENTRY_VALID;
+size_t utf16_length(const uint16_t *wstr)
+{
+        size_t len = 0;
+        
+        while (*wstr++ != 0)
+                len++;
+        
+        return len;
 }
 

uspace/srv/fs/fat/fat_dentry.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -37 +38 @@
 #include <bool.h>
 
+#define IS_D_CHAR(ch) (isalnum(ch) || ch == '_')
+#define FAT_STOP_CHARS "*?/\\\n\t|'"
+
 #define FAT_NAME_LEN            8
 #define FAT_EXT_LEN             3
@@ -44 +48 @@
 #define FAT_EXT_PAD             "   "
 
-#define FAT_ATTR_RDONLY         (1 << 0)
-#define FAT_ATTR_VOLLABEL       (1 << 3)
-#define FAT_ATTR_SUBDIR         (1 << 4)
-
+#define FAT_ATTR_RDONLY   0x01
+#define FAT_ATTR_HIDDEN   0x02
+#define FAT_ATTR_SYSTEM   0x04
+#define FAT_ATTR_VOLLABEL 0x08
+#define FAT_ATTR_SUBDIR   0x10
+#define FAT_ATTR_ARCHIVE  0x20
+#define FAT_ATTR_LFN \
+    (FAT_ATTR_RDONLY | FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM | FAT_ATTR_VOLLABEL)
+    
 #define FAT_LCASE_LOWER_NAME    0x08
 #define FAT_LCASE_LOWER_EXT     0x10
 
-#define FAT_PAD                 ' ' 
+#define FAT_PAD                 ' '
+#define FAT_LFN_PAD     0xffff
+#define FAT_SFN_CHAR '_'
 
 #define FAT_DENTRY_UNUSED       0x00
@@ -57 +68 @@
 #define FAT_DENTRY_DOT          0x2e
 #define FAT_DENTRY_ERASED       0xe5
+#define FAT_LFN_LAST            0x40
+#define FAT_LFN_ERASED          0x80
+
+#define FAT_LFN_ORDER(d) ((d)->lfn.order)
+#define FAT_IS_LFN(d) \
+    ((FAT_LFN_ORDER((d)) & FAT_LFN_LAST) == FAT_LFN_LAST)
+#define FAT_LFN_COUNT(d) \
+    (FAT_LFN_ORDER((d)) ^ FAT_LFN_LAST)
+#define FAT_LFN_PART1(d) ((d)->lfn.part1)
+#define FAT_LFN_PART2(d) ((d)->lfn.part2)
+#define FAT_LFN_PART3(d) ((d)->lfn.part3)
+#define FAT_LFN_ATTR(d) ((d)->lfn.attr)
+#define FAT_LFN_CHKSUM(d) ((d)->lfn.check_sum)
+
+#define FAT_LFN_NAME_SIZE   260
+#define FAT_LFN_MAX_COUNT   20
+#define FAT_LFN_PART1_SIZE  5
+#define FAT_LFN_PART2_SIZE  6
+#define FAT_LFN_PART3_SIZE  2
+#define FAT_LFN_ENTRY_SIZE \
+    (FAT_LFN_PART1_SIZE + FAT_LFN_PART2_SIZE + FAT_LFN_PART3_SIZE)
 
 typedef enum {
@@ -62 +94 @@
         FAT_DENTRY_LAST,
         FAT_DENTRY_FREE,
-        FAT_DENTRY_VALID
+        FAT_DENTRY_VALID,
+        FAT_DENTRY_LFN
 } fat_dentry_clsf_t;
 
-typedef struct {
-        uint8_t         name[8];
-        uint8_t         ext[3];
-        uint8_t         attr;
-        uint8_t         lcase;
-        uint8_t         ctime_fine;
-        uint16_t        ctime;
-        uint16_t        cdate;
-        uint16_t        adate;
-        union {
-                uint16_t        eaidx;          /* FAT12/FAT16 */
-                uint16_t        firstc_hi;      /* FAT32 */
+typedef union {
+        struct {
+                uint8_t         name[8];
+                uint8_t         ext[3];
+                uint8_t         attr;
+                uint8_t         lcase;
+                uint8_t         ctime_fine;
+                uint16_t        ctime;
+                uint16_t        cdate;
+                uint16_t        adate;
+                union {
+                        uint16_t        eaidx;          /* FAT12/FAT16 */
+                        uint16_t        firstc_hi;      /* FAT32 */
+                } __attribute__ ((packed));
+                uint16_t        mtime;
+                uint16_t        mdate;
+                union {
+                        uint16_t        firstc;         /* FAT12/FAT16 */
+                        uint16_t        firstc_lo;      /* FAT32 */
+                } __attribute__ ((packed));
+                uint32_t        size;
         } __attribute__ ((packed));
-        uint16_t        mtime;
-        uint16_t        mdate;
-        union {
-                uint16_t        firstc;         /* FAT12/FAT16 */
-                uint16_t        firstc_lo;      /* FAT32 */
-        } __attribute__ ((packed));
-        uint32_t        size;
+        struct {
+                uint8_t         order;
+                uint16_t        part1[FAT_LFN_PART1_SIZE];
+                uint8_t         attr;
+                uint8_t         type;
+                uint8_t         check_sum;
+                uint16_t        part2[FAT_LFN_PART2_SIZE];
+                uint16_t        firstc_lo; /* MUST be 0 */
+                uint16_t        part3[FAT_LFN_PART3_SIZE];
+        } __attribute__ ((packed)) lfn;
 } __attribute__ ((packed)) fat_dentry_t;
 
+
 extern int fat_dentry_namecmp(char *, const char *);
-extern bool fat_dentry_name_verify(const char *);
 extern void fat_dentry_name_get(const fat_dentry_t *, char *);
 extern void fat_dentry_name_set(fat_dentry_t *, const char *);
 extern fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *);
+extern uint8_t fat_dentry_chksum(uint8_t *);
+
+extern size_t fat_lfn_str_nlength(const uint16_t *, size_t);
+extern size_t fat_lfn_size(const fat_dentry_t *);
+extern size_t fat_lfn_get_entry(const fat_dentry_t *, uint16_t *, size_t *);
+extern size_t fat_lfn_set_entry(const uint16_t *, size_t *, size_t,
+    fat_dentry_t *);
+
+extern void str_to_ascii(char *, const char *, size_t, uint8_t);
+extern size_t utf16_length(const uint16_t *);
+
+extern bool fat_valid_name(const char *);
+extern bool fat_valid_short_name(const char *);
 
 #endif

uspace/srv/fs/fat/fat_fat.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -29 +30 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 /**
@@ -50 +51 @@
 #include <mem.h>
 
-/*
- * 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 CLBN2PBN(bs, cl, bn) \
-        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
+#define IS_ODD(number)  (number & 0x1)
 
 /**
@@ -65 +57 @@
  * during allocation of clusters. The lock does not have to be held durring
  * deallocation of clusters.
- */  
+ */
 static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock);
 
@@ -77 +69 @@
  * @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, service_id_t service_id, 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 *lastc, uint32_t *numc, uint32_t max_clusters)
+{
+        uint32_t clusters = 0;
+        fat_cluster_t clst = firstc, clst_last1 = FAT_CLST_LAST1(bs);
+        fat_cluster_t clst_bad = FAT_CLST_BAD(bs);
         int rc;
 
@@ -99 +91 @@
         }
 
-        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, service_id, 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, service_id, 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 +135 @@
                 return ELIMIT;
 
-        if (nodep->firstc == FAT_CLST_ROOT) 
+        if (!FAT_IS_FAT32(bs) && nodep->firstc == FAT_CLST_ROOT)
                 goto fall_through;
 
@@ -178 +162 @@
         if (rc != EOK)
                 return rc;
-        
+
         /*
          * Update the "current" cluster cache.
@@ -198 +182 @@
  * @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.
@@ -208 +192 @@
     fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
 {
-        uint16_t clusters;
-        unsigned max_clusters;
+        uint32_t clusters;
+        uint32_t max_clusters;
         fat_cluster_t c;
         int rc;
@@ -219 +203 @@
                 return ELIMIT;
 
-        if (fcl == FAT_CLST_ROOT) {
+        if (!FAT_IS_FAT32(bs) && fcl == FAT_CLST_ROOT) {
                 /* root directory special case */
                 assert(bn < RDS(bs));
@@ -253 +237 @@
  * @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, aoff64_t pos)
+int
+fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
 {
         block_t *b;
@@ -275 +260 @@
                         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)) {
@@ -304 +289 @@
  * @return              EOK or a negative error code.
  */
+static int
+fat_get_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t *value)
+{
+        block_t *b, *b1;
+        uint16_t byte1, byte2;
+        aoff64_t offset;
+        int rc;
+
+        offset = (clst + clst / 2);
+        if (offset / BPS(bs) >= SF(bs))
+                return ERANGE;
+
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        byte1 = ((uint8_t *) b->data)[offset % BPS(bs)];
+        /* This cluster access spans a sector boundary. Check only for FAT12 */
+        if ((offset % BPS(bs)) + 1 == BPS(bs)) {
+                /* Is this the last sector of FAT? */
+                if (offset / BPS(bs) < SF(bs)) {
+                        /* No, read the next sector */
+                        rc = block_get(&b1, service_id, 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
+                        */
+                        byte2 = ((uint8_t*) b1->data)[0];
+
+                        rc = block_put(b1);
+                        if (rc != EOK) {
+                                block_put(b);
+                                return rc;
+                        }
+                } else {
+                        /* Yes. This is the last sector of FAT */
+                        block_put(b);
+                        return ERANGE;
+                }
+        } else
+                byte2 = ((uint8_t *) b->data)[(offset % BPS(bs)) + 1];
+
+        *value = uint16_t_le2host(byte1 | (byte2 << 8));
+        if (IS_ODD(clst))
+                *value = (*value) >> 4;
+        else
+                *value = (*value) & FAT12_MASK;
+        
+        rc = block_put(b);
+
+        return rc;
+}
+
+/** Get cluster from the first FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID 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.
+ */
+static int
+fat_get_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t *value)
+{
+        block_t *b;
+        aoff64_t offset;
+        int rc;
+
+        offset = (clst * FAT16_CLST_SIZE);
+
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        *value = uint16_t_le2host(*(uint16_t *)(b->data + offset % BPS(bs)));
+
+        rc = block_put(b);
+
+        return rc;
+}
+
+/** Get cluster from the first FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID 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.
+ */
+static int
+fat_get_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t *value)
+{
+        block_t *b;
+        aoff64_t offset;
+        int rc;
+
+        offset = (clst * FAT32_CLST_SIZE);
+
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) &
+            FAT32_MASK;
+
+        rc = block_put(b);
+
+        return rc;
+}
+
+
+/** Get cluster from the first FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID 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, service_id_t service_id, unsigned fatno,
     fat_cluster_t clst, fat_cluster_t *value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
-        int rc;
-
+        int rc;
+
+        assert(fatno < FATCNT(bs));
+
+        if (FAT_IS_FAT12(bs))
+                rc = fat_get_cluster_fat12(bs, service_id, fatno, clst, value);
+        else if (FAT_IS_FAT16(bs))
+                rc = fat_get_cluster_fat16(bs, service_id, fatno, clst, value);
+        else
+                rc = fat_get_cluster_fat32(bs, service_id, fatno, clst, value);
+
+        return rc;
+}
+
+/** Set cluster in one instance of FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID for the file system.
+ * @param fatno         Number of the FAT instance where to make the change.
+ * @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.
+ */
+static int
+fat_set_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t value)
+{
+        block_t *b, *b1 = NULL;
+        aoff64_t offset;
+        uint16_t byte1, byte2;
+        int rc;
+
+        offset = (clst + clst / 2);
+        if (offset / BPS(bs) >= SF(bs))
+                return ERANGE;
+        
         rc = block_get(&b, service_id, 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);
+
+        byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
+        bool border = false;
+        /* This cluster access spans a sector boundary. */
+        if ((offset % BPS(bs)) + 1 == BPS(bs)) {
+                /* Is it the last sector of FAT? */
+                if (offset / BPS(bs) < SF(bs)) {
+                        /* No, read the next sector */
+                        rc = block_get(&b1, service_id, 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
+                         */
+                        byte2 = ((uint8_t *) b1->data)[0];
+                        border = true;
+                } else {
+                        /* Yes. This is the last sector of FAT */
+                        block_put(b);
+                        return ERANGE;
+                }
+        } else
+                byte2 = ((uint8_t*) b->data)[(offset % BPS(bs)) + 1];
+
+        if (IS_ODD(clst)) {
+                byte1 &= 0x0f;
+                byte2 = 0;
+                value = (value << 4);
+        } else {
+                byte1 = 0;
+                byte2 &= 0xf0;
+                value &= FAT12_MASK;
+        }
+
+        byte1 = byte1 | (value & 0xff);
+        byte2 = byte2 | (value >> 8);
+
+        ((uint8_t *) b->data)[(offset % BPS(bs))] = byte1;
+        if (border) {
+                ((uint8_t *) b1->data)[0] = byte2;
+
+                b1->dirty = true;
+                rc = block_put(b1);
+                if (rc != EOK) {
+                        block_put(b);
+                        return rc;
+                }
+        } else 
+                ((uint8_t *) b->data)[(offset % BPS(bs)) + 1] = byte2;
+
+        b->dirty = true;        /* need to sync block */
         rc = block_put(b);
-        
+
+        return rc;
+}
+
+/** Set cluster in one instance of FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID for the file system.
+ * @param fatno         Number of the FAT instance where to make the change.
+ * @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.
+ */
+static int
+fat_set_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t value)
+{
+        block_t *b;
+        aoff64_t offset;
+        int rc;
+
+        offset = (clst * FAT16_CLST_SIZE);
+
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        *(uint16_t *)(b->data + offset % BPS(bs)) = host2uint16_t_le(value);
+
+        b->dirty = true;        /* need to sync block */
+        rc = block_put(b);
+
+        return rc;
+}
+
+/** Set cluster in one instance of FAT.
+ *
+ * @param bs            Buffer holding the boot sector for the file system.
+ * @param service_id    Service ID for the file system.
+ * @param fatno         Number of the FAT instance where to make the change.
+ * @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.
+ */
+static int
+fat_set_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t value)
+{
+        block_t *b;
+        aoff64_t offset;
+        int rc;
+        fat_cluster_t temp;
+
+        offset = (clst * FAT32_CLST_SIZE);
+
+        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
+            offset / BPS(bs), BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        temp = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs)));
+        temp &= 0xf0000000;
+        temp |= (value & FAT32_MASK);
+        *(uint32_t *)(b->data + offset % BPS(bs)) = host2uint32_t_le(temp);
+
+        b->dirty = true;        /* need to sync block */
+        rc = block_put(b);
+
         return rc;
 }
@@ -338 +613 @@
     fat_cluster_t clst, fat_cluster_t value)
 {
-        block_t *b;
-        fat_cluster_t *cp;
         int rc;
 
         assert(fatno < FATCNT(bs));
-        rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno +
-            (clst * sizeof(fat_cluster_t)) / 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 */
-        rc = block_put(b);
+
+        if (FAT_IS_FAT12(bs))
+                rc = fat_set_cluster_fat12(bs, service_id, fatno, clst, value);
+        else if (FAT_IS_FAT16(bs))
+                rc = fat_set_cluster_fat16(bs, service_id, fatno, clst, value);
+        else
+                rc = fat_set_cluster_fat32(bs, service_id, fatno, clst, value);
+
         return rc;
 }
@@ -369 +641 @@
         uint8_t fatno;
         unsigned c;
-        int rc;
-
-        for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
+        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
+        int rc;
+
+        for (fatno = FAT1 + 1; fatno < FATCNT(bs); fatno++) {
                 for (c = 0; c < nclsts; c++) {
                         rc = fat_set_cluster(bs, service_id, fatno, lifo[c],
-                            c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
+                            c == 0 ? clst_last1 : lifo[c - 1]);
                         if (rc != EOK)
                                 return rc;
@@ -404 +677 @@
     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, service_id, RSCNT(bs) + b,
-                    BLOCK_FLAGS_NONE);
-                if (rc != EOK)
-                        goto error;
-                for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) {
+        for (clst = FAT_CLST_FIRST; clst < CC(bs) + 2 && found < nclsts;
+            clst++) {
+                rc = fat_get_cluster(bs, service_id, FAT1, clst, &value);
+                if (rc != EOK)
+                        break;
+
+                if (value == FAT_CLST_RES0) {
                         /*
-                         * 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.
+                         * The cluster is free. Put it into our stack
+                         * of found clusters and mark it as non-free.
                          */
-                        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,
-                                            service_id, lifo, nclsts);
-                                        if (rc != EOK)
-                                                goto error;
-                                        *mcl = lifo[found - 1];
-                                        *lcl = lifo[0];
-                                        free(lifo);
-                                        fibril_mutex_unlock(&fat_alloc_lock);
-                                        return EOK;
-                                }
-                        }
+                        lifo[found] = clst;
+                        rc = fat_set_cluster(bs, service_id, FAT1, clst,
+                            (found == 0) ?  clst_last1 : lifo[found - 1]);
+                        if (rc != EOK)
+                                break;
+
+                        found++;
                 }
-                rc = block_put(blk);
-                if (rc != EOK) {
-error:
+        }
+
+        if (rc == EOK && found == nclsts) {
+                rc = fat_alloc_shadow_clusters(bs, service_id, lifo, nclsts);
+                if (rc == EOK) {
+                        *mcl = lifo[found - 1];
+                        *lcl = lifo[0];
+                        free(lifo);
                         fibril_mutex_unlock(&fat_alloc_lock);
-                        free(lifo);
-                        return rc;
+                        return EOK;
                 }
         }
-out:
+
+        /* If something wrong - free the clusters */
+        while (found--) {
+                (void) fat_set_cluster(bs, service_id, FAT1, lifo[found],
+                    FAT_CLST_RES0);
+        }
+
+        free(lifo);
         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--) {
-                rc = fat_set_cluster(bs, service_id, FAT1, lifo[found],
-                    FAT_CLST_RES0);
-                if (rc != EOK) {
-                        free(lifo);
-                        return rc;
-                }
-        }
-        
-        free(lifo);
         return ENOSPC;
 }
@@ -509 +745 @@
 {
         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, service_id, FAT1, firstc, &nextc);
                 if (rc != EOK)
                         return rc;
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
+
+                for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {
                         rc = fat_set_cluster(bs, service_id, fatno, firstc,
                             FAT_CLST_RES0);
@@ -524 +762 @@
                                 return rc;
                 }
-
                 firstc = nextc;
         }
@@ -540 +777 @@
  * @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,
+int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
     fat_cluster_t lcl)
 {
@@ -559 +795 @@
                 } else {
                         rc = fat_cluster_walk(bs, service_id, nodep->firstc,
-                            &lastc, NULL, (uint16_t) -1);
+                            &lastc, NULL, (uint32_t) -1);
                         if (rc != EOK)
                                 return rc;
                 }
 
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, nodep->idx->service_id, fatno,
-                            lastc, mcl);
+                for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {
+                        rc = fat_set_cluster(bs, nodep->idx->service_id,
+                            fatno, lastc, mcl);
                         if (rc != EOK)
                                 return rc;
@@ -590 +826 @@
 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;
         service_id_t service_id = nodep->idx->service_id;
@@ -616 +853 @@
 
                 /* Terminate the cluster chain in all copies of FAT. */
-                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
+                for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {
                         rc = fat_set_cluster(bs, service_id, fatno, lcl,
-                            FAT_CLST_LAST1);
+                            clst_last1);
                         if (rc != EOK)
                                 return rc;
@@ -673 +910 @@
 
         /* 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;
 
         if (bs->totsec16 != 0 && bs->totsec32 != 0 &&
-            bs->totsec16 != bs->totsec32) 
+            bs->totsec16 != bs->totsec32)
                 return ENOTSUP;
 
@@ -690 +926 @@
 
         /* Check number of sectors per FAT. */
-        if (bs->sec_per_fat == 0)
+        if (SF(bs) == 0)
                 return ENOTSUP;
 
@@ -700 +936 @@
          * 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, service_id, fat_no, 0, &e0);
                 if (rc != EOK)
@@ -715 +950 @@
                         return EIO;
 
-                /* Check that first byte of FAT contains the media descriptor. */
+                /*
+                 * Check that first byte of FAT contains the media descriptor.
+                 */
                 if ((e0 & 0xff) != bs->mdesc)
                         return ENOTSUP;
@@ -723 +960 @@
                  * set to one.
                  */
-                if ((e0 >> 8) != 0xff || e1 != 0xffff)
+                if (!FAT_IS_FAT12(bs) && 
+                    ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
                         return ENOTSUP;
         }
@@ -732 +970 @@
 /**
  * @}
- */ 
+ */

uspace/srv/fs/fat/fat_fat.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -29 +30 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 #ifndef FAT_FAT_FAT_H_
@@ -40 +41 @@
 #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     0
+#define FAT_CLST_RES1     1
+#define FAT_CLST_FIRST    2
+
+#define FAT32_CLST_BAD    0x0ffffff7
+#define FAT32_CLST_LAST1  0x0ffffff8
+#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 */
@@ -52 +66 @@
 #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 CLBN2PBN(bs, cl, bn) \
+        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % 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_IS_FAT32(bs)        (CC(bs) >= FAT16_CLST_MAX)
+
+#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))
+
+#define FAT_CLST_LAST1(bs)      (FAT32_CLST_LAST1 & FAT_MASK((bs)))
+#define FAT_CLST_LAST8(bs)      (FAT32_CLST_LAST8 & FAT_MASK((bs)))
+#define FAT_CLST_BAD(bs)        (FAT32_CLST_BAD & FAT_MASK((bs)))
+
+#define FAT_ROOT_CLST(bs) \
+    (FAT_IS_FAT32(bs) ? uint32_t_le2host(bs->fat32.root_cluster) : \
+    FAT_CLST_ROOT)
+
 /* forward declarations */
 struct block;
@@ -57 +104 @@
 struct fat_bs;
 
-typedef uint16_t fat_cluster_t;
+typedef uint32_t fat_cluster_t;
 
-#define fat_clusters_get(numc, bs, dh, fc) \
-    fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1)
+#define fat_clusters_get(numc, bs, sid, fc) \
+    fat_cluster_walk((bs), (sid), (fc), NULL, (numc), (uint32_t) -1)
 extern int fat_cluster_walk(struct fat_bs *, service_id_t, fat_cluster_t,
-    fat_cluster_t *, uint16_t *, uint16_t);
+    fat_cluster_t *, uint32_t *, uint32_t);
 
 extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,

uspace/srv/fs/fat/fat_idx.c

@@ -116 +116 @@
 #define UPH_BUCKETS     (1 << UPH_BUCKETS_LOG)
 
-#define UPH_DH_KEY      0
+#define UPH_SID_KEY     0
 #define UPH_PFC_KEY     1
 #define UPH_PDI_KEY     2
@@ -122 +122 @@
 static hash_index_t pos_hash(unsigned long key[])
 {
-        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UPH_SID_KEY];
         fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
         unsigned pdi = (unsigned)key[UPH_PDI_KEY];
@@ -150 +150 @@
 static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        service_id_t service_id = (service_id_t)key[UPH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UPH_SID_KEY];
         fat_cluster_t pfc;
         unsigned pdi;
@@ -190 +190 @@
 #define UIH_BUCKETS     (1 << UIH_BUCKETS_LOG)
 
-#define UIH_DH_KEY      0
+#define UIH_SID_KEY     0
 #define UIH_INDEX_KEY   1
 
 static hash_index_t idx_hash(unsigned long key[])
 {
-        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UIH_SID_KEY];
         fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
 
@@ -209 +209 @@
 static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        service_id_t service_id = (service_id_t)key[UIH_DH_KEY];
+        service_id_t service_id = (service_id_t)key[UIH_SID_KEY];
         fs_index_t index;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
@@ -402 +402 @@
                 
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = service_id,
+                [UIH_SID_KEY] = service_id,
                 [UIH_INDEX_KEY] = fidx->index,
         };
@@ -420 +420 @@
         link_t *l;
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = service_id,
+                [UPH_SID_KEY] = service_id,
                 [UPH_PFC_KEY] = pfc,
                 [UPH_PDI_KEY] = pdi,
@@ -439 +439 @@
                 
                 unsigned long ikey[] = {
-                        [UIH_DH_KEY] = service_id,
+                        [UIH_SID_KEY] = service_id,
                         [UIH_INDEX_KEY] = fidx->index,
                 };
@@ -458 +458 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->service_id,
+                [UPH_SID_KEY] = idx->service_id,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -471 +471 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->service_id,
+                [UPH_SID_KEY] = idx->service_id,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -487 +487 @@
         link_t *l;
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = service_id,
+                [UIH_SID_KEY] = service_id,
                 [UIH_INDEX_KEY] = index,
         };
@@ -509 +509 @@
 {
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = idx->service_id,
+                [UIH_SID_KEY] = idx->service_id,
                 [UIH_INDEX_KEY] = idx->index,
         };
@@ -571 +571 @@
 {
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = service_id
+                [UIH_SID_KEY] = service_id
         };
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = service_id
+                [UPH_SID_KEY] = service_id
         };
 

uspace/srv/fs/fat/fat_ops.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
  *
@@ -29 +30 @@
 /** @addtogroup fs
  * @{
- */ 
+ */
 
 /**
@@ -39 +40 @@
 #include "fat_dentry.h"
 #include "fat_fat.h"
+#include "fat_directory.h"
 #include "../../vfs/vfs.h"
 #include <libfs.h>
@@ -56 +58 @@
 #include <align.h>
 #include <malloc.h>
+#include <str.h>
 
 #define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
@@ -104 +107 @@
         node->dirty = false;
         node->lastc_cached_valid = false;
-        node->lastc_cached_value = FAT_CLST_LAST1;
+        node->lastc_cached_value = 0;
         node->currc_cached_valid = false;
         node->currc_cached_bn = 0;
-        node->currc_cached_value = FAT_CLST_LAST1;
+        node->currc_cached_value = 0;
 }
 
@@ -116 +119 @@
         fat_dentry_t *d;
         int rc;
-        
+
         assert(node->dirty);
 
         bs = block_bb_get(node->idx->service_id);
-        
+
         /* Read the block that contains the dentry of interest. */
         rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc,
@@ -136 +139 @@
                 d->attr = FAT_ATTR_SUBDIR;
         }
-        
+
         /* TODO: update other fields? (e.g time fields) */
-        
+
         b->dirty = true;                /* need to sync block */
         rc = block_put(b);
@@ -255 +258 @@
         fn->data = nodep;
         nodep->bp = fn;
-        
+
         *nodepp = nodep;
         return EOK;
@@ -291 +294 @@
          * We must instantiate the node from the file system.
          */
-        
+
         assert(idxp->pfc);
 
@@ -309 +312 @@
 
         d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
+        if (FAT_IS_FAT32(bs)) {
+                nodep->firstc = uint16_t_le2host(d->firstc_lo) | 
+                    (uint16_t_le2host(d->firstc_hi) << 16);
+        } else
+                nodep->firstc = uint16_t_le2host(d->firstc);
+
         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
@@ -316 +325 @@
                  */
                 nodep->type = FAT_DIRECTORY;
+
                 /*
                  * Unfortunately, the 'size' field of the FAT dentry is not
@@ -321 +331 @@
                  * size of the directory by walking the FAT.
                  */
-                uint16_t clusters;
+                uint32_t clusters;
                 rc = fat_clusters_get(&clusters, bs, idxp->service_id,
-                    uint16_t_le2host(d->firstc));
+                    nodep->firstc);
                 if (rc != EOK) {
                         (void) block_put(b);
@@ -334 +344 @@
                 nodep->size = uint32_t_le2host(d->size);
         }
-        nodep->firstc = uint16_t_le2host(d->firstc);
+
         nodep->lnkcnt = 1;
         nodep->refcnt = 1;
@@ -363 +373 @@
 int fat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
 {
-        fat_bs_t *bs;
         fat_node_t *parentp = FAT_NODE(pfn);
-        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
-        unsigned i, j;
-        unsigned blocks;
+        char name[FAT_LFN_NAME_SIZE];
         fat_dentry_t *d;
         service_id_t service_id;
-        block_t *b;
         int rc;
 
@@ -376 +382 @@
         service_id = parentp->idx->service_id;
         fibril_mutex_unlock(&parentp->idx->lock);
-
-        bs = block_bb_get(service_id);
-        blocks = parentp->size / BPS(bs);
-        for (i = 0; i < blocks; i++) {
-                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
-                if (rc != EOK)
-                        return rc;
-                for (j = 0; j < DPS(bs); j++) { 
-                        d = ((fat_dentry_t *)b->data) + j;
-                        switch (fat_classify_dentry(d)) {
-                        case FAT_DENTRY_SKIP:
-                        case FAT_DENTRY_FREE:
-                                continue;
-                        case FAT_DENTRY_LAST:
-                                /* miss */
-                                rc = block_put(b);
-                                *rfn = NULL;
-                                return rc;
-                        default:
-                        case FAT_DENTRY_VALID:
-                                fat_dentry_name_get(d, name);
-                                break;
+        
+        fat_directory_t di;
+        rc = fat_directory_open(parentp, &di);
+        if (rc != EOK)
+                return rc;
+
+        while (fat_directory_read(&di, name, &d) == EOK) {
+                if (fat_dentry_namecmp(name, component) == 0) {
+                        /* hit */
+                        fat_node_t *nodep;
+                        aoff64_t o = di.pos %
+                            (BPS(di.bs) / sizeof(fat_dentry_t));
+                        fat_idx_t *idx = fat_idx_get_by_pos(service_id,
+                            parentp->firstc, di.bnum * DPS(di.bs) + o);
+                        if (!idx) {
+                                /*
+                                 * Can happen if memory is low or if we
+                                 * run out of 32-bit indices.
+                                 */
+                                rc = fat_directory_close(&di);
+                                return (rc == EOK) ? ENOMEM : rc;
                         }
-                        if (fat_dentry_namecmp(name, component) == 0) {
-                                /* hit */
-                                fat_node_t *nodep;
-                                fat_idx_t *idx = fat_idx_get_by_pos(service_id,
-                                    parentp->firstc, i * DPS(bs) + j);
-                                if (!idx) {
-                                        /*
-                                         * Can happen if memory is low or if we
-                                         * run out of 32-bit indices.
-                                         */
-                                        rc = block_put(b);
-                                        return (rc == EOK) ? ENOMEM : rc;
-                                }
-                                rc = fat_node_get_core(&nodep, idx);
-                                fibril_mutex_unlock(&idx->lock);
-                                if (rc != EOK) {
-                                        (void) block_put(b);
-                                        return rc;
-                                }
-                                *rfn = FS_NODE(nodep);
-                                rc = block_put(b);
-                                if (rc != EOK)
-                                        (void) fat_node_put(*rfn);
+                        rc = fat_node_get_core(&nodep, idx);
+                        fibril_mutex_unlock(&idx->lock);
+                        if (rc != EOK) {
+                                (void) fat_directory_close(&di);
                                 return rc;
                         }
-                }
-                rc = block_put(b);
-                if (rc != EOK)
+                        *rfn = FS_NODE(nodep);
+                        rc = fat_directory_close(&di);
+                        if (rc != EOK)
+                                (void) fat_node_put(*rfn);
                         return rc;
-        }
-
+                } else {
+                        rc = fat_directory_next(&di);
+                        if (rc != EOK)
+                                break;
+                }
+        }
+        (void) fat_directory_close(&di);
         *rfn = NULL;
         return EOK;
@@ -591 +583 @@
         fat_bs_t *bs;
         block_t *b;
-        unsigned i, j;
-        unsigned blocks;
-        fat_cluster_t mcl, lcl;
+        fat_directory_t di;
+        fat_dentry_t de;
         int rc;
 
@@ -607 +598 @@
         fibril_mutex_unlock(&childp->lock);
 
-        if (!fat_dentry_name_verify(name)) {
-                /*
-                 * Attempt to create unsupported name.
-                 */
+        if (!fat_valid_name(name))
                 return ENOTSUP;
-        }
-
-        /*
-         * Get us an unused parent node's dentry or grow the parent and allocate
-         * a new one.
-         */
-        
+
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->service_id);
-
-        blocks = parentp->size / BPS(bs);
-
-        for (i = 0; i < blocks; i++) {
-                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&parentp->idx->lock);
-                        return rc;
-                }
-                for (j = 0; j < DPS(bs); j++) {
-                        d = ((fat_dentry_t *)b->data) + j;
-                        switch (fat_classify_dentry(d)) {
-                        case FAT_DENTRY_SKIP:
-                        case FAT_DENTRY_VALID:
-                                /* skipping used and meta entries */
-                                continue;
-                        case FAT_DENTRY_FREE:
-                        case FAT_DENTRY_LAST:
-                                /* found an empty slot */
-                                goto hit;
-                        }
-                }
-                rc = block_put(b);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&parentp->idx->lock);
-                        return rc;
-                }
-        }
-        j = 0;
-        
-        /*
-         * We need to grow the parent in order to create a new unused dentry.
-         */
-        if (parentp->firstc == FAT_CLST_ROOT) {
-                /* Can't grow the root directory. */
-                fibril_mutex_unlock(&parentp->idx->lock);
-                return ENOSPC;
-        }
-        rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl);
+        rc = fat_directory_open(parentp, &di);
         if (rc != EOK) {
                 fibril_mutex_unlock(&parentp->idx->lock);
                 return rc;
         }
-        rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
-                fibril_mutex_unlock(&parentp->idx->lock);
-                return rc;
-        }
-        rc = fat_append_clusters(bs, parentp, mcl, lcl);
-        if (rc != EOK) {
-                (void) fat_free_clusters(bs, parentp->idx->service_id, mcl);
-                fibril_mutex_unlock(&parentp->idx->lock);
-                return rc;
-        }
-        parentp->size += BPS(bs) * SPC(bs);
-        parentp->dirty = true;          /* need to sync node */
-        rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
-        if (rc != EOK) {
-                fibril_mutex_unlock(&parentp->idx->lock);
-                return rc;
-        }
-        d = (fat_dentry_t *)b->data;
-
-hit:
+
         /*
          * At this point we only establish the link between the parent and the
@@ -692 +615 @@
          * dentry data is kept in the child node structure.
          */
-        memset(d, 0, sizeof(fat_dentry_t));
-        fat_dentry_name_set(d, name);
-        b->dirty = true;                /* need to sync block */
-        rc = block_put(b);
+        memset(&de, 0, sizeof(fat_dentry_t));
+
+        rc = fat_directory_write(&di, name, &de);
+        if (rc != EOK) {
+                (void) fat_directory_close(&di);
+                fibril_mutex_unlock(&parentp->idx->lock);
+                return rc;
+        }
+        rc = fat_directory_close(&di);
+        if (rc != EOK) {
+                fibril_mutex_unlock(&parentp->idx->lock);
+                return rc;
+        }
+
         fibril_mutex_unlock(&parentp->idx->lock);
-        if (rc != EOK) 
-                return rc;
 
         fibril_mutex_lock(&childp->idx->lock);
-        
+
         if (childp->type == FAT_DIRECTORY) {
                 /*
@@ -720 +651 @@
                 d = (fat_dentry_t *) b->data;
                 if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
-                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
+                    (bcmp(d->name, FAT_NAME_DOT, FAT_NAME_LEN)) == 0) {
                         memset(d, 0, sizeof(fat_dentry_t));
                         memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
@@ -730 +661 @@
                 d++;
                 if ((fat_classify_dentry(d) == FAT_DENTRY_LAST) ||
-                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
+                    (bcmp(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN) == 0)) {
                         memset(d, 0, sizeof(fat_dentry_t));
                         memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
                         memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
                         d->attr = FAT_ATTR_SUBDIR;
-                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
-                            host2uint16_t_le(FAT_CLST_RES0) :
+                        d->firstc = (parentp->firstc == FAT_ROOT_CLST(bs)) ?
+                            host2uint16_t_le(FAT_CLST_ROOTPAR) :
                             host2uint16_t_le(parentp->firstc);
                         /* TODO: initialize also the date/time members. */
@@ -750 +681 @@
 
         childp->idx->pfc = parentp->firstc;
-        childp->idx->pdi = i * DPS(bs) + j;
+        childp->idx->pdi = di.pos;      /* di.pos holds absolute position of SFN entry */
         fibril_mutex_unlock(&childp->idx->lock);
 
@@ -770 +701 @@
         fat_node_t *parentp = FAT_NODE(pfn);
         fat_node_t *childp = FAT_NODE(cfn);
-        fat_bs_t *bs;
-        fat_dentry_t *d;
-        block_t *b;
         bool has_children;
         int rc;
@@ -778 +706 @@
         if (!parentp)
                 return EBUSY;
-        
+
         rc = fat_has_children(&has_children, cfn);
         if (rc != EOK)
@@ -789 +717 @@
         assert(childp->lnkcnt == 1);
         fibril_mutex_lock(&childp->idx->lock);
-        bs = block_bb_get(childp->idx->service_id);
-
-        rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc,
-            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
-            BLOCK_FLAGS_NONE);
-        if (rc != EOK) 
+        
+        fat_directory_t di;
+        rc = fat_directory_open(parentp, &di);
+        if (rc != EOK)
                 goto error;
-        d = (fat_dentry_t *)b->data +
-            (childp->idx->pdi % (BPS(bs) / sizeof(fat_dentry_t)));
-        /* mark the dentry as not-currently-used */
-        d->name[0] = FAT_DENTRY_ERASED;
-        b->dirty = true;                /* need to sync block */
-        rc = block_put(b);
+        rc = fat_directory_seek(&di, childp->idx->pdi);
+        if (rc != EOK)
+                goto error;
+        rc = fat_directory_erase(&di);
+        if (rc != EOK)
+                goto error;
+        rc = fat_directory_close(&di);
         if (rc != EOK)
                 goto error;
@@ -820 +747 @@
 
 error:
-        fibril_mutex_unlock(&parentp->idx->lock);
+        (void) fat_directory_close(&di);
+        fibril_mutex_unlock(&childp->idx->lock);
         fibril_mutex_unlock(&childp->lock);
-        fibril_mutex_unlock(&childp->idx->lock);
+        fibril_mutex_unlock(&parentp->lock);
         return rc;
 }
@@ -839 +767 @@
                 return EOK;
         }
-        
+
         fibril_mutex_lock(&nodep->idx->lock);
         bs = block_bb_get(nodep->idx->service_id);
@@ -847 +775 @@
         for (i = 0; i < blocks; i++) {
                 fat_dentry_t *d;
-        
+
                 rc = fat_block_get(&b, bs, nodep, i, BLOCK_FLAGS_NONE);
                 if (rc != EOK) {
@@ -875 +803 @@
                 if (rc != EOK) {
                         fibril_mutex_unlock(&nodep->idx->lock);
-                        return rc;      
+                        return rc;
                 }
         }
@@ -946 +874 @@
         fat_bs_t *bs;
         int rc;
-        
+
         /* Check for option enabling write through. */
         if (str_cmp(opts, "wtcache") == 0)
@@ -1003 +931 @@
                 return ENOMEM;
         }
+
         fs_node_initialize(rfn);
         fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
@@ -1027 +956 @@
 
         rootp->type = FAT_DIRECTORY;
-        rootp->firstc = FAT_CLST_ROOT;
+        rootp->firstc = FAT_ROOT_CLST(bs);
         rootp->refcnt = 1;
         rootp->lnkcnt = 0;      /* FS root is not linked */
-        rootp->size = RDE(bs) * sizeof(fat_dentry_t);
+
+        if (FAT_IS_FAT32(bs)) {
+                uint32_t clusters;
+                rc = fat_clusters_get(&clusters, bs, service_id, rootp->firstc);
+                if (rc != EOK) {
+                        free(rfn);
+                        free(rootp);
+                        (void) block_cache_fini(service_id);
+                        block_fini(service_id);
+                        fat_idx_fini_by_service_id(service_id);
+                        return ENOTSUP;
+                }
+                rootp->size = BPS(bs) * SPC(bs) * clusters;
+        } else
+                rootp->size = RDE(bs) * sizeof(fat_dentry_t);
+
         rootp->idx = ridxp;
         ridxp->nodep = rootp;
         rootp->bp = rfn;
         rfn->data = rootp;
-        
+
         fibril_mutex_unlock(&ridxp->lock);
 
@@ -1064 +1008 @@
                 return EBUSY;
         }
-        
+
         /*
          * Put the root node and force it to the FAT free node list.
@@ -1141 +1085 @@
                 }
         } else {
-                unsigned bnum;
                 aoff64_t spos = pos;
-                char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
+                char name[FAT_LFN_NAME_SIZE];
                 fat_dentry_t *d;
 
@@ -1150 +1093 @@
                 assert(BPS(bs) % sizeof(fat_dentry_t) == 0);
 
-                /*
-                 * Our strategy for readdir() is to use the position pointer as
-                 * an index into the array of all dentries. On entry, it points
-                 * to the first unread dentry. If we skip any dentries, we bump
-                 * the position pointer accordingly.
-                 */
-                bnum = (pos * sizeof(fat_dentry_t)) / BPS(bs);
-                while (bnum < nodep->size / BPS(bs)) {
-                        aoff64_t o;
-
-                        rc = fat_block_get(&b, bs, nodep, bnum,
-                            BLOCK_FLAGS_NONE);
-                        if (rc != EOK)
-                                goto err;
-                        for (o = pos % (BPS(bs) / sizeof(fat_dentry_t));
-                            o < BPS(bs) / sizeof(fat_dentry_t);
-                            o++, pos++) {
-                                d = ((fat_dentry_t *)b->data) + o;
-                                switch (fat_classify_dentry(d)) {
-                                case FAT_DENTRY_SKIP:
-                                case FAT_DENTRY_FREE:
-                                        continue;
-                                case FAT_DENTRY_LAST:
-                                        rc = block_put(b);
-                                        if (rc != EOK)
-                                                goto err;
-                                        goto miss;
-                                default:
-                                case FAT_DENTRY_VALID:
-                                        fat_dentry_name_get(d, name);
-                                        rc = block_put(b);
-                                        if (rc != EOK)
-                                                goto err;
-                                        goto hit;
-                                }
-                        }
-                        rc = block_put(b);
-                        if (rc != EOK)
-                                goto err;
-                        bnum++;
-                }
+                fat_directory_t di;
+                rc = fat_directory_open(nodep, &di);
+                if (rc != EOK)
+                        goto err;
+                rc = fat_directory_seek(&di, pos);
+                if (rc != EOK) {
+                        (void) fat_directory_close(&di);
+                        goto err;
+                }
+
+                rc = fat_directory_read(&di, name, &d);
+                if (rc == EOK)
+                        goto hit;
+                if (rc == ENOENT)
+                        goto miss;
+
+err:
+                (void) fat_node_put(fn);
+                async_answer_0(callid, rc);
+                return rc;
+
 miss:
+                rc = fat_directory_close(&di);
+                if (rc != EOK)
+                        goto err;
                 rc = fat_node_put(fn);
                 async_answer_0(callid, rc != EOK ? rc : ENOENT);
@@ -1197 +1123 @@
                 return rc != EOK ? rc : ENOENT;
 
-err:
-                (void) fat_node_put(fn);
-                async_answer_0(callid, rc);
-                return rc;
-
 hit:
-                (void) async_data_read_finalize(callid, name, str_size(name) + 1);
+                pos = di.pos;
+                rc = fat_directory_close(&di);
+                if (rc != EOK)
+                        goto err;
+                (void) async_data_read_finalize(callid, name,
+                    str_size(name) + 1);
                 bytes = (pos - spos) + 1;
         }
@@ -1231 +1157 @@
                 return ENOENT;
         nodep = FAT_NODE(fn);
-        
+
         ipc_callid_t callid;
         size_t len;
@@ -1247 +1173 @@
          * 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) {
@@ -1295 +1221 @@
                  */
                 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 */
@@ -1380 +1306 @@
                 nodep->size = size;
                 nodep->dirty = true;            /* need to sync node */
-                rc = EOK;       
+                rc = EOK;
         } else {
                 /*
@@ -1401 +1327 @@
                 nodep->size = size;
                 nodep->dirty = true;            /* need to sync node */
-                rc = EOK;       
+                rc = EOK;
         }
 out:
@@ -1444 +1370 @@
         if (!fn)
                 return ENOENT;
-        
+
         fat_node_t *nodep = FAT_NODE(fn);
-        
+
         nodep->dirty = true;
         rc = fat_node_sync(nodep);
-        
+
         fat_node_put(fn);
         return rc;