Changeset 5d95f02 in mainline

Timestamp:

2011-08-26T23:04:07Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

4bf6895

Parents:

0dbe5ac

Message:

Cleanup.

Location:

uspace/srv/fs/fat

Files:

• fat.h (modified) (2 diffs)
• fat_dentry.c (modified) (6 diffs)
• fat_dentry.h (modified) (3 diffs)
• fat_directory.c (modified) (21 diffs)
• fat_directory.h (modified) (1 diff)
• fat_fat.c (modified) (27 diffs)
• fat_fat.h (modified) (1 diff)

uspace/srv/fs/fat/fat.h

@@ -47 +47 @@
 #endif
 
-#define min(a, b)               ((a) < (b) ? (a) : (b))
+#define min(a, b)       ((a) < (b) ? (a) : (b))
 
 /*
@@ -56 +56 @@
 #define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
 #define FATCNT(bs)      (bs)->fatcnt
-#define SF(bs)          (uint16_t_le2host((bs)->sec_per_fat) !=0 ? \
+
+#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

@@ -221 +221 @@
 uint8_t fat_dentry_chksum(uint8_t *name)
 {
-        uint8_t i, sum=0;
-        for (i=0; i<(FAT_NAME_LEN+FAT_EXT_LEN); i++) {
+        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;
 }
@@ -269 +270 @@
 {
         int i;
-        for (i=FAT_LFN_PART3_SIZE-1; i>=0 && *offset>0; 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;
@@ -275 +276 @@
                 dst[(*offset)] = uint16_t_le2host(d->lfn.part3[i]);
         }
-        for (i=FAT_LFN_PART2_SIZE-1; i>=0 && *offset>0; 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;
@@ -281 +282 @@
                 dst[(*offset)] = uint16_t_le2host(d->lfn.part2[i]);
         }
-        for (i=FAT_LFN_PART1_SIZE-1; i>=0 && *offset>0; 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;
@@ -290 +291 @@
 }
 
-size_t fat_lfn_set_entry(const uint16_t *src, size_t *offset, size_t size, fat_dentry_t *d)
+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++) {
+        for (idx = 0; idx < FAT_LFN_PART1_SIZE; idx++) {
                 if (*offset < size) {
                         d->lfn.part1[idx] = host2uint16_t_le(src[*offset]);
                         (*offset)++;
-                }
-                else
+                } else
                         d->lfn.part1[idx] = FAT_LFN_PAD;
         }
-        for (idx=0; idx < FAT_LFN_PART2_SIZE; idx++) {
+        for (idx = 0; idx < FAT_LFN_PART2_SIZE; idx++) {
                 if (*offset < size) {
                         d->lfn.part2[idx] = host2uint16_t_le(src[*offset]);
                         (*offset)++;
-                }
-                else
+                } else
                         d->lfn.part2[idx] = FAT_LFN_PAD;
         }
-        for (idx=0; idx < FAT_LFN_PART3_SIZE; idx++) {
+        for (idx = 0; idx < FAT_LFN_PART3_SIZE; idx++) {
                 if (*offset < size) {
                         d->lfn.part3[idx] = host2uint16_t_le(src[*offset]);
                         (*offset)++;
-                }
-                else
+                } else
                         d->lfn.part3[idx] = FAT_LFN_PAD;
         }
@@ -339 +338 @@
                         else
                                 *dst = pad;
-                }
-                else
+                } else
                         break;
 

uspace/srv/fs/fat/fat_dentry.h

@@ -71 +71 @@
 #define FAT_LFN_ERASED          0x80
 
-#define FAT_LFN_ORDER(d) (d->lfn.order)
+#define FAT_LFN_ORDER(d) ((d)->lfn.order)
 #define FAT_IS_LFN(d) \
-    ((FAT_LFN_ORDER(d) & FAT_LFN_LAST) == FAT_LFN_LAST)
+    ((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)
+    (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
@@ -98 +98 @@
 } fat_dentry_clsf_t;
 
-typedef struct {
-        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;
+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));
-                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;
-        };
+                uint16_t        mtime;
+                uint16_t        mdate;
+                union {
+                        uint16_t        firstc;         /* FAT12/FAT16 */
+                        uint16_t        firstc_lo;      /* FAT32 */
+                } __attribute__ ((packed));
+                uint32_t        size;
+        } __attribute__ ((packed));
+        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;
 
