Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ipc.c

    ra35b458 r77f0a1d  
    3535#include <vfs/canonify.h>
    3636
    37 static void vfs_in_clone(ipc_callid_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(ipc_callid_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);
    5151        char *fs_name = NULL;
    52         ipc_callid_t callid;
     52        cap_call_handle_t chandle;
    5353        vfs_fs_probe_info_t info;
    5454        size_t len;
    … …  
    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;
    7272
    7373        /* Now we should get a read request */
    74         if (!async_data_read_receive(&callid, &len))
     74        if (!async_data_read_receive(&chandle, &len))
    7575                goto out;
    7676
    7777        if (len > sizeof(info))
    7878                len = sizeof(info);
    79         (void) async_data_read_finalize(callid, &info, len);
     79        (void) async_data_read_finalize(chandle, &info, len);
    8080
    8181out:
    … …  
    8383}
    8484
    85 static void vfs_in_fstypes(ipc_callid_t rid, ipc_call_t *request)
    86 {
    87         ipc_callid_t callid;
     85static void vfs_in_fstypes(cap_call_handle_t req_handle, ipc_call_t *request)
     86{
     87        cap_call_handle_t chandle;
    8888        size_t len;
    8989        vfs_fstypes_t fstypes;
    … …  
    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 */
    102         if (!async_data_read_receive(&callid, &len))
     102        if (!async_data_read_receive(&chandle, &len))
    103103                goto out;
    104104
    105105        if (len > fstypes.size)
    106106                len = fstypes.size;
    107         (void) async_data_read_finalize(callid, fstypes.buf, len);
     107        (void) async_data_read_finalize(chandle, fstypes.buf, len);
    108108
    109109out:
    … …  
    111111}
    112112
    113 static void vfs_in_mount(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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(ipc_callid_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);
    315 }
    316 
    317 void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     314        async_answer_1(req_handle, rc, bytes);
     315}
     316
     317void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    318318{
    319319        bool cont = true;
    … …  
    323323         * This call needs to be answered.
    324324         */
    325         async_answer_0(iid, EOK);
     325        async_answer_0(icall_handle, EOK);
    326326
    327327        while (cont) {
    328328                ipc_call_t call;
    329                 ipc_callid_t callid = async_get_call(&call);
     329                cap_call_handle_t chandle = async_get_call(&call);
    330330
    331331                if (!IPC_GET_IMETHOD(call))
    … …  
    334334                switch (IPC_GET_IMETHOD(call)) {
    335335                case VFS_IN_CLONE:
    336                         vfs_in_clone(callid, &call);
     336                        vfs_in_clone(chandle, &call);
    337337                        break;
    338338                case VFS_IN_FSPROBE:
    339                         vfs_in_fsprobe(callid, &call);
     339                        vfs_in_fsprobe(chandle, &call);
    340340                        break;
    341341                case VFS_IN_FSTYPES:
    342                         vfs_in_fstypes(callid, &call);
     342                        vfs_in_fstypes(chandle, &call);
    343343                        break;
    344344                case VFS_IN_MOUNT:
    345                         vfs_in_mount(callid, &call);
     345                        vfs_in_mount(chandle, &call);
    346346                        break;
    347347                case VFS_IN_OPEN:
    348                         vfs_in_open(callid, &call);
     348                        vfs_in_open(chandle, &call);
    349349                        break;
    350350                case VFS_IN_PUT:
    351                         vfs_in_put(callid, &call);
     351                        vfs_in_put(chandle, &call);
    352352                        break;
    353353                case VFS_IN_READ:
    354                         vfs_in_read(callid, &call);
     354                        vfs_in_read(chandle, &call);
    355355                        break;
    356356                case VFS_IN_REGISTER:
    357                         vfs_register(callid, &call);
     357                        vfs_register(chandle, &call);
    358358                        cont = false;
    359359                        break;
    360360                case VFS_IN_RENAME:
    361                         vfs_in_rename(callid, &call);
     361                        vfs_in_rename(chandle, &call);
    362362                        break;
    363363                case VFS_IN_RESIZE:
    364                         vfs_in_resize(callid, &call);
     364                        vfs_in_resize(chandle, &call);
    365365                        break;
    366366                case VFS_IN_STAT:
    367                         vfs_in_stat(callid, &call);
     367                        vfs_in_stat(chandle, &call);
    368368                        break;
    369369                case VFS_IN_STATFS:
    370                         vfs_in_statfs(callid, &call);
     370                        vfs_in_statfs(chandle, &call);
    371371                        break;
    372372                case VFS_IN_SYNC:
    373                         vfs_in_sync(callid, &call);
     373                        vfs_in_sync(chandle, &call);
    374374                        break;
    375375                case VFS_IN_UNLINK:
    376                         vfs_in_unlink(callid, &call);
     376                        vfs_in_unlink(chandle, &call);
    377377                        break;
    378378                case VFS_IN_UNMOUNT:
    379                         vfs_in_unmount(callid, &call);
     379                        vfs_in_unmount(chandle, &call);
    380380                        break;
    381381                case VFS_IN_WAIT_HANDLE:
    382                         vfs_in_wait_handle(callid, &call);
     382                        vfs_in_wait_handle(chandle, &call);
    383383                        break;
    384384                case VFS_IN_WALK:
    385                         vfs_in_walk(callid, &call);
     385                        vfs_in_walk(chandle, &call);
    386386                        break;
    387387                case VFS_IN_WRITE:
    388                         vfs_in_write(callid, &call);
     388                        vfs_in_write(chandle, &call);
    389389                        break;
    390390                default:
    391                         async_answer_0(callid, ENOTSUP);
     391                        async_answer_0(chandle, ENOTSUP);
    392392                        break;
    393393                }
Note: See TracChangeset for help on using the changeset viewer.