Changes in uspace/lib/fs/libfs.c [a35b458:77f0a1d] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/fs/libfs.c

    ra35b458 r77f0a1d  
    5858        ((rc1) == EOK ? (rc2) : (rc1))
    5959
    60 #define answer_and_return(rid, rc) \
     60#define answer_and_return(chandle, rc) \
    6161        do { \
    62                 async_answer_0((rid), (rc)); \
     62                async_answer_0((chandle), (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, ipc_callid_t,
     73static void libfs_link(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    7474    ipc_call_t *);
    75 static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     75static void libfs_lookup(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    7676    ipc_call_t *);
    77 static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
    78 static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     77static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    7978    ipc_call_t *);
    80 static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     79static void libfs_open_node(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    8180    ipc_call_t *);
    82 
    83 static void vfs_out_fsprobe(ipc_callid_t rid, ipc_call_t *req)
     81static void libfs_statfs(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
     82    ipc_call_t *);
     83
     84static void vfs_out_fsprobe(cap_call_handle_t req_handle, ipc_call_t *req)
    8485{
    8586        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    8788        vfs_fs_probe_info_t info;
    8889
    89         ipc_callid_t callid;
     90        cap_call_handle_t chandle;
    9091        size_t size;
    91         if ((!async_data_read_receive(&callid, &size)) ||
     92        if ((!async_data_read_receive(&chandle, &size)) ||
    9293            (size != sizeof(info))) {
    93                 async_answer_0(callid, EIO);
    94                 async_answer_0(rid, EIO);
     94                async_answer_0(chandle, EIO);
     95                async_answer_0(req_handle, EIO);
    9596                return;
    9697        }
    … …  
    99100        rc = vfs_out_ops->fsprobe(service_id, &info);
    100101        if (rc != EOK) {
    101                 async_answer_0(callid, EIO);
    102                 async_answer_0(rid, rc);
     102                async_answer_0(chandle, EIO);
     103                async_answer_0(req_handle, rc);
    103104                return;
    104105        }
    105106
    106         async_data_read_finalize(callid, &info, sizeof(info));
    107         async_answer_0(rid, EOK);
    108 }
    109 
    110 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
     107        async_data_read_finalize(chandle, &info, sizeof(info));
     108        async_answer_0(req_handle, EOK);
     109}
     110
     111static void vfs_out_mounted(cap_call_handle_t req_handle, ipc_call_t *req)
    111112{
    112113        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    117118        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    118119        if (rc != EOK) {
    119                 async_answer_0(rid, rc);
     120                async_answer_0(req_handle, rc);
    120121                return;
    121122        }
    … …  
    125126        rc = vfs_out_ops->mounted(service_id, opts, &index, &size);
    126127
    127         if (rc == EOK)
    128                 async_answer_3(rid, EOK, index, LOWER32(size), UPPER32(size));
    129         else
    130                 async_answer_0(rid, rc);
     128        if (rc == EOK) {
     129                async_answer_3(req_handle, EOK, index, LOWER32(size),
     130                    UPPER32(size));
     131        } else
     132                async_answer_0(req_handle, rc);
    131133
    132134        free(opts);
    133135}
    134136
    135 static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)
     137static void vfs_out_unmounted(cap_call_handle_t req_handle, ipc_call_t *req)
    136138{
    137139        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    140142        rc = vfs_out_ops->unmounted(service_id);
    141143
    142         async_answer_0(rid, rc);
    143 }
    144 
    145 static void vfs_out_link(ipc_callid_t rid, ipc_call_t *req)
    146 {
    147         libfs_link(libfs_ops, reg.fs_handle, rid, req);
    148 }
    149 
    150 static void vfs_out_lookup(ipc_callid_t rid, ipc_call_t *req)
    151 {
    152         libfs_lookup(libfs_ops, reg.fs_handle, rid, req);
    153 }
    154 
    155 static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req)
     144        async_answer_0(req_handle, rc);
     145}
     146
     147static 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
     152static 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
     157static void vfs_out_read(cap_call_handle_t req_handle, ipc_call_t *req)
    156158{
    157159        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    165167
    166168        if (rc == EOK)
    167                 async_answer_1(rid, EOK, rbytes);
     169                async_answer_1(req_handle, EOK, rbytes);
    168170        else
    169                 async_answer_0(rid, rc);
    170 }
    171 
    172 static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req)
     171                async_answer_0(req_handle, rc);
     172}
     173
     174static void vfs_out_write(cap_call_handle_t req_handle, ipc_call_t *req)
    173175{
    174176        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    183185
    184186        if (rc == EOK) {
    185                 async_answer_3(rid, EOK, wbytes, LOWER32(nsize),
     187                async_answer_3(req_handle, EOK, wbytes, LOWER32(nsize),
    186188                    UPPER32(nsize));
    187189        } else
    188                 async_answer_0(rid, rc);
    189 }
    190 
    191 static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req)
     190                async_answer_0(req_handle, rc);
     191}
     192
     193static void vfs_out_truncate(cap_call_handle_t req_handle, ipc_call_t *req)
    192194{
    193195        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    199201        rc = vfs_out_ops->truncate(service_id, index, size);
    200202
    201         async_answer_0(rid, rc);
    202 }
    203 
    204 static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req)
     203        async_answer_0(req_handle, rc);
     204}
     205
     206static void vfs_out_close(cap_call_handle_t req_handle, ipc_call_t *req)
    205207{
    206208        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    210212        rc = vfs_out_ops->close(service_id, index);
    211213
    212         async_answer_0(rid, rc);
    213 }
    214 
    215 static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req)
     214        async_answer_0(req_handle, rc);
     215}
     216
     217static void vfs_out_destroy(cap_call_handle_t req_handle, ipc_call_t *req)
    216218{
    217219        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    227229                        rc = vfs_out_ops->destroy(service_id, index);
    228230        }
    229         async_answer_0(rid, rc);
    230 }
    231 
    232 static void vfs_out_open_node(ipc_callid_t rid, ipc_call_t *req)
    233 {
    234         libfs_open_node(libfs_ops, reg.fs_handle, rid, req);
    235 }
    236 
    237 static void vfs_out_stat(ipc_callid_t rid, ipc_call_t *req)
    238 {
    239         libfs_stat(libfs_ops, reg.fs_handle, rid, req);
    240 }
    241 
    242 static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req)
     231        async_answer_0(req_handle, rc);
     232}
     233
     234static 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
     239static 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
     244static void vfs_out_sync(cap_call_handle_t req_handle, ipc_call_t *req)
    243245{
    244246        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    248250        rc = vfs_out_ops->sync(service_id, index);
    249251
    250         async_answer_0(rid, rc);
    251 }
    252 
    253 static void vfs_out_statfs(ipc_callid_t rid, ipc_call_t *req)
    254 {
    255         libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
    256 }
    257 
    258 static void vfs_out_is_empty(ipc_callid_t rid, ipc_call_t *req)
     252        async_answer_0(req_handle, rc);
     253}
     254
     255static 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
     260static void vfs_out_is_empty(cap_call_handle_t req_handle, ipc_call_t *req)
    259261{
    260262        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    265267        rc = libfs_ops->node_get(&node, service_id, index);
    266268        if (rc != EOK)
    267                 async_answer_0(rid, rc);
     269                async_answer_0(req_handle, rc);
    268270        if (node == NULL)
    269                 async_answer_0(rid, EINVAL);
     271                async_answer_0(req_handle, EINVAL);
    270272
    271273        bool children = false;
    … …  
    274276
    275277        if (rc != EOK)
    276                 async_answer_0(rid, rc);
    277         async_answer_0(rid, children ? ENOTEMPTY : EOK);
    278 }
    279 
    280 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    281 {
    282         if (iid) {
     278                async_answer_0(req_handle, rc);
     279        async_answer_0(req_handle, children ? ENOTEMPTY : EOK);
     280}
     281
     282static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     283    void *arg)
     284{
     285        if (icall_handle) {
    283286                /*
    284287                 * This only happens for connections opened by
    … …  
    286289                 * created by IPC_M_CONNECT_TO_ME.
    287290                 */
    288                 async_answer_0(iid, EOK);
     291                async_answer_0(icall_handle, EOK);
    289292        }
    290293
    291294        while (true) {
    292295                ipc_call_t call;
    293                 ipc_callid_t callid = async_get_call(&call);
     296                cap_call_handle_t chandle = async_get_call(&call);
    294297
    295298                if (!IPC_GET_IMETHOD(call))
    … …  
    298301                switch (IPC_GET_IMETHOD(call)) {
    299302                case VFS_OUT_FSPROBE:
    300                         vfs_out_fsprobe(callid, &call);
     303                        vfs_out_fsprobe(chandle, &call);
    301304                        break;
    302305                case VFS_OUT_MOUNTED:
    303                         vfs_out_mounted(callid, &call);
     306                        vfs_out_mounted(chandle, &call);
    304307                        break;
    305308                case VFS_OUT_UNMOUNTED:
    306                         vfs_out_unmounted(callid, &call);
     309                        vfs_out_unmounted(chandle, &call);
    307310                        break;
    308311                case VFS_OUT_LINK:
    309                         vfs_out_link(callid, &call);
     312                        vfs_out_link(chandle, &call);
    310313                        break;
    311314                case VFS_OUT_LOOKUP:
    312                         vfs_out_lookup(callid, &call);
     315                        vfs_out_lookup(chandle, &call);
    313316                        break;
    314317                case VFS_OUT_READ:
    315                         vfs_out_read(callid, &call);
     318                        vfs_out_read(chandle, &call);
    316319                        break;
    317320                case VFS_OUT_WRITE:
    318                         vfs_out_write(callid, &call);
     321                        vfs_out_write(chandle, &call);
    319322                        break;
    320323                case VFS_OUT_TRUNCATE:
    321                         vfs_out_truncate(callid, &call);
     324                        vfs_out_truncate(chandle, &call);
    322325                        break;
    323326                case VFS_OUT_CLOSE:
    324                         vfs_out_close(callid, &call);
     327                        vfs_out_close(chandle, &call);
    325328                        break;
    326329                case VFS_OUT_DESTROY:
    327                         vfs_out_destroy(callid, &call);
     330                        vfs_out_destroy(chandle, &call);
    328331                        break;
    329332                case VFS_OUT_OPEN_NODE:
    330                         vfs_out_open_node(callid, &call);
     333                        vfs_out_open_node(chandle, &call);
    331334                        break;
    332335                case VFS_OUT_STAT:
    333                         vfs_out_stat(callid, &call);
     336                        vfs_out_stat(chandle, &call);
    334337                        break;
    335338                case VFS_OUT_SYNC:
    336                         vfs_out_sync(callid, &call);
     339                        vfs_out_sync(chandle, &call);
    337340                        break;
    338341                case VFS_OUT_STATFS:
    339                         vfs_out_statfs(callid, &call);
     342                        vfs_out_statfs(chandle, &call);
    340343                        break;
    341344                case VFS_OUT_IS_EMPTY:
    342                         vfs_out_is_empty(callid, &call);
     345                        vfs_out_is_empty(chandle, &call);
    343346                        break;
    344347                default:
    345                         async_answer_0(callid, ENOTSUP);
     348                        async_answer_0(chandle, ENOTSUP);
    346349                        break;
    347350                }
    … …  
    479482{
    480483        size_t size;
    481         ipc_callid_t wcall;
     484        cap_call_handle_t wcall;
    482485
    483486        if (!async_data_write_receive(&wcall, &size))
    … …  
    492495/** Link a file at a path.
    493496 */
    494 void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    495     ipc_call_t *req)
     497void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle,
     498    cap_call_handle_t req_handle, ipc_call_t *req)
    496499{
    497500        service_id_t parent_sid = IPC_GET_ARG1(*req);
    … …  
    502505        errno_t rc = receive_fname(component);
    503506        if (rc != EOK) {
    504                 async_answer_0(rid, rc);
     507                async_answer_0(req_handle, rc);
    505508                return;
    506509        }
    … …  
    509512        rc = ops->node_get(&parent, parent_sid, parent_index);
    510513        if (parent == NULL) {
    511                 async_answer_0(rid, rc == EOK ? EBADF : rc);
     514                async_answer_0(req_handle, rc == EOK ? EBADF : rc);
    512515                return;
    513516        }
    … …  
    516519        rc = ops->node_get(&child, parent_sid, child_index);
    517520        if (child == NULL) {
    518                 async_answer_0(rid, rc == EOK ? EBADF : rc);
     521                async_answer_0(req_handle, rc == EOK ? EBADF : rc);
    519522                ops->node_put(parent);
    520523                return;
    … …  
    524527        ops->node_put(parent);
    525528        ops->node_put(child);
    526         async_answer_0(rid, rc);
     529        async_answer_0(req_handle, rc);
    527530}
    528531
    … …  
    532535 * as returned by the canonify() function.
    533536 *
    534  * @param ops       libfs operations structure with function pointers to
    535  *                  file system implementation
    536  * @param fs_handle File system handle of the file system where to perform
    537  *                  the lookup.
    538  * @param rid       Request ID of the VFS_OUT_LOOKUP request.
    539  * @param request   VFS_OUT_LOOKUP request data itself.
     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.
    540543 *
    541544 */
    542 void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    543     ipc_call_t *req)
     545void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle,
     546    cap_call_handle_t req_handle, ipc_call_t *req)
    544547{
    545548        unsigned first = IPC_GET_ARG1(*req);
    … …  
    564567        rc = ops->node_get(&cur, service_id, index);
    565568        if (rc != EOK) {
    566                 async_answer_0(rid, rc);
     569                async_answer_0(req_handle, rc);
    567570                goto out;
    568571        }
    … …  
    581584
    582585                if (!ops->is_directory(cur)) {
    583                         async_answer_0(rid, ENOTDIR);
     586                        async_answer_0(req_handle, ENOTDIR);
    584587                        goto out;
    585588                }
    … …  
    590593                assert(rc != ERANGE);
    591594                if (rc != EOK) {
    592                         async_answer_0(rid, rc);
     595                        async_answer_0(req_handle, rc);
    593596                        goto out;
    594597                }
    … …  
    604607                rc = ops->match(&tmp, cur, component);
    605608                if (rc != EOK) {
    606                         async_answer_0(rid, rc);
     609                        async_answer_0(req_handle, rc);
    607610                        goto out;
    608611                }
    … …  
    612615                        rc = ops->node_put(par);
    613616                        if (rc != EOK) {
    614                                 async_answer_0(rid, rc);
     617                                async_answer_0(req_handle, rc);
    615618                                goto out;
    616619                        }
    … …  
    632635
    633636        if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) {
    634                 async_answer_0(rid, EISDIR);
     637                async_answer_0(req_handle, EISDIR);
    635638                goto out;
    636639        }
    637640
    638641        if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) {
    639                 async_answer_0(rid, ENOTDIR);
     642                async_answer_0(req_handle, ENOTDIR);
    640643                goto out;
    641644        }
    … …  
    645648        if (lflag & L_UNLINK) {
    646649                if (!cur) {
    647                         async_answer_0(rid, ENOENT);
     650                        async_answer_0(req_handle, ENOENT);
    648651                        goto out;
    649652                }
    650653                if (!par) {
    651                         async_answer_0(rid, EINVAL);
     654                        async_answer_0(req_handle, EINVAL);
    652655                        goto out;
    653656                }
    … …  
    656659                if (rc == EOK) {
    657660                        aoff64_t size = ops->size_get(cur);
    658                         async_answer_5(rid, EOK, fs_handle,
     661                        async_answer_5(req_handle, EOK, fs_handle,
    659662                            ops->index_get(cur),
    660663                            (ops->is_directory(cur) << 16) | last,
    661664                            LOWER32(size), UPPER32(size));
    662665                } else {
    663                         async_answer_0(rid, rc);
     666                        async_answer_0(req_handle, rc);
    664667                }
    665668                goto out;
    … …  
    670673        if (lflag & L_CREATE) {
    671674                if (cur && (lflag & L_EXCLUSIVE)) {
    672                         async_answer_0(rid, EEXIST);
     675                        async_answer_0(req_handle, EEXIST);
    673676                        goto out;
    674677                }
    … …  
    678681                            lflag & (L_FILE | L_DIRECTORY));
    679682                        if (rc != EOK) {
    680                                 async_answer_0(rid, rc);
     683                                async_answer_0(req_handle, rc);
    681684                                goto out;
    682685                        }
    683686                        if (!cur) {
    684                                 async_answer_0(rid, ENOSPC);
     687                                async_answer_0(req_handle, ENOSPC);
    685688                                goto out;
    686689                        }
    … …  
    690693                                (void) ops->destroy(cur);
    691694                                cur = NULL;
    692                                 async_answer_0(rid, rc);
     695                                async_answer_0(req_handle, rc);
    693696                                goto out;
    694697                        }
    … …  
    699702out1:
    700703        if (!cur) {
    701                 async_answer_5(rid, EOK, fs_handle, ops->index_get(par),
     704                async_answer_5(req_handle, EOK, fs_handle, ops->index_get(par),
    702705                    (ops->is_directory(par) << 16) | last_next,
    703706                    LOWER32(ops->size_get(par)), UPPER32(ops->size_get(par)));
    … …  
    705708        }
    706709
    707         async_answer_5(rid, EOK, fs_handle, ops->index_get(cur),
     710        async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur),
    708711            (ops->is_directory(cur) << 16) | last, LOWER32(ops->size_get(cur)),
    709712            UPPER32(ops->size_get(cur)));
    … …  
    720723}
    721724
    722 void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    723     ipc_call_t *request)
     725void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle,
     726    cap_call_handle_t req_handle, ipc_call_t *request)
    724727{
    725728        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    … …  
    728731        fs_node_t *fn;
    729732        errno_t rc = ops->node_get(&fn, service_id, index);
    730         on_error(rc, answer_and_return(rid, rc));
    731 
    732         ipc_callid_t callid;
     733        on_error(rc, answer_and_return(req_handle, rc));
     734
     735        cap_call_handle_t chandle;
    733736        size_t size;
    734         if ((!async_data_read_receive(&callid, &size)) ||
     737        if ((!async_data_read_receive(&chandle, &size)) ||
    735738            (size != sizeof(vfs_stat_t))) {
    736739                ops->node_put(fn);
    737                 async_answer_0(callid, EINVAL);
    738                 async_answer_0(rid, EINVAL);
     740                async_answer_0(chandle, EINVAL);
     741                async_answer_0(req_handle, EINVAL);
    739742                return;
    740743        }
    … …  
    755758
    756759
    757         async_data_read_finalize(callid, &stat, sizeof(vfs_stat_t));
    758         async_answer_0(rid, EOK);
    759 }
    760 
    761 void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    762     ipc_call_t *request)
     760        async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
     761        async_answer_0(req_handle, EOK);
     762}
     763
     764void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle,
     765    cap_call_handle_t req_handle, ipc_call_t *request)
    763766{
    764767        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    … …  
    767770        fs_node_t *fn;
    768771        errno_t rc = ops->node_get(&fn, service_id, index);
    769         on_error(rc, answer_and_return(rid, rc));
    770 
    771         ipc_callid_t callid;
     772        on_error(rc, answer_and_return(req_handle, rc));
     773
     774        cap_call_handle_t chandle;
    772775        size_t size;
    773         if ((!async_data_read_receive(&callid, &size)) ||
     776        if ((!async_data_read_receive(&chandle, &size)) ||
    774777            (size != sizeof(vfs_statfs_t))) {
    775778                goto error;
    … …  
    800803
    801804        ops->node_put(fn);
    802         async_data_read_finalize(callid, &st, sizeof(vfs_statfs_t));
    803         async_answer_0(rid, EOK);
     805        async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
     806        async_answer_0(req_handle, EOK);
    804807        return;
    805808
    806809error:
    807810        ops->node_put(fn);
    808         async_answer_0(callid, EINVAL);
    809         async_answer_0(rid, EINVAL);
     811        async_answer_0(chandle, EINVAL);
     812        async_answer_0(req_handle, EINVAL);
    810813}
    811814
    … …  
    813816/** Open VFS triplet.
    814817 *
    815  * @param ops     libfs operations structure with function pointers to
    816  *                file system implementation
    817  * @param rid     Request ID of the VFS_OUT_OPEN_NODE request.
    818  * @param request VFS_OUT_OPEN_NODE request data itself.
     818 * @param ops         libfs operations structure with function pointers to
     819 *                    file system implementation
     820 * @param req_handle  Call handle of the VFS_OUT_OPEN_NODE request.
     821 * @param request     VFS_OUT_OPEN_NODE request data itself.
    819822 *
    820823 */
    821 void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    822     ipc_call_t *request)
     824void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle,
     825    cap_call_handle_t req_handle, ipc_call_t *request)
    823826{
    824827        service_id_t service_id = IPC_GET_ARG1(*request);
    … …  
    827830        fs_node_t *fn;
    828831        errno_t rc = ops->node_get(&fn, service_id, index);
    829         on_error(rc, answer_and_return(rid, rc));
     832        on_error(rc, answer_and_return(req_handle, rc));
    830833
    831834        if (fn == NULL) {
    832                 async_answer_0(rid, ENOENT);
     835                async_answer_0(req_handle, ENOENT);
    833836                return;
    834837        }
    … …  
    836839        rc = ops->node_open(fn);
    837840        aoff64_t size = ops->size_get(fn);
    838         async_answer_4(rid, rc, LOWER32(size), UPPER32(size),
     841        async_answer_4(req_handle, rc, LOWER32(size), UPPER32(size),
    839842            ops->lnkcnt_get(fn),
    840843            (ops->is_file(fn) ? L_FILE : 0) |
Note: See TracChangeset for help on using the changeset viewer.