@@ -144 +142 @@
 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 size_t fat_lfn_set_entry(const uint16_t *, size_t *, size_t,
+    fat_dentry_t *);
 
-extern void str_to_ascii(char *dst, const char *src, size_t count, uint8_t pad);
-extern size_t utf16_length(const uint16_t *wstr);
+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 *name);
-extern bool fat_valid_short_name(const char *name);
-
+extern bool fat_valid_name(const char *);
+extern bool fat_valid_short_name(const char *);
 
 #endif

uspace/srv/fs/fat/fat_directory.c

@@ -46 +46 @@
 #include <stdio.h>
 
-int fat_directory_block_load(fat_directory_t *);
-
-
 int fat_directory_open(fat_node_t *nodep, fat_directory_t *di)
 {
@@ -57 +54 @@
 
         di->bs = block_bb_get(di->nodep->idx->service_id);
-        di->blocks = ROUND_UP(nodep->size, BPS(di->bs))/BPS(di->bs);
+        di->blocks = ROUND_UP(nodep->size, BPS(di->bs)) / BPS(di->bs);
         di->pos = 0;
         di->bnum = 0;
         di->last = false;
+
         return EOK;
 }
@@ -66 +64 @@
 int fat_directory_close(fat_directory_t *di)
 {
-        int rc=EOK;
+        int rc = EOK;
         
         if (di->b)
@@ -74 +72 @@
 }
 
-int fat_directory_block_load(fat_directory_t *di)
+static int fat_directory_block_load(fat_directory_t *di)
 {
         uint32_t i;
@@ -86 +84 @@
                 }
                 if (!di->b) {
-                        rc = fat_block_get(&di->b, di->bs, di->nodep, i, BLOCK_FLAGS_NONE);
+                        rc = fat_block_get(&di->b, di->bs, di->nodep, i,
+                            BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
                                 di->b = NULL;
@@ -95 +94 @@
                 return EOK;
         }
+
         return ENOENT;
 }
@@ -104 +104 @@
         di->pos += 1;
         rc = fat_directory_block_load(di);
-        if (rc!=EOK)
+        if (rc != EOK)
                 di->pos -= 1;
         
@@ -112 +112 @@
 int fat_directory_prev(fat_directory_t *di)
 {
-        int rc=EOK;
+        int rc = EOK;
         
         if (di->pos > 0) {
                 di->pos -= 1;
-                rc=fat_directory_block_load(di);
-        }
-        else
+                rc = fat_directory_block_load(di);
+        } else
                 return ENOENT;
         
-        if (rc!=EOK)
+        if (rc != EOK)
                 di->pos += 1;
         
@@ -134 +133 @@
         di->pos = pos;
         rc = fat_directory_block_load(di);
-        if (rc!=EOK)
+        if (rc != EOK)
                 di->pos = _pos;
         
@@ -161 +160 @@
         int long_entry_count = 0;
         uint8_t checksum = 0;
