Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/libfs/libfs.c

    r0daba212 r0143f72  
    4646#include <sys/stat.h>
    4747
    48 #define on_error(rc, action) \
    49         do { \
    50                 if ((rc) != EOK) \
    51                         action; \
    52         } while (0)
    53 
    54 #define combine_rc(rc1, rc2) \
    55         ((rc1) == EOK ? (rc2) : (rc1))
    56 
    57 #define answer_and_return(rid, rc) \
    58         do { \
    59                 ipc_answer_0((rid), (rc)); \
    60                 return; \
    61         } while (0)
    62 
    6348/** Register file system server.
    6449 *
     
    177162        }
    178163
    179         fs_node_t *fn;
    180         res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
    181         if (res != EOK || !fn) {
     164        fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
     165        if (!fn) {
    182166                ipc_hangup(mountee_phone);
    183                 ipc_answer_0(callid, combine_rc(res, ENOENT));
    184                 ipc_answer_0(rid, combine_rc(res, ENOENT));
     167                ipc_answer_0(callid, ENOENT);
     168                ipc_answer_0(rid, ENOENT);
    185169                return;
    186170        }
     
    188172        if (fn->mp_data.mp_active) {
    189173                ipc_hangup(mountee_phone);
    190                 (void) ops->node_put(fn);
     174                ops->node_put(fn);
    191175                ipc_answer_0(callid, EBUSY);
    192176                ipc_answer_0(rid, EBUSY);
     
    195179
    196180        rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
    197         if (rc != EOK) {
     181        if (rc != 0) {
    198182                ipc_hangup(mountee_phone);
    199                 (void) ops->node_put(fn);
     183                ops->node_put(fn);
    200184                ipc_answer_0(callid, rc);
    201185                ipc_answer_0(rid, rc);
     
    246230        char component[NAME_MAX + 1];
    247231        int len;
    248         int rc;
    249232
    250233        if (last < next)
     
    252235
    253236        fs_node_t *par = NULL;
    254         fs_node_t *cur = NULL;
     237        fs_node_t *cur = ops->root_get(dev_handle);
    255238        fs_node_t *tmp = NULL;
    256 
    257         rc = ops->root_get(&cur, dev_handle);
    258         on_error(rc, goto out_with_answer);
    259239
    260240        if (cur->mp_data.mp_active) {
     
    262242                    next, last, cur->mp_data.dev_handle, lflag, index,
    263243                    IPC_FF_ROUTE_FROM_ME);
    264                 (void) ops->node_put(cur);
     244                ops->node_put(cur);
    265245                return;
    266246        }
     
    269249                next++;         /* eat slash */
    270250       
    271         while (next <= last) {
    272                 bool has_children;
    273 
    274                 rc = ops->has_children(&has_children, cur);
    275                 on_error(rc, goto out_with_answer);
    276                 if (!has_children)
    277                         break;
    278 
     251        while (next <= last && ops->has_children(cur)) {
    279252                /* collect the component */
    280253                len = 0;
     
    294267
    295268                /* match the component */
    296                 rc = ops->match(&tmp, cur, component);
    297                 on_error(rc, goto out_with_answer);
    298 
     269                tmp = ops->match(cur, component);
    299270                if (tmp && tmp->mp_data.mp_active) {
    300271                        if (next > last)
     
    306277                            VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
    307278                            lflag, index, IPC_FF_ROUTE_FROM_ME);
    308                         (void) ops->node_put(cur);
    309                         (void) ops->node_put(tmp);
     279                        ops->node_put(cur);
     280                        ops->node_put(tmp);
    310281                        if (par)
    311                                 (void) ops->node_put(par);
     282                                ops->node_put(par);
    312283                        return;
    313284                }
     
    329300                                fs_node_t *fn;
    330301                                if (lflag & L_CREATE)
    331                                         rc = ops->create(&fn, dev_handle,
    332                                             lflag);
     302                                        fn = ops->create(dev_handle, lflag);
    333303                                else
    334                                         rc = ops->node_get(&fn, dev_handle,
     304                                        fn = ops->node_get(dev_handle,
    335305                                            index);
    336                                 on_error(rc, goto out_with_answer);
    337306                                if (fn) {
     307                                        int rc;
     308
    338309                                        rc = ops->link(cur, fn, component);
    339310                                        if (rc != EOK) {
    340                                                 if (lflag & L_CREATE)
    341                                                         (void) ops->destroy(fn);
     311                                                if (lflag & L_CREATE) {
     312                                                        (void)ops->destroy(fn);
     313                                                }
    342314                                                ipc_answer_0(rid, rc);
    343315                                        } else {
     
    347319                                                    ops->size_get(fn),
    348320                                                    ops->lnkcnt_get(fn));
    349                                                 (void) ops->node_put(fn);
     321                                                ops->node_put(fn);
    350322                                        }
    351323                                } else {
     
    358330                }
    359331
    360                 if (par) {
    361                         rc = ops->node_put(par);
    362                         on_error(rc, goto out_with_answer);
    363                 }
     332                if (par)
     333                        ops->node_put(par);
    364334
    365335                /* descend one level */
     
    370340
    371341        /* handle miss: excessive components */
    372         if (next <= last) {
    373                 bool has_children;
    374 
    375                 rc = ops->has_children(&has_children, cur);
    376                 on_error(rc, goto out_with_answer);
    377                 if (has_children)
    378                         goto skip_miss;
    379 
     342        if (next <= last && !ops->has_children(cur)) {
    380343                if (lflag & (L_CREATE | L_LINK)) {
    381344                        if (!ops->is_directory(cur)) {
     
    405368                        fs_node_t *fn;
    406369                        if (lflag & L_CREATE)
    407                                 rc = ops->create(&fn, dev_handle, lflag);
     370                                fn = ops->create(dev_handle, lflag);
    408371                        else
    409                                 rc = ops->node_get(&fn, dev_handle, index);
    410                         on_error(rc, goto out_with_answer);
     372                                fn = ops->node_get(dev_handle, index);
    411373                        if (fn) {
     374                                int rc;
     375
    412376                                rc = ops->link(cur, fn, component);
    413377                                if (rc != EOK) {
    414378                                        if (lflag & L_CREATE)
    415                                                 (void) ops->destroy(fn);
     379                                                (void)ops->destroy(fn);
    416380                                        ipc_answer_0(rid, rc);
    417381                                } else {
     
    421385                                            ops->size_get(fn),
    422386                                            ops->lnkcnt_get(fn));
    423                                         (void) ops->node_put(fn);
     387                                        ops->node_put(fn);
    424388                                }
    425389                        } else {
     
    431395                goto out;
    432396        }
    433 skip_miss:
    434397
    435398        /* handle hit */
    436399        if (lflag & L_UNLINK) {
    437400                unsigned old_lnkcnt = ops->lnkcnt_get(cur);
    438                 rc = ops->unlink(par, cur, component);
    439                 ipc_answer_5(rid, (ipcarg_t)rc, fs_handle, dev_handle,
     401                int res = ops->unlink(par, cur, component);
     402                ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
    440403                    ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
    441404                goto out;
     
    455418        }
    456419
    457 out_with_answer:
    458         if (rc == EOK) {
    459                 ipc_answer_5(rid, EOK, fs_handle, dev_handle,
    460                     ops->index_get(cur), ops->size_get(cur),
    461                     ops->lnkcnt_get(cur));
    462         } else {
    463                 ipc_answer_0(rid, rc);
    464         }
     420        ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
     421            ops->size_get(cur), ops->lnkcnt_get(cur));
    465422
    466423out:
    467424        if (par)
    468                 (void) ops->node_put(par);
     425                ops->node_put(par);
    469426        if (cur)
    470                 (void) ops->node_put(cur);
     427                ops->node_put(cur);
    471428        if (tmp)
    472                 (void) ops->node_put(tmp);
     429                ops->node_put(tmp);
    473430}
    474431
     
    478435        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    479436        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    480         fs_node_t *fn;
    481         int rc;
    482 
    483         rc = ops->node_get(&fn, dev_handle, index);
    484         on_error(rc, answer_and_return(rid, rc));
     437        fs_node_t *fn = ops->node_get(dev_handle, index);
    485438
    486439        ipc_callid_t callid;
     
    520473        dev_handle_t dev_handle = IPC_GET_ARG1(*request);
    521474        fs_index_t index = IPC_GET_ARG2(*request);
    522         fs_node_t *fn;
    523         int rc;
    524        
    525         rc = ops->node_get(&fn, dev_handle, index);
    526         on_error(rc, answer_and_return(rid, rc));
    527        
    528         if (fn == NULL) {
     475       
     476        fs_node_t *node = ops->node_get(dev_handle, index);
     477       
     478        if (node == NULL) {
    529479                ipc_answer_0(rid, ENOENT);
    530480                return;
    531481        }
    532482       
    533         ipc_answer_5(rid, EOK, fs_handle, dev_handle, index, ops->size_get(fn),
    534             ops->lnkcnt_get(fn));
    535        
    536         (void) ops->node_put(fn);
     483        ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,
     484            ops->size_get(node), ops->lnkcnt_get(node));
     485       
     486        ops->node_put(node);
    537487}
    538488
Note: See TracChangeset for help on using the changeset viewer.