Index: uspace/lib/ext4/src/filesystem.c
===================================================================
--- uspace/lib/ext4/src/filesystem.c	(revision 4bfad3422afe1c140899057793076c94f3bd77db)
+++ uspace/lib/ext4/src/filesystem.c	(revision be39fc6933dcee0f4da8cad1a1eb341979fbb8ce)
@@ -69,5 +69,5 @@
  *
  */
-int ext4_filesystem_init(ext4_filesystem_t *fs, ext4fs_instance_t *inst,
+int ext4_filesystem_init(ext4_filesystem_t *fs, ext4_instance_t *inst,
     service_id_t service_id, enum cache_mode cmode, aoff64_t *size)
 {
@@ -135,5 +135,5 @@
 	/* Read root node */
 	fs_node_t *root_node;
-	rc = ext4fs_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
+	rc = ext4_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
 	if (rc != EOK)
 		goto err_2;
@@ -148,12 +148,12 @@
 	ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
 
-	ext4fs_node_t *enode = EXT4FS_NODE(root_node);
+	ext4_node_t *enode = EXT4_NODE(root_node);
 	
 	*size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
 
-	ext4fs_node_put(root_node);
+	ext4_node_put(root_node);
 	return EOK;
 err_3:
-	ext4fs_node_put(root_node);
+	ext4_node_put(root_node);
 err_2:
 	block_cache_fini(fs->device);
Index: uspace/lib/ext4/src/ops.c
===================================================================
--- uspace/lib/ext4/src/ops.c	(revision 4bfad3422afe1c140899057793076c94f3bd77db)
+++ uspace/lib/ext4/src/ops.c	(revision be39fc6933dcee0f4da8cad1a1eb341979fbb8ce)
@@ -36,46 +36,54 @@
  */
 
+#include <adt/hash_table.h>
+#include <adt/hash.h>
 #include <errno.h>
-#include <ext4/libext4.h>
 #include <fibril_synch.h>
 #include <libfs.h>
 #include <macros.h>
 #include <malloc.h>
-#include <adt/hash_table.h>
-#include <adt/hash.h>
+#include <mem.h>
+#include <str.h>
 #include <ipc/loc.h>
+#include "ext4/balloc.h"
+#include "ext4/directory.h"
+#include "ext4/directory_index.h"
+#include "ext4/extent.h"
+#include "ext4/inode.h"
 #include "ext4/ops.h"
+#include "ext4/filesystem.h"
 #include "ext4/fstypes.h"
+#include "ext4/superblock.h"
 
 /* Forward declarations of auxiliary functions */
 
-static int ext4fs_read_directory(ipc_callid_t, aoff64_t, size_t,
-    ext4fs_instance_t *, ext4_inode_ref_t *, size_t *);
-static int ext4fs_read_file(ipc_callid_t, aoff64_t, size_t, ext4fs_instance_t *,
+static int ext4_read_directory(ipc_callid_t, aoff64_t, size_t,
+    ext4_instance_t *, ext4_inode_ref_t *, size_t *);
+static int ext4_read_file(ipc_callid_t, aoff64_t, size_t, ext4_instance_t *,
     ext4_inode_ref_t *, size_t *);
-static bool ext4fs_is_dots(const uint8_t *, size_t);
-static int ext4fs_instance_get(service_id_t, ext4fs_instance_t **);
+static bool ext4_is_dots(const uint8_t *, size_t);
+static int ext4_instance_get(service_id_t, ext4_instance_t **);
 
 /* Forward declarations of ext4 libfs operations. */
 
-static int ext4fs_root_get(fs_node_t **, service_id_t);
-static int ext4fs_match(fs_node_t **, fs_node_t *, const char *);
-static int ext4fs_node_get(fs_node_t **, service_id_t, fs_index_t);
-static int ext4fs_node_open(fs_node_t *);
-       int ext4fs_node_put(fs_node_t *);
-static int ext4fs_create_node(fs_node_t **, service_id_t, int);
-static int ext4fs_destroy_node(fs_node_t *);
-static int ext4fs_link(fs_node_t *, fs_node_t *, const char *);
-static int ext4fs_unlink(fs_node_t *, fs_node_t *, const char *);
-static int ext4fs_has_children(bool *, fs_node_t *);
-static fs_index_t ext4fs_index_get(fs_node_t *);
-static aoff64_t ext4fs_size_get(fs_node_t *);
-static unsigned ext4fs_lnkcnt_get(fs_node_t *);
-static bool ext4fs_is_directory(fs_node_t *);
-static bool ext4fs_is_file(fs_node_t *node);
-static service_id_t ext4fs_service_get(fs_node_t *node);
-static int ext4fs_size_block(service_id_t, uint32_t *);
-static int ext4fs_total_block_count(service_id_t, uint64_t *);
-static int ext4fs_free_block_count(service_id_t, uint64_t *);
+static int ext4_root_get(fs_node_t **, service_id_t);
+static int ext4_match(fs_node_t **, fs_node_t *, const char *);
+static int ext4_node_get(fs_node_t **, service_id_t, fs_index_t);
+static int ext4_node_open(fs_node_t *);
+       int ext4_node_put(fs_node_t *);
+static int ext4_create_node(fs_node_t **, service_id_t, int);
+static int ext4_destroy_node(fs_node_t *);
+static int ext4_link(fs_node_t *, fs_node_t *, const char *);
+static int ext4_unlink(fs_node_t *, fs_node_t *, const char *);
+static int ext4_has_children(bool *, fs_node_t *);
+static fs_index_t ext4_index_get(fs_node_t *);
+static aoff64_t ext4_size_get(fs_node_t *);
+static unsigned ext4_lnkcnt_get(fs_node_t *);
+static bool ext4_is_directory(fs_node_t *);
+static bool ext4_is_file(fs_node_t *node);
+static service_id_t ext4_service_get(fs_node_t *node);
+static int ext4_size_block(service_id_t, uint32_t *);
+static int ext4_total_block_count(service_id_t, uint64_t *);
+static int ext4_free_block_count(service_id_t, uint64_t *);
 
 /* Static variables */
@@ -101,5 +109,5 @@
 static size_t open_nodes_hash(const ht_link_t *item)
 {
-	ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
+	ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
 	return hash_combine(enode->instance->service_id, enode->inode_ref->index);	
 }
@@ -108,5 +116,5 @@
 {
 	node_key_t *key = (node_key_t *)key_arg;
-	ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
+	ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
 	
 	return key->service_id == enode->instance->service_id
@@ -130,5 +138,5 @@
  *
  */
-int ext4fs_global_init(void)
+int ext4_global_init(void)
 {
 	if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
@@ -144,5 +152,5 @@
  * @return Error code
  */
-int ext4fs_global_fini(void)
+int ext4_global_fini(void)
 {
 	hash_table_destroy(&open_nodes);
@@ -162,5 +170,5 @@
  *
  */
-int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
+int ext4_instance_get(service_id_t service_id, ext4_instance_t **inst)
 {
 	fibril_mutex_lock(&instance_list_mutex);
@@ -171,5 +179,5 @@
 	}
 	
-	list_foreach(instance_list, link, ext4fs_instance_t, tmp) {
+	list_foreach(instance_list, link, ext4_instance_t, tmp) {
 		if (tmp->service_id == service_id) {
 			*inst = tmp;
@@ -191,7 +199,7 @@
  *
  */
-int ext4fs_root_get(fs_node_t **rfn, service_id_t service_id)
-{
-	return ext4fs_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
+int ext4_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+	return ext4_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
 }
 
@@ -207,7 +215,7 @@
  *
  */
-int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
-{
-	ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
+int ext4_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
+{
+	ext4_node_t *eparent = EXT4_NODE(pfn);
 	ext4_filesystem_t *fs = eparent->instance->filesystem;
 	
@@ -231,5 +239,5 @@
 	/* Load node from search result */
 	uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry);
-	rc = ext4fs_node_get_core(rfn, eparent->instance, inode);
+	rc = ext4_node_get_core(rfn, eparent->instance, inode);
 	if (rc != EOK)
 		goto exit;
@@ -254,12 +262,12 @@
  *
  */
-int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
-{
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
-	if (rc != EOK)
-		return rc;
-	
-	return ext4fs_node_get_core(rfn, inst, index);
+int ext4_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
+{
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
+	if (rc != EOK)
+		return rc;
+	
+	return ext4_node_get_core(rfn, inst, index);
 }
 
@@ -273,5 +281,5 @@
  *
  */
-int ext4fs_node_get_core(fs_node_t **rfn, ext4fs_instance_t *inst,
+int ext4_node_get_core(fs_node_t **rfn, ext4_instance_t *inst,
     fs_index_t index)
 {
@@ -285,7 +293,7 @@
 	
 	ht_link_t *already_open = hash_table_find(&open_nodes, &key);
-	ext4fs_node_t *enode = NULL;
+	ext4_node_t *enode = NULL;
 	if (already_open) {
-		enode = hash_table_get_inst(already_open, ext4fs_node_t, link);
+		enode = hash_table_get_inst(already_open, ext4_node_t, link);
 		*rfn = enode->fs_node;
 		enode->references++;
@@ -296,5 +304,5 @@
 	
 	/* Prepare new enode */
-	enode = malloc(sizeof(ext4fs_node_t));
+	enode = malloc(sizeof(ext4_node_t));
 	if (enode == NULL) {
 		fibril_mutex_unlock(&open_nodes_lock);
@@ -347,5 +355,5 @@
  *
  */
-static int ext4fs_node_put_core(ext4fs_node_t *enode)
+static int ext4_node_put_core(ext4_node_t *enode)
 {
 	hash_table_remove_item(&open_nodes, &enode->link);
@@ -374,5 +382,5 @@
  *
  */
-int ext4fs_node_open(fs_node_t *fn)
+int ext4_node_open(fs_node_t *fn)
 {
 	/* Stateless operation */
@@ -388,13 +396,13 @@
  *
  */
-int ext4fs_node_put(fs_node_t *fn)
+int ext4_node_put(fs_node_t *fn)
 {
 	fibril_mutex_lock(&open_nodes_lock);
 	
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_node_t *enode = EXT4_NODE(fn);
 	assert(enode->references > 0);
 	enode->references--;
 	if (enode->references == 0) {
-		int rc = ext4fs_node_put_core(enode);
+		int rc = ext4_node_put_core(enode);
 		if (rc != EOK) {
 			fibril_mutex_unlock(&open_nodes_lock);
@@ -417,9 +425,9 @@
  *
  */
-int ext4fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
+int ext4_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
 	/* Allocate enode */
-	ext4fs_node_t *enode;
-	enode = malloc(sizeof(ext4fs_node_t));
+	ext4_node_t *enode;
+	enode = malloc(sizeof(ext4_node_t));
 	if (enode == NULL)
 		return ENOMEM;
@@ -434,6 +442,6 @@
 	
 	/* Load instance */
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK) {
 		free(enode);
@@ -478,20 +486,20 @@
  *
  */
-int ext4fs_destroy_node(fs_node_t *fn)
+int ext4_destroy_node(fs_node_t *fn)
 {
 	/* If directory, check for children */
 	bool has_children;
-	int rc = ext4fs_has_children(&has_children, fn);
-	if (rc != EOK) {
-		ext4fs_node_put(fn);
+	int rc = ext4_has_children(&has_children, fn);
+	if (rc != EOK) {
+		ext4_node_put(fn);
 		return rc;
 	}
 	
 	if (has_children) {
-		ext4fs_node_put(fn);
+		ext4_node_put(fn);
 		return EINVAL;
 	}
 	
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_inode_ref_t *inode_ref = enode->inode_ref;
 	
@@ -499,5 +507,5 @@
 	rc = ext4_filesystem_truncate_inode(inode_ref, 0);
 	if (rc != EOK) {
-		ext4fs_node_put(fn);
+		ext4_node_put(fn);
 		return rc;
 	}
@@ -513,9 +521,9 @@
 	rc = ext4_filesystem_free_inode(inode_ref);
 	if (rc != EOK) {
-		ext4fs_node_put(fn);
-		return rc;
-	}
-	
-	return ext4fs_node_put(fn);
+		ext4_node_put(fn);
+		return rc;
+	}
+	
+	return ext4_node_put(fn);
 }
 
@@ -529,5 +537,5 @@
  *
  */
-int ext4fs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+int ext4_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
 	/* Check maximum name length */
@@ -535,6 +543,6 @@
 		return ENAMETOOLONG;
 	
-	ext4fs_node_t *parent = EXT4FS_NODE(pfn);
-	ext4fs_node_t *child = EXT4FS_NODE(cfn);
+	ext4_node_t *parent = EXT4_NODE(pfn);
+	ext4_node_t *child = EXT4_NODE(cfn);
 	ext4_filesystem_t *fs = parent->instance->filesystem;
 	
@@ -602,8 +610,8 @@
  *
  */
-int ext4fs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+int ext4_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
 	bool has_children;
-	int rc = ext4fs_has_children(&has_children, cfn);
+	int rc = ext4_has_children(&has_children, cfn);
 	if (rc != EOK)
 		return rc;
@@ -614,5 +622,5 @@
 	
 	/* Remove entry from parent directory */
-	ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref;
+	ext4_inode_ref_t *parent = EXT4_NODE(pfn)->inode_ref;
 	rc = ext4_directory_remove_entry(parent, name);
 	if (rc != EOK)
@@ -620,5 +628,5 @@
 	
 	/* Decrement links count */
-	ext4_inode_ref_t *child_inode_ref = EXT4FS_NODE(cfn)->inode_ref;
+	ext4_inode_ref_t *child_inode_ref = EXT4_NODE(cfn)->inode_ref;
 	
 	uint32_t lnk_count =
@@ -627,10 +635,10 @@
 	
 	/* If directory - handle links from parent */
-	if ((lnk_count <= 1) && (ext4fs_is_directory(cfn))) {
+	if ((lnk_count <= 1) && (ext4_is_directory(cfn))) {
 		assert(lnk_count == 1);
 		
 		lnk_count--;
 		
-		ext4_inode_ref_t *parent_inode_ref = EXT4FS_NODE(pfn)->inode_ref;
+		ext4_inode_ref_t *parent_inode_ref = EXT4_NODE(pfn)->inode_ref;
 		
 		uint32_t parent_lnk_count = ext4_inode_get_links_count(
@@ -675,7 +683,7 @@
  *
  */
-int ext4fs_has_children(bool *has_children, fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+int ext4_has_children(bool *has_children, fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_filesystem_t *fs = enode->instance->filesystem;
 	
@@ -699,5 +707,5 @@
 			    ext4_directory_entry_ll_get_name_length(fs->superblock,
 			    it.current);
-			if (!ext4fs_is_dots(it.current->name, name_size)) {
+			if (!ext4_is_dots(it.current->name, name_size)) {
 				found = true;
 				break;
@@ -728,7 +736,7 @@
  *
  */
-fs_index_t ext4fs_index_get(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+fs_index_t ext4_index_get(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	return enode->inode_ref->index;
 }
@@ -741,7 +749,7 @@
  *
  */
-aoff64_t ext4fs_size_get(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+aoff64_t ext4_size_get(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
 	return ext4_inode_get_size(sb, enode->inode_ref->inode);
@@ -755,10 +763,10 @@
  *
  */
-unsigned ext4fs_lnkcnt_get(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+unsigned ext4_lnkcnt_get(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
 	
-	if (ext4fs_is_directory(fn)) {
+	if (ext4_is_directory(fn)) {
 		if (lnkcnt > 1)
 			return 1;
@@ -778,7 +786,7 @@
  *
  */
-bool ext4fs_is_directory(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+bool ext4_is_directory(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
 	
@@ -794,7 +802,7 @@
  *
  */
-bool ext4fs_is_file(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+bool ext4_is_file(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
 	
@@ -810,14 +818,14 @@
  *
  */
-service_id_t ext4fs_service_get(fs_node_t *fn)
-{
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+service_id_t ext4_service_get(fs_node_t *fn)
+{
+	ext4_node_t *enode = EXT4_NODE(fn);
 	return enode->instance->service_id;
 }
 
-int ext4fs_size_block(service_id_t service_id, uint32_t *size)
-{
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+int ext4_size_block(service_id_t service_id, uint32_t *size)
+{
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
@@ -832,8 +840,8 @@
 }
 
-int ext4fs_total_block_count(service_id_t service_id, uint64_t *count)
-{
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+int ext4_total_block_count(service_id_t service_id, uint64_t *count)
+{
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
@@ -848,8 +856,8 @@
 }
 
-int ext4fs_free_block_count(service_id_t service_id, uint64_t *count)
-{
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+int ext4_free_block_count(service_id_t service_id, uint64_t *count)
+{
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
@@ -864,24 +872,24 @@
  * libfs operations.
  */
-libfs_ops_t ext4fs_libfs_ops = {
-	.root_get = ext4fs_root_get,
-	.match = ext4fs_match,
-	.node_get = ext4fs_node_get,
-	.node_open = ext4fs_node_open,
-	.node_put = ext4fs_node_put,
-	.create = ext4fs_create_node,
-	.destroy = ext4fs_destroy_node,
-	.link = ext4fs_link,
-	.unlink = ext4fs_unlink,
-	.has_children = ext4fs_has_children,
-	.index_get = ext4fs_index_get,
-	.size_get = ext4fs_size_get,
-	.lnkcnt_get = ext4fs_lnkcnt_get,
-	.is_directory = ext4fs_is_directory,
-	.is_file = ext4fs_is_file,
-	.service_get = ext4fs_service_get,
-	.size_block = ext4fs_size_block,
-	.total_block_count = ext4fs_total_block_count,
-	.free_block_count = ext4fs_free_block_count
+libfs_ops_t ext4_libfs_ops = {
+	.root_get = ext4_root_get,
+	.match = ext4_match,
+	.node_get = ext4_node_get,
+	.node_open = ext4_node_open,
+	.node_put = ext4_node_put,
+	.create = ext4_create_node,
+	.destroy = ext4_destroy_node,
+	.link = ext4_link,
+	.unlink = ext4_unlink,
+	.has_children = ext4_has_children,
+	.index_get = ext4_index_get,
+	.size_get = ext4_size_get,
+	.lnkcnt_get = ext4_lnkcnt_get,
+	.is_directory = ext4_is_directory,
+	.is_file = ext4_is_file,
+	.service_get = ext4_service_get,
+	.size_block = ext4_size_block,
+	.total_block_count = ext4_total_block_count,
+	.free_block_count = ext4_free_block_count
 };
 
@@ -899,5 +907,5 @@
  * @return Error code
  */
-static int ext4fs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+static int ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
 {
 	return ENOTSUP;
@@ -917,5 +925,5 @@
  *
  */
-static int ext4fs_mounted(service_id_t service_id, const char *opts,
+static int ext4_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
 {
@@ -927,6 +935,6 @@
 	
 	/* Allocate instance structure */
-	ext4fs_instance_t *inst = (ext4fs_instance_t *)
-	    malloc(sizeof(ext4fs_instance_t));
+	ext4_instance_t *inst = (ext4_instance_t *)
+	    malloc(sizeof(ext4_instance_t));
 	if (inst == NULL) {
 		free(fs);
@@ -976,8 +984,8 @@
  *
  */
-static int ext4fs_unmounted(service_id_t service_id)
-{
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+static int ext4_unmounted(service_id_t service_id)
+{
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
@@ -1010,5 +1018,5 @@
  *
  */
-static int ext4fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static int ext4_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -1023,6 +1031,6 @@
 	}
 	
-	ext4fs_instance_t *inst;
-	int rc = ext4fs_instance_get(service_id, &inst);
+	ext4_instance_t *inst;
+	int rc = ext4_instance_get(service_id, &inst);
 	if (rc != EOK) {
 		async_answer_0(callid, rc);
@@ -1041,9 +1049,9 @@
 	if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
 	    EXT4_INODE_MODE_FILE)) {
-		rc = ext4fs_read_file(callid, pos, size, inst, inode_ref,
+		rc = ext4_read_file(callid, pos, size, inst, inode_ref,
 		    rbytes);
 	} else if (ext4_inode_is_type(inst->filesystem->superblock,
 	    inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
-		rc = ext4fs_read_directory(callid, pos, size, inst, inode_ref,
+		rc = ext4_read_directory(callid, pos, size, inst, inode_ref,
 		    rbytes);
 	} else {
@@ -1066,5 +1074,5 @@
  *
  */
-bool ext4fs_is_dots(const uint8_t *name, size_t name_size)
+bool ext4_is_dots(const uint8_t *name, size_t name_size)
 {
 	if ((name_size == 1) && (name[0] == '.'))
@@ -1089,6 +1097,6 @@
  *
  */
-int ext4fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
-    ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
+int ext4_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
+    ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
 {
 	ext4_directory_iterator_t it;
@@ -1113,5 +1121,5 @@
 		
 		/* Skip . and .. */
-		if (ext4fs_is_dots(it.current->name, name_size))
+		if (ext4_is_dots(it.current->name, name_size))
 			goto skip;
 		
@@ -1180,6 +1188,6 @@
  *
  */
-int ext4fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
-    ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
+int ext4_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
+    ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
 {
 	ext4_superblock_t *sb = inst->filesystem->superblock;
@@ -1269,9 +1277,9 @@
  *
  */
-static int ext4fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static int ext4_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
 	fs_node_t *fn;
-	int rc = ext4fs_node_get(&fn, service_id, index);
+	int rc = ext4_node_get(&fn, service_id, index);
 	if (rc != EOK)
 		return rc;
@@ -1285,5 +1293,5 @@
 	}
 	
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_filesystem_t *fs = enode->instance->filesystem;
 	
@@ -1391,5 +1399,5 @@
 	;
 
-	int const rc2 = ext4fs_node_put(fn);
+	int const rc2 = ext4_node_put(fn);
 	return rc == EOK ? rc2 : rc;
 }
@@ -1406,17 +1414,17 @@
  *
  */
-static int ext4fs_truncate(service_id_t service_id, fs_index_t index,
+static int ext4_truncate(service_id_t service_id, fs_index_t index,
     aoff64_t new_size)
 {
 	fs_node_t *fn;
-	int rc = ext4fs_node_get(&fn, service_id, index);
-	if (rc != EOK)
-		return rc;
-	
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	int rc = ext4_node_get(&fn, service_id, index);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_node_t *enode = EXT4_NODE(fn);
 	ext4_inode_ref_t *inode_ref = enode->inode_ref;
 	
 	rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
-	int const rc2 = ext4fs_node_put(fn);
+	int const rc2 = ext4_node_put(fn);
 	
 	return rc == EOK ? rc2 : rc;
@@ -1431,5 +1439,5 @@
  *
  */
-static int ext4fs_close(service_id_t service_id, fs_index_t index)
+static int ext4_close(service_id_t service_id, fs_index_t index)
 {
 	return EOK;
@@ -1444,13 +1452,13 @@
  *
  */
-static int ext4fs_destroy(service_id_t service_id, fs_index_t index)
+static int ext4_destroy(service_id_t service_id, fs_index_t index)
 {
 	fs_node_t *fn;
-	int rc = ext4fs_node_get(&fn, service_id, index);
+	int rc = ext4_node_get(&fn, service_id, index);
 	if (rc != EOK)
 		return rc;
 	
 	/* Destroy the inode */
-	return ext4fs_destroy_node(fn);
+	return ext4_destroy_node(fn);
 }
 
@@ -1461,15 +1469,15 @@
  *
  */
-static int ext4fs_sync(service_id_t service_id, fs_index_t index)
+static int ext4_sync(service_id_t service_id, fs_index_t index)
 {
 	fs_node_t *fn;
-	int rc = ext4fs_node_get(&fn, service_id, index);
-	if (rc != EOK)
-		return rc;
-	
-	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	int rc = ext4_node_get(&fn, service_id, index);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_node_t *enode = EXT4_NODE(fn);
 	enode->inode_ref->dirty = true;
 	
-	return ext4fs_node_put(fn);
+	return ext4_node_put(fn);
 }
 
@@ -1477,14 +1485,14 @@
  *
  */
-vfs_out_ops_t ext4fs_ops = {
-	.fsprobe = ext4fs_fsprobe,
-	.mounted = ext4fs_mounted,
-	.unmounted = ext4fs_unmounted,
-	.read = ext4fs_read,
-	.write = ext4fs_write,
-	.truncate = ext4fs_truncate,
-	.close = ext4fs_close,
-	.destroy = ext4fs_destroy,
-	.sync = ext4fs_sync
+vfs_out_ops_t ext4_ops = {
+	.fsprobe = ext4_fsprobe,
+	.mounted = ext4_mounted,
+	.unmounted = ext4_unmounted,
+	.read = ext4_read,
+	.write = ext4_write,
+	.truncate = ext4_truncate,
+	.close = ext4_close,
+	.destroy = ext4_destroy,
+	.sync = ext4_sync
 };
 
