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

Changeset 0dbe5ac in mainline


Ignore:
Timestamp:
2011-08-26T21:19:24Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
5d95f02
Parents:
ff0c270
Message:

Cstyle.

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

Legend:

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

    rff0c270 r0dbe5ac  
    147147        if (di->pos > 0) {
    148148                di->pos -= 1;
    149                 rc=exfat_directory_block_load(di);
    150         }
    151         else
     149                rc = exfat_directory_block_load(di);
     150        } else
    152151                return ENOENT;
    153152       
    154         if (rc!=EOK)
     153        if (rc != EOK)
    155154                di->pos += 1;
    156155       
     
    281280                return rc;
    282281        count = de->file.count + 1;
    283         array = (exfat_dentry_t *) malloc(count*sizeof(exfat_dentry_t));
     282        array = (exfat_dentry_t *) malloc(count * sizeof(exfat_dentry_t));
    284283        if (!array)
    285284                return ENOMEM;
     
    290289                array[i] = *de;
    291290                rc = exfat_directory_next(di);
    292                 if (rc!=EOK) {
     291                if (rc != EOK) {
    293292                        free(array);
    294293                        return rc;
     
    378377
    379378        /* Looking for set of free entries */
    380         rc = exfat_directory_lookup_free(di, df.file.count+1);
     379        rc = exfat_directory_lookup_free(di, df.file.count + 1);
    381380        if (rc != EOK)
    382381                return rc;
  • uspace/srv/fs/exfat/exfat_fat.c

    rff0c270 r0dbe5ac  
    135135        if (nodep->fragmented) {
    136136                if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
    137                         nodep->lastc_cached_valid) {
    138                                 /*
    139                         * This is a request to read a block within the last cluster
    140                         * when fortunately we have the last cluster number cached.
    141                         */
     137                    nodep->lastc_cached_valid) {
     138                        /*
     139                         * This is a request to read a block within the last cluster
     140                         * when fortunately we have the last cluster number cached.
     141                         */
    142142                        return block_get(block, nodep->idx->service_id, DATA_FS(bs) +
    143143                        (nodep->lastc_cached_value-EXFAT_CLST_FIRST)*SPC(bs) +
     
    195195        int rc;
    196196
    197         if (fcl < EXFAT_CLST_FIRST || fcl > DATA_CNT(bs)+2)
     197        if (fcl < EXFAT_CLST_FIRST || fcl > DATA_CNT(bs) + 2)
    198198                return ELIMIT;
    199199
    200200        if (!fragmented) {
    201201                rc = block_get(block, service_id, DATA_FS(bs) +
    202                     (fcl-EXFAT_CLST_FIRST)*SPC(bs) + bn, flags);
     202                    (fcl - EXFAT_CLST_FIRST)*SPC(bs) + bn, flags);
    203203        } else {
    204204                max_clusters = bn / SPC(bs);
     
    209209
    210210                rc = block_get(block, service_id, DATA_FS(bs) +
    211                     (c-EXFAT_CLST_FIRST)*SPC(bs) + (bn % SPC(bs)), flags);
     211                    (c - EXFAT_CLST_FIRST) * SPC(bs) + (bn % SPC(bs)), flags);
    212212
    213213                if (clp)
     
    310310
    311311        fibril_mutex_lock(&exfat_alloc_lock);
    312         for (clst=EXFAT_CLST_FIRST; clst < DATA_CNT(bs)+2 && found < nclsts; clst++) {
     312        for (clst = EXFAT_CLST_FIRST; clst < DATA_CNT(bs) + 2 && found < nclsts;
     313            clst++) {
    313314                /* Need to rewrite because of multiple exfat_bitmap_get calls */
    314                 if (bitmap_is_free(bs, service_id, clst)==EOK) {
    315                    /*
    316                         * The cluster is free. Put it into our stack
    317                         * of found clusters and mark it as non-free.
    318                         */
     315                if (bitmap_is_free(bs, service_id, clst) == EOK) {
     316                        /*
     317                         * The cluster is free. Put it into our stack
     318                         * of found clusters and mark it as non-free.
     319                         */
    319320                        lifo[found] = clst;
    320321                        rc = exfat_set_cluster(bs, service_id, clst,
    321                                 (found == 0) ?  EXFAT_CLST_EOF : lifo[found - 1]);
     322                            (found == 0) ?  EXFAT_CLST_EOF : lifo[found - 1]);
    322323                        if (rc != EOK)
    323324                                break;
     
    339340
    340341        /* If something wrong - free the clusters */
    341         if (found > 0) {
    342                 while (found--) {
    343                         (void) bitmap_clear_cluster(bs, service_id, lifo[found]);
    344                         (void) exfat_set_cluster(bs, service_id, lifo[found], 0);
    345                 }
     342        while (found--) {
     343                (void) bitmap_clear_cluster(bs, service_id, lifo[found]);
     344                (void) exfat_set_cluster(bs, service_id, lifo[found], 0);
    346345        }
    347346
     
    490489
    491490        for (i = 0; i < SPC(bs); i++) {
    492                 rc = exfat_block_get_by_clst(&b, bs, service_id, false, c, NULL, i,
    493                     BLOCK_FLAGS_NOREAD);
     491                rc = exfat_block_get_by_clst(&b, bs, service_id, false, c, NULL,
     492                    i, BLOCK_FLAGS_NOREAD);
    494493                if (rc != EOK)
    495494                        return rc;
     
    517516                if (rc != EOK)
    518517                        return rc;
    519                 if (i == blocks-1)
    520                         count = nodep->size - i*BPS(bs);
     518                if (i == blocks - 1)
     519                        count = nodep->size - i * BPS(bs);
    521520                memcpy(uctable, b->data, count);
    522521                uctable += count;
  • uspace/srv/fs/exfat/exfat_fat.h

    rff0c270 r0dbe5ac  
    5858typedef uint32_t exfat_cluster_t;
    5959
    60 
    6160#define exfat_clusters_get(numc, bs, sid, fc) \
    6261    exfat_cluster_walk((bs), (sid), (fc), NULL, (numc), (uint32_t) -1)
    63 extern int exfat_cluster_walk(struct exfat_bs *bs, service_id_t service_id,
    64     exfat_cluster_t firstc, exfat_cluster_t *lastc, uint32_t *numc,
    65     uint32_t max_clusters);
    66 extern int exfat_block_get(block_t **block, struct exfat_bs *bs,
    67     struct exfat_node *nodep, aoff64_t bn, int flags);
    68 extern int exfat_block_get_by_clst(block_t **block, struct exfat_bs *bs,
    69     service_id_t service_id, bool fragmented, exfat_cluster_t fcl,
    70     exfat_cluster_t *clp, aoff64_t bn, int flags);
    7162
    72 extern int exfat_get_cluster(struct exfat_bs *bs, service_id_t service_id,
    73     exfat_cluster_t clst, exfat_cluster_t *value);
    74 extern int exfat_set_cluster(struct exfat_bs *bs, service_id_t service_id,
    75     exfat_cluster_t clst, exfat_cluster_t value);
     63extern int exfat_cluster_walk(struct exfat_bs *, service_id_t,
     64    exfat_cluster_t, exfat_cluster_t *, uint32_t *, uint32_t);
     65extern int exfat_block_get(block_t **, struct exfat_bs *, struct exfat_node *,
     66    aoff64_t, int);
     67extern int exfat_block_get_by_clst(block_t **, struct exfat_bs *, service_id_t,
     68    bool, exfat_cluster_t, exfat_cluster_t *, aoff64_t, int);
     69
     70extern int exfat_get_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
     71    exfat_cluster_t *);
     72extern int exfat_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
     73    exfat_cluster_t);
    7674extern int exfat_sanity_check(struct exfat_bs *, service_id_t);
    7775
     
    8381    exfat_cluster_t *, exfat_cluster_t *);
    8482extern int exfat_free_clusters(struct exfat_bs *, service_id_t, exfat_cluster_t);
    85 extern int exfat_zero_cluster(struct exfat_bs * bs, service_id_t service_id,
    86     exfat_cluster_t mcl);
     83extern int exfat_zero_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
    8784
    88 extern int exfat_read_uctable(struct exfat_bs *bs, struct exfat_node *nodep,
    89     uint8_t *uctable);
     85extern int exfat_read_uctable(struct exfat_bs *, struct exfat_node *,
     86    uint8_t *);
    9087
    9188#endif
  • uspace/srv/fs/exfat/exfat_ops.c

    rff0c270 r0dbe5ac  
    3434/**
    3535 * @file        exfat_ops.c
    36  * @brief       Implementation of VFS operations for the exFAT file system server.
     36 * @brief       Implementation of VFS operations for the exFAT file system
     37 *              server.
    3738 */
    3839
     
    335336        switch (exfat_classify_dentry(d)) {
    336337        case EXFAT_DENTRY_FILE:
    337                 nodep->type = (uint16_t_le2host(d->file.attr) & EXFAT_ATTR_SUBDIR)?
     338                nodep->type =
     339                    (uint16_t_le2host(d->file.attr) & EXFAT_ATTR_SUBDIR) ?
    338340                    EXFAT_DIRECTORY : EXFAT_FILE;
    339341                rc = exfat_directory_next(&di);
     
    395397}
    396398
    397 int exfat_node_expand(service_id_t service_id, exfat_node_t *nodep, exfat_cluster_t clusters)
     399int exfat_node_expand(service_id_t service_id, exfat_node_t *nodep,
     400    exfat_cluster_t clusters)
    398401{
    399402        exfat_bs_t *bs;
     
    439442}
    440443
    441 static int exfat_node_shrink(service_id_t service_id, exfat_node_t *nodep, aoff64_t size)
     444static int exfat_node_shrink(service_id_t service_id, exfat_node_t *nodep,
     445    aoff64_t size)
    442446{
    443447        exfat_bs_t *bs;
     
    505509{
    506510        exfat_node_t *parentp = EXFAT_NODE(pfn);
    507         char name[EXFAT_FILENAME_LEN+1];
     511        char name[EXFAT_FILENAME_LEN + 1];
    508512        exfat_file_dentry_t df;
    509513        exfat_stream_dentry_t ds;
     
    520524                return rc;
    521525
    522         while (exfat_directory_read_file(&di, name, EXFAT_FILENAME_LEN,
    523             &df, &ds) == EOK) {
     526        while (exfat_directory_read_file(&di, name, EXFAT_FILENAME_LEN, &df,
     527            &ds) == EOK) {
    524528                if (stricmp(name, component) == 0) {
    525529                        /* hit */
    526530                        exfat_node_t *nodep;
    527                         aoff64_t o = di.pos % (BPS(di.bs) / sizeof(exfat_dentry_t));
     531                        aoff64_t o = di.pos %
     532                            (BPS(di.bs) / sizeof(exfat_dentry_t));
    528533                        exfat_idx_t *idx = exfat_idx_get_by_pos(service_id,
    529534                                parentp->firstc, di.bnum * DPS(di.bs) + o);
     
    734739         */
    735740        rc = exfat_directory_write_file(&di, name);
    736         if (rc!=EOK)
     741        if (rc != EOK)
    737742                return rc;
    738743        rc = exfat_directory_close(&di);
    739         if (rc!=EOK)
     744        if (rc != EOK)
    740745                return rc;
    741746
     
    962967{
    963968        int rc;
    964         exfat_node_t *rootp=NULL, *bitmapp=NULL, *uctablep=NULL;
     969        exfat_node_t *rootp = NULL, *bitmapp = NULL, *uctablep = NULL;
    965970        enum cache_mode cmode;
    966971        exfat_bs_t *bs;
     
    10621067        rc = exfat_node_get_new_by_pos(&bitmapp, service_id, rootp->firstc,
    10631068            di.pos);
    1064         if (rc!=EOK) {
     1069        if (rc != EOK) {
    10651070                free(rootp);
    10661071                (void) block_cache_fini(service_id);
     
    11031108        rc = exfat_node_get_new_by_pos(&uctablep, service_id, rootp->firstc,
    11041109            di.pos);
    1105         if (rc!=EOK) {
     1110        if (rc != EOK) {
    11061111                free(rootp);
    11071112                free(bitmapp);
     
    11231128
    11241129        rc = exfat_directory_close(&di);
    1125         if (rc!=EOK) {
     1130        if (rc != EOK) {
    11261131                free(rootp);
    11271132                free(bitmapp);
     
    11881193        exfat_node_t *nodep;
    11891194        exfat_bs_t *bs;
    1190         size_t bytes=0;
     1195        size_t bytes = 0;
    11911196        block_t *b;
    11921197        int rc;
     
    12441249                       
    12451250                aoff64_t spos = pos;
    1246                 char name[EXFAT_FILENAME_LEN+1];
     1251                char name[EXFAT_FILENAME_LEN + 1];
    12471252                exfat_file_dentry_t df;
    12481253                exfat_stream_dentry_t ds;
     
    12601265                }
    12611266
    1262                 rc = exfat_directory_read_file(&di, name, EXFAT_FILENAME_LEN, &df, &ds);
    1263                 if (rc == EOK) goto hit;
    1264                 if (rc == ENOENT) goto miss;
     1267                rc = exfat_directory_read_file(&di, name, EXFAT_FILENAME_LEN,
     1268                    &df, &ds);
     1269                if (rc == EOK)
     1270                    goto hit;
     1271                if (rc == ENOENT)
     1272                    goto miss;
    12651273
    12661274err:
     
    12811289                pos = di.pos;
    12821290                rc = exfat_directory_close(&di);
    1283                 if (rc!=EOK)
     1291                if (rc != EOK)
    12841292                        goto err;
    1285                 (void) async_data_read_finalize(callid, name, str_size(name) + 1);
    1286                 bytes = (pos - spos)+1;
     1293                (void) async_data_read_finalize(callid, name,
     1294                    str_size(name) + 1);
     1295                bytes = (pos - spos) + 1;
    12871296        }
    12881297
     
    13951404                return rc;
    13961405        }
    1397 
    13981406
    13991407        *wbytes = bytes;
     
    14771485};
    14781486
    1479 
    14801487/**
    14811488 * @}
Note: See TracChangeset for help on using the changeset viewer.