+        int rc;
 
         do {
-                if (fat_directory_get(di, &d) == EOK) {
-                        switch (fat_classify_dentry(d)) {
-                        case FAT_DENTRY_LAST:
-                                long_entry_count = 0;
-                                long_entry = false;
-                                return ENOENT;
-                        case FAT_DENTRY_LFN:
-                                if (long_entry) {
-                                        /* We found long entry */
-                                        long_entry_count--;
-                                        if ((FAT_LFN_ORDER(d) == long_entry_count) && 
-                                                (checksum == FAT_LFN_CHKSUM(d))) {
-                                                /* Right order! */
-                                                fat_lfn_get_entry(d, wname, &lfn_offset);
-                                        } else {
-                                                /* Something wrong with order. Skip this long entries set */
-                                                long_entry_count = 0;
-                                                long_entry = false;
-                                        }
+                rc = fat_directory_get(di, &d);
+                if (rc != EOK)
+                        return rc;
+
+                switch (fat_classify_dentry(d)) {
+                case FAT_DENTRY_LAST:
+                        long_entry_count = 0;
+                        long_entry = false;
+                        return ENOENT;
+                case FAT_DENTRY_LFN:
+                        if (long_entry) {
+                                /* We found long entry */
+                                long_entry_count--;
+                                if ((FAT_LFN_ORDER(d) == long_entry_count) && 
+                                        (checksum == FAT_LFN_CHKSUM(d))) {
+                                        /* Right order! */
+                                        fat_lfn_get_entry(d, wname,
+                                            &lfn_offset);
                                 } else {
-                                        if (FAT_IS_LFN(d)) {
-                                                /* We found Last long entry! */
-                                                if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
-                                                        long_entry = true;
-                                                        long_entry_count = FAT_LFN_COUNT(d);
-                                                        lfn_size = (FAT_LFN_ENTRY_SIZE * 
-                                                                (FAT_LFN_COUNT(d) - 1)) + fat_lfn_size(d);
-                                                        lfn_offset = lfn_size;
-                                                        fat_lfn_get_entry(d, wname, &lfn_offset);
-                                                        checksum = FAT_LFN_CHKSUM(d);
-                                                }
-                                        }
+                                        /*
+                                         * Something wrong with order.
+                                         * Skip this long entries set.
+                                         */
+                                        long_entry_count = 0;
+                                        long_entry = false;
                                 }
-                                break;
-                        case FAT_DENTRY_VALID:
-                                if (long_entry && 
-                                        (checksum == fat_dentry_chksum(d->name))) {
-                                        wname[lfn_size] = '\0';
-                                        if (utf16_to_str(name, FAT_LFN_NAME_SIZE, wname) != EOK)
-                                                fat_dentry_name_get(d, name);
+                        } else if (FAT_IS_LFN(d)) {
+                                /* We found Last long entry! */
+                                if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
+                                        long_entry = true;
+                                        long_entry_count = FAT_LFN_COUNT(d);
+                                        lfn_size = (FAT_LFN_ENTRY_SIZE * 
+                                            (FAT_LFN_COUNT(d) - 1)) +
+                                            fat_lfn_size(d);
+                                        lfn_offset = lfn_size;
+                                        fat_lfn_get_entry(d, wname,
+                                            &lfn_offset);
+                                        checksum = FAT_LFN_CHKSUM(d);
                                 }
-                                else
+                        }
+                        break;
+                case FAT_DENTRY_VALID:
+                        if (long_entry && 
+                            (checksum == fat_dentry_chksum(d->name))) {
+                                wname[lfn_size] = '\0';
+                                if (utf16_to_str(name, FAT_LFN_NAME_SIZE,
+                                    wname) != EOK)
                                         fat_dentry_name_get(d, name);
+                        } else
+                                fat_dentry_name_get(d, name);
                                 
-                                *de = d;
-                                return EOK;
-                        default:
-                        case FAT_DENTRY_SKIP:
-                        case FAT_DENTRY_FREE:
-                                long_entry_count = 0;
-                                long_entry = false;
-                                break;
-                        }
+                        *de = d;
+                        return EOK;
+                default:
+                case FAT_DENTRY_SKIP:
+                case FAT_DENTRY_FREE:
+                        long_entry_count = 0;
+                        long_entry = false;
+                        break;
                 }
         } while (fat_directory_next(di) == EOK);
@@ -239 +245 @@
         while (!flag && fat_directory_prev(di) == EOK) {
                 if (fat_directory_get(di, &d) == EOK &&
-                        fat_classify_dentry(d) == FAT_DENTRY_LFN &&                     
-                        checksum == FAT_LFN_CHKSUM(d)) {
-                                if (FAT_IS_LFN(d))
-                                        flag = true;
-                                memset(d, 0, sizeof(fat_dentry_t));
-                                d->name[0] = FAT_DENTRY_ERASED;
-                                di->b->dirty = true;
-                }
-                else
+                    fat_classify_dentry(d) == FAT_DENTRY_LFN &&                 
+                    checksum == FAT_LFN_CHKSUM(d)) {
+                        if (FAT_IS_LFN(d))
+                                flag = true;
+                        memset(d, 0, sizeof(fat_dentry_t));
+                        d->name[0] = FAT_DENTRY_ERASED;
+                        di->b->dirty = true;
+                } else
                         break;
         }
