Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 7c3fb9bd77e4d2f6c10517a052e567f176fa91ee)
+++ uspace/lib/fs/libfs.c	(revision 984a9ba2fa05c490a7066737655ed19130c714e8)
@@ -58,7 +58,7 @@
 	((rc1) == EOK ? (rc2) : (rc1))
 
-#define answer_and_return(chandle, rc) \
+#define answer_and_return(call, rc) \
 	do { \
-		async_answer_0((chandle), (rc)); \
+		async_answer_0((call), (rc)); \
 		return; \
 	} while (0)
@@ -71,16 +71,11 @@
 static char fs_name[FS_NAME_MAXLEN + 1];
 
-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_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 req_handle, ipc_call_t *req)
+static void libfs_link(libfs_ops_t *, fs_handle_t, ipc_call_t *);
+static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_call_t *);
+static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_call_t *);
+static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_call_t *);
+static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_call_t *);
+
+static void vfs_out_fsprobe(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -88,10 +83,10 @@
 	vfs_fs_probe_info_t info;
 
-	cap_call_handle_t chandle;
+	ipc_call_t call;
 	size_t size;
-	if ((!async_data_read_receive(&chandle, &size)) ||
+	if ((!async_data_read_receive(&call, &size)) ||
 	    (size != sizeof(info))) {
-		async_answer_0(chandle, EIO);
-		async_answer_0(req_handle, EIO);
+		async_answer_0(&call, EIO);
+		async_answer_0(req, EIO);
 		return;
 	}
@@ -100,14 +95,14 @@
 	rc = vfs_out_ops->fsprobe(service_id, &info);
 	if (rc != EOK) {
-		async_answer_0(chandle, EIO);
-		async_answer_0(req_handle, rc);
+		async_answer_0(&call, EIO);
+		async_answer_0(req, rc);
 		return;
 	}
 
-	async_data_read_finalize(chandle, &info, sizeof(info));
-	async_answer_0(req_handle, EOK);
-}
-
-static void vfs_out_mounted(cap_call_handle_t req_handle, ipc_call_t *req)
+	async_data_read_finalize(&call, &info, sizeof(info));
+	async_answer_0(req, EOK);
+}
+
+static void vfs_out_mounted(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -118,5 +113,5 @@
 	rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
 	if (rc != EOK) {
-		async_answer_0(req_handle, rc);
+		async_answer_0(req, rc);
 		return;
 	}
@@ -127,13 +122,13 @@
 
 	if (rc == EOK) {
-		async_answer_3(req_handle, EOK, index, LOWER32(size),
+		async_answer_3(req, EOK, index, LOWER32(size),
 		    UPPER32(size));
 	} else
-		async_answer_0(req_handle, rc);
+		async_answer_0(req, rc);
 
 	free(opts);
 }
 
-static void vfs_out_unmounted(cap_call_handle_t req_handle, ipc_call_t *req)
+static void vfs_out_unmounted(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -142,18 +137,18 @@
 	rc = vfs_out_ops->unmounted(service_id);
 
-	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)
+	async_answer_0(req, rc);
+}
+
+static void vfs_out_link(ipc_call_t *req)
+{
+	libfs_link(libfs_ops, reg.fs_handle, req);
+}
+
+static void vfs_out_lookup(ipc_call_t *req)
+{
+	libfs_lookup(libfs_ops, reg.fs_handle, req);
+}
+
+static void vfs_out_read(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -167,10 +162,10 @@
 
 	if (rc == EOK)
-		async_answer_1(req_handle, EOK, rbytes);
+		async_answer_1(req, EOK, rbytes);
 	else
-		async_answer_0(req_handle, rc);
-}
-
-static void vfs_out_write(cap_call_handle_t req_handle, ipc_call_t *req)
+		async_answer_0(req, rc);
+}
+
+static void vfs_out_write(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -185,11 +180,11 @@
 
 	if (rc == EOK) {
-		async_answer_3(req_handle, EOK, wbytes, LOWER32(nsize),
+		async_answer_3(req, EOK, wbytes, LOWER32(nsize),
 		    UPPER32(nsize));
 	} else
-		async_answer_0(req_handle, rc);
-}
-
-static void vfs_out_truncate(cap_call_handle_t req_handle, ipc_call_t *req)
+		async_answer_0(req, rc);
+}
+
+static void vfs_out_truncate(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -201,8 +196,8 @@
 	rc = vfs_out_ops->truncate(service_id, index, size);
 
-	async_answer_0(req_handle, rc);
-}
-
-static void vfs_out_close(cap_call_handle_t req_handle, ipc_call_t *req)
+	async_answer_0(req, rc);
+}
+
+static void vfs_out_close(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -212,8 +207,8 @@
 	rc = vfs_out_ops->close(service_id, index);
 
-	async_answer_0(req_handle, rc);
-}
-
-static void vfs_out_destroy(cap_call_handle_t req_handle, ipc_call_t *req)
+	async_answer_0(req, rc);
+}
+
+static void vfs_out_destroy(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -229,18 +224,18 @@
 			rc = vfs_out_ops->destroy(service_id, index);
 	}
