Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 4198f9c3 in mainline


Ignore:
Timestamp:
2009-06-28T13:43:15Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
852b801
Parents:
6408be3
Message:

Separate the VFS input and output protocols.

Location:
uspace
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/trace/trace.c

    r6408be3 r4198f9c3  
    636636        p = proto_new("vfs");
    637637        o = oper_new("read", 1, arg_def, V_ERRNO, 1, resp_def);
    638         proto_add_oper(p, VFS_READ, o);
     638        proto_add_oper(p, VFS_IN_READ, o);
    639639        o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def);
    640         proto_add_oper(p, VFS_WRITE, o);
     640        proto_add_oper(p, VFS_IN_WRITE, o);
    641641        o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def);
    642         proto_add_oper(p, VFS_TRUNCATE, o);
     642        proto_add_oper(p, VFS_IN_TRUNCATE, o);
    643643        o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def);
    644         proto_add_oper(p, VFS_MOUNT, o);
     644        proto_add_oper(p, VFS_IN_MOUNT, o);
    645645/*      o = oper_new("unmount", 0, arg_def);
    646         proto_add_oper(p, VFS_UNMOUNT, o);*/
     646        proto_add_oper(p, VFS_IN_UNMOUNT, o);*/
    647647        o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def);
    648         proto_add_oper(p, VFS_OPEN, o);
     648        proto_add_oper(p, VFS_IN_OPEN, o);
    649649        o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
    650         proto_add_oper(p, VFS_CLOSE, o);
     650        proto_add_oper(p, VFS_IN_CLOSE, o);
    651651        o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def);
    652         proto_add_oper(p, VFS_SEEK, o);
     652        proto_add_oper(p, VFS_IN_SEEK, o);
    653653        o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def);
    654         proto_add_oper(p, VFS_MKDIR, o);
     654        proto_add_oper(p, VFS_IN_MKDIR, o);
    655655        o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def);
    656         proto_add_oper(p, VFS_UNLINK, o);
     656        proto_add_oper(p, VFS_IN_UNLINK, o);
    657657        o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
    658         proto_add_oper(p, VFS_RENAME, o);
     658        proto_add_oper(p, VFS_IN_RENAME, o);
    659659
    660660        proto_register(SERVICE_VFS, p);
  • uspace/lib/libc/generic/vfs/vfs.c

    r6408be3 r4198f9c3  
    138138        vfs_connect();
    139139       
    140         req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
     140        req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
    141141        rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    142142        if (rc != EOK) {
     
    199199        vfs_connect();
    200200       
    201         req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
     201        req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
    202202        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    203203        if (rc != EOK) {
     
    231231       
    232232        ipc_call_t answer;
    233         aid_t req = async_send_4(vfs_phone, VFS_OPEN_NODE, node->fs_handle,
     233        aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
    234234            node->dev_handle, node->index, oflag, &answer);
    235235       
     
    253253        vfs_connect();
    254254       
    255         rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
     255        rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
    256256       
    257257        async_serialize_end();
     
    271271        vfs_connect();
    272272       
    273         req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
     273        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    274274        rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
    275275        if (rc != EOK) {
     
    298298        vfs_connect();
    299299       
    300         req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
     300        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    301301        rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
    302302        if (rc != EOK) {
     
    322322       
    323323        ipcarg_t device;
    324         ipcarg_t rc = async_req_1_1(vfs_phone, VFS_DEVICE, fildes, &device);
     324        ipcarg_t rc = async_req_1_1(vfs_phone, VFS_IN_DEVICE, fildes, &device);
    325325       
    326326        async_serialize_end();
     
    342342        ipcarg_t dev_handle;
    343343        ipcarg_t index;
    344         ipcarg_t rc = async_req_1_3(vfs_phone, VFS_NODE, fildes, &fs_handle,
     344        ipcarg_t rc = async_req_1_3(vfs_phone, VFS_IN_NODE, fildes, &fs_handle,
    345345            &dev_handle, &index);
    346346       
     
    363363        vfs_connect();
    364364       
    365         ipcarg_t rc = async_req_1_0(vfs_phone, VFS_SYNC, fildes);
     365        ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
    366366       
    367367        async_serialize_end();
     
    380380       
    381381        ipcarg_t newoffs;
    382         rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
     382        rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence,
    383383            &newoffs);
    384384
     
    400400        vfs_connect();
    401401       
    402         rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
     402        rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length);
    403403        async_serialize_end();
    404404        futex_up(&vfs_phone_futex);
     
    453453        vfs_connect();
    454454       
    455         req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
     455        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
    456456        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    457457        if (rc != EOK) {
     
    483483        vfs_connect();
    484484       
    485         req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
     485        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
    486486        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    487487        if (rc != EOK) {
     
    530530        vfs_connect();
    531531       
    532         req = async_send_0(vfs_phone, VFS_RENAME, NULL);
     532        req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
    533533        rc = ipc_data_write_start(vfs_phone, olda, olda_size);
    534534        if (rc != EOK) {
  • uspace/lib/libc/include/ipc/console.h

    r6408be3 r4198f9c3  
    4040
    4141typedef enum {
    42         CONSOLE_GET_SIZE = VFS_LAST_SRV,
     42        CONSOLE_GET_SIZE = VFS_OUT_LAST,
    4343        CONSOLE_GET_EVENT,
    4444        CONSOLE_GOTO,
  • uspace/lib/libc/include/ipc/vfs.h

    r6408be3 r4198f9c3  
    5858
    5959typedef enum {
    60         VFS_OPEN_NODE = IPC_FIRST_USER_METHOD,
    61         VFS_READ,
    62         VFS_WRITE,
    63         VFS_TRUNCATE,
    64         VFS_MOUNT,
    65         VFS_UNMOUNT,
    66         VFS_DEVICE,
    67         VFS_SYNC,
    68         VFS_CLOSE,
    69         VFS_LAST_CMN  /* keep this the last member of this enum */
    70 } vfs_request_cmn_t;
     60        VFS_IN_OPEN = IPC_FIRST_USER_METHOD,
     61        VFS_IN_OPEN_NODE,
     62        VFS_IN_READ,
     63        VFS_IN_WRITE,
     64        VFS_IN_SEEK,
     65        VFS_IN_TRUNCATE,
     66        VFS_IN_CLOSE,
     67        VFS_IN_MOUNT,
     68        VFS_IN_UNMOUNT,
     69        VFS_IN_DEVICE,
     70        VFS_IN_SYNC,
     71        VFS_IN_REGISTER,
     72        VFS_IN_MKDIR,
     73        VFS_IN_UNLINK,
     74        VFS_IN_RENAME,
     75        VFS_IN_NODE
     76} vfs_in_request_t;
    7177
    7278typedef enum {
    73         VFS_LOOKUP = VFS_LAST_CMN,
    74         VFS_MOUNTED,
    75         VFS_DESTROY,
    76         VFS_LAST_CLNT  /* keep this the last member of this enum */
    77 } vfs_request_clnt_t;
    78 
    79 typedef enum {
    80         VFS_REGISTER = VFS_LAST_CMN,
    81         VFS_OPEN,
    82         VFS_SEEK,
    83         VFS_MKDIR,
    84         VFS_UNLINK,
    85         VFS_RENAME,
    86         VFS_NODE,
    87         VFS_LAST_SRV  /* keep this the last member of this enum */
    88 } vfs_request_srv_t;
     79        VFS_OUT_OPEN_NODE = IPC_FIRST_USER_METHOD,
     80        VFS_OUT_READ,
     81        VFS_OUT_WRITE,
     82        VFS_OUT_TRUNCATE,
     83        VFS_OUT_CLOSE,
     84        VFS_OUT_MOUNT,
     85        VFS_OUT_MOUNTED,
     86        VFS_OUT_UNMOUNT,
     87        VFS_OUT_DEVICE,
     88        VFS_OUT_SYNC,
     89        VFS_OUT_LOOKUP,
     90        VFS_OUT_DESTROY,
     91        VFS_OUT_LAST
     92} vfs_out_request_t;
    8993
    9094/*
  • uspace/lib/libfs/libfs.c

    r6408be3 r4198f9c3  
    7070         */
    7171        ipc_call_t answer;
    72         aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
     72        aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
    7373
    7474        /*
     
    105105         
    106106        /*
    107          * Pick up the answer for the request to the VFS_REQUEST call.
     107         * Pick up the answer for the request to the VFS_IN_REQUEST call.
    108108         */
    109109        async_wait_for(req, NULL);
     
    187187       
    188188        ipc_call_t answer;
    189         aid_t msg = async_send_1(mountee_phone, VFS_MOUNTED, mr_dev_handle,
     189        aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
    190190            &answer);
    191191        ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     
    214214 * @param fs_handle File system handle of the file system where to perform
    215215 *                  the lookup.
    216  * @param rid       Request ID of the VFS_LOOKUP request.
    217  * @param request   VFS_LOOKUP request data itself.
     216 * @param rid       Request ID of the VFS_OUT_LOOKUP request.
     217 * @param request   VFS_OUT_LOOKUP request data itself.
    218218 *
    219219 */
     
    238238
    239239        if (cur->mp_data.mp_active) {
    240                 ipc_forward_slow(rid, cur->mp_data.phone, VFS_LOOKUP,
     240                ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
    241241                    next, last, cur->mp_data.dev_handle, lflag, index,
    242242                    IPC_FF_ROUTE_FROM_ME);
     
    273273                                next--;
    274274                               
    275                         ipc_forward_slow(rid, tmp->mp_data.phone, VFS_LOOKUP,
    276                             next, last, tmp->mp_data.dev_handle, lflag, index,
    277                             IPC_FF_ROUTE_FROM_ME);
     275                        ipc_forward_slow(rid, tmp->mp_data.phone,
     276                            VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
     277                            lflag, index, IPC_FF_ROUTE_FROM_ME);
    278278                        ops->node_put(cur);
    279279                        ops->node_put(tmp);
     
    433433 * @param ops       libfs operations structure with function pointers to
    434434 *                  file system implementation
    435  * @param rid       Request ID of the VFS_OPEN_NODE request.
    436  * @param request   VFS_OPEN_NODE request data itself.
     435 * @param rid       Request ID of the VFS_OUT_OPEN_NODE request.
     436 * @param request   VFS_OUT_OPEN_NODE request data itself.
    437437 *
    438438 */
  • uspace/srv/console/console.c

    r6408be3 r4198f9c3  
    552552                                gcons_notify_disconnect(cons->index);
    553553                        return;
    554                 case VFS_READ:
     554                case VFS_OUT_READ:
    555555                        async_serialize_end();
    556556                        cons_read(cons, callid, &call);
    557557                        async_serialize_start();
    558558                        continue;
    559                 case VFS_WRITE:
     559                case VFS_OUT_WRITE:
    560560                        async_serialize_end();
    561561                        cons_write(cons, callid, &call);
    562562                        async_serialize_start();
    563563                        continue;
    564                 case VFS_SYNC:
     564                case VFS_OUT_SYNC:
    565565                        fb_pending_flush();
    566566                        if (cons == active_console) {
  • uspace/srv/fs/devfs/devfs.c

    r6408be3 r4198f9c3  
    6868                case IPC_M_PHONE_HUNGUP:
    6969                        return;
    70                 case VFS_MOUNTED:
     70                case VFS_OUT_MOUNTED:
    7171                        devfs_mounted(callid, &call);
    7272                        break;
    73                 case VFS_MOUNT:
     73                case VFS_OUT_MOUNT:
    7474                        devfs_mount(callid, &call);
    7575                        break;
    76                 case VFS_LOOKUP:
     76                case VFS_OUT_LOOKUP:
    7777                        devfs_lookup(callid, &call);
    7878                        break;
    79                 case VFS_OPEN_NODE:
     79                case VFS_OUT_OPEN_NODE:
    8080                        devfs_open_node(callid, &call);
    8181                        break;
    82                 case VFS_DEVICE:
     82                case VFS_OUT_DEVICE:
    8383                        devfs_device(callid, &call);
    8484                        break;
    85                 case VFS_READ:
     85                case VFS_OUT_READ:
    8686                        devfs_read(callid, &call);
    8787                        break;
    88                 case VFS_WRITE:
     88                case VFS_OUT_WRITE:
    8989                        devfs_write(callid, &call);
    9090                        break;
    91                 case VFS_TRUNCATE:
     91                case VFS_OUT_TRUNCATE:
    9292                        devfs_truncate(callid, &call);
    9393                        break;
    94                 case VFS_CLOSE:
     94                case VFS_OUT_CLOSE:
    9595                        devfs_close(callid, &call);
    9696                        break;
    97                 case VFS_SYNC:
     97                case VFS_OUT_SYNC:
    9898                        devfs_sync(callid, &call);
    9999                        break;
    100                 case VFS_DESTROY:
     100                case VFS_OUT_DESTROY:
    101101                        devfs_destroy(callid, &call);
    102102                        break;
  • uspace/srv/fs/fat/fat.c

    r6408be3 r4198f9c3  
    9292                case IPC_M_PHONE_HUNGUP:
    9393                        return;
    94                 case VFS_MOUNTED:
     94                case VFS_OUT_MOUNTED:
    9595                        fat_mounted(callid, &call);
    9696                        break;
    97                 case VFS_MOUNT:
     97                case VFS_OUT_MOUNT:
    9898                        fat_mount(callid, &call);
    9999                        break;
    100                 case VFS_LOOKUP:
     100                case VFS_OUT_LOOKUP:
    101101                        fat_lookup(callid, &call);
    102102                        break;
    103                 case VFS_READ:
     103                case VFS_OUT_READ:
    104104                        fat_read(callid, &call);
    105105                        break;
    106                 case VFS_WRITE:
     106                case VFS_OUT_WRITE:
    107107                        fat_write(callid, &call);
    108108                        break;
    109                 case VFS_TRUNCATE:
     109                case VFS_OUT_TRUNCATE:
    110110                        fat_truncate(callid, &call);
    111111                        break;
    112                 case VFS_CLOSE:
     112                case VFS_OUT_CLOSE:
    113113                        fat_close(callid, &call);
    114114                        break;
    115                 case VFS_DESTROY:
     115                case VFS_OUT_DESTROY:
    116116                        fat_destroy(callid, &call);
    117117                        break;
    118                 case VFS_OPEN_NODE:
     118                case VFS_OUT_OPEN_NODE:
    119119                        fat_open_node(callid, &call);
    120120                        break;
    121                 case VFS_DEVICE:
     121                case VFS_OUT_DEVICE:
    122122                        fat_device(callid, &call);
    123123                        break;
    124                 case VFS_SYNC:
     124                case VFS_OUT_SYNC:
    125125                        fat_sync(callid, &call);
    126126                        break;
  • uspace/srv/fs/tmpfs/tmpfs.c

    r6408be3 r4198f9c3  
    9999                case IPC_M_PHONE_HUNGUP:
    100100                        return;
    101                 case VFS_MOUNTED:
     101                case VFS_OUT_MOUNTED:
    102102                        tmpfs_mounted(callid, &call);
    103103                        break;
    104                 case VFS_MOUNT:
     104                case VFS_OUT_MOUNT:
    105105                        tmpfs_mount(callid, &call);
    106106                        break;
    107                 case VFS_LOOKUP:
     107                case VFS_OUT_LOOKUP:
    108108                        tmpfs_lookup(callid, &call);
    109109                        break;
    110                 case VFS_READ:
     110                case VFS_OUT_READ:
    111111                        tmpfs_read(callid, &call);
    112112                        break;
    113                 case VFS_WRITE:
     113                case VFS_OUT_WRITE:
    114114                        tmpfs_write(callid, &call);
    115115                        break;
    116                 case VFS_TRUNCATE:
     116                case VFS_OUT_TRUNCATE:
    117117                        tmpfs_truncate(callid, &call);
    118118                        break;
    119                 case VFS_CLOSE:
     119                case VFS_OUT_CLOSE:
    120120                        tmpfs_close(callid, &call);
    121121                        break;
    122                 case VFS_DESTROY:
     122                case VFS_OUT_DESTROY:
    123123                        tmpfs_destroy(callid, &call);
    124124                        break;
    125                 case VFS_OPEN_NODE:
     125                case VFS_OUT_OPEN_NODE:
    126126                        tmpfs_open_node(callid, &call);
    127127                        break;
    128                 case VFS_DEVICE:
     128                case VFS_OUT_DEVICE:
    129129                        tmpfs_device(callid, &call);
    130130                        break;
    131                 case VFS_SYNC:
     131                case VFS_OUT_SYNC:
    132132                        tmpfs_sync(callid, &call);
    133133                        break;
     
    153153                return -1;
    154154        }
    155        
     155
    156156        int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
    157157            tmpfs_connection);
  • uspace/srv/vfs/vfs.c

    r6408be3 r4198f9c3  
    8080                        keep_on_going = false;
    8181                        break;
    82                 case VFS_REGISTER:
     82                case VFS_IN_REGISTER:
    8383                        vfs_register(callid, &call);
    8484                        keep_on_going = false;
    8585                        break;
    86                 case VFS_MOUNT:
     86                case VFS_IN_MOUNT:
    8787                        vfs_mount(callid, &call);
    8888                        break;
    89                 case VFS_OPEN:
     89                case VFS_IN_OPEN:
    9090                        vfs_open(callid, &call);
    9191                        break;
    92                 case VFS_OPEN_NODE:
     92                case VFS_IN_OPEN_NODE:
    9393                        vfs_open_node(callid, &call);
    9494                        break;
    95                 case VFS_CLOSE:
     95                case VFS_IN_CLOSE:
    9696                        vfs_close(callid, &call);
    9797                        break;
    98                 case VFS_READ:
     98                case VFS_IN_READ:
    9999                        vfs_read(callid, &call);
    100100                        break;
    101                 case VFS_WRITE:
     101                case VFS_IN_WRITE:
    102102                        vfs_write(callid, &call);
    103103                        break;
    104                 case VFS_SEEK:
     104                case VFS_IN_SEEK:
    105105                        vfs_seek(callid, &call);
    106106                        break;
    107                 case VFS_TRUNCATE:
     107                case VFS_IN_TRUNCATE:
    108108                        vfs_truncate(callid, &call);
    109109                        break;
    110                 case VFS_MKDIR:
     110                case VFS_IN_MKDIR:
    111111                        vfs_mkdir(callid, &call);
    112112                        break;
    113                 case VFS_UNLINK:
     113                case VFS_IN_UNLINK:
    114114                        vfs_unlink(callid, &call);
    115115                        break;
    116                 case VFS_RENAME:
     116                case VFS_IN_RENAME:
    117117                        vfs_rename(callid, &call);
    118118                        break;
    119                 case VFS_DEVICE:
     119                case VFS_IN_DEVICE:
    120120                        vfs_device(callid, &call);
    121121                        break;
    122                 case VFS_SYNC:
     122                case VFS_IN_SYNC:
    123123                        vfs_sync(callid, &call);
    124124                        break;
    125                 case VFS_NODE:
     125                case VFS_IN_NODE:
    126126                        vfs_node(callid, &call);
    127127                        break;
  • uspace/srv/vfs/vfs_lookup.c

    r6408be3 r4198f9c3  
    160160        ipc_call_t answer;
    161161        int phone = vfs_grab_phone(root->fs_handle);
    162         aid_t req = async_send_5(phone, VFS_LOOKUP, (ipcarg_t) first,
     162        aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (ipcarg_t) first,
    163163            (ipcarg_t) (first + len - 1) % PLB_SIZE,
    164164            (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
     
    205205       
    206206        ipc_call_t answer;
    207         aid_t req = async_send_2(phone, VFS_OPEN_NODE,
     207        aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE,
    208208            (ipcarg_t) result->triplet.dev_handle,
    209209            (ipcarg_t) result->triplet.index, &answer);
  • uspace/srv/vfs/vfs_node.c

    r6408be3 r4198f9c3  
    130130                int phone = vfs_grab_phone(node->fs_handle);
    131131                ipcarg_t rc;
    132                 rc = async_req_2_0(phone, VFS_DESTROY,
     132                rc = async_req_2_0(phone, VFS_OUT_DESTROY,
    133133                    (ipcarg_t)node->dev_handle, (ipcarg_t)node->index);
    134134                assert(rc == EOK);
  • uspace/srv/vfs/vfs_ops.c

    r6408be3 r4198f9c3  
    109109                /*
    110110                 * Now we hold a reference to mp_node.
    111                  * It will be dropped upon the corresponding VFS_UNMOUNT.
     111                 * It will be dropped upon the corresponding VFS_IN_UNMOUNT.
    112112                 * This prevents the mount point from being deleted.
    113113                 */
     
    122122                        /* Tell the mountee that it is being mounted. */
    123123                        phone = vfs_grab_phone(fs_handle);
    124                         msg = async_send_1(phone, VFS_MOUNTED,
     124                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
    125125                            (ipcarg_t) dev_handle, &answer);
    126126                        /* send the mount options */
     
    184184
    185185        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    186         msg = async_send_4(phone, VFS_MOUNT,
     186        msg = async_send_4(phone, VFS_OUT_MOUNT,
    187187            (ipcarg_t) mp_res.triplet.dev_handle,
    188188            (ipcarg_t) mp_res.triplet.index,
     
    438438        /*
    439439         * The POSIX interface is open(path, oflag, mode).
    440          * We can receive oflags and mode along with the VFS_OPEN call; the path
    441          * will need to arrive in another call.
     440         * We can receive oflags and mode along with the VFS_IN_OPEN call;
     441         * the path will need to arrive in another call.
    442442         *
    443443         * We also receive one private, non-POSIX set of flags called lflag
     
    556556         * It is necessary so that the file will not disappear when
    557557         * vfs_node_put() is called. The reference will be dropped by the
    558          * respective VFS_CLOSE.
     558         * respective VFS_IN_CLOSE.
    559559         */
    560560        vfs_node_addref(node);
     
    633633         * It is necessary so that the file will not disappear when
    634634         * vfs_node_put() is called. The reference will be dropped by the
    635          * respective VFS_CLOSE.
     635         * respective VFS_IN_CLOSE.
    636636         */
    637637        vfs_node_addref(node);
     
    675675        int fs_phone = vfs_grab_phone(file->node->fs_handle);
    676676       
    677         /* Make a VFS_DEVICE request at the destination FS server. */
     677        /* Make a VFS_OUT_DEVICE request at the destination FS server. */
    678678        aid_t msg;
    679679        ipc_call_t answer;
    680         msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
    681             file->node->dev_handle, file->node->index, &answer);
     680        msg = async_send_2(fs_phone, VFS_OUT_DEVICE, file->node->dev_handle,
     681            file->node->index, &answer);
    682682
    683683        /* Wait for reply from the FS server. */
     
    709709        int fs_phone = vfs_grab_phone(file->node->fs_handle);
    710710       
    711         /* Make a VFS_SYMC request at the destination FS server. */
     711        /* Make a VFS_OUT_SYMC request at the destination FS server. */
    712712        aid_t msg;
    713713        ipc_call_t answer;
    714         msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
    715             file->node->dev_handle, file->node->index, &answer);
     714        msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
     715            file->node->index, &answer);
    716716
    717717        /* Wait for reply from the FS server. */
     
    743743        int fs_phone = vfs_grab_phone(file->node->fs_handle);
    744744       
    745         /* Make a VFS_CLOSE request at the destination FS server. */
     745        /* Make a VFS_OUT_CLOSE request at the destination FS server. */
    746746        aid_t msg;
    747747        ipc_call_t answer;
    748         msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
    749             file->node->dev_handle, file->node->index, &answer);
     748        msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
     749            file->node->index, &answer);
    750750
    751751        /* Wait for reply from the FS server. */
     
    833833        if (!read && file->append)
    834834                file->pos = file->node->size;
    835         msg = async_send_3(fs_phone, IPC_GET_METHOD(*request),
     835        msg = async_send_3(fs_phone, read ? VFS_OUT_READ : VFS_OUT_WRITE,
    836836            file->node->dev_handle, file->node->index, file->pos, &answer);
    837837       
     
    947947       
    948948        fs_phone = vfs_grab_phone(fs_handle);
    949         rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)dev_handle,
     949        rc = async_req_3_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t)dev_handle,
    950950            (ipcarg_t)index, (ipcarg_t)size);
    951951        vfs_release_phone(fs_phone);
     
    10511051         * The name has already been unlinked by vfs_lookup_internal().
    10521052         * We have to get and put the VFS node to ensure that it is
    1053          * VFS_DESTROY'ed after the last reference to it is dropped.
     1053         * VFS_OUT_DESTROY'ed after the last reference to it is dropped.
    10541054         */
    10551055        vfs_node_t *node = vfs_node_get(&lr);
Note: See TracChangeset for help on using the changeset viewer.