@@ -257 +262 @@
 {
         int rc;
-        bool enable_lfn = true; /* We can use this variable to switch off LFN support */
+        bool enable_lfn = true; /* TODO: make this a mount option */
         
         if (fat_valid_short_name(name)) {
-                /* NAME could be directly stored in dentry without creating LFN */
+                /*
+                 * NAME could be directly stored in dentry without creating
+                 * LFN.
+                 */
                 fat_dentry_name_set(de, name);
                 if (fat_directory_is_sfn_exist(di, de))
@@ -313 +321 @@
                         if (rc != EOK)
                                 return rc;
-                        fat_lfn_set_entry(wname, &lfn_offset, lfn_size+1, d);
+                        fat_lfn_set_entry(wname, &lfn_offset, lfn_size + 1, d);
                         FAT_LFN_CHKSUM(d) = checksum;
                         FAT_LFN_ORDER(d) = ++idx;
@@ -327 +335 @@
 }
 
-int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de, const char *lname)
-{
-        char name[FAT_NAME_LEN+1];
-        char ext[FAT_EXT_LEN+1];
-        char number[FAT_NAME_LEN+1];
+int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de,
+    const char *lname)
+{
+        char name[FAT_NAME_LEN + 1];
+        char ext[FAT_EXT_LEN + 1];
+        char number[FAT_NAME_LEN + 1];
         memset(name, FAT_PAD, FAT_NAME_LEN);
         memset(ext, FAT_PAD, FAT_EXT_LEN);
@@ -349 +358 @@
 
         unsigned idx;
-        for (idx=1; idx <= FAT_MAX_SFN; idx++) {
+        for (idx = 1; idx <= FAT_MAX_SFN; idx++) {
                 snprintf(number, sizeof(number), "%u", idx);
 
                 /* Fill de->name with FAT_PAD */
-                memset(de->name, FAT_PAD, FAT_NAME_LEN+FAT_EXT_LEN);
+                memset(de->name, FAT_PAD, FAT_NAME_LEN + FAT_EXT_LEN);
                 /* Copy ext */
                 memcpy(de->ext, ext, str_size(ext));
@@ -361 +370 @@
                 /* Copy number */
                 size_t offset;
-                if (str_size(name)+str_size(number)+1 >FAT_NAME_LEN)
-                        offset = FAT_NAME_LEN - str_size(number)-1;
+                if (str_size(name)+str_size(number) + 1 > FAT_NAME_LEN)
+                        offset = FAT_NAME_LEN - str_size(number) - 1;
                 else
                         offset = str_size(name);
                 de->name[offset] = '~';
                 offset++;
-                memcpy(de->name+offset, number, str_size(number));
+                memcpy(de->name + offset, number, str_size(number));
 
                 if (!fat_directory_is_sfn_exist(di, de))
                         return EOK;
         }
+
         return ERANGE;
 }
@@ -381 +391 @@
 
         rc = fat_directory_get(di, &d);
-        if (rc!=EOK)
+        if (rc != EOK)
                 return rc;
         memcpy(d, de, sizeof(fat_dentry_t));
         di->b->dirty = true;
+
         return EOK;
 }
@@ -397 +408 @@
                 return ENOSPC;
         }
-        rc = fat_alloc_clusters(di->bs, di->nodep->idx->service_id, 1, &mcl, &lcl);
+        rc = fat_alloc_clusters(di->bs, di->nodep->idx->service_id, 1, &mcl,
+            &lcl);
         if (rc != EOK)
                 return rc;
         rc = fat_zero_cluster(di->bs, di->nodep->idx->service_id, mcl);
         if (rc != EOK) {
-                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id, mcl);
+                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
+                    mcl);
                 return rc;
         }
         rc = fat_append_clusters(di->bs, di->nodep, mcl, lcl);
         if (rc != EOK) {
-                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id, mcl);
+                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
+                    mcl);
                 return rc;
         }
@@ -422 +436 @@
         size_t found;
         aoff64_t pos;
