Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/lib/fs/libfs.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -58,7 +58,7 @@
 	((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)
@@ -75,5 +75,6 @@
 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 *);
@@ -81,5 +82,5 @@
     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);
@@ -92,5 +93,5 @@
 	    (size != sizeof(info))) {
 		async_answer_0(chandle, EIO);
-		async_answer_0(rid, EIO);
+		async_answer_0(req_handle, EIO);
 		return;
 	}
@@ -100,13 +101,13 @@
 	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);
-}
-
-static void vfs_out_mounted(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, EOK);
+}
+
+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);
@@ -117,5 +118,5 @@
 	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;
 	}
@@ -125,13 +126,14 @@
 	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);
@@ -140,18 +142,18 @@
 	rc = vfs_out_ops->unmounted(service_id);
 
-	async_answer_0(rid, rc);
-}
-
-static void vfs_out_link(cap_call_handle_t rid, ipc_call_t *req)
-{
-	libfs_link(libfs_ops, reg.fs_handle, rid, req);
-}
-
-static void vfs_out_lookup(cap_call_handle_t rid, ipc_call_t *req)
-{
-	libfs_lookup(libfs_ops, reg.fs_handle, rid, req);
-}
-
-static void vfs_out_read(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, rc);
+}
+
+static void vfs_out_link(cap_call_handle_t req_handle, ipc_call_t *req)
+{
+	libfs_link(libfs_ops, reg.fs_handle, req_handle, req);
+}
+
+static void vfs_out_lookup(cap_call_handle_t req_handle, ipc_call_t *req)
+{
+	libfs_lookup(libfs_ops, reg.fs_handle, req_handle, 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);
@@ -165,10 +167,10 @@
 
 	if (rc == EOK)
-		async_answer_1(rid, EOK, rbytes);
+		async_answer_1(req_handle, EOK, rbytes);
 	else
-		async_answer_0(rid, rc);
-}
-
-static void vfs_out_write(cap_call_handle_t rid, ipc_call_t *req)
+		async_answer_0(req_handle, rc);
+}
+
+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);
@@ -183,11 +185,11 @@
 
 	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);
-}
-
-static void vfs_out_truncate(cap_call_handle_t rid, ipc_call_t *req)
+		async_answer_0(req_handle, rc);
+}
+
+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);
@@ -199,8 +201,8 @@
 	rc = vfs_out_ops->truncate(service_id, index, size);
 
-	async_answer_0(rid, rc);
-}
-
-static void vfs_out_close(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, rc);
+}
+
+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);
@@ -210,8 +212,8 @@
 	rc = vfs_out_ops->close(service_id, index);
 
-	async_answer_0(rid, rc);
-}
-
-static void vfs_out_destroy(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, rc);
+}
+
+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);
@@ -227,18 +229,18 @@
 			rc = vfs_out_ops->destroy(service_id, index);
 	}