-	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)
+	async_answer_0(req, rc);
+}
+
+static void vfs_out_open_node(ipc_call_t *req)
+{
+	libfs_open_node(libfs_ops, reg.fs_handle, req);
+}
+
+static void vfs_out_stat(ipc_call_t *req)
+{
+	libfs_stat(libfs_ops, reg.fs_handle, req);
+}
+
+static void vfs_out_sync(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -250,13 +245,13 @@
 	rc = vfs_out_ops->sync(service_id, index);
 
-	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)
+	async_answer_0(req, rc);
+}
+
+static void vfs_out_statfs(ipc_call_t *req)
+{
+	libfs_statfs(libfs_ops, reg.fs_handle, req);
+}
+
+static void vfs_out_is_empty(ipc_call_t *req)
 {
 	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
@@ -267,7 +262,7 @@
 	rc = libfs_ops->node_get(&node, service_id, index);
 	if (rc != EOK)
-		async_answer_0(req_handle, rc);
+		async_answer_0(req, rc);
 	if (node == NULL)
-		async_answer_0(req_handle, EINVAL);
+		async_answer_0(req, EINVAL);
 
 	bool children = false;
@@ -276,12 +271,11 @@
 
 	if (rc != 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)
-{
-	if (icall_handle) {
+		async_answer_0(req, rc);
+	async_answer_0(req, children ? ENOTEMPTY : EOK);
+}
+
+static void vfs_connection(ipc_call_t *icall, void *arg)
+{
+	if (icall->cap_handle) {
 		/*
 		 * This only happens for connections opened by
@@ -289,10 +283,10 @@
 		 * created by IPC_M_CONNECT_TO_ME.
 		 */
-		async_answer_0(icall_handle, EOK);
+		async_answer_0(icall, EOK);
 	}
 
 	while (true) {
 		ipc_call_t call;
-		cap_call_handle_t chandle = async_get_call(&call);
+		async_get_call(&call);
 
 		if (!IPC_GET_IMETHOD(call))
@@ -301,50 +295,50 @@
 		switch (IPC_GET_IMETHOD(call)) {
 		case VFS_OUT_FSPROBE:
-			vfs_out_fsprobe(chandle, &call);
+			vfs_out_fsprobe(&call);
 			break;
 		case VFS_OUT_MOUNTED:
-			vfs_out_mounted(chandle, &call);
+			vfs_out_mounted(&call);
 			break;
 		case VFS_OUT_UNMOUNTED:
-			vfs_out_unmounted(chandle, &call);
+			vfs_out_unmounted(&call);
 			break;
 		case VFS_OUT_LINK:
-			vfs_out_link(chandle, &call);
+			vfs_out_link(&call);
 			break;
 		case VFS_OUT_LOOKUP:
-			vfs_out_lookup(chandle, &call);
+			vfs_out_lookup(&call);
 			break;
 		case VFS_OUT_READ:
-			vfs_out_read(chandle, &call);
+			vfs_out_read(&call);
 			break;
 		case VFS_OUT_WRITE:
-			vfs_out_write(chandle, &call);
+			vfs_out_write(&call);
 			break;
 		case VFS_OUT_TRUNCATE:
-			vfs_out_truncate(chandle, &call);
+			vfs_out_truncate(&call);
 			break;
 		case VFS_OUT_CLOSE:
-			vfs_out_close(chandle, &call);
+			vfs_out_close(&call);
 			break;
 		case VFS_OUT_DESTROY:
-			vfs_out_destroy(chandle, &call);
+			vfs_out_destroy(&call);
 			break;
 		case VFS_OUT_OPEN_NODE:
-			vfs_out_open_node(chandle, &call);
+			vfs_out_open_node(&call);
 			break;
 		case VFS_OUT_STAT:
-			vfs_out_stat(chandle, &call);
+			vfs_out_stat(&call);
 			break;
 		case VFS_OUT_SYNC:
-			vfs_out_sync(chandle, &call);
+			vfs_out_sync(&call);
 			break;
 		case VFS_OUT_STATFS:
-			vfs_out_statfs(chandle, &call);
+			vfs_out_statfs(&call);
 			break;
 		case VFS_OUT_IS_EMPTY:
-			vfs_out_is_empty(chandle, &call);
+			vfs_out_is_empty(&call);
 			break;
 		default:
-			async_answer_0(chandle, ENOTSUP);
+			async_answer_0(&call, ENOTSUP);
 			break;
 		}
@@ -481,20 +475,22 @@
 static errno_t receive_fname(char *buffer)
 {
+	ipc_call_t call;
 	size_t size;
-	cap_call_handle_t wcall;
-
-	if (!async_data_write_receive(&wcall, &size))
+
+	if (!async_data_write_receive(&call, &size))
 		return ENOENT;
+
 	if (size > NAME_MAX + 1) {
-		async_answer_0(wcall, ERANGE);
+		async_answer_0(&call, ERANGE);
 		return ERANGE;
 	}
-	return async_data_write_finalize(wcall, buffer, size);
+
+	return async_data_write_finalize(&call, buffer, size);
 }
 
 /** Link a file at a path.
+ *
  */
-void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle,
-    cap_call_handle_t req_handle, ipc_call_t *req)
+void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
 {
 	service_id_t parent_sid = IPC_GET_ARG1(*req);
@@ -505,5 +501,5 @@
 	errno_t rc = receive_fname(component);
 	if (rc != EOK) {
-		async_answer_0(req_handle, rc);
+		async_answer_0(req, rc);
 		return;
 	}
@@ -512,5 +508,5 @@
 	rc = ops->node_get(&parent, parent_sid, parent_index);
 	if (parent == NULL) {
-		async_answer_0(req_handle, rc == EOK ? EBADF : rc);
+		async_answer_0(req, rc == EOK ? EBADF : rc);
 		return;
 	}
@@ -519,5 +515,5 @@
 	rc = ops->node_get(&child, parent_sid, child_index);
 	if (child == NULL) {
-		async_answer_0(req_handle, rc == EOK ? EBADF : rc);
+		async_answer_0(req, rc == EOK ? EBADF : rc);
 		ops->node_put(parent);
 		return;
@@ -527,5 +523,5 @@
 	ops->node_put(parent);
 	ops->node_put(child);
-	async_answer_0(req_handle, rc);
+	async_answer_0(req, rc);
 }
 
@@ -535,14 +531,12 @@
  * 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 req_handle  Call handle 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       VFS_OUT_LOOKUP request data itself.
  *
  */
-void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle,
-    cap_call_handle_t req_handle, ipc_call_t *req)
+void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
 {
 	unsigned first = IPC_GET_ARG1(*req);
@@ -567,5 +561,5 @@
 	rc = ops->node_get(&cur, service_id, index);
 	if (rc != EOK) {
-		async_answer_0(req_handle, rc);
+		async_answer_0(req, rc);
 		goto out;
 	}
@@ -584,5 +578,5 @@
 
 		if (!ops->is_directory(cur)) {
-			async_answer_0(req_handle, ENOTDIR);
+			async_answer_0(req, ENOTDIR);
 			goto out;
 		}
@@ -593,5 +587,5 @@
 		assert(rc != ERANGE);
 		if (rc != EOK) {
-			async_answer_0(req_handle, rc);
+			async_answer_0(req, rc);
 			goto out;
 		}
@@ -607,5 +601,5 @@
 		rc = ops->match(&tmp, cur, component);
 		if (rc != EOK) {
-			async_answer_0(req_handle, rc);
+			async_answer_0(req, rc);
 			goto out;
 		}
@@ -615,5 +609,5 @@
 			rc = ops->node_put(par);
 			if (rc != EOK) {
-				async_answer_0(req_handle, rc);
+				async_answer_0(req, rc);
 				goto out;
 			}
@@ -636,10 +630,10 @@
 
 	if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) {
-		async_answer_0(req_handle, EISDIR);
+		async_answer_0(req, EISDIR);
 		goto out;
 	}
 
 	if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) {
-		async_answer_0(req_handle, ENOTDIR);
+		async_answer_0(req, ENOTDIR);
 		goto out;
 	}
@@ -649,9 +643,9 @@
 	if (lflag & L_UNLINK) {
 		if (!cur) {
-			async_answer_0(req_handle, ENOENT);
+			async_answer_0(req, ENOENT);
 			goto out;
 		}
 		if (!par) {
-			async_answer_0(req_handle, EINVAL);
+			async_answer_0(req, EINVAL);
 			goto out;
 		}
@@ -660,10 +654,10 @@
 		if (rc == EOK) {
 			aoff64_t size = ops->size_get(cur);
-			async_answer_5(req_handle, EOK, fs_handle,
+			async_answer_5(req, EOK, fs_handle,
 			    ops->index_get(cur),
 			    (ops->is_directory(cur) << 16) | last,
 			    LOWER32(size), UPPER32(size));
 		} else {
-			async_answer_0(req_handle, rc);
+			async_answer_0(req, rc);
 		}
 		goto out;
@@ -674,5 +668,5 @@
 	if (lflag & L_CREATE) {
 		if (cur && (lflag & L_EXCLUSIVE)) {
-			async_answer_0(req_handle, EEXIST);
+			async_answer_0(req, EEXIST);
 			goto out;
 		}
@@ -682,9 +676,9 @@
 			    lflag & (L_FILE | L_DIRECTORY));
 			if (rc != EOK) {
-				async_answer_0(req_handle, rc);
+				async_answer_0(req, rc);
 				goto out;
 			}
 			if (!cur) {
-				async_answer_0(req_handle, ENOSPC);
+				async_answer_0(req, ENOSPC);
 				goto out;
 			}
@@ -694,5 +688,5 @@
 				(void) ops->destroy(cur);
 				cur = NULL;
-				async_answer_0(req_handle, rc);
+				async_answer_0(req, rc);
 				goto out;
 			}
@@ -703,5 +697,5 @@
 out1:
 	if (!cur) {
-		async_answer_5(req_handle, EOK, fs_handle, ops->index_get(par),
+		async_answer_5(req, EOK, fs_handle, ops->index_get(par),
 		    (ops->is_directory(par) << 16) | last_next,
 		    LOWER32(ops->size_get(par)), UPPER32(ops->size_get(par)));
@@ -709,5 +703,5 @@
 	}
 
-	async_answer_5(req_handle, EOK, fs_handle, ops->index_get(cur),
+	async_answer_5(req, EOK, fs_handle, ops->index_get(cur),
 	    (ops->is_directory(cur) << 16) | last, LOWER32(ops->size_get(cur)),
 	    UPPER32(ops->size_get(cur)));
@@ -724,21 +718,20 @@
 }
 
-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);
+void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_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);
 
 	fs_node_t *fn;
 	errno_t rc = ops->node_get(&fn, service_id, index);
-	on_error(rc, answer_and_return(req_handle, rc));
-
-	cap_call_handle_t chandle;
+	on_error(rc, answer_and_return(req, rc));
+
+	ipc_call_t call;
 	size_t size;
-	if ((!async_data_read_receive(&chandle, &size)) ||
+	if ((!async_data_read_receive(&call, &size)) ||
 	    (size != sizeof(vfs_stat_t))) {
 		ops->node_put(fn);
-		async_answer_0(chandle, EINVAL);
-		async_answer_0(req_handle, EINVAL);
+		async_answer_0(&call, EINVAL);
+		async_answer_0(req, EINVAL);
 		return;
 	}
@@ -758,22 +751,20 @@
 	ops->node_put(fn);
 
-
-	async_data_read_finalize(chandle, &stat, sizeof(vfs_stat_t));
-	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);
-	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+	async_data_read_finalize(&call, &stat, sizeof(vfs_stat_t));
+	async_answer_0(req, EOK);
+}
+
+void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_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);
 
 	fs_node_t *fn;
 	errno_t rc = ops->node_get(&fn, service_id, index);
