Changeset 984a9ba in mainline for uspace/lib/fs/libfs.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/fs/libfs.c

    r76f566d r984a9ba  
    5858        ((rc1) == EOK ? (rc2) : (rc1))
    5959
    60 #define answer_and_return(chandle, rc) \
     60#define answer_and_return(call, rc) \
    6161        do { \
    62                 async_answer_0((chandle), (rc)); \
     62                async_answer_0((call), (rc)); \
    6363                return; \
    6464        } while (0)
    … …  
    7171static char fs_name[FS_NAME_MAXLEN + 1];
    7272
    73 static void libfs_link(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    74     ipc_call_t *);
    75 static void libfs_lookup(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    76     ipc_call_t *);
    77 static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    78     ipc_call_t *);
    79 static void libfs_open_node(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    80     ipc_call_t *);
    81 static void libfs_statfs(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    82     ipc_call_t *);
    83 
    84 static void vfs_out_fsprobe(cap_call_handle_t req_handle, ipc_call_t *req)
     73static void libfs_link(libfs_ops_t *, fs_handle_t, ipc_call_t *);
     74static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_call_t *);
     75static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_call_t *);
     76static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_call_t *);
     77static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_call_t *);
     78
     79static void vfs_out_fsprobe(ipc_call_t *req)
    8580{
    8681        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    8883        vfs_fs_probe_info_t info;
    8984
    90         cap_call_handle_t chandle;
     85        ipc_call_t call;
    9186        size_t size;
    92         if ((!async_data_read_receive(&chandle, &size)) ||
     87        if ((!async_data_read_receive(&call, &size)) ||
    9388            (size != sizeof(info))) {
    94                 async_answer_0(chandle, EIO);
    95                 async_answer_0(req_handle, EIO);
     89                async_answer_0(&call, EIO);
     90                async_answer_0(req, EIO);
    9691                return;
    9792        }
    … …  
    10095        rc = vfs_out_ops->fsprobe(service_id, &info);
    10196        if (rc != EOK) {
    102                 async_answer_0(chandle, EIO);
    103                 async_answer_0(req_handle, rc);
     97                async_answer_0(&call, EIO);
     98                async_answer_0(req, rc);
    10499                return;
    105100        }
    106101
    107         async_data_read_finalize(chandle, &info, sizeof(info));
    108         async_answer_0(req_handle, EOK);
    109 }
    110 
    111 static void vfs_out_mounted(cap_call_handle_t req_handle, ipc_call_t *req)
     102        async_data_read_finalize(&call, &info, sizeof(info));
     103        async_answer_0(req, EOK);
     104}
     105
     106static void vfs_out_mounted(ipc_call_t *req)
    112107{
    113108        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    118113        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    119114        if (rc != EOK) {
    120                 async_answer_0(req_handle, rc);
     115                async_answer_0(req, rc);
    121116                return;
    122117        }
    … …  
    127122
    128123        if (rc == EOK) {
    129                 async_answer_3(req_handle, EOK, index, LOWER32(size),
     124                async_answer_3(req, EOK, index, LOWER32(size),
    130125                    UPPER32(size));
    131126        } else
    132                 async_answer_0(req_handle, rc);
     127                async_answer_0(req, rc);
    133128
    134129        free(opts);
    135130}
    136131
    137 static void vfs_out_unmounted(cap_call_handle_t req_handle, ipc_call_t *req)
     132static void vfs_out_unmounted(ipc_call_t *req)
    138133{
    139134        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    142137        rc = vfs_out_ops->unmounted(service_id);
    143138
    144         async_answer_0(req_handle, rc);
    145 }
    146 
    147 static void vfs_out_link(cap_call_handle_t req_handle, ipc_call_t *req)
    148 {
    149         libfs_link(libfs_ops, reg.fs_handle, req_handle, req);
    150 }
    151 
    152 static void vfs_out_lookup(cap_call_handle_t req_handle, ipc_call_t *req)
    153 {
    154         libfs_lookup(libfs_ops, reg.fs_handle, req_handle, req);
    155 }
    156 
    157 static void vfs_out_read(cap_call_handle_t req_handle, ipc_call_t *req)
     139        async_answer_0(req, rc);
     140}
     141
     142static void vfs_out_link(ipc_call_t *req)
     143{
     144        libfs_link(libfs_ops, reg.fs_handle, req);
     145}
     146
     147static void vfs_out_lookup(ipc_call_t *req)
     148{
     149        libfs_lookup(libfs_ops, reg.fs_handle, req);
     150}
     151
     152static void vfs_out_read(ipc_call_t *req)
    158153{
    159154        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    167162
    168163        if (rc == EOK)
    169                 async_answer_1(req_handle, EOK, rbytes);
     164                async_answer_1(req, EOK, rbytes);
    170165        else
    171                 async_answer_0(req_handle, rc);
    172 }
    173 
    174 static void vfs_out_write(cap_call_handle_t req_handle, ipc_call_t *req)
     166                async_answer_0(req, rc);
     167}
     168
     169static void vfs_out_write(ipc_call_t *req)
    175170{
    176171        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    185180
    186181        if (rc == EOK) {
    187                 async_answer_3(req_handle, EOK, wbytes, LOWER32(nsize),
     182                async_answer_3(req, EOK, wbytes, LOWER32(nsize),
    188183                    UPPER32(nsize));
    189184        } else
    190                 async_answer_0(req_handle, rc);
    191 }
    192 
    193 static void vfs_out_truncate(cap_call_handle_t req_handle, ipc_call_t *req)
     185                async_answer_0(req, rc);
     186}
     187
     188static void vfs_out_truncate(ipc_call_t *req)
    194189{
    195190        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    201196        rc = vfs_out_ops->truncate(service_id, index, size);
    202197
    203         async_answer_0(req_handle, rc);
    204 }
    205 
    206 static void vfs_out_close(cap_call_handle_t req_handle, ipc_call_t *req)
     198        async_answer_0(req, rc);
     199}
     200
     201static void vfs_out_close(ipc_call_t *req)
    207202{
    208203        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    212207        rc = vfs_out_ops->close(service_id, index);
    213208
    214         async_answer_0(req_handle, rc);
    215 }
    216 
    217 static void vfs_out_destroy(cap_call_handle_t req_handle, ipc_call_t *req)
     209        async_answer_0(req, rc);
     210}
     211
     212static void vfs_out_destroy(ipc_call_t *req)
    218213{
    219214        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    229224                        rc = vfs_out_ops->destroy(service_id, index);
    230225        }
    231         async_answer_0(req_handle, rc);
    232 }
    233 
    234 static void vfs_out_open_node(cap_call_handle_t req_handle, ipc_call_t *req)
    235 {
    236         libfs_open_node(libfs_ops, reg.fs_handle, req_handle, req);
    237 }
    238 
    239 static void vfs_out_stat(cap_call_handle_t req_handle, ipc_call_t *req)
    240 {
    241         libfs_stat(libfs_ops, reg.fs_handle, req_handle, req);
    242 }
    243 
    244 static void vfs_out_sync(cap_call_handle_t req_handle, ipc_call_t *req)
     226        async_answer_0(req, rc);
     227}
     228
     229static void vfs_out_open_node(ipc_call_t *req)
     230{
     231        libfs_open_node(libfs_ops, reg.fs_handle, req);
     232}
     233
     234static void vfs_out_stat(ipc_call_t *req)
     235{
     236        libfs_stat(libfs_ops, reg.fs_handle, req);
     237}
     238
     239static void vfs_out_sync(ipc_call_t *req)
    245240{
    246241        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    250245        rc = vfs_out_ops->sync(service_id, index);
    251246
    252         async_answer_0(req_handle, rc);
    253 }
    254 
    255 static void vfs_out_statfs(cap_call_handle_t req_handle, ipc_call_t *req)
    256 {
    257         libfs_statfs(libfs_ops, reg.fs_handle, req_handle, req);
    258 }
    259 
    260 static void vfs_out_is_empty(cap_call_handle_t req_handle, ipc_call_t *req)
     247        async_answer_0(req, rc);
     248}
     249
     250static void vfs_out_statfs(ipc_call_t *req)
     251{
     252        libfs_statfs(libfs_ops, reg.fs_handle, req);
     253}
     254
     255static void vfs_out_is_empty(ipc_call_t *req)
    261256{
    262257        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    267262        rc = libfs_ops->node_get(&node, service_id, index);
    268263        if (rc != EOK)
    269                 async_answer_0(req_handle, rc);
     264                async_answer_0(req, rc);
    270265        if (node == NULL)
    271                 async_answer_0(req_handle, EINVAL);
     266                async_answer_0(req, EINVAL);
    272267
    273268        bool children = false;
    … …  
    276271
    277272        if (rc != EOK)
    278                 async_answer_0(req_handle, rc);
    279         async_answer_0(req_handle, children ? ENOTEMPTY : EOK);
    280 }
    281 
    282 static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
    283     void *arg)
    284 {
    285         if (icall_handle) {
     273                async_answer_0(req, rc);
     274        async_answer_0(req, children ? ENOTEMPTY : EOK);
     275}
     276
     277static void vfs_connection(ipc_call_t *icall, void *arg)
     278{
     279        if (icall->cap_handle) {
    286280                /*
    287281                 * This only happens for connections opened by
    … …  
    289283                 * created by IPC_M_CONNECT_TO_ME.
    290284                 */
    291                 async_answer_0(icall_handle, EOK);
     285                async_answer_0(icall, EOK);
    292286        }
    293287
    294288        while (true) {
    295289                ipc_call_t call;
    296                 cap_call_handle_t chandle = async_get_call(&call);
     290                async_get_call(&call);
    297291
    298292                if (!IPC_GET_IMETHOD(call))
    … …  
    301295                switch (IPC_GET_IMETHOD(call)) {
    302296                case VFS_OUT_FSPROBE:
    303                         vfs_out_fsprobe(chandle, &call);
     297                        vfs_out_fsprobe(&call);
    304298                        break;
    305299                case VFS_OUT_MOUNTED:
    306                         vfs_out_mounted(chandle, &call);
     300                        vfs_out_mounted(&call);
    307301                        break;
    308302                case VFS_OUT_UNMOUNTED:
    309                         vfs_out_unmounted(chandle, &call);
     303                        vfs_out_unmounted(&call);
    310304                        break;
    311305                case VFS_OUT_LINK:
    312                         vfs_out_link(chandle, &call);
     306                        vfs_out_link(&call);
    313307                        break;
    314308                case VFS_OUT_LOOKUP:
    315                         vfs_out_lookup(chandle, &call);
     309                        vfs_out_lookup(&call);
    316310                        break;
    317311                case VFS_OUT_READ:
    318                         vfs_out_read(chandle, &call);
     312                        vfs_out_read(&call);
    319313                        break;
    320314                case VFS_OUT_WRITE:
    321                         vfs_out_write(chandle, &call);
     315                        vfs_out_write(&call);
    322316                        break;
    323317                case VFS_OUT_TRUNCATE:
    324                         vfs_out_truncate(chandle, &call);
     318                        vfs_out_truncate(&call);
    325319                        break;
    326320                case VFS_OUT_CLOSE:
    327                         vfs_out_close(chandle, &call);
     321                        vfs_out_close(&call);
    328322                        break;
    329323                case VFS_OUT_DESTROY:
    330                         vfs_out_destroy(chandle, &call);
     324                        vfs_out_destroy(&call);
    331325                        break;
    332326                case VFS_OUT_OPEN_NODE:
    333                         vfs_out_open_node(chandle, &call);
     327                        vfs_out_open_node(&call);
    334328                        break;
    335329                case VFS_OUT_STAT:
    336                         vfs_out_stat(chandle, &call);
     330                        vfs_out_stat(&call);
    337331                        break;
    338332                case VFS_OUT_SYNC:
    339                         vfs_out_sync(chandle, &call);
     333                        vfs_out_sync(&call);
    340334                        break;
    341335                case VFS_OUT_STATFS:
    342                         vfs_out_statfs(chandle, &call);
     336                        vfs_out_statfs(&call);
    343337                        break;
    344338                case VFS_OUT_IS_EMPTY:
    345                         vfs_out_is_empty(chandle, &call);
     339                        vfs_out_is_empty(&call);
    346340                        break;
    347341                default:
    348                         async_answer_0(chandle, ENOTSUP);
     342                        async_answer_0(&call, ENOTSUP);
    349343                        break;
    350344                }
    … …  
    481475static errno_t receive_fname(char *buffer)
    482476{
     477        ipc_call_t call;
    483478        size_t size;
    484         cap_call_handle_t wcall;
    485 
    486         if (!async_data_write_receive(&wcall, &size))
     479
     480        if (!async_data_write_receive(&call, &size))
    487481                return ENOENT;
     482
    488483        if (size > NAME_MAX + 1) {
    489                 async_answer_0(wcall, ERANGE);
     484                async_answer_0(&call, ERANGE);
    490485                return ERANGE;
    491486        }
    492         return async_data_write_finalize(wcall, buffer, size);
     487
     488        return async_data_write_finalize(&call, buffer, size);
    493489}
    494490
    495491/** Link a file at a path.
     492 *
    496493 */
    497 void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle,
    498     cap_call_handle_t req_handle, ipc_call_t *req)
     494void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
    499495{
    500496        service_id_t parent_sid = IPC_GET_ARG1(*req);
    … …  
    505501        errno_t rc = receive_fname(component);
    506502        if (rc != EOK) {
    507                 async_answer_0(req_handle, rc);
     503                async_answer_0(req, rc);
    508504                return;
    509505        }
    … …  
    512508        rc = ops->node_get(&parent, parent_sid, parent_index);
    513509        if (parent == NULL) {
    514                 async_answer_0(req_handle, rc == EOK ? EBADF : rc);
     510                async_answer_0(req, rc == EOK ? EBADF : rc);
    515511                return;
    516512        }
    … …  
    519515        rc = ops->node_get(&child, parent_sid, child_index);
    520516        if (child == NULL) {
    521                 async_answer_0(req_handle, rc == EOK ? EBADF : rc);
     517                async_answer_0(req, rc == EOK ? EBADF : rc);
    522518                ops->node_put(parent);
    523519                return;
    … …  
    527523        ops->node_put(parent);
    528524        ops->node_put(child);
    529         async_answer_0(req_handle, rc);
     525        async_answer_0(req, rc);
    530526}
    531527
    … …  
    535531 * as returned by the canonify() function.
    536532 *
    537  * @param ops         libfs operations structure with function pointers to
    538  *                    file system implementation
    539  * @param fs_handle   File system handle of the file system where to perform
    540  *                    the lookup.
    541  * @param req_handle  Call handle of the VFS_OUT_LOOKUP request.
    542  * @param request     VFS_OUT_LOOKUP request data itself.
     533 * @param ops       libfs operations structure with function pointers to
     534 *                  file system implementation
     535 * @param fs_handle File system handle of the file system where to perform
     536 *                  the lookup.
     537 * @param req       VFS_OUT_LOOKUP request data itself.
    543538 *
    544539 */
    545 void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle,
    546     cap_call_handle_t req_handle, ipc_call_t *req)
     540void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
    547541{
    548542        unsigned first = IPC_GET_ARG1(*req);
    … …  
    567561        rc = ops->node_get(&cur, service_id, index);
    568562        if (rc != EOK) {
    569                 async_answer_0(req_handle, rc);
     563                async_answer_0(req, rc);
    570564                goto out;
    571565        }
    … …  
    584578
    585579                if (!ops->is_directory(cur)) {
    586                         async_answer_0(req_handle, ENOTDIR);
     580                        async_answer_0(req, ENOTDIR);
    587581                        goto out;
    588582                }
    … …  
    593587                assert(rc != ERANGE);
    594588                if (rc != EOK) {
    595                         async_answer_0(req_handle, rc);
     589                        async_answer_0(req, rc);
    596590                        goto out;
    597591                }
    … …  
    607601                rc = ops->match(&tmp, cur, component);
    608602                if (rc != EOK) {
    609                         async_answer_0(req_handle, rc);
     603                        async_answer_0(req, rc);
    610604                        goto out;
    611605                }
    … …  
    615609                        rc = ops->node_put(par);
    616610                        if (rc != EOK) {
    617                                 async_answer_0(req_handle, rc);
     611                                async_answer_0(req, rc);
    618612                                goto out;
    619613                        }
    … …  
    636630
    637631        if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) {
    638                 async_answer_0(req_handle, EISDIR);
     632                async_answer_0(req, EISDIR);
    639633                goto out;
    640634        }
    641635
    642636        if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) {
    643                 async_answer_0(req_handle, ENOTDIR);
     637                async_answer_0(req, ENOTDIR);
    644638                goto out;
    645639        }
    … …  
    649643        if (lflag & L_UNLINK) {
    650644                if (!cur) {
    651                         async_answer_0(req_handle, ENOENT);
     645                        async_answer_0(req, ENOENT);
    652646                        goto out;
    653647                }
    654648                if (!par) {
    655                         async_answer_0(req_handle, EINVAL);
     649                        async_answer_0(req, EINVAL);
    656650                        goto out;
    657651                }
    … …  
    660654                if (rc == EOK) {
    661655                        aoff64_t size = ops->size_get(cur);
    662                         async_answer_5(req_handle, EOK, fs_handle,
     656                        async_answer_5(req, EOK, fs_handle,
    663657                            ops->index_get(cur),
    664658                            (ops->is_directory(cur) << 16) | last,
    665659                            LOWER32(size), UPPER32(size));
    666660                } else {
    667                         async_answer_0(req_handle, rc);
     661                        async_answer_0(req, rc);
    668662                }
    669663                goto out;
    … …  
    674668        if (lflag & L_CREATE) {
    675669                if (cur && (lflag & L_EXCLUSIVE)) {
    676                         async_answer_0(req_handle, EEXIST);
     670                        async_answer_0(req, EEXIST);
    677671                        goto out;
    678672                }
    … …  
    682676                            lflag & (L_FILE | L_DIRECTORY));
    683677                        if (rc != EOK) {
    684                                 async_answer_0(req_handle, rc);
     678                                async_answer_0(req, rc);
    685679                                goto out;
    686680                        }
    687681                        if (!cur) {
    688                                 async_answer_0(req_handle, ENOSPC);
     682                                async_answer_0(req, ENOSPC);
    689683                                goto out;
    690684                        }
    … …  
    694688                                (void) ops->destroy(cur);
    695689                                cur = NULL;
    696                                 async_answer_0(req_handle, rc);
     690                                async_answer_0(req, rc);
    697691                                goto out;
    698692                        }
    … …  
    703697out1:
    704698        if (!cur) {
    705                 async_answer_5(req_handle, EOK, fs_handle, ops->index_get(par),
     699                async_answer_5(req, EOK, fs_handle, ops->index_get(par),
    706700                    (ops->is_directory(par) << 16) | last_next,
    707701                    LOWER32(ops->size_get(par)), UPPER32(ops->size_get(par)));
    … …  
    709703        }
    710704
    711         async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur),
     705        async_answer_5(req, EOK, fs_handle, ops->index_get(cur),
    712706            (ops->is_directory(cur) << 16) | last, LOWER32(ops->size_get(cur)),
    713707            UPPER32(ops->size_get(cur)));
    … …  
    724718}
    725719
    726 void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle,
    727     cap_call_handle_t req_handle, ipc_call_t *request)
    728 {
    729         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    730         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     720void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
     721{
     722        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
     723        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    731724
    732725        fs_node_t *fn;
    733726        errno_t rc = ops->node_get(&fn, service_id, index);
    734         on_error(rc, answer_and_return(req_handle, rc));
    735 
    736         cap_call_handle_t chandle;
     727        on_error(rc, answer_and_return(req, rc));
     728
     729        ipc_call_t call;
    737730        size_t size;
    738         if ((!async_data_read_receive(&chandle, &size)) ||
     731        if ((!async_data_read_receive(&call, &size)) ||
    739732            (size != sizeof(vfs_stat_t))) {
    740733                ops->node_put(fn);
    741                 async_answer_0(chandle, EINVAL);
    742                 async_answer_0(req_handle, EINVAL);
     734                async_answer_0(&call, EINVAL);
     735                async_answer_0(req, EINVAL);
    743736                return;
    744737        }
    … …  
    758751        ops->node_put(fn);
    759752
    760 
    761         async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
    762         async_answer_0(req_handle, EOK);
    763 }
    764 
    765 void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle,
    766     cap_call_handle_t req_handle, ipc_call_t *request)
    767 {
    768         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    769         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     753        async_data_read_finalize(&call, &stat, sizeof(vfs_stat_t));
     754        async_answer_0(req, EOK);
     755}
     756
     757void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
     758{
     759        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
     760        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    770761
    771762        fs_node_t *fn;
    772763        errno_t rc = ops->node_get(&fn, service_id, index);
    773         on_error(rc, answer_and_return(req_handle, rc));
    774 
    775         cap_call_handle_t chandle;
     764        on_error(rc, answer_and_return(req, rc));
     765
     766        ipc_call_t call;
    776767        size_t size;
    777         if ((!async_data_read_receive(&chandle, &size)) ||
     768        if ((!async_data_read_receive(&call, &size)) ||
    778769            (size != sizeof(vfs_statfs_t))) {
    779770                goto error;
    … …  
    804795
    805796        ops->node_put(fn);
    806         async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
    807         async_answer_0(req_handle, EOK);
     797        async_data_read_finalize(&call, &st, sizeof(vfs_statfs_t));
     798        async_answer_0(req, EOK);
    808799        return;
    809800
    810801error:
    811802        ops->node_put(fn);
    812         async_answer_0(chandle, EINVAL);
    813         async_answer_0(req_handle, EINVAL);
     803        async_answer_0(&call, EINVAL);
     804        async_answer_0(req, EINVAL);
    814805}
    815806
    … …  
    817808/** Open VFS triplet.
    818809 *
    819  * @param ops         libfs operations structure with function pointers to
    820  *                    file system implementation
    821  * @param req_handle  Call handle of the VFS_OUT_OPEN_NODE request.
    822  * @param request     VFS_OUT_OPEN_NODE request data itself.
     810 * @param ops libfs operations structure with function pointers to
     811 *            file system implementation
     812 * @param req VFS_OUT_OPEN_NODE request data itself.
    823813 *
    824814 */
    825 void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle,
    826     cap_call_handle_t req_handle, ipc_call_t *request)
    827 {
    828         service_id_t service_id = IPC_GET_ARG1(*request);
    829         fs_index_t index = IPC_GET_ARG2(*request);
     815void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
     816{
     817        service_id_t service_id = IPC_GET_ARG1(*req);
     818        fs_index_t index = IPC_GET_ARG2(*req);
    830819
    831820        fs_node_t *fn;
    832821        errno_t rc = ops->node_get(&fn, service_id, index);
    833         on_error(rc, answer_and_return(req_handle, rc));
     822        on_error(rc, answer_and_return(req, rc));
    834823
    835824        if (fn == NULL) {
    836                 async_answer_0(req_handle, ENOENT);
     825                async_answer_0(req, ENOENT);
    837826                return;
    838827        }
    … …  
    840829        rc = ops->node_open(fn);
    841830        aoff64_t size = ops->size_get(fn);
    842         async_answer_4(req_handle, rc, LOWER32(size), UPPER32(size),
     831        async_answer_4(req, rc, LOWER32(size), UPPER32(size),
    843832            ops->lnkcnt_get(fn),
    844833            (ops->is_file(fn) ? L_FILE : 0) |
    … …  
    891880{
    892881        fibril_mutex_lock(&instances_mutex);
     882
    893883        list_foreach(instances_list, link, fs_instance_t, inst) {
    894884                if (inst->service_id == service_id) {
    … …  
    898888                }
    899889        }
     890
    900891        fibril_mutex_unlock(&instances_mutex);
    901892        return ENOENT;
    … …  
    905896{
    906897        fibril_mutex_lock(&instances_mutex);
     898
    907899        list_foreach(instances_list, link, fs_instance_t, inst) {
    908900                if (inst->service_id == service_id) {
    … …  
    913905                }
    914906        }
     907
    915908        fibril_mutex_unlock(&instances_mutex);
    916909        return ENOENT;
Note: See TracChangeset for help on using the changeset viewer.