-	async_answer_0(rid, rc);
-}
-
-static void vfs_out_open_node(cap_call_handle_t rid, ipc_call_t *req)
-{
-	libfs_open_node(libfs_ops, reg.fs_handle, rid, req);
-}
-
-static void vfs_out_stat(cap_call_handle_t rid, ipc_call_t *req)
-{
-	libfs_stat(libfs_ops, reg.fs_handle, rid, req);
-}
-
-static void vfs_out_sync(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, rc);
+}
+
+static void vfs_out_open_node(cap_call_handle_t req_handle, ipc_call_t *req)
+{
+	libfs_open_node(libfs_ops, reg.fs_handle, req_handle, req);
+}
+
+static void vfs_out_stat(cap_call_handle_t req_handle, ipc_call_t *req)
+{
+	libfs_stat(libfs_ops, reg.fs_handle, req_handle, 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);
@@ -248,13 +250,13 @@
 	rc = vfs_out_ops->sync(service_id, index);
 
-	async_answer_0(rid, rc);
-}
-
-static void vfs_out_statfs(cap_call_handle_t rid, ipc_call_t *req)
-{
-	libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
-}
-
-static void vfs_out_is_empty(cap_call_handle_t rid, ipc_call_t *req)
+	async_answer_0(req_handle, rc);
+}
+
+static void vfs_out_statfs(cap_call_handle_t req_handle, ipc_call_t *req)
+{
+	libfs_statfs(libfs_ops, reg.fs_handle, req_handle, 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);
@@ -265,7 +267,7 @@
 	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;
@@ -274,9 +276,10 @@
 
 	if (rc != EOK)
-		async_answer_0(rid, rc);
-	async_answer_0(rid, children ? ENOTEMPTY : EOK);
-}
-
-static void vfs_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+		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)
 {
 	if (icall_handle) {
@@ -492,6 +495,6 @@
 /** 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);
@@ -502,5 +505,5 @@
 	errno_t rc = receive_fname(component);
 	if (rc != EOK) {
-		async_answer_0(rid, rc);
+		async_answer_0(req_handle, rc);
 		return;
 	}
@@ -509,5 +512,5 @@
 	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;
 	}
@@ -516,5 +519,5 @@
 	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;
@@ -524,5 +527,5 @@
 	ops->node_put(parent);
 	ops->node_put(child);
-	async_answer_0(rid, rc);
+	async_answer_0(req_handle, rc);
 }
 
@@ -532,14 +535,14 @@
  * 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);
@@ -564,5 +567,5 @@
 	rc = ops->node_get(&cur, service_id, index);
 	if (rc != EOK) {
-		async_answer_0(rid, rc);
+		async_answer_0(req_handle, rc);
 		goto out;
 	}
@@ -581,5 +584,5 @@
 
 		if (!ops->is_directory(cur)) {
-			async_answer_0(rid, ENOTDIR);
+			async_answer_0(req_handle, ENOTDIR);
 			goto out;
 		}
@@ -590,5 +593,5 @@
 		assert(rc != ERANGE);
 		if (rc != EOK) {
-			async_answer_0(rid, rc);
+			async_answer_0(req_handle, rc);
 			goto out;
 		}
@@ -604,5 +607,5 @@
 		rc = ops->match(&tmp, cur, component);
 		if (rc != EOK) {
-			async_answer_0(rid, rc);
+			async_answer_0(req_handle, rc);
 			goto out;
 		}
@@ -612,5 +615,5 @@
 			rc = ops->node_put(par);
 			if (rc != EOK) {
-				async_answer_0(rid, rc);
+				async_answer_0(req_handle, rc);
 				goto out;
 			}
@@ -632,10 +635,10 @@
 
 	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;
 	}
@@ -645,9 +648,9 @@
 	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;
 		}
@@ -656,10 +659,10 @@
 		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;
@@ -670,5 +673,5 @@
 	if (lflag & L_CREATE) {
 		if (cur && (lflag & L_EXCLUSIVE)) {
-			async_answer_0(rid, EEXIST);
+			async_answer_0(req_handle, EEXIST);
 			goto out;
 		}
@@ -678,9 +681,9 @@
 			    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;
 			}
@@ -690,5 +693,5 @@
 				(void) ops->destroy(cur);
 				cur = NULL;
-				async_answer_0(rid, rc);
+				async_answer_0(req_handle, rc);
 				goto out;
 			}
@@ -699,5 +702,5 @@
 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)));
@@ -705,5 +708,5 @@
 	}
 
-	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)));
@@ -720,6 +723,6 @@
 }
 
-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);
@@ -728,5 +731,5 @@
 	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;
@@ -736,5 +739,5 @@
 		ops->node_put(fn);
 		async_answer_0(chandle, EINVAL);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -756,9 +759,9 @@
 
 	async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
-	async_answer_0(rid, EOK);
-}
-
-void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, cap_call_handle_t rid,
-    ipc_call_t *request)
+	async_answer_0(req_handle, EOK);
+}
+
+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);
@@ -767,5 +770,5 @@
 	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;
@@ -801,5 +804,5 @@
 	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;
 
@@ -807,5 +810,5 @@
 	ops->node_put(fn);
 	async_answer_0(chandle, EINVAL);
-	async_answer_0(rid, EINVAL);
+	async_answer_0(req_handle, EINVAL);
 }
 
@@ -813,12 +816,12 @@
 /** 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);
@@ -827,8 +830,8 @@
 	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;
 	}
@@ -836,5 +839,5 @@
 	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) |
Index: uspace/srv/clipboard/clipboard.c
===================================================================
--- uspace/srv/clipboard/clipboard.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/srv/clipboard/clipboard.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -47,5 +47,5 @@
 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;
@@ -65,10 +65,10 @@
 
 		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;
 		}
@@ -84,12 +84,12 @@
 
 		fibril_mutex_unlock(&clip_mtx);
-		async_answer_0(rid, EOK);
+		async_answer_0(req_handle, EOK);
 		break;
 	default:
-		async_answer_0(rid, EINVAL);
-	}
-}
-
-static void clip_get_data(cap_call_handle_t rid, ipc_call_t *request)
+		async_answer_0(req_handle, EINVAL);
+	}
+}
+
+static void clip_get_data(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	fibril_mutex_lock(&clip_mtx);
@@ -103,5 +103,5 @@
 		if (!async_data_read_receive(&chandle, &size)) {
 			async_answer_0(chandle, EINVAL);
-			async_answer_0(rid, EINVAL);
+			async_answer_0(req_handle, EINVAL);
 			break;
 		}
@@ -110,5 +110,5 @@
 			/* So far we only understand binary data */
 			async_answer_0(chandle, EOVERFLOW);
-			async_answer_0(rid, EOVERFLOW);
+			async_answer_0(req_handle, EOVERFLOW);
 			break;
 		}
@@ -117,5 +117,5 @@
 			/* The client expects different size of data */
 			async_answer_0(chandle, EOVERFLOW);
-			async_answer_0(rid, EOVERFLOW);
+			async_answer_0(req_handle, EOVERFLOW);
 			break;
 		}
