Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/fat/fat_ops.c

    rcca29e3c r1ee00b7  
    9494       
    9595        /* Read the block that contains the dentry of interest. */
    96         rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
     96        b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
    9797            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
    98         assert(rc == EOK);
    9998
    10099        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
    … …  
    203202
    204203        /* Read the block that contains the dentry of interest. */
    205         rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
     204        b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
    206205            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
    207         assert(rc == EOK);
     206        assert(b);
    208207
    209208        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
    … …  
    220219                 * size of the directory by walking the FAT.
    221220                 */
    222                 uint16_t clusters;
    223                 rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
     221                nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
    224222                    uint16_t_le2host(d->firstc));
    225                 assert(rc == EOK);
    226                 nodep->size = bps * spc * clusters;
    227223        } else {
    228224                nodep->type = FAT_FILE;
    … …  
    329325        nodep = fat_node_get_new();
    330326        if (!nodep) {
    331                 (void) fat_free_clusters(bs, dev_handle, mcl);
     327                fat_free_clusters(bs, dev_handle, mcl);
    332328                return NULL;
    333329        }
    334330        idxp = fat_idx_get_new(dev_handle);
    335331        if (!idxp) {
    336                 (void) fat_free_clusters(bs, dev_handle, mcl); 
     332                fat_free_clusters(bs, dev_handle, mcl);
    337333                fat_node_put(FS_NODE(nodep));
    338334                return NULL;
    … …  
    341337        if (flags & L_DIRECTORY) {
    342338                /* Populate the new cluster with unused dentries. */
    343                 rc = fat_zero_cluster(bs, dev_handle, mcl);
    344                 assert(rc == EOK);
     339                fat_zero_cluster(bs, dev_handle, mcl);
    345340                nodep->type = FAT_DIRECTORY;
    346341                nodep->firstc = mcl;
    … …  
    366361        fat_node_t *nodep = FAT_NODE(fn);
    367362        fat_bs_t *bs;
    368         int rc = EOK;
    369363
    370364        /*
    … …  
    385379                assert(nodep->size);
    386380                /* Free all clusters allocated to the node. */
    387                 rc = fat_free_clusters(bs, nodep->idx->dev_handle,
    388                     nodep->firstc);
     381                fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
    389382        }
    390383
    … …  
    392385        free(nodep->bp);
    393386        free(nodep);
    394         return rc;
     387        return EOK;
    395388}
    396389
    … …  
    440433
    441434        for (i = 0; i < blocks; i++) {
    442                 rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    443                 assert(rc == EOK);
     435                b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
    444436                for (j = 0; j < dps; j++) {
    445437                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    473465                return rc;
    474466        }
    475         rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    476         assert(rc == EOK);
    477         rc = fat_append_clusters(bs, parentp, mcl);
    478         assert(rc == EOK);
     467        fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
     468        fat_append_clusters(bs, parentp, mcl);
    479469        parentp->size += bps * bs->spc;
    480470        parentp->dirty = true;          /* need to sync node */
    481         rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    482         assert(rc == EOK);
     471        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
    483472        d = (fat_dentry_t *)b->data;
    484473
    … …  
    505494         * not use them anyway, so this is rather a sign of our good will.
    506495         */
    507         rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
    508         assert(rc == EOK);
     496        b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
    509497        d = (fat_dentry_t *)b->data;
    510498        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
    … …  
    573561        bps = uint16_t_le2host(bs->bps);
    574562
    575         rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
     563        b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
    576564            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
    577565            BLOCK_FLAGS_NONE);
    578         assert(rc == EOK);
    579566        d = (fat_dentry_t *)b->data +
    580567            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
    … …  
    618605        blocks = parentp->size / bps;
    619606        for (i = 0; i < blocks; i++) {
    620                 rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    621                 assert(rc == EOK);
     607                b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
    622608                for (j = 0; j < dps; j++) {
    623609                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    712698                fat_dentry_t *d;
    713699       
    714                 rc = fat_block_get(&b, bs, nodep, i, BLOCK_FLAGS_NONE);
    715                 assert(rc == EOK);
     700                b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
    716701                for (j = 0; j < dps; j++) {
    717702                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    833818
    834819        /* prepare the boot block */
    835         rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
     820        rc = block_bb_read(dev_handle, BS_BLOCK);
    836821        if (rc != EOK) {
    837822                block_fini(dev_handle);
    … …  
    968953                        bytes = min(len, bps - pos % bps);
    969954                        bytes = min(bytes, nodep->size - pos);
    970                         rc = fat_block_get(&b, bs, nodep, pos / bps,
     955                        b = fat_block_get(bs, nodep, pos / bps,
    971956                            BLOCK_FLAGS_NONE);
    972                         assert(rc == EOK);
    973957                        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
    974958                            bytes);
    … …  
    996980                        off_t o;
    997981
    998                         rc = fat_block_get(&b, bs, nodep, bnum,
    999                             BLOCK_FLAGS_NONE);
    1000                         assert(rc == EOK);
     982                        b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
    1001983                        for (o = pos % (bps / sizeof(fat_dentry_t));
    1002984                            o < bps / sizeof(fat_dentry_t);
    … …  
    10931075                 * next block size boundary.
    10941076                 */
    1095                 rc = fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
    1096                 assert(rc == EOK);
    1097                 rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
    1098                 assert(rc == EOK);
     1077                fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
     1078                b = fat_block_get(bs, nodep, pos / bps, flags);
    10991079                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    11001080                    bytes);
    … …  
    11291109                }
    11301110                /* zero fill any gaps */
    1131                 rc = fat_fill_gap(bs, nodep, mcl, pos);
    1132                 assert(rc == EOK);
    1133                 rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
     1111                fat_fill_gap(bs, nodep, mcl, pos);
     1112                b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
    11341113                    flags);
    1135                 assert(rc == EOK);
    11361114                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    11371115                    bytes);
    … …  
    11431121                 * node's cluster chain.
    11441122                 */
    1145                 rc = fat_append_clusters(bs, nodep, mcl);
    1146                 assert(rc == EOK);
     1123                fat_append_clusters(bs, nodep, mcl);
    11471124                nodep->size = pos + bytes;
    11481125                nodep->dirty = true;            /* need to sync node */
    … …  
    11971174                 */
    11981175                if (size == 0) {
    1199                         rc = fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
    1200                         if (rc != EOK)
    1201                                 goto out;
     1176                        fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
    12021177                } else {
    12031178                        fat_cluster_t lastc;
    1204                         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
    1205                             &lastc, NULL, (size - 1) / bpc);
    1206                         if (rc != EOK)
    1207                                 goto out;
    1208                         rc = fat_chop_clusters(bs, nodep, lastc);
    1209                         if (rc != EOK)
    1210                                 goto out;
     1179                        (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
     1180                            &lastc, (size - 1) / bpc);
     1181                        fat_chop_clusters(bs, nodep, lastc);
    12111182                }
    12121183                nodep->size = size;
    … …  
    12141185                rc = EOK;       
    12151186        }
    1216 out:
    12171187        fat_node_put(fn);
    12181188        ipc_answer_0(rid, rc);
Note: See TracChangeset for help on using the changeset viewer.