Changeset 5d95f02 in mainline for uspace/srv/fs/fat/fat_directory.c


Ignore:
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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.