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


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/fs/libfs.c

    r77f0a1d ra35b458  
    5858        ((rc1) == EOK ? (rc2) : (rc1))
    5959
    60 #define answer_and_return(chandle, rc) \
     60#define answer_and_return(rid, rc) \
    6161        do { \
    62                 async_answer_0((chandle), (rc)); \
     62                async_answer_0((rid), (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,
     73static void libfs_link(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    7474    ipc_call_t *);
    75 static void libfs_lookup(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
     75static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    7676    ipc_call_t *);
    77 static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
     77static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
     78static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    7879    ipc_call_t *);
    79 static void libfs_open_node(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
     80static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    8081    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)
     82
     83static void vfs_out_fsprobe(ipc_callid_t rid, ipc_call_t *req)
    8584{
    8685        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    8887        vfs_fs_probe_info_t info;
    8988
    90         cap_call_handle_t chandle;
     89        ipc_callid_t callid;
    9190        size_t size;
    92         if ((!async_data_read_receive(&chandle, &size)) ||
     91        if ((!async_data_read_receive(&callid, &size)) ||
    9392            (size != sizeof(info))) {
    94                 async_answer_0(chandle, EIO);
    95                 async_answer_0(req_handle, EIO);
     93                async_answer_0(callid, EIO);
     94                async_answer_0(rid, EIO);
    9695                return;
    9796        }
    … …  
    10099        rc = vfs_out_ops->fsprobe(service_id, &info);
    101100        if (rc != EOK) {
    102                 async_answer_0(chandle, EIO);
    103                 async_answer_0(req_handle, rc);
     101                async_answer_0(callid, EIO);
     102                async_answer_0(rid, rc);
    104103                return;
    105104        }
    106105
    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)
     106        async_data_read_finalize(callid, &info, sizeof(info));
     107        async_answer_0(rid, EOK);
     108}
     109
     110static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
    112111{
    113112        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    118117        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    119118        if (rc != EOK) {
    120                 async_answer_0(req_handle, rc);
     119                async_answer_0(rid, rc);
    121120                return;
    122121        }
    … …  
    126125        rc = vfs_out_ops->mounted(service_id, opts, &index, &size);
    127126
    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);
     127        if (rc == EOK)
     128                async_answer_3(rid, EOK, index, LOWER32(size), UPPER32(size));
     129        else
     130                async_answer_0(rid, rc);
    133131
    134132        free(opts);
    135133}
    136134
    137 static void vfs_out_unmounted(cap_call_handle_t req_handle, ipc_call_t *req)
     135static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)
    138136{
    139137        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    142140        rc = vfs_out_ops->unmounted(service_id);
    143141
    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)
     142        async_answer_0(rid, rc);
     143}
     144
     145static 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
     150static 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
     155static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req)
    158156{
    159157        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    167165
    168166        if (rc == EOK)
    169                 async_answer_1(req_handle, EOK, rbytes);
     167                async_answer_1(rid, EOK, rbytes);
    170168        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)
     169                async_answer_0(rid, rc);
     170}
     171
     172static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req)
    175173{
    176174        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    185183
    186184        if (rc == EOK) {
    187                 async_answer_3(req_handle, EOK, wbytes, LOWER32(nsize),
     185                async_answer_3(rid, EOK, wbytes, LOWER32(nsize),
    188186                    UPPER32(nsize));
    189187        } 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)
     188                async_answer_0(rid, rc);
     189}
     190
     191static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req)
    194192{
    195193        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    201199        rc = vfs_out_ops->truncate(service_id, index, size);
    202200
    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)
     201        async_answer_0(rid, rc);
     202}
     203
     204static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req)
    207205{
    208206        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    212210        rc = vfs_out_ops->close(service_id, index);
    213211
    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)
     212        async_answer_0(rid, rc);
     213}
     214
     215static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req)
    218216{
    219217        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    229227                        rc = vfs_out_ops->destroy(service_id, index);
    230228        }
    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)
     229        async_answer_0(rid, rc);
     230}
     231
     232static 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
     237static 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
     242static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req)
    245243{
    246244        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    250248        rc = vfs_out_ops->sync(service_id, index);
    251249
    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)
     250        async_answer_0(rid, rc);
     251}
     252
     253static 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
     258static void vfs_out_is_empty(ipc_callid_t rid, ipc_call_t *req)
    261259{
    262260        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    … …  
    267265        rc = libfs_ops->node_get(&node, service_id, index);
    268266        if (rc != EOK)
    269                 async_answer_0(req_handle, rc);
     267                async_answer_0(rid, rc);
    270268        if (node == NULL)
    271                 async_answer_0(req_handle, EINVAL);
     269                async_answer_0(rid, EINVAL);
    272270
    273271        bool children = false;
    … …  
    276274
    277275        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) {
     276                async_answer_0(rid, rc);
     277        async_answer_0(rid, children ? ENOTEMPTY : EOK);
     278}
     279
     280static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     281{
     282        if (iid) {
    286283                /*
    287284                 * This only happens for connections opened by
    … …  
    289286                 * created by IPC_M_CONNECT_TO_ME.
    290287                 */
    291                 async_answer_0(icall_handle, EOK);
     288                async_answer_0(iid, EOK);
    292289        }
    293290
    294291        while (true) {
    295292                ipc_call_t call;
    296                 cap_call_handle_t chandle = async_get_call(&call);
     293                ipc_callid_t callid = async_get_call(&call);
    297294
    298295                if (!IPC_GET_IMETHOD(call))
    … …  
    301298                switch (IPC_GET_IMETHOD(call)) {
    302299                case VFS_OUT_FSPROBE:
    303                         vfs_out_fsprobe(chandle, &call);
     300                        vfs_out_fsprobe(callid, &call);
    304301                        break;
    305302                case VFS_OUT_MOUNTED:
    306                         vfs_out_mounted(chandle, &call);
     303                        vfs_out_mounted(callid, &call);
    307304                        break;
    308305                case VFS_OUT_UNMOUNTED:
    309                         vfs_out_unmounted(chandle, &call);
     306                        vfs_out_unmounted(callid, &call);
    310307                        break;
    311308                case VFS_OUT_LINK:
    312                         vfs_out_link(chandle, &call);
     309                        vfs_out_link(callid, &call);
    313310                        break;
    314311                case VFS_OUT_LOOKUP:
    315                         vfs_out_lookup(chandle, &call);
     312                        vfs_out_lookup(callid, &call);
    316313                        break;
    317314                case VFS_OUT_READ:
    318                         vfs_out_read(chandle, &call);
     315                        vfs_out_read(callid, &call);
    319316                        break;
    320317                case VFS_OUT_WRITE:
    321                         vfs_out_write(chandle, &call);
     318                        vfs_out_write(callid, &call);
    322319                        break;
    323320                case VFS_OUT_TRUNCATE:
    324                         vfs_out_truncate(chandle, &call);
     321                        vfs_out_truncate(callid, &call);
    325322                        break;
    326323                case VFS_OUT_CLOSE:
    327                         vfs_out_close(chandle, &call);
     324                        vfs_out_close(callid, &call);
    328325                        break;
    329326                case VFS_OUT_DESTROY:
    330                         vfs_out_destroy(chandle, &call);
     327                        vfs_out_destroy(callid, &call);
    331328                        break;
    332329                case VFS_OUT_OPEN_NODE:
    333                         vfs_out_open_node(chandle, &call);
     330                        vfs_out_open_node(callid, &call);
    334331                        break;
    335332                case VFS_OUT_STAT:
    336                         vfs_out_stat(chandle, &call);
     333                        vfs_out_stat(callid, &call);
    337334                        break;
    338335                case VFS_OUT_SYNC:
    339                         vfs_out_sync(chandle, &call);
     336                        vfs_out_sync(callid, &call);
    340337                        break;
    341338                case VFS_OUT_STATFS:
    342                         vfs_out_statfs(chandle, &call);
     339                        vfs_out_statfs(callid, &call);
    343340                        break;
    344341                case VFS_OUT_IS_EMPTY:
    345                         vfs_out_is_empty(chandle, &call);
     342                        vfs_out_is_empty(callid, &call);
    346343                        break;
    347344                default:
    348                         async_answer_0(chandle, ENOTSUP);
     345                        async_answer_0(callid, ENOTSUP);
    349346                        break;
    350347                }
    … …  
    482479{
    483480        size_t size;
    484         cap_call_handle_t wcall;
     481        ipc_callid_t wcall;
    485482
    486483        if (!async_data_write_receive(&wcall, &size))
    … …  
    495492/** Link a file at a path.
    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_callid_t rid,
     495    ipc_call_t *req)
    499496{
    500497        service_id_t parent_sid = IPC_GET_ARG1(*req);
    … …  
    505502        errno_t rc = receive_fname(component);
    506503        if (rc != EOK) {
    507                 async_answer_0(req_handle, rc);
     504                async_answer_0(rid, rc);
    508505                return;
    509506        }
    … …  
    512509        rc = ops->node_get(&parent, parent_sid, parent_index);
    513510        if (parent == NULL) {
    514                 async_answer_0(req_handle, rc == EOK ? EBADF : rc);
     511                async_answer_0(rid, rc == EOK ? EBADF : rc);
    515512                return;
    516513        }
    … …  
    519516        rc = ops->node_get(&child, parent_sid, child_index);
    520517        if (child == NULL) {
    521                 async_answer_0(req_handle, rc == EOK ? EBADF : rc);
     518                async_answer_0(rid, rc == EOK ? EBADF : rc);
    522519                ops->node_put(parent);
    523520                return;
    … …  
    527524        ops->node_put(parent);
    528525        ops->node_put(child);
    529         async_answer_0(req_handle, rc);
     526        async_answer_0(rid, rc);
    530527}
    531528
    … …  
    535532 * as returned by the canonify() function.
    536533 *
    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.
     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.
    543540 *
    544541 */
    545 void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle,
    546     cap_call_handle_t req_handle, ipc_call_t *req)
     542void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     543    ipc_call_t *req)
    547544{
    548545        unsigned first = IPC_GET_ARG1(*req);
    … …  
    567564        rc = ops->node_get(&cur, service_id, index);
    568565        if (rc != EOK) {
    569                 async_answer_0(req_handle, rc);
     566                async_answer_0(rid, rc);
    570567                goto out;
    571568        }
    … …  
    584581
    585582                if (!ops->is_directory(cur)) {
    586                         async_answer_0(req_handle, ENOTDIR);
     583                        async_answer_0(rid, ENOTDIR);
    587584                        goto out;
    588585                }
    … …  
    593590                assert(rc != ERANGE);
    594591                if (rc != EOK) {
    595                         async_answer_0(req_handle, rc);
     592                        async_answer_0(rid, rc);
    596593                        goto out;
    597594                }
    … …  
    607604                rc = ops->match(&tmp, cur, component);
    608605                if (rc != EOK) {
    609                         async_answer_0(req_handle, rc);
     606                        async_answer_0(rid, rc);
    610607                        goto out;
    611608                }
    … …  
    615612                        rc = ops->node_put(par);
    616613                        if (rc != EOK) {
    617                                 async_answer_0(req_handle, rc);
     614                                async_answer_0(rid, rc);
    618615                                goto out;
    619616                        }
    … …  
    635632
    636633        if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) {
    637                 async_answer_0(req_handle, EISDIR);
     634                async_answer_0(rid, EISDIR);
    638635                goto out;
    639636        }
    640637
    641638        if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) {
    642                 async_answer_0(req_handle, ENOTDIR);
     639                async_answer_0(rid, ENOTDIR);
    643640                goto out;
    644641        }
    … …  
    648645        if (lflag & L_UNLINK) {
    649646                if (!cur) {
    650                         async_answer_0(req_handle, ENOENT);
     647                        async_answer_0(rid, ENOENT);
    651648                        goto out;
    652649                }
    653650                if (!par) {
    654                         async_answer_0(req_handle, EINVAL);
     651                        async_answer_0(rid, EINVAL);
    655652                        goto out;
    656653                }
    … …  
    659656                if (rc == EOK) {
    660657                        aoff64_t size = ops->size_get(cur);
    661                         async_answer_5(req_handle, EOK, fs_handle,
     658                        async_answer_5(rid, EOK, fs_handle,
    662659                            ops->index_get(cur),
    663660                            (ops->is_directory(cur) << 16) | last,
    664661                            LOWER32(size), UPPER32(size));
    665662                } else {
    666                         async_answer_0(req_handle, rc);
     663                        async_answer_0(rid, rc);
    667664                }
    668665                goto out;
    … …  
    673670        if (lflag & L_CREATE) {
    674671                if (cur && (lflag & L_EXCLUSIVE)) {
    675                         async_answer_0(req_handle, EEXIST);
     672                        async_answer_0(rid, EEXIST);
    676673                        goto out;
    677674                }
    … …  
    681678                            lflag & (L_FILE | L_DIRECTORY));
    682679                        if (rc != EOK) {
    683                                 async_answer_0(req_handle, rc);
     680                                async_answer_0(rid, rc);
    684681                                goto out;
    685682                        }
    686683                        if (!cur) {
    687                                 async_answer_0(req_handle, ENOSPC);
     684                                async_answer_0(rid, ENOSPC);
    688685                                goto out;
    689686                        }
    … …  
    693690                                (void) ops->destroy(cur);
    694691                                cur = NULL;
    695                                 async_answer_0(req_handle, rc);
     692                                async_answer_0(rid, rc);
    696693                                goto out;
    697694                        }
    … …  
    702699out1:
    703700        if (!cur) {
    704                 async_answer_5(req_handle, EOK, fs_handle, ops->index_get(par),
     701                async_answer_5(rid, EOK, fs_handle, ops->index_get(par),
    705702                    (ops->is_directory(par) << 16) | last_next,
    706703                    LOWER32(ops->size_get(par)), UPPER32(ops->size_get(par)));
    … …  
    708705        }
    709706
    710         async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur),
     707        async_answer_5(rid, EOK, fs_handle, ops->index_get(cur),
    711708            (ops->is_directory(cur) << 16) | last, LOWER32(ops->size_get(cur)),
    712709            UPPER32(ops->size_get(cur)));
    … …  
    723720}
    724721
    725 void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle,
    726     cap_call_handle_t req_handle, ipc_call_t *request)
     722void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     723    ipc_call_t *request)
    727724{
    728725        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    … …  
    731728        fs_node_t *fn;
    732729        errno_t rc = ops->node_get(&fn, service_id, index);
    733         on_error(rc, answer_and_return(req_handle, rc));
    734 
    735         cap_call_handle_t chandle;
     730        on_error(rc, answer_and_return(rid, rc));
     731
     732        ipc_callid_t callid;
    736733        size_t size;
    737         if ((!async_data_read_receive(&chandle, &size)) ||
     734        if ((!async_data_read_receive(&callid, &size)) ||
    738735            (size != sizeof(vfs_stat_t))) {
    739736                ops->node_put(fn);
    740                 async_answer_0(chandle, EINVAL);
    741                 async_answer_0(req_handle, EINVAL);
     737                async_answer_0(callid, EINVAL);
     738                async_answer_0(rid, EINVAL);
    742739                return;
    743740        }
    … …  
    758755
    759756
    760         async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
    761         async_answer_0(req_handle, EOK);
    762 }
    763 
    764 void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle,
    765     cap_call_handle_t req_handle, ipc_call_t *request)
     757        async_data_read_finalize(callid, &stat, sizeof(vfs_stat_t));
     758        async_answer_0(rid, EOK);
     759}
     760
     761void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     762    ipc_call_t *request)
    766763{
    767764        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    … …  
    770767        fs_node_t *fn;
    771768        errno_t rc = ops->node_get(&fn, service_id, index);
    772         on_error(rc, answer_and_return(req_handle, rc));
    773 
    774         cap_call_handle_t chandle;
     769        on_error(rc, answer_and_return(rid, rc));
     770
     771        ipc_callid_t callid;
    775772        size_t size;
    776         if ((!async_data_read_receive(&chandle, &size)) ||
     773        if ((!async_data_read_receive(&callid, &size)) ||
    777774            (size != sizeof(vfs_statfs_t))) {
    778775                goto error;
    … …  
    803800
    804801        ops->node_put(fn);
    805         async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
    806         async_answer_0(req_handle, EOK);
     802        async_data_read_finalize(callid, &st, sizeof(vfs_statfs_t));
     803        async_answer_0(rid, EOK);
    807804        return;
    808805
    809806error:
    810807        ops->node_put(fn);
    811         async_answer_0(chandle, EINVAL);
    812         async_answer_0(req_handle, EINVAL);
     808        async_answer_0(callid, EINVAL);
     809        async_answer_0(rid, EINVAL);
    813810}
    814811
    … …  
    816813/** Open VFS triplet.
    817814 *
    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.
     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.
    822819 *
    823820 */
    824 void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle,
    825     cap_call_handle_t req_handle, ipc_call_t *request)
     821void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     822    ipc_call_t *request)
    826823{
    827824        service_id_t service_id = IPC_GET_ARG1(*request);
    … …  
    830827        fs_node_t *fn;
    831828        errno_t rc = ops->node_get(&fn, service_id, index);
    832         on_error(rc, answer_and_return(req_handle, rc));
     829        on_error(rc, answer_and_return(rid, rc));
    833830
    834831        if (fn == NULL) {
    835                 async_answer_0(req_handle, ENOENT);
     832                async_answer_0(rid, ENOENT);
    836833                return;
    837834        }
    … …  
    839836        rc = ops->node_open(fn);
    840837        aoff64_t size = ops->size_get(fn);
    841         async_answer_4(req_handle, rc, LOWER32(size), UPPER32(size),
     838        async_answer_4(rid, rc, LOWER32(size), UPPER32(size),
    842839            ops->lnkcnt_get(fn),
    843840            (ops->is_file(fn) ? L_FILE : 0) |
Note: See TracChangeset for help on using the changeset viewer.