Changeset 77f0a1d in mainline


Ignore:
Timestamp:
2018-03-22T22:54:52Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
eed4139
Parents:
a46e56b
Message:

Get rid of rid in favor of req_handle

Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/fs/libfs.c

    ra46e56b 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)
    … …  
    7575static 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, cap_call_handle_t, ipc_call_t *);
     77static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
     78    ipc_call_t *);
    7879static void libfs_open_node(libfs_ops_t *, fs_handle_t, cap_call_handle_t,
    7980    ipc_call_t *);
    … …  
    8182    ipc_call_t *);
    8283
    83 static void vfs_out_fsprobe(cap_call_handle_t rid, ipc_call_t *req)
     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);
    … …  
    9293            (size != sizeof(info))) {
    9394                async_answer_0(chandle, EIO);
    94                 async_answer_0(rid, EIO);
     95                async_answer_0(req_handle, EIO);
    9596                return;
    9697        }
    … …  
    100101        if (rc != EOK) {
    101102                async_answer_0(chandle, EIO);
    102                 async_answer_0(rid, rc);
     103                async_answer_0(req_handle, rc);
    103104                return;
    104105        }
    105106
    106107        async_data_read_finalize(chandle, &info, sizeof(info));
    107         async_answer_0(rid, EOK);
    108 }
    109 
    110 static void vfs_out_mounted(cap_call_handle_t rid, ipc_call_t *req)
     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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_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(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     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)
    281284{
    282285        if (icall_handle) {
    … …  
    492495/** Link a file at a path.
    493496 */
    494 void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_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, cap_call_handle_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, cap_call_handle_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));
     733        on_error(rc, answer_and_return(req_handle, rc));
    731734
    732735        cap_call_handle_t chandle;
    … …  
    736739                ops->node_put(fn);
    737740                async_answer_0(chandle, EINVAL);
    738                 async_answer_0(rid, EINVAL);
     741                async_answer_0(req_handle, EINVAL);
    739742                return;
    740743        }
    … …  
    756759
    757760        async_data_read_finalize(chandle, &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, cap_call_handle_t rid,
    762     ipc_call_t *request)
     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));
     772        on_error(rc, answer_and_return(req_handle, rc));
    770773
    771774        cap_call_handle_t chandle;
    … …  
    801804        ops->node_put(fn);
    802805        async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
    803         async_answer_0(rid, EOK);
     806        async_answer_0(req_handle, EOK);
    804807        return;
    805808
    … …  
    807810        ops->node_put(fn);
    808811        async_answer_0(chandle, EINVAL);
    809         async_answer_0(rid, 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, cap_call_handle_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) |

  • uspace/srv/clipboard/clipboard.c

    ra46e56b r77f0a1d  
    4747static service_id_t svc_id;
    4848
    49 static void clip_put_data(cap_call_handle_t rid, ipc_call_t *request)
     49static void clip_put_data(cap_call_handle_t req_handle, ipc_call_t *request)
    5050{
    5151        char *data;
    … …  
    6565
    6666                fibril_mutex_unlock(&clip_mtx);
    67                 async_answer_0(rid, EOK);
     67                async_answer_0(req_handle, EOK);
    6868                break;
    6969        case CLIPBOARD_TAG_DATA:
    7070                rc = async_data_write_accept((void **) &data, false, 0, 0, 0, &size);
    7171                if (rc != EOK) {
    72                         async_answer_0(rid, rc);
     72                        async_answer_0(req_handle, rc);
    7373                        break;
    7474                }
    … …  
    8484
    8585                fibril_mutex_unlock(&clip_mtx);
    86                 async_answer_0(rid, EOK);
     86                async_answer_0(req_handle, EOK);
    8787                break;
    8888        default:
    89                 async_answer_0(rid, EINVAL);
    90         }
    91 }
    92 
    93 static void clip_get_data(cap_call_handle_t rid, ipc_call_t *request)
     89                async_answer_0(req_handle, EINVAL);
     90        }
     91}
     92
     93static void clip_get_data(cap_call_handle_t req_handle, ipc_call_t *request)
    9494{
    9595        fibril_mutex_lock(&clip_mtx);
    … …  
    103103                if (!async_data_read_receive(&chandle, &size)) {
    104104                        async_answer_0(chandle, EINVAL);
    105                         async_answer_0(rid, EINVAL);
     105                        async_answer_0(req_handle, EINVAL);
    106106                        break;
    107107                }
    … …  
    110110                        /* So far we only understand binary data */
    111111                        async_answer_0(chandle, EOVERFLOW);
    112                         async_answer_0(rid, EOVERFLOW);
     112                        async_answer_0(req_handle, EOVERFLOW);
    113113                        break;
    114114                }
    … …  
    117117                        /* The client expects different size of data */
    118118                        async_answer_0(chandle, EOVERFLOW);
    119                         async_answer_0(rid, EOVERFLOW);
     119                        async_answer_0(req_handle, EOVERFLOW);
    120120                        break;
    121121                }
    … …  
    123123                errno_t retval = async_data_read_finalize(chandle, clip_data, size);
    124124                if (retval != EOK) {
    125                         async_answer_0(rid, retval);
    126                         break;
    127                 }
    128 
    129                 async_answer_0(rid, EOK);
     125                        async_answer_0(req_handle, retval);
     126                        break;
     127                }
     128
     129                async_answer_0(req_handle, EOK);
    130130                break;
    131131        default:
    … …  
    134134                 * data from the clipbard
    135135                 */
    136                 async_answer_0(rid, EINVAL);
     136                async_answer_0(req_handle, EINVAL);
    137137                break;
    138138        }
    … …  
    141141}
    142142
    143 static void clip_content(cap_call_handle_t rid, ipc_call_t *request)
     143static void clip_content(cap_call_handle_t req_handle, ipc_call_t *request)
    144144{
    145145        fibril_mutex_lock(&clip_mtx);
    … …  
    149149
    150150        fibril_mutex_unlock(&clip_mtx);
    151         async_answer_2(rid, EOK, (sysarg_t) size, (sysarg_t) tag);
    152 }
    153 
    154 static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     151        async_answer_2(req_handle, EOK, (sysarg_t) size, (sysarg_t) tag);
     152}
     153
     154static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     155    void *arg)
    155156{
    156157        /* Accept connection */

  • uspace/srv/loader/main.c

    ra46e56b r77f0a1d  
    9090static bool connected = false;
    9191
    92 static void ldr_get_taskid(cap_call_handle_t rid, ipc_call_t *request)
     92static void ldr_get_taskid(cap_call_handle_t req_handle, ipc_call_t *request)
    9393{
    9494        cap_call_handle_t chandle;
    … …  
    100100        if (!async_data_read_receive(&chandle, &len)) {
    101101                async_answer_0(chandle, EINVAL);
    102                 async_answer_0(rid, EINVAL);
     102                async_answer_0(req_handle, EINVAL);
    103103                return;
    104104        }
    … …  
    108108
    109109        async_data_read_finalize(chandle, &task_id, len);
    110         async_answer_0(rid, EOK);
     110        async_answer_0(req_handle, EOK);
    111111}
    112112
    113113/** Receive a call setting the current working directory.
    114114 *
    115  * @param rid
    116  * @param request
    117  */
    118 static void ldr_set_cwd(cap_call_handle_t rid, ipc_call_t *request)
     115 * @param req_handle
     116 * @param request
     117 */
     118static void ldr_set_cwd(cap_call_handle_t req_handle, ipc_call_t *request)
    119119{
    120120        char *buf;
    … …  
    128128        }
    129129
    130         async_answer_0(rid, rc);
     130        async_answer_0(req_handle, rc);
    131131}
    132132
    133133/** Receive a call setting the program to execute.
    134134 *
    135  * @param rid
    136  * @param request
    137  */
    138 static void ldr_set_program(cap_call_handle_t rid, ipc_call_t *request)
     135 * @param req_handle
     136 * @param request
     137 */
     138static void ldr_set_program(cap_call_handle_t req_handle, ipc_call_t *request)
    139139{
    140140        cap_call_handle_t write_chandle;
    141141        size_t namesize;
    142142        if (!async_data_write_receive(&write_chandle, &namesize)) {
    143                 async_answer_0(rid, EINVAL);
     143                async_answer_0(req_handle, EINVAL);
    144144                return;
    145145        }
    … …  
    148148        errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
    149149        if (rc != EOK) {
    150                 async_answer_0(rid, EINVAL);
     150                async_answer_0(req_handle, EINVAL);
    151151                return;
    152152        }
    … …  
    155155        rc = vfs_receive_handle(true, &file);
    156156        if (rc != EOK) {
    157                 async_answer_0(rid, EINVAL);
     157                async_answer_0(req_handle, EINVAL);
    158158                return;
    159159        }
    … …  
    161161        progname = name;
    162162        program_fd = file;
    163         async_answer_0(rid, EOK);
     163        async_answer_0(req_handle, EOK);
    164164}
    165165
    166166/** Receive a call setting arguments of the program to execute.
    167167 *
    168  * @param rid
    169  * @param request
    170  */
    171 static void ldr_set_args(cap_call_handle_t rid, ipc_call_t *request)
     168 * @param req_handle
     169 * @param request
     170 */
     171static void ldr_set_args(cap_call_handle_t req_handle, ipc_call_t *request)
    172172{
    173173        char *buf;
    … …  
    194194                if (_argv == NULL) {
    195195                        free(buf);
    196                         async_answer_0(rid, ENOMEM);
     196                        async_answer_0(req_handle, ENOMEM);
    197197                        return;
    198198                }
    … …  
    226226        }
    227227
    228         async_answer_0(rid, rc);
     228        async_answer_0(req_handle, rc);
    229229}
    230230
    231231/** Receive a call setting inbox files of the program to execute.
    232232 *
    233  * @param rid
    234  * @param request
    235  */
    236 static void ldr_add_inbox(cap_call_handle_t rid, ipc_call_t *request)
     233 * @param req_handle
     234 * @param request
     235 */
     236static void ldr_add_inbox(cap_call_handle_t req_handle, ipc_call_t *request)
    237237{
    238238        if (inbox_entries == INBOX_MAX_ENTRIES) {
    239                 async_answer_0(rid, ERANGE);
     239                async_answer_0(req_handle, ERANGE);
    240240                return;
    241241        }
    … …  
    244244        size_t namesize;
    245245        if (!async_data_write_receive(&write_chandle, &namesize)) {
    246                 async_answer_0(rid, EINVAL);
     246                async_answer_0(req_handle, EINVAL);
    247247                return;
    248248        }
    … …  
    251251        errno_t rc = async_data_write_finalize(write_chandle, name, namesize);
    252252        if (rc != EOK) {
    253                 async_answer_0(rid, EINVAL);
     253                async_answer_0(req_handle, EINVAL);
    254254                return;
    255255        }
    … …  
    258258        rc = vfs_receive_handle(true, &file);
    259259        if (rc != EOK) {
    260                 async_answer_0(rid, EINVAL);
     260                async_answer_0(req_handle, EINVAL);
    261261                return;
    262262        }
    … …  
    272272        inbox[inbox_entries].file = file;
    273273        inbox_entries++;
    274         async_answer_0(rid, EOK);
     274        async_answer_0(req_handle, EOK);
    275275}
    276276
    277277/** Load the previously selected program.
    278278 *
    279  * @param rid
     279 * @param req_handle
    280280 * @param request
    281281 * @return 0 on success, !0 on error.
    282282 */
    283 static int ldr_load(cap_call_handle_t rid, ipc_call_t *request)
     283static int ldr_load(cap_call_handle_t req_handle, ipc_call_t *request)
    284284{
    285285        int rc = elf_load(program_fd, &prog_info);
    286286        if (rc != EE_OK) {
    287287                DPRINTF("Failed to load executable for '%s'.\n", progname);
    288                 async_answer_0(rid, EINVAL);
     288                async_answer_0(req_handle, EINVAL);
    289289                return 1;
    290290        }
    … …  
    300300        pcb.inbox_entries = inbox_entries;
    301301
    302         async_answer_0(rid, EOK);
     302        async_answer_0(req_handle, EOK);
    303303        return 0;
    304304}
    … …  
    306306/** Run the previously loaded program.
    307307 *
    308  * @param rid
     308 * @param req_handle
    309309 * @param request
    310310 * @return 0 on success, !0 on error.
    311311 */
    312 static __attribute__((noreturn)) void ldr_run(cap_call_handle_t rid,
     312static __attribute__((noreturn)) void ldr_run(cap_call_handle_t req_handle,
    313313    ipc_call_t *request)
    314314{
    … …  
    320320        /* Run program */
    321321        DPRINTF("Reply OK\n");
    322         async_answer_0(rid, EOK);
     322        async_answer_0(req_handle, EOK);
    323323        DPRINTF("Jump to entry point at %p\n", pcb.entry);
    324324        entry_point_jmp(prog_info.finfo.entry, &pcb);
    … …  
    332332 * to execute the loaded program).
    333333 */
    334 static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
     334static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall,
     335    void *arg)
    335336{
    336337        /* Already have a connection? */

  • uspace/srv/vfs/vfs_ipc.c

    ra46e56b r77f0a1d  
    3535#include <vfs/canonify.h>
    3636
    37 static void vfs_in_clone(cap_call_handle_t rid, ipc_call_t *request)
     37static void vfs_in_clone(cap_call_handle_t req_handle, ipc_call_t *request)
    3838{
    3939        int oldfd = IPC_GET_ARG1(*request);
    … …  
    4343        int outfd = -1;
    4444        errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd);
    45         async_answer_1(rid, rc, outfd);
    46 }
    47 
    48 static void vfs_in_fsprobe(cap_call_handle_t rid, ipc_call_t *request)
     45        async_answer_1(req_handle, rc, outfd);
     46}
     47
     48static void vfs_in_fsprobe(cap_call_handle_t req_handle, ipc_call_t *request)
    4949{
    5050        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    … …  
    6262            FS_NAME_MAXLEN, 0, NULL);
    6363        if (rc != EOK) {
    64                 async_answer_0(rid, rc);
     64                async_answer_0(req_handle, rc);
    6565                return;
    6666        }
    6767
    6868        rc = vfs_op_fsprobe(fs_name, service_id, &info);
    69         async_answer_0(rid, rc);
     69        async_answer_0(req_handle, rc);
    7070        if (rc != EOK)
    7171                goto out;
    … …  
    8383}
    8484
    85 static void vfs_in_fstypes(cap_call_handle_t rid, ipc_call_t *request)
     85static void vfs_in_fstypes(cap_call_handle_t req_handle, ipc_call_t *request)
    8686{
    8787        cap_call_handle_t chandle;
    … …  
    9292        rc = vfs_get_fstypes(&fstypes);
    9393        if (rc != EOK) {
    94                 async_answer_0(rid, ENOMEM);
     94                async_answer_0(req_handle, ENOMEM);
    9595                return;
    9696        }
    9797
    9898        /* Send size of the data */
    99         async_answer_1(rid, EOK, fstypes.size);
     99        async_answer_1(req_handle, EOK, fstypes.size);
    100100
    101101        /* Now we should get a read request */
    … …  
    111111}
    112112
    113 static void vfs_in_mount(cap_call_handle_t rid, ipc_call_t *request)
     113static void vfs_in_mount(cap_call_handle_t req_handle, ipc_call_t *request)
    114114{
    115115        int mpfd = IPC_GET_ARG1(*request);
    … …  
    132132            MAX_MNTOPTS_LEN, 0, NULL);
    133133        if (rc != EOK) {
    134                 async_answer_0(rid, rc);
     134                async_answer_0(req_handle, rc);
    135135                return;
    136136        }
    … …  
    143143        if (rc != EOK) {
    144144                free(opts);
    145                 async_answer_0(rid, rc);
     145                async_answer_0(req_handle, rc);
    146146                return;
    147147        }
    … …  
    150150        rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name,
    151151             &outfd);
    152         async_answer_1(rid, rc, outfd);
     152        async_answer_1(req_handle, rc, outfd);
    153153
    154154        free(opts);
    … …  
    156156}
    157157
    158 static void vfs_in_open(cap_call_handle_t rid, ipc_call_t *request)
     158static void vfs_in_open(cap_call_handle_t req_handle, ipc_call_t *request)
    159159{
    160160        int fd = IPC_GET_ARG1(*request);
    … …  
    162162
    163163        errno_t rc = vfs_op_open(fd, mode);
    164         async_answer_0(rid, rc);
    165 }
    166 
    167 static void vfs_in_put(cap_call_handle_t rid, ipc_call_t *request)
     164        async_answer_0(req_handle, rc);
     165}
     166
     167static void vfs_in_put(cap_call_handle_t req_handle, ipc_call_t *request)
    168168{
    169169        int fd = IPC_GET_ARG1(*request);
    170170        errno_t rc = vfs_op_put(fd);
    171         async_answer_0(rid, rc);
    172 }
    173 
    174 static void vfs_in_read(cap_call_handle_t rid, ipc_call_t *request)
     171        async_answer_0(req_handle, rc);
     172}
     173
     174static void vfs_in_read(cap_call_handle_t req_handle, ipc_call_t *request)
    175175{
    176176        int fd = IPC_GET_ARG1(*request);
    … …  
    180180        size_t bytes = 0;
    181181        errno_t rc = vfs_op_read(fd, pos, &bytes);
    182         async_answer_1(rid, rc, bytes);
    183 }
    184 
    185 static void vfs_in_rename(cap_call_handle_t rid, ipc_call_t *request)
     182        async_answer_1(req_handle, rc, bytes);
     183}
     184
     185static void vfs_in_rename(cap_call_handle_t req_handle, ipc_call_t *request)
    186186{
    187187        /* The common base directory. */
    … …  
    219219
    220220out:
    221         async_answer_0(rid, rc);
     221        async_answer_0(req_handle, rc);
    222222
    223223        if (old)
    … …  
    227227}
    228228
    229 static void vfs_in_resize(cap_call_handle_t rid, ipc_call_t *request)
     229static void vfs_in_resize(cap_call_handle_t req_handle, ipc_call_t *request)
    230230{
    231231        int fd = IPC_GET_ARG1(*request);
    232232        int64_t size = MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
    233233        errno_t rc = vfs_op_resize(fd, size);
    234         async_answer_0(rid, rc);
    235 }
    236 
    237 static void vfs_in_stat(cap_call_handle_t rid, ipc_call_t *request)
     234        async_answer_0(req_handle, rc);
     235}
     236
     237static void vfs_in_stat(cap_call_handle_t req_handle, ipc_call_t *request)
    238238{
    239239        int fd = IPC_GET_ARG1(*request);
    240240        errno_t rc = vfs_op_stat(fd);
    241         async_answer_0(rid, rc);
    242 }
    243 
    244 static void vfs_in_statfs(cap_call_handle_t rid, ipc_call_t *request)
     241        async_answer_0(req_handle, rc);
     242}
     243
     244static void vfs_in_statfs(cap_call_handle_t req_handle, ipc_call_t *request)
    245245{
    246246        int fd = (int) IPC_GET_ARG1(*request);
    247247
    248248        errno_t rc = vfs_op_statfs(fd);
    249         async_answer_0(rid, rc);
    250 }
    251 
    252 static void vfs_in_sync(cap_call_handle_t rid, ipc_call_t *request)
     249        async_answer_0(req_handle, rc);
     250}
     251
     252static void vfs_in_sync(cap_call_handle_t req_handle, ipc_call_t *request)
    253253{
    254254        int fd = IPC_GET_ARG1(*request);
    255255        errno_t rc = vfs_op_sync(fd);
    256         async_answer_0(rid, rc);
    257 }
    258 
    259 static void vfs_in_unlink(cap_call_handle_t rid, ipc_call_t *request)
     256        async_answer_0(req_handle, rc);
     257}
     258
     259static void vfs_in_unlink(cap_call_handle_t req_handle, ipc_call_t *request)
    260260{
    261261        int parentfd = IPC_GET_ARG1(*request);
    … …  
    267267                rc = vfs_op_unlink(parentfd, expectfd, path);
    268268
    269         async_answer_0(rid, rc);
    270 }
    271 
    272 static void vfs_in_unmount(cap_call_handle_t rid, ipc_call_t *request)
     269        async_answer_0(req_handle, rc);
     270}
     271
     272static void vfs_in_unmount(cap_call_handle_t req_handle, ipc_call_t *request)
    273273{
    274274        int mpfd = IPC_GET_ARG1(*request);
    275275        errno_t rc = vfs_op_unmount(mpfd);
    276         async_answer_0(rid, rc);
    277 }
    278 
    279 static void vfs_in_wait_handle(cap_call_handle_t rid, ipc_call_t *request)
     276        async_answer_0(req_handle, rc);
     277}
     278
     279static void vfs_in_wait_handle(cap_call_handle_t req_handle, ipc_call_t *request)
    280280{
    281281        bool high_fd = IPC_GET_ARG1(*request);
    282282        int fd = -1;
    283283        errno_t rc = vfs_op_wait_handle(high_fd, &fd);
    284         async_answer_1(rid, rc, fd);
    285 }
    286 
    287 static void vfs_in_walk(cap_call_handle_t rid, ipc_call_t *request)
     284        async_answer_1(req_handle, rc, fd);
     285}
     286
     287static void vfs_in_walk(cap_call_handle_t req_handle, ipc_call_t *request)
    288288{
    289289        /*
    … …  
    301301                free(path);
    302302        }
    303         async_answer_1(rid, rc, fd);
    304 }
    305 
    306 static void vfs_in_write(cap_call_handle_t rid, ipc_call_t *request)
     303        async_answer_1(req_handle, rc, fd);
     304}
     305
     306static void vfs_in_write(cap_call_handle_t req_handle, ipc_call_t *request)
    307307{
    308308        int fd = IPC_GET_ARG1(*request);
    … …  
    312312        size_t bytes = 0;
    313313        errno_t rc = vfs_op_write(fd, pos, &bytes);
    314         async_answer_1(rid, rc, bytes);
     314        async_answer_1(req_handle, rc, bytes);
    315315}
    316316

  • uspace/srv/vfs/vfs_pager.c

    ra46e56b r77f0a1d  
    4242#include <as.h>
    4343
    44 void vfs_page_in(cap_call_handle_t rid, ipc_call_t *request)
     44void vfs_page_in(cap_call_handle_t req_handle, ipc_call_t *request)
    4545{
    4646        aoff64_t offset = IPC_GET_ARG1(*request);
    … …  
    5555
    5656        if (page == AS_MAP_FAILED) {
    57                 async_answer_0(rid, ENOMEM);
     57                async_answer_0(req_handle, ENOMEM);
    5858                return;
    5959        }
    … …  
    7878        } while (total < page_size);
    7979
    80         async_answer_1(rid, rc, (sysarg_t) page);
     80        async_answer_1(req_handle, rc, (sysarg_t) page);
    8181
    8282        /*

  • uspace/srv/vfs/vfs_register.c

    ra46e56b r77f0a1d  
    108108/** VFS_REGISTER protocol function.
    109109 *
    110  * @param rid     Hash of the call with the request.
    111  * @param request Call structure with the request.
    112  *
    113  */
    114 void vfs_register(cap_call_handle_t rid, ipc_call_t *request)
     110 * @param req_handle  Call handle of the request.
     111 * @param request     Call structure with the request.
     112 *
     113 */
     114void vfs_register(cap_call_handle_t req_handle, ipc_call_t *request)
    115115{
    116116        dprintf("Processing VFS_REGISTER request received from %zx.\n",
    … …  
    124124                dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
    125125                    rc);
    126                 async_answer_0(rid, rc);
     126                async_answer_0(req_handle, rc);
    127127                return;
    128128        }
    … …  
    134134        if (!fs_info) {
    135135                dprintf("Could not allocate memory for FS info.\n");
    136                 async_answer_0(rid, ENOMEM);
     136                async_answer_0(req_handle, ENOMEM);
    137137                return;
    138138        }
    … …  
    146146        if (!vfs_info_sane(&fs_info->vfs_info)) {
    147147                free(fs_info);
    148                 async_answer_0(rid, EINVAL);
     148                async_answer_0(req_handle, EINVAL);
    149149                return;
    150150        }
    … …  
    163163                fibril_mutex_unlock(&fs_list_lock);
    164164                free(fs_info);
    165                 async_answer_0(rid, EEXIST);
     165                async_answer_0(req_handle, EEXIST);
    166166                return;
    167167        }
    … …  
    184184                fibril_mutex_unlock(&fs_list_lock);
    185185                free(fs_info);
    186                 async_answer_0(rid, EINVAL);
     186                async_answer_0(req_handle, EINVAL);
    187187                return;
    188188        }
    … …  
    203203                free(fs_info);
    204204                async_answer_0(chandle, EINVAL);
    205                 async_answer_0(rid, EINVAL);
     205                async_answer_0(req_handle, EINVAL);
    206206                return;
    207207        }
    … …  
    217217                free(fs_info);
    218218                async_answer_0(chandle, EINVAL);
    219                 async_answer_0(rid, EINVAL);
     219                async_answer_0(req_handle, EINVAL);
    220220                return;
    221221        }
    … …  
    235235         */
    236236        fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
    237         async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle);
     237        async_answer_1(req_handle, EOK, (sysarg_t) fs_info->fs_handle);
    238238
    239239        fibril_condvar_broadcast(&fs_list_cv);
Note: See TracChangeset for help on using the changeset viewer.