+        int rc;
         
         do {
                 found = 0;
-                pos=0;
+                pos = 0;
                 fat_directory_seek(di, 0);
                 do {
-                        if (fat_directory_get(di, &d) == EOK) {
-                                switch (fat_classify_dentry(d)) {
-                                case FAT_DENTRY_LAST:
-                                case FAT_DENTRY_FREE:
-                                        if (found==0) pos = di->pos;
-                                        found++;
-                                        if (found == count) {
-                                                fat_directory_seek(di, pos);
-                                                return EOK;
-                                        }
-                                        break;
-                                case FAT_DENTRY_VALID:
-                                case FAT_DENTRY_LFN:
-                                case FAT_DENTRY_SKIP:
-                                default:
-                                        found = 0;
-                                        break;
+                        rc = fat_directory_get(di, &d);
+                        if (rc != EOK)
+                                return rc;
+
+                        switch (fat_classify_dentry(d)) {
+                        case FAT_DENTRY_LAST:
+                        case FAT_DENTRY_FREE:
+                                if (found == 0)
+                                        pos = di->pos;
+                                found++;
+                                if (found == count) {
+                                        fat_directory_seek(di, pos);
+                                        return EOK;
                                 }
+                                break;
+                        case FAT_DENTRY_VALID:
+                        case FAT_DENTRY_LFN:
+                        case FAT_DENTRY_SKIP:
+                        default:
+                                found = 0;
+                                break;
                         }
                 } while (fat_directory_next(di) == EOK);        
         } while (fat_directory_expand(di) == EOK);
+
         return ENOSPC;
 }
 
-int fat_directory_lookup_name(fat_directory_t *di, const char *name, fat_dentry_t **de)
+int fat_directory_lookup_name(fat_directory_t *di, const char *name,
+    fat_dentry_t **de)
 {
         char entry[FAT_LFN_NAME_SIZE];
+
         fat_directory_seek(di, 0);
         while (fat_directory_read(di, entry, de) == EOK) {
@@ -464 +485 @@
                 }
         }
+
         return ENOENT;
 }
@@ -470 +492 @@
 {
         fat_dentry_t *d;
+        int rc;
+
         fat_directory_seek(di, 0);
         do {
-                if (fat_directory_get(di, &d) == EOK) {
-                        switch (fat_classify_dentry(d)) {
-                        case FAT_DENTRY_LAST:
-                                return false;
-                        case FAT_DENTRY_VALID:
-                                        if (bcmp(de->name, d->name, FAT_NAME_LEN+FAT_EXT_LEN)==0)
-                                                return true;
-                                        break;
-                        default:
-                        case FAT_DENTRY_LFN:
-                        case FAT_DENTRY_SKIP:
-                        case FAT_DENTRY_FREE:
-                                break;
-                        }
+                rc = fat_directory_get(di, &d);
+                if (rc != EOK)
+                        return false;
+
+                switch (fat_classify_dentry(d)) {
+                case FAT_DENTRY_LAST:
+                        return false;
+                case FAT_DENTRY_VALID:
+                        if (bcmp(de->name, d->name,
+                            FAT_NAME_LEN + FAT_EXT_LEN)==0)
+                                return true;
+                        break;
+                default:
+                case FAT_DENTRY_LFN:
+                case FAT_DENTRY_SKIP:
+                case FAT_DENTRY_FREE:
+                        break;
                 }
         } while (fat_directory_next(di) == EOK);        
+
         return false;
 }

uspace/srv/fs/fat/fat_directory.h

@@ -63 +63 @@
 extern int fat_directory_write(fat_directory_t *, const char *, fat_dentry_t *);
 extern int fat_directory_erase(fat_directory_t *);
-extern int fat_directory_lookup_name(fat_directory_t *, const char *, fat_dentry_t **);
+extern int fat_directory_lookup_name(fat_directory_t *, const char *,
+    fat_dentry_t **);
 extern bool fat_directory_is_sfn_exist(fat_directory_t *, fat_dentry_t *);
 
-extern int fat_directory_lookup_free(fat_directory_t *di, size_t count);
-extern int fat_directory_write_dentry(fat_directory_t *di, fat_dentry_t *de);
-extern int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de, const char *lname);
-extern int fat_directory_expand(fat_directory_t *di);
-
+extern int fat_directory_lookup_free(fat_directory_t *, size_t);
+extern int fat_directory_write_dentry(fat_directory_t *, fat_dentry_t *);
+extern int fat_directory_create_sfn(fat_directory_t *, fat_dentry_t *,
+    const char *);
+extern int fat_directory_expand(fat_directory_t *);
 
 #endif

