Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 5d95f02 in mainline


Ignore:
Timestamp:
2011-08-26T23:04:07Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
4bf6895
Parents:
0dbe5ac
Message:

Cleanup.

Location:
uspace/srv/fs/fat
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/fat/fat.h

    r0dbe5ac r5d95f02  
    4747#endif
    4848
    49 #define min(a, b)               ((a) < (b) ? (a) : (b))
     49#define min(a, b)       ((a) < (b) ? (a) : (b))
    5050
    5151/*
     
    5656#define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
    5757#define FATCNT(bs)      (bs)->fatcnt
    58 #define SF(bs)          (uint16_t_le2host((bs)->sec_per_fat) !=0 ? \
     58
     59#define SF(bs)          (uint16_t_le2host((bs)->sec_per_fat) ? \
    5960    uint16_t_le2host((bs)->sec_per_fat) : \
    6061    uint32_t_le2host(bs->fat32.sectors_per_fat))
     62
    6163#define RDE(bs)         uint16_t_le2host((bs)->root_ent_max)
    62 #define TS(bs)          (uint16_t_le2host((bs)->totsec16) != 0 ? \
    63                         uint16_t_le2host((bs)->totsec16) : \
    64                         uint32_t_le2host(bs->totsec32))
    65 
    66 #define BS_BLOCK                0
    67 #define BS_SIZE                 512
     64
     65#define TS(bs)          (uint16_t_le2host((bs)->totsec16) ? \
     66    uint16_t_le2host((bs)->totsec16) : \
     67    uint32_t_le2host(bs->totsec32))
     68
     69#define BS_BLOCK        0
     70#define BS_SIZE         512
    6871
    6972typedef struct fat_bs {
  • uspace/srv/fs/fat/fat_dentry.c

    r0dbe5ac r5d95f02  
    221221uint8_t fat_dentry_chksum(uint8_t *name)
    222222{
    223         uint8_t i, sum=0;
    224         for (i=0; i<(FAT_NAME_LEN+FAT_EXT_LEN); i++) {
     223        uint8_t i, sum = 0;
     224
     225        for (i = 0; i < (FAT_NAME_LEN + FAT_EXT_LEN); i++)
    225226                sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + name[i];
    226         }
     227
    227228        return sum;
    228229}
     
    269270{
    270271        int i;
    271         for (i=FAT_LFN_PART3_SIZE-1; i>=0 && *offset>0; i--) {
     272        for (i = FAT_LFN_PART3_SIZE - 1; i >= 0 && *offset > 0; i--) {
    272273                if (d->lfn.part3[i] == 0 || d->lfn.part3[i] == FAT_LFN_PAD)
    273274                        continue;
     
    275276                dst[(*offset)] = uint16_t_le2host(d->lfn.part3[i]);
    276277        }
    277         for (i=FAT_LFN_PART2_SIZE-1; i>=0 && *offset>0; i--) {
     278        for (i = FAT_LFN_PART2_SIZE - 1; i >= 0 && *offset > 0; i--) {
    278279                if (d->lfn.part2[i] == 0 || d->lfn.part2[i] == FAT_LFN_PAD)
    279280                        continue;
     
    281282                dst[(*offset)] = uint16_t_le2host(d->lfn.part2[i]);
    282283        }
    283         for (i=FAT_LFN_PART1_SIZE-1; i>=0 && *offset>0; i--) {
     284        for (i = FAT_LFN_PART1_SIZE - 1; i >= 0 && *offset > 0; i--) {
    284285                if (d->lfn.part1[i] == 0 || d->lfn.part1[i] == FAT_LFN_PAD)
    285286                        continue;
     
    290291}
    291292
    292 size_t fat_lfn_set_entry(const uint16_t *src, size_t *offset, size_t size, fat_dentry_t *d)
     293size_t fat_lfn_set_entry(const uint16_t *src, size_t *offset, size_t size,
     294    fat_dentry_t *d)
    293295{
    294296        size_t idx;
    295         for (idx=0; idx < FAT_LFN_PART1_SIZE; idx++) {
     297        for (idx = 0; idx < FAT_LFN_PART1_SIZE; idx++) {
    296298                if (*offset < size) {
    297299                        d->lfn.part1[idx] = host2uint16_t_le(src[*offset]);
    298300                        (*offset)++;
    299                 }
    300                 else
     301                } else
    301302                        d->lfn.part1[idx] = FAT_LFN_PAD;
    302303        }
    303         for (idx=0; idx < FAT_LFN_PART2_SIZE; idx++) {
     304        for (idx = 0; idx < FAT_LFN_PART2_SIZE; idx++) {
    304305                if (*offset < size) {
    305306                        d->lfn.part2[idx] = host2uint16_t_le(src[*offset]);
    306307                        (*offset)++;
    307                 }
    308                 else
     308                } else
    309309                        d->lfn.part2[idx] = FAT_LFN_PAD;
    310310        }
    311         for (idx=0; idx < FAT_LFN_PART3_SIZE; idx++) {
     311        for (idx = 0; idx < FAT_LFN_PART3_SIZE; idx++) {
    312312                if (*offset < size) {
    313313                        d->lfn.part3[idx] = host2uint16_t_le(src[*offset]);
    314314                        (*offset)++;
    315                 }
    316                 else
     315                } else
    317316                        d->lfn.part3[idx] = FAT_LFN_PAD;
    318317        }
     
    339338                        else
    340339                                *dst = pad;
    341                 }
    342                 else
     340                } else
    343341                        break;
    344342
  • uspace/srv/fs/fat/fat_dentry.h

    r0dbe5ac r5d95f02  
    7171#define FAT_LFN_ERASED          0x80
    7272
    73 #define FAT_LFN_ORDER(d) (d->lfn.order)
     73#define FAT_LFN_ORDER(d) ((d)->lfn.order)
    7474#define FAT_IS_LFN(d) \
    75     ((FAT_LFN_ORDER(d) & FAT_LFN_LAST) == FAT_LFN_LAST)
     75    ((FAT_LFN_ORDER((d)) & FAT_LFN_LAST) == FAT_LFN_LAST)
    7676#define FAT_LFN_COUNT(d) \
    77     (FAT_LFN_ORDER(d) ^ FAT_LFN_LAST)
    78 #define FAT_LFN_PART1(d) (d->lfn.part1)
    79 #define FAT_LFN_PART2(d) (d->lfn.part2)
    80 #define FAT_LFN_PART3(d) (d->lfn.part3)
    81 #define FAT_LFN_ATTR(d) (d->lfn.attr)
    82 #define FAT_LFN_CHKSUM(d) (d->lfn.check_sum)
     77    (FAT_LFN_ORDER((d)) ^ FAT_LFN_LAST)
     78#define FAT_LFN_PART1(d) ((d)->lfn.part1)
     79#define FAT_LFN_PART2(d) ((d)->lfn.part2)
     80#define FAT_LFN_PART3(d) ((d)->lfn.part3)
     81#define FAT_LFN_ATTR(d) ((d)->lfn.attr)
     82#define FAT_LFN_CHKSUM(d) ((d)->lfn.check_sum)
    8383
    8484#define FAT_LFN_NAME_SIZE   260
     
    9898} fat_dentry_clsf_t;
    9999
    100 typedef struct {
    101         union {
    102                 struct {
    103                         uint8_t         name[8];
    104                         uint8_t         ext[3];
    105                         uint8_t         attr;
    106                         uint8_t         lcase;
    107                         uint8_t         ctime_fine;
    108                         uint16_t        ctime;
    109                         uint16_t        cdate;
    110                         uint16_t        adate;
    111                         union {
    112                                 uint16_t        eaidx;          /* FAT12/FAT16 */
    113                                 uint16_t        firstc_hi;      /* FAT32 */
    114                         } __attribute__ ((packed));
    115                         uint16_t        mtime;
    116                         uint16_t        mdate;
    117                         union {
    118                                 uint16_t        firstc;         /* FAT12/FAT16 */
    119                                 uint16_t        firstc_lo;      /* FAT32 */
    120                         } __attribute__ ((packed));
    121                         uint32_t        size;
     100typedef union {
     101        struct {
     102                uint8_t         name[8];
     103                uint8_t         ext[3];
     104                uint8_t         attr;
     105                uint8_t         lcase;
     106                uint8_t         ctime_fine;
     107                uint16_t        ctime;
     108                uint16_t        cdate;
     109                uint16_t        adate;
     110                union {
     111                        uint16_t        eaidx;          /* FAT12/FAT16 */
     112                        uint16_t        firstc_hi;      /* FAT32 */
    122113                } __attribute__ ((packed));
    123                 struct {
    124                         uint8_t         order;
    125                         uint16_t        part1[FAT_LFN_PART1_SIZE];
    126                         uint8_t         attr;
    127                         uint8_t         type;
    128                         uint8_t         check_sum;
    129                         uint16_t        part2[FAT_LFN_PART2_SIZE];
    130                         uint16_t        firstc_lo; /* MUST be 0 */
    131                         uint16_t        part3[FAT_LFN_PART3_SIZE];
    132                 } __attribute__ ((packed)) lfn;
    133         };
     114                uint16_t        mtime;
     115                uint16_t        mdate;
     116                union {
     117                        uint16_t        firstc;         /* FAT12/FAT16 */
     118                        uint16_t        firstc_lo;      /* FAT32 */
     119                } __attribute__ ((packed));
     120                uint32_t        size;
     121        } __attribute__ ((packed));
     122        struct {
     123                uint8_t         order;
     124                uint16_t        part1[FAT_LFN_PART1_SIZE];
     125                uint8_t         attr;
     126                uint8_t         type;
     127                uint8_t         check_sum;
     128                uint16_t        part2[FAT_LFN_PART2_SIZE];
     129                uint16_t        firstc_lo; /* MUST be 0 */
     130                uint16_t        part3[FAT_LFN_PART3_SIZE];
     131        } __attribute__ ((packed)) lfn;
    134132} __attribute__ ((packed)) fat_dentry_t;
    135133
     
    144142extern size_t fat_lfn_size(const fat_dentry_t *);
    145143extern size_t fat_lfn_get_entry(const fat_dentry_t *, uint16_t *, size_t *);
    146 extern size_t fat_lfn_set_entry(const uint16_t *, size_t *, size_t, fat_dentry_t *);
     144extern size_t fat_lfn_set_entry(const uint16_t *, size_t *, size_t,
     145    fat_dentry_t *);
    147146
    148 extern void str_to_ascii(char *dst, const char *src, size_t count, uint8_t pad);
    149 extern size_t utf16_length(const uint16_t *wstr);
     147extern void str_to_ascii(char *, const char *, size_t, uint8_t);
     148extern size_t utf16_length(const uint16_t *);
    150149
    151 extern bool fat_valid_name(const char *name);
    152 extern bool fat_valid_short_name(const char *name);
    153 
     150extern bool fat_valid_name(const char *);
     151extern bool fat_valid_short_name(const char *);
    154152
    155153#endif
  • uspace/srv/fs/fat/fat_directory.c

    r0dbe5ac r5d95f02  
    4646#include <stdio.h>
    4747
    48 int fat_directory_block_load(fat_directory_t *);
    49 
    50 
    5148int fat_directory_open(fat_node_t *nodep, fat_directory_t *di)
    5249{
     
    5754
    5855        di->bs = block_bb_get(di->nodep->idx->service_id);
    59         di->blocks = ROUND_UP(nodep->size, BPS(di->bs))/BPS(di->bs);
     56        di->blocks = ROUND_UP(nodep->size, BPS(di->bs)) / BPS(di->bs);
    6057        di->pos = 0;
    6158        di->bnum = 0;
    6259        di->last = false;
     60
    6361        return EOK;
    6462}
     
    6664int fat_directory_close(fat_directory_t *di)
    6765{
    68         int rc=EOK;
     66        int rc = EOK;
    6967       
    7068        if (di->b)
     
    7472}
    7573
    76 int fat_directory_block_load(fat_directory_t *di)
     74static int fat_directory_block_load(fat_directory_t *di)
    7775{
    7876        uint32_t i;
     
    8684                }
    8785                if (!di->b) {
    88                         rc = fat_block_get(&di->b, di->bs, di->nodep, i, BLOCK_FLAGS_NONE);
     86                        rc = fat_block_get(&di->b, di->bs, di->nodep, i,
     87                            BLOCK_FLAGS_NONE);
    8988                        if (rc != EOK) {
    9089                                di->b = NULL;
     
    9594                return EOK;
    9695        }
     96
    9797        return ENOENT;
    9898}
     
    104104        di->pos += 1;
    105105        rc = fat_directory_block_load(di);
    106         if (rc!=EOK)
     106        if (rc != EOK)
    107107                di->pos -= 1;
    108108       
     
    112112int fat_directory_prev(fat_directory_t *di)
    113113{
    114         int rc=EOK;
     114        int rc = EOK;
    115115       
    116116        if (di->pos > 0) {
    117117                di->pos -= 1;
    118                 rc=fat_directory_block_load(di);
    119         }
    120         else
     118                rc = fat_directory_block_load(di);
     119        } else
    121120                return ENOENT;
    122121       
    123         if (rc!=EOK)
     122        if (rc != EOK)
    124123                di->pos += 1;
    125124       
     
    134133        di->pos = pos;
    135134        rc = fat_directory_block_load(di);
    136         if (rc!=EOK)
     135        if (rc != EOK)
    137136                di->pos = _pos;
    138137       
     
    161160        int long_entry_count = 0;
    162161        uint8_t checksum = 0;
     162        int rc;
    163163
    164164        do {
    165                 if (fat_directory_get(di, &d) == EOK) {
    166                         switch (fat_classify_dentry(d)) {
    167                         case FAT_DENTRY_LAST:
    168                                 long_entry_count = 0;
    169                                 long_entry = false;
    170                                 return ENOENT;
    171                         case FAT_DENTRY_LFN:
    172                                 if (long_entry) {
    173                                         /* We found long entry */
    174                                         long_entry_count--;
    175                                         if ((FAT_LFN_ORDER(d) == long_entry_count) &&
    176                                                 (checksum == FAT_LFN_CHKSUM(d))) {
    177                                                 /* Right order! */
    178                                                 fat_lfn_get_entry(d, wname, &lfn_offset);
    179                                         } else {
    180                                                 /* Something wrong with order. Skip this long entries set */
    181                                                 long_entry_count = 0;
    182                                                 long_entry = false;
    183                                         }
     165                rc = fat_directory_get(di, &d);
     166                if (rc != EOK)
     167                        return rc;
     168
     169                switch (fat_classify_dentry(d)) {
     170                case FAT_DENTRY_LAST:
     171                        long_entry_count = 0;
     172                        long_entry = false;
     173                        return ENOENT;
     174                case FAT_DENTRY_LFN:
     175                        if (long_entry) {
     176                                /* We found long entry */
     177                                long_entry_count--;
     178                                if ((FAT_LFN_ORDER(d) == long_entry_count) &&
     179                                        (checksum == FAT_LFN_CHKSUM(d))) {
     180                                        /* Right order! */
     181                                        fat_lfn_get_entry(d, wname,
     182                                            &lfn_offset);
    184183                                } else {
    185                                         if (FAT_IS_LFN(d)) {
    186                                                 /* We found Last long entry! */
    187                                                 if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
    188                                                         long_entry = true;
    189                                                         long_entry_count = FAT_LFN_COUNT(d);
    190                                                         lfn_size = (FAT_LFN_ENTRY_SIZE *
    191                                                                 (FAT_LFN_COUNT(d) - 1)) + fat_lfn_size(d);
    192                                                         lfn_offset = lfn_size;
    193                                                         fat_lfn_get_entry(d, wname, &lfn_offset);
    194                                                         checksum = FAT_LFN_CHKSUM(d);
    195                                                 }
    196                                         }
     184                                        /*
     185                                         * Something wrong with order.
     186                                         * Skip this long entries set.
     187                                         */
     188                                        long_entry_count = 0;
     189                                        long_entry = false;
    197190                                }
    198                                 break;
    199                         case FAT_DENTRY_VALID:
    200                                 if (long_entry &&
    201                                         (checksum == fat_dentry_chksum(d->name))) {
    202                                         wname[lfn_size] = '\0';
    203                                         if (utf16_to_str(name, FAT_LFN_NAME_SIZE, wname) != EOK)
    204                                                 fat_dentry_name_get(d, name);
     191                        } else if (FAT_IS_LFN(d)) {
     192                                /* We found Last long entry! */
     193                                if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
     194                                        long_entry = true;
     195                                        long_entry_count = FAT_LFN_COUNT(d);
     196                                        lfn_size = (FAT_LFN_ENTRY_SIZE *
     197                                            (FAT_LFN_COUNT(d) - 1)) +
     198                                            fat_lfn_size(d);
     199                                        lfn_offset = lfn_size;
     200                                        fat_lfn_get_entry(d, wname,
     201                                            &lfn_offset);
     202                                        checksum = FAT_LFN_CHKSUM(d);
    205203                                }
    206                                 else
     204                        }
     205                        break;
     206                case FAT_DENTRY_VALID:
     207                        if (long_entry &&
     208                            (checksum == fat_dentry_chksum(d->name))) {
     209                                wname[lfn_size] = '\0';
     210                                if (utf16_to_str(name, FAT_LFN_NAME_SIZE,
     211                                    wname) != EOK)
    207212                                        fat_dentry_name_get(d, name);
     213                        } else
     214                                fat_dentry_name_get(d, name);
    208215                               
    209                                 *de = d;
    210                                 return EOK;
    211                         default:
    212                         case FAT_DENTRY_SKIP:
    213                         case FAT_DENTRY_FREE:
    214                                 long_entry_count = 0;
    215                                 long_entry = false;
    216                                 break;
    217                         }
     216                        *de = d;
     217                        return EOK;
     218                default:
     219                case FAT_DENTRY_SKIP:
     220                case FAT_DENTRY_FREE:
     221                        long_entry_count = 0;
     222                        long_entry = false;
     223                        break;
    218224                }
    219225        } while (fat_directory_next(di) == EOK);
     
    239245        while (!flag && fat_directory_prev(di) == EOK) {
    240246                if (fat_directory_get(di, &d) == EOK &&
    241                         fat_classify_dentry(d) == FAT_DENTRY_LFN &&                     
    242                         checksum == FAT_LFN_CHKSUM(d)) {
    243                                 if (FAT_IS_LFN(d))
    244                                         flag = true;
    245                                 memset(d, 0, sizeof(fat_dentry_t));
    246                                 d->name[0] = FAT_DENTRY_ERASED;
    247                                 di->b->dirty = true;
    248                 }
    249                 else
     247                    fat_classify_dentry(d) == FAT_DENTRY_LFN &&                 
     248                    checksum == FAT_LFN_CHKSUM(d)) {
     249                        if (FAT_IS_LFN(d))
     250                                flag = true;
     251                        memset(d, 0, sizeof(fat_dentry_t));
     252                        d->name[0] = FAT_DENTRY_ERASED;
     253                        di->b->dirty = true;
     254                } else
    250255                        break;
    251256        }
     
    257262{
    258263        int rc;
    259         bool enable_lfn = true; /* We can use this variable to switch off LFN support */
     264        bool enable_lfn = true; /* TODO: make this a mount option */
    260265       
    261266        if (fat_valid_short_name(name)) {
    262                 /* NAME could be directly stored in dentry without creating LFN */
     267                /*
     268                 * NAME could be directly stored in dentry without creating
     269                 * LFN.
     270                 */
    263271                fat_dentry_name_set(de, name);
    264272                if (fat_directory_is_sfn_exist(di, de))
     
    313321                        if (rc != EOK)
    314322                                return rc;
    315                         fat_lfn_set_entry(wname, &lfn_offset, lfn_size+1, d);
     323                        fat_lfn_set_entry(wname, &lfn_offset, lfn_size + 1, d);
    316324                        FAT_LFN_CHKSUM(d) = checksum;
    317325                        FAT_LFN_ORDER(d) = ++idx;
     
    327335}
    328336
    329 int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de, const char *lname)
    330 {
    331         char name[FAT_NAME_LEN+1];
    332         char ext[FAT_EXT_LEN+1];
    333         char number[FAT_NAME_LEN+1];
     337int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de,
     338    const char *lname)
     339{
     340        char name[FAT_NAME_LEN + 1];
     341        char ext[FAT_EXT_LEN + 1];
     342        char number[FAT_NAME_LEN + 1];
    334343        memset(name, FAT_PAD, FAT_NAME_LEN);
    335344        memset(ext, FAT_PAD, FAT_EXT_LEN);
     
    349358
    350359        unsigned idx;
    351         for (idx=1; idx <= FAT_MAX_SFN; idx++) {
     360        for (idx = 1; idx <= FAT_MAX_SFN; idx++) {
    352361                snprintf(number, sizeof(number), "%u", idx);
    353362
    354363                /* Fill de->name with FAT_PAD */
    355                 memset(de->name, FAT_PAD, FAT_NAME_LEN+FAT_EXT_LEN);
     364                memset(de->name, FAT_PAD, FAT_NAME_LEN + FAT_EXT_LEN);
    356365                /* Copy ext */
    357366                memcpy(de->ext, ext, str_size(ext));
     
    361370                /* Copy number */
    362371                size_t offset;
    363                 if (str_size(name)+str_size(number)+1 >FAT_NAME_LEN)
    364                         offset = FAT_NAME_LEN - str_size(number)-1;
     372                if (str_size(name)+str_size(number) + 1 > FAT_NAME_LEN)
     373                        offset = FAT_NAME_LEN - str_size(number) - 1;
    365374                else
    366375                        offset = str_size(name);
    367376                de->name[offset] = '~';
    368377                offset++;
    369                 memcpy(de->name+offset, number, str_size(number));
     378                memcpy(de->name + offset, number, str_size(number));
    370379
    371380                if (!fat_directory_is_sfn_exist(di, de))
    372381                        return EOK;
    373382        }
     383
    374384        return ERANGE;
    375385}
     
    381391
    382392        rc = fat_directory_get(di, &d);
    383         if (rc!=EOK)
     393        if (rc != EOK)
    384394                return rc;
    385395        memcpy(d, de, sizeof(fat_dentry_t));
    386396        di->b->dirty = true;
     397
    387398        return EOK;
    388399}
     
    397408                return ENOSPC;
    398409        }
    399         rc = fat_alloc_clusters(di->bs, di->nodep->idx->service_id, 1, &mcl, &lcl);
     410        rc = fat_alloc_clusters(di->bs, di->nodep->idx->service_id, 1, &mcl,
     411            &lcl);
    400412        if (rc != EOK)
    401413                return rc;
    402414        rc = fat_zero_cluster(di->bs, di->nodep->idx->service_id, mcl);
    403415        if (rc != EOK) {
    404                 (void) fat_free_clusters(di->bs, di->nodep->idx->service_id, mcl);
     416                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
     417                    mcl);
    405418                return rc;
    406419        }
    407420        rc = fat_append_clusters(di->bs, di->nodep, mcl, lcl);
    408421        if (rc != EOK) {
    409                 (void) fat_free_clusters(di->bs, di->nodep->idx->service_id, mcl);
     422                (void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
     423                    mcl);
    410424                return rc;
    411425        }
     
    422436        size_t found;
    423437        aoff64_t pos;
     438        int rc;
    424439       
    425440        do {
    426441                found = 0;
    427                 pos=0;
     442                pos = 0;
    428443                fat_directory_seek(di, 0);
    429444                do {
    430                         if (fat_directory_get(di, &d) == EOK) {
    431                                 switch (fat_classify_dentry(d)) {
    432                                 case FAT_DENTRY_LAST:
    433                                 case FAT_DENTRY_FREE:
    434                                         if (found==0) pos = di->pos;
    435                                         found++;
    436                                         if (found == count) {
    437                                                 fat_directory_seek(di, pos);
    438                                                 return EOK;
    439                                         }
    440                                         break;
    441                                 case FAT_DENTRY_VALID:
    442                                 case FAT_DENTRY_LFN:
    443                                 case FAT_DENTRY_SKIP:
    444                                 default:
    445                                         found = 0;
    446                                         break;
     445                        rc = fat_directory_get(di, &d);
     446                        if (rc != EOK)
     447                                return rc;
     448
     449                        switch (fat_classify_dentry(d)) {
     450                        case FAT_DENTRY_LAST:
     451                        case FAT_DENTRY_FREE:
     452                                if (found == 0)
     453                                        pos = di->pos;
     454                                found++;
     455                                if (found == count) {
     456                                        fat_directory_seek(di, pos);
     457                                        return EOK;
    447458                                }
     459                                break;
     460                        case FAT_DENTRY_VALID:
     461                        case FAT_DENTRY_LFN:
     462                        case FAT_DENTRY_SKIP:
     463                        default:
     464                                found = 0;
     465                                break;
    448466                        }
    449467                } while (fat_directory_next(di) == EOK);       
    450468        } while (fat_directory_expand(di) == EOK);
     469
    451470        return ENOSPC;
    452471}
    453472
    454 int fat_directory_lookup_name(fat_directory_t *di, const char *name, fat_dentry_t **de)
     473int fat_directory_lookup_name(fat_directory_t *di, const char *name,
     474    fat_dentry_t **de)
    455475{
    456476        char entry[FAT_LFN_NAME_SIZE];
     477
    457478        fat_directory_seek(di, 0);
    458479        while (fat_directory_read(di, entry, de) == EOK) {
     
    464485                }
    465486        }
     487
    466488        return ENOENT;
    467489}
     
    470492{
    471493        fat_dentry_t *d;
     494        int rc;
     495
    472496        fat_directory_seek(di, 0);
    473497        do {
    474                 if (fat_directory_get(di, &d) == EOK) {
    475                         switch (fat_classify_dentry(d)) {
    476                         case FAT_DENTRY_LAST:
    477                                 return false;
    478                         case FAT_DENTRY_VALID:
    479                                         if (bcmp(de->name, d->name, FAT_NAME_LEN+FAT_EXT_LEN)==0)
    480                                                 return true;
    481                                         break;
    482                         default:
    483                         case FAT_DENTRY_LFN:
    484                         case FAT_DENTRY_SKIP:
    485                         case FAT_DENTRY_FREE:
    486                                 break;
    487                         }
     498                rc = fat_directory_get(di, &d);
     499                if (rc != EOK)
     500                        return false;
     501
     502                switch (fat_classify_dentry(d)) {
     503                case FAT_DENTRY_LAST:
     504                        return false;
     505                case FAT_DENTRY_VALID:
     506                        if (bcmp(de->name, d->name,
     507                            FAT_NAME_LEN + FAT_EXT_LEN)==0)
     508                                return true;
     509                        break;
     510                default:
     511                case FAT_DENTRY_LFN:
     512                case FAT_DENTRY_SKIP:
     513                case FAT_DENTRY_FREE:
     514                        break;
    488515                }
    489516        } while (fat_directory_next(di) == EOK);       
     517
    490518        return false;
    491519}
  • uspace/srv/fs/fat/fat_directory.h

    r0dbe5ac r5d95f02  
    6363extern int fat_directory_write(fat_directory_t *, const char *, fat_dentry_t *);
    6464extern int fat_directory_erase(fat_directory_t *);
    65 extern int fat_directory_lookup_name(fat_directory_t *, const char *, fat_dentry_t **);
     65extern int fat_directory_lookup_name(fat_directory_t *, const char *,
     66    fat_dentry_t **);
    6667extern bool fat_directory_is_sfn_exist(fat_directory_t *, fat_dentry_t *);
    6768
    68 extern int fat_directory_lookup_free(fat_directory_t *di, size_t count);
    69 extern int fat_directory_write_dentry(fat_directory_t *di, fat_dentry_t *de);
    70 extern int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de, const char *lname);
    71 extern int fat_directory_expand(fat_directory_t *di);
    72 
     69extern int fat_directory_lookup_free(fat_directory_t *, size_t);
     70extern int fat_directory_write_dentry(fat_directory_t *, fat_dentry_t *);
     71extern int fat_directory_create_sfn(fat_directory_t *, fat_dentry_t *,
     72    const char *);
     73extern int fat_directory_expand(fat_directory_t *);
    7374
    7475#endif
  • uspace/srv/fs/fat/fat_fat.c

    r0dbe5ac r5d95f02  
    5151#include <mem.h>
    5252
    53 /*
    54  * Convenience macros for computing some frequently used values from the
    55  * primitive boot sector members.
    56  */
    57 #define CLBN2PBN(bs, cl, bn) \
    58         (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
    59 
    6053#define IS_ODD(number)  (number & 0x1)
    6154
     
    244237 * @return              EOK on success or a negative error code.
    245238 */
    246 int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
     239int
     240fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
    247241{
    248242        block_t *b;
     
    286280}
    287281
    288 /** Get cluster from the first FAT. FAT12 version
     282/** Get cluster from the first FAT.
    289283 *
    290284 * @param bs            Buffer holding the boot sector for the file system.
     
    304298        int rc;
    305299
    306         offset = (clst + clst/2);
     300        offset = (clst + clst / 2);
    307301        if (offset / BPS(bs) >= SF(bs))
    308302                return ERANGE;
     
    313307                return rc;
    314308
    315         byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
     309        byte1 = ((uint8_t *) b->data)[offset % BPS(bs)];
    316310        /* This cluster access spans a sector boundary. Check only for FAT12 */
    317311        if ((offset % BPS(bs)) + 1 == BPS(bs)) {
    318                 /* Is it last sector of FAT? */
     312                /* Is this the last sector of FAT? */
    319313                if (offset / BPS(bs) < SF(bs)) {
    320                         /* No. Reading next sector */
     314                        /* No, read the next sector */
    321315                        rc = block_get(&b1, service_id, 1 + RSCNT(bs) +
    322                                 SF(bs)*fatno + offset / BPS(bs), BLOCK_FLAGS_NONE);
     316                            SF(bs) * fatno + offset / BPS(bs),
     317                            BLOCK_FLAGS_NONE);
    323318                        if (rc != EOK) {
    324319                                block_put(b);
     
    336331                                return rc;
    337332                        }
    338                 }
    339                 else {
    340                         /* Yes. It is last sector of FAT */
     333                } else {
     334                        /* Yes. This is the last sector of FAT */
    341335                        block_put(b);
    342336                        return ERANGE;
    343337                }
    344         }
    345         else
    346                 byte2 = ((uint8_t*) b->data)[(offset % BPS(bs))+1];
     338        } else
     339                byte2 = ((uint8_t *) b->data)[(offset % BPS(bs)) + 1];
    347340
    348341        *value = uint16_t_le2host(byte1 | (byte2 << 8));
     
    353346       
    354347        rc = block_put(b);
     348
    355349        return rc;
    356350}
    357351
    358 /** Get cluster from the first FAT. FAT16 version
     352/** Get cluster from the first FAT.
    359353 *
    360354 * @param bs            Buffer holding the boot sector for the file system.
     
    387381}
    388382
    389 /** Get cluster from the first FAT. FAT32 version
     383/** Get cluster from the first FAT.
    390384 *
    391385 * @param bs            Buffer holding the boot sector for the file system.
     
    411405                return rc;
    412406
    413         *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) & FAT32_MASK;
     407        *value = uint32_t_le2host(*(uint32_t *)(b->data + offset % BPS(bs))) &
     408            FAT32_MASK;
    414409
    415410        rc = block_put(b);
     
    436431        assert(fatno < FATCNT(bs));
    437432
    438         if (FAT_IS_FAT12(bs)) {
     433        if (FAT_IS_FAT12(bs))
    439434                rc = fat_get_cluster_fat12(bs, service_id, fatno, clst, value);
    440         }
    441         else {
    442                 if (FAT_IS_FAT32(bs))
    443                         rc = fat_get_cluster_fat32(bs, service_id, fatno, clst, value);
    444                 else
    445                         rc = fat_get_cluster_fat16(bs, service_id, fatno, clst, value);
    446         }
     435        else if (FAT_IS_FAT16(bs))
     436                rc = fat_get_cluster_fat16(bs, service_id, fatno, clst, value);
     437        else
     438                rc = fat_get_cluster_fat32(bs, service_id, fatno, clst, value);
    447439
    448440        return rc;
    449441}
    450442
    451 /** Set cluster in one instance of FAT. FAT12 version.
     443/** Set cluster in one instance of FAT.
    452444 *
    453445 * @param bs            Buffer holding the boot sector for the file system.
     
    463455    fat_cluster_t clst, fat_cluster_t value)
    464456{
    465         block_t *b, *b1=NULL;
     457        block_t *b, *b1 = NULL;
    466458        aoff64_t offset;
    467459        uint16_t byte1, byte2;
    468460        int rc;
    469461
    470         offset = (clst + clst/2);
     462        offset = (clst + clst / 2);
    471463        if (offset / BPS(bs) >= SF(bs))
    472464                return ERANGE;
     
    479471        byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
    480472        bool border = false;
    481         /* This cluster access spans a sector boundary. Check only for FAT12 */
    482         if ((offset % BPS(bs))+1 == BPS(bs)) {
    483                 /* Is it last sector of FAT? */
     473        /* This cluster access spans a sector boundary. */
     474        if ((offset % BPS(bs)) + 1 == BPS(bs)) {
     475                /* Is it the last sector of FAT? */
    484476                if (offset / BPS(bs) < SF(bs)) {
    485                         /* No. Reading next sector */
     477                        /* No, read the next sector */
    486478                        rc = block_get(&b1, service_id, 1 + RSCNT(bs) +
    487                                 SF(bs)*fatno + offset / BPS(bs), BLOCK_FLAGS_NONE);
     479                            SF(bs) * fatno + offset / BPS(bs),
     480                            BLOCK_FLAGS_NONE);
    488481                        if (rc != EOK) {
    489482                                block_put(b);
     
    494487                         * first byte of next sector
    495488                         */
    496                         byte2 = ((uint8_t*) b1->data)[0];
     489                        byte2 = ((uint8_t *) b1->data)[0];
    497490                        border = true;
    498                 }
    499                 else {
    500                         /* Yes. It is last sector of fat */
     491                } else {
     492                        /* Yes. This is the last sector of FAT */
    501493                        block_put(b);
    502494                        return ERANGE;
     
    504496        }
    505497        else
    506                 byte2 = ((uint8_t*) b->data)[(offset % BPS(bs))+1];
     498                byte2 = ((uint8_t*) b->data)[(offset % BPS(bs)) + 1];
    507499
    508500        if (IS_ODD(clst)) {
     
    519511        byte2 = byte2 | (value >> 8);
    520512
    521         ((uint8_t*) b->data)[(offset % BPS(bs))] = byte1;
     513        ((uint8_t *) b->data)[(offset % BPS(bs))] = byte1;
    522514        if (border) {
    523                 ((uint8_t*) b1->data)[0] = byte2;
     515                ((uint8_t *) b1->data)[0] = byte2;
    524516
    525517                b1->dirty = true;
     
    530522                }
    531523        } else
    532                 ((uint8_t*) b->data)[(offset % BPS(bs))+1] = byte2;
     524                ((uint8_t *) b->data)[(offset % BPS(bs)) + 1] = byte2;
    533525
    534526        b->dirty = true;        /* need to sync block */
    535527        rc = block_put(b);
     528
    536529        return rc;
    537530}
    538531
    539 /** Set cluster in one instance of FAT. FAT16 version.
     532/** Set cluster in one instance of FAT.
    540533 *
    541534 * @param bs            Buffer holding the boot sector for the file system.
     
    566559        b->dirty = true;        /* need to sync block */
    567560        rc = block_put(b);
     561
    568562        return rc;
    569563}
    570564
    571 /** Set cluster in one instance of FAT. FAT32 version.
     565/** Set cluster in one instance of FAT.
    572566 *
    573567 * @param bs            Buffer holding the boot sector for the file system.
     
    602596        b->dirty = true;        /* need to sync block */
    603597        rc = block_put(b);
     598
    604599        return rc;
    605600}
     
    625620        if (FAT_IS_FAT12(bs))
    626621                rc = fat_set_cluster_fat12(bs, service_id, fatno, clst, value);
    627         else if (FAT_IS_FAT32(bs))
     622        else if (FAT_IS_FAT16(bs))
     623                rc = fat_set_cluster_fat16(bs, service_id, fatno, clst, value);
     624        else
    628625                rc = fat_set_cluster_fat32(bs, service_id, fatno, clst, value);
    629         else
    630                 rc = fat_set_cluster_fat16(bs, service_id, fatno, clst, value);
    631626
    632627        return rc;
     
    695690         */
    696691        fibril_mutex_lock(&fat_alloc_lock);
    697         for (clst=FAT_CLST_FIRST; clst < CC(bs)+2 && found < nclsts; clst++) {
     692        for (clst = FAT_CLST_FIRST; clst < CC(bs) + 2 && found < nclsts;
     693            clst++) {
    698694                rc = fat_get_cluster(bs, service_id, FAT1, clst, &value);
    699695                if (rc != EOK)
    700                 break;
     696                        break;
    701697
    702698                if (value == FAT_CLST_RES0) {
    703                 /*
    704                 * The cluster is free. Put it into our stack
    705                 * of found clusters and mark it as non-free.
    706                 */
    707                 lifo[found] = clst;
    708                 rc = fat_set_cluster(bs, service_id, FAT1, clst,
    709                     (found == 0) ?  clst_last1 : lifo[found - 1]);
    710                 if (rc != EOK)
    711                         break;
    712 
    713                 found++;
     699                        /*
     700                        * The cluster is free. Put it into our stack
     701                        * of found clusters and mark it as non-free.
     702                        */
     703                        lifo[found] = clst;
     704                        rc = fat_set_cluster(bs, service_id, FAT1, clst,
     705                            (found == 0) ?  clst_last1 : lifo[found - 1]);
     706                        if (rc != EOK)
     707                                break;
     708
     709                        found++;
    714710                }
    715711        }
     
    727723
    728724        /* If something wrong - free the clusters */
    729         if (found > 0) {
    730                 while (found--) {
    731                 rc = fat_set_cluster(bs, service_id, FAT1, lifo[found],
     725        while (found--) {
     726                (void) fat_set_cluster(bs, service_id, FAT1, lifo[found],
    732727                    FAT_CLST_RES0);
    733                 }
    734728        }
    735729
    736730        free(lifo);
    737731        fibril_mutex_unlock(&fat_alloc_lock);
     732
    738733        return ENOSPC;
    739734}
     
    757752        while (firstc < FAT_CLST_LAST1(bs)) {
    758753                assert(firstc >= FAT_CLST_FIRST && firstc < clst_bad);
     754
    759755                rc = fat_get_cluster(bs, service_id, FAT1, firstc, &nextc);
    760756                if (rc != EOK)
    761757                        return rc;
     758
    762759                for (fatno = FAT1; fatno < FATCNT(bs); fatno++) {
    763760                        rc = fat_set_cluster(bs, service_id, fatno, firstc,
     
    766763                                return rc;
    767764                }
    768 
    769765                firstc = nextc;
    770766        }
     
    782778 * @return              EOK on success or a negative error code.
    783779 */
    784 int
    785 fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
     780int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
    786781    fat_cluster_t lcl)
    787782{
     
    942937         * sanitized to support file systems with this property.
    943938         */
    944         if (!FAT_IS_FAT32(bs) && (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)
     939        if (!FAT_IS_FAT32(bs) &&
     940            (RDE(bs) * sizeof(fat_dentry_t)) % BPS(bs) != 0)
    945941                return ENOTSUP;
    946942
     
    955951                        return EIO;
    956952
    957                 /* Check that first byte of FAT contains the media descriptor. */
     953                /*
     954                 * Check that first byte of FAT contains the media descriptor.
     955                 */
    958956                if ((e0 & 0xff) != bs->mdesc)
    959957                        return ENOTSUP;
     
    964962                 */
    965963                if (!FAT_IS_FAT12(bs) &&
    966                         ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
     964                    ((e0 >> 8) != (FAT_MASK(bs) >> 8) || e1 != FAT_MASK(bs)))
    967965                        return ENOTSUP;
    968966        }
  • uspace/srv/fs/fat/fat_fat.h

    r0dbe5ac r5d95f02  
    7676#define CC(bs)    (DS(bs) / SPC(bs))
    7777
     78#define CLBN2PBN(bs, cl, bn) \
     79        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
     80
    7881#define FAT_IS_FAT12(bs)        (CC(bs) < FAT12_CLST_MAX)
    7982#define FAT_IS_FAT16(bs) \
Note: See TracChangeset for help on using the changeset viewer.