Index: uspace/app/mkminix/mkminix.c
===================================================================
--- uspace/app/mkminix/mkminix.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/app/mkminix/mkminix.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -97,5 +97,5 @@
 static inline int write_block(aoff64_t off, size_t size, const void *data);
 
-static devmap_handle_t handle;
+static service_id_t service_id;
 static int shift;
 
@@ -201,5 +201,5 @@
 	}
 
-	rc = devmap_device_get_handle(device_name, &handle, 0);
+	rc = loc_service_get_id(device_name, &service_id, 0);
 	if (rc != EOK) {
 		printf(NAME ": Error resolving device `%s'.\n", device_name);
@@ -207,5 +207,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
+	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
 	if (rc != EOK)  {
 		printf(NAME ": Error initializing libblock.\n");
@@ -213,5 +213,5 @@
 	}
 
-	rc = block_get_bsize(handle, &devblock_size);
+	rc = block_get_bsize(service_id, &devblock_size);
 	if (rc != EOK) {
 		printf(NAME ": Error determining device block size.\n");
@@ -219,5 +219,5 @@
 	}
 
-	rc = block_get_nblocks(handle, &sb.dev_nblocks);
+	rc = block_get_nblocks(service_id, &sb.dev_nblocks);
 	if (rc != EOK) {
 		printf(NAME ": Warning, failed to obtain block device size.\n");
@@ -271,4 +271,6 @@
 		return 2;
 	}
+
+	block_fini(service_id);
 
 	return 0;
@@ -600,5 +602,5 @@
 	sb->s_disk_version = 3;
 
-	rc = block_write_direct(handle, MFS_SUPERBLOCK << 1, 1 << 1, sb); 
+	rc = block_write_direct(service_id, MFS_SUPERBLOCK << 1, 1 << 1, sb);
 	free(sb);
 
@@ -690,5 +692,5 @@
 		uint8_t *data_ptr = (uint8_t *) data;
 
-		rc = block_write_direct(handle, tmp_off << 2, size << 2, data_ptr);
+		rc = block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
 
 		if (rc != EOK)
@@ -698,7 +700,7 @@
 		tmp_off++;
 
-		return block_write_direct(handle, tmp_off << 2, size << 2, data_ptr);
-	}
-	return block_write_direct(handle, off << shift, size << shift, data);	
+		return block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
+	}
+	return block_write_direct(service_id, off << shift, size << shift, data);
 }
 
Index: uspace/srv/fs/minixfs/mfs.c
===================================================================
--- uspace/srv/fs/minixfs/mfs.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -38,6 +38,4 @@
  */
 
-#define _MAIN
-
 #include <ipc/services.h>
 #include <ns.h>
@@ -55,91 +53,4 @@
 	.write_retains_size = false,
 };
-
-
-/**
- * This connection fibril processes VFS requests from VFS.
- *
- * In order to support simultaneous VFS requests, our design is as follows.
- * The connection fibril accepts VFS requests from VFS. If there is only one
- * instance of the fibril, VFS will need to serialize all VFS requests it sends
- * to MinixFS. To overcome this bottleneck, VFS can send MinixFS the IPC_M_CONNECT_ME_TO
- * call. In that case, a new connection fibril will be created, which in turn
- * will accept the call. Thus, a new phone will be opened for VFS.
- *
- * There are few issues with this arrangement. First, VFS can run out of
- * available phones. In that case, VFS can close some other phones or use one
- * phone for more serialized requests. Similarily, MinixFS can refuse to duplicate
- * the connection. VFS should then just make use of already existing phones and
- * route its requests through them. To avoid paying the fibril creation price
- * upon each request, MinixFS might want to keep the connections open after the
- * request has been completed.
- */
-
-static void mfs_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
-	if (iid) {
-		/*
-		 * This only happens for connections opened by
-		 * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
-		 * created by IPC_M_CONNECT_TO_ME.
-		 */
-		async_answer_0(iid, EOK);
-	}
-
-	while (1) {
-		ipc_callid_t callid;
-		ipc_call_t call;
-
-		callid = async_get_call(&call);
-		int method = IPC_GET_IMETHOD(call);
-
-		/*mfsdebug(NAME "method = %d\n", method);*/
-		switch  (method) {
-		case VFS_OUT_MOUNTED:
-			mfs_mounted(callid, &call);
-			break;
-		case VFS_OUT_MOUNT:
-			mfs_mount(callid, &call);
-			break;
-		case VFS_OUT_STAT:
-			mfs_stat(callid, &call);
-			break;
-		case VFS_OUT_LOOKUP:
-			mfs_lookup(callid, &call);
-			break;
-		case VFS_OUT_READ:
-			mfs_read(callid, &call);
-			break;
-		case VFS_OUT_OPEN_NODE:
-			mfs_open_node(callid, &call);
-			break;
-		case VFS_OUT_CLOSE:
-			mfs_close(callid, &call);
-			break;
-		case VFS_OUT_WRITE:
-			mfs_write(callid, &call);
-			break;
-		case VFS_OUT_TRUNCATE:
-			mfs_truncate(callid, &call);
-			break;
-		case VFS_OUT_DESTROY:
-			mfs_destroy(callid, &call);
-			break;
-		case VFS_OUT_UNMOUNTED:
-			mfs_unmounted(callid, &call);
-			break;
-		case VFS_OUT_UNMOUNT:
-			mfs_unmount(callid, &call);
-			break;
-		case VFS_OUT_SYNC:
-			mfs_sync(callid, &call);
-			break;
-		default:
-			async_answer_0(callid, ENOTSUP);
-			break;
-		}
-	}
-}
-
 
 int main(int argc, char **argv)