uspace/srv/fs/fat/fat_fat.c

@@ -51 +51 @@
 #include <mem.h>
 
-/*
- * Convenience macros for computing some frequently used values from the
- * primitive boot sector members.
- */
-#define CLBN2PBN(bs, cl, bn) \
-        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
-
 #define IS_ODD(number)  (number & 0x1)
 
@@ -244 +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;
@@ -286 +280 @@
 }
 
-/** Get cluster from the first FAT. FAT12 version
+/** Get cluster from the first FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -304 +298 @@
         int rc;
 
-        offset = (clst + clst/2);
+        offset = (clst + clst / 2);
         if (offset / BPS(bs) >= SF(bs))
                 return ERANGE;
@@ -313 +307 @@
                 return rc;
 
-        byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
+        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 it last sector of FAT? */
+                /* Is this the last sector of FAT? */
                 if (offset / BPS(bs) < SF(bs)) {
-                        /* No. Reading next sector */
+                        /* No, read the next sector */
                         rc = block_get(&b1, service_id, 1 + RSCNT(bs) +
-                                SF(bs)*fatno + offset / BPS(bs), BLOCK_FLAGS_NONE);
+                            SF(bs) * fatno + offset / BPS(bs),
+                            BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
                                 block_put(b);
@@ -336 +331 @@
                                 return rc;
                         }
-                }
-                else {
-                        /* Yes. It is last sector of FAT */
+                } else {
+                        /* Yes. This is the last sector of FAT */
                         block_put(b);
                         return ERANGE;
                 }
-        }
-        else
-                byte2 = ((uint8_t*) b->data)[(offset % BPS(bs))+1];
+        } else
+                byte2 = ((uint8_t *) b->data)[(offset % BPS(bs)) + 1];
 
         *value = uint16_t_le2host(byte1 | (byte2 << 8));
@@ -353 +346 @@
         
         rc = block_put(b);
+
         return rc;
 }
 
-/** Get cluster from the first FAT. FAT16 version
+/** Get cluster from the first FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -387 +381 @@
 }
 
-/** Get cluster from the first FAT. FAT32 version
+/** Get cluster from the first FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -411 +405 @@
                 return rc;
 
-        *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) & FAT32_MASK;
+        *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) &
+            FAT32_MASK;
 
         rc = block_put(b);
@@ -436 +431 @@
         assert(fatno < FATCNT(bs));
 
-        if (FAT_IS_FAT12(bs)) {
+        if (FAT_IS_FAT12(bs))
                 rc = fat_get_cluster_fat12(bs, service_id, fatno, clst, value);
-        }
-        else {
-                if (FAT_IS_FAT32(bs))
-                        rc = fat_get_cluster_fat32(bs, service_id, fatno, clst, value);
-                else
-                        rc = fat_get_cluster_fat16(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. FAT12 version.
+/** Set cluster in one instance of FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -463 +455 @@
     fat_cluster_t clst, fat_cluster_t value)
 {
-        block_t *b, *b1=NULL;
+        block_t *b, *b1 = NULL;
         aoff64_t offset;
         uint16_t byte1, byte2;
         int rc;
 
-        offset = (clst + clst/2);
+        offset = (clst + clst / 2);
         if (offset / BPS(bs) >= SF(bs))
                 return ERANGE;
@@ -479 +471 @@
         byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
         bool border = false;
-        /* This cluster access spans a sector boundary. Check only for FAT12 */
-        if ((offset % BPS(bs))+1 == BPS(bs)) {
-                /* Is it last sector of FAT? */
+        /* 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. Reading next sector */
+                        /* No, read the next sector */
                         rc = block_get(&b1, service_id, 1 + RSCNT(bs) +
-                                SF(bs)*fatno + offset / BPS(bs), BLOCK_FLAGS_NONE);
+                            SF(bs) * fatno + offset / BPS(bs),
+                            BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
                                 block_put(b);
@@ -494 +487 @@
                          * first byte of next sector
                          */
-                        byte2 = ((uint8_t*) b1->data)[0];
+                        byte2 = ((uint8_t *) b1->data)[0];
                         border = true;
-                }
-                else {
-                        /* Yes. It is last sector of fat */
+                } else {
+                        /* Yes. This is the last sector of FAT */
                         block_put(b);
                         return ERANGE;
@@ -504 +496 @@
         }
         else