@@ -123,9 +123,9 @@
 		errno_t retval = async_data_read_finalize(chandle, clip_data, size);
 		if (retval != EOK) {
-			async_answer_0(rid, retval);
-			break;
-		}
-
-		async_answer_0(rid, EOK);
+			async_answer_0(req_handle, retval);
+			break;
+		}
+
+		async_answer_0(req_handle, EOK);
 		break;
 	default:
@@ -134,5 +134,5 @@
 		 * data from the clipbard
 		 */
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		break;
 	}
@@ -141,5 +141,5 @@
 }
 
-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);
@@ -149,8 +149,9 @@
 
 	fibril_mutex_unlock(&clip_mtx);
-	async_answer_2(rid, EOK, (sysarg_t) size, (sysarg_t) tag);
-}
-
-static void clip_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
+	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)
 {
 	/* Accept connection */
Index: uspace/srv/loader/main.c
===================================================================
--- uspace/srv/loader/main.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/srv/loader/main.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -90,5 +90,5 @@
 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;
@@ -100,5 +100,5 @@
 	if (!async_data_read_receive(&chandle, &len)) {
 		async_answer_0(chandle, EINVAL);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -108,13 +108,13 @@
 
 	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 request
- */
-static void ldr_set_cwd(cap_call_handle_t rid, ipc_call_t *request)
+ * @param req_handle
+ * @param request
+ */
+static void ldr_set_cwd(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	char *buf;
@@ -128,18 +128,18 @@
 	}
 
-	async_answer_0(rid, rc);
+	async_answer_0(req_handle, rc);
 }
 
 /** Receive a call setting the program to execute.
  *
- * @param rid
- * @param request
- */
-static void ldr_set_program(cap_call_handle_t rid, ipc_call_t *request)
+ * @param req_handle
+ * @param 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;
 	}
