Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1ee00b7 rcca29e3c  
    9494       
    9595        /* Read the block that contains the dentry of interest. */
    96         b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
     96        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
    9797            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     98        assert(rc == EOK);
    9899
    99100        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
    … …  
    202203
    203204        /* Read the block that contains the dentry of interest. */
    204         b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
     205        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
    205206            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
    206         assert(b);
     207        assert(rc == EOK);
    207208
    208209        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
    … …  
    219220                 * size of the directory by walking the FAT.
    220221                 */
    221                 nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
     222                uint16_t clusters;
     223                rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
    222224                    uint16_t_le2host(d->firstc));
     225                assert(rc == EOK);
     226                nodep->size = bps * spc * clusters;
    223227        } else {
    224228                nodep->type = FAT_FILE;
    … …  
    325329        nodep = fat_node_get_new();
    326330        if (!nodep) {
    327                 fat_free_clusters(bs, dev_handle, mcl);
     331                (void) fat_free_clusters(bs, dev_handle, mcl);
    328332                return NULL;
    329333        }
    330334        idxp = fat_idx_get_new(dev_handle);
    331335        if (!idxp) {
    332                 fat_free_clusters(bs, dev_handle, mcl);
     336                (void) fat_free_clusters(bs, dev_handle, mcl); 
    333337                fat_node_put(FS_NODE(nodep));
    334338                return NULL;
    … …  
    337341        if (flags & L_DIRECTORY) {
    338342                /* Populate the new cluster with unused dentries. */
    339                 fat_zero_cluster(bs, dev_handle, mcl);
     343                rc = fat_zero_cluster(bs, dev_handle, mcl);
     344                assert(rc == EOK);
    340345                nodep->type = FAT_DIRECTORY;
    341346                nodep->firstc = mcl;
    … …  
    361366        fat_node_t *nodep = FAT_NODE(fn);
    362367        fat_bs_t *bs;
     368        int rc = EOK;
    363369
    364370        /*
    … …  
    379385                assert(nodep->size);
    380386                /* Free all clusters allocated to the node. */
    381                 fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
     387                rc = fat_free_clusters(bs, nodep->idx->dev_handle,
     388                    nodep->firstc);
    382389        }
    383390
    … …  
    385392        free(nodep->bp);
    386393        free(nodep);
    387         return EOK;
     394        return rc;
    388395}
    389396
    … …  
    433440
    434441        for (i = 0; i < blocks; i++) {
    435                 b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     442                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     443                assert(rc == EOK);
    436444                for (j = 0; j < dps; j++) {
    437445                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    465473                return rc;
    466474        }
    467         fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    468         fat_append_clusters(bs, parentp, mcl);
     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);
    469479        parentp->size += bps * bs->spc;
    470480        parentp->dirty = true;          /* need to sync node */
    471         b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     481        rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     482        assert(rc == EOK);
    472483        d = (fat_dentry_t *)b->data;
    473484
    … …  
    494505         * not use them anyway, so this is rather a sign of our good will.
    495506         */
    496         b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
     507        rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
     508        assert(rc == EOK);
    497509        d = (fat_dentry_t *)b->data;
    498510        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
    … …  
    561573        bps = uint16_t_le2host(bs->bps);
    562574
    563         b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
     575        rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
    564576            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
    565577            BLOCK_FLAGS_NONE);
     578        assert(rc == EOK);
    566579        d = (fat_dentry_t *)b->data +
    567580            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
    … …  
    605618        blocks = parentp->size / bps;
    606619        for (i = 0; i < blocks; i++) {
    607                 b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     620                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     621                assert(rc == EOK);
    608622                for (j = 0; j < dps; j++) {
    609623                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    698712                fat_dentry_t *d;
    699713       
    700                 b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
     714                rc = fat_block_get(&b, bs, nodep, i, BLOCK_FLAGS_NONE);
     715                assert(rc == EOK);
    701716                for (j = 0; j < dps; j++) {
    702717                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    818833
    819834        /* prepare the boot block */
    820         rc = block_bb_read(dev_handle, BS_BLOCK);
     835        rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
    821836        if (rc != EOK) {
    822837                block_fini(dev_handle);
    … …  
    953968                        bytes = min(len, bps - pos % bps);
    954969                        bytes = min(bytes, nodep->size - pos);
    955                         b = fat_block_get(bs, nodep, pos / bps,
     970                        rc = fat_block_get(&b, bs, nodep, pos / bps,
    956971                            BLOCK_FLAGS_NONE);
     972                        assert(rc == EOK);
    957973                        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
    958974                            bytes);
    … …  
    980996                        off_t o;
    981997
    982                         b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
     998                        rc = fat_block_get(&b, bs, nodep, bnum,
     999                            BLOCK_FLAGS_NONE);
     1000                        assert(rc == EOK);
    9831001                        for (o = pos % (bps / sizeof(fat_dentry_t));
    9841002                            o < bps / sizeof(fat_dentry_t);
    … …  
    10751093                 * next block size boundary.
    10761094                 */
    1077                 fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
    1078                 b = fat_block_get(bs, nodep, pos / bps, flags);
     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);
    10791099                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    10801100                    bytes);
    … …  
    11091129                }
    11101130                /* zero fill any gaps */
    1111                 fat_fill_gap(bs, nodep, mcl, pos);
    1112                 b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
     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,
    11131134                    flags);
     1135                assert(rc == EOK);
    11141136                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    11151137                    bytes);
    … …  
    11211143                 * node's cluster chain.
    11221144                 */
    1123                 fat_append_clusters(bs, nodep, mcl);
     1145                rc = fat_append_clusters(bs, nodep, mcl);
     1146                assert(rc == EOK);
    11241147                nodep->size = pos + bytes;
    11251148                nodep->dirty = true;            /* need to sync node */
    … …  
    11741197                 */
    11751198                if (size == 0) {
    1176                         fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
     1199                        rc = fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
     1200                        if (rc != EOK)
     1201                                goto out;
    11771202                } else {
    11781203                        fat_cluster_t lastc;
    1179                         (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
    1180                             &lastc, (size - 1) / bpc);
    1181                         fat_chop_clusters(bs, nodep, 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;
    11821211                }
    11831212                nodep->size = size;
    … …  
    11851214                rc = EOK;       
    11861215        }
     1216out:
    11871217        fat_node_put(fn);
    11881218        ipc_answer_0(rid, rc);
Note: See TracChangeset for help on using the changeset viewer.