-                byte2 = ((uint8_t*) b->data)[(offset % BPS(bs))+1];
+                byte2 = ((uint8_t*) b->data)[(offset % BPS(bs)) + 1];
 
         if (IS_ODD(clst)) {
@@ -519 +511 @@
         byte2 = byte2 | (value >> 8);
 
-        ((uint8_t*) b->data)[(offset % BPS(bs))] = byte1;
+        ((uint8_t *) b->data)[(offset % BPS(bs))] = byte1;
         if (border) {
-                ((uint8_t*) b1->data)[0] = byte2;
+                ((uint8_t *) b1->data)[0] = byte2;
 
                 b1->dirty = true;
@@ -530 +522 @@
                 }
         } else 
-                ((uint8_t*) b->data)[(offset % BPS(bs))+1] = byte2;
+                ((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. FAT16 version.
+/** Set cluster in one instance of FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -566 +559 @@
         b->dirty = true;        /* need to sync block */
         rc = block_put(b);
+
         return rc;
 }
 
-/** Set cluster in one instance of FAT. FAT32 version.
+/** Set cluster in one instance of FAT.
  *
  * @param bs            Buffer holding the boot sector for the file system.
@@ -602 +596 @@
         b->dirty = true;        /* need to sync block */
         rc = block_put(b);
+
         return rc;
 }
@@ -625 +620 @@
         if (FAT_IS_FAT12(bs))
                 rc = fat_set_cluster_fat12(bs, service_id, fatno, clst, value);
-        else if (FAT_IS_FAT32(bs))
+        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);
-        else
-                rc = fat_set_cluster_fat16(bs, service_id, fatno, clst, value);
 
         return rc;
@@ -695 +690 @@
          */
         fibril_mutex_lock(&fat_alloc_lock);
-        for (clst=FAT_CLST_FIRST; clst < CC(bs)+2 && found < nclsts; clst++) {
+        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;
+                        break;
 
                 if (value == FAT_CLST_RES0) {
-                /*
-                 * The cluster is free. Put it into our stack
-                 * of found clusters and mark it as non-free.
-                 */
-                lifo[found] = clst;
-                rc = fat_set_cluster(bs, service_id, FAT1, clst,
-                    (found == 0) ?  clst_last1 : lifo[found - 1]);
-                if (rc != EOK)
-                        break;
-
-                found++;
+                        /*
+                         * The cluster is free. Put it into our stack
+                         * of found clusters and mark it as non-free.
+                         */
+                        lifo[found] = clst;
+                        rc = fat_set_cluster(bs, service_id, FAT1, clst,
+                            (found == 0) ?  clst_last1 : lifo[found - 1]);
+                        if (rc != EOK)
+                                break;
+
+                        found++;
                 }
         }
@@ -727 +723 @@
 
         /* If something wrong - free the clusters */
-        if (found > 0) {
-                while (found--) {
-                rc = fat_set_cluster(bs, service_id, FAT1, lifo[found],
+        while (found--) {
+                (void) fat_set_cluster(bs, service_id, FAT1, lifo[found],
                     FAT_CLST_RES0);
-                }
         }
 
         free(lifo);
         fibril_mutex_unlock(&fat_alloc_lock);
+
         return ENOSPC;
 }
@@ -757 +752 @@
         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 < FATCNT(bs); fatno++) {
                         rc = fat_set_cluster(bs, service_id, fatno, firstc,
@@ -766 +763 @@
                                 return rc;
                 }
-
                 firstc = nextc;
         }
@@ -782 +778 @@
  * @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)
 {
@@ -942 +937 @@
          * sanitized to support file systems with this property.
          */
-        if (!FAT_IS_FAT32(bs) && (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)
+        if (!FAT_IS_FAT32(bs) &&
+            (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)
                 return ENOTSUP;
 
@@ -955 +951 @@
                         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;
@@ -964 +962 @@
                  */
                 if (!FAT_IS_FAT12(bs) && 
-                        ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
+                    ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
                         return ENOTSUP;
         }

uspace/srv/fs/fat/fat_fat.h

@@ -76 +76 @@
 #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) \