@@ -163,5 +74,5 @@
 	}
 
-	rc = fs_register(vfs_sess, &mfs_reg, &mfs_vfs_info, mfs_connection);
+	rc = fs_register(vfs_sess, &mfs_vfs_info, &mfs_ops, &mfs_libfs_ops);
 	if (rc != EOK)
 		goto err;
Index: uspace/srv/fs/minixfs/mfs.h
===================================================================
--- uspace/srv/fs/minixfs/mfs.h	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs.h	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -58,15 +58,7 @@
 #endif
 
-#ifdef _MAIN
-#define GLOBAL
-#else
-#define GLOBAL extern
-#endif
-
 #define on_error(r, inst) do {	\
 				if (r != EOK) inst;	\
 			}while(0)
-
-GLOBAL fs_reg_t mfs_reg;
 
 typedef uint32_t bitchunk_t;
@@ -144,5 +136,5 @@
 struct mfs_instance {
 	link_t link;
-	devmap_handle_t handle;
+	service_id_t service_id;
 	struct mfs_sb_info *sbi;
 	unsigned open_nodes_cnt;
@@ -159,34 +151,6 @@
 
 /*mfs_ops.c*/
-extern void mfs_mounted(ipc_callid_t rid, ipc_call_t *request);
-extern void mfs_mount(ipc_callid_t rid, ipc_call_t *request);
-extern void mfs_lookup(ipc_callid_t rid, ipc_call_t *request);
-extern int mfs_instance_get(devmap_handle_t handle,
-			    struct mfs_instance **instance);
-
-extern void mfs_stat(ipc_callid_t rid, ipc_call_t *request);
-extern void mfs_close(ipc_callid_t rid, ipc_call_t *request);
-extern void mfs_open_node(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_read(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_write(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_truncate(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_destroy(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_unmounted(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_unmount(ipc_callid_t rid, ipc_call_t *request);
-
-extern void
-mfs_sync(ipc_callid_t rid, ipc_call_t *request);
+extern vfs_out_ops_t mfs_ops;
+extern libfs_ops_t mfs_libfs_ops;
 
 extern int
Index: uspace/srv/fs/minixfs/mfs_balloc.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_balloc.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs_balloc.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -150,5 +150,5 @@
 	uint32_t block = idx / (sbi->block_size * 8) + start_block;
 
-	r = block_get(&b, inst->handle, block, BLOCK_FLAGS_NONE);
+	r = block_get(&b, inst->service_id, block, BLOCK_FLAGS_NONE);
 	on_error(r, goto out_err);
 
@@ -216,5 +216,5 @@
 
 	for (i = *search / bits_per_block; i < nblocks; ++i) {
-		r = block_get(&b, inst->handle, i + start_block,
+		r = block_get(&b, inst->service_id, i + start_block,
 			      BLOCK_FLAGS_NONE);
 
Index: uspace/srv/fs/minixfs/mfs_dentry.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_dentry.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs_dentry.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -61,5 +61,5 @@
 	}
 
-	r = block_get(&b, inst->handle, block, BLOCK_FLAGS_NONE);
+	r = block_get(&b, inst->service_id, block, BLOCK_FLAGS_NONE);
 	on_error(r, goto out_err);
 
@@ -115,5 +115,5 @@
 	on_error(r, goto out);
 
-	r = block_get(&b, mnode->instance->handle, block, BLOCK_FLAGS_NONE);
+	r = block_get(&b, mnode->instance->service_id, block, BLOCK_FLAGS_NONE);
 	on_error(r, goto out);
 
Index: uspace/srv/fs/minixfs/mfs_inode.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_inode.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs_inode.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -93,5 +93,5 @@
 	const int itable_off = sbi->itable_off;
 
-	r = block_get(&b, instance->handle,
+	r = block_get(&b, instance->service_id,
 		      itable_off + inum / sbi->ino_per_block,
 		      BLOCK_FLAGS_NONE);
@@ -149,5 +149,5 @@
 	const int ino_off = inum % sbi->ino_per_block;
 
-	r = block_get(&b, instance->handle,
+	r = block_get(&b, instance->service_id,
 		      itable_off + inum / sbi->ino_per_block,
 		      BLOCK_FLAGS_NONE);
@@ -221,5 +221,5 @@
 	const bool native = sbi->native;
 
-	r = block_get(&b, mnode->instance->handle,
+	r = block_get(&b, mnode->instance->service_id,
 		      itable_off + inum / sbi->ino_per_block,
 		      BLOCK_FLAGS_NONE);
@@ -263,5 +263,5 @@
 	const bool native = sbi->native;
 
-	r = block_get(&b, mnode->instance->handle,
+	r = block_get(&b, mnode->instance->service_id,
 		      itable_off + inum / sbi->ino_per_block,
 		      BLOCK_FLAGS_NONE);
Index: uspace/srv/fs/minixfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_ops.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs_ops.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -38,5 +38,5 @@
 
 #define OPEN_NODES_KEYS 2
-#define OPEN_NODES_DEV_HANDLE_KEY 0
+#define OPEN_NODES_SERVICE_KEY 0
 #define OPEN_NODES_INODE_KEY 1
 #define OPEN_NODES_BUCKETS 256
@@ -51,13 +51,12 @@
 static fs_index_t mfs_index_get(fs_node_t *fsnode);
 static unsigned mfs_lnkcnt_get(fs_node_t *fsnode);
-static char mfs_plb_get_char(unsigned pos);
 static bool mfs_is_directory(fs_node_t *fsnode);
 static bool mfs_is_file(fs_node_t *fsnode);
 static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
-static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle);
-static devmap_handle_t mfs_device_get(fs_node_t *fsnode);
+static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
+static service_id_t mfs_device_get(fs_node_t *fsnode);
 static aoff64_t mfs_size_get(fs_node_t *node);
 static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
-static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags);
+static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags);
 static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name);
 static int mfs_unlink(fs_node_t *, fs_node_t *, const char *name);
@@ -68,6 +67,8 @@
 static void open_nodes_remove_cb(link_t *link);
 
-static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
+static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
 			fs_index_t index);
+static int
+mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
 
 
@@ -92,5 +93,4 @@
 	.unlink = mfs_unlink,
 	.destroy = mfs_destroy_node,
-	.plb_get_char = mfs_plb_get_char,
 	.has_children = mfs_has_children,
 	.lnkcnt_get = mfs_lnkcnt_get
@@ -109,6 +109,6 @@
 	struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
 	assert(keys > 0);
-	if (mnode->instance->handle !=
-	    ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
+	if (mnode->instance->service_id !=
+	    ((service_id_t) key[OPEN_NODES_SERVICE_KEY])) {
 		return false;
 	}
@@ -140,7 +140,8 @@
 }
 
-void mfs_mounted(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+static int
+mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
+		aoff64_t *size, unsigned *linkcnt)
+{
 	enum cache_mode cmode;
 	struct mfs_superblock *sb;
@@ -151,14 +152,5 @@
 	mfs_version_t version;
 	uint16_t magic;
-
-	/* Accept the mount options */
-	char *opts;
-	int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
-
-	if (rc != EOK) {
-		mfsdebug("Can't accept async data write\n");
-		async_answer_0(rid, rc);
-		return;
-	}
+	int rc;
 
 	/* Check for option enabling write through. */
@@ -168,28 +160,21 @@
 		cmode = CACHE_MODE_WB;
 
-	free(opts);
-
 	/* initialize libblock */
-	rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, 1024);
-	if (rc != EOK) {
-		mfsdebug("libblock initialization failed\n");
-		async_answer_0(rid, rc);
-		return;
-	}
+	rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
+	if (rc != EOK)
+		return rc;
 
 	/*Allocate space for generic MFS superblock*/
 	sbi = malloc(sizeof(*sbi));
-
 	if (!sbi) {
-		async_answer_0(rid, ENOMEM);
-		return;
+		block_fini(service_id);
+		return ENOMEM;
 	}
 
 	/*Allocate space for filesystem instance*/
 	instance = malloc(sizeof(*instance));
-
 	if (!instance) {
-		async_answer_0(rid, ENOMEM);
-		return;
+		block_fini(service_id);
+		return ENOMEM;
 	}
 
@@ -197,16 +182,14 @@
 
 	sb = malloc(MFS_SUPERBLOCK_SIZE);
-
 	if (!sb) {
-		async_answer_0(rid, ENOMEM);
-		return;
+		block_fini(service_id);
+		return ENOMEM;
 	}
 
 	/* Read the superblock */
-	rc = block_read_direct(devmap_handle, MFS_SUPERBLOCK << 1, 1, sb);
+	rc = block_read_direct(service_id, MFS_SUPERBLOCK << 1, 1, sb);
 	if (rc != EOK) {
-		block_fini(devmap_handle);
-		async_answer_0(rid, rc);
-		return;
+		block_fini(service_id);
+		return rc;
 	}
 
@@ -221,7 +204,6 @@
 	if (!check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
 		mfsdebug("magic number not recognized\n");
-		block_fini(devmap_handle);
-		async_answer_0(rid, ENOTSUP);
-		return;
+		block_fini(service_id);
+		return ENOTSUP;
 	}
 
@@ -278,16 +260,17 @@
 	free(sb);
 
-	rc = block_cache_init(devmap_handle, sbi->block_size, 0, cmode);
-
+	rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
 	if (rc != EOK) {
-		block_fini(devmap_handle);
-		async_answer_0(rid, EINVAL);
+		free(sbi);
+		free(instance);
+		block_cache_fini(service_id);
+		block_fini(service_id);
 		mfsdebug("block cache initialization failed\n");
-		return;
+		return EINVAL;
 	}
 
 	/*Initialize the instance structure and add it to the list*/
 	link_initialize(&instance->link);
-	instance->handle = devmap_handle;
+	instance->service_id = service_id;
 	instance->sbi = sbi;
 
@@ -299,44 +282,29 @@
 
 	fs_node_t *fn;
-	mfs_node_get(&fn, devmap_handle, MFS_ROOT_INO);
-
-	struct mfs_node *nroot = fn->data;
-
-	async_answer_3(rid, EOK,
-			MFS_ROOT_INO,
-			0,
-			nroot->ino_i->i_nlinks);
-
-	mfs_node_put(fn);
-}
-
-void mfs_mount(ipc_callid_t rid, ipc_call_t *request)
-{
-	libfs_mount(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
-}
-
-void mfs_unmount(ipc_callid_t rid, ipc_call_t *request)
-{
-	libfs_unmount(&mfs_libfs_ops, rid, request);
-}
-
-void mfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t devmap = (devmap_handle_t) IPC_GET_ARG1(*request);
+	mfs_node_get(&fn, service_id, MFS_ROOT_INO);
+
+	struct mfs_node *mroot = fn->data;
+
+	*index = mroot->ino_i->index;
+	*size = mroot->ino_i->i_size;
+	*linkcnt = mroot->ino_i->i_nlinks;
+
+	return mfs_node_put(fn);
+}
+
+static int
+mfs_unmounted(service_id_t service_id)
+{
 	struct mfs_instance *inst;
 
-	int r = mfs_instance_get(devmap, &inst);
-	if (r != EOK) {
-		async_answer_0(rid, r);
-		return;
-	}
-
-	if (inst->open_nodes_cnt != 0) {
-		async_answer_0(rid, EBUSY);
-		return;
-	}
-
-	(void) block_cache_fini(devmap);
-	block_fini(devmap);
+	int r = mfs_instance_get(service_id, &inst);
+	if (r != EOK)
+		return r;
+
+	if (inst->open_nodes_cnt != 0)
+		return EBUSY;
+
+	(void) block_cache_fini(service_id);
+	block_fini(service_id);
 
 	/* Remove the instance from the list */
@@ -347,15 +315,14 @@
 	free(inst->sbi);
 	free(inst);
-
-	async_answer_0(rid, EOK);
-}
-
-devmap_handle_t mfs_device_get(fs_node_t *fsnode)
+	return EOK;
+}
+
+service_id_t mfs_device_get(fs_node_t *fsnode)
 {
 	struct mfs_node *node = fsnode->data;
-	return node->instance->handle;
-}
-
-static int mfs_create_node(fs_node_t **rfn, devmap_handle_t handle, int flags)
+	return node->instance->service_id;
+}
+
+static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
 	int r;
@@ -367,5 +334,5 @@
 	mfsdebug("%s()\n", __FUNCTION__);
 
-	r = mfs_instance_get(handle, &inst);
+	r = mfs_instance_get(service_id, &inst);
 	on_error(r, return r);
 
@@ -421,5 +388,5 @@
 
 	unsigned long key[] = {
-		[OPEN_NODES_DEV_HANDLE_KEY] = inst->handle,
+		[OPEN_NODES_SERVICE_KEY] = inst->service_id,
 		[OPEN_NODES_INODE_KEY] = inum,
 	};
@@ -498,10 +465,6 @@
 }
 
-void mfs_stat(ipc_callid_t rid, ipc_call_t *request)
-{
-	libfs_stat(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
-}
-
-static int mfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle,
+static int
+mfs_node_get(fs_node_t **rfn, service_id_t service_id,
 			fs_index_t index)
 {
@@ -511,5 +474,5 @@
 	mfsdebug("%s()\n", __FUNCTION__);
 
-	rc = mfs_instance_get(devmap_handle, &instance);
+	rc = mfs_instance_get(service_id, &instance);
 	on_error(rc, return rc);
 
@@ -517,5 +480,6 @@
 }
 
-static int mfs_node_put(fs_node_t *fsnode)
+static int
+mfs_node_put(fs_node_t *fsnode)
 {
 	int rc = EOK;
@@ -530,5 +494,5 @@
 	if (mnode->refcnt == 0) {
 		unsigned long key[] = {
-			[OPEN_NODES_DEV_HANDLE_KEY] = mnode->instance->handle,
+			[OPEN_NODES_SERVICE_KEY] = mnode->instance->service_id,
 			[OPEN_NODES_INODE_KEY] = mnode->ino_i->index
 		};
@@ -588,5 +552,5 @@
 	/* Check if the node is not already open */
 	unsigned long key[] = {
-		[OPEN_NODES_DEV_HANDLE_KEY] = inst->handle,
+		[OPEN_NODES_SERVICE_KEY] = inst->service_id,
 		[OPEN_NODES_INODE_KEY] = index,
 	};
@@ -659,18 +623,8 @@
 }
 
-static int mfs_root_get(fs_node_t **rfn, devmap_handle_t handle)
-{
-	int rc = mfs_node_get(rfn, handle, MFS_ROOT_INO);
+static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+	int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
 	return rc;
-}
-
-void mfs_lookup(ipc_callid_t rid, ipc_call_t *request)
-{
-	libfs_lookup(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
-}
-
-static char mfs_plb_get_char(unsigned pos)
-{
-	return mfs_reg.plb_ro[pos % PLB_SIZE];
 }
 
@@ -772,23 +726,16 @@
 }
 
-void
-mfs_read(ipc_callid_t rid, ipc_call_t *request)
+static int
+mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
+		size_t *rbytes)
 {
 	int rc;
-	devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
-	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-	aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
-					       IPC_GET_ARG4(*request));
 	fs_node_t *fn;
 
-	rc = mfs_node_get(&fn, handle, index);
-	if (rc != EOK) {
-		async_answer_0(rid, rc);
-		return;
-	}
-	if (!fn) {
-		async_answer_0(rid, ENOENT);
-		return;
-	}
+	rc = mfs_node_get(&fn, service_id, index);
+	if (rc != EOK)
+		return rc;
+	if (!fn)
+		return ENOENT;
 
 	struct mfs_node *mnode;
@@ -827,6 +774,5 @@
 		rc = mfs_node_put(fn);
 		async_answer_0(callid, rc != EOK ? rc : ENOENT);
-		async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
-		return;
+		return rc;
 found:
 		async_data_read_finalize(callid, d_info.d_name,
@@ -866,5 +812,5 @@
 		}
 
-		rc = block_get(&b, handle, zone, BLOCK_FLAGS_NONE);
+		rc = block_get(&b, service_id, zone, BLOCK_FLAGS_NONE);
 		on_error(rc, goto out_error);
 
@@ -875,41 +821,31 @@
 		if (rc != EOK) {
 			mfs_node_put(fn);
-			async_answer_0(rid, rc);
-			return;
+			return rc;
 		}
 	}
 out_success:
 	rc = mfs_node_put(fn);
-	async_answer_1(rid, rc, (sysarg_t)bytes);
-	return;
+	*rbytes = bytes;
+	return rc;
 out_error:
 	;
 	int tmp = mfs_node_put(fn);
 	async_answer_0(callid, tmp != EOK ? tmp : rc);
-	async_answer_0(rid, tmp != EOK ? tmp : rc);
-}
-
-void
-mfs_write(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
-	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-	aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
-					       IPC_GET_ARG4(*request));
-
+	return tmp != EOK ? tmp : rc;
+}
+
+static int
+mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
+		size_t *wbytes, aoff64_t *nsize)
+{
 	fs_node_t *fn;
 	int r;
 	int flags = BLOCK_FLAGS_NONE;
 
-	r = mfs_node_get(&fn, handle, index);
-	if (r != EOK) {
-		async_answer_0(rid, r);
-		return;
-	}
-
-	if (!fn) {
-		async_answer_0(rid, ENOENT);
-		return;
-	}
+	r = mfs_node_get(&fn, service_id, index);
+	if (r != EOK)
+		return r;
+	if (!fn)
+		return ENOENT;
 
 	ipc_callid_t callid;
@@ -953,5 +889,5 @@
 
 	block_t *b;
-	r = block_get(&b, handle, block, flags);
+	r = block_get(&b, service_id, block, flags);
 	on_error(r, goto out_err);
 
@@ -962,6 +898,5 @@
 	if (r != EOK) {
 		mfs_node_put(fn);
-		async_answer_0(rid, r);
-		return;
+		return r;
 	}
 
@@ -969,34 +904,29 @@
 	ino_i->dirty = true;
 	r = mfs_node_put(fn);
-	async_answer_2(rid, r, bytes, pos + bytes);
-	return;
+	*nsize = pos + bytes;
+	*wbytes = bytes;
+	return r;
 
 out_err:
 	mfs_node_put(fn);
 	async_answer_0(callid, r);
-	async_answer_0(rid, r);
-}
-
-void
-mfs_destroy(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t handle = (devmap_handle_t)IPC_GET_ARG1(*request);
-	fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
+	return r;
+}
+
+static int
+mfs_destroy(service_id_t service_id, fs_index_t index)
+{
 	fs_node_t *fn;
 	int r;
 
-	r = mfs_node_get(&fn, handle, index);
-	if (r != EOK) {
-		async_answer_0(rid, r);
-		return;
-	}
-	if (!fn) {
-		async_answer_0(rid, ENOENT);
-		return;
-	}
+	r = mfs_node_get(&fn, service_id, index);
+	if (r != EOK)
+		return r;
+	if (!fn)
+		return ENOENT;
 
 	/*Destroy the inode*/
 	r = mfs_destroy_node(fn);
-	async_answer_0(rid, r);
+	return r;
 }
 