@@ -148,5 +148,5 @@
 	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;
 	}
@@ -155,5 +155,5 @@
 	rc = vfs_receive_handle(true, &file);
 	if (rc != EOK) {
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -161,13 +161,13 @@
 	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 request
- */
-static void ldr_set_args(cap_call_handle_t rid, ipc_call_t *request)
+ * @param req_handle
+ * @param request
+ */
+static void ldr_set_args(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	char *buf;
@@ -194,5 +194,5 @@
 		if (_argv == NULL) {
 			free(buf);
-			async_answer_0(rid, ENOMEM);
+			async_answer_0(req_handle, ENOMEM);
 			return;
 		}
@@ -226,16 +226,16 @@
 	}
 
-	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 request
- */
-static void ldr_add_inbox(cap_call_handle_t rid, ipc_call_t *request)
+ * @param req_handle
+ * @param 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;
 	}
@@ -244,5 +244,5 @@
 	size_t namesize;
 	if (!async_data_write_receive(&write_chandle, &namesize)) {
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -251,5 +251,5 @@
 	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;
 	}
@@ -258,5 +258,5 @@
 	rc = vfs_receive_handle(true, &file);
 	if (rc != EOK) {
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -272,19 +272,19 @@
 	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;
 	}
@@ -300,5 +300,5 @@
 	pcb.inbox_entries = inbox_entries;
 
-	async_answer_0(rid, EOK);
+	async_answer_0(req_handle, EOK);
 	return 0;
 }
@@ -306,9 +306,9 @@
 /** 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)
 {
@@ -320,5 +320,5 @@
 	/* 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);
@@ -332,5 +332,6 @@
  * 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? */
Index: uspace/srv/vfs/vfs_ipc.c
===================================================================
--- uspace/srv/vfs/vfs_ipc.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/srv/vfs/vfs_ipc.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -35,5 +35,5 @@
 #include <vfs/canonify.h>
 
-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);
@@ -43,8 +43,8 @@
 	int outfd = -1;
 	errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd);
-	async_answer_1(rid, rc, outfd);
-}
-
-static void vfs_in_fsprobe(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_1(req_handle, rc, outfd);
+}
+
+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);
@@ -62,10 +62,10 @@
 	    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;
@@ -83,5 +83,5 @@
 }
 
-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;
@@ -92,10 +92,10 @@
 	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 */
@@ -111,5 +111,5 @@
 }
 
-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);
@@ -132,5 +132,5 @@
 	    MAX_MNTOPTS_LEN, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(rid, rc);
+		async_answer_0(req_handle, rc);
 		return;
 	}
@@ -143,5 +143,5 @@
 	if (rc != EOK) {
 		free(opts);
-		async_answer_0(rid, rc);
+		async_answer_0(req_handle, rc);
 		return;
 	}
@@ -150,5 +150,5 @@
 	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);
@@ -156,5 +156,5 @@
 }
 
-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);
@@ -162,15 +162,15 @@
 
 	errno_t rc = vfs_op_open(fd, mode);
