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

Changeset 63bcbbc in mainline


Ignore:
Timestamp:
2011-12-12T20:23:53Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
1df224c
Parents:
bf84871 (diff), 80ec9b8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:exfat-helenos.

Location:
uspace/srv/fs/exfat
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/exfat/exfat_bitmap.c

    rbf84871 r63bcbbc  
    4545#include <assert.h>
    4646#include <fibril_synch.h>
    47 #include <malloc.h>
    4847#include <mem.h>
    4948
  • uspace/srv/fs/exfat/exfat_dentry.c

    rbf84871 r63bcbbc  
    101101bool exfat_valid_char(wchar_t ch)
    102102{
    103         /* TODO */
    104         return true;
     103        switch (ch) {
     104        case 0x01 ... 0x1F:
     105        case '/':
     106        case '\\':
     107        case '?':
     108        case '|':
     109        case '>':
     110        case '<':
     111        case '"':
     112        case '*':
     113        case ':':
     114                return false;
     115        default:
     116                return true;
     117        }
    105118}
    106119
    107120bool exfat_valid_name(const char *name)
    108121{
    109         /* TODO */
     122        size_t off = 0;
     123        wchar_t ch;
     124
     125        while ((ch = str_decode(name, &off, STR_NO_LIMIT)) != 0) {
     126                if (!exfat_valid_char(ch))
     127                        return false;
     128        }
    110129        return true;
    111130}
  • uspace/srv/fs/exfat/exfat_directory.c

    rbf84871 r63bcbbc  
    112112                rc = block_put(di->b);
    113113                di->b = NULL;
     114                if (rc != EOK)
     115                        return rc;
    114116        }
    115117        if (!di->b) {
     
    266268                if (idx == 2 || idx == 3)
    267269                        continue;
    268                 checksum = ((checksum << 15) | (checksum >> 1)) + (uint16_t)bytes[idx];
     270                checksum = ((checksum << 15) | (checksum >> 1)) +
     271                    (uint16_t)bytes[idx];
    269272        }
    270273        return checksum;
     
    310313        array[1].stream.valid_data_size = host2uint64_t_le(ds->valid_data_size);
    311314        array[1].stream.data_size = host2uint64_t_le(ds->data_size);
    312         array[0].file.checksum = host2uint16_t_le(exfat_directory_set_checksum((uint8_t *)array,
     315        array[0].file.checksum =
     316            host2uint16_t_le(exfat_directory_set_checksum((uint8_t *)array,
    313317            count * sizeof(exfat_dentry_t)));
    314318
     
    352356        uctablep = EXFAT_NODE(fn);
    353357
    354         uctable_chars = ALIGN_DOWN(uctablep->size, sizeof(uint16_t)) / sizeof(uint16_t);
     358        uctable_chars = ALIGN_DOWN(uctablep->size,
     359            sizeof(uint16_t)) / sizeof(uint16_t);
    355360        uctable = (uint16_t *) malloc(uctable_chars * sizeof(uint16_t));
    356361        rc = exfat_read_uctable(di->bs, uctablep, (uint8_t *)uctable);
     
    417422                        return rc;
    418423
    419                 if (i == df.file.count - 2)
    420                         chars = ds.stream.name_size - EXFAT_NAME_PART_LEN*(df.file.count - 2);
     424                if (i == df.file.count - 2) {
     425                        chars = ds.stream.name_size -
     426                            EXFAT_NAME_PART_LEN*(df.file.count - 2);
     427                }
     428
    421429                rc = exfat_directory_get(di, &de);
    422430                if (rc != EOK)
  • uspace/srv/fs/exfat/exfat_fat.c

    rbf84871 r63bcbbc  
    5050#include <malloc.h>
    5151#include <mem.h>
     52#include <str.h>
    5253
    5354
     
    322323                            (found == 0) ?  EXFAT_CLST_EOF : lifo[found - 1]);
    323324                        if (rc != EOK)
    324                                 break;
     325                                goto exit_error;
    325326                        found++;
    326327                        rc = bitmap_set_cluster(bs, service_id, clst);
    327328                        if (rc != EOK)
    328                                 break;
     329                                goto exit_error;
    329330
    330331                }
     
    339340        }
    340341
     342        rc = ENOSPC;
     343
     344exit_error:
     345
    341346        /* If something wrong - free the clusters */
    342347        while (found--) {
     
    347352        free(lifo);
    348353        fibril_mutex_unlock(&exfat_alloc_lock);
    349         return ENOSPC;
     354        return rc;
    350355}
    351356
     
    537542int exfat_sanity_check(exfat_bs_t *bs, service_id_t service_id)
    538543{
    539         /* TODO */
     544        if (str_cmp((char const *)bs->oem_name, "EXFAT   "))
     545                return ENOTSUP;
     546        else if (uint16_t_le2host(bs->signature) != 0xAA55)
     547                return ENOTSUP;
     548        else if (uint32_t_le2host(bs->fat_sector_count) == 0)
     549                return ENOTSUP;
     550        else if (uint32_t_le2host(bs->data_clusters) == 0)
     551                return ENOTSUP;
     552        else if (bs->fat_count != 1)
     553                return ENOTSUP;
     554        else if ((bs->bytes_per_sector + bs->sec_per_cluster) > 25) {
     555                /* exFAT does not support cluster size > 32 Mb */
     556                return ENOTSUP;
     557        }
    540558        return EOK;
    541559}
  • uspace/srv/fs/exfat/exfat_ops.c

    rbf84871 r63bcbbc  
    657657                        return rc;
    658658                }
     659
     660                rc = exfat_zero_cluster(bs, service_id, nodep->firstc);
     661                if (rc != EOK) {
     662                        (void) exfat_node_put(FS_NODE(nodep));
     663                        return rc;
     664                }
     665
    659666                nodep->size = BPC(bs);
    660667        } else {
     
    739746         */
    740747        rc = exfat_directory_write_file(&di, name);
    741         if (rc != EOK)
    742                 return rc;
     748        if (rc != EOK) {
     749                (void) exfat_directory_close(&di);
     750                fibril_mutex_unlock(&parentp->idx->lock);
     751                return rc;
     752        }
    743753        rc = exfat_directory_close(&di);
    744         if (rc != EOK)
    745                 return rc;
     754        if (rc != EOK) {
     755                fibril_mutex_unlock(&parentp->idx->lock);
     756                return rc;
     757        }
    746758
    747759        fibril_mutex_unlock(&parentp->idx->lock);
     
    12581270                exfat_directory_t di;
    12591271                rc = exfat_directory_open(nodep, &di);
    1260                 if (rc != EOK) goto err;
     1272                if (rc != EOK)
     1273                        goto err;
     1274
    12611275                rc = exfat_directory_seek(&di, pos);
    12621276                if (rc != EOK) {
     
    12681282                    &df, &ds);
    12691283                if (rc == EOK)
    1270                     goto hit;
    1271                 if (rc == ENOENT)
    1272                     goto miss;
     1284                        goto hit;
     1285                else if (rc == ENOENT)
     1286                        goto miss;
     1287
     1288                (void) exfat_directory_close(&di);
    12731289
    12741290err:
     
    12791295miss:
    12801296                rc = exfat_directory_close(&di);
    1281                 if (rc!=EOK)
     1297                if (rc != EOK)
    12821298                        goto err;
    12831299                rc = exfat_node_put(fn);
     
    13971413
    13981414        (void) async_data_write_finalize(callid,
    1399                 b->data + pos % BPS(bs), bytes);
     1415            b->data + pos % BPS(bs), bytes);
    14001416        b->dirty = true;                /* need to sync block */
    14011417        rc = block_put(b);
Note: See TracChangeset for help on using the changeset viewer.