-	on_error(rc, answer_and_return(req_handle, rc));
-
-	cap_call_handle_t chandle;
+	on_error(rc, answer_and_return(req, rc));
+
+	ipc_call_t call;
 	size_t size;
-	if ((!async_data_read_receive(&chandle, &size)) ||
+	if ((!async_data_read_receive(&call, &size)) ||
 	    (size != sizeof(vfs_statfs_t))) {
 		goto error;
@@ -804,12 +795,12 @@
 
 	ops->node_put(fn);
-	async_data_read_finalize(chandle, &st, sizeof(vfs_statfs_t));
-	async_answer_0(req_handle, EOK);
+	async_data_read_finalize(&call, &st, sizeof(vfs_statfs_t));
+	async_answer_0(req, EOK);
 	return;
 
 error:
 	ops->node_put(fn);
-	async_answer_0(chandle, EINVAL);
-	async_answer_0(req_handle, EINVAL);
+	async_answer_0(&call, EINVAL);
+	async_answer_0(req, EINVAL);
 }
 
@@ -817,22 +808,20 @@
 /** Open VFS triplet.
  *
- * @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.
+ * @param ops libfs operations structure with function pointers to
+ *            file system implementation
+ * @param req VFS_OUT_OPEN_NODE request data itself.
  *
  */
-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);
+void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_call_t *req)
+{
+	service_id_t service_id = IPC_GET_ARG1(*req);
+	fs_index_t index = IPC_GET_ARG2(*req);
 
 	fs_node_t *fn;
 	errno_t rc = ops->node_get(&fn, service_id, index);
-	on_error(rc, answer_and_return(req_handle, rc));
+	on_error(rc, answer_and_return(req, rc));
 
 	if (fn == NULL) {
-		async_answer_0(req_handle, ENOENT);
+		async_answer_0(req, ENOENT);
 		return;
 	}
@@ -840,5 +829,5 @@
 	rc = ops->node_open(fn);
 	aoff64_t size = ops->size_get(fn);
-	async_answer_4(req_handle, rc, LOWER32(size), UPPER32(size),
+	async_answer_4(req, rc, LOWER32(size), UPPER32(size),
 	    ops->lnkcnt_get(fn),
 	    (ops->is_file(fn) ? L_FILE : 0) |
@@ -891,4 +880,5 @@
 {
 	fibril_mutex_lock(&instances_mutex);
+
 	list_foreach(instances_list, link, fs_instance_t, inst) {
 		if (inst->service_id == service_id) {
@@ -898,4 +888,5 @@
 		}
 	}
+
 	fibril_mutex_unlock(&instances_mutex);
 	return ENOENT;
@@ -905,4 +896,5 @@
 {
 	fibril_mutex_lock(&instances_mutex);
+
 	list_foreach(instances_list, link, fs_instance_t, inst) {
 		if (inst->service_id == service_id) {
@@ -913,4 +905,5 @@
 		}
 	}
+
 	fibril_mutex_unlock(&instances_mutex);
 	return ENOENT;
