Index: uspace/app/trace/trace.c =================================================================== --- uspace/app/trace/trace.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/app/trace/trace.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -636,25 +636,25 @@ p = proto_new("vfs"); o = oper_new("read", 1, arg_def, V_ERRNO, 1, resp_def); - proto_add_oper(p, VFS_READ, o); + proto_add_oper(p, VFS_IN_READ, o); o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def); - proto_add_oper(p, VFS_WRITE, o); + proto_add_oper(p, VFS_IN_WRITE, o); o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_TRUNCATE, o); + proto_add_oper(p, VFS_IN_TRUNCATE, o); o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_MOUNT, o); + proto_add_oper(p, VFS_IN_MOUNT, o); /* o = oper_new("unmount", 0, arg_def); - proto_add_oper(p, VFS_UNMOUNT, o);*/ + proto_add_oper(p, VFS_IN_UNMOUNT, o);*/ o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_OPEN, o); + proto_add_oper(p, VFS_IN_OPEN, o); o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_CLOSE, o); + proto_add_oper(p, VFS_IN_CLOSE, o); o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_SEEK, o); + proto_add_oper(p, VFS_IN_SEEK, o); o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_MKDIR, o); + proto_add_oper(p, VFS_IN_MKDIR, o); o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_UNLINK, o); + proto_add_oper(p, VFS_IN_UNLINK, o); o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def); - proto_add_oper(p, VFS_RENAME, o); + proto_add_oper(p, VFS_IN_RENAME, o); proto_register(SERVICE_VFS, p); Index: uspace/lib/libc/generic/vfs/vfs.c =================================================================== --- uspace/lib/libc/generic/vfs/vfs.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/lib/libc/generic/vfs/vfs.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -138,5 +138,5 @@ vfs_connect(); - req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL); + req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL); rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size); if (rc != EOK) { @@ -199,5 +199,5 @@ vfs_connect(); - req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer); + req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer); rc = ipc_data_write_start(vfs_phone, pa, pa_size); if (rc != EOK) { @@ -231,5 +231,5 @@ ipc_call_t answer; - aid_t req = async_send_4(vfs_phone, VFS_OPEN_NODE, node->fs_handle, + aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle, node->dev_handle, node->index, oflag, &answer); @@ -253,5 +253,5 @@ vfs_connect(); - rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes); + rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes); async_serialize_end(); @@ -271,5 +271,5 @@ vfs_connect(); - req = async_send_1(vfs_phone, VFS_READ, fildes, &answer); + req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer); rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte); if (rc != EOK) { @@ -298,5 +298,5 @@ vfs_connect(); - req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer); + req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer); rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte); if (rc != EOK) { @@ -322,5 +322,5 @@ ipcarg_t device; - ipcarg_t rc = async_req_1_1(vfs_phone, VFS_DEVICE, fildes, &device); + ipcarg_t rc = async_req_1_1(vfs_phone, VFS_IN_DEVICE, fildes, &device); async_serialize_end(); @@ -342,5 +342,5 @@ ipcarg_t dev_handle; ipcarg_t index; - ipcarg_t rc = async_req_1_3(vfs_phone, VFS_NODE, fildes, &fs_handle, + ipcarg_t rc = async_req_1_3(vfs_phone, VFS_IN_NODE, fildes, &fs_handle, &dev_handle, &index); @@ -363,5 +363,5 @@ vfs_connect(); - ipcarg_t rc = async_req_1_0(vfs_phone, VFS_SYNC, fildes); + ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes); async_serialize_end(); @@ -380,5 +380,5 @@ ipcarg_t newoffs; - rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence, + rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence, &newoffs); @@ -400,5 +400,5 @@ vfs_connect(); - rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length); + rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length); async_serialize_end(); futex_up(&vfs_phone_futex); @@ -453,5 +453,5 @@ vfs_connect(); - req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL); + req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL); rc = ipc_data_write_start(vfs_phone, pa, pa_size); if (rc != EOK) { @@ -483,5 +483,5 @@ vfs_connect(); - req = async_send_0(vfs_phone, VFS_UNLINK, NULL); + req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL); rc = ipc_data_write_start(vfs_phone, pa, pa_size); if (rc != EOK) { @@ -530,5 +530,5 @@ vfs_connect(); - req = async_send_0(vfs_phone, VFS_RENAME, NULL); + req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL); rc = ipc_data_write_start(vfs_phone, olda, olda_size); if (rc != EOK) { Index: uspace/lib/libc/include/ipc/console.h =================================================================== --- uspace/lib/libc/include/ipc/console.h (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/lib/libc/include/ipc/console.h (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -40,5 +40,5 @@ typedef enum { - CONSOLE_GET_SIZE = VFS_LAST_SRV, + CONSOLE_GET_SIZE = VFS_OUT_LAST, CONSOLE_GET_EVENT, CONSOLE_GOTO, Index: uspace/lib/libc/include/ipc/vfs.h =================================================================== --- uspace/lib/libc/include/ipc/vfs.h (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/lib/libc/include/ipc/vfs.h (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -58,33 +58,37 @@ typedef enum { - VFS_OPEN_NODE = IPC_FIRST_USER_METHOD, - VFS_READ, - VFS_WRITE, - VFS_TRUNCATE, - VFS_MOUNT, - VFS_UNMOUNT, - VFS_DEVICE, - VFS_SYNC, - VFS_CLOSE, - VFS_LAST_CMN /* keep this the last member of this enum */ -} vfs_request_cmn_t; + VFS_IN_OPEN = IPC_FIRST_USER_METHOD, + VFS_IN_OPEN_NODE, + VFS_IN_READ, + VFS_IN_WRITE, + VFS_IN_SEEK, + VFS_IN_TRUNCATE, + VFS_IN_CLOSE, + VFS_IN_MOUNT, + VFS_IN_UNMOUNT, + VFS_IN_DEVICE, + VFS_IN_SYNC, + VFS_IN_REGISTER, + VFS_IN_MKDIR, + VFS_IN_UNLINK, + VFS_IN_RENAME, + VFS_IN_NODE +} vfs_in_request_t; typedef enum { - VFS_LOOKUP = VFS_LAST_CMN, - VFS_MOUNTED, - VFS_DESTROY, - VFS_LAST_CLNT /* keep this the last member of this enum */ -} vfs_request_clnt_t; - -typedef enum { - VFS_REGISTER = VFS_LAST_CMN, - VFS_OPEN, - VFS_SEEK, - VFS_MKDIR, - VFS_UNLINK, - VFS_RENAME, - VFS_NODE, - VFS_LAST_SRV /* keep this the last member of this enum */ -} vfs_request_srv_t; + VFS_OUT_OPEN_NODE = IPC_FIRST_USER_METHOD, + VFS_OUT_READ, + VFS_OUT_WRITE, + VFS_OUT_TRUNCATE, + VFS_OUT_CLOSE, + VFS_OUT_MOUNT, + VFS_OUT_MOUNTED, + VFS_OUT_UNMOUNT, + VFS_OUT_DEVICE, + VFS_OUT_SYNC, + VFS_OUT_LOOKUP, + VFS_OUT_DESTROY, + VFS_OUT_LAST +} vfs_out_request_t; /* Index: uspace/lib/libfs/libfs.c =================================================================== --- uspace/lib/libfs/libfs.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/lib/libfs/libfs.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -70,5 +70,5 @@ */ ipc_call_t answer; - aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer); + aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer); /* @@ -105,5 +105,5 @@ /* - * Pick up the answer for the request to the VFS_REQUEST call. + * Pick up the answer for the request to the VFS_IN_REQUEST call. */ async_wait_for(req, NULL); @@ -187,5 +187,5 @@ ipc_call_t answer; - aid_t msg = async_send_1(mountee_phone, VFS_MOUNTED, mr_dev_handle, + aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle, &answer); ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); @@ -214,6 +214,6 @@ * @param fs_handle File system handle of the file system where to perform * the lookup. - * @param rid Request ID of the VFS_LOOKUP request. - * @param request VFS_LOOKUP request data itself. + * @param rid Request ID of the VFS_OUT_LOOKUP request. + * @param request VFS_OUT_LOOKUP request data itself. * */ @@ -238,5 +238,5 @@ if (cur->mp_data.mp_active) { - ipc_forward_slow(rid, cur->mp_data.phone, VFS_LOOKUP, + ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, next, last, cur->mp_data.dev_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); @@ -273,7 +273,7 @@ next--; - ipc_forward_slow(rid, tmp->mp_data.phone, VFS_LOOKUP, - next, last, tmp->mp_data.dev_handle, lflag, index, - IPC_FF_ROUTE_FROM_ME); + ipc_forward_slow(rid, tmp->mp_data.phone, + VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle, + lflag, index, IPC_FF_ROUTE_FROM_ME); ops->node_put(cur); ops->node_put(tmp); @@ -433,6 +433,6 @@ * @param ops libfs operations structure with function pointers to * file system implementation - * @param rid Request ID of the VFS_OPEN_NODE request. - * @param request VFS_OPEN_NODE request data itself. + * @param rid Request ID of the VFS_OUT_OPEN_NODE request. + * @param request VFS_OUT_OPEN_NODE request data itself. * */ Index: uspace/srv/console/console.c =================================================================== --- uspace/srv/console/console.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/console/console.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -552,15 +552,15 @@ gcons_notify_disconnect(cons->index); return; - case VFS_READ: + case VFS_OUT_READ: async_serialize_end(); cons_read(cons, callid, &call); async_serialize_start(); continue; - case VFS_WRITE: + case VFS_OUT_WRITE: async_serialize_end(); cons_write(cons, callid, &call); async_serialize_start(); continue; - case VFS_SYNC: + case VFS_OUT_SYNC: fb_pending_flush(); if (cons == active_console) { Index: uspace/srv/fs/devfs/devfs.c =================================================================== --- uspace/srv/fs/devfs/devfs.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/fs/devfs/devfs.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -68,35 +68,35 @@ case IPC_M_PHONE_HUNGUP: return; - case VFS_MOUNTED: + case VFS_OUT_MOUNTED: devfs_mounted(callid, &call); break; - case VFS_MOUNT: + case VFS_OUT_MOUNT: devfs_mount(callid, &call); break; - case VFS_LOOKUP: + case VFS_OUT_LOOKUP: devfs_lookup(callid, &call); break; - case VFS_OPEN_NODE: + case VFS_OUT_OPEN_NODE: devfs_open_node(callid, &call); break; - case VFS_DEVICE: + case VFS_OUT_DEVICE: devfs_device(callid, &call); break; - case VFS_READ: + case VFS_OUT_READ: devfs_read(callid, &call); break; - case VFS_WRITE: + case VFS_OUT_WRITE: devfs_write(callid, &call); break; - case VFS_TRUNCATE: + case VFS_OUT_TRUNCATE: devfs_truncate(callid, &call); break; - case VFS_CLOSE: + case VFS_OUT_CLOSE: devfs_close(callid, &call); break; - case VFS_SYNC: + case VFS_OUT_SYNC: devfs_sync(callid, &call); break; - case VFS_DESTROY: + case VFS_OUT_DESTROY: devfs_destroy(callid, &call); break; Index: uspace/srv/fs/fat/fat.c =================================================================== --- uspace/srv/fs/fat/fat.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/fs/fat/fat.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -92,35 +92,35 @@ case IPC_M_PHONE_HUNGUP: return; - case VFS_MOUNTED: + case VFS_OUT_MOUNTED: fat_mounted(callid, &call); break; - case VFS_MOUNT: + case VFS_OUT_MOUNT: fat_mount(callid, &call); break; - case VFS_LOOKUP: + case VFS_OUT_LOOKUP: fat_lookup(callid, &call); break; - case VFS_READ: + case VFS_OUT_READ: fat_read(callid, &call); break; - case VFS_WRITE: + case VFS_OUT_WRITE: fat_write(callid, &call); break; - case VFS_TRUNCATE: + case VFS_OUT_TRUNCATE: fat_truncate(callid, &call); break; - case VFS_CLOSE: + case VFS_OUT_CLOSE: fat_close(callid, &call); break; - case VFS_DESTROY: + case VFS_OUT_DESTROY: fat_destroy(callid, &call); break; - case VFS_OPEN_NODE: + case VFS_OUT_OPEN_NODE: fat_open_node(callid, &call); break; - case VFS_DEVICE: + case VFS_OUT_DEVICE: fat_device(callid, &call); break; - case VFS_SYNC: + case VFS_OUT_SYNC: fat_sync(callid, &call); break; Index: uspace/srv/fs/tmpfs/tmpfs.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/fs/tmpfs/tmpfs.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -99,35 +99,35 @@ case IPC_M_PHONE_HUNGUP: return; - case VFS_MOUNTED: + case VFS_OUT_MOUNTED: tmpfs_mounted(callid, &call); break; - case VFS_MOUNT: + case VFS_OUT_MOUNT: tmpfs_mount(callid, &call); break; - case VFS_LOOKUP: + case VFS_OUT_LOOKUP: tmpfs_lookup(callid, &call); break; - case VFS_READ: + case VFS_OUT_READ: tmpfs_read(callid, &call); break; - case VFS_WRITE: + case VFS_OUT_WRITE: tmpfs_write(callid, &call); break; - case VFS_TRUNCATE: + case VFS_OUT_TRUNCATE: tmpfs_truncate(callid, &call); break; - case VFS_CLOSE: + case VFS_OUT_CLOSE: tmpfs_close(callid, &call); break; - case VFS_DESTROY: + case VFS_OUT_DESTROY: tmpfs_destroy(callid, &call); break; - case VFS_OPEN_NODE: + case VFS_OUT_OPEN_NODE: tmpfs_open_node(callid, &call); break; - case VFS_DEVICE: + case VFS_OUT_DEVICE: tmpfs_device(callid, &call); break; - case VFS_SYNC: + case VFS_OUT_SYNC: tmpfs_sync(callid, &call); break; @@ -153,5 +153,5 @@ return -1; } - + int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info, tmpfs_connection); Index: uspace/srv/vfs/vfs.c =================================================================== --- uspace/srv/vfs/vfs.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/vfs/vfs.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -80,48 +80,48 @@ keep_on_going = false; break; - case VFS_REGISTER: + case VFS_IN_REGISTER: vfs_register(callid, &call); keep_on_going = false; break; - case VFS_MOUNT: + case VFS_IN_MOUNT: vfs_mount(callid, &call); break; - case VFS_OPEN: + case VFS_IN_OPEN: vfs_open(callid, &call); break; - case VFS_OPEN_NODE: + case VFS_IN_OPEN_NODE: vfs_open_node(callid, &call); break; - case VFS_CLOSE: + case VFS_IN_CLOSE: vfs_close(callid, &call); break; - case VFS_READ: + case VFS_IN_READ: vfs_read(callid, &call); break; - case VFS_WRITE: + case VFS_IN_WRITE: vfs_write(callid, &call); break; - case VFS_SEEK: + case VFS_IN_SEEK: vfs_seek(callid, &call); break; - case VFS_TRUNCATE: + case VFS_IN_TRUNCATE: vfs_truncate(callid, &call); break; - case VFS_MKDIR: + case VFS_IN_MKDIR: vfs_mkdir(callid, &call); break; - case VFS_UNLINK: + case VFS_IN_UNLINK: vfs_unlink(callid, &call); break; - case VFS_RENAME: + case VFS_IN_RENAME: vfs_rename(callid, &call); break; - case VFS_DEVICE: + case VFS_IN_DEVICE: vfs_device(callid, &call); break; - case VFS_SYNC: + case VFS_IN_SYNC: vfs_sync(callid, &call); break; - case VFS_NODE: + case VFS_IN_NODE: vfs_node(callid, &call); break; Index: uspace/srv/vfs/vfs_lookup.c =================================================================== --- uspace/srv/vfs/vfs_lookup.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/vfs/vfs_lookup.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -160,5 +160,5 @@ ipc_call_t answer; int phone = vfs_grab_phone(root->fs_handle); - aid_t req = async_send_5(phone, VFS_LOOKUP, (ipcarg_t) first, + aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (ipcarg_t) first, (ipcarg_t) (first + len - 1) % PLB_SIZE, (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index, @@ -205,5 +205,5 @@ ipc_call_t answer; - aid_t req = async_send_2(phone, VFS_OPEN_NODE, + aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE, (ipcarg_t) result->triplet.dev_handle, (ipcarg_t) result->triplet.index, &answer); Index: uspace/srv/vfs/vfs_node.c =================================================================== --- uspace/srv/vfs/vfs_node.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/vfs/vfs_node.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -130,5 +130,5 @@ int phone = vfs_grab_phone(node->fs_handle); ipcarg_t rc; - rc = async_req_2_0(phone, VFS_DESTROY, + rc = async_req_2_0(phone, VFS_OUT_DESTROY, (ipcarg_t)node->dev_handle, (ipcarg_t)node->index); assert(rc == EOK); Index: uspace/srv/vfs/vfs_ops.c =================================================================== --- uspace/srv/vfs/vfs_ops.c (revision 6408be36c6763b9e0ae86d2f2f07dbc9247e741e) +++ uspace/srv/vfs/vfs_ops.c (revision 4198f9c3ae7988eea2c8a649c01af1be31ded05d) @@ -109,5 +109,5 @@ /* * Now we hold a reference to mp_node. - * It will be dropped upon the corresponding VFS_UNMOUNT. + * It will be dropped upon the corresponding VFS_IN_UNMOUNT. * This prevents the mount point from being deleted. */ @@ -122,5 +122,5 @@ /* Tell the mountee that it is being mounted. */ phone = vfs_grab_phone(fs_handle); - msg = async_send_1(phone, VFS_MOUNTED, + msg = async_send_1(phone, VFS_OUT_MOUNTED, (ipcarg_t) dev_handle, &answer); /* send the mount options */ @@ -184,5 +184,5 @@ phone = vfs_grab_phone(mp_res.triplet.fs_handle); - msg = async_send_4(phone, VFS_MOUNT, + msg = async_send_4(phone, VFS_OUT_MOUNT, (ipcarg_t) mp_res.triplet.dev_handle, (ipcarg_t) mp_res.triplet.index, @@ -438,6 +438,6 @@ /* * The POSIX interface is open(path, oflag, mode). - * We can receive oflags and mode along with the VFS_OPEN call; the path - * will need to arrive in another call. + * We can receive oflags and mode along with the VFS_IN_OPEN call; + * the path will need to arrive in another call. * * We also receive one private, non-POSIX set of flags called lflag @@ -556,5 +556,5 @@ * It is necessary so that the file will not disappear when * vfs_node_put() is called. The reference will be dropped by the - * respective VFS_CLOSE. + * respective VFS_IN_CLOSE. */ vfs_node_addref(node); @@ -633,5 +633,5 @@ * It is necessary so that the file will not disappear when * vfs_node_put() is called. The reference will be dropped by the - * respective VFS_CLOSE. + * respective VFS_IN_CLOSE. */ vfs_node_addref(node); @@ -675,9 +675,9 @@ int fs_phone = vfs_grab_phone(file->node->fs_handle); - /* Make a VFS_DEVICE request at the destination FS server. */ + /* Make a VFS_OUT_DEVICE request at the destination FS server. */ aid_t msg; ipc_call_t answer; - msg = async_send_2(fs_phone, IPC_GET_METHOD(*request), - file->node->dev_handle, file->node->index, &answer); + msg = async_send_2(fs_phone, VFS_OUT_DEVICE, file->node->dev_handle, + file->node->index, &answer); /* Wait for reply from the FS server. */ @@ -709,9 +709,9 @@ int fs_phone = vfs_grab_phone(file->node->fs_handle); - /* Make a VFS_SYMC request at the destination FS server. */ + /* Make a VFS_OUT_SYMC request at the destination FS server. */ aid_t msg; ipc_call_t answer; - msg = async_send_2(fs_phone, IPC_GET_METHOD(*request), - file->node->dev_handle, file->node->index, &answer); + msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle, + file->node->index, &answer); /* Wait for reply from the FS server. */ @@ -743,9 +743,9 @@ int fs_phone = vfs_grab_phone(file->node->fs_handle); - /* Make a VFS_CLOSE request at the destination FS server. */ + /* Make a VFS_OUT_CLOSE request at the destination FS server. */ aid_t msg; ipc_call_t answer; - msg = async_send_2(fs_phone, IPC_GET_METHOD(*request), - file->node->dev_handle, file->node->index, &answer); + msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle, + file->node->index, &answer); /* Wait for reply from the FS server. */ @@ -833,5 +833,5 @@ if (!read && file->append) file->pos = file->node->size; - msg = async_send_3(fs_phone, IPC_GET_METHOD(*request), + msg = async_send_3(fs_phone, read ? VFS_OUT_READ : VFS_OUT_WRITE, file->node->dev_handle, file->node->index, file->pos, &answer); @@ -947,5 +947,5 @@ fs_phone = vfs_grab_phone(fs_handle); - rc = async_req_3_0(fs_phone, VFS_TRUNCATE, (ipcarg_t)dev_handle, + rc = async_req_3_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t)dev_handle, (ipcarg_t)index, (ipcarg_t)size); vfs_release_phone(fs_phone); @@ -1051,5 +1051,5 @@ * The name has already been unlinked by vfs_lookup_internal(). * We have to get and put the VFS node to ensure that it is - * VFS_DESTROY'ed after the last reference to it is dropped. + * VFS_OUT_DESTROY'ed after the last reference to it is dropped. */ vfs_node_t *node = vfs_node_get(&lr);