-	async_answer_0(rid, rc);
-}
-
-static void vfs_in_put(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_read(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+static void vfs_in_read(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	int fd = IPC_GET_ARG1(*request);
@@ -180,8 +180,8 @@
 	size_t bytes = 0;
 	errno_t rc = vfs_op_read(fd, pos, &bytes);
-	async_answer_1(rid, rc, bytes);
-}
-
-static void vfs_in_rename(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_1(req_handle, rc, bytes);
+}
+
+static void vfs_in_rename(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	/* The common base directory. */
@@ -219,5 +219,5 @@
 
 out:
-	async_answer_0(rid, rc);
+	async_answer_0(req_handle, rc);
 
 	if (old)
@@ -227,35 +227,35 @@
 }
 
-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);
-}
-
-static void vfs_in_stat(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_statfs(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_sync(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_unlink(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+static void vfs_in_unlink(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	int parentfd = IPC_GET_ARG1(*request);
@@ -267,23 +267,23 @@
 		rc = vfs_op_unlink(parentfd, expectfd, path);
 
-	async_answer_0(rid, rc);
-}
-
-static void vfs_in_unmount(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_wait_handle(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_0(req_handle, rc);
+}
+
+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);
-}
-
-static void vfs_in_walk(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_1(req_handle, rc, fd);
+}
+
+static void vfs_in_walk(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	/*
@@ -301,8 +301,8 @@
 		free(path);
 	}
-	async_answer_1(rid, rc, fd);
-}
-
-static void vfs_in_write(cap_call_handle_t rid, ipc_call_t *request)
+	async_answer_1(req_handle, rc, fd);
+}
+
+static void vfs_in_write(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	int fd = IPC_GET_ARG1(*request);
@@ -312,5 +312,5 @@
 	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);
 }
 
Index: uspace/srv/vfs/vfs_pager.c
===================================================================
--- uspace/srv/vfs/vfs_pager.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/srv/vfs/vfs_pager.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -42,5 +42,5 @@
 #include <as.h>
 
-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);
@@ -55,5 +55,5 @@
 
 	if (page == AS_MAP_FAILED) {
-		async_answer_0(rid, ENOMEM);
+		async_answer_0(req_handle, ENOMEM);
 		return;
 	}
@@ -78,5 +78,5 @@
 	} while (total < page_size);
 
-	async_answer_1(rid, rc, (sysarg_t) page);
+	async_answer_1(req_handle, rc, (sysarg_t) page);
 
 	/*
Index: uspace/srv/vfs/vfs_register.c
===================================================================
--- uspace/srv/vfs/vfs_register.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
+++ uspace/srv/vfs/vfs_register.c	(revision 77f0a1d4bb8b6671f79bcf1c047b1bb9ada543c9)
@@ -108,9 +108,9 @@
 /** VFS_REGISTER protocol function.
  *
- * @param rid     Hash of the call with the request.
- * @param request Call structure with the request.
- *
- */
-void vfs_register(cap_call_handle_t rid, ipc_call_t *request)
+ * @param req_handle  Call handle of the request.
+ * @param request     Call structure with the request.
+ *
+ */
+void vfs_register(cap_call_handle_t req_handle, ipc_call_t *request)
 {
 	dprintf("Processing VFS_REGISTER request received from %zx.\n",
@@ -124,5 +124,5 @@
 		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;
 	}
@@ -134,5 +134,5 @@
 	if (!fs_info) {
 		dprintf("Could not allocate memory for FS info.\n");
-		async_answer_0(rid, ENOMEM);
+		async_answer_0(req_handle, ENOMEM);
 		return;
 	}
@@ -146,5 +146,5 @@
 	if (!vfs_info_sane(&fs_info->vfs_info)) {
 		free(fs_info);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -163,5 +163,5 @@
 		fibril_mutex_unlock(&fs_list_lock);
 		free(fs_info);
-		async_answer_0(rid, EEXIST);
+		async_answer_0(req_handle, EEXIST);
 		return;
 	}
@@ -184,5 +184,5 @@
 		fibril_mutex_unlock(&fs_list_lock);
 		free(fs_info);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -203,5 +203,5 @@
 		free(fs_info);
 		async_answer_0(chandle, EINVAL);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -217,5 +217,5 @@
 		free(fs_info);
 		async_answer_0(chandle, EINVAL);
-		async_answer_0(rid, EINVAL);
+		async_answer_0(req_handle, EINVAL);
 		return;
 	}
@@ -235,5 +235,5 @@
 	 */
 	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);