@@ -1031,24 +961,15 @@
 }
 
-void
-mfs_truncate(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
-	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-	aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
-						IPC_GET_ARG4(*request));
+static int
+mfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
+{
 	fs_node_t *fn;
 	int r;
 
-	r = mfs_node_get(&fn, handle, index);
-	if (r != EOK) {
-		async_answer_0(rid, r);
-		return;
-	}
-
-	if (!fn) {
-		async_answer_0(rid, r);
-		return;
-	}
+	r = mfs_node_get(&fn, service_id, index);
+	if (r != EOK)
+		return r;
+	if (!fn)
+		return r;
 
 	struct mfs_node *mnode = fn->data;
@@ -1060,20 +981,25 @@
 		r = inode_shrink(mnode, ino_i->i_size - size);
 
-	async_answer_0(rid, r);
 	mfs_node_put(fn);
-}
-
-int mfs_instance_get(devmap_handle_t handle, struct mfs_instance **instance)
-{
-	link_t *link;
+	return r;
+}
+
+static int
+mfs_instance_get(service_id_t service_id, struct mfs_instance **instance)
+{
 	struct mfs_instance *instance_ptr;
 
 	fibril_mutex_lock(&inst_list_mutex);
 
-	for (link = inst_list.next; link != &inst_list; link = link->next) {
+	if (list_empty(&inst_list)) {
+		fibril_mutex_unlock(&inst_list_mutex);
+		return EINVAL;
+	}
+
+	list_foreach(inst_list, link) {
 		instance_ptr = list_get_instance(link, struct mfs_instance,
 						 link);
 
-		if (instance_ptr->handle == handle) {
+		if (instance_ptr->service_id == service_id) {
 			*instance = instance_ptr;
 			fibril_mutex_unlock(&inst_list_mutex);
@@ -1117,39 +1043,36 @@
 }
 
-void
-mfs_close(ipc_callid_t rid, ipc_call_t *request)
-{
-	async_answer_0(rid, EOK);
-}
-
-void
-mfs_open_node(ipc_callid_t rid, ipc_call_t *request)
-{
-	libfs_open_node(&mfs_libfs_ops, mfs_reg.fs_handle, rid, request);
-}
-
-void
-mfs_sync(ipc_callid_t rid, ipc_call_t *request)
-{
-	devmap_handle_t devmap = (devmap_handle_t) IPC_GET_ARG1(*request);
-	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
-
+static int
+mfs_close(service_id_t service_id, fs_index_t index)
+{
+	return 0;
+}
+
+static int
+mfs_sync(service_id_t service_id, fs_index_t index)
+{
 	fs_node_t *fn;
-	int rc = mfs_node_get(&fn, devmap, index);
-	if (rc != EOK) {
-		async_answer_0(rid, rc);
-		return;
-	}
-	if (!fn) {
-		async_answer_0(rid, ENOENT);
-		return;
-	}
+	int rc = mfs_node_get(&fn, service_id, index);
+	if (rc != EOK)
+		return rc;
+	if (!fn)
+		return ENOENT;
 
 	struct mfs_node *mnode = fn->data;
 	mnode->ino_i->dirty = true;
 
-	rc = mfs_node_put(fn);
-	async_answer_0(rid, rc);
-}
+	return mfs_node_put(fn);
+}
+
+vfs_out_ops_t mfs_ops = {
+	.mounted = mfs_mounted,
+	.unmounted = mfs_unmounted,
+	.read = mfs_read,
+	.write = mfs_write,
+	.truncate = mfs_truncate,
+	.close = mfs_close,
+	.destroy = mfs_destroy,
+	.sync = mfs_sync,
+};
 
 /**
Index: uspace/srv/fs/minixfs/mfs_rw.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_rw.c	(revision 8ff0bd25c8215c84283f8ba039f4cb58b7660280)
+++ uspace/srv/fs/minixfs/mfs_rw.c	(revision 03bc76a7fb314e6f8a8a718e724a331923b447b8)
@@ -296,5 +296,5 @@
 	int r;
 
-	r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NOREAD);
+	r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NOREAD);
 	on_error(r, return r);
 
@@ -331,5 +331,5 @@
 		return ENOMEM;
 
-	r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NONE);
+	r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NONE);
 	if (r != EOK) {
 		free(*ind_zone);
@@ -360,5 +360,5 @@
 	block_t *b;
 
-	r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NONE);
+	r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NONE);
 	on_error(r, return r);