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

Changeset c699b0c in mainline


Ignore:
Timestamp:
2011-09-04T13:12:33Z (10 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master
Children:
3a5ee6c
Parents:
03bc76a
Message:

remove the on_error() macro

Location:
uspace/srv/fs/minixfs
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/minixfs/mfs.h

    r03bc76a rc699b0c  
    5858#endif
    5959
    60 #define on_error(r, inst) do {  \
    61                                 if (r != EOK) inst;     \
    62                         }while(0)
    63 
    6460typedef uint32_t bitchunk_t;
    6561
  • uspace/srv/fs/minixfs/mfs_balloc.c

    r03bc76a rc699b0c  
    151151
    152152        r = block_get(&b, inst->service_id, block, BLOCK_FLAGS_NONE);
    153         on_error(r, goto out_err);
     153        if (r != EOK)
     154                goto out_err;
    154155
    155156        /*Compute the bit index in the block*/
     
    219220                              BLOCK_FLAGS_NONE);
    220221
    221                 on_error(r, goto out);
     222                if (r != EOK)
     223                        goto out;
    222224
    223225                unsigned tmp = *search % bits_per_block;
     
    228230                        /*No free bit in this block*/
    229231                        r = block_put(b);
    230                         on_error(r, goto out);
     232                        if (r != EOK)
     233                                goto out;
    231234                        continue;
    232235                }
     
    237240                        /*Index is beyond the limit, it is invalid*/
    238241                        r = block_put(b);
    239                         on_error(r, goto out);
     242                        if (r != EOK)
     243                                goto out;
    240244                        break;
    241245                }
  • uspace/srv/fs/minixfs/mfs_dentry.c

    r03bc76a rc699b0c  
    5353
    5454        int r = read_map(&block, mnode, index * sbi->dirsize);
    55         on_error(r, goto out_err);
     55        if (r != EOK)
     56                goto out_err;
    5657
    5758        if (block == 0) {
     
    6263
    6364        r = block_get(&b, inst->service_id, block, BLOCK_FLAGS_NONE);
    64         on_error(r, goto out_err);
     65        if (r != EOK)
     66                goto out_err;
    6567
    6668        unsigned dentries_per_zone = sbi->block_size / sbi->dirsize;
     
    113115
    114116        r = read_map(&block, mnode, d_off_bytes);
    115         on_error(r, goto out);
     117        if (r != EOK)
     118                goto out;
    116119
    117120        r = block_get(&b, mnode->instance->service_id, block, BLOCK_FLAGS_NONE);
    118         on_error(r, goto out);
     121        if (r != EOK)
     122                goto out;
    119123
    120124        const size_t name_len = sbi->max_name_len;
     
    166170        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize ; ++i) {
    167171                r = read_dentry(mnode, &d_info, i);
    168                 on_error(r, return r);
     172                if (r != EOK)
     173                        return r;
    169174
    170175                const size_t d_name_len = str_size(d_info.d_name);
     
    206211        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    207212                r = read_dentry(mnode, &d_info, i);
    208                 on_error(r, return r);
     213                if (r != EOK)
     214                        return r;
    209215
    210216                if (d_info.d_inum == 0) {
     
    219225                pos = mnode->ino_i->i_size;
    220226                r = read_map(&b, mnode, pos);
    221                 on_error(r, goto out);
     227                if (r != EOK)
     228                        goto out;
    222229
    223230                if (b == 0) {
     
    226233                        uint32_t dummy;
    227234                        r = mfs_alloc_zone(mnode->instance, &b);
    228                         on_error(r, goto out);
     235                        if (r != EOK)
     236                                goto out;
    229237                        r = write_map(mnode, pos, b, &dummy);
    230                         on_error(r, goto out);
     238                        if (r != EOK)
     239                                goto out;
    231240                }
    232241
  • uspace/srv/fs/minixfs/mfs_inode.c

    r03bc76a rc699b0c  
    9696                      itable_off + inum / sbi->ino_per_block,
    9797                      BLOCK_FLAGS_NONE);
    98         on_error(r, goto out_err);
     98        if (r != EOK)
     99                goto out_err;
    99100
    100101        ino = b->data + ino_off * sizeof(struct mfs_inode);
     
    152153                      itable_off + inum / sbi->ino_per_block,
    153154                      BLOCK_FLAGS_NONE);
    154         on_error(r, goto out_err);
     155        if (r != EOK)
     156                goto out_err;
    155157
    156158        ino = b->data + ino_off * sizeof(struct mfs2_inode);
     
    225227                      BLOCK_FLAGS_NONE);
    226228
    227         on_error(r, goto out);
     229        if (r != EOK)
     230                goto out;
    228231
    229232        struct mfs_inode *ino = b->data;
     
    267270                      BLOCK_FLAGS_NONE);
    268271
    269         on_error(r, goto out);
     272        if (r != EOK)
     273                goto out;
    270274
    271275        struct mfs2_inode *ino2 = b->data;
     
    330334
    331335                r = write_map(mnode, pos, 0, &old_zone);
    332                 on_error(r, goto exit_error);
     336                if (r != EOK)
     337                        goto exit_error;
    333338
    334339                ino_i->i_size -= bs;
     
    338343
    339344                r = mfs_free_zone(mnode->instance, old_zone);
    340                 on_error(r, goto exit_error);
     345                if (r != EOK)
     346                        goto exit_error;
    341347        }
    342348
  • uspace/srv/fs/minixfs/mfs_ops.c

    r03bc76a rc699b0c  
    335335
    336336        r = mfs_instance_get(service_id, &inst);
    337         on_error(r, return r);
     337        if (r != EOK)
     338                return r;
    338339
    339340        /*Alloc a new inode*/
    340341        r = mfs_alloc_inode(inst, &inum);
    341         on_error(r, return r);
     342        if (r != EOK)
     343                return r;
    342344
    343345        struct mfs_ino_info *ino_i;
     
    432434        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    433435                r = read_dentry(mnode, &d_info, i);
    434                 on_error(r, return r);
     436                if (r != EOK)
     437                        return r;
    435438
    436439                if (!d_info.d_inum) {
     
    475478
    476479        rc = mfs_instance_get(service_id, &instance);
    477         on_error(rc, return rc);
     480        if (rc != EOK)
     481                return rc;
    478482
    479483        return mfs_node_core_get(rfn, instance, index);
     
    583587
    584588        rc = get_inode(inst, &ino_i, index);
    585         on_error(rc, goto out_err);
     589        if (rc != EOK)
     590                goto out_err;
    586591
    587592        ino_i->index = index;
     
    641646
    642647        int r = insert_dentry(parent, name, child->ino_i->index);
    643         on_error(r, goto exit_error);
     648        if (r != EOK)
     649                goto exit_error;
    644650
    645651        if (S_ISDIR(child->ino_i->i_mode)) {
    646652                r = insert_dentry(child, ".", child->ino_i->index);
    647                 on_error(r, goto exit_error);
     653                if (r != EOK)
     654                        goto exit_error;
    648655                //child->ino_i->i_nlinks++;
    649656                //child->ino_i->dirty = true;
    650657                r = insert_dentry(child, "..", parent->ino_i->index);
    651                 on_error(r, goto exit_error);
     658                if (r != EOK)
     659                        goto exit_error;
    652660                //parent->ino_i->i_nlinks++;
    653661                //parent->ino_i->dirty = true;
     
    672680
    673681        r = mfs_has_children(&has_children, cfn);
    674         on_error(r, return r);
     682        if (r != EOK)
     683                return r;
    675684
    676685        if (has_children)
     
    678687
    679688        r = remove_dentry(parent, name);
    680         on_error(r, return r);
     689        if (r != EOK)
     690                return r;
    681691
    682692        struct mfs_ino_info *chino = child->ino_i;
     
    713723        for (i = 2; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    714724                r = read_dentry(mnode, &d_info, i);
    715                 on_error(r, return r);
     725                if (r != EOK)
     726                        return r;
    716727
    717728                if (d_info.d_inum) {
     
    764775                for (; pos < mnode->ino_i->i_size / sbi->dirsize; ++pos) {
    765776                        rc = read_dentry(mnode, &d_info, pos);
    766                         on_error(rc, goto out_error);
     777                        if (rc != EOK)
     778                                goto out_error;
    767779
    768780                        if (d_info.d_inum) {
     
    796808
    797809                rc = read_map(&zone, mnode, pos);
    798                 on_error(rc, goto out_error);
     810                if (rc != EOK)
     811                        goto out_error;
    799812
    800813                if (zone == 0) {
     
    813826
    814827                rc = block_get(&b, service_id, zone, BLOCK_FLAGS_NONE);
    815                 on_error(rc, goto out_error);
     828                if (rc != EOK)
     829                        goto out_error;
    816830
    817831                async_data_read_finalize(callid, b->data +
     
    870884        if (pos < boundary) {
    871885                r = read_map(&block, mnode, pos);
    872                 on_error(r, goto out_err);
     886                if (r != EOK)
     887                        goto out_err;
    873888
    874889                if (block == 0) {
    875890                        /*Writing in a sparse block*/
    876891                        r = mfs_alloc_zone(mnode->instance, &block);
    877                         on_error(r, goto out_err);
     892                        if (r != EOK)
     893                                goto out_err;
    878894                        flags = BLOCK_FLAGS_NOREAD;
    879895                }
     
    882898
    883899                r = mfs_alloc_zone(mnode->instance, &block);
    884                 on_error(r, goto out_err);
     900                if (r != EOK)
     901                        goto out_err;
    885902
    886903                r = write_map(mnode, pos, block, &dummy);
    887                 on_error(r, goto out_err);
     904                if (r != EOK)
     905                        goto out_err;
    888906        }
    889907
    890908        block_t *b;
    891909        r = block_get(&b, service_id, block, flags);
    892         on_error(r, goto out_err);
     910        if (r != EOK)
     911                goto out_err;
    893912
    894913        async_data_write_finalize(callid, b->data + pos % bs, bytes);
     
    941960
    942961        r = mfs_has_children(&has_children, fn);
    943         on_error(r, goto out);
     962        if (r != EOK)
     963                goto out;
    944964
    945965        assert(!has_children);
     
    953973        /*Free the entire inode content*/
    954974        r = inode_shrink(mnode, mnode->ino_i->i_size);
    955         on_error(r, goto out);
     975        if (r != EOK)
     976                goto out;
    956977        r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
    957978
  • uspace/srv/fs/minixfs/mfs_rw.c

    r03bc76a rc699b0c  
    135135                                uint32_t zone;
    136136                                r = alloc_zone_and_clear(inst, &zone);
    137                                 on_error(r, return r);
     137                                if (r != EOK)
     138                                        return r;
    138139
    139140                                ino_i->i_izone[0] = zone;
     
    147148
    148149                r = read_ind_zone(inst, ino_i->i_izone[0], &ind_zone);
    149                 on_error(r, return r);
     150                if (r != EOK)
     151                        return r;
    150152
    151153                *b = ind_zone[rblock];
     
    167169                        uint32_t zone;
    168170                        r = alloc_zone_and_clear(inst, &zone);
    169                         on_error(r, return r);
     171                        if (r != EOK)
     172                                return r;
    170173
    171174                        ino_i->i_izone[1] = zone;
     
    179182
    180183        r = read_ind_zone(inst, ino_i->i_izone[1], &ind_zone);
    181         on_error(r, return r);
     184        if (r != EOK)
     185                return r;
    182186
    183187        /*
     
    192196                        uint32_t zone;
    193197                        r = alloc_zone_and_clear(inst, &zone);
    194                         on_error(r, goto out_free_ind1);
     198                        if (r != EOK)
     199                                goto out_free_ind1;
    195200
    196201                        ind_zone[ind2_off] = zone;
     
    205210
    206211        r = read_ind_zone(inst, ind_zone[ind2_off], &ind2_zone);
    207         on_error(r, goto out_free_ind1);
     212        if (r != EOK)
     213                goto out_free_ind1;
    208214
    209215        *b = ind2_zone[ind2_off % ptrs_per_block];
     
    247253                if (ino_i->i_izone[0]) {
    248254                        r = mfs_free_zone(inst, ino_i->i_izone[0]);
    249                         on_error(r, return r);
     255                        if (r != EOK)
     256                                return r;
    250257
    251258                        ino_i->i_izone[0] = 0;
     
    270277
    271278        r = read_ind_zone(inst, ino_i->i_izone[1], &dbl_zone);
    272         on_error(r, return r);
     279        if (r != EOK)
     280                return r;
    273281
    274282        for (i = fzone_to_free; i < ptrs_per_block; ++i) {
     
    277285
    278286                r = mfs_free_zone(inst, dbl_zone[i]);
    279                 on_error(r, goto out);
     287                if (r != EOK)
     288                        goto out;
    280289        }
    281290
     
    297306
    298307        r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NOREAD);
    299         on_error(r, return r);
     308        if (r != EOK)
     309                return r;
    300310
    301311        memset(b->data, 0, b->size);
     
    311321
    312322        r = mfs_alloc_zone(inst, zone);
    313         on_error(r, return r);
     323        if (r != EOK)
     324                return r;
    314325
    315326        r = reset_zone_content(inst, *zone);
     
    361372
    362373        r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NONE);
    363         on_error(r, return r);
     374        if (r != EOK)
     375                return r;
    364376
    365377        if (sbi->fs_version == MFS_VERSION_V1) {
Note: See TracChangeset for help on using the changeset viewer.