From 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9 Mon Sep 17 00:00:00 2001 From: Jakub Jermar Date: Thu, 22 Mar 2018 23:54:52 +0100 Subject: [PATCH] Get rid of rid in favor of req_handle --- uspace/lib/fs/libfs.c | 193 ++++++++++++++++++++------------------- uspace/srv/clipboard/clipboard.c | 31 ++++--- uspace/srv/loader/main.c | 63 ++++++------- uspace/srv/vfs/vfs_ipc.c | 76 +++++++-------- uspace/srv/vfs/vfs_pager.c | 6 +- uspace/srv/vfs/vfs_register.c | 22 ++--- 6 files changed, 198 insertions(+), 193 deletions(-) diff --git a/uspace/lib/fs/libfs.c b/uspace/lib/fs/libfs.c index 82e616409..800948aa2 100644 --- a/uspace/lib/fs/libfs.c +++ b/uspace/lib/fs/libfs.c @@ -57,9 +57,9 @@ #define combine_rc(rc1, rc2) \ ((rc1) == EOK ? (rc2) : (rc1)) -#define answer_and_return(rid, rc) \ +#define answer_and_return(chandle, rc) \ do { \ - async_answer_0((rid), (rc)); \ + async_answer_0((chandle), (rc)); \ return; \ } while (0) @@ -74,13 +74,14 @@ static void libfs_link(libfs_ops_t *, fs_handle_t, cap_call_handle_t, ipc_call_t *); static void libfs_lookup(libfs_ops_t *, fs_handle_t, cap_call_handle_t, ipc_call_t *); -static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t, ipc_call_t *); +static void libfs_stat(libfs_ops_t *, fs_handle_t, cap_call_handle_t, + ipc_call_t *); static void libfs_open_node(libfs_ops_t *, fs_handle_t, cap_call_handle_t, ipc_call_t *); static void libfs_statfs(libfs_ops_t *, fs_handle_t, cap_call_handle_t, ipc_call_t *); -static void vfs_out_fsprobe(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_fsprobe(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); errno_t rc; @@ -91,7 +92,7 @@ static void vfs_out_fsprobe(cap_call_handle_t rid, ipc_call_t *req) if ((!async_data_read_receive(&chandle, &size)) || (size != sizeof(info))) { async_answer_0(chandle, EIO); - async_answer_0(rid, EIO); + async_answer_0(req_handle, EIO); return; } @@ -99,15 +100,15 @@ static void vfs_out_fsprobe(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->fsprobe(service_id, &info); if (rc != EOK) { async_answer_0(chandle, EIO); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } async_data_read_finalize(chandle, &info, sizeof(info)); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); } -static void vfs_out_mounted(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_mounted(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); char *opts; @@ -116,7 +117,7 @@ static void vfs_out_mounted(cap_call_handle_t rid, ipc_call_t *req) /* Accept the mount options. */ rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } @@ -124,35 +125,36 @@ static void vfs_out_mounted(cap_call_handle_t rid, ipc_call_t *req) aoff64_t size; rc = vfs_out_ops->mounted(service_id, opts, &index, &size); - if (rc == EOK) - async_answer_3(rid, EOK, index, LOWER32(size), UPPER32(size)); - else - async_answer_0(rid, rc); + if (rc == EOK) { + async_answer_3(req_handle, EOK, index, LOWER32(size), + UPPER32(size)); + } else + async_answer_0(req_handle, rc); free(opts); } -static void vfs_out_unmounted(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_unmounted(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); errno_t rc; rc = vfs_out_ops->unmounted(service_id); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_link(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_link(cap_call_handle_t req_handle, ipc_call_t *req) { - libfs_link(libfs_ops, reg.fs_handle, rid, req); + libfs_link(libfs_ops, reg.fs_handle, req_handle, req); } -static void vfs_out_lookup(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_lookup(cap_call_handle_t req_handle, ipc_call_t *req) { - libfs_lookup(libfs_ops, reg.fs_handle, rid, req); + libfs_lookup(libfs_ops, reg.fs_handle, req_handle, req); } -static void vfs_out_read(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_read(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -164,12 +166,12 @@ static void vfs_out_read(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->read(service_id, index, pos, &rbytes); if (rc == EOK) - async_answer_1(rid, EOK, rbytes); + async_answer_1(req_handle, EOK, rbytes); else - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_write(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_write(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -182,13 +184,13 @@ static void vfs_out_write(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize); if (rc == EOK) { - async_answer_3(rid, EOK, wbytes, LOWER32(nsize), + async_answer_3(req_handle, EOK, wbytes, LOWER32(nsize), UPPER32(nsize)); } else - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_truncate(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_truncate(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -198,10 +200,10 @@ static void vfs_out_truncate(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->truncate(service_id, index, size); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_close(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_close(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -209,10 +211,10 @@ static void vfs_out_close(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->close(service_id, index); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_destroy(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_destroy(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -226,20 +228,20 @@ static void vfs_out_destroy(cap_call_handle_t rid, ipc_call_t *req) if (destroy) rc = vfs_out_ops->destroy(service_id, index); } - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_open_node(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_open_node(cap_call_handle_t req_handle, ipc_call_t *req) { - libfs_open_node(libfs_ops, reg.fs_handle, rid, req); + libfs_open_node(libfs_ops, reg.fs_handle, req_handle, req); } -static void vfs_out_stat(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_stat(cap_call_handle_t req_handle, ipc_call_t *req) { - libfs_stat(libfs_ops, reg.fs_handle, rid, req); + libfs_stat(libfs_ops, reg.fs_handle, req_handle, req); } -static void vfs_out_sync(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_sync(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -247,15 +249,15 @@ static void vfs_out_sync(cap_call_handle_t rid, ipc_call_t *req) rc = vfs_out_ops->sync(service_id, index); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_out_statfs(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_statfs(cap_call_handle_t req_handle, ipc_call_t *req) { - libfs_statfs(libfs_ops, reg.fs_handle, rid, req); + libfs_statfs(libfs_ops, reg.fs_handle, req_handle, req); } -static void vfs_out_is_empty(cap_call_handle_t rid, ipc_call_t *req) +static void vfs_out_is_empty(cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); @@ -264,20 +266,21 @@ static void vfs_out_is_empty(cap_call_handle_t rid, ipc_call_t *req) fs_node_t *node = NULL; rc = libfs_ops->node_get(&node, service_id, index); if (rc != EOK) - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); if (node == NULL) - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); bool children = false; rc = libfs_ops->has_children(&children, node); libfs_ops->node_put(node); if (rc != EOK) - async_answer_0(rid, rc); - async_answer_0(rid, children ? ENOTEMPTY : EOK); + async_answer_0(req_handle, rc); + async_answer_0(req_handle, children ? ENOTEMPTY : EOK); } -static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg) +static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, + void *arg) { if (icall_handle) { /* @@ -491,8 +494,8 @@ static errno_t receive_fname(char *buffer) /** Link a file at a path. */ -void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, - ipc_call_t *req) +void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, + cap_call_handle_t req_handle, ipc_call_t *req) { service_id_t parent_sid = IPC_GET_ARG1(*req); fs_index_t parent_index = IPC_GET_ARG2(*req); @@ -501,21 +504,21 @@ void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, char component[NAME_MAX + 1]; errno_t rc = receive_fname(component); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } fs_node_t *parent = NULL; rc = ops->node_get(&parent, parent_sid, parent_index); if (parent == NULL) { - async_answer_0(rid, rc == EOK ? EBADF : rc); + async_answer_0(req_handle, rc == EOK ? EBADF : rc); return; } fs_node_t *child = NULL; rc = ops->node_get(&child, parent_sid, child_index); if (child == NULL) { - async_answer_0(rid, rc == EOK ? EBADF : rc); + async_answer_0(req_handle, rc == EOK ? EBADF : rc); ops->node_put(parent); return; } @@ -523,7 +526,7 @@ void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, rc = ops->link(parent, child, component); ops->node_put(parent); ops->node_put(child); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } /** Lookup VFS triplet by name in the file system name space. @@ -531,16 +534,16 @@ void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, * The path passed in the PLB must be in the canonical file system path format * as returned by the canonify() function. * - * @param ops libfs operations structure with function pointers to - * file system implementation - * @param fs_handle File system handle of the file system where to perform - * the lookup. - * @param rid Request ID of the VFS_OUT_LOOKUP request. - * @param request VFS_OUT_LOOKUP request data itself. + * @param ops libfs operations structure with function pointers to + * file system implementation + * @param fs_handle File system handle of the file system where to perform + * the lookup. + * @param req_handle Call handle of the VFS_OUT_LOOKUP request. + * @param request VFS_OUT_LOOKUP request data itself. * */ -void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, - ipc_call_t *req) +void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, + cap_call_handle_t req_handle, ipc_call_t *req) { unsigned first = IPC_GET_ARG1(*req); unsigned len = IPC_GET_ARG2(*req); @@ -563,7 +566,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid rc = ops->node_get(&cur, service_id, index); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } @@ -580,7 +583,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid } if (!ops->is_directory(cur)) { - async_answer_0(rid, ENOTDIR); + async_answer_0(req_handle, ENOTDIR); goto out; } @@ -589,7 +592,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid rc = plb_get_component(component, &clen, &next, last); assert(rc != ERANGE); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } @@ -603,7 +606,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid /* Match the component */ rc = ops->match(&tmp, cur, component); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } @@ -611,7 +614,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid if (par) { rc = ops->node_put(par); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } } @@ -631,12 +634,12 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid /* Check for some error conditions. */ if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) { - async_answer_0(rid, EISDIR); + async_answer_0(req_handle, EISDIR); goto out; } if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) { - async_answer_0(rid, ENOTDIR); + async_answer_0(req_handle, ENOTDIR); goto out; } @@ -644,23 +647,23 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid if (lflag & L_UNLINK) { if (!cur) { - async_answer_0(rid, ENOENT); + async_answer_0(req_handle, ENOENT); goto out; } if (!par) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); goto out; } rc = ops->unlink(par, cur, component); if (rc == EOK) { aoff64_t size = ops->size_get(cur); - async_answer_5(rid, EOK, fs_handle, + async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur), (ops->is_directory(cur) << 16) | last, LOWER32(size), UPPER32(size)); } else { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } goto out; } @@ -669,7 +672,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid if (lflag & L_CREATE) { if (cur && (lflag & L_EXCLUSIVE)) { - async_answer_0(rid, EEXIST); + async_answer_0(req_handle, EEXIST); goto out; } @@ -677,11 +680,11 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid rc = ops->create(&cur, service_id, lflag & (L_FILE | L_DIRECTORY)); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } if (!cur) { - async_answer_0(rid, ENOSPC); + async_answer_0(req_handle, ENOSPC); goto out; } @@ -689,7 +692,7 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid if (rc != EOK) { (void) ops->destroy(cur); cur = NULL; - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); goto out; } } @@ -698,13 +701,13 @@ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid /* Return. */ out1: if (!cur) { - async_answer_5(rid, EOK, fs_handle, ops->index_get(par), + async_answer_5(req_handle, EOK, fs_handle, ops->index_get(par), (ops->is_directory(par) << 16) | last_next, LOWER32(ops->size_get(par)), UPPER32(ops->size_get(par))); goto out; } - async_answer_5(rid, EOK, fs_handle, ops->index_get(cur), + async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur), (ops->is_directory(cur) << 16) | last, LOWER32(ops->size_get(cur)), UPPER32(ops->size_get(cur))); @@ -719,15 +722,15 @@ out: (void) ops->node_put(tmp); } -void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, - ipc_call_t *request) +void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, + cap_call_handle_t req_handle, ipc_call_t *request) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); fs_node_t *fn; errno_t rc = ops->node_get(&fn, service_id, index); - on_error(rc, answer_and_return(rid, rc)); + on_error(rc, answer_and_return(req_handle, rc)); cap_call_handle_t chandle; size_t size; @@ -735,7 +738,7 @@ void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, (size != sizeof(vfs_stat_t))) { ops->node_put(fn); async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -755,18 +758,18 @@ void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t)); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); } -void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, - ipc_call_t *request) +void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, + cap_call_handle_t req_handle, ipc_call_t *request) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); fs_node_t *fn; errno_t rc = ops->node_get(&fn, service_id, index); - on_error(rc, answer_and_return(rid, rc)); + on_error(rc, answer_and_return(req_handle, rc)); cap_call_handle_t chandle; size_t size; @@ -800,42 +803,42 @@ void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid ops->node_put(fn); async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t)); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); return; error: ops->node_put(fn); async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); } /** Open VFS triplet. * - * @param ops libfs operations structure with function pointers to - * file system implementation - * @param rid Request ID of the VFS_OUT_OPEN_NODE request. - * @param request VFS_OUT_OPEN_NODE request data itself. + * @param ops libfs operations structure with function pointers to + * file system implementation + * @param req_handle Call handle of the VFS_OUT_OPEN_NODE request. + * @param request VFS_OUT_OPEN_NODE request data itself. * */ -void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid, - ipc_call_t *request) +void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, + cap_call_handle_t req_handle, ipc_call_t *request) { service_id_t service_id = IPC_GET_ARG1(*request); fs_index_t index = IPC_GET_ARG2(*request); fs_node_t *fn; errno_t rc = ops->node_get(&fn, service_id, index); - on_error(rc, answer_and_return(rid, rc)); + on_error(rc, answer_and_return(req_handle, rc)); if (fn == NULL) { - async_answer_0(rid, ENOENT); + async_answer_0(req_handle, ENOENT); return; } rc = ops->node_open(fn); aoff64_t size = ops->size_get(fn); - async_answer_4(rid, rc, LOWER32(size), UPPER32(size), + async_answer_4(req_handle, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn), (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0)); diff --git a/uspace/srv/clipboard/clipboard.c b/uspace/srv/clipboard/clipboard.c index ad6c40590..d20bacf9f 100644 --- a/uspace/srv/clipboard/clipboard.c +++ b/uspace/srv/clipboard/clipboard.c @@ -46,7 +46,7 @@ static clipboard_tag_t clip_tag = CLIPBOARD_TAG_NONE; static FIBRIL_MUTEX_INITIALIZE(clip_mtx); static service_id_t svc_id; -static void clip_put_data(cap_call_handle_t rid, ipc_call_t *request) +static void clip_put_data(cap_call_handle_t req_handle, ipc_call_t *request) { char *data; errno_t rc; @@ -64,12 +64,12 @@ static void clip_put_data(cap_call_handle_t rid, ipc_call_t *request) clip_tag = CLIPBOARD_TAG_NONE; fibril_mutex_unlock(&clip_mtx); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); break; case CLIPBOARD_TAG_DATA: rc = async_data_write_accept((void **) &data, false, 0, 0, 0, &size); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); break; } @@ -83,14 +83,14 @@ static void clip_put_data(cap_call_handle_t rid, ipc_call_t *request) clip_tag = CLIPBOARD_TAG_DATA; fibril_mutex_unlock(&clip_mtx); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); break; default: - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); } } -static void clip_get_data(cap_call_handle_t rid, ipc_call_t *request) +static void clip_get_data(cap_call_handle_t req_handle, ipc_call_t *request) { fibril_mutex_lock(&clip_mtx); @@ -102,45 +102,45 @@ static void clip_get_data(cap_call_handle_t rid, ipc_call_t *request) case CLIPBOARD_TAG_DATA: if (!async_data_read_receive(&chandle, &size)) { async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); break; } if (clip_tag != CLIPBOARD_TAG_DATA) { /* So far we only understand binary data */ async_answer_0(chandle, EOVERFLOW); - async_answer_0(rid, EOVERFLOW); + async_answer_0(req_handle, EOVERFLOW); break; } if (clip_size != size) { /* The client expects different size of data */ async_answer_0(chandle, EOVERFLOW); - async_answer_0(rid, EOVERFLOW); + async_answer_0(req_handle, EOVERFLOW); break; } errno_t retval = async_data_read_finalize(chandle, clip_data, size); if (retval != EOK) { - async_answer_0(rid, retval); + async_answer_0(req_handle, retval); break; } - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); break; default: /* * Sorry, we don't know how to get unknown or NONE * data from the clipbard */ - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); break; } fibril_mutex_unlock(&clip_mtx); } -static void clip_content(cap_call_handle_t rid, ipc_call_t *request) +static void clip_content(cap_call_handle_t req_handle, ipc_call_t *request) { fibril_mutex_lock(&clip_mtx); @@ -148,10 +148,11 @@ static void clip_content(cap_call_handle_t rid, ipc_call_t *request) clipboard_tag_t tag = clip_tag; fibril_mutex_unlock(&clip_mtx); - async_answer_2(rid, EOK, (sysarg_t) size, (sysarg_t) tag); + async_answer_2(req_handle, EOK, (sysarg_t) size, (sysarg_t) tag); } -static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg) +static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, + void *arg) { /* Accept connection */ async_answer_0(icall_handle, EOK); diff --git a/uspace/srv/loader/main.c b/uspace/srv/loader/main.c index 093b60767..06d4bc497 100644 --- a/uspace/srv/loader/main.c +++ b/uspace/srv/loader/main.c @@ -89,7 +89,7 @@ static elf_info_t prog_info; /** Used to limit number of connections to one. */ static bool connected = false; -static void ldr_get_taskid(cap_call_handle_t rid, ipc_call_t *request) +static void ldr_get_taskid(cap_call_handle_t req_handle, ipc_call_t *request) { cap_call_handle_t chandle; task_id_t task_id; @@ -99,7 +99,7 @@ static void ldr_get_taskid(cap_call_handle_t rid, ipc_call_t *request) if (!async_data_read_receive(&chandle, &len)) { async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -107,15 +107,15 @@ static void ldr_get_taskid(cap_call_handle_t rid, ipc_call_t *request) len = sizeof(task_id); async_data_read_finalize(chandle, &task_id, len); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); } /** Receive a call setting the current working directory. * - * @param rid + * @param req_handle * @param request */ -static void ldr_set_cwd(cap_call_handle_t rid, ipc_call_t *request) +static void ldr_set_cwd(cap_call_handle_t req_handle, ipc_call_t *request) { char *buf; errno_t rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, NULL); @@ -127,48 +127,48 @@ static void ldr_set_cwd(cap_call_handle_t rid, ipc_call_t *request) cwd = buf; } - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } /** Receive a call setting the program to execute. * - * @param rid + * @param req_handle * @param request */ -static void ldr_set_program(cap_call_handle_t rid, ipc_call_t *request) +static void ldr_set_program(cap_call_handle_t req_handle, ipc_call_t *request) { cap_call_handle_t write_chandle; size_t namesize; if (!async_data_write_receive(&write_chandle, &namesize)) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } char* name = malloc(namesize); errno_t rc = async_data_write_finalize(write_chandle, name, namesize); if (rc != EOK) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } int file; rc = vfs_receive_handle(true, &file); if (rc != EOK) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } progname = name; program_fd = file; - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); } /** Receive a call setting arguments of the program to execute. * - * @param rid + * @param req_handle * @param request */ -static void ldr_set_args(cap_call_handle_t rid, ipc_call_t *request) +static void ldr_set_args(cap_call_handle_t req_handle, ipc_call_t *request) { char *buf; size_t buf_size; @@ -193,7 +193,7 @@ static void ldr_set_args(cap_call_handle_t rid, ipc_call_t *request) char **_argv = (char **) malloc((count + 1) * sizeof(char *)); if (_argv == NULL) { free(buf); - async_answer_0(rid, ENOMEM); + async_answer_0(req_handle, ENOMEM); return; } @@ -225,39 +225,39 @@ static void ldr_set_args(cap_call_handle_t rid, ipc_call_t *request) argv = _argv; } - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } /** Receive a call setting inbox files of the program to execute. * - * @param rid + * @param req_handle * @param request */ -static void ldr_add_inbox(cap_call_handle_t rid, ipc_call_t *request) +static void ldr_add_inbox(cap_call_handle_t req_handle, ipc_call_t *request) { if (inbox_entries == INBOX_MAX_ENTRIES) { - async_answer_0(rid, ERANGE); + async_answer_0(req_handle, ERANGE); return; } cap_call_handle_t write_chandle; size_t namesize; if (!async_data_write_receive(&write_chandle, &namesize)) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } char* name = malloc(namesize); errno_t rc = async_data_write_finalize(write_chandle, name, namesize); if (rc != EOK) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } int file; rc = vfs_receive_handle(true, &file); if (rc != EOK) { - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -271,21 +271,21 @@ static void ldr_add_inbox(cap_call_handle_t rid, ipc_call_t *request) inbox[inbox_entries].name = name; inbox[inbox_entries].file = file; inbox_entries++; - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); } /** Load the previously selected program. * - * @param rid + * @param req_handle * @param request * @return 0 on success, !0 on error. */ -static int ldr_load(cap_call_handle_t rid, ipc_call_t *request) +static int ldr_load(cap_call_handle_t req_handle, ipc_call_t *request) { int rc = elf_load(program_fd, &prog_info); if (rc != EE_OK) { DPRINTF("Failed to load executable for '%s'.\n", progname); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return 1; } @@ -299,17 +299,17 @@ static int ldr_load(cap_call_handle_t rid, ipc_call_t *request) pcb.inbox = inbox; pcb.inbox_entries = inbox_entries; - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); return 0; } /** Run the previously loaded program. * - * @param rid + * @param req_handle * @param request * @return 0 on success, !0 on error. */ -static __attribute__((noreturn)) void ldr_run(cap_call_handle_t rid, +static __attribute__((noreturn)) void ldr_run(cap_call_handle_t req_handle, ipc_call_t *request) { DPRINTF("Set task name\n"); @@ -319,7 +319,7 @@ static __attribute__((noreturn)) void ldr_run(cap_call_handle_t rid, /* Run program */ DPRINTF("Reply OK\n"); - async_answer_0(rid, EOK); + async_answer_0(req_handle, EOK); DPRINTF("Jump to entry point at %p\n", pcb.entry); entry_point_jmp(prog_info.finfo.entry, &pcb); @@ -331,7 +331,8 @@ static __attribute__((noreturn)) void ldr_run(cap_call_handle_t rid, * Receive and carry out commands (of which the last one should be * to execute the loaded program). */ -static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg) +static void ldr_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, + void *arg) { /* Already have a connection? */ if (connected) { diff --git a/uspace/srv/vfs/vfs_ipc.c b/uspace/srv/vfs/vfs_ipc.c index c5f961a52..6e2f4cc89 100644 --- a/uspace/srv/vfs/vfs_ipc.c +++ b/uspace/srv/vfs/vfs_ipc.c @@ -34,7 +34,7 @@ #include #include -static void vfs_in_clone(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_clone(cap_call_handle_t req_handle, ipc_call_t *request) { int oldfd = IPC_GET_ARG1(*request); int newfd = IPC_GET_ARG2(*request); @@ -42,10 +42,10 @@ static void vfs_in_clone(cap_call_handle_t rid, ipc_call_t *request) int outfd = -1; errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd); - async_answer_1(rid, rc, outfd); + async_answer_1(req_handle, rc, outfd); } -static void vfs_in_fsprobe(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_fsprobe(cap_call_handle_t req_handle, ipc_call_t *request) { service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request); char *fs_name = NULL; @@ -61,12 +61,12 @@ static void vfs_in_fsprobe(cap_call_handle_t rid, ipc_call_t *request) rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN, 0, NULL); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } rc = vfs_op_fsprobe(fs_name, service_id, &info); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); if (rc != EOK) goto out; @@ -82,7 +82,7 @@ out: free(fs_name); } -static void vfs_in_fstypes(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_fstypes(cap_call_handle_t req_handle, ipc_call_t *request) { cap_call_handle_t chandle; size_t len; @@ -91,12 +91,12 @@ static void vfs_in_fstypes(cap_call_handle_t rid, ipc_call_t *request) rc = vfs_get_fstypes(&fstypes); if (rc != EOK) { - async_answer_0(rid, ENOMEM); + async_answer_0(req_handle, ENOMEM); return; } /* Send size of the data */ - async_answer_1(rid, EOK, fstypes.size); + async_answer_1(req_handle, EOK, fstypes.size); /* Now we should get a read request */ if (!async_data_read_receive(&chandle, &len)) @@ -110,7 +110,7 @@ out: vfs_fstypes_free(&fstypes); } -static void vfs_in_mount(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_mount(cap_call_handle_t req_handle, ipc_call_t *request) { int mpfd = IPC_GET_ARG1(*request); @@ -131,7 +131,7 @@ static void vfs_in_mount(cap_call_handle_t rid, ipc_call_t *request) errno_t rc = async_data_write_accept((void **) &opts, true, 0, MAX_MNTOPTS_LEN, 0, NULL); if (rc != EOK) { - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } @@ -142,36 +142,36 @@ static void vfs_in_mount(cap_call_handle_t rid, ipc_call_t *request) FS_NAME_MAXLEN, 0, NULL); if (rc != EOK) { free(opts); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } int outfd = 0; rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name, &outfd); - async_answer_1(rid, rc, outfd); + async_answer_1(req_handle, rc, outfd); free(opts); free(fs_name); } -static void vfs_in_open(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_open(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); int mode = IPC_GET_ARG2(*request); errno_t rc = vfs_op_open(fd, mode); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_put(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_put(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); errno_t rc = vfs_op_put(fd); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_read(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_read(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request), @@ -179,10 +179,10 @@ static void vfs_in_read(cap_call_handle_t rid, ipc_call_t *request) size_t bytes = 0; errno_t rc = vfs_op_read(fd, pos, &bytes); - async_answer_1(rid, rc, bytes); + async_answer_1(req_handle, rc, bytes); } -static void vfs_in_rename(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_rename(cap_call_handle_t req_handle, ipc_call_t *request) { /* The common base directory. */ int basefd; @@ -218,7 +218,7 @@ static void vfs_in_rename(cap_call_handle_t rid, ipc_call_t *request) rc = vfs_op_rename(basefd, oldc, newc); out: - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); if (old) free(old); @@ -226,37 +226,37 @@ out: free(new); } -static void vfs_in_resize(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_resize(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); int64_t size = MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request)); errno_t rc = vfs_op_resize(fd, size); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_stat(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_stat(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); errno_t rc = vfs_op_stat(fd); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_statfs(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_statfs(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = (int) IPC_GET_ARG1(*request); errno_t rc = vfs_op_statfs(fd); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_sync(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_sync(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); errno_t rc = vfs_op_sync(fd); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_unlink(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_unlink(cap_call_handle_t req_handle, ipc_call_t *request) { int parentfd = IPC_GET_ARG1(*request); int expectfd = IPC_GET_ARG2(*request); @@ -266,25 +266,25 @@ static void vfs_in_unlink(cap_call_handle_t rid, ipc_call_t *request) if (rc == EOK) rc = vfs_op_unlink(parentfd, expectfd, path); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_unmount(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_unmount(cap_call_handle_t req_handle, ipc_call_t *request) { int mpfd = IPC_GET_ARG1(*request); errno_t rc = vfs_op_unmount(mpfd); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); } -static void vfs_in_wait_handle(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_wait_handle(cap_call_handle_t req_handle, ipc_call_t *request) { bool high_fd = IPC_GET_ARG1(*request); int fd = -1; errno_t rc = vfs_op_wait_handle(high_fd, &fd); - async_answer_1(rid, rc, fd); + async_answer_1(req_handle, rc, fd); } -static void vfs_in_walk(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_walk(cap_call_handle_t req_handle, ipc_call_t *request) { /* * Parent is our relative root for file lookup. @@ -300,10 +300,10 @@ static void vfs_in_walk(cap_call_handle_t rid, ipc_call_t *request) rc = vfs_op_walk(parentfd, flags, path, &fd); free(path); } - async_answer_1(rid, rc, fd); + async_answer_1(req_handle, rc, fd); } -static void vfs_in_write(cap_call_handle_t rid, ipc_call_t *request) +static void vfs_in_write(cap_call_handle_t req_handle, ipc_call_t *request) { int fd = IPC_GET_ARG1(*request); aoff64_t pos = MERGE_LOUP32(IPC_GET_ARG2(*request), @@ -311,7 +311,7 @@ static void vfs_in_write(cap_call_handle_t rid, ipc_call_t *request) size_t bytes = 0; errno_t rc = vfs_op_write(fd, pos, &bytes); - async_answer_1(rid, rc, bytes); + async_answer_1(req_handle, rc, bytes); } void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg) diff --git a/uspace/srv/vfs/vfs_pager.c b/uspace/srv/vfs/vfs_pager.c index 207da9865..239ab67b1 100644 --- a/uspace/srv/vfs/vfs_pager.c +++ b/uspace/srv/vfs/vfs_pager.c @@ -41,7 +41,7 @@ #include #include -void vfs_page_in(cap_call_handle_t rid, ipc_call_t *request) +void vfs_page_in(cap_call_handle_t req_handle, ipc_call_t *request) { aoff64_t offset = IPC_GET_ARG1(*request); size_t page_size = IPC_GET_ARG2(*request); @@ -54,7 +54,7 @@ void vfs_page_in(cap_call_handle_t rid, ipc_call_t *request) AS_AREA_UNPAGED); if (page == AS_MAP_FAILED) { - async_answer_0(rid, ENOMEM); + async_answer_0(req_handle, ENOMEM); return; } @@ -77,7 +77,7 @@ void vfs_page_in(cap_call_handle_t rid, ipc_call_t *request) chunk.size = page_size - total; } while (total < page_size); - async_answer_1(rid, rc, (sysarg_t) page); + async_answer_1(req_handle, rc, (sysarg_t) page); /* * FIXME: diff --git a/uspace/srv/vfs/vfs_register.c b/uspace/srv/vfs/vfs_register.c index 487021f04..240f666be 100644 --- a/uspace/srv/vfs/vfs_register.c +++ b/uspace/srv/vfs/vfs_register.c @@ -107,11 +107,11 @@ static bool vfs_info_sane(vfs_info_t *info) /** VFS_REGISTER protocol function. * - * @param rid Hash of the call with the request. - * @param request Call structure with the request. + * @param req_handle Call handle of the request. + * @param request Call structure with the request. * */ -void vfs_register(cap_call_handle_t rid, ipc_call_t *request) +void vfs_register(cap_call_handle_t req_handle, ipc_call_t *request) { dprintf("Processing VFS_REGISTER request received from %zx.\n", request->in_phone_hash); @@ -123,7 +123,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) if (rc != EOK) { dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n", rc); - async_answer_0(rid, rc); + async_answer_0(req_handle, rc); return; } @@ -133,7 +133,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) fs_info_t *fs_info = (fs_info_t *) malloc(sizeof(fs_info_t)); if (!fs_info) { dprintf("Could not allocate memory for FS info.\n"); - async_answer_0(rid, ENOMEM); + async_answer_0(req_handle, ENOMEM); return; } @@ -145,7 +145,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) if (!vfs_info_sane(&fs_info->vfs_info)) { free(fs_info); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -162,7 +162,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) dprintf("FS is already registered.\n"); fibril_mutex_unlock(&fs_list_lock); free(fs_info); - async_answer_0(rid, EEXIST); + async_answer_0(req_handle, EEXIST); return; } @@ -183,7 +183,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) list_remove(&fs_info->fs_link); fibril_mutex_unlock(&fs_list_lock); free(fs_info); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -202,7 +202,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) async_hangup(fs_info->sess); free(fs_info); async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -216,7 +216,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) async_hangup(fs_info->sess); free(fs_info); async_answer_0(chandle, EINVAL); - async_answer_0(rid, EINVAL); + async_answer_0(req_handle, EINVAL); return; } @@ -234,7 +234,7 @@ void vfs_register(cap_call_handle_t rid, ipc_call_t *request) * system a global file system handle. */ fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next); - async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle); + async_answer_1(req_handle, EOK, (sysarg_t) fs_info->fs_handle); fibril_condvar_broadcast(&fs_list_cv); fibril_mutex_unlock(&fs_list_lock); -- 2.11.4.GIT