Index: uspace/srv/fs/minixfs/mfs.h
===================================================================
--- uspace/srv/fs/minixfs/mfs.h	(revision 930bacaa57eda20af53925e75553d6d3679e2296)
+++ uspace/srv/fs/minixfs/mfs.h	(revision 155f7929f70344ff1ca8c9122b07bc1948b77eab)
@@ -82,4 +82,20 @@
 };
 
+/*Generic MinixFS inode*/
+struct mfs_ino_info {
+        uint16_t        i_mode;
+        uint16_t        i_nlinks;
+        int16_t         i_uid;
+        uint16_t        i_gid;
+        int32_t         i_size;
+        int32_t         i_atime;
+        int32_t         i_mtime;
+        int32_t         i_ctime;
+        /*Block numbers for direct zones*/
+        uint32_t        i_dzone[V2_NR_DIRECT_ZONES];
+        /*Block numbers for indirect zones*/
+        uint32_t        i_izone[V2_NR_INDIRECT_ZONES];
+};
+
 struct mfs_instance {
 	link_t link;
@@ -90,9 +106,5 @@
 /*MinixFS node in core*/
 struct mfs_node {
-	union {
-		struct mfs_inode *ino;
-		struct mfs2_inode *ino2;
-	};
-
+	struct mfs_ino_info *ino_i;
 	struct mfs_instance *instance;
 };
@@ -115,8 +127,8 @@
 /*mfs_inode.c*/
 extern
-struct mfs_inode *mfs_read_inode_raw(const struct mfs_instance *instance, 
+struct mfs_ino_info *mfs_read_inode_raw(const struct mfs_instance *instance, 
 					uint16_t inum);
 extern
-struct mfs2_inode *mfs2_read_inode_raw(const struct mfs_instance *instance,
+struct mfs_ino_info *mfs2_read_inode_raw(const struct mfs_instance *instance,
 					uint32_t inum);
 
Index: uspace/srv/fs/minixfs/mfs_inode.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_inode.c	(revision 930bacaa57eda20af53925e75553d6d3679e2296)
+++ uspace/srv/fs/minixfs/mfs_inode.c	(revision 155f7929f70344ff1ca8c9122b07bc1948b77eab)
@@ -1,12 +1,14 @@
 #include <stdlib.h>
 #include <assert.h>
+#include <errno.h>
 #include <mem.h>
 #include "mfs.h"
 #include "mfs_utils.h"
 
-struct mfs_inode *mfs_read_inode_raw(const struct mfs_instance *instance, 
+struct mfs_ino_info *mfs_read_inode_raw(const struct mfs_instance *instance, 
 					uint16_t inum)
 {
-	struct mfs_inode *ino;
+	struct mfs_inode *ino = NULL;
+	struct mfs_ino_info *ino_i = NULL;
 	struct mfs_sb_info *sbi;
 	block_t *b;
@@ -16,8 +18,9 @@
 	const size_t ino_size = sizeof(struct mfs_inode);
 
+	ino_i = (struct mfs_ino_info *) malloc(sizeof(struct mfs_ino_info));
 	ino = (struct mfs_inode *) malloc(ino_size);
 
-	if (!ino)
-		return NULL;
+	if (!ino || !ino_i)
+		goto out_err;
 
 	sbi = instance->sbi;
@@ -26,29 +29,39 @@
 	const int itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
 
-	block_get(&b, instance->handle, itable_off + inum / V1_INODES_PER_BLOCK,
-			BLOCK_FLAGS_NONE);
+	if (block_get(&b, instance->handle, itable_off + inum / V1_INODES_PER_BLOCK,
+			BLOCK_FLAGS_NONE) != EOK)
+		goto out_err;
 
 	memcpy(ino, ((uint8_t *) b->data) + ino_off * ino_size, ino_size);
 
-	ino->i_mode = conv16(sbi->native, ino->i_mode);
-	ino->i_uid = conv16(sbi->native, ino->i_uid);
-	ino->i_size = conv32(sbi->native, ino->i_size);
-	ino->i_mtime = conv32(sbi->native, ino->i_mtime);
+	ino_i->i_mode = conv16(sbi->native, ino->i_mode);
+	ino_i->i_uid = conv16(sbi->native, ino->i_uid);
+	ino_i->i_size = conv32(sbi->native, ino->i_size);
+	ino_i->i_mtime = conv32(sbi->native, ino->i_mtime);
 
 	for (i = 0; i < V1_NR_DIRECT_ZONES; ++i)
-		ino->i_dzone[i] = conv16(sbi->native, ino->i_dzone[i]);
+		ino_i->i_dzone[i] = conv16(sbi->native, ino->i_dzone[i]);
 
 	for (i = 0; i < V1_NR_INDIRECT_ZONES; ++i)
-		ino->i_izone[i] = conv16(sbi->native, ino->i_izone[i]);
+		ino_i->i_izone[i] = conv16(sbi->native, ino->i_izone[i]);
 
 	block_put(b);
 
-	return ino;
+	free(ino);
+	return ino_i;
+
+out_err:
+	if (ino)
+		free(ino);
+	if (ino_i)
+		free(ino_i);
+	return NULL;
 }
 
-struct mfs2_inode *mfs2_read_inode_raw(const struct mfs_instance *instance,
+struct mfs_ino_info *mfs2_read_inode_raw(const struct mfs_instance *instance,
 					uint32_t inum)
 {
-	struct mfs2_inode *ino;
+	struct mfs2_inode *ino = NULL;
+	struct mfs_ino_info *ino_i = NULL;
 	struct mfs_sb_info *sbi;
 	block_t *b;
@@ -58,7 +71,8 @@
 
 	ino = (struct mfs2_inode *) malloc(ino_size);
+	ino_i = (struct mfs_ino_info *) malloc(sizeof(struct mfs_ino_info));
 
-	if (!ino)
-		return NULL;
+	if (!ino || !ino_i)
+		goto out_err;
 
 	sbi = instance->sbi;
@@ -68,28 +82,37 @@
 	const int ino_off = inum % V3_INODES_PER_BLOCK(sbi->block_size);
 
-	block_get(&b, instance->handle, 
+	if (block_get(&b, instance->handle, 
 		itable_off + inum / V3_INODES_PER_BLOCK(sbi->block_size),
-		BLOCK_FLAGS_NONE);
+			BLOCK_FLAGS_NONE) != EOK)
+		goto out_err;
 
 	memcpy(ino, ((uint8_t *)b->data) + ino_off * ino_size, ino_size);
 
-	ino->i_mode = conv16(sbi->native, ino->i_mode);
-	ino->i_nlinks = conv16(sbi->native, ino->i_nlinks);
-	ino->i_uid = conv16(sbi->native, ino->i_uid);
-	ino->i_gid = conv16(sbi->native, ino->i_gid);
-	ino->i_size = conv32(sbi->native, ino->i_size);
-	ino->i_atime = conv32(sbi->native, ino->i_atime);
-	ino->i_mtime = conv32(sbi->native, ino->i_mtime);
-	ino->i_ctime = conv32(sbi->native, ino->i_ctime);
+	ino_i->i_mode = conv16(sbi->native, ino->i_mode);
+	ino_i->i_nlinks = conv16(sbi->native, ino->i_nlinks);
+	ino_i->i_uid = conv16(sbi->native, ino->i_uid);
+	ino_i->i_gid = conv16(sbi->native, ino->i_gid);
+	ino_i->i_size = conv32(sbi->native, ino->i_size);
+	ino_i->i_atime = conv32(sbi->native, ino->i_atime);
+	ino_i->i_mtime = conv32(sbi->native, ino->i_mtime);
+	ino_i->i_ctime = conv32(sbi->native, ino->i_ctime);
 
 	for (i = 0; i < V2_NR_DIRECT_ZONES; ++i)
-		ino->i_dzone[i] = conv32(sbi->native, ino->i_dzone[i]);
+		ino_i->i_dzone[i] = conv32(sbi->native, ino->i_dzone[i]);
 
 	for (i = 0; i < V2_NR_INDIRECT_ZONES; ++i)
-		ino->i_izone[i] = conv32(sbi->native, ino->i_izone[i]);
+		ino_i->i_izone[i] = conv32(sbi->native, ino->i_izone[i]);
 
 	block_put(b);
 
-	return ino;
+	free(ino);
+	return ino_i;
+
+out_err:
+	if (ino)
+		free(ino);
+	if (ino_i)
+		free(ino_i);
+	return NULL;
 }
 
Index: uspace/srv/fs/minixfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_ops.c	(revision 930bacaa57eda20af53925e75553d6d3679e2296)
+++ uspace/srv/fs/minixfs/mfs_ops.c	(revision 155f7929f70344ff1ca8c9122b07bc1948b77eab)
@@ -212,6 +212,4 @@
 aoff64_t mfs_size_get(fs_node_t *node)
 {
-	aoff64_t size;
-
 	mfsdebug("request for inode size\n");
 	assert(node);
@@ -219,22 +217,7 @@
 	const struct mfs_node *mnode = node->data;
 	assert(mnode);
-
-	const struct mfs_instance *inst = mnode->instance;
-	assert(inst);
-
-	const struct mfs_sb_info *sbi = inst->sbi;
-	assert(sbi);
-
-	if (sbi->fs_version == MFS_VERSION_V1) {
-		struct mfs_inode *ino;
-		ino = mnode->ino;
-		size = ino->i_size;
-	} else {
-		struct mfs2_inode *ino2;
-		ino2 = mnode->ino2;
-		size = ino2->i_size;
-	}
-
-	return size;
+	assert(mnode->ino_i);
+
+	return mnode->ino_i->i_size;
 }
 
@@ -282,17 +265,18 @@
 	}
 
+	struct mfs_ino_info *ino_i;
+
 	if (sbi->fs_version == MFS_VERSION_V1) {
 		/*Read MFS V1 inode*/
-		struct mfs_inode *ino;
-
-		ino = mfs_read_inode_raw(inst, index);
-		mnode->ino = ino;
+		ino_i = mfs_read_inode_raw(inst, index);
 	} else {
 		/*Read MFS V2/V3 inode*/
-		struct mfs2_inode *ino2;
-
-		ino2 = mfs2_read_inode_raw(inst, index);
-		mnode->ino2 = ino2;
-	}
+		ino_i = mfs2_read_inode_raw(inst, index);
+	}
+
+	if (!ino_i)
+		return -1;
+
+	mnode->ino_i = ino_i;
 
 	mnode->instance = inst;
@@ -313,10 +297,5 @@
 {
 	const struct mfs_node *node = fsnode->data;
-	const struct mfs_sb_info *sbi = node->instance->sbi;
-
-	if (sbi->fs_version == MFS_VERSION_V1)
-		return S_ISDIR(node->ino->i_mode);
-	else
-		return S_ISDIR(node->ino2->i_mode);
+	return S_ISDIR(node->ino_i->i_mode);
 }
 
@@ -324,10 +303,5 @@
 {
 	struct mfs_node *node = fsnode->data;
-	struct mfs_sb_info *sbi = node->instance->sbi;
-
-	if (sbi->fs_version == MFS_VERSION_V1)
-		return S_ISREG(node->ino->i_mode);
-	else
-		return S_ISREG(node->ino2->i_mode);
+	return S_ISREG(node->ino_i->i_mode);
 }
 
Index: uspace/srv/fs/minixfs/mfs_read.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_read.c	(revision 930bacaa57eda20af53925e75553d6d3679e2296)
+++ uspace/srv/fs/minixfs/mfs_read.c	(revision 155f7929f70344ff1ca8c9122b07bc1948b77eab)
@@ -4,6 +4,5 @@
 #include "mfs_utils.h"
 
-static int read_map_v1(uint16_t *b, const struct mfs_node *mnode, int rblock);
-static int read_map_v2(uint32_t *b, const struct mfs_node *mnode, int rblock);
+static int read_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock);
 
 /*Given the position in the file expressed in
@@ -22,5 +21,4 @@
 	assert(sbi);
 
-	const mfs_version_t fs_version = sbi->fs_version;
 	const int block_size = sbi->block_size;
 
@@ -28,96 +26,25 @@
 	int rblock = pos / block_size;
 
-	if (fs_version == MFS_VERSION_V1) {
-		if (mnode->ino->i_size < (int32_t) pos)
-			return -1;
-
-		uint16_t b16 = 0;
-		r = read_map_v1(&b16, mnode, rblock);
-		*b = b16;
-	} else {
-		if (mnode->ino2->i_size < (int32_t) pos)
-			return -1;
-
-		r = read_map_v2(b, mnode, rblock);
-	}
-
-	return r;
-}
-
-static int read_map_v1(uint16_t *b, const struct mfs_node *mnode, int rblock)
-{
-	const int ptrs_per_block = MFS_BLOCKSIZE / sizeof(uint16_t);
-	block_t *bi1, *bi2;
-	const struct mfs_inode *ino = mnode->ino;
-	int r;
-
-	assert(ino);
-	assert(mnode->instance);
-
-	if (rblock < V1_NR_DIRECT_ZONES) {
-		*b = ino->i_dzone[rblock];
+	if (mnode->ino_i->i_size < (int32_t) pos) {
 		r = EOK;
+		*b = 0;
 		goto out;
 	}
 
-	rblock -= V1_NR_DIRECT_ZONES - 1;
-
-	/*Check if the wanted block is in the single indirect zone*/
-	if (rblock < ptrs_per_block) {
-		if (ino->i_izone[0] == 0) {
-			r = -1;
-			goto out;
-		}
-
-		r = read_ind_block(bi1, mnode->instance, ino->i_izone[0]);
-
-		if (r != EOK)
-			goto out;
-
-		*b = ((uint16_t *) bi1->data)[rblock];
-		goto out_block;
-	}
-
-	rblock -= ptrs_per_block - 1;
-
-	/*The wanted block is in the double indirect zone*/
-	uint16_t di_block = rblock / ptrs_per_block;
-
-	/*read the first indirect zone*/
-	if (ino->i_izone[1] == 0) {
-		r = -1;
-		goto out;
-	}
-
-	r = read_ind_block(bi1, mnode->instance, ino->i_izone[1]);
-
-	if (r != EOK)
-		goto out;
-
-	/*read the dobule indirect zone*/
-	r = read_ind_block(bi2, mnode->instance,
-			((uint16_t *) bi1->data)[di_block]);
-
-	if (r != EOK)
-		goto out_block;
-
-	*b = ((uint16_t *) bi2->data)[rblock % ptrs_per_block];
-	block_put(bi2);
-
-out_block:
-	block_put(bi1);
+	r = read_map_ondisk(b, mnode, rblock);
 out:
 	return r;
 }
 
-static int read_map_v2(uint32_t *b, const struct mfs_node *mnode, int rblock)
+static int read_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock)
 {
 	block_t *bi1, *bi2;
-	int r;
+	int r, nr_direct, nr_indirect;
+	int ptrs_per_block;
 
 	assert(mnode);
-	const struct mfs2_inode *ino2 = mnode->ino2;
+	const struct mfs_ino_info *ino_i = mnode->ino_i;
 
-	assert(ino2);
+	assert(ino_i);
 	assert(mnode->instance);
 
@@ -125,26 +52,38 @@
 	assert(sbi);
 
-	const int ptrs_per_block = sbi->block_size / sizeof(uint32_t);
+	const int fs_version = sbi->fs_version;
 
-	if (rblock < V2_NR_DIRECT_ZONES) {
-		*b = ino2->i_dzone[rblock];
+	if (fs_version == MFS_VERSION_V1) {
+		nr_direct = V1_NR_DIRECT_ZONES;
+		nr_indirect = V1_NR_INDIRECT_ZONES;
+		ptrs_per_block = MFS_BLOCKSIZE / sizeof(uint16_t);
+	} else {
+		nr_direct = V2_NR_DIRECT_ZONES;
+		nr_indirect = V2_NR_INDIRECT_ZONES;
+		ptrs_per_block = sbi->block_size / sizeof(uint32_t);
+	}
+
+	if (rblock < nr_direct) {
+		*b = ino_i->i_dzone[rblock];
 		r = EOK;
 		goto out;
 	}
-	rblock -= V2_NR_DIRECT_ZONES - 1;
+	rblock -= nr_direct - 1;
 
 	/*Check if the wanted block is in the single indirect zone*/
 	if (rblock < ptrs_per_block) {
-		if (ino2->i_izone[0] == 0) {
+		if (ino_i->i_izone[0] == 0) {
 			r = -1;
 			goto out;
 		}
 
-		r = read_ind_block(bi2, mnode->instance, ino2->i_izone[0]);
+		r = read_ind_block(bi2, mnode->instance, ino_i->i_izone[0]);
 
 		if (r != EOK)
 			goto out;
 
-		*b = ((uint32_t *) bi1->data)[rblock];
+		*b = fs_version == MFS_VERSION_V1 ? 
+				((uint16_t *) bi1->data)[rblock] :
+				((uint32_t *) bi1->data)[rblock];
 		goto out_block;
 	}
@@ -156,10 +95,10 @@
 
 	/*read the first indirect zone*/
-	if (ino2->i_izone[1] == 0) {
+	if (ino_i->i_izone[1] == 0) {
 		r = -1;
 		goto out;
 	}
 
-	r = read_ind_block(bi1, mnode->instance, ino2->i_izone[1]);
+	r = read_ind_block(bi1, mnode->instance, ino_i->i_izone[1]);
 
 	if (r != EOK)
@@ -167,11 +106,21 @@
 
 	/*read the second indirect zone*/
-	r = read_ind_block(bi2, mnode->instance,
+	if (fs_version == MFS_VERSION_V1) {
+		r = read_ind_block(bi2, mnode->instance,
+			((uint16_t *) bi1->data)[di_block]);
+
+		if (r != EOK)
+			goto out_block;
+
+		*b = ((uint16_t *) bi2->data)[rblock % ptrs_per_block];
+	} else {
+		r = read_ind_block(bi2, mnode->instance,
 			((uint32_t *) bi1->data)[di_block]);
 
-	if (r != EOK)
-		goto out_block;
+		if (r != EOK)
+			goto out_block;
 
-	*b = ((uint32_t *) bi2->data)[rblock % ptrs_per_block];
+		*b = ((uint32_t *) bi2->data)[rblock % ptrs_per_block];
+	}
 	block_put(bi2);