Index: HelenOS.config
===================================================================
--- HelenOS.config	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ HelenOS.config	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -89,5 +89,5 @@
 @ "tmpfs" TMPFS image
 @ "fat" FAT16 image
-@ "ext2fs" EXT2 image
+@ "ext4fs" ext4 image
 ! RDFMT (choice)
 
Index: abi/include/syscall.h
===================================================================
--- abi/include/syscall.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ abi/include/syscall.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -63,6 +63,4 @@
 	SYS_PAGE_FIND_MAPPING,
 	
-	SYS_IPC_CALL_SYNC_FAST,
-	SYS_IPC_CALL_SYNC_SLOW,
 	SYS_IPC_CALL_ASYNC_FAST,
 	SYS_IPC_CALL_ASYNC_SLOW,
Index: boot/Makefile
===================================================================
--- boot/Makefile	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ boot/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -47,6 +47,6 @@
 	$(MKFAT) 1048576 $(DIST_PATH) $@
 endif
-ifeq ($(RDFMT),ext2fs)
-	$(MKEXT2) 1048576 $(DIST_PATH) $@
+ifeq ($(RDFMT),ext4fs)
+	$(MKEXT4) 1048576 $(DIST_PATH) $@
 endif
 
Index: boot/Makefile.common
===================================================================
--- boot/Makefile.common	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ boot/Makefile.common	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -55,5 +55,5 @@
 MKTMPFS = $(TOOLS_PATH)/mktmpfs.py
 MKFAT = $(TOOLS_PATH)/mkfat.py
-MKEXT2 = $(TOOLS_PATH)/mkext2.py
+MKEXT4 = $(TOOLS_PATH)/mkext4.py
 MKUIMAGE = $(TOOLS_PATH)/mkuimage.py
 
@@ -84,6 +84,6 @@
 endif
 
-ifeq ($(RDFMT),ext2fs)
-	INIT_TASKS += $(USPACE_PATH)/srv/fs/ext2fs/ext2fs
+ifeq ($(RDFMT),ext4fs)
+	INIT_TASKS += $(USPACE_PATH)/srv/fs/ext4fs/ext4fs
 endif
 
@@ -106,4 +106,5 @@
 	$(USPACE_PATH)/srv/fs/exfat/exfat \
 	$(USPACE_PATH)/srv/fs/ext2fs/ext2fs \
+	$(USPACE_PATH)/srv/fs/ext4fs/ext4fs \
 	$(USPACE_PATH)/srv/hid/remcons/remcons \
 	$(USPACE_PATH)/srv/hid/isdv4_tablet/isdv4_tablet \
@@ -174,4 +175,5 @@
 	$(USPACE_PATH)/app/tester/tester \
 	$(USPACE_PATH)/app/testread/testread \
+	$(USPACE_PATH)/app/testwrit/testwrit \
 	$(USPACE_PATH)/app/tetris/tetris \
 	$(USPACE_PATH)/app/trace/trace \
Index: kernel/generic/include/ipc/ipc.h
===================================================================
--- kernel/generic/include/ipc/ipc.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/include/ipc/ipc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -77,7 +77,4 @@
 	waitq_t wq;
 	
-	/** Linkage for the list of task's synchronous answerboxes. */
-	link_t sync_box_link;
-	
 	/** Phones connected to this answerbox. */
 	list_t connected_phones;
@@ -116,10 +113,4 @@
 	struct task *sender;
 	
-	/*
-	 * The caller box is different from sender->answerbox
-	 * for synchronous calls.
-	 */
-	answerbox_t *callerbox;
-	
 	/** Private data to internal IPC. */
 	sysarg_t priv;
@@ -147,5 +138,4 @@
 
 extern int ipc_call(phone_t *, call_t *);
-extern int ipc_call_sync(phone_t *, call_t *);
 extern call_t *ipc_wait_for_call(answerbox_t *, uint32_t, unsigned int);
 extern int ipc_forward(call_t *, phone_t *, answerbox_t *, unsigned int);
Index: kernel/generic/include/ipc/sysipc.h
===================================================================
--- kernel/generic/include/ipc/sysipc.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/include/ipc/sysipc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -40,7 +40,4 @@
 #include <typedefs.h>
 
-extern sysarg_t sys_ipc_call_sync_fast(sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t, ipc_data_t *);
-extern sysarg_t sys_ipc_call_sync_slow(sysarg_t, ipc_data_t *, ipc_data_t *);
 extern sysarg_t sys_ipc_call_async_fast(sysarg_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t, sysarg_t);
Index: kernel/generic/include/proc/task.h
===================================================================
--- kernel/generic/include/proc/task.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/include/proc/task.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -94,5 +94,4 @@
 	phone_t phones[IPC_MAX_PHONES];
 	stats_ipc_t ipc_info;   /**< IPC statistics */
-	list_t sync_boxes;      /**< List of synchronous answerboxes. */
 	event_t events[EVENT_TASK_END - EVENT_END];
 	
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/src/ipc/ipc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -71,5 +71,4 @@
 {
 	memsetb(call, sizeof(*call), 0);
-	call->callerbox = &TASK->answerbox;
 	call->sender = TASK;
 	call->buffer = NULL;
@@ -120,5 +119,4 @@
 	irq_spinlock_initialize(&box->irq_lock, "ipc.box.irqlock");
 	waitq_initialize(&box->wq);
-	link_initialize(&box->sync_box_link);
 	list_initialize(&box->connected_phones);
 	list_initialize(&box->calls);
@@ -163,47 +161,4 @@
 }
 
-/** Helper function to facilitate synchronous calls.
- *
- * @param phone   Destination kernel phone structure.
- * @param request Call structure with request.
- *
- * @return EOK on success or EINTR if the sleep was interrupted.
- *
- */
-int ipc_call_sync(phone_t *phone, call_t *request)
-{
-	answerbox_t *sync_box = slab_alloc(ipc_answerbox_slab, 0);
-	ipc_answerbox_init(sync_box, TASK);
-	
-	/*
-	 * Put the answerbox on the TASK's list of synchronous answerboxes so
-	 * that it can be cleaned up if the call is interrupted.
-	 */
-	irq_spinlock_lock(&TASK->lock, true);
-	list_append(&sync_box->sync_box_link, &TASK->sync_boxes);
-	irq_spinlock_unlock(&TASK->lock, true);
-	
-	/* We will receive data in a special box. */
-	request->callerbox = sync_box;
-	
-	ipc_call(phone, request);
-	if (!ipc_wait_for_call(sync_box, SYNCH_NO_TIMEOUT,
-	    SYNCH_FLAGS_INTERRUPTIBLE)) {
-		/* The answerbox and the call will be freed by ipc_cleanup(). */
-		return EINTR;
-	}
-	
-	/*
-	 * The answer arrived without interruption so we can remove the
-	 * answerbox from the TASK's list of synchronous answerboxes.
-	 */
-	irq_spinlock_lock(&TASK->lock, true);
-	list_remove(&sync_box->sync_box_link);
-	irq_spinlock_unlock(&TASK->lock, true);
-	
-	slab_free(ipc_answerbox_slab, sync_box);
-	return EOK;
-}
-
 /** Answer a message which was not dispatched and is not listed in any queue.
  *
@@ -214,5 +169,5 @@
 static void _ipc_answer_free_call(call_t *call, bool selflocked)
 {
-	answerbox_t *callerbox = call->callerbox;
+	answerbox_t *callerbox = &call->sender->answerbox;
 	bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
 	
@@ -606,18 +561,4 @@
 	ipc_cleanup_call_list(&TASK->answerbox.calls);
 	irq_spinlock_unlock(&TASK->answerbox.lock, true);
-	
-	/* Wait for all answers to interrupted synchronous calls to arrive */
-	ipl_t ipl = interrupts_disable();
-	while (!list_empty(&TASK->sync_boxes)) {
-		answerbox_t *box = list_get_instance(
-		    list_first(&TASK->sync_boxes), answerbox_t, sync_box_link);
-		
-		list_remove(&box->sync_box_link);
-		call_t *call = ipc_wait_for_call(box, SYNCH_NO_TIMEOUT,
-		    SYNCH_FLAGS_NONE);
-		ipc_call_free(call);
-		slab_free(ipc_answerbox_slab, box);
-	}
-	interrupts_restore(ipl);
 	
 	/* Wait for all answers to asynchronous calls to arrive */
Index: kernel/generic/src/ipc/sysipc.c
===================================================================
--- kernel/generic/src/ipc/sysipc.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/src/ipc/sysipc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -612,123 +612,4 @@
 		break;
 	}
-	
-	return 0;
-}
-
-/** Make a fast call over IPC, wait for reply and return to user.
- *
- * This function can handle only three arguments of payload, but is faster than
- * the generic function (i.e. sys_ipc_call_sync_slow()).
- *
- * @param phoneid Phone handle for the call.
- * @param imethod Interface and method of the call.
- * @param arg1    Service-defined payload argument.
- * @param arg2    Service-defined payload argument.
- * @param arg3    Service-defined payload argument.
- * @param data    Address of user-space structure where the reply call will
- *                be stored.
- *
- * @return 0 on success.
- * @return ENOENT if there is no such phone handle.
- *
- */
-sysarg_t sys_ipc_call_sync_fast(sysarg_t phoneid, sysarg_t imethod,
-    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, ipc_data_t *data)
-{
-	phone_t *phone;
-	if (phone_get(phoneid, &phone) != EOK)
-		return ENOENT;
-	
-	call_t *call = ipc_call_alloc(0);
-	IPC_SET_IMETHOD(call->data, imethod);
-	IPC_SET_ARG1(call->data, arg1);
-	IPC_SET_ARG2(call->data, arg2);
-	IPC_SET_ARG3(call->data, arg3);
-	
-	/*
-	 * To achieve deterministic behavior, zero out arguments that are beyond
-	 * the limits of the fast version.
-	 */
-	IPC_SET_ARG4(call->data, 0);
-	IPC_SET_ARG5(call->data, 0);
-	
-	int res = request_preprocess(call, phone);
-	int rc;
-	
-	if (!res) {
-#ifdef CONFIG_UDEBUG
-		udebug_stoppable_begin();
-#endif
-		rc = ipc_call_sync(phone, call);
-#ifdef CONFIG_UDEBUG
-		udebug_stoppable_end();
-#endif
-		
-		if (rc != EOK) {
-			/* The call will be freed by ipc_cleanup(). */
-			return rc;
-		}
-		
-		process_answer(call);
-	} else
-		IPC_SET_RETVAL(call->data, res);
-	
-	rc = STRUCT_TO_USPACE(&data->args, &call->data.args);
-	ipc_call_free(call);
-	if (rc != 0)
-		return rc;
-	
-	return 0;
-}
-
-/** Make a synchronous IPC call allowing to transmit the entire payload.
- *
- * @param phoneid Phone handle for the call.
- * @param request User-space address of call data with the request.
- * @param reply   User-space address of call data where to store the
- *                answer.
- *
- * @return Zero on success or an error code.
- *
- */
-sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *request,
-    ipc_data_t *reply)
-{
-	phone_t *phone;
-	if (phone_get(phoneid, &phone) != EOK)
-		return ENOENT;
-	
-	call_t *call = ipc_call_alloc(0);
-	int rc = copy_from_uspace(&call->data.args, &request->args,
-	    sizeof(call->data.args));
-	if (rc != 0) {
-		ipc_call_free(call);
-		return (sysarg_t) rc;
-	}
-	
-	int res = request_preprocess(call, phone);
-	
-	if (!res) {
-#ifdef CONFIG_UDEBUG
-		udebug_stoppable_begin();
-#endif
-		rc = ipc_call_sync(phone, call);
-#ifdef CONFIG_UDEBUG
-		udebug_stoppable_end();
-#endif
-		
-		if (rc != EOK) {
-			/* The call will be freed by ipc_cleanup(). */
-			return rc;
-		}
-		
-		process_answer(call);
-	} else
-		IPC_SET_RETVAL(call->data, res);
-	
-	rc = STRUCT_TO_USPACE(&reply->args, &call->data.args);
-	ipc_call_free(call);
-	if (rc != 0)
-		return rc;
 	
 	return 0;
Index: kernel/generic/src/proc/task.c
===================================================================
--- kernel/generic/src/proc/task.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/src/proc/task.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -156,5 +156,4 @@
 	
 	list_initialize(&task->threads);
-	list_initialize(&task->sync_boxes);
 	
 	ipc_answerbox_init(&task->answerbox, task);
Index: kernel/generic/src/syscall/syscall.c
===================================================================
--- kernel/generic/src/syscall/syscall.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ kernel/generic/src/syscall/syscall.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -151,6 +151,4 @@
 	
 	/* IPC related syscalls. */
-	(syshandler_t) sys_ipc_call_sync_fast,
-	(syshandler_t) sys_ipc_call_sync_slow,
 	(syshandler_t) sys_ipc_call_async_fast,
 	(syshandler_t) sys_ipc_call_async_slow,
Index: tools/mkext4.py
===================================================================
--- tools/mkext4.py	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ tools/mkext4.py	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1 @@
+mkext2.py
Index: uspace/Makefile
===================================================================
--- uspace/Makefile	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -58,4 +58,5 @@
 	app/tester \
 	app/testread \
+	app/testwrit \
 	app/tetris \
 	app/trace \
@@ -97,4 +98,5 @@
 	srv/fs/locfs \
 	srv/fs/ext2fs \
+	srv/fs/ext4fs \
 	srv/hid/console \
 	srv/hid/s3c24xx_ts \
@@ -197,4 +199,5 @@
 	lib/nic \
 	lib/ext2 \
+	lib/ext4 \
 	lib/usb \
 	lib/usbhost \
Index: uspace/Makefile.common
===================================================================
--- uspace/Makefile.common	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/Makefile.common	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -115,4 +115,5 @@
 
 LIBEXT2_PREFIX = $(LIB_PREFIX)/ext2
+LIBEXT4_PREFIX = $(LIB_PREFIX)/ext4
 
 LIBUSB_PREFIX = $(LIB_PREFIX)/usb
Index: uspace/app/testwrit/Makefile
===================================================================
--- uspace/app/testwrit/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/app/testwrit/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2011 Frantisek Princ
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+USPACE_PREFIX = ../..
+BINARY = testwrit
+
+SOURCES = \
+	testwrit.c
+
+include $(USPACE_PREFIX)/Makefile.common
Index: uspace/app/testwrit/testwrit.c
===================================================================
--- uspace/app/testwrit/testwrit.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/app/testwrit/testwrit.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2011 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup test
+ * @{
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+
+#define BUF_SIZE  1024
+
+int main(int argc, char *argv[])
+{
+	char buffer[BUF_SIZE];
+	uint64_t iterations, i;
+	FILE *file;
+	char *file_name;
+	
+	/* Prepare some example data */
+	memset(buffer, 0xcafebabe, BUF_SIZE);
+	
+	if (argc != 3) {
+		printf("syntax: testwrit <iterations> <target file>\n");
+		return 1;
+	}
+	
+	char *end;
+	iterations = strtoul(argv[1], &end, 10);
+	file_name = argv[2];
+	
+	/* Open target file */
+	file = fopen(file_name, "a");
+	if (file == NULL) {
+		printf("Failed opening file\n");
+		return 1;
+	}
+	
+	/* Writing loop */
+	for (i = 0; i < iterations; ++i) {
+		fwrite(buffer, 1, BUF_SIZE, file);
+	}
+	
+	fclose(file);
+	
+	return 0;
+}
+
+/**
+ * @}
+ */
Index: uspace/app/trace/syscalls.c
===================================================================
--- uspace/app/trace/syscalls.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/app/trace/syscalls.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -53,6 +53,4 @@
     [SYS_AS_AREA_DESTROY] = { "as_area_destroy",	1,	V_ERRNO },
 
-    [SYS_IPC_CALL_SYNC_FAST] = { "ipc_call_sync_fast",	6,	V_ERRNO },
-    [SYS_IPC_CALL_SYNC_SLOW] = { "ipc_call_sync_slow",	3,	V_ERRNO },
     [SYS_IPC_CALL_ASYNC_FAST] = { "ipc_call_async_fast", 6,	V_HASH },
     [SYS_IPC_CALL_ASYNC_SLOW] = { "ipc_call_async_slow", 2,	V_HASH },
Index: uspace/app/trace/trace.c
===================================================================
--- uspace/app/trace/trace.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/app/trace/trace.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -318,61 +318,4 @@
 }
 
-static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
-{
-	ipc_call_t question, reply;
-	int rc;
-	int phoneid;
-
-	phoneid = sc_args[0];
-
-	IPC_SET_IMETHOD(question, sc_args[1]);
-	IPC_SET_ARG1(question, sc_args[2]);
-	IPC_SET_ARG2(question, sc_args[3]);
-	IPC_SET_ARG3(question, sc_args[4]);
-	IPC_SET_ARG4(question, 0);
-	IPC_SET_ARG5(question, 0);
-
-	memset(&reply, 0, sizeof(reply));
-	rc = udebug_mem_read(sess, &reply.args, sc_args[5], sizeof(reply.args));
-	if (rc < 0)
-		return;
-	
-	ipcp_call_sync(phoneid, &question, &reply);
-}
-
-static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)
-{
-	ipc_call_t question;
-	int rc;
-
-	memset(&question, 0, sizeof(question));
-	rc = udebug_mem_read(sess, &question.args, sc_args[1],
-	    sizeof(question.args));
-
-	if (rc < 0) {
-		printf("Error: mem_read->%d\n", rc);
-		return;
-	}
-
-	thread_ipc_req[thread_id] = question;
-}
-
-static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)
-{
-	ipc_call_t reply;
-	int rc;
-
-	memset(&reply, 0, sizeof(reply));
-	rc = udebug_mem_read(sess, &reply.args, sc_args[2],
-	    sizeof(reply.args));
-
-	if (rc < 0) {
-		printf("Error: mem_read->%d\n", rc);
-		return;
-	}
-
-	ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);
-}
-
 static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
 {
@@ -408,12 +351,4 @@
 		print_sc_args(sc_args, syscall_desc[sc_id].n_args);
 	}
-
-	switch (sc_id) {
-	case SYS_IPC_CALL_SYNC_SLOW:
-		sc_ipc_call_sync_slow_b(thread_id, sc_args);
-		break;
-	default:
-		break;
-	}
 }
 
@@ -447,10 +382,4 @@
 	case SYS_IPC_CALL_ASYNC_SLOW:
 		sc_ipc_call_async_slow(sc_args, sc_rc);
-		break;
-	case SYS_IPC_CALL_SYNC_FAST:
-		sc_ipc_call_sync_fast(sc_args);
-		break;
-	case SYS_IPC_CALL_SYNC_SLOW:
-		sc_ipc_call_sync_slow_e(thread_id, sc_args);
 		break;
 	case SYS_IPC_WAIT:
Index: uspace/drv/bus/usb/usbmast/main.c
===================================================================
--- uspace/drv/bus/usb/usbmast/main.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/drv/bus/usb/usbmast/main.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -37,5 +37,5 @@
 #include <as.h>
 #include <async.h>
-#include <ipc/bd.h>
+#include <bd_srv.h>
 #include <macros.h>
 #include <usb/dev/driver.h>
@@ -82,4 +82,25 @@
     void *arg);
 
+static int usbmast_bd_open(bd_srvs_t *, bd_srv_t *);
+static int usbmast_bd_close(bd_srv_t *);
+static int usbmast_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int usbmast_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int usbmast_bd_get_block_size(bd_srv_t *, size_t *);
+static int usbmast_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t usbmast_bd_ops = {
+	.open = usbmast_bd_open,
+	.close = usbmast_bd_close,
+	.read_blocks = usbmast_bd_read_blocks,
+	.write_blocks = usbmast_bd_write_blocks,
+	.get_block_size = usbmast_bd_get_block_size,
+	.get_num_blocks = usbmast_bd_get_num_blocks
+};
+
+static usbmast_fun_t *bd_srv_usbmast(bd_srv_t *bd)
+{
+	return (usbmast_fun_t *)bd->srvs->sarg;
+}
+
 /** Callback when a device is removed from the system.
  *
@@ -219,4 +240,8 @@
 	mfun->lun = lun;
 
+	bd_srvs_init(&mfun->bds);
+	mfun->bds.ops = &usbmast_bd_ops;
+	mfun->bds.sarg = mfun;
+
 	/* Set up a connection handler. */
 	fun->conn_handler = usbmast_bd_connection;
@@ -284,64 +309,61 @@
 {
 	usbmast_fun_t *mfun;
-	void *comm_buf = NULL;
-	size_t comm_size;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	unsigned int flags;
-	sysarg_t method;
-	uint64_t ba;
-	size_t cnt;
-	int retval;
-
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-	
-	(void) async_share_out_finalize(callid, &comm_buf);
-	if (comm_buf == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-	
+
 	mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-
-		if (!method) {
-			/* The other side hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-
-		switch (method) {
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, mfun->block_size);
-			break;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(mfun->nblocks),
-			    UPPER32(mfun->nblocks));
-			break;
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			retval = usbmast_read(mfun, ba, cnt, comm_buf);
-			async_answer_0(callid, retval);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			retval = usbmast_write(mfun, ba, cnt, comm_buf);
-			async_answer_0(callid, retval);
-			break;
-		default:
-			async_answer_0(callid, EINVAL);
-		}
-	}
-}
+	bd_conn(iid, icall, &mfun->bds);
+}
+
+/** Open device. */
+static int usbmast_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int usbmast_bd_close(bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Read blocks from the device. */
+static int usbmast_bd_read_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt, void *buf,
+    size_t size)
+{
+	usbmast_fun_t *mfun = bd_srv_usbmast(bd);
+
+	if (size < cnt * mfun->block_size)
+		return EINVAL;
+
+	return usbmast_read(mfun, ba, cnt, buf);
+}
+
+/** Write blocks to the device. */
+static int usbmast_bd_write_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	usbmast_fun_t *mfun = bd_srv_usbmast(bd);
+
+	if (size < cnt * mfun->block_size)
+		return EINVAL;
+
+	return usbmast_write(mfun, ba, cnt, buf);
+}
+
+/** Get device block size. */
+static int usbmast_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	usbmast_fun_t *mfun = bd_srv_usbmast(bd);
+	*rsize = mfun->block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int usbmast_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	usbmast_fun_t *mfun = bd_srv_usbmast(bd);
+	*rnb = mfun->nblocks;
+	return EOK;
+}
+
 
 /** USB mass storage driver ops. */
Index: uspace/drv/bus/usb/usbmast/usbmast.h
===================================================================
--- uspace/drv/bus/usb/usbmast/usbmast.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/drv/bus/usb/usbmast/usbmast.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -37,4 +37,5 @@
 #define USBMAST_H_
 
+#include <bd_srv.h>
 #include <sys/types.h>
 #include <usb/usb.h>
@@ -68,4 +69,6 @@
 	/** Block size in bytes */
 	size_t block_size;
+	/** Block device service structure */
+	bd_srvs_t bds;
 } usbmast_fun_t;
 
Index: uspace/lib/block/libblock.c
===================================================================
--- uspace/lib/block/libblock.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/block/libblock.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -40,5 +40,4 @@
 #include "../../srv/vfs/vfs.h"
 #include <ipc/loc.h>
-#include <ipc/bd.h>
 #include <ipc/services.h>
 #include <errno.h>
@@ -47,4 +46,5 @@
 #include <as.h>
 #include <assert.h>
+#include <bd.h>
 #include <fibril_synch.h>
 #include <adt/list.h>
@@ -80,7 +80,5 @@
 	service_id_t service_id;
 	async_sess_t *sess;
-	fibril_mutex_t comm_area_lock;
-	void *comm_area;
-	size_t comm_size;
+	bd_t *bd;
 	void *bb_buf;
 	aoff64_t bb_addr;
@@ -89,8 +87,6 @@
 } devcon_t;
 
-static int read_blocks(devcon_t *, aoff64_t, size_t);
-static int write_blocks(devcon_t *, aoff64_t, size_t);
-static int get_block_size(async_sess_t *, size_t *);
-static int get_num_blocks(async_sess_t *, aoff64_t *);
+static int read_blocks(devcon_t *, aoff64_t, size_t, void *, size_t);
+static int write_blocks(devcon_t *, aoff64_t, size_t, void *, size_t);
 static aoff64_t ba_ltop(devcon_t *, aoff64_t);
 
@@ -112,10 +108,7 @@
 
 static int devcon_add(service_id_t service_id, async_sess_t *sess,
-    size_t bsize, void *comm_area, size_t comm_size)
+    size_t bsize, bd_t *bd)
 {
 	devcon_t *devcon;
-	
-	if (comm_size < bsize)
-		return EINVAL;
 	
 	devcon = malloc(sizeof(devcon_t));
@@ -126,7 +119,5 @@
 	devcon->service_id = service_id;
 	devcon->sess = sess;
-	fibril_mutex_initialize(&devcon->comm_area_lock);
-	devcon->comm_area = comm_area;
-	devcon->comm_size = comm_size;
+	devcon->bd = bd;
 	devcon->bb_buf = NULL;
 	devcon->bb_addr = 0;
@@ -158,23 +149,14 @@
     size_t comm_size)
 {
-	void *comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
-	    MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-	if (!comm_area)
-		return ENOMEM;
-	
+	bd_t *bd;
+
 	async_sess_t *sess = loc_service_connect(mgmt, service_id,
 	    IPC_FLAG_BLOCKING);
 	if (!sess) {
-		munmap(comm_area, comm_size);
 		return ENOENT;
 	}
 	
-	async_exch_t *exch = async_exchange_begin(sess);
-	int rc = async_share_out_start(exch, comm_area,
-	    AS_AREA_READ | AS_AREA_WRITE);
-	async_exchange_end(exch);
-	
+	int rc = bd_open(sess, &bd);
 	if (rc != EOK) {
-		munmap(comm_area, comm_size);
 		async_hangup(sess);
 		return rc;
@@ -182,15 +164,14 @@
 	
 	size_t bsize;
-	rc = get_block_size(sess, &bsize);
-	
+	rc = bd_get_block_size(bd, &bsize);
 	if (rc != EOK) {
-		munmap(comm_area, comm_size);
+		bd_close(bd);
 		async_hangup(sess);
 		return rc;
 	}
 	
-	rc = devcon_add(service_id, sess, bsize, comm_area, comm_size);
+	rc = devcon_add(service_id, sess, bsize, bd);
 	if (rc != EOK) {
-		munmap(comm_area, comm_size);
+		bd_close(bd);
 		async_hangup(sess);
 		return rc;
@@ -213,5 +194,5 @@
 		free(devcon->bb_buf);
 	
-	munmap(devcon->comm_area, devcon->comm_size);
+	bd_close(devcon->bd);
 	async_hangup(devcon->sess);
 	
@@ -233,13 +214,9 @@
 		return ENOMEM;
 
-	fibril_mutex_lock(&devcon->comm_area_lock);
-	rc = read_blocks(devcon, 0, 1);
+	rc = read_blocks(devcon, 0, 1, bb_buf, devcon->pblock_size);
 	if (rc != EOK) {
-		fibril_mutex_unlock(&devcon->comm_area_lock);
 	    	free(bb_buf);
 		return rc;
 	}
-	memcpy(bb_buf, devcon->comm_area, devcon->pblock_size);
-	fibril_mutex_unlock(&devcon->comm_area_lock);
 
 	devcon->bb_buf = bb_buf;
@@ -338,6 +315,6 @@
 		list_remove(&b->free_link);
 		if (b->dirty) {
-			memcpy(devcon->comm_area, b->data, b->size);
-			rc = write_blocks(devcon, b->pba, cache->blocks_cluster);
+			rc = write_blocks(devcon, b->pba, cache->blocks_cluster,
+			    b->data, b->size);
 			if (rc != EOK)
 				return rc;
@@ -481,9 +458,6 @@
 				list_append(&b->free_link, &cache->free_list);
 				fibril_mutex_unlock(&cache->lock);
-				fibril_mutex_lock(&devcon->comm_area_lock);
-				memcpy(devcon->comm_area, b->data, b->size);
 				rc = write_blocks(devcon, b->pba,
-				    cache->blocks_cluster);
-				fibril_mutex_unlock(&devcon->comm_area_lock);
+				    cache->blocks_cluster, b->data, b->size);
 				if (rc != EOK) {
 					/*
@@ -555,8 +529,6 @@
 			 * the new contents from the device.
 			 */
-			fibril_mutex_lock(&devcon->comm_area_lock);
-			rc = read_blocks(devcon, b->pba, cache->blocks_cluster);
-			memcpy(b->data, devcon->comm_area, cache->lblock_size);
-			fibril_mutex_unlock(&devcon->comm_area_lock);
+			rc = read_blocks(devcon, b->pba, cache->blocks_cluster,
+			    b->data, cache->lblock_size);
 			if (rc != EOK) 
 				b->toxic = true;
@@ -616,8 +588,6 @@
 	if (block->dirty && (block->refcnt == 1) &&
 	    (blocks_cached > CACHE_HI_WATERMARK || mode != CACHE_MODE_WB)) {
-		fibril_mutex_lock(&devcon->comm_area_lock);
-		memcpy(devcon->comm_area, block->data, block->size);
-		rc = write_blocks(devcon, block->pba, cache->blocks_cluster);
-		fibril_mutex_unlock(&devcon->comm_area_lock);
+		rc = write_blocks(devcon, block->pba, cache->blocks_cluster,
+		    block->data, block->size);
 		block->dirty = false;
 	}
@@ -688,4 +658,5 @@
  *
  * @param service_id	Service ID of the block device.
+ * @param buf		Buffer for holding one block
  * @param bufpos	Pointer to the first unread valid offset within the
  * 			communication buffer.
@@ -699,6 +670,6 @@
  * @return		EOK on success or a negative return code on failure.
  */
-int block_seqread(service_id_t service_id, size_t *bufpos, size_t *buflen,
-    aoff64_t *pos, void *dst, size_t size)
+int block_seqread(service_id_t service_id, void *buf, size_t *bufpos,
+    size_t *buflen, aoff64_t *pos, void *dst, size_t size)
 {
 	size_t offset = 0;
@@ -711,5 +682,4 @@
 	block_size = devcon->pblock_size;
 	
-	fibril_mutex_lock(&devcon->comm_area_lock);
 	while (left > 0) {
 		size_t rd;
@@ -725,5 +695,5 @@
 			 * destination buffer.
 			 */
-			memcpy(dst + offset, devcon->comm_area + *bufpos, rd);
+			memcpy(dst + offset, buf + *bufpos, rd);
 			offset += rd;
 			*bufpos += rd;
@@ -736,7 +706,7 @@
 			int rc;
 
-			rc = read_blocks(devcon, *pos / block_size, 1);
+			rc = read_blocks(devcon, *pos / block_size, 1, buf,
+			    devcon->pblock_size);
 			if (rc != EOK) {
-				fibril_mutex_unlock(&devcon->comm_area_lock);
 				return rc;
 			}
@@ -746,5 +716,4 @@
 		}
 	}
-	fibril_mutex_unlock(&devcon->comm_area_lock);
 	
 	return EOK;
@@ -763,18 +732,9 @@
 {
 	devcon_t *devcon;
-	int rc;
 
 	devcon = devcon_search(service_id);
 	assert(devcon);
-	
-	fibril_mutex_lock(&devcon->comm_area_lock);
-
-	rc = read_blocks(devcon, ba, cnt);
-	if (rc == EOK)
-		memcpy(buf, devcon->comm_area, devcon->pblock_size * cnt);
-
-	fibril_mutex_unlock(&devcon->comm_area_lock);
-
-	return rc;
+
+	return read_blocks(devcon, ba, cnt, buf, devcon->pblock_size * cnt);
 }
 
@@ -792,17 +752,9 @@
 {
 	devcon_t *devcon;
-	int rc;
 
 	devcon = devcon_search(service_id);
 	assert(devcon);
-	
-	fibril_mutex_lock(&devcon->comm_area_lock);
-
-	memcpy(devcon->comm_area, data, devcon->pblock_size * cnt);
-	rc = write_blocks(devcon, ba, cnt);
-
-	fibril_mutex_unlock(&devcon->comm_area_lock);
-
-	return rc;
+
+	return write_blocks(devcon, ba, cnt, (void *)data, devcon->pblock_size * cnt);
 }
 
@@ -820,6 +772,6 @@
 	devcon = devcon_search(service_id);
 	assert(devcon);
-	
-	return get_block_size(devcon->sess, bsize);
+
+	return bd_get_block_size(devcon->bd, bsize);
 }
 
@@ -836,5 +788,5 @@
 	assert(devcon);
 	
-	return get_num_blocks(devcon->sess, nblocks);
+	return bd_get_num_blocks(devcon->bd, nblocks);
 }
 
@@ -887,5 +839,5 @@
 	memcpy(data, buffer + offset, bytes);
 	free(buffer);
-	
+
 	return EOK;
 }
@@ -903,25 +855,18 @@
 {
 	devcon_t *devcon = devcon_search(service_id);
-	assert(devcon);
-	
 	toc_block_t *toc = NULL;
-	
-	fibril_mutex_lock(&devcon->comm_area_lock);
-	
-	async_exch_t *exch = async_exchange_begin(devcon->sess);
-	int rc = async_req_1_0(exch, BD_READ_TOC, session);
-	async_exchange_end(exch);
-	
-	if (rc == EOK) {
-		toc = (toc_block_t *) malloc(sizeof(toc_block_t));
-		if (toc != NULL) {
-			memset(toc, 0, sizeof(toc_block_t));
-			memcpy(toc, devcon->comm_area,
-			    min(devcon->pblock_size, sizeof(toc_block_t)));
-		}
-	}
-	
-	
-	fibril_mutex_unlock(&devcon->comm_area_lock);
+	int rc;
+	
+	assert(devcon);
+	
+	toc = (toc_block_t *) malloc(sizeof(toc_block_t));
+	if (toc == NULL)
+		return NULL;
+	
+	rc = bd_read_toc(devcon->bd, session, toc, sizeof(toc_block_t));
+	if (rc != EOK) {
+		free(toc);
+		return NULL;
+	}
 	
 	return toc;
@@ -937,13 +882,10 @@
  * @return		EOK on success or negative error code on failure.
  */
-static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
-{
-	assert(devcon);
-	
-	async_exch_t *exch = async_exchange_begin(devcon->sess);
-	int rc = async_req_3_0(exch, BD_READ_BLOCKS, LOWER32(ba),
-	    UPPER32(ba), cnt);
-	async_exchange_end(exch);
-	
+static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt, void *buf,
+    size_t size)
+{
+	assert(devcon);
+	
+	int rc = bd_read_blocks(devcon->bd, ba, cnt, buf, size);
 	if (rc != EOK) {
 		printf("Error %d reading %zu blocks starting at block %" PRIuOFF64
@@ -967,13 +909,10 @@
  * @return		EOK on success or negative error code on failure.
  */
-static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
-{
-	assert(devcon);
-	
-	async_exch_t *exch = async_exchange_begin(devcon->sess);
-	int rc = async_req_3_0(exch, BD_WRITE_BLOCKS, LOWER32(ba),
-	    UPPER32(ba), cnt);
-	async_exchange_end(exch);
-	
+static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt, void *data,
+    size_t size)
+{
+	assert(devcon);
+	
+	int rc = bd_write_blocks(devcon->bd, ba, cnt, data, size);
 	if (rc != EOK) {
 		printf("Error %d writing %zu blocks starting at block %" PRIuOFF64
@@ -987,35 +926,4 @@
 }
 
-/** Get block size used by the device. */
-static int get_block_size(async_sess_t *sess, size_t *bsize)
-{
-	sysarg_t bs;
-	
-	async_exch_t *exch = async_exchange_begin(sess);
-	int rc = async_req_0_1(exch, BD_GET_BLOCK_SIZE, &bs);
-	async_exchange_end(exch);
-	
-	if (rc == EOK)
-		*bsize = (size_t) bs;
-	
-	return rc;
-}
-
-/** Get total number of blocks on block device. */
-static int get_num_blocks(async_sess_t *sess, aoff64_t *nblocks)
-{
-	sysarg_t nb_l;
-	sysarg_t nb_h;
-	
-	async_exch_t *exch = async_exchange_begin(sess);
-	int rc = async_req_0_2(exch, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
-	async_exchange_end(exch);
-	
-	if (rc == EOK)
-		*nblocks = (aoff64_t) MERGE_LOUP32(nb_l, nb_h);
-	
-	return rc;
-}
-
 /** Convert logical block address to physical block address. */
 static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba)
Index: uspace/lib/block/libblock.h
===================================================================
--- uspace/lib/block/libblock.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/block/libblock.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -122,6 +122,6 @@
 extern int block_put(block_t *);
 
-extern int block_seqread(service_id_t, size_t *, size_t *, aoff64_t *, void *,
-    size_t);
+extern int block_seqread(service_id_t, void *, size_t *, size_t *, aoff64_t *,
+    void *, size_t);
 
 extern int block_get_bsize(service_id_t, size_t *);
Index: uspace/lib/c/Makefile
===================================================================
--- uspace/lib/c/Makefile	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/c/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -62,4 +62,6 @@
 	generic/ddi.c \
 	generic/as.c \
+	generic/bd.c \
+	generic/bd_srv.c \
 	generic/cap.c \
 	generic/cfg.c \
Index: uspace/lib/c/generic/async.c
===================================================================
--- uspace/lib/c/generic/async.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/c/generic/async.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -114,4 +114,5 @@
 #include <stdlib.h>
 #include <macros.h>
+#include "private/libc.h"
 
 #define CLIENT_HASH_TABLE_BUCKETS  32
@@ -2166,5 +2167,6 @@
 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
 {
-	return ipc_share_in_finalize(callid, src, flags);
+	return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
+	    (sysarg_t) __entry);
 }
 
@@ -2233,5 +2235,5 @@
 int async_share_out_finalize(ipc_callid_t callid, void **dst)
 {
-	return ipc_share_out_finalize(callid, dst);
+	return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
 }
 
@@ -2317,5 +2319,5 @@
 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
-	return ipc_data_read_finalize(callid, src, size);
+	return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
 }
 
@@ -2420,5 +2422,5 @@
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
 {
-	return ipc_data_write_finalize(callid, dst, size);
+	return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
 }
 
Index: uspace/lib/c/generic/bd.c
===================================================================
--- uspace/lib/c/generic/bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/c/generic/bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2012 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/**
+ * @file
+ * @brief IP link client stub
+ */
+
+#include <async.h>
+#include <assert.h>
+#include <bd.h>
+#include <errno.h>
+#include <ipc/bd.h>
+#include <ipc/services.h>
+#include <loc.h>
+#include <macros.h>
+#include <stdlib.h>
+
+static void bd_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
+
+int bd_open(async_sess_t *sess, bd_t **rbd)
+{
+	bd_t *bd = calloc(1, sizeof(bd_t));
+	if (bd == NULL)
+		return ENOMEM;
+	
+	bd->sess = sess;
+	
+	async_exch_t *exch = async_exchange_begin(sess);
+	
+	int rc = async_connect_to_me(exch, 0, 0, 0, bd_cb_conn, bd);
+	async_exchange_end(exch);
+	
+	if (rc != EOK)
+		goto error;
+	
+	*rbd = bd;
+	return EOK;
+	
+error:
+	if (bd != NULL)
+		free(bd);
+	
+	return rc;
+}
+
+void bd_close(bd_t *bd)
+{
+	/* XXX Synchronize with bd_cb_conn */
+	free(bd);
+}
+
+int bd_read_blocks(bd_t *bd, aoff64_t ba, size_t cnt, void *data, size_t size)
+{
+	async_exch_t *exch = async_exchange_begin(bd->sess);
+
+	ipc_call_t answer;
+	aid_t req = async_send_3(exch, BD_READ_BLOCKS, LOWER32(ba),
+	    UPPER32(ba), cnt, &answer);
+	int rc = async_data_read_start(exch, data, size);
+	async_exchange_end(exch);
+
+	if (rc != EOK) {
+		async_forget(req);
+		return rc;
+	}
+
+	sysarg_t retval;
+	async_wait_for(req, &retval);
+
+	if (retval != EOK)
+		return retval;
+
+	return EOK;
+}
+
+int bd_read_toc(bd_t *bd, uint8_t session, void *buf, size_t size)
+{
+	async_exch_t *exch = async_exchange_begin(bd->sess);
+
+	ipc_call_t answer;
+	aid_t req = async_send_1(exch, BD_READ_TOC, session, &answer);
+	int rc = async_data_read_start(exch, buf, size);
+	async_exchange_end(exch);
+
+	if (rc != EOK) {
+		async_forget(req);
+		return rc;
+	}
+
+	sysarg_t retval;
+	async_wait_for(req, &retval);
+
+	if (retval != EOK)
+		return retval;
+
+	return EOK;
+}
+
+int bd_write_blocks(bd_t *bd, aoff64_t ba, size_t cnt, const void *data,
+    size_t size)
+{
+	async_exch_t *exch = async_exchange_begin(bd->sess);
+
+	ipc_call_t answer;
+	aid_t req = async_send_3(exch, BD_WRITE_BLOCKS, LOWER32(ba),
+	    UPPER32(ba), cnt, &answer);
+	int rc = async_data_write_start(exch, data, size);
+	async_exchange_end(exch);
+
+	if (rc != EOK) {
+		async_forget(req);
+		return rc;
+	}
+
+	sysarg_t retval;
+	async_wait_for(req, &retval);
+	if (retval != EOK)
+		return retval;
+
+	return EOK;
+}
+
+int bd_get_block_size(bd_t *bd, size_t *rbsize)
+{
+	sysarg_t bsize;
+	async_exch_t *exch = async_exchange_begin(bd->sess);
+
+	int rc = async_req_0_1(exch, BD_GET_BLOCK_SIZE, &bsize);
+	async_exchange_end(exch);
+
+	if (rc != EOK)
+		return rc;
+
+	*rbsize = bsize;
+	return EOK;
+}
+
+int bd_get_num_blocks(bd_t *bd, aoff64_t *rnb)
+{
+	sysarg_t nb_l;
+	sysarg_t nb_h;
+	async_exch_t *exch = async_exchange_begin(bd->sess);
+
+	int rc = async_req_0_2(exch, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
+	async_exchange_end(exch);
+
+	if (rc != EOK)
+		return rc;
+
+	*rnb = (aoff64_t) MERGE_LOUP32(nb_l, nb_h);
+	return EOK;
+}
+
+static void bd_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+	bd_t *bd = (bd_t *)arg;
+
+	(void)bd;
+
+	while (true) {
+		ipc_call_t call;
+		ipc_callid_t callid = async_get_call(&call);
+
+		if (!IPC_GET_IMETHOD(call)) {
+			/* TODO: Handle hangup */
+			return;
+		}
+
+		switch (IPC_GET_IMETHOD(call)) {
+		default:
+			async_answer_0(callid, ENOTSUP);
+		}
+	}
+}
+
+/** @}
+ */
Index: uspace/lib/c/generic/bd_srv.c
===================================================================
--- uspace/lib/c/generic/bd_srv.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/c/generic/bd_srv.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2012 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/**
+ * @file
+ * @brief Block device server stub
+ */
+#include <errno.h>
+#include <ipc/bd.h>
+#include <macros.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include <bd_srv.h>
+
+static void bd_read_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
+    ipc_call_t *call)
+{
+	aoff64_t ba;
+	size_t cnt;
+	void *buf;
+	size_t size;
+	int rc;
+	ipc_callid_t rcallid;
+
+	ba = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
+	cnt = IPC_GET_ARG3(*call);
+
+	if (!async_data_read_receive(&rcallid, &size)) {
+		async_answer_0(callid, EINVAL);
+		return;
+	}
+
+	buf = malloc(size);
+	if (buf == NULL) {
+		async_answer_0(rcallid, ENOMEM);
+		async_answer_0(callid, ENOMEM);
+		return;
+	}
+
+	if (srv->srvs->ops->read_blocks == NULL) {
+		async_answer_0(rcallid, ENOTSUP);
+		async_answer_0(callid, ENOTSUP);
+		return;
+	}
+
+	rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
+	if (rc != EOK) {
+		async_answer_0(rcallid, ENOMEM);
+		async_answer_0(callid, ENOMEM);
+		return;
+	}
+
+	async_data_read_finalize(rcallid, buf, size);
+
+	free(buf);
+	async_answer_0(callid, EOK);
+}
+
+static void bd_read_toc_srv(bd_srv_t *srv, ipc_callid_t callid,
+    ipc_call_t *call)
+{
+	uint8_t session;
+	void *buf;
+	size_t size;
+	int rc;
+	ipc_callid_t rcallid;
+
+	session = IPC_GET_ARG1(*call);
+
+	if (!async_data_read_receive(&rcallid, &size)) {
+		async_answer_0(callid, EINVAL);
+		return;
+	}
+
+	buf = malloc(size);
+	if (buf == NULL) {
+		async_answer_0(rcallid, ENOMEM);
+		async_answer_0(callid, ENOMEM);
+		return;
+	}
+
+	if (srv->srvs->ops->read_toc == NULL) {
+		async_answer_0(rcallid, ENOTSUP);
+		async_answer_0(callid, ENOTSUP);
+		return;
+	}
+
+	rc = srv->srvs->ops->read_toc(srv, session, buf, size);
+	if (rc != EOK) {
+		async_answer_0(rcallid, ENOMEM);
+		async_answer_0(callid, ENOMEM);
+		return;
+	}
+
+	async_data_read_finalize(rcallid, buf, size);
+
+	free(buf);
+	async_answer_0(callid, EOK);
+}
+
+static void bd_write_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
+    ipc_call_t *call)
+{
+	aoff64_t ba;
+	size_t cnt;
+	void *data;
+	size_t size;
+	int rc;
+
+	ba = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
+	cnt = IPC_GET_ARG3(*call);
+
+	rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return;
+	}
+
+	if (srv->srvs->ops->write_blocks == NULL) {
+		async_answer_0(callid, ENOTSUP);
+		return;
+	}
+
+	rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
+	free(data);
+	async_answer_0(callid, rc);
+}
+
+static void bd_get_block_size_srv(bd_srv_t *srv, ipc_callid_t callid,
+    ipc_call_t *call)
+{
+	int rc;
+	size_t block_size;
+
+	if (srv->srvs->ops->get_block_size == NULL) {
+		async_answer_0(callid, ENOTSUP);
+		return;
+	}
+
+	rc = srv->srvs->ops->get_block_size(srv, &block_size);
+	async_answer_1(callid, rc, block_size);
+}
+
+static void bd_get_num_blocks_srv(bd_srv_t *srv, ipc_callid_t callid,
+    ipc_call_t *call)
+{
+	int rc;
+	aoff64_t num_blocks;
+
+	if (srv->srvs->ops->get_num_blocks == NULL) {
+		async_answer_0(callid, ENOTSUP);
+		return;
+	}
+
+	rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
+	async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
+}
+
+static bd_srv_t *bd_srv_create(bd_srvs_t *srvs)
+{
+	bd_srv_t *srv;
+
+	srv = calloc(1, sizeof(srv));
+	if (srv == NULL)
+		return NULL;
+
+	srv->srvs = srvs;
+	return srv;
+}
+
+void bd_srvs_init(bd_srvs_t *srvs)
+{
+	srvs->ops = NULL;
+	srvs->sarg = NULL;
+}
+
+int bd_conn(ipc_callid_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
+{
+	bd_srv_t *srv;
+	int rc;
+
+	/* Accept the connection */
+	async_answer_0(iid, EOK);
+
+	srv = bd_srv_create(srvs);
+	if (srv == NULL)
+		return ENOMEM;
+
+	async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
+	if (sess == NULL)
+		return ENOMEM;
+
+	srv->client_sess = sess;
+
+	rc = srvs->ops->open(srvs, srv);
+	if (rc != EOK)
+		return rc;
+
+	while (true) {
+		ipc_call_t call;
+		ipc_callid_t callid = async_get_call(&call);
+		sysarg_t method = IPC_GET_IMETHOD(call);
+
+		if (!method) {
+			/* The other side has hung up */
+			async_answer_0(callid, EOK);
+			break;
+		}
+
+		switch (method) {
+		case BD_READ_BLOCKS:
+			bd_read_blocks_srv(srv, callid, &call);
+			break;
+		case BD_READ_TOC:
+			bd_read_toc_srv(srv, callid, &call);
+			break;
+		case BD_WRITE_BLOCKS:
+			bd_write_blocks_srv(srv, callid, &call);
+			break;
+		case BD_GET_BLOCK_SIZE:
+			bd_get_block_size_srv(srv, callid, &call);
+			break;
+		case BD_GET_NUM_BLOCKS:
+			bd_get_num_blocks_srv(srv, callid, &call);
+			break;
+		default:
+			async_answer_0(callid, EINVAL);
+		}
+	}
+
+	rc = srvs->ops->close(srv);
+	free(srv);
+
+	return rc;
+}
+
+/** @}
+ */
Index: uspace/lib/c/generic/ipc.c
===================================================================
--- uspace/lib/c/generic/ipc.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/c/generic/ipc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -48,5 +48,4 @@
 #include <fibril.h>
 #include <macros.h>
-#include "private/libc.h"
 
 /**
@@ -83,101 +82,4 @@
 
 static atomic_t ipc_futex = FUTEX_INITIALIZER;
-
-/** Fast synchronous call.
- *
- * Only three payload arguments can be passed using this function. However,
- * this function is faster than the generic ipc_call_sync_slow() because
- * the payload is passed directly in registers.
- *
- * @param phoneid Phone handle for the call.
- * @param method  Requested method.
- * @param arg1    Service-defined payload argument.
- * @param arg2    Service-defined payload argument.
- * @param arg3    Service-defined payload argument.
- * @param result1 If non-NULL, the return ARG1 will be stored there.
- * @param result2 If non-NULL, the return ARG2 will be stored there.
- * @param result3 If non-NULL, the return ARG3 will be stored there.
- * @param result4 If non-NULL, the return ARG4 will be stored there.
- * @param result5 If non-NULL, the return ARG5 will be stored there.
- *
- * @return Negative values representing IPC errors.
- * @return Otherwise the RETVAL of the answer.
- *
- */
-int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2,
-    sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
-{
-	ipc_call_t resdata;
-	int callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
-	    arg2, arg3, (sysarg_t) &resdata);
-	if (callres)
-		return callres;
-	
-	if (result1)
-		*result1 = IPC_GET_ARG1(resdata);
-	if (result2)
-		*result2 = IPC_GET_ARG2(resdata);
-	if (result3)
-		*result3 = IPC_GET_ARG3(resdata);
-	if (result4)
-		*result4 = IPC_GET_ARG4(resdata);
-	if (result5)
-		*result5 = IPC_GET_ARG5(resdata);
-	
-	return IPC_GET_RETVAL(resdata);
-}
-
-/** Synchronous call transmitting 5 arguments of payload.
- *
- * @param phoneid Phone handle for the call.
- * @param imethod Requested interface and method.
- * @param arg1    Service-defined payload argument.
- * @param arg2    Service-defined payload argument.
- * @param arg3    Service-defined payload argument.
- * @param arg4    Service-defined payload argument.
- * @param arg5    Service-defined payload argument.
- * @param result1 If non-NULL, storage for the first return argument.
- * @param result2 If non-NULL, storage for the second return argument.
- * @param result3 If non-NULL, storage for the third return argument.
- * @param result4 If non-NULL, storage for the fourth return argument.
- * @param result5 If non-NULL, storage for the fifth return argument.
- *
- * @return Negative values representing IPC errors.
- * @return Otherwise the RETVAL of the answer.
- *
- */
-int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
-    sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4,
-    sysarg_t *result5)
-{
-	ipc_call_t data;
-	
-	IPC_SET_IMETHOD(data, imethod);
-	IPC_SET_ARG1(data, arg1);
-	IPC_SET_ARG2(data, arg2);
-	IPC_SET_ARG3(data, arg3);
-	IPC_SET_ARG4(data, arg4);
-	IPC_SET_ARG5(data, arg5);
-	
-	int callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid,
-	    (sysarg_t) &data, (sysarg_t) &data);
-	if (callres)
-		return callres;
-	
-	if (result1)
-		*result1 = IPC_GET_ARG1(data);
-	if (result2)
-		*result2 = IPC_GET_ARG2(data);
-	if (result3)
-		*result3 = IPC_GET_ARG3(data);
-	if (result4)
-		*result4 = IPC_GET_ARG4(data);
-	if (result5)
-		*result5 = IPC_GET_ARG5(data);
-	
-	return IPC_GET_RETVAL(data);
-}
 
 /** Send asynchronous message via syscall.
@@ -611,98 +513,4 @@
 }
 
-/** Request callback connection.
- *
- * The @a task_id and @a phonehash identifiers returned
- * by the kernel can be used for connection tracking.
- *
- * @param phoneid   Phone handle used for contacting the other side.
- * @param arg1      User defined argument.
- * @param arg2      User defined argument.
- * @param arg3      User defined argument.
- * @param task_id   Identifier of the client task.
- * @param phonehash Opaque identifier of the phone that will
- *                  be used for incoming calls.
- *
- * @return Zero on success or a negative error code.
- *
- */
-int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
-    task_id_t *task_id, sysarg_t *phonehash)
-{
-	ipc_call_t data;
-	int rc = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid,
-	    IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, (sysarg_t) &data);
-	if (rc == EOK) {
-		*task_id = data.in_task_id;
-		*phonehash = IPC_GET_ARG5(data);
-	}	
-	return rc;
-}
-
-/** Request cloned connection.
- *
- * @param phoneid Phone handle used for contacting the other side.
- *
- * @return Cloned phone handle on success or a negative error code.
- *
- */
-int ipc_clone_establish(int phoneid)
-{
-	sysarg_t newphid;
-	int res = ipc_call_sync_0_5(phoneid, IPC_M_CLONE_ESTABLISH, NULL,
-	    NULL, NULL, NULL, &newphid);
-	if (res)
-		return res;
-	
-	return newphid;
-}
-
-/** Request new connection.
- *
- * @param phoneid Phone handle used for contacting the other side.
- * @param arg1    User defined argument.
- * @param arg2    User defined argument.
- * @param arg3    User defined argument.
- *
- * @return New phone handle on success or a negative error code.
- *
- */
-int ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
-{
-	sysarg_t newphid;
-	int res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
-	    NULL, NULL, NULL, NULL, &newphid);
-	if (res)
-		return res;
-	
-	return newphid;
-}
-
-/** Request new connection (blocking)
- *
- * If the connection is not available at the moment, the
- * call should block. This has to be, however, implemented
- * on the server side.
- *
- * @param phoneid Phone handle used for contacting the other side.
- * @param arg1    User defined argument.
- * @param arg2    User defined argument.
- * @param arg3    User defined argument.
- *
- * @return New phone handle on success or a negative error code.
- *
- */
-int ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3)
-{
-	sysarg_t newphid;
-	int res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
-	    IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
-	if (res)
-		return res;
-	
-	return newphid;
-}
-
 /** Hang up a phone.
  *
@@ -758,148 +566,4 @@
 }
 
-/** Wrapper for IPC_M_SHARE_IN calls.
- *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param size    Size of the destination address space area.
- * @param arg     User defined argument.
- * @param flags   Storage for received flags. Can be NULL.
- * @param dst     Destination address space area base. Cannot be NULL.
- *
- * @return Zero on success or a negative error code from errno.h.
- *
- */
-int ipc_share_in_start(int phoneid, size_t size, sysarg_t arg,
-    unsigned int *flags, void **dst)
-{
-	sysarg_t _flags = 0;
-	sysarg_t _dst = (sysarg_t) -1;
-	int res = ipc_call_sync_2_4(phoneid, IPC_M_SHARE_IN, (sysarg_t) size,
-	    arg, NULL, &_flags, NULL, &_dst);
-	
-	if (flags)
-		*flags = (unsigned int) _flags;
-	
-	*dst = (void *) _dst;
-	return res;
-}
-
-/** Wrapper for answering the IPC_M_SHARE_IN calls.
- *
- * This wrapper only makes it more comfortable to answer IPC_M_SHARE_IN
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
- *
- * @param callid Hash of the IPC_M_DATA_READ call to answer.
- * @param src    Source address space base.
- * @param flags Flags to be used for sharing. Bits can be only cleared.
- *
- * @return Zero on success or a value from @ref errno.h on failure.
- *
- */
-int ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
-{
-	return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
-	    (sysarg_t) __entry);
-}
-
-/** Wrapper for IPC_M_SHARE_OUT calls.
- *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param src     Source address space area base address.
- * @param flags   Flags to be used for sharing. Bits can be only cleared.
- *
- * @return Zero on success or a negative error code from errno.h.
- *
- */
-int ipc_share_out_start(int phoneid, void *src, unsigned int flags)
-{
-	return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
-	    (sysarg_t) flags);
-}
-
-/** Wrapper for answering the IPC_M_SHARE_OUT calls.
- *
- * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
- *
- * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Destination address space area base address.
- *
- * @return Zero on success or a value from @ref errno.h on failure.
- *
- */
-int ipc_share_out_finalize(ipc_callid_t callid, void **dst)
-{
-	return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
-}
-
-/** Wrapper for IPC_M_DATA_READ calls.
- *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param dst     Address of the beginning of the destination buffer.
- * @param size    Size of the destination buffer.
- *
- * @return Zero on success or a negative error code from errno.h.
- *
- */
-int ipc_data_read_start(int phoneid, void *dst, size_t size)
-{
-	return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
-	    (sysarg_t) size);
-}
-
-/** Wrapper for answering the IPC_M_DATA_READ calls.
- *
- * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
- *
- * @param callid Hash of the IPC_M_DATA_READ call to answer.
- * @param src    Source address for the IPC_M_DATA_READ call.
- * @param size   Size for the IPC_M_DATA_READ call. Can be smaller than
- *               the maximum size announced by the sender.
- *
- * @return Zero on success or a value from @ref errno.h on failure.
- *
- */
-int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
-{
-	return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
-}
-
-/** Wrapper for IPC_M_DATA_WRITE calls.
- *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param src     Address of the beginning of the source buffer.
- * @param size    Size of the source buffer.
- *
- * @return Zero on success or a negative error code from errno.h.
- *
- */
-int ipc_data_write_start(int phoneid, const void *src, size_t size)
-{
-	return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
-	    (sysarg_t) size);
-}
-
-/** Wrapper for answering the IPC_M_DATA_WRITE calls.
- *
- * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
- *
- * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
- * @param size   Final size for the IPC_M_DATA_WRITE call.
- *
- * @return Zero on success or a value from @ref errno.h on failure.
- *
- */
-int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
-{
-	return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
-}
-
 /** Connect to a task specified by id.
  *
Index: uspace/lib/c/generic/iplink_srv.c
===================================================================
--- uspace/lib/c/generic/iplink_srv.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/c/generic/iplink_srv.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -139,4 +139,7 @@
 		if (!method) {
 			/* The other side has hung up */
+		    	fibril_mutex_lock(&srv->lock);
+			srv->connected = false;
+		    	fibril_mutex_unlock(&srv->lock);
 			async_answer_0(callid, EOK);
 			break;
Index: uspace/lib/c/include/bd.h
===================================================================
--- uspace/lib/c/include/bd.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/c/include/bd.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2012 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBC_BD_H_
+#define LIBC_BD_H_
+
+#include <async.h>
+#include <sys/types.h>
+
+typedef struct {
+	async_sess_t *sess;
+} bd_t;
+
+extern int bd_open(async_sess_t *, bd_t **);
+extern void bd_close(bd_t *);
+extern int bd_read_blocks(bd_t *, aoff64_t, size_t, void *, size_t);
+extern int bd_read_toc(bd_t *, uint8_t, void *, size_t);
+extern int bd_write_blocks(bd_t *, aoff64_t, size_t, const void *, size_t);
+extern int bd_get_block_size(bd_t *, size_t *);
+extern int bd_get_num_blocks(bd_t *, aoff64_t *);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/bd_srv.h
===================================================================
--- uspace/lib/c/include/bd_srv.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/c/include/bd_srv.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2012 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBC_BD_SRV_H_
+#define LIBC_BD_SRV_H_
+
+#include <adt/list.h>
+#include <async.h>
+#include <fibril_synch.h>
+#include <bool.h>
+#include <sys/types.h>
+
+typedef struct bd_ops bd_ops_t;
+
+/** Service setup (per sevice) */
+typedef struct {
+	bd_ops_t *ops;
+	void *sarg;
+} bd_srvs_t;
+
+/** Server structure (per client session) */
+typedef struct {
+	bd_srvs_t *srvs;
+	async_sess_t *client_sess;
+	void *carg;
+} bd_srv_t;
+
+typedef struct bd_ops {
+	int (*open)(bd_srvs_t *, bd_srv_t *);
+	int (*close)(bd_srv_t *);
+	int (*read_blocks)(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+	int (*read_toc)(bd_srv_t *, uint8_t, void *, size_t);
+	int (*write_blocks)(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+	int (*get_block_size)(bd_srv_t *, size_t *);
+	int (*get_num_blocks)(bd_srv_t *, aoff64_t *);
+} bd_ops_t;
+
+extern void bd_srvs_init(bd_srvs_t *);
+
+extern int bd_conn(ipc_callid_t, ipc_call_t *, bd_srvs_t *);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/ipc/ipc.h
===================================================================
--- uspace/lib/c/include/ipc/ipc.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/lib/c/include/ipc/ipc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -47,140 +47,4 @@
 
 typedef void (*ipc_async_callback_t)(void *, int, ipc_call_t *);
-
-/*
- * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
- * They are in the form ipc_call_sync_m_n(), where m denotes the number of
- * arguments of payload and n denotes number of return values. Whenever
- * possible, the fast version is used.
- */
-
-#define ipc_call_sync_0_0(phoneid, method) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0)
-#define ipc_call_sync_0_1(phoneid, method, res1) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), 0, 0, 0, 0)
-#define ipc_call_sync_0_2(phoneid, method, res1, res2) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), 0, 0, 0)
-#define ipc_call_sync_0_3(phoneid, method, res1, res2, res3) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-	    0, 0)
-#define ipc_call_sync_0_4(phoneid, method, res1, res2, res3, res4) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-	    (res4), 0)
-#define ipc_call_sync_0_5(phoneid, method, res1, res2, res3, res4, res5) \
-	ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-	    (res4), (res5))
-
-#define ipc_call_sync_1_0(phoneid, method, arg1) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, 0, 0, 0, 0, 0)
-#define ipc_call_sync_1_1(phoneid, method, arg1, res1) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), 0, 0, 0, 0)
-#define ipc_call_sync_1_2(phoneid, method, arg1, res1, res2) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), 0, \
-	    0, 0)
-#define ipc_call_sync_1_3(phoneid, method, arg1, res1, res2, res3) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
-	    (res3), 0, 0)
-#define ipc_call_sync_1_4(phoneid, method, arg1, res1, res2, res3, res4) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
-	    (res3), (res4), 0)
-#define ipc_call_sync_1_5(phoneid, method, arg1, res1, res2, res3, res4, \
-    res5) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
-	    (res3), (res4), (res5))
-
-#define ipc_call_sync_2_0(phoneid, method, arg1, arg2) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, 0, 0, 0, \
-	    0, 0)
-#define ipc_call_sync_2_1(phoneid, method, arg1, arg2, res1) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), 0, 0, \
-	    0, 0)
-#define ipc_call_sync_2_2(phoneid, method, arg1, arg2, res1, res2) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-	    (res2), 0, 0, 0)
-#define ipc_call_sync_2_3(phoneid, method, arg1, arg2, res1, res2, res3) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-	    (res2), (res3), 0, 0)
-#define ipc_call_sync_2_4(phoneid, method, arg1, arg2, res1, res2, res3, \
-    res4) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-	    (res2), (res3), (res4), 0)
-#define ipc_call_sync_2_5(phoneid, method, arg1, arg2, res1, res2, res3, \
-    res4, res5)\
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-	    (res2), (res3), (res4), (res5))
-
-#define ipc_call_sync_3_0(phoneid, method, arg1, arg2, arg3) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, 0, 0, \
-	    0, 0)
-#define ipc_call_sync_3_1(phoneid, method, arg1, arg2, arg3, res1) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
-	    0, 0, 0, 0)
-#define ipc_call_sync_3_2(phoneid, method, arg1, arg2, arg3, res1, res2) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
-	    (res2), 0, 0, 0)
-#define ipc_call_sync_3_3(phoneid, method, arg1, arg2, arg3, res1, res2, \
-    res3) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (res1), (res2), (res3), 0, 0)
-#define ipc_call_sync_3_4(phoneid, method, arg1, arg2, arg3, res1, res2, \
-    res3, res4) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (res1), (res2), (res3), (res4), 0)
-#define ipc_call_sync_3_5(phoneid, method, arg1, arg2, arg3, res1, res2, \
-    res3, res4, res5) \
-	ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (res1), (res2), (res3), (res4), (res5))
-
-#define ipc_call_sync_4_0(phoneid, method, arg1, arg2, arg3, arg4) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-	    0, 0, 0, 0, 0)
-#define ipc_call_sync_4_1(phoneid, method, arg1, arg2, arg3, arg4, res1) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-	    (res1), 0, 0, 0, 0)
-#define ipc_call_sync_4_2(phoneid, method, arg1, arg2, arg3, arg4, res1, res2) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-	    (res1), (res2), 0, 0, 0)
-#define ipc_call_sync_4_3(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
-    res3) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), 0, (res1), (res2), (res3), 0, 0)
-#define ipc_call_sync_4_4(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
-    res3, res4) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), 0, (res1), (res2), (res3), (res4), 0)
-#define ipc_call_sync_4_5(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
-    res3, res4, res5) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), 0, (res1), (res2), (res3), (res4), (res5))
-
-#define ipc_call_sync_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-	    (arg5), 0, 0, 0, 0, 0)
-#define ipc_call_sync_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-	    (arg5), (res1), 0, 0, 0, 0)
-#define ipc_call_sync_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
-    res2) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), (arg5), (res1), (res2), 0, 0, 0)
-#define ipc_call_sync_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
-    res2, res3) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), (arg5), (res1), (res2), (res3), 0, 0)
-#define ipc_call_sync_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
-    res2, res3, res4) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), (arg5), (res1), (res2), (res3), (res4), 0)
-#define ipc_call_sync_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
-    res2, res3, res4, res5) \
-	ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
-	    (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
-
-extern int ipc_call_sync_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *);
-
-extern int ipc_call_sync_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *,
-    sysarg_t *);
 
 extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, sysarg_t, unsigned int);
@@ -254,10 +118,4 @@
     sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool);
 
-extern int ipc_clone_establish(int);
-extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, task_id_t *,
-    sysarg_t *);
-extern int ipc_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
-extern int ipc_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
-
 extern int ipc_hangup(int);
 
@@ -267,26 +125,4 @@
     sysarg_t, sysarg_t, sysarg_t, unsigned int);
 
-/*
- * User-friendly wrappers for ipc_share_in_start().
- */
-
-#define ipc_share_in_start_0_0(phoneid, size, dst) \
-	ipc_share_in_start((phoneid), (size), 0, NULL, (dst))
-#define ipc_share_in_start_0_1(phoneid, size, flags, dst) \
-	ipc_share_in_start((phoneid), (size), 0, (flags), (dst))
-#define ipc_share_in_start_1_0(phoneid, size, arg, dst) \
-	ipc_share_in_start((phoneid), (size), (arg), NULL, (dst))
-#define ipc_share_in_start_1_1(phoneid, size, arg, flags, dst) \
-	ipc_share_in_start((phoneid), (size), (arg), (flags), (dst))
-
-extern int ipc_share_in_start(int, size_t, sysarg_t, unsigned int *, void **);
-extern int ipc_share_in_finalize(ipc_callid_t, void *, unsigned int);
-extern int ipc_share_out_start(int, void *, unsigned int);
-extern int ipc_share_out_finalize(ipc_callid_t, void **);
-extern int ipc_data_read_start(int, void *, size_t);
-extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
-extern int ipc_data_write_start(int, const void *, size_t);
-extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
-
 extern int ipc_connect_kbox(task_id_t);
 
Index: uspace/lib/ext4/Makefile
===================================================================
--- uspace/lib/ext4/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2012 Frantisek Princ
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+USPACE_PREFIX = ../..
+LIBRARY = libext4
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a
+
+SOURCES = \
+	libext4_balloc.c \
+	libext4_bitmap.c \
+	libext4_block_group.c \
+	libext4_crc.c \
+	libext4_directory.c \
+	libext4_directory_index.c \
+	libext4_extent.c \
+	libext4_filesystem.c \
+	libext4_hash.c \
+	libext4_ialloc.c \
+	libext4_inode.c \
+	libext4_superblock.c
+
+include $(USPACE_PREFIX)/Makefile.common
Index: uspace/lib/ext4/libext4.h
===================================================================
--- uspace/lib/ext4/libext4.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_H_
+#define LIBEXT4_LIBEXT4_H_
+
+#include "libext4_balloc.h"
+#include "libext4_bitmap.h"
+#include "libext4_block_group.h"
+#include "libext4_crc.h"
+#include "libext4_directory.h"
+#include "libext4_directory_index.h"
+#include "libext4_extent.h"
+#include "libext4_filesystem.h"
+#include "libext4_hash.h"
+#include "libext4_ialloc.h"
+#include "libext4_inode.h"
+#include "libext4_superblock.h"
+#include "libext4_types.h"
+
+#include <stdio.h>
+#define EXT4FS_DBG(format, ...) \
+	printf("ext4fs: %s: " format "\n", \
+	    __FUNCTION__, ##__VA_ARGS__) \
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_balloc.c
===================================================================
--- uspace/lib/ext4/libext4_balloc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_balloc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,667 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_balloc.c
+ * @brief Physical block allocator.
+ */
+
+#include <errno.h>
+#include <sys/types.h>
+#include "libext4.h"
+
+/** Compute number of block group from block address.
+ *
+ * @param sb         Superblock pointer.
+ * @param block_addr Absolute address of block.
+ *
+ * @return Block group index
+ *
+ */
+static uint32_t ext4_balloc_get_bgid_of_block(ext4_superblock_t *sb,
+    uint32_t block_addr)
+{
+	uint32_t blocks_per_group =
+	    ext4_superblock_get_blocks_per_group(sb);
+	uint32_t first_block =
+	    ext4_superblock_get_first_data_block(sb);
+	
+	/* First block == 0 or 1 */
+	if (first_block == 0)
+		return block_addr / blocks_per_group;
+	else
+		return (block_addr - 1) / blocks_per_group;
+}
+
+/** Free block.
+ *
+ * @param inode_ref  Inode, where the block is allocated
+ * @param block_addr Absolute block address to free
+ *
+ * @return Error code
+ *
+ */
+int ext4_balloc_free_block(ext4_inode_ref_t *inode_ref, uint32_t block_addr)
+{
+	ext4_filesystem_t *fs = inode_ref->fs;
+	ext4_superblock_t *sb = fs->superblock;
+	
+	/* Compute indexes */
+	uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr);
+	uint32_t index_in_group =
+	    ext4_filesystem_blockaddr2_index_in_group(sb, block_addr);
+	
+	/* Load block group reference */
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Load block with bitmap */
+	uint32_t bitmap_block_addr =
+	    ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
+	block_t *bitmap_block;
+	rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
+	if (rc != EOK)
+		return rc;
+	
+	/* Modify bitmap */
+	ext4_bitmap_free_bit(bitmap_block->data, index_in_group);
+	bitmap_block->dirty = true;
+	
+	/* Release block with bitmap */
+	rc = block_put(bitmap_block);
+	if (rc != EOK) {
+		/* Error in saving bitmap */
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+	
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Update superblock free blocks count */
+	uint32_t sb_free_blocks =
+	    ext4_superblock_get_free_blocks_count(sb);
+	sb_free_blocks++;
+	ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
+	
+	/* Update inode blocks count */
+	uint64_t ino_blocks =
+	    ext4_inode_get_blocks_count(sb, inode_ref->inode);
+	ino_blocks -= block_size / EXT4_INODE_BLOCK_SIZE;
+	ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
+	inode_ref->dirty = true;
+	
+	/* Update block group free blocks count */
+	uint32_t free_blocks =
+	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+	free_blocks++;
+	ext4_block_group_set_free_blocks_count(bg_ref->block_group,
+	    sb, free_blocks);
+	bg_ref->dirty = true;
+	
+	/* Release block group reference */
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	return EOK;
+}
+
+/** Free continuous set of blocks.
+ *
+ * @param inode_ref Inode, where the blocks are allocated
+ * @param first     First block to release
+ * @param count     Number of blocks to release
+ *
+ */
+int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
+    uint32_t first, uint32_t count)
+{
+	ext4_filesystem_t *fs = inode_ref->fs;
+	ext4_superblock_t *sb = fs->superblock;
+	
+	/* Compute indexes */
+	uint32_t block_group_first =
+	    ext4_balloc_get_bgid_of_block(sb, first);
+	uint32_t block_group_last =
+	    ext4_balloc_get_bgid_of_block(sb, first + count - 1);
+	
+	assert(block_group_first == block_group_last);
+	
+	/* Load block group reference */
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(fs, block_group_first, &bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	uint32_t index_in_group_first =
+	    ext4_filesystem_blockaddr2_index_in_group(sb, first);
+	
+	/* Load block with bitmap */
+	uint32_t bitmap_block_addr =
+	    ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
+	
+	block_t *bitmap_block;
+	rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
+	if (rc != EOK)
+		return rc;
+	
+	/* Modify bitmap */
+	ext4_bitmap_free_bits(bitmap_block->data, index_in_group_first, count);
+	bitmap_block->dirty = true;
+	
+	/* Release block with bitmap */
+	rc = block_put(bitmap_block);
+	if (rc != EOK) {
+		/* Error in saving bitmap */
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+	
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Update superblock free blocks count */
+	uint32_t sb_free_blocks =
+	    ext4_superblock_get_free_blocks_count(sb);
+	sb_free_blocks += count;
+	ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
+	
+	/* Update inode blocks count */
+	uint64_t ino_blocks =
+	    ext4_inode_get_blocks_count(sb, inode_ref->inode);
+	ino_blocks -= count * (block_size / EXT4_INODE_BLOCK_SIZE);
+	ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
+	inode_ref->dirty = true;
+	
+	/* Update block group free blocks count */
+	uint32_t free_blocks =
+	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+	free_blocks += count;
+	ext4_block_group_set_free_blocks_count(bg_ref->block_group,
+	    sb, free_blocks);
+	bg_ref->dirty = true;
+	
+	/* Release block group reference */
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	return EOK;
+}
+
+/** Compute first block for data in block group.
+ *
+ * @param sb   Pointer to superblock
+ * @param bg   Pointer to block group
+ * @param bgid Index of block group
+ *
+ * @return Absolute block index of first block
+ *
+ */
+uint32_t ext4_balloc_get_first_data_block_in_group(ext4_superblock_t *sb,
+    ext4_block_group_ref_t *bg_ref)
+{
+	uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
+	uint32_t inode_table_first_block =
+	    ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
+	uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
+	uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint32_t inode_table_bytes;
+	
+	if (bg_ref->index < block_group_count - 1) {
+		inode_table_bytes = inodes_per_group * inode_table_item_size;
+	} else {
+		/* Last block group could be smaller */
+		uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
+		inode_table_bytes =
+		    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
+		    inode_table_item_size;
+	}
+	
+	uint32_t inode_table_blocks = inode_table_bytes / block_size;
+	
+	if (inode_table_bytes % block_size)
+		inode_table_blocks++;
+	
+	return inode_table_first_block + inode_table_blocks;
+}
+
+/** Compute 'goal' for allocation algorithm.
+ *
+ * @param inode_ref Reference to inode, to allocate block for
+ *
+ * @return Goal block number
+ *
+ */
+static uint32_t ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref)
+{
+	uint32_t goal = 0;
+	
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	
+	uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint32_t inode_block_count = inode_size / block_size;
+	
+	if (inode_size % block_size != 0)
+		inode_block_count++;
+	
+	/* If inode has some blocks, get last block address + 1 */
+	if (inode_block_count > 0) {
+		int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
+		    inode_block_count - 1, &goal);
+		if (rc != EOK)
+			return 0;
+		
+		if (goal != 0) {
+			goal++;
+			return goal;
+		}
+		
+		/* If goal == 0, sparse file -> continue */
+	}
+	
+	/* Identify block group of inode */
+	uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+	uint32_t block_group = (inode_ref->index - 1) / inodes_per_group;
+	block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Load block group reference */
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
+	    block_group, &bg_ref);
+	if (rc != EOK)
+		return 0;
+	
+	/* Compute indexes */
+	uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
+	uint32_t inode_table_first_block =
+	    ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
+	uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
+	uint32_t inode_table_bytes;
+	
+	/* Check for last block group */
+	if (block_group < block_group_count - 1) {
+		inode_table_bytes = inodes_per_group * inode_table_item_size;
+	} else {
+		/* Last block group could be smaller */
+		uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
+		inode_table_bytes =
+		    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
+		    inode_table_item_size;
+	}
+	
+	uint32_t inode_table_blocks = inode_table_bytes / block_size;
+	
+	if (inode_table_bytes % block_size)
+		inode_table_blocks++;
+	
+	goal = inode_table_first_block + inode_table_blocks;
+	
+	ext4_filesystem_put_block_group_ref(bg_ref);
+	
+	return goal;
+}
+
+/** Data block allocation algorithm.
+ *
+ * @param inode_ref Inode to allocate block for
+ * @param fblock    Allocated block address
+ *
+ * @return Error code
+ *
+ */
+int ext4_balloc_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t *fblock)
+{
+	uint32_t allocated_block = 0;
+	
+	uint32_t bitmap_block_addr;
+	block_t *bitmap_block;
+	uint32_t rel_block_idx = 0;
+	
+	/* Find GOAL */
+	uint32_t goal = ext4_balloc_find_goal(inode_ref);
+	if (goal == 0) {
+		/* no goal found => partition is full */
+		return ENOSPC;
+	}
+	
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	
+	/* Load block group number for goal and relative index */
+	uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
+	uint32_t index_in_group =
+	    ext4_filesystem_blockaddr2_index_in_group(sb, goal);
+	
+	/* Load block group reference */
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
+	    block_group, &bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Compute indexes */
+	uint32_t first_in_group =
+	    ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
+	
+	uint32_t first_in_group_index =
+	    ext4_filesystem_blockaddr2_index_in_group(sb, first_in_group);
+	
+	if (index_in_group < first_in_group_index)
+		index_in_group = first_in_group_index;
+	
+	/* Load block with bitmap */
+	bitmap_block_addr =
+	    ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
+	
+	rc = block_get(&bitmap_block, inode_ref->fs->device,
+	    bitmap_block_addr, BLOCK_FLAGS_NONE);
+	if (rc != EOK) {
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+	
+	/* Check if goal is free */
+	if (ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group)) {
+		ext4_bitmap_set_bit(bitmap_block->data, index_in_group);
+		bitmap_block->dirty = true;
+		rc = block_put(bitmap_block);
+		if (rc != EOK) {
+			ext4_filesystem_put_block_group_ref(bg_ref);
+			return rc;
+		}
+		
+		allocated_block =
+		    ext4_filesystem_index_in_group2blockaddr(sb, index_in_group,
+		    block_group);
+		
+		goto success;
+	}
+	
+	uint32_t blocks_in_group =
+	    ext4_superblock_get_blocks_in_group(sb, block_group);
+	
+	uint32_t end_idx = (index_in_group + 63) & ~63;
+	if (end_idx > blocks_in_group)
+		end_idx = blocks_in_group;
+	
+	/* Try to find free block near to goal */
+	for (uint32_t tmp_idx = index_in_group + 1; tmp_idx < end_idx;
+	    ++tmp_idx) {
+		if (ext4_bitmap_is_free_bit(bitmap_block->data, tmp_idx)) {
+			ext4_bitmap_set_bit(bitmap_block->data, tmp_idx);
+			bitmap_block->dirty = true;
+			rc = block_put(bitmap_block);
+			if (rc != EOK)
+				return rc;
+			
+			allocated_block =
+			    ext4_filesystem_index_in_group2blockaddr(sb, tmp_idx,
+			    block_group);
+			
+			goto success;
+		}
+	}
+	
+	/* Find free BYTE in bitmap */
+	rc = ext4_bitmap_find_free_byte_and_set_bit(bitmap_block->data,
+	    index_in_group, &rel_block_idx, blocks_in_group);
+	if (rc == EOK) {
+		bitmap_block->dirty = true;
+		rc = block_put(bitmap_block);
+		if (rc != EOK)
+			return rc;
+		
+		allocated_block =
+		    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
+		    block_group);
+		
+		goto success;
+	}
+	
+	/* Find free bit in bitmap */
+	rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data,
+	    index_in_group, &rel_block_idx, blocks_in_group);
+	if (rc == EOK) {
+		bitmap_block->dirty = true;
+		rc = block_put(bitmap_block);
+		if (rc != EOK)
+			return rc;
+		
+		allocated_block =
+		    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
+		    block_group);
+		
+		goto success;
+	}
+	
+	/* No free block found yet */
+	block_put(bitmap_block);
+	ext4_filesystem_put_block_group_ref(bg_ref);
+	
+	/* Try other block groups */
+	uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
+	
+	uint32_t bgid = (block_group + 1) % block_group_count;
+	uint32_t count = block_group_count;
+	
+	while (count > 0) {
+		rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, bgid,
+		    &bg_ref);
+		if (rc != EOK)
+			return rc;
+		
+		/* Load block with bitmap */
+		bitmap_block_addr =
+		    ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
+		
+		rc = block_get(&bitmap_block, inode_ref->fs->device,
+		    bitmap_block_addr, 0);
+		if (rc != EOK) {
+			ext4_filesystem_put_block_group_ref(bg_ref);
+			return rc;
+		}
+		
+		/* Compute indexes */
+		first_in_group =
+		    ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
+		index_in_group =
+		    ext4_filesystem_blockaddr2_index_in_group(sb, first_in_group);
+		blocks_in_group = ext4_superblock_get_blocks_in_group(sb, bgid);
+		
+		first_in_group_index =
+		    ext4_filesystem_blockaddr2_index_in_group(sb, first_in_group);
+		
+		if (index_in_group < first_in_group_index)
+			index_in_group = first_in_group_index;
+		
+		/* Try to find free byte in bitmap */
+		rc = ext4_bitmap_find_free_byte_and_set_bit(bitmap_block->data,
+		    index_in_group, &rel_block_idx, blocks_in_group);
+		if (rc == EOK) {
+			bitmap_block->dirty = true;
+			rc = block_put(bitmap_block);
+			if (rc != EOK)
+				return rc;
+			
+			allocated_block =
+			    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
+			    bgid);
+			
+			goto success;
+		}
+		
+		/* Try to find free bit in bitmap */
+		rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data,
+		    index_in_group, &rel_block_idx, blocks_in_group);
+		if (rc == EOK) {
+			bitmap_block->dirty = true;
+			rc = block_put(bitmap_block);
+			if (rc != EOK)
+				return rc;
+			
+			allocated_block =
+			    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
+			    bgid);
+			
+			goto success;
+		}
+		
+		block_put(bitmap_block);
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		
+		/* Goto next group */
+		bgid = (bgid + 1) % block_group_count;
+		count--;
+	}
+	
+	return ENOSPC;
+	
+success:
+	/* Empty command - because of syntax */
+	;
+	
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Update superblock free blocks count */
+	uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb);
+	sb_free_blocks--;
+	ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
+	
+	/* Update inode blocks (different block size!) count */
+	uint64_t ino_blocks =
+	    ext4_inode_get_blocks_count(sb, inode_ref->inode);
+	ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
+	ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
+	inode_ref->dirty = true;
+	
+	/* Update block group free blocks count */
+	uint32_t bg_free_blocks =
+	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+	bg_free_blocks--;
+	ext4_block_group_set_free_blocks_count(bg_ref->block_group, sb,
+	    bg_free_blocks);
+	bg_ref->dirty = true;
+	
+	ext4_filesystem_put_block_group_ref(bg_ref);
+	
+	*fblock = allocated_block;
+	return EOK;
+}
+
+/** Try to allocate concrete block.
+ *
+ * @param inode_ref Inode to allocate block for
+ * @param fblock    Block address to allocate
+ * @param free      Output value - if target block is free
+ *
+ * @return Error code
+ *
+ */
+int ext4_balloc_try_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t fblock,
+    bool *free)
+{
+	int rc = EOK;
+	
+	ext4_filesystem_t *fs = inode_ref->fs;
+	ext4_superblock_t *sb = fs->superblock;
+	
+	/* Compute indexes */
+	uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock);
+	uint32_t index_in_group =
+	    ext4_filesystem_blockaddr2_index_in_group(sb, fblock);
+	
+	/* Load block group reference */
+	ext4_block_group_ref_t *bg_ref;
+	rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Load block with bitmap */
+	uint32_t bitmap_block_addr =
+	    ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
+	block_t *bitmap_block;
+	rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
+	if (rc != EOK)
+		return rc;
+	
+	/* Check if block is free */
+	*free = ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group);
+	
+	/* Allocate block if possible */
+	if (*free) {
+		ext4_bitmap_set_bit(bitmap_block->data, index_in_group);
+		bitmap_block->dirty = true;
+	}
+	
+	/* Release block with bitmap */
+	rc = block_put(bitmap_block);
+	if (rc != EOK) {
+		/* Error in saving bitmap */
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+	
+	/* If block is not free, return */
+	if (!(*free))
+		goto terminate;
+	
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Update superblock free blocks count */
+	uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb);
+	sb_free_blocks--;
+	ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
+	
+	/* Update inode blocks count */
+	uint64_t ino_blocks =
+	    ext4_inode_get_blocks_count(sb, inode_ref->inode);
+	ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
+	ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
+	inode_ref->dirty = true;
+	
+	/* Update block group free blocks count */
+	uint32_t free_blocks =
+	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+	free_blocks--;
+	ext4_block_group_set_free_blocks_count(bg_ref->block_group,
+	    sb, free_blocks);
+	bg_ref->dirty = true;
+	
+terminate:
+	return ext4_filesystem_put_block_group_ref(bg_ref);
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_balloc.h
===================================================================
--- uspace/lib/ext4/libext4_balloc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_balloc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_BALLOC_H_
+#define LIBEXT4_LIBEXT4_BALLOC_H_
+
+#include <sys/types.h>
+#include "libext4_types.h"
+
+extern int ext4_balloc_free_block(ext4_inode_ref_t *, uint32_t);
+extern int ext4_balloc_free_blocks(ext4_inode_ref_t *, uint32_t, uint32_t);
+extern uint32_t ext4_balloc_get_first_data_block_in_group(ext4_superblock_t *,
+    ext4_block_group_ref_t *);
+extern int ext4_balloc_alloc_block(ext4_inode_ref_t *, uint32_t *);
+extern int ext4_balloc_try_alloc_block(ext4_inode_ref_t *, uint32_t, bool *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_bitmap.c
===================================================================
--- uspace/lib/ext4/libext4_bitmap.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_bitmap.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_bitmap.c
+ * @brief Ext4 bitmap operations.
+ */
+
+#include <errno.h>
+#include <libblock.h>
+#include <sys/types.h>
+#include "libext4.h"
+
+/** Set bit in bitmap to 0 (free).
+ *
+ * Index must be checked by caller, if it's not out of bounds.
+ *
+ * @param bitmap Pointer to bitmap
+ * @param index  Index of bit in bitmap
+ *
+ */
+void ext4_bitmap_free_bit(uint8_t *bitmap, uint32_t index)
+{
+	uint32_t byte_index = index / 8;
+	uint32_t bit_index = index % 8;
+	
+	uint8_t *target = bitmap + byte_index;
+	
+	*target &= ~ (1 << bit_index);
+}
+
+/** Free continous set of bits (set to 0).
+ *
+ * Index and count must be checked by caller, if they aren't out of bounds.
+ *
+ * @param bitmap Pointer to bitmap
+ * @param index  Index of first bit to zeroed
+ * @param count  Number of bits to be zeroed
+ *
+ */
+void ext4_bitmap_free_bits(uint8_t *bitmap, uint32_t index, uint32_t count)
+{
+	uint8_t *target;
+	uint32_t idx = index;
+	uint32_t remaining = count;
+	uint32_t byte_index;
+	
+	/* Align index to multiple of 8 */
+	while (((idx % 8) != 0) && (remaining > 0)) {
+		byte_index = idx / 8;
+		uint32_t bit_index = idx % 8;
+		
+		target = bitmap + byte_index;
+		*target &= ~ (1 << bit_index);
+		
+		idx++;
+		remaining--;
+	}
+	
+	/* For < 8 bits this check necessary */
+	if (remaining == 0)
+		return;
+	
+	assert((idx % 8) == 0);
+	
+	byte_index = idx / 8;
+	target = bitmap + byte_index;
+	
+	/* Zero the whole bytes */
+	while (remaining >= 8) {
+		*target = 0;
+		
+		idx += 8;
+		remaining -= 8;
+		target++;
+	}
+	
+	assert(remaining < 8);
+	
+	/* Zero remaining bytes */
+	while (remaining != 0) {
+		byte_index = idx / 8;
+		uint32_t bit_index = idx % 8;
+		
+		target = bitmap + byte_index;
+		*target &= ~ (1 << bit_index);
+		
+		idx++;
+		remaining--;
+	}
+}
+
+/** Set bit in bitmap to 1 (used).
+ *
+ * @param bitmap Pointer to bitmap
+ * @param index  Index of bit to set
+ *
+ */
+void ext4_bitmap_set_bit(uint8_t *bitmap, uint32_t index)
+{
+	uint32_t byte_index = index / 8;
+	uint32_t bit_index = index % 8;
+	
+	uint8_t *target = bitmap + byte_index;
+	
+	*target |= 1 << bit_index;
+}
+
+/** Check if requested bit is free.
+ *
+ * @param bitmap Pointer to bitmap
+ * @param index  Index of bit to be checked
+ *
+ * @return True if bit is free, else false
+ *
+ */
+bool ext4_bitmap_is_free_bit(uint8_t *bitmap, uint32_t index)
+{
+	uint32_t byte_index = index / 8;
+	uint32_t bit_index = index % 8;
+	
+	uint8_t *target = bitmap + byte_index;
+	
+	if (*target & (1 << bit_index))
+		return false;
+	else
+		return true;
+}
+
+/** Try to find free byte and set the first bit as used.
+ *
+ * Walk through bitmap and try to find free byte (equal to 0).
+ * If byte found, set the first bit as used.
+ *
+ * @param bitmap Pointer to bitmap
+ * @param start  Index of bit, where the algorithm will begin
+ * @param index  Output value - index of bit (if found free byte)
+ * @param max    Maximum index of bit in bitmap
+ *
+ * @return Error code
+ *
+ */
+int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *bitmap, uint32_t start,
+    uint32_t *index, uint32_t max)
+{
+	uint32_t idx;
+	
+	/* Align idx */
+	if (start % 8)
+		idx = start + (8 - (start % 8));
+	else
+		idx = start;
+	
+	uint8_t *pos = bitmap + (idx / 8);
+	
+	/* Try to find free byte */
+	while (idx < max) {
+		if (*pos == 0) {
+			*pos |= 1;
+			
+			*index = idx;
+			return EOK;
+		}
+		
+		idx += 8;
+		++pos;
+	}
+	
+	/* Free byte not found */
+	return ENOSPC;
+}
+
+/** Try to find free bit and set it as used (1).
+ *
+ * Walk through bitmap and try to find any free bit.
+ *
+ * @param bitmap    Pointer to bitmap
+ * @param start_idx Index of bit, where algorithm will begin
+ * @param index     Output value - index of set bit (if found)
+ * @param max       Maximum index of bit in bitmap
+ *
+ * @return Error code
+ *
+ */
+int ext4_bitmap_find_free_bit_and_set(uint8_t *bitmap, uint32_t start_idx,
+    uint32_t *index, uint32_t max)
+{
+	uint8_t *pos = bitmap + (start_idx / 8);
+	uint32_t idx = start_idx;
+	bool byte_part = false;
+	
+	/* Check the rest of first byte */
+	while ((idx % 8) != 0) {
+		byte_part = true;
+		
+		if ((*pos & (1 << (idx % 8))) == 0) {
+			*pos |= (1 << (idx % 8));
+			*index = idx;
+			return EOK;
+		}
+		
+		++idx;
+	}
+	
+	if (byte_part)
+		++pos;
+	
+	/* Check the whole bytes (255 = 11111111 binary) */
+	while (idx < max) {
+		if ((*pos & 255) != 255) {
+			/* Free bit found */
+			break;
+		}
+		
+		idx += 8;
+		++pos;
+	}
+	
+	/* If idx < max, some free bit found */
+	if (idx < max) {
+		/* Check which bit from byte is free */
+		for (uint8_t i = 0; i < 8; ++i) {
+			if ((*pos & (1 << i)) == 0) {
+				/* Free bit found */
+				*pos |= (1 << i);
+				
+				*index = idx;
+				return EOK;
+			}
+			
+			idx++;
+		}
+	}
+	
+	/* Free bit not found */
+	return ENOSPC;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_bitmap.h
===================================================================
--- uspace/lib/ext4/libext4_bitmap.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_bitmap.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_BITMAP_H_
+#define LIBEXT4_LIBEXT4_BITMAP_H_
+
+#include <sys/types.h>
+
+extern void ext4_bitmap_free_bit(uint8_t *, uint32_t);
+extern void ext4_bitmap_free_bits(uint8_t *, uint32_t, uint32_t);
+extern void ext4_bitmap_set_bit(uint8_t *, uint32_t);
+extern bool ext4_bitmap_is_free_bit(uint8_t *, uint32_t);
+extern int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *, uint32_t,
+    uint32_t *, uint32_t);
+extern int ext4_bitmap_find_free_bit_and_set(uint8_t *, uint32_t, uint32_t *,
+    uint32_t);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_block_group.c
===================================================================
--- uspace/lib/ext4/libext4_block_group.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_block_group.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_block_group.c
+ * @brief Ext4 block group structure operations.
+ */
+
+#include <byteorder.h>
+#include "libext4.h"
+
+/** Get address of block with data block bitmap.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Address of block with block bitmap
+ *
+ */
+uint64_t ext4_block_group_get_block_bitmap(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint64_t) uint32_t_le2host(bg->block_bitmap_hi) << 32) |
+		    uint32_t_le2host(bg->block_bitmap_lo);
+	else
+		return uint32_t_le2host(bg->block_bitmap_lo);
+}
+
+/** Set address of block with data block bitmap.
+ *
+ * @param bg           Pointer to block group
+ * @param sb           Pointer to superblock
+ * @param block_bitmap Address of block with block bitmap
+ *
+ */
+void ext4_block_group_set_block_bitmap(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint64_t block_bitmap)
+{
+	bg->block_bitmap_lo = host2uint32_t_le((block_bitmap << 32) >> 32);
+	
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->block_bitmap_hi = host2uint32_t_le(block_bitmap >> 32);
+}
+
+/** Get address of block with i-node bitmap.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Address of block with i-node bitmap
+ *
+ */
+uint64_t ext4_block_group_get_inode_bitmap(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint64_t) uint32_t_le2host(bg->inode_bitmap_hi) << 32) |
+		    uint32_t_le2host(bg->inode_bitmap_lo);
+	else
+		return uint32_t_le2host(bg->inode_bitmap_lo);
+}
+
+/** Set address of block with i-node bitmap.
+ *
+ * @param bg           Pointer to block group
+ * @param sb           Pointer to superblock
+ * @param inode_bitmap Address of block with i-node bitmap
+ *
+ */
+void ext4_block_group_set_inode_bitmap(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint64_t inode_bitmap)
+{
+	bg->inode_bitmap_lo = host2uint32_t_le((inode_bitmap << 32) >> 32);
+	
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->inode_bitmap_hi = host2uint32_t_le(inode_bitmap >> 32);
+}
+
+/** Get address of the first block of the i-node table.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Address of first block of i-node table
+ *
+ */
+uint64_t ext4_block_group_get_inode_table_first_block(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint64_t)
+		    uint32_t_le2host(bg->inode_table_first_block_hi) << 32) |
+		    uint32_t_le2host(bg->inode_table_first_block_lo);
+	else
+		return uint32_t_le2host(bg->inode_table_first_block_lo);
+}
+
+/** Set address of the first block of the i-node table.
+ *
+ * @param bg                Pointer to block group
+ * @param sb                Pointer to superblock
+ * @param inode_table_first Address of first block of i-node table
+ *
+ */
+void ext4_block_group_set_inode_table_first_block(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint64_t inode_table_first)
+{
+	bg->inode_table_first_block_lo =
+	    host2uint32_t_le((inode_table_first << 32) >> 32);
+	
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->inode_table_first_block_hi =
+		    host2uint32_t_le(inode_table_first >> 32);
+}
+
+/** Get number of free blocks in block group.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Number of free blocks in block group
+ *
+ */
+uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint32_t)
+		    uint16_t_le2host(bg->free_blocks_count_hi) << 16) |
+		    uint16_t_le2host(bg->free_blocks_count_lo);
+	else
+		return uint16_t_le2host(bg->free_blocks_count_lo);
+}
+
+/** Set number of free blocks in block group.
+ *
+ * @param bg    Pointer to block group
+ * @param sb    Pointer to superblock
+ * @param value Number of free blocks in block group
+ *
+ */
+void ext4_block_group_set_free_blocks_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint32_t value)
+{
+	bg->free_blocks_count_lo = host2uint16_t_le((value << 16) >> 16);
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->free_blocks_count_hi = host2uint16_t_le(value >> 16);
+}
+
+/** Get number of free i-nodes in block group.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Number of free i-nodes in block group
+ *
+ */
+uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint32_t)
+		    uint16_t_le2host(bg->free_inodes_count_hi) << 16) |
+		    uint16_t_le2host(bg->free_inodes_count_lo);
+	else
+		return uint16_t_le2host(bg->free_inodes_count_lo);
+}
+
+/** Set number of free i-nodes in block group.
+ *
+ * @param bg    Pointer to block group
+ * @param sb    Pointer to superblock
+ * @param value Number of free i-nodes in block group
+ *
+ */
+void ext4_block_group_set_free_inodes_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint32_t value)
+{
+	bg->free_inodes_count_lo = host2uint16_t_le((value << 16) >> 16);
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->free_inodes_count_hi = host2uint16_t_le(value >> 16);
+}
+
+/** Get number of used directories in block group.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Number of used directories in block group
+ *
+ */
+uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint32_t)
+		    uint16_t_le2host(bg->used_dirs_count_hi) << 16) |
+		    uint16_t_le2host(bg->used_dirs_count_lo);
+	else
+		return uint16_t_le2host(bg->used_dirs_count_lo);
+}
+
+/** Set number of used directories in block group.
+ *
+ * @param bg    Pointer to block group
+ * @param sb    Pointer to superblock
+ * @param value Number of used directories in block group
+ *
+ */
+void ext4_block_group_set_used_dirs_count(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint32_t count)
+{
+	bg->used_dirs_count_lo = host2uint16_t_le((count << 16) >> 16);
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->used_dirs_count_hi = host2uint16_t_le(count >> 16);
+}
+
+/** Get flags of block group.
+ *
+ * @param bg Pointer to block group
+ *
+ * @return Flags of block group
+ *
+ */
+uint16_t ext4_block_group_get_flags(ext4_block_group_t *bg)
+{
+	return uint16_t_le2host(bg->flags);
+}
+
+/** Set flags for block group.
+ *
+ * @param bg    Pointer to block group
+ * @param flags Flags for block group
+ *
+ */
+void ext4_block_group_set_flags(ext4_block_group_t *bg, uint16_t flags)
+{
+	bg->flags = host2uint16_t_le(flags);
+}
+
+/** Get number of unused i-nodes.
+ *
+ * @param bg Pointer to block group
+ * @param sb Pointer to superblock
+ *
+ * @return Number of unused i-nodes
+ *
+ */
+uint32_t ext4_block_group_get_itable_unused(ext4_block_group_t *bg,
+    ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ((uint32_t)
+		    uint16_t_le2host(bg->itable_unused_hi) << 16) |
+		    uint16_t_le2host(bg->itable_unused_lo);
+	else
+		return uint16_t_le2host(bg->itable_unused_lo);
+}
+
+/** Set number of unused i-nodes.
+ *
+ * @param bg    Pointer to block group
+ * @param sb    Pointer to superblock
+ * @param value Number of unused i-nodes
+ *
+ */
+void ext4_block_group_set_itable_unused(ext4_block_group_t *bg,
+    ext4_superblock_t *sb, uint32_t value)
+{
+	bg->itable_unused_lo = host2uint16_t_le((value << 16) >> 16);
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		bg->itable_unused_hi = host2uint16_t_le(value >> 16);
+}
+
+/** Get checksum of block group.
+ *
+ * @param bg Pointer to block group
+ *
+ * @return checksum of block group
+ *
+ */
+uint16_t ext4_block_group_get_checksum(ext4_block_group_t *bg)
+{
+	return uint16_t_le2host(bg->checksum);
+}
+
+/** Set checksum of block group.
+ *
+ * @param bg       Pointer to block group
+ * @param checksum Cheksum of block group
+ *
+ */
+void ext4_block_group_set_checksum(ext4_block_group_t *bg, uint16_t checksum)
+{
+	bg->checksum = host2uint16_t_le(checksum);
+}
+
+/** Check if block group has a flag.
+ *
+ * @param bg   Pointer to block group
+ * @param flag Flag to be checked
+ *
+ * @return True if flag is set to 1
+ *
+ */
+bool ext4_block_group_has_flag(ext4_block_group_t *bg, uint32_t flag)
+{
+	if (ext4_block_group_get_flags(bg) & flag)
+		return true;
+	
+	return false;
+}
+
+/** Set (add) flag of block group.
+ *
+ * @param bg   Pointer to block group
+ * @param flag Flag to be set
+ *
+ */
+void ext4_block_group_set_flag(ext4_block_group_t *bg, uint32_t set_flag)
+{
+	uint32_t flags = ext4_block_group_get_flags(bg);
+	flags = flags | set_flag;
+	ext4_block_group_set_flags(bg, flags);
+}
+
+/** Clear (remove) flag of block group.
+ *
+ * @param bg   Pointer to block group
+ * @param flag Flag to be cleared
+ *
+ */
+void ext4_block_group_clear_flag(ext4_block_group_t *bg, uint32_t clear_flag)
+{
+	uint32_t flags = ext4_block_group_get_flags(bg);
+	flags = flags & (~clear_flag);
+	ext4_block_group_set_flags(bg, flags);
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_block_group.h
===================================================================
--- uspace/lib/ext4/libext4_block_group.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_block_group.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_BLOCK_GROUP_H_
+#define LIBEXT4_LIBEXT4_BLOCK_GROUP_H_
+
+#include <libblock.h>
+#include <sys/types.h>
+#include "libext4_types.h"
+
+extern uint64_t ext4_block_group_get_block_bitmap(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_block_bitmap(ext4_block_group_t *,
+    ext4_superblock_t *, uint64_t);
+extern uint64_t ext4_block_group_get_inode_bitmap(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_inode_bitmap(ext4_block_group_t *,
+    ext4_superblock_t *, uint64_t);
+extern uint64_t ext4_block_group_get_inode_table_first_block(
+    ext4_block_group_t *, ext4_superblock_t *);
+extern void ext4_block_group_set_inode_table_first_block(ext4_block_group_t *,
+    ext4_superblock_t *, uint64_t);
+extern uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_free_blocks_count(ext4_block_group_t *,
+    ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_free_inodes_count(ext4_block_group_t *,
+    ext4_superblock_t *, uint32_t);
+extern void ext4_block_group_set_free_inodes_count(ext4_block_group_t *,
+    ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_used_dirs_count(ext4_block_group_t *,
+    ext4_superblock_t *, uint32_t);
+extern uint16_t ext4_block_group_get_flags(ext4_block_group_t *);
+extern void ext4_block_group_set_flags(ext4_block_group_t *, uint16_t);
+extern uint32_t ext4_block_group_get_itable_unused(ext4_block_group_t *,
+    ext4_superblock_t *);
+extern void ext4_block_group_set_itable_unused(ext4_block_group_t *,
+    ext4_superblock_t *, uint32_t);
+extern uint16_t ext4_block_group_get_checksum(ext4_block_group_t *);
+extern void ext4_block_group_set_checksum(ext4_block_group_t *, uint16_t);
+
+extern bool ext4_block_group_has_flag(ext4_block_group_t *, uint32_t);
+extern void ext4_block_group_set_flag(ext4_block_group_t *, uint32_t);
+extern void ext4_block_group_clear_flag(ext4_block_group_t *, uint32_t);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_crc.c
===================================================================
--- uspace/lib/ext4/libext4_crc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_crc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+/**
+ * @file  libext4_crc.c
+ * @brief CRC checksumming implementation from Linux.
+ */
+
+#include <byteorder.h>
+#include "libext4.h"
+
+/** CRC table for the CRC-16.
+ *
+ * The poly is 0x8005 (x^16 + x^15 + x^2 + 1).
+ *
+ */
+uint16_t const crc16_table[256] = {
+	0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
+	0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
+	0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
+	0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
+	0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
+	0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
+	0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
+	0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
+	0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
+	0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
+	0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
+	0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
+	0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
+	0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
+	0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
+	0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
+	0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
+	0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
+	0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
+	0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
+	0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
+	0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
+	0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
+	0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
+	0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
+	0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
+	0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
+	0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
+	0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
+	0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
+	0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
+	0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+};
+
+/** Modify CRC value.
+ *
+ * @param crc   Current CRC value
+ * @param data  New byte of data to be "added" to CRC
+ *
+ * @return Updated CRC value
+ *
+ */
+static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data)
+{
+	return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
+}
+
+/** Compute the CRC-16 for the data buffer.
+ *
+ * @param crc    Previous CRC value
+ * @param buffer Data pointer
+ * @param len    Number of bytes in the buffer
+ *
+ * @return Updated CRC value
+ *
+ */
+uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len)
+{
+	while (len--)
+		crc = crc16_byte(crc, *buffer++);
+	
+	return crc;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_crc.h
===================================================================
--- uspace/lib/ext4/libext4_crc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_crc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_CRC_H_
+#define LIBEXT4_LIBEXT4_CRC_H_
+
+extern uint16_t crc16(uint16_t, const uint8_t *, size_t);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_directory.c
===================================================================
--- uspace/lib/ext4/libext4_directory.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_directory.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,765 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_directory.c
+ * @brief Ext4 directory structure operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <malloc.h>
+#include "libext4.h"
+
+/** Get i-node number from directory entry.
+ *
+ * @param de Directory entry
+ *
+ * @return I-node number
+ *
+ */
+uint32_t ext4_directory_entry_ll_get_inode(ext4_directory_entry_ll_t *de)
+{
+	return uint32_t_le2host(de->inode);
+}
+
+/** Set i-node number to directory entry.
+ *
+ * @param de    Directory entry
+ * @param inode I-node number
+ *
+ */
+void ext4_directory_entry_ll_set_inode(ext4_directory_entry_ll_t *de,
+    uint32_t inode)
+{
+	de->inode = host2uint32_t_le(inode);
+}
+
+/** Get directory entry length.
+ *
+ * @param de Directory entry
+ *
+ * @return Entry length
+ *
+ */
+uint16_t ext4_directory_entry_ll_get_entry_length(ext4_directory_entry_ll_t *de)
+{
+	return uint16_t_le2host(de->entry_length);
+}
+
+/** Set directory entry length.
+ *
+ * @param de     Directory entry
+ * @param length Entry length
+ *
+ */
+void ext4_directory_entry_ll_set_entry_length(ext4_directory_entry_ll_t *de,
+    uint16_t length)
+{
+	de->entry_length = host2uint16_t_le(length);
+}
+
+/** Get directory entry name length.
+ *
+ * @param sb Superblock
+ * @param de Directory entry
+ *
+ * @return Entry name length
+ *
+ */
+uint16_t ext4_directory_entry_ll_get_name_length(ext4_superblock_t *sb,
+    ext4_directory_entry_ll_t *de)
+{
+	if ((ext4_superblock_get_rev_level(sb) == 0) &&
+	    (ext4_superblock_get_minor_rev_level(sb) < 5))
+		return ((uint16_t)de->name_length_high) << 8 |
+		    ((uint16_t)de->name_length);
+	
+	return de->name_length;
+
+}
+
+/** Set directory entry name length.
+ *
+ * @param sb     Superblock
+ * @param de     Directory entry
+ * @param length Entry name length
+ *
+ */
+void ext4_directory_entry_ll_set_name_length(ext4_superblock_t *sb,
+    ext4_directory_entry_ll_t *de, uint16_t length)
+{
+	de->name_length = (length << 8) >> 8;
+	
+	if ((ext4_superblock_get_rev_level(sb) == 0) &&
+	    (ext4_superblock_get_minor_rev_level(sb) < 5))
+		de->name_length_high = length >> 8;
+	
+	/* Else do nothing */
+}
+
+/** Get i-node type of directory entry.
+ *
+ * @param sb Superblock
+ * @param de Directory entry
+ *
+ * @return I-node type (file, dir, etc.)
+ *
+ */
+uint8_t ext4_directory_entry_ll_get_inode_type(ext4_superblock_t *sb,
+    ext4_directory_entry_ll_t *de)
+{
+	if ((ext4_superblock_get_rev_level(sb) > 0) ||
+	    (ext4_superblock_get_minor_rev_level(sb) >= 5))
+		return de->inode_type;
+	
+	return EXT4_DIRECTORY_FILETYPE_UNKNOWN;
+}
+
+/** Set i-node type of directory entry.
+ *
+ * @param sb   Superblock
+ * @param de   Directory entry
+ * @param type I-node type (file, dir, etc.)
+ *
+ */
+void ext4_directory_entry_ll_set_inode_type(ext4_superblock_t *sb,
+    ext4_directory_entry_ll_t *de, uint8_t type)
+{
+	if ((ext4_superblock_get_rev_level(sb) > 0) ||
+	    (ext4_superblock_get_minor_rev_level(sb) >= 5))
+		de->inode_type = type;
+	
+	/* Else do nothing */
+}
+
+static int ext4_directory_iterator_seek(ext4_directory_iterator_t *, aoff64_t);
+static int ext4_directory_iterator_set(ext4_directory_iterator_t *, uint32_t);
+
+/** Initialize directory iterator.
+ *
+ * Set position to the first valid entry from the required position.
+ *
+ * @param it        Pointer to iterator to be initialized
+ * @param inode_ref Directory i-node
+ * @param pos       Position to start reading entries from
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_iterator_init(ext4_directory_iterator_t *it,
+    ext4_inode_ref_t *inode_ref, aoff64_t pos)
+{
+	it->inode_ref = inode_ref;
+	it->current = NULL;
+	it->current_offset = 0;
+	it->current_block = NULL;
+	
+	return ext4_directory_iterator_seek(it, pos);
+}
+
+/** Jump to the next valid entry
+ *
+ * @param it Initialized iterator
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_iterator_next(ext4_directory_iterator_t *it)
+{
+	assert(it->current != NULL);
+	
+	uint16_t skip = ext4_directory_entry_ll_get_entry_length(it->current);
+	
+	return ext4_directory_iterator_seek(it, it->current_offset + skip);
+}
+
+/** Seek to next valid directory entry.
+ *
+ * Here can be jumped to the next data block.
+ *
+ * @param it  Initialized iterator
+ * @param pos Position of the next entry
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_iterator_seek(ext4_directory_iterator_t *it, aoff64_t pos)
+{
+	uint64_t size = ext4_inode_get_size(it->inode_ref->fs->superblock,
+	    it->inode_ref->inode);
+	
+	/* The iterator is not valid until we seek to the desired position */
+	it->current = NULL;
+	
+	/* Are we at the end? */
+	if (pos >= size) {
+		if (it->current_block) {
+			int rc = block_put(it->current_block);
+			it->current_block = NULL;
+			
+			if (rc != EOK)
+				return rc;
+		}
+		
+		it->current_offset = pos;
+		return EOK;
+	}
+	
+	/* Compute next block address */
+	uint32_t block_size =
+	    ext4_superblock_get_block_size(it->inode_ref->fs->superblock);
+	aoff64_t current_block_idx = it->current_offset / block_size;
+	aoff64_t next_block_idx = pos / block_size;
+	
+	/*
+	 * If we don't have a block or are moving accross block boundary,
+	 * we need to get another block
+	 */
+	if ((it->current_block == NULL) ||
+	    (current_block_idx != next_block_idx)) {
+		if (it->current_block) {
+			int rc = block_put(it->current_block);
+			it->current_block = NULL;
+			
+			if (rc != EOK)
+				return rc;
+		}
+		
+		uint32_t next_block_phys_idx;
+		int rc = ext4_filesystem_get_inode_data_block_index(it->inode_ref,
+		    next_block_idx, &next_block_phys_idx);
+		if (rc != EOK)
+			return rc;
+		
+		rc = block_get(&it->current_block, it->inode_ref->fs->device,
+		    next_block_phys_idx, BLOCK_FLAGS_NONE);
+		if (rc != EOK) {
+			it->current_block = NULL;
+			return rc;
+		}
+	}
+	
+	it->current_offset = pos;
+	
+	return ext4_directory_iterator_set(it, block_size);
+}
+
+/** Do some checks before returning iterator.
+ *
+ * @param it         Iterator to be checked
+ * @param block_size Size of data block
+ *
+ * @return Error code
+ *
+ */
+static int ext4_directory_iterator_set(ext4_directory_iterator_t *it,
+    uint32_t block_size)
+{
+	it->current = NULL;
+	
+	uint32_t offset_in_block = it->current_offset % block_size;
+	
+	/* Ensure proper alignment */
+	if ((offset_in_block % 4) != 0)
+		return EIO;
+	
+	/* Ensure that the core of the entry does not overflow the block */
+	if (offset_in_block > block_size - 8)
+		return EIO;
+	
+	ext4_directory_entry_ll_t *entry =
+	    it->current_block->data + offset_in_block;
+	
+	/* Ensure that the whole entry does not overflow the block */
+	uint16_t length = ext4_directory_entry_ll_get_entry_length(entry);
+	if (offset_in_block + length > block_size)
+		return EIO;
+	
+	/* Ensure the name length is not too large */
+	if (ext4_directory_entry_ll_get_name_length(
+	    it->inode_ref->fs->superblock, entry) > length-8)
+		return EIO;
+	
+	/* Everything OK - "publish" the entry */
+	it->current = entry;
+	return EOK;
+}
+
+/** Uninitialize directory iterator.
+ *
+ * Release all allocated structures.
+ *
+ * @param it Iterator to be finished
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_iterator_fini(ext4_directory_iterator_t *it)
+{
+	it->inode_ref = NULL;
+	it->current = NULL;
+	
+	if (it->current_block)
+		return block_put(it->current_block);
+	
+	return EOK;
+}
+
+/** Write directory entry to concrete data block.
+ *
+ * @param sb        Superblock
+ * @param entry     Pointer to entry to be written
+ * @param entry_len Length of new entry
+ * @param child     Child i-node to be written to new entry
+ * @param name      Name of the new entry
+ * @param name_len  Length of entry name
+ *
+ */
+void ext4_directory_write_entry(ext4_superblock_t *sb,
+    ext4_directory_entry_ll_t *entry, uint16_t entry_len,
+    ext4_inode_ref_t *child, const char *name, size_t name_len)
+{
+	/* Check maximum entry length */
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	assert(entry_len <= block_size);
+	
+	/* Set basic attributes */
+	ext4_directory_entry_ll_set_inode(entry, child->index);
+	ext4_directory_entry_ll_set_entry_length(entry, entry_len);
+	ext4_directory_entry_ll_set_name_length(sb, entry, name_len);
+	
+	/* Write name */
+	memcpy(entry->name, name, name_len);
+	
+	/* Set type of entry */
+	if (ext4_inode_is_type(sb, child->inode, EXT4_INODE_MODE_DIRECTORY))
+		ext4_directory_entry_ll_set_inode_type(sb, entry,
+		    EXT4_DIRECTORY_FILETYPE_DIR);
+	else
+		ext4_directory_entry_ll_set_inode_type(sb, entry,
+		    EXT4_DIRECTORY_FILETYPE_REG_FILE);
+}
+
+/** Add new entry to the directory.
+ *
+ * @param parent Directory i-node
+ * @param name   Name of new entry
+ * @param child  I-node to be referenced from new entry
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_add_entry(ext4_inode_ref_t *parent, const char *name,
+    ext4_inode_ref_t *child)
+{
+	ext4_filesystem_t *fs = parent->fs;
+	
+	/* Index adding (if allowed) */
+	if ((ext4_superblock_has_feature_compatible(fs->superblock,
+	    EXT4_FEATURE_COMPAT_DIR_INDEX)) &&
+	    (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
+		int rc = ext4_directory_dx_add_entry(parent, child, name);
+		
+		/* Check if index is not corrupted */
+		if (rc != EXT4_ERR_BAD_DX_DIR) {
+			if (rc != EOK)
+				return rc;
+			
+			return EOK;
+		}
+		
+		/* Needed to clear dir index flag if corrupted */
+		ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX);
+		parent->dirty = true;
+	}
+	
+	/* Linear algorithm */
+	
+	uint32_t iblock = 0;
+	uint32_t fblock = 0;
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
+	uint32_t inode_size = ext4_inode_get_size(fs->superblock, parent->inode);
+	uint32_t total_blocks = inode_size / block_size;
+	
+	uint32_t name_len = str_size(name);
+	
+	/* Find block, where is space for new entry and try to add */
+	bool success = false;
+	for (iblock = 0; iblock < total_blocks; ++iblock) {
+		int rc = ext4_filesystem_get_inode_data_block_index(parent,
+		    iblock, &fblock);
+		if (rc != EOK)
+			return rc;
+		
+		block_t *block;
+		rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		/* If adding is successful, function can finish */
+		rc = ext4_directory_try_insert_entry(fs->superblock, block,
+		    child, name, name_len);
+		if (rc == EOK)
+			success = true;
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+		
+		if (success)
+			return EOK;
+	}
+	
+	/* No free block found - needed to allocate next data block */
+	
+	iblock = 0;
+	fblock = 0;
+	int rc = ext4_filesystem_append_inode_block(parent, &fblock, &iblock);
+	if (rc != EOK)
+		return rc;
+	
+	/* Load new block */
+	block_t *new_block;
+	rc = block_get(&new_block, fs->device, fblock, BLOCK_FLAGS_NOREAD);
+	if (rc != EOK)
+		return rc;
+	
+	/* Fill block with zeroes */
+	memset(new_block->data, 0, block_size);
+	ext4_directory_entry_ll_t *block_entry = new_block->data;
+	ext4_directory_write_entry(fs->superblock, block_entry, block_size,
+	    child, name, name_len);
+	
+	/* Save new block */
+	new_block->dirty = true;
+	rc = block_put(new_block);
+	
+	return rc;
+}
+
+/** Find directory entry with passed name.
+ *
+ * @param result Result structure to be returned if entry found
+ * @param parent Directory i-node
+ * @param name   Name of entry to be found
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_find_entry(ext4_directory_search_result_t *result,
+    ext4_inode_ref_t *parent, const char *name)
+{
+	uint32_t name_len = str_size(name);
+	
+	ext4_superblock_t *sb = parent->fs->superblock;
+	
+	/* Index search */
+	if ((ext4_superblock_has_feature_compatible(sb,
+	    EXT4_FEATURE_COMPAT_DIR_INDEX)) &&
+	    (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
+		int rc = ext4_directory_dx_find_entry(result, parent, name_len,
+		    name);
+		
+		/* Check if index is not corrupted */
+		if (rc != EXT4_ERR_BAD_DX_DIR) {
+			if (rc != EOK)
+				return rc;
+			
+			return EOK;
+		}
+		
+		/* Needed to clear dir index flag if corrupted */
+		ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX);
+		parent->dirty = true;
+	}
+	
+	/* Linear algorithm */
+	
+	uint32_t iblock;
+	uint32_t fblock;
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint32_t inode_size = ext4_inode_get_size(sb, parent->inode);
+	uint32_t total_blocks = inode_size / block_size;
+	
+	/* Walk through all data blocks */
+	for (iblock = 0; iblock < total_blocks; ++iblock) {
+		/* Load block address */
+		int rc = ext4_filesystem_get_inode_data_block_index(parent, iblock,
+		    &fblock);
+		if (rc != EOK)
+			return rc;
+		
+		/* Load data block */
+		block_t *block;
+		rc = block_get(&block, parent->fs->device, fblock, BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		/* Try to find entry in block */
+		ext4_directory_entry_ll_t *res_entry;
+		rc = ext4_directory_find_in_block(block, sb, name_len, name,
+		    &res_entry);
+		if (rc == EOK) {
+			result->block = block;
+			result->dentry = res_entry;
+			return EOK;
+		}
+		
+		/* Entry not found - put block and continue to the next block */
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+	}
+	
+	/* Entry was not found */
+	
+	result->block = NULL;
+	result->dentry =  NULL;
+	
+	return ENOENT;
+}
+
+/** Remove directory entry.
+ *
+ * @param parent Directory i-node
+ * @param name   Name of the entry to be removed
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_remove_entry(ext4_inode_ref_t *parent, const char *name)
+{
+	/* Check if removing from directory */
+	if (!ext4_inode_is_type(parent->fs->superblock, parent->inode,
+	    EXT4_INODE_MODE_DIRECTORY))
+		return ENOTDIR;
+	
+	/* Try to find entry */
+	ext4_directory_search_result_t result;
+	int rc = ext4_directory_find_entry(&result, parent, name);
+	if (rc != EOK)
+		return rc;
+	
+	/* Invalidate entry */
+	ext4_directory_entry_ll_set_inode(result.dentry, 0);
+	
+	/* Store entry position in block */
+	uint32_t pos = (void *) result.dentry - result.block->data;
+	
+	/*
+	 * If entry is not the first in block, it must be merged
+	 * with previous entry
+	 */
+	if (pos != 0) {
+		uint32_t offset = 0;
+		
+		/* Start from the first entry in block */
+		ext4_directory_entry_ll_t *tmp_dentry = result.block->data;
+		uint16_t tmp_dentry_length =
+		    ext4_directory_entry_ll_get_entry_length(tmp_dentry);
+		
+		/* Find direct predecessor of removed entry */
+		while ((offset + tmp_dentry_length) < pos) {
+			offset +=
+			    ext4_directory_entry_ll_get_entry_length(tmp_dentry);
+			tmp_dentry = result.block->data + offset;
+			tmp_dentry_length =
+			    ext4_directory_entry_ll_get_entry_length(tmp_dentry);
+		}
+		
+		assert(tmp_dentry_length + offset == pos);
+		
+		/* Add to removed entry length to predecessor's length */
+		uint16_t del_entry_length =
+		    ext4_directory_entry_ll_get_entry_length(result.dentry);
+		ext4_directory_entry_ll_set_entry_length(tmp_dentry,
+		    tmp_dentry_length + del_entry_length);
+	}
+	
+	result.block->dirty = true;
+	
+	return ext4_directory_destroy_result(&result);
+}
+
+/** Try to insert entry to concrete data block.
+ *
+ * @param sb           Superblock
+ * @param target_block Block to try to insert entry to
+ * @param child        Child i-node to be inserted by new entry
+ * @param name         Name of the new entry
+ * @param name_len     Length of the new entry name
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_try_insert_entry(ext4_superblock_t *sb,
+    block_t *target_block, ext4_inode_ref_t *child, const char *name,
+    uint32_t name_len)
+{
+	/* Compute required length entry and align it to 4 bytes */
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint16_t required_len = sizeof(ext4_fake_directory_entry_t) + name_len;
+	
+	if ((required_len % 4) != 0)
+		required_len += 4 - (required_len % 4);
+	
+	/* Initialize pointers, stop means to upper bound */
+	ext4_directory_entry_ll_t *dentry = target_block->data;
+	ext4_directory_entry_ll_t *stop = target_block->data + block_size;
+	
+	/*
+	 * Walk through the block and check for invalid entries
+	 * or entries with free space for new entry
+	 */
+	while (dentry < stop) {
+		uint32_t inode = ext4_directory_entry_ll_get_inode(dentry);
+		uint16_t rec_len = ext4_directory_entry_ll_get_entry_length(dentry);
+		
+		/* If invalid and large enough entry, use it */
+		if ((inode == 0) && (rec_len >= required_len)) {
+			ext4_directory_write_entry(sb, dentry, rec_len, child,
+			    name, name_len);
+			target_block->dirty = true;
+			
+			return EOK;
+		}
+		
+		/* Valid entry, try to split it */
+		if (inode != 0) {
+			uint16_t used_name_len =
+			    ext4_directory_entry_ll_get_name_length(sb, dentry);
+			
+			uint16_t used_space =
+			    sizeof(ext4_fake_directory_entry_t) + used_name_len;
+			
+			if ((used_name_len % 4) != 0)
+				used_space += 4 - (used_name_len % 4);
+			
+			uint16_t free_space = rec_len - used_space;
+			
+			/* There is free space for new entry */
+			if (free_space >= required_len) {
+				/* Cut tail of current entry */
+				ext4_directory_entry_ll_set_entry_length(dentry, used_space);
+				ext4_directory_entry_ll_t *new_entry =
+				    (void *) dentry + used_space;
+				ext4_directory_write_entry(sb, new_entry,
+				    free_space, child, name, name_len);
+				
+				target_block->dirty = true;
+				
+				return EOK;
+			}
+		}
+		
+		/* Jump to the next entry */
+		dentry = (void *) dentry + rec_len;
+	}
+	
+	/* No free space found for new entry */
+	return ENOSPC;
+}
+
+/** Try to find entry in block by name.
+ *
+ * @param block     Block containing entries
+ * @param sb        Superblock
+ * @param name_len  Length of entry name
+ * @param name      Name of entry to be found
+ * @param res_entry Output pointer to found entry, NULL if not found
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_find_in_block(block_t *block, ext4_superblock_t *sb,
+    size_t name_len, const char *name, ext4_directory_entry_ll_t **res_entry)
+{
+	/* Start from the first entry in block */
+	ext4_directory_entry_ll_t *dentry =
+	    (ext4_directory_entry_ll_t *) block->data;
+	
+	/* Set upper bound for cycling */
+	uint8_t *addr_limit = block->data + ext4_superblock_get_block_size(sb);
+	
+	/* Walk through the block and check entries */
+	while ((uint8_t *) dentry < addr_limit) {
+		/* Termination condition */
+		if ((uint8_t *) dentry + name_len > addr_limit)
+			break;
+		
+		/* Valid entry - check it */
+		if (dentry->inode != 0) {
+			/* For more effectivity compare firstly only lengths */
+			if (ext4_directory_entry_ll_get_name_length(sb, dentry) ==
+			    name_len) {
+				/* Compare names */
+				if (bcmp((uint8_t *) name, dentry->name, name_len) == 0) {
+					*res_entry = dentry;
+					return EOK;
+				}
+			}
+		}
+		
+		uint16_t dentry_len =
+		    ext4_directory_entry_ll_get_entry_length(dentry);
+		
+		/* Corrupted entry */
+		if (dentry_len == 0)
+			return EINVAL;
+		
+		/* Jump to next entry */
+		dentry = (ext4_directory_entry_ll_t *) ((uint8_t *) dentry + dentry_len);
+	}
+	
+	/* Entry not found */
+	return ENOENT;
+}
+
+/** Simple function to release allocated data from result.
+ *
+ * @param result Search result to destroy
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_destroy_result(ext4_directory_search_result_t *result)
+{
+	if (result->block)
+		return block_put(result->block);
+	
+	return EOK;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_directory.h
===================================================================
--- uspace/lib/ext4/libext4_directory.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_directory.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_DIRECTORY_H_
+#define LIBEXT4_LIBEXT4_DIRECTORY_H_
+
+#include "libext4_types.h"
+
+extern uint32_t ext4_directory_entry_ll_get_inode(ext4_directory_entry_ll_t *);
+extern void ext4_directory_entry_ll_set_inode(ext4_directory_entry_ll_t *,
+    uint32_t);
+extern uint16_t ext4_directory_entry_ll_get_entry_length(
+    ext4_directory_entry_ll_t *);
+extern void ext4_directory_entry_ll_set_entry_length(ext4_directory_entry_ll_t *,
+    uint16_t);
+extern uint16_t ext4_directory_entry_ll_get_name_length(ext4_superblock_t *,
+    ext4_directory_entry_ll_t *);
+extern void ext4_directory_entry_ll_set_name_length(ext4_superblock_t *,
+    ext4_directory_entry_ll_t *, uint16_t);
+extern uint8_t ext4_directory_entry_ll_get_inode_type(ext4_superblock_t *,
+    ext4_directory_entry_ll_t *);
+extern void ext4_directory_entry_ll_set_inode_type(ext4_superblock_t *,
+    ext4_directory_entry_ll_t *, uint8_t);
+
+extern int ext4_directory_iterator_init(ext4_directory_iterator_t *,
+    ext4_inode_ref_t *, aoff64_t);
+extern int ext4_directory_iterator_next(ext4_directory_iterator_t *);
+extern int ext4_directory_iterator_fini(ext4_directory_iterator_t *);
+
+extern void ext4_directory_write_entry(ext4_superblock_t *,
+    ext4_directory_entry_ll_t *, uint16_t, ext4_inode_ref_t *,
+    const char *, size_t);
+extern int ext4_directory_add_entry(ext4_inode_ref_t *, const char *,
+    ext4_inode_ref_t *);
+extern int ext4_directory_find_entry(ext4_directory_search_result_t *,
+    ext4_inode_ref_t *, const char *);
+extern int ext4_directory_remove_entry(ext4_inode_ref_t *, const char *);
+
+extern int ext4_directory_try_insert_entry(ext4_superblock_t *, block_t *,
+    ext4_inode_ref_t *, const char *, uint32_t);
+
+extern int ext4_directory_find_in_block(block_t *, ext4_superblock_t *, size_t,
+    const char *, ext4_directory_entry_ll_t **);
+
+extern int ext4_directory_destroy_result(ext4_directory_search_result_t *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_directory_index.c
===================================================================
--- uspace/lib/ext4/libext4_directory_index.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_directory_index.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1159 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_directory_index.c
+ * @brief Ext4 directory index operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <malloc.h>
+#include <sort.h>
+#include "libext4.h"
+
+/** Type entry to pass to sorting algorithm.
+ *
+ */
+typedef struct ext4_dx_sort_entry {
+	uint32_t hash;
+	uint32_t rec_len;
+	void *dentry;
+} ext4_dx_sort_entry_t;
+
+/** Get hash version used in directory index.
+ *
+ * @param root_info Pointer to root info structure of index
+ *
+ * @return Hash algorithm version
+ *
+ */
+uint8_t ext4_directory_dx_root_info_get_hash_version(
+    ext4_directory_dx_root_info_t *root_info)
+{
+	return root_info->hash_version;
+}
+
+/** Set hash version, that will be used in directory index.
+ *
+ * @param root_info Pointer to root info structure of index
+ * @param version   Hash algorithm version
+ *
+ */
+void ext4_directory_dx_root_info_set_hash_version(
+    ext4_directory_dx_root_info_t *root_info, uint8_t version)
+{
+	root_info->hash_version = version;
+}
+
+/** Get length of root_info structure in bytes.
+ *
+ * @param root_info Pointer to root info structure of index
+ *
+ * @return Length of the structure
+ *
+ */
+uint8_t ext4_directory_dx_root_info_get_info_length(
+    ext4_directory_dx_root_info_t *root_info)
+{
+	return root_info->info_length;
+}
+
+/** Set length of root_info structure in bytes.
+ *
+ * @param root_info   Pointer to root info structure of index
+ * @param info_length Length of the structure
+ *
+ */
+void ext4_directory_dx_root_info_set_info_length(
+    ext4_directory_dx_root_info_t *root_info, uint8_t info_length)
+{
+	root_info->info_length = info_length;
+}
+
+/** Get number of indirect levels of HTree.
+ *
+ * @param root_info Pointer to root info structure of index
+ *
+ * @return Height of HTree (actually only 0 or 1)
+ *
+ */
+uint8_t ext4_directory_dx_root_info_get_indirect_levels(
+    ext4_directory_dx_root_info_t *root_info)
+{
+	return root_info->indirect_levels;
+}
+
+/** Set number of indirect levels of HTree.
+ *
+ * @param root_info Pointer to root info structure of index
+ * @param levels    Height of HTree (actually only 0 or 1)
+ *
+ */
+void ext4_directory_dx_root_info_set_indirect_levels(
+    ext4_directory_dx_root_info_t *root_info, uint8_t levels)
+{
+	root_info->indirect_levels = levels;
+}
+
+/** Get maximum number of index node entries.
+ *
+ * @param countlimit Pointer to counlimit structure
+ *
+ * @return Maximum of entries in node
+ *
+ */
+uint16_t ext4_directory_dx_countlimit_get_limit(
+    ext4_directory_dx_countlimit_t *countlimit)
+{
+	return uint16_t_le2host(countlimit->limit);
+}
+
+/** Set maximum number of index node entries.
+ *
+ * @param countlimit Pointer to counlimit structure
+ * @param limit      Maximum of entries in node
+ *
+ */
+void ext4_directory_dx_countlimit_set_limit(
+    ext4_directory_dx_countlimit_t *countlimit, uint16_t limit)
+{
+	countlimit->limit = host2uint16_t_le(limit);
+}
+
+/** Get current number of index node entries.
+ *
+ * @param countlimit Pointer to counlimit structure
+ *
+ * @return Number of entries in node
+ *
+ */
+uint16_t ext4_directory_dx_countlimit_get_count(
+    ext4_directory_dx_countlimit_t *countlimit)
+{
+	return uint16_t_le2host(countlimit->count);
+}
+
+/** Set current number of index node entries.
+ *
+ * @param countlimit Pointer to counlimit structure
+ * @param count      Number of entries in node
+ *
+ */
+void ext4_directory_dx_countlimit_set_count(
+    ext4_directory_dx_countlimit_t *countlimit, uint16_t count)
+{
+	countlimit->count = host2uint16_t_le(count);
+}
+
+/** Get hash value of index entry.
+ *
+ * @param entry Pointer to index entry
+ *
+ * @return Hash value
+ *
+ */
+uint32_t ext4_directory_dx_entry_get_hash(ext4_directory_dx_entry_t *entry)
+{
+	return uint32_t_le2host(entry->hash);
+}
+
+/** Set hash value of index entry.
+ *
+ * @param entry Pointer to index entry
+ * @param hash  Hash value
+ *
+ */
+void ext4_directory_dx_entry_set_hash(ext4_directory_dx_entry_t *entry,
+    uint32_t hash)
+{
+	entry->hash = host2uint32_t_le(hash);
+}
+
+/** Get block address where child node is located.
+ *
+ * @param entry Pointer to index entry
+ *
+ * @return Block address of child node
+ *
+ */
+uint32_t ext4_directory_dx_entry_get_block(ext4_directory_dx_entry_t *entry)
+{
+	return uint32_t_le2host(entry->block);
+}
+
+/** Set block address where child node is located.
+ *
+ * @param entry Pointer to index entry
+ * @param block Block address of child node
+ *
+ */
+void ext4_directory_dx_entry_set_block(ext4_directory_dx_entry_t *entry,
+    uint32_t block)
+{
+	entry->block = host2uint32_t_le(block);
+}
+
+/** Initialize index structure of new directory.
+ *
+ * @param dir Pointer to directory i-node
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_dx_init(ext4_inode_ref_t *dir)
+{
+	/* Load block 0, where will be index root located */
+	uint32_t fblock;
+	int rc = ext4_filesystem_get_inode_data_block_index(dir, 0,
+	    &fblock);
+	if (rc != EOK)
+		return rc;
+	
+	block_t *block;
+	rc = block_get(&block, dir->fs->device, fblock, BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		return rc;
+	
+	/* Initialize pointers to data structures */
+	ext4_directory_dx_root_t *root = block->data;
+	ext4_directory_dx_root_info_t *info = &(root->info);
+	
+	/* Initialize root info structure */
+	uint8_t hash_version =
+	    ext4_superblock_get_default_hash_version(dir->fs->superblock);
+	
+	ext4_directory_dx_root_info_set_hash_version(info, hash_version);
+	ext4_directory_dx_root_info_set_indirect_levels(info, 0);
+	ext4_directory_dx_root_info_set_info_length(info, 8);
+	
+	/* Set limit and current number of entries */
+	ext4_directory_dx_countlimit_t *countlimit =
+	    (ext4_directory_dx_countlimit_t *) &root->entries;
+	ext4_directory_dx_countlimit_set_count(countlimit, 1);
+	
+	uint32_t block_size =
+	    ext4_superblock_get_block_size(dir->fs->superblock);
+	uint32_t entry_space =
+	    block_size - 2 * sizeof(ext4_directory_dx_dot_entry_t) -
+	    sizeof(ext4_directory_dx_root_info_t);
+	uint16_t root_limit = entry_space / sizeof(ext4_directory_dx_entry_t);
+	ext4_directory_dx_countlimit_set_limit(countlimit, root_limit);
+	
+	/* Append new block, where will be new entries inserted in the future */
+	uint32_t iblock;
+	rc = ext4_filesystem_append_inode_block(dir, &fblock, &iblock);
+	if (rc != EOK) {
+		block_put(block);
+		return rc;
+	}
+	
+	block_t *new_block;
+	rc = block_get(&new_block, dir->fs->device, fblock, BLOCK_FLAGS_NOREAD);
+	if (rc != EOK) {
+		block_put(block);
+		return rc;
+	}
+	
+	/* Fill the whole block with empty entry */
+	ext4_directory_entry_ll_t *block_entry = new_block->data;
+	ext4_directory_entry_ll_set_entry_length(block_entry, block_size);
+	ext4_directory_entry_ll_set_inode(block_entry, 0);
+	
+	new_block->dirty = true;
+	rc = block_put(new_block);
+	if (rc != EOK) {
+		block_put(block);
+		return rc;
+	}
+	
+	/* Connect new block to the only entry in index */
+	ext4_directory_dx_entry_t *entry = root->entries;
+	ext4_directory_dx_entry_set_block(entry, iblock);
+	
+	block->dirty = true;
+	
+	return block_put(block);
+}
+
+/** Initialize hash info structure necessary for index operations.
+ *
+ * @param hinfo      Pointer to hinfo to be initialized
+ * @param root_block Root block (number 0) of index
+ * @param sb         Pointer to superblock
+ * @param name_len   Length of name to be computed hash value from
+ * @param name       Name to be computed hash value from
+ *
+ * @return Error code
+ *
+ */
+static int ext4_directory_hinfo_init(ext4_hash_info_t *hinfo,
+    block_t *root_block, ext4_superblock_t *sb, size_t name_len,
+    const char *name)
+{
+	ext4_directory_dx_root_t *root =
+	    (ext4_directory_dx_root_t *) root_block->data;
+	
+	if ((root->info.hash_version != EXT4_HASH_VERSION_TEA) &&
+	    (root->info.hash_version != EXT4_HASH_VERSION_HALF_MD4) &&
+	    (root->info.hash_version != EXT4_HASH_VERSION_LEGACY))
+		return EXT4_ERR_BAD_DX_DIR;
+	
+	/* Check unused flags */
+	if (root->info.unused_flags != 0)
+		return EXT4_ERR_BAD_DX_DIR;
+	
+	/* Check indirect levels */
+	if (root->info.indirect_levels > 1)
+		return EXT4_ERR_BAD_DX_DIR;
+	
+	/* Check if node limit is correct */
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint32_t entry_space = block_size;
+	entry_space -= 2 * sizeof(ext4_directory_dx_dot_entry_t);
+	entry_space -= sizeof(ext4_directory_dx_root_info_t);
+	entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
+	
+	uint16_t limit = ext4_directory_dx_countlimit_get_limit(
+	    (ext4_directory_dx_countlimit_t *) &root->entries);
+	if (limit != entry_space)
+		return EXT4_ERR_BAD_DX_DIR;
+	
+	/* Check hash version and modify if necessary */
+	hinfo->hash_version =
+	    ext4_directory_dx_root_info_get_hash_version(&root->info);
+	if ((hinfo->hash_version <= EXT4_HASH_VERSION_TEA) &&
+	    (ext4_superblock_has_flag(sb, EXT4_SUPERBLOCK_FLAGS_UNSIGNED_HASH))) {
+		/* 3 is magic from ext4 linux implementation */
+		hinfo->hash_version += 3;
+	}
+	
+	/* Load hash seed from superblock */
+	hinfo->seed = ext4_superblock_get_hash_seed(sb);
+	
+	/* Compute hash value of name */
+	if (name)
+		ext4_hash_string(hinfo, name_len, name);
+	
+	return EOK;
+}
+
+/** Walk through index tree and load leaf with corresponding hash value.
+ *
+ * @param hinfo      Initialized hash info structure
+ * @param inode_ref  Current i-node
+ * @param root_block Root block (iblock 0), where is root node located
+ * @param dx_block   Pointer to leaf node in dx_blocks array
+ * @param dx_blocks  Array with the whole path from root to leaf
+ *
+ * @return Error code
+ *
+ */
+static int ext4_directory_dx_get_leaf(ext4_hash_info_t *hinfo,
+    ext4_inode_ref_t *inode_ref, block_t *root_block,
+    ext4_directory_dx_block_t **dx_block, ext4_directory_dx_block_t *dx_blocks)
+{
+	ext4_directory_dx_block_t *tmp_dx_block = dx_blocks;
+	ext4_directory_dx_root_t *root =
+	    (ext4_directory_dx_root_t *) root_block->data;
+	ext4_directory_dx_entry_t *entries =
+	    (ext4_directory_dx_entry_t *) &root->entries;
+	
+	uint16_t limit = ext4_directory_dx_countlimit_get_limit(
+	    (ext4_directory_dx_countlimit_t *) entries);
+	uint8_t indirect_level =
+	    ext4_directory_dx_root_info_get_indirect_levels(&root->info);
+	
+	block_t *tmp_block = root_block;
+	ext4_directory_dx_entry_t *p;
+	ext4_directory_dx_entry_t *q;
+	ext4_directory_dx_entry_t *m;
+	ext4_directory_dx_entry_t *at;
+	
+	/* Walk through the index tree */
+	while (true) {
+		uint16_t count = ext4_directory_dx_countlimit_get_count(
+		    (ext4_directory_dx_countlimit_t *) entries);
+		if ((count == 0) || (count > limit))
+			return EXT4_ERR_BAD_DX_DIR;
+		
+		/* Do binary search in every node */
+		p = entries + 1;
+		q = entries + count - 1;
+		
+		while (p <= q) {
+			m = p + (q - p) / 2;
+			if (ext4_directory_dx_entry_get_hash(m) > hinfo->hash)
+				q = m - 1;
+			else
+				p = m + 1;
+		}
+		
+		at = p - 1;
+		
+		/* Write results */
+		tmp_dx_block->block = tmp_block;
+		tmp_dx_block->entries = entries;
+		tmp_dx_block->position = at;
+		
+		/* Is algorithm in the leaf? */
+		if (indirect_level == 0) {
+			*dx_block = tmp_dx_block;
+			return EOK;
+		}
+		
+		/* Goto child node */
+		uint32_t next_block = ext4_directory_dx_entry_get_block(at);
+		
+		indirect_level--;
+		
+		uint32_t fblock;
+		int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
+		    next_block, &fblock);
+		if (rc != EOK)
+			return rc;
+		
+		rc = block_get(&tmp_block, inode_ref->fs->device, fblock,
+		    BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		entries = ((ext4_directory_dx_node_t *) tmp_block->data)->entries;
+		limit = ext4_directory_dx_countlimit_get_limit(
+		    (ext4_directory_dx_countlimit_t *) entries);
+		
+		uint16_t entry_space =
+		    ext4_superblock_get_block_size(inode_ref->fs->superblock) -
+		    sizeof(ext4_directory_dx_dot_entry_t);
+		entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
+		
+		if (limit != entry_space) {
+			block_put(tmp_block);
+			return EXT4_ERR_BAD_DX_DIR;
+		}
+		
+		++tmp_dx_block;
+	}
+	
+	/* Unreachable */
+	return EOK;
+}
+
+/** Check if the the next block would be checked during entry search.
+ *
+ * @param inode_ref Directory i-node
+ * @param hash      Hash value to check
+ * @param dx_block  Current block
+ * @param dx_blocks Array with path from root to leaf node
+ *
+ * @return Error code
+ *
+ */
+static int ext4_directory_dx_next_block(ext4_inode_ref_t *inode_ref,
+    uint32_t hash, ext4_directory_dx_block_t *dx_block,
+    ext4_directory_dx_block_t *dx_blocks)
+{
+	uint32_t num_handles = 0;
+	ext4_directory_dx_block_t *p = dx_block;
+	
+	/* Try to find data block with next bunch of entries */
+	while (true) {
+		p->position++;
+		uint16_t count = ext4_directory_dx_countlimit_get_count(
+		    (ext4_directory_dx_countlimit_t *) p->entries);
+		
+		if (p->position < p->entries + count)
+			break;
+		
+		if (p == dx_blocks)
+			return EOK;
+		
+		num_handles++;
+		p--;
+	}
+	
+	/* Check hash collision (if not occured - no next block cannot be used) */
+	uint32_t current_hash = ext4_directory_dx_entry_get_hash(p->position);
+	if ((hash & 1) == 0) {
+		if ((current_hash & ~1) != hash)
+			return 0;
+	}
+	
+	/* Fill new path */
+	while (num_handles--) {
+		uint32_t block_idx =
+		    ext4_directory_dx_entry_get_block(p->position);
+		uint32_t block_addr;
+		
+		int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
+		    block_idx, &block_addr);
+		if (rc != EOK)
+			return rc;
+		
+		block_t *block;
+		rc = block_get(&block, inode_ref->fs->device, block_addr, BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		p++;
+		
+		/* Don't forget to put old block (prevent memory leak) */
+		block_put(p->block);
+		
+		p->block = block;
+		p->entries = ((ext4_directory_dx_node_t *) block->data)->entries;
+		p->position = p->entries;
+	}
+	
+	return ENOENT;
+}
+
+/** Try to find directory entry using directory index.
+ *
+ * @param result    Output value - if entry will be found,
+ *                  than will be passed through this parameter
+ * @param inode_ref Directory i-node
+ * @param name_len  Length of name to be found
+ * @param name      Name to be found
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_dx_find_entry(ext4_directory_search_result_t *result,
+    ext4_inode_ref_t *inode_ref, size_t name_len, const char *name)
+{
+	/* Load direct block 0 (index root) */
+	uint32_t root_block_addr;
+	int rc = ext4_filesystem_get_inode_data_block_index(inode_ref, 0,
+	    &root_block_addr);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_filesystem_t *fs = inode_ref->fs;
+	
+	block_t *root_block;
+	rc = block_get(&root_block, fs->device, root_block_addr,
+	    BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		return rc;
+	
+	/* Initialize hash info (compute hash value) */
+	ext4_hash_info_t hinfo;
+	rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock,
+	    name_len, name);
+	if (rc != EOK) {
+		block_put(root_block);
+		return EXT4_ERR_BAD_DX_DIR;
+	}
+	
+	/*
+	 * Hardcoded number 2 means maximum height of index tree,
+	 * specified in the Linux driver.
+	 */
+	ext4_directory_dx_block_t dx_blocks[2];
+	ext4_directory_dx_block_t *dx_block;
+	ext4_directory_dx_block_t *tmp;
+	
+	rc = ext4_directory_dx_get_leaf(&hinfo, inode_ref, root_block,
+	    &dx_block, dx_blocks);
+	if (rc != EOK) {
+		block_put(root_block);
+		return EXT4_ERR_BAD_DX_DIR;
+	}
+	
+	do {
+		/* Load leaf block */
+		uint32_t leaf_block_idx =
+		    ext4_directory_dx_entry_get_block(dx_block->position);
+		uint32_t leaf_block_addr;
+		
+		rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
+		    leaf_block_idx, &leaf_block_addr);
+		if (rc != EOK)
+			goto cleanup;
+		
+		block_t *leaf_block;
+		rc = block_get(&leaf_block, fs->device, leaf_block_addr,
+		    BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			goto cleanup;
+		
+		/* Linear search inside block */
+		ext4_directory_entry_ll_t *res_dentry;
+		rc = ext4_directory_find_in_block(leaf_block, fs->superblock,
+		    name_len, name, &res_dentry);
+		
+		/* Found => return it */
+		if (rc == EOK) {
+			result->block = leaf_block;
+			result->dentry = res_dentry;
+			goto cleanup;
+		}
+		
+		/* Not found, leave untouched */
+		block_put(leaf_block);
+		
+		if (rc != ENOENT)
+			goto cleanup;
+		
+		/* check if the next block could be checked */
+		rc = ext4_directory_dx_next_block(inode_ref, hinfo.hash,
+		    dx_block, &dx_blocks[0]);
+		if (rc < 0)
+			goto cleanup;
+	} while (rc == ENOENT);
+	
+	/* Entry not found */
+	rc = ENOENT;
+	
+cleanup:
+	/* The whole path must be released (preventing memory leak) */
+	tmp = dx_blocks;
+	
+	while (tmp <= dx_block) {
+		block_put(tmp->block);
+		++tmp;
+	}
+	
+	return rc;
+}
+
+/** Compare function used to pass in quicksort implementation.
+ *
+ * It can compare two entries by hash value.
+ *
+ * @param arg1  First entry
+ * @param arg2  Second entry
+ * @param dummy Unused parameter, can be NULL
+ *
+ * @return Classic compare result
+ *         (0: equal, -1: arg1 < arg2, 1: arg1 > arg2)
+ *
+ */
+static int ext4_directory_dx_entry_comparator(void *arg1, void *arg2, void *dummy)
+{
+	ext4_dx_sort_entry_t *entry1 = arg1;
+	ext4_dx_sort_entry_t *entry2 = arg2;
+	
+	if (entry1->hash == entry2->hash)
+		return 0;
+	
+	if (entry1->hash < entry2->hash)
+		return -1;
+	else
+		return 1;
+}
+
+/** Insert new index entry to block.
+ *
+ * Note that space for new entry must be checked by caller.
+ *
+ * @param index_block Block where to insert new entry
+ * @param hash        Hash value covered by child node
+ * @param iblock      Logical number of child block
+ *
+ */
+static void ext4_directory_dx_insert_entry(
+    ext4_directory_dx_block_t *index_block, uint32_t hash, uint32_t iblock)
+{
+	ext4_directory_dx_entry_t *old_index_entry = index_block->position;
+	ext4_directory_dx_entry_t *new_index_entry = old_index_entry + 1;
+	
+	ext4_directory_dx_countlimit_t *countlimit =
+	    (ext4_directory_dx_countlimit_t *) index_block->entries;
+	uint32_t count = ext4_directory_dx_countlimit_get_count(countlimit);
+	
+	ext4_directory_dx_entry_t *start_index = index_block->entries;
+	size_t bytes = (void *) (start_index + count) - (void *) (new_index_entry);
+	
+	memmove(new_index_entry + 1, new_index_entry, bytes);
+	
+	ext4_directory_dx_entry_set_block(new_index_entry, iblock);
+	ext4_directory_dx_entry_set_hash(new_index_entry, hash);
+	
+	ext4_directory_dx_countlimit_set_count(countlimit, count + 1);
+	
+	index_block->block->dirty = true;
+}
+
+/** Split directory entries to two parts preventing node overflow.
+ *
+ * @param inode_ref      Directory i-node
+ * @param hinfo          Hash info
+ * @param old_data_block Block with data to be split
+ * @param index_block    Block where index entries are located
+ * @param new_data_block Output value for newly allocated data block
+ *
+ */
+static int ext4_directory_dx_split_data(ext4_inode_ref_t *inode_ref,
+    ext4_hash_info_t *hinfo, block_t *old_data_block,
+    ext4_directory_dx_block_t *index_block, block_t **new_data_block)
+{
+	int rc = EOK;
+	
+	/* Allocate buffer for directory entries */
+	uint32_t block_size =
+	    ext4_superblock_get_block_size(inode_ref->fs->superblock);
+	void *entry_buffer = malloc(block_size);
+	if (entry_buffer == NULL)
+		return ENOMEM;
+	
+	/* dot entry has the smallest size available */
+	uint32_t max_entry_count =
+	    block_size / sizeof(ext4_directory_dx_dot_entry_t);
+	
+	/* Allocate sort entry */
+	ext4_dx_sort_entry_t *sort_array =
+	    malloc(max_entry_count * sizeof(ext4_dx_sort_entry_t));
+	if (sort_array == NULL) {
+		free(entry_buffer);
+		return ENOMEM;
+	}
+	
+	uint32_t idx = 0;
+	uint32_t real_size = 0;
+	
+	/* Initialize hinfo */
+	ext4_hash_info_t tmp_hinfo;
+	memcpy(&tmp_hinfo, hinfo, sizeof(ext4_hash_info_t));
+	
+	/* Load all valid entries to the buffer */
+	ext4_directory_entry_ll_t *dentry = old_data_block->data;
+	void *entry_buffer_ptr = entry_buffer;
+	while ((void *)dentry < old_data_block->data + block_size) {
+		/* Read only valid entries */
+		if (ext4_directory_entry_ll_get_inode(dentry) != 0) {
+			uint8_t len = ext4_directory_entry_ll_get_name_length(
+			    inode_ref->fs->superblock, dentry);
+			ext4_hash_string(&tmp_hinfo, len, (char *) dentry->name);
+			
+			uint32_t rec_len = 8 + len;
+			
+			if ((rec_len % 4) != 0)
+				rec_len += 4 - (rec_len % 4);
+			
+			memcpy(entry_buffer_ptr, dentry, rec_len);
+			
+			sort_array[idx].dentry = entry_buffer_ptr;
+			sort_array[idx].rec_len = rec_len;
+			sort_array[idx].hash = tmp_hinfo.hash;
+			
+			entry_buffer_ptr += rec_len;
+			real_size += rec_len;
+			idx++;
+		}
+		
+		dentry = (void *) dentry +
+		    ext4_directory_entry_ll_get_entry_length(dentry);
+	}
+	
+	/* Sort all entries */
+	qsort(sort_array, idx, sizeof(ext4_dx_sort_entry_t),
+	    ext4_directory_dx_entry_comparator, NULL);
+	
+	/* Allocate new block for store the second part of entries */
+	uint32_t new_fblock;
+	uint32_t new_iblock;
+	rc = ext4_filesystem_append_inode_block(inode_ref, &new_fblock,
+	    &new_iblock);
+	if (rc != EOK) {
+		free(sort_array);
+		free(entry_buffer);
+		return rc;
+	}
+	
+	/* Load new block */
+	block_t *new_data_block_tmp;
+	rc = block_get(&new_data_block_tmp, inode_ref->fs->device,
+	    new_fblock, BLOCK_FLAGS_NOREAD);
+	if (rc != EOK) {
+		free(sort_array);
+		free(entry_buffer);
+		return rc;
+	}
+	
+	/*
+	 * Distribute entries to two blocks (by size)
+	 * - compute the half
+	 */
+	uint32_t new_hash = 0;
+	uint32_t current_size = 0;
+	uint32_t mid = 0;
+	for (uint32_t i = 0; i < idx; ++i) {
+		if ((current_size + sort_array[i].rec_len) > (real_size / 2)) {
+			new_hash = sort_array[i].hash;
+			mid = i;
+			break;
+		}
+		
+		current_size += sort_array[i].rec_len;
+	}
+	
+	/* Check hash collision */
+	uint32_t continued = 0;
+	if (new_hash == sort_array[mid-1].hash)
+		continued = 1;
+	
+	uint32_t offset = 0;
+	void *ptr;
+	
+	/* First part - to the old block */
+	for (uint32_t i = 0; i < mid; ++i) {
+		ptr = old_data_block->data + offset;
+		memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len);
+		
+		ext4_directory_entry_ll_t *tmp = ptr;
+		if (i < (mid - 1))
+			ext4_directory_entry_ll_set_entry_length(tmp,
+			    sort_array[i].rec_len);
+		else
+			ext4_directory_entry_ll_set_entry_length(tmp,
+			    block_size - offset);
+		
+		offset += sort_array[i].rec_len;
+	}
+	
+	/* Second part - to the new block */
+	offset = 0;
+	for (uint32_t i = mid; i < idx; ++i) {
+		ptr = new_data_block_tmp->data + offset;
+		memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len);
+		
+		ext4_directory_entry_ll_t *tmp = ptr;
+		if (i < (idx - 1))
+			ext4_directory_entry_ll_set_entry_length(tmp,
+			    sort_array[i].rec_len);
+		else
+			ext4_directory_entry_ll_set_entry_length(tmp,
+			    block_size - offset);
+		
+		offset += sort_array[i].rec_len;
+	}
+	
+	/* Do some steps to finish operation */
+	old_data_block->dirty = true;
+	new_data_block_tmp->dirty = true;
+	
+	free(sort_array);
+	free(entry_buffer);
+	
+	ext4_directory_dx_insert_entry(index_block, new_hash + continued,
+	    new_iblock);
+	
+	*new_data_block = new_data_block_tmp;
+	
+	return EOK;
+}
+
+/** Split index node and maybe some parent nodes in the tree hierarchy.
+ *
+ * @param inode_ref Directory i-node
+ * @param dx_blocks Array with path from root to leaf node
+ * @param dx_block  Leaf block to be split if needed
+ *
+ * @return Error code
+ *
+ */
+static int ext4_directory_dx_split_index(ext4_inode_ref_t *inode_ref,
+		ext4_directory_dx_block_t *dx_blocks, ext4_directory_dx_block_t *dx_block)
+{
+	ext4_directory_dx_entry_t *entries;
+	if (dx_block == dx_blocks)
+		entries =
+		    ((ext4_directory_dx_root_t *) dx_block->block->data)->entries;
+	else
+		entries =
+		    ((ext4_directory_dx_node_t *) dx_block->block->data)->entries;
+	
+	ext4_directory_dx_countlimit_t *countlimit =
+	    (ext4_directory_dx_countlimit_t *) entries;
+	
+	uint16_t leaf_limit =
+	    ext4_directory_dx_countlimit_get_limit(countlimit);
+	uint16_t leaf_count =
+	    ext4_directory_dx_countlimit_get_count(countlimit);
+	
+	/* Check if is necessary to split index block */
+	if (leaf_limit == leaf_count) {
+		size_t levels = dx_block - dx_blocks;
+		
+		ext4_directory_dx_entry_t *root_entries =
+		    ((ext4_directory_dx_root_t *) dx_blocks[0].block->data)->entries;
+		
+		ext4_directory_dx_countlimit_t *root_countlimit =
+		    (ext4_directory_dx_countlimit_t *) root_entries;
+		uint16_t root_limit =
+		    ext4_directory_dx_countlimit_get_limit(root_countlimit);
+		uint16_t root_count =
+		    ext4_directory_dx_countlimit_get_count(root_countlimit);
+		
+		/* Linux limitation */
+		if ((levels > 0) && (root_limit == root_count))
+			return ENOSPC;
+		
+		/* Add new block to directory */
+		uint32_t new_fblock;
+		uint32_t new_iblock;
+		int rc = ext4_filesystem_append_inode_block(inode_ref,
+		    &new_fblock, &new_iblock);
+		if (rc != EOK)
+			return rc;
+		
+		/* load new block */
+		block_t *new_block;
+		rc = block_get(&new_block, inode_ref->fs->device,
+		    new_fblock, BLOCK_FLAGS_NOREAD);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_directory_dx_node_t *new_node = new_block->data;
+		ext4_directory_dx_entry_t *new_entries = new_node->entries;
+		
+		uint32_t block_size =
+		    ext4_superblock_get_block_size(inode_ref->fs->superblock);
+		
+		/* Split leaf node */
+		if (levels > 0) {
+			uint32_t count_left = leaf_count / 2;
+			uint32_t count_right = leaf_count - count_left;
+			uint32_t hash_right =
+			    ext4_directory_dx_entry_get_hash(entries + count_left);
+			
+			/* Copy data to new node */
+			memcpy((void *) new_entries, (void *) (entries + count_left),
+			    count_right * sizeof(ext4_directory_dx_entry_t));
+			
+			/* Initialize new node */
+			ext4_directory_dx_countlimit_t *left_countlimit =
+			    (ext4_directory_dx_countlimit_t *) entries;
+			ext4_directory_dx_countlimit_t *right_countlimit =
+			    (ext4_directory_dx_countlimit_t *) new_entries;
+			
+			ext4_directory_dx_countlimit_set_count(left_countlimit, count_left);
+			ext4_directory_dx_countlimit_set_count(right_countlimit, count_right);
+			
+			uint32_t entry_space =
+			    block_size - sizeof(ext4_fake_directory_entry_t);
+			uint32_t node_limit =
+			    entry_space / sizeof(ext4_directory_dx_entry_t);
+			ext4_directory_dx_countlimit_set_limit(right_countlimit, node_limit);
+			
+			/* Which index block is target for new entry */
+			uint32_t position_index = (dx_block->position - dx_block->entries);
+			if (position_index >= count_left) {
+				dx_block->block->dirty = true;
+				
+				block_t *block_tmp = dx_block->block;
+				dx_block->block = new_block;
+				dx_block->position =
+				    new_entries + position_index - count_left;
+				dx_block->entries = new_entries;
+				
+				new_block = block_tmp;
+			}
+			
+			/* Finally insert new entry */
+			ext4_directory_dx_insert_entry(dx_blocks, hash_right, new_iblock);
+			
+			return block_put(new_block);
+		} else {
+			/* Create second level index */
+			
+			/* Copy data from root to child block */
+			memcpy((void *) new_entries, (void *) entries,
+			    leaf_count * sizeof(ext4_directory_dx_entry_t));
+			
+			ext4_directory_dx_countlimit_t *new_countlimit =
+			    (ext4_directory_dx_countlimit_t *) new_entries;
+			
+			uint32_t entry_space =
+			    block_size - sizeof(ext4_fake_directory_entry_t);
+			uint32_t node_limit =
+			    entry_space / sizeof(ext4_directory_dx_entry_t);
+			ext4_directory_dx_countlimit_set_limit(new_countlimit, node_limit);
+			
+			/* Set values in root node */
+			ext4_directory_dx_countlimit_t *new_root_countlimit =
+			    (ext4_directory_dx_countlimit_t *) entries;
+			
+			ext4_directory_dx_countlimit_set_count(new_root_countlimit, 1);
+			ext4_directory_dx_entry_set_block(entries, new_iblock);
+			
+			((ext4_directory_dx_root_t *)
+			    dx_blocks[0].block->data)->info.indirect_levels = 1;
+			
+			/* Add new entry to the path */
+			dx_block = dx_blocks + 1;
+			dx_block->position = dx_block->position - entries + new_entries;
+			dx_block->entries = new_entries;
+			dx_block->block = new_block;
+		}
+	}
+	
+	return EOK;
+}
+
+/** Add new entry to indexed directory
+ *
+ * @param parent Directory i-node
+ * @param child  I-node to be referenced from directory entry
+ * @param name   Name of new directory entry
+ *
+ * @return Error code
+ *
+ */
+int ext4_directory_dx_add_entry(ext4_inode_ref_t *parent,
+    ext4_inode_ref_t *child, const char *name)
+{
+	int rc2 = EOK;
+	
+	/* Get direct block 0 (index root) */
+	uint32_t root_block_addr;
+	int rc = ext4_filesystem_get_inode_data_block_index(parent, 0,
+	    &root_block_addr);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_filesystem_t *fs = parent->fs;
+	
+	block_t *root_block;
+	rc = block_get(&root_block, fs->device, root_block_addr,
+	    BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		return rc;
+	
+	/* Initialize hinfo structure (mainly compute hash) */
+	uint32_t name_len = str_size(name);
+	ext4_hash_info_t hinfo;
+	rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock,
+	    name_len, name);
+	if (rc != EOK) {
+		block_put(root_block);
+		return EXT4_ERR_BAD_DX_DIR;
+	}
+	
+	/*
+	 * Hardcoded number 2 means maximum height of index
+	 * tree defined in Linux.
+	 */
+	ext4_directory_dx_block_t dx_blocks[2];
+	ext4_directory_dx_block_t *dx_block;
+	ext4_directory_dx_block_t *dx_it;
+	
+	rc = ext4_directory_dx_get_leaf(&hinfo, parent, root_block,
+	    &dx_block, dx_blocks);
+	if (rc != EOK) {
+		rc = EXT4_ERR_BAD_DX_DIR;
+		goto release_index;
+	}
+	
+	/* Try to insert to existing data block */
+	uint32_t leaf_block_idx =
+	    ext4_directory_dx_entry_get_block(dx_block->position);
+	uint32_t leaf_block_addr;
+	rc = ext4_filesystem_get_inode_data_block_index(parent, leaf_block_idx,
+	    &leaf_block_addr);
+	if (rc != EOK)
+		goto release_index;
+	
+	block_t *target_block;
+	rc = block_get(&target_block, fs->device, leaf_block_addr,
+	    BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		goto release_index;
+	
+	/* Check if insert operation passed */
+	rc = ext4_directory_try_insert_entry(fs->superblock, target_block, child,
+	    name, name_len);
+	if (rc == EOK)
+		goto release_target_index;
+	
+	/*
+	 * Check if there is needed to split index node
+	 * (and recursively also parent nodes)
+	 */
+	rc = ext4_directory_dx_split_index(parent, dx_blocks, dx_block);
+	if (rc != EOK)
+		goto release_target_index;
+	
+	/* Split entries to two blocks (includes sorting by hash value) */
+	block_t *new_block = NULL;
+	rc = ext4_directory_dx_split_data(parent, &hinfo, target_block,
+	    dx_block, &new_block);
+	if (rc != EOK) {
+		rc2 = rc;
+		goto release_target_index;
+	}
+	
+	/* Where to save new entry */
+	uint32_t new_block_hash =
+	    ext4_directory_dx_entry_get_hash(dx_block->position + 1);
+	if (hinfo.hash >= new_block_hash)
+		rc = ext4_directory_try_insert_entry(fs->superblock, new_block,
+		    child, name, name_len);
+	else
+		rc = ext4_directory_try_insert_entry(fs->superblock, target_block,
+		    child, name, name_len);
+	
+	/* Cleanup */
+	rc = block_put(new_block);
+	if (rc != EOK)
+		return rc;
+	
+	/* Cleanup operations */
+	
+release_target_index:
+	rc2 = rc;
+	
+	rc = block_put(target_block);
+	if (rc != EOK)
+		return rc;
+	
+release_index:
+	if (rc != EOK)
+		rc2 = rc;
+	
+	dx_it = dx_blocks;
+	
+	while (dx_it <= dx_block) {
+		rc = block_put(dx_it->block);
+		if (rc != EOK)
+			return rc;
+		
+		dx_it++;
+	}
+	
+	return rc2;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_directory_index.h
===================================================================
--- uspace/lib/ext4/libext4_directory_index.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_directory_index.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_DIRECTORY_INDEX_H_
+#define LIBEXT4_LIBEXT4_DIRECTORY_INDEX_H_
+
+#include "libext4_types.h"
+
+extern uint8_t ext4_directory_dx_root_info_get_hash_version(
+    ext4_directory_dx_root_info_t *);
+extern void ext4_directory_dx_root_info_set_hash_version(
+    ext4_directory_dx_root_info_t *, uint8_t);
+extern uint8_t ext4_directory_dx_root_info_get_info_length(
+    ext4_directory_dx_root_info_t *);
+extern void ext4_directory_dx_root_info_set_info_length(
+    ext4_directory_dx_root_info_t *, uint8_t);
+extern uint8_t ext4_directory_dx_root_info_get_indirect_levels(
+    ext4_directory_dx_root_info_t *);
+extern void ext4_directory_dx_root_info_set_indirect_levels(
+    ext4_directory_dx_root_info_t *, uint8_t);
+
+extern uint16_t ext4_directory_dx_countlimit_get_limit(
+    ext4_directory_dx_countlimit_t *);
+extern void ext4_directory_dx_countlimit_set_limit(
+    ext4_directory_dx_countlimit_t *, uint16_t);
+extern uint16_t ext4_directory_dx_countlimit_get_count(
+    ext4_directory_dx_countlimit_t *);
+extern void ext4_directory_dx_countlimit_set_count(
+    ext4_directory_dx_countlimit_t *, uint16_t);
+
+extern uint32_t ext4_directory_dx_entry_get_hash(ext4_directory_dx_entry_t *);
+extern void ext4_directory_dx_entry_set_hash(ext4_directory_dx_entry_t *,
+    uint32_t);
+extern uint32_t ext4_directory_dx_entry_get_block(ext4_directory_dx_entry_t *);
+extern void ext4_directory_dx_entry_set_block(ext4_directory_dx_entry_t *,
+    uint32_t);
+
+extern int ext4_directory_dx_init(ext4_inode_ref_t *);
+extern int ext4_directory_dx_find_entry(ext4_directory_search_result_t *,
+    ext4_inode_ref_t *, size_t, const char *);
+extern int ext4_directory_dx_add_entry(ext4_inode_ref_t *, ext4_inode_ref_t *,
+    const char *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_extent.c
===================================================================
--- uspace/lib/ext4/libext4_extent.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_extent.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1084 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_extent.c
+ * @brief Ext4 extent structures operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <malloc.h>
+#include "libext4.h"
+
+/** Get logical number of the block covered by extent.
+ *
+ * @param extent Extent to load number from
+ *
+ * @return Logical number of the first block covered by extent
+ *
+ */
+uint32_t ext4_extent_get_first_block(ext4_extent_t *extent)
+{
+	return uint32_t_le2host(extent->first_block);
+}
+
+/** Set logical number of the first block covered by extent.
+ *
+ * @param extent Extent to set number to
+ * @param iblock Logical number of the first block covered by extent
+ *
+ */
+void ext4_extent_set_first_block(ext4_extent_t *extent, uint32_t iblock)
+{
+	extent->first_block = host2uint32_t_le(iblock);
+}
+
+/** Get number of blocks covered by extent.
+ *
+ * @param extent Extent to load count from
+ *
+ * @return Number of blocks covered by extent
+ *
+ */
+uint16_t ext4_extent_get_block_count(ext4_extent_t *extent)
+{
+	return uint16_t_le2host(extent->block_count);
+}
+
+/** Set number of blocks covered by extent.
+ *
+ * @param extent Extent to load count from
+ * @param count  Number of blocks covered by extent
+ *
+ */
+void ext4_extent_set_block_count(ext4_extent_t *extent, uint16_t count)
+{
+	extent->block_count = host2uint16_t_le(count);
+}
+
+/** Get physical number of the first block covered by extent.
+ *
+ * @param extent Extent to load number
+ *
+ * @return Physical number of the first block covered by extent
+ *
+ */
+uint64_t ext4_extent_get_start(ext4_extent_t *extent)
+{
+	return ((uint64_t)uint16_t_le2host(extent->start_hi)) << 32 |
+	    ((uint64_t)uint32_t_le2host(extent->start_lo));
+}
+
+/** Set physical number of the first block covered by extent.
+ *
+ * @param extent Extent to load number
+ * @param fblock Physical number of the first block covered by extent
+ *
+ */
+void ext4_extent_set_start(ext4_extent_t *extent, uint64_t fblock)
+{
+	extent->start_lo = host2uint32_t_le((fblock << 32) >> 32);
+	extent->start_hi = host2uint16_t_le((uint16_t)(fblock >> 32));
+}
+
+/** Get logical number of the block covered by extent index.
+ *
+ * @param index Extent index to load number from
+ *
+ * @return Logical number of the first block covered by extent index
+ *
+ */
+uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *index)
+{
+	return uint32_t_le2host(index->first_block);
+}
+
+/** Set logical number of the block covered by extent index.
+ *
+ * @param index  Extent index to set number to
+ * @param iblock Logical number of the first block covered by extent index
+ *
+ */
+void ext4_extent_index_set_first_block(ext4_extent_index_t *index,
+    uint32_t iblock)
+{
+	index->first_block = host2uint32_t_le(iblock);
+}
+
+/** Get physical number of block where the child node is located.
+ *
+ * @param index Extent index to load number from
+ *
+ * @return Physical number of the block with child node
+ *
+ */
+uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *index)
+{
+	return ((uint64_t) uint16_t_le2host(index->leaf_hi)) << 32 |
+	    ((uint64_t)uint32_t_le2host(index->leaf_lo));
+}
+
+/** Set physical number of block where the child node is located.
+ *
+ * @param index  Extent index to set number to
+ * @param fblock Ohysical number of the block with child node
+ *
+ */
+void ext4_extent_index_set_leaf(ext4_extent_index_t *index, uint64_t fblock)
+{
+	index->leaf_lo = host2uint32_t_le((fblock << 32) >> 32);
+	index->leaf_hi = host2uint16_t_le((uint16_t) (fblock >> 32));
+}
+
+/** Get magic value from extent header.
+ *
+ * @param header Extent header to load value from
+ *
+ * @return Magic value of extent header
+ *
+ */
+uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *header)
+{
+	return uint16_t_le2host(header->magic);
+}
+
+/** Set magic value to extent header.
+ *
+ * @param header Extent header to set value to
+ * @param magic  Magic value of extent header
+ *
+ */
+void ext4_extent_header_set_magic(ext4_extent_header_t *header, uint16_t magic)
+{
+	header->magic = host2uint16_t_le(magic);
+}
+
+/** Get number of entries from extent header
+ *
+ * @param header Extent header to get value from
+ *
+ * @return Number of entries covered by extent header
+ *
+ */
+uint16_t ext4_extent_header_get_entries_count(ext4_extent_header_t *header)
+{
+	return uint16_t_le2host(header->entries_count);
+}
+
+/** Set number of entries to extent header
+ *
+ * @param header Extent header to set value to
+ * @param count  Number of entries covered by extent header
+ *
+ */
+void ext4_extent_header_set_entries_count(ext4_extent_header_t *header,
+    uint16_t count)
+{
+	header->entries_count = host2uint16_t_le(count);
+}
+
+/** Get maximum number of entries from extent header
+ *
+ * @param header Extent header to get value from
+ *
+ * @return Maximum number of entries covered by extent header
+ *
+ */
+uint16_t ext4_extent_header_get_max_entries_count(ext4_extent_header_t *header)
+{
+	return uint16_t_le2host(header->max_entries_count);
+}
+
+/** Set maximum number of entries to extent header
+ *
+ * @param header    Extent header to set value to
+ * @param max_count Maximum number of entries covered by extent header
+ *
+ */
+void ext4_extent_header_set_max_entries_count(ext4_extent_header_t *header,
+    uint16_t max_count)
+{
+	header->max_entries_count = host2uint16_t_le(max_count);
+}
+
+/** Get depth of extent subtree.
+ *
+ * @param header Extent header to get value from
+ *
+ * @return Depth of extent subtree
+ *
+ */
+uint16_t ext4_extent_header_get_depth(ext4_extent_header_t *header)
+{
+	return uint16_t_le2host(header->depth);
+}
+
+/** Set depth of extent subtree.
+ *
+ * @param header Extent header to set value to
+ * @param depth  Depth of extent subtree
+ *
+ */
+void ext4_extent_header_set_depth(ext4_extent_header_t *header, uint16_t depth)
+{
+	header->depth = host2uint16_t_le(depth);
+}
+
+/** Get generation from extent header
+ *
+ * @param header Extent header to get value from
+ *
+ * @return Generation
+ *
+ */
+uint32_t ext4_extent_header_get_generation(ext4_extent_header_t *header)
+{
+	return uint32_t_le2host(header->generation);
+}
+
+/** Set generation to extent header
+ *
+ * @param header     Extent header to set value to
+ * @param generation Generation
+ *
+ */
+void ext4_extent_header_set_generation(ext4_extent_header_t *header,
+    uint32_t generation)
+{
+	header->generation = host2uint32_t_le(generation);
+}
+
+/** Binary search in extent index node.
+ *
+ * @param header Extent header of index node
+ * @param index  Output value - found index will be set here
+ * @param iblock Logical block number to find in index node
+ *
+ */
+static void ext4_extent_binsearch_idx(ext4_extent_header_t *header,
+    ext4_extent_index_t **index, uint32_t iblock)
+{
+	ext4_extent_index_t *r;
+	ext4_extent_index_t *l;
+	ext4_extent_index_t *m;
+	
+	uint16_t entries_count =
+	    ext4_extent_header_get_entries_count(header);
+	
+	/* Initialize bounds */
+	l = EXT4_EXTENT_FIRST_INDEX(header) + 1;
+	r = EXT4_EXTENT_FIRST_INDEX(header) + entries_count - 1;
+	
+	/* Do binary search */
+	while (l <= r) {
+		m = l + (r - l) / 2;
+		uint32_t first_block = ext4_extent_index_get_first_block(m);
+		
+		if (iblock < first_block)
+			r = m - 1;
+		else
+			l = m + 1;
+	}
+	
+	/* Set output value */
+	*index = l - 1;
+}
+
+/** Binary search in extent leaf node.
+ *
+ * @param header Extent header of leaf node
+ * @param extent Output value - found extent will be set here,
+ *               or NULL if node is empty
+ * @param iblock Logical block number to find in leaf node
+ *
+ */
+static void ext4_extent_binsearch(ext4_extent_header_t *header,
+    ext4_extent_t **extent, uint32_t iblock)
+{
+	ext4_extent_t *r;
+	ext4_extent_t *l;
+	ext4_extent_t *m;
+	
+	uint16_t entries_count =
+	    ext4_extent_header_get_entries_count(header);
+	
+	if (entries_count == 0) {
+		/* this leaf is empty */
+		*extent = NULL;
+		return;
+	}
+	
+	/* Initialize bounds */
+	l = EXT4_EXTENT_FIRST(header) + 1;
+	r = EXT4_EXTENT_FIRST(header) + entries_count - 1;
+	
+	/* Do binary search */
+	while (l <= r) {
+		m = l + (r - l) / 2;
+		uint32_t first_block = ext4_extent_get_first_block(m);
+		
+		if (iblock < first_block)
+			r = m - 1;
+		else
+			l = m + 1;
+	}
+	
+	/* Set output value */
+	*extent = l - 1;
+}
+
+/** Find physical block in the extent tree by logical block number.
+ *
+ * There is no need to save path in the tree during this algorithm.
+ *
+ * @param inode_ref I-node to load block from
+ * @param iblock    Logical block number to find
+ * @param fblock    Output value for physical block number
+ *
+ * @return Error code
+ *
+ */
+int ext4_extent_find_block(ext4_inode_ref_t *inode_ref, uint32_t iblock,
+    uint32_t *fblock)
+{
+	/* Compute bound defined by i-node size */
+	uint64_t inode_size =
+	    ext4_inode_get_size(inode_ref->fs->superblock, inode_ref->inode);
+	
+	uint32_t block_size =
+	    ext4_superblock_get_block_size(inode_ref->fs->superblock);
+	
+	uint32_t last_idx = (inode_size - 1) / block_size;
+	
+	/* Check if requested iblock is not over size of i-node */
+	if (iblock > last_idx) {
+		*fblock = 0;
+		return EOK;
+	}
+	
+	block_t *block = NULL;
+	
+	/* Walk through extent tree */
+	ext4_extent_header_t *header =
+	    ext4_inode_get_extent_header(inode_ref->inode);
+	
+	while (ext4_extent_header_get_depth(header) != 0) {
+		/* Search index in node */
+		ext4_extent_index_t *index;
+		ext4_extent_binsearch_idx(header, &index, iblock);
+		
+		/* Load child node and set values for the next iteration */
+		uint64_t child = ext4_extent_index_get_leaf(index);
+		
+		if (block != NULL)
+			block_put(block);
+		
+		int rc = block_get(&block, inode_ref->fs->device, child,
+		    BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		header = (ext4_extent_header_t *)block->data;
+	}
+	
+	/* Search extent in the leaf block */
+	ext4_extent_t* extent = NULL;
+	ext4_extent_binsearch(header, &extent, iblock);
+	
+	/* Prevent empty leaf */
+	if (extent == NULL) {
+		*fblock = 0;
+	} else {
+		/* Compute requested physical block address */
+		uint32_t phys_block;
+		uint32_t first = ext4_extent_get_first_block(extent);
+		phys_block = ext4_extent_get_start(extent) + iblock - first;
+		
+		*fblock = phys_block;
+	}
+	
+	/* Cleanup */
+	if (block != NULL)
+		block_put(block);
+	
+	return EOK;
+}
+
+/** Find extent for specified iblock.
+ *
+ * This function is used for finding block in the extent tree with
+ * saving the path through the tree for possible future modifications.
+ *
+ * @param inode_ref I-node to read extent tree from
+ * @param iblock    Iblock to find extent for
+ * @param ret_path  Output value for loaded path from extent tree
+ *
+ * @return Error code
+ *
+ */
+static int ext4_extent_find_extent(ext4_inode_ref_t *inode_ref, uint32_t iblock,
+    ext4_extent_path_t **ret_path)
+{
+	ext4_extent_header_t *eh =
+	    ext4_inode_get_extent_header(inode_ref->inode);
+	
+	uint16_t depth = ext4_extent_header_get_depth(eh);
+	
+	ext4_extent_path_t *tmp_path;
+	
+	/* Added 2 for possible tree growing */
+	tmp_path = malloc(sizeof(ext4_extent_path_t) * (depth + 2));
+	if (tmp_path == NULL)
+		return ENOMEM;
+	
+	/* Initialize structure for algorithm start */
+	tmp_path[0].block = inode_ref->block;
+	tmp_path[0].header = eh;
+	
+	/* Walk through the extent tree */
+	uint16_t pos = 0;
+	int rc;
+	while (ext4_extent_header_get_depth(eh) != 0) {
+		/* Search index in index node by iblock */
+		ext4_extent_binsearch_idx(tmp_path[pos].header,
+		    &tmp_path[pos].index, iblock);
+		
+		tmp_path[pos].depth = depth;
+		tmp_path[pos].extent = NULL;
+		
+		assert(tmp_path[pos].index != NULL);
+		
+		/* Load information for the next iteration */
+		uint64_t fblock = ext4_extent_index_get_leaf(tmp_path[pos].index);
+		
+		block_t *block;
+		rc = block_get(&block, inode_ref->fs->device, fblock,
+		    BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			goto cleanup;
+		
+		pos++;
+		
+		eh = (ext4_extent_header_t *)block->data;
+		tmp_path[pos].block = block;
+		tmp_path[pos].header = eh;
+	}
+	
+	tmp_path[pos].depth = 0;
+	tmp_path[pos].extent = NULL;
+	tmp_path[pos].index = NULL;
+	
+	/* Find extent in the leaf node */
+	ext4_extent_binsearch(tmp_path[pos].header, &tmp_path[pos].extent, iblock);
+	*ret_path = tmp_path;
+	
+	return EOK;
+	
+cleanup:
+	/*
+	 * Put loaded blocks
+	 * From 1: 0 is a block with inode data
+	 */
+	for (uint16_t i = 1; i < tmp_path->depth; ++i) {
+		if (tmp_path[i].block)
+			block_put(tmp_path[i].block);
+	}
+	
+	/* Destroy temporary data structure */
+	free(tmp_path);
+	
+	return rc;
+}
+
+/** Release extent and all data blocks covered by the extent.
+ *
+ * @param inode_ref I-node to release extent and block from
+ * @param extent    Extent to release
+ *
+ * @return Error code
+ *
+ */
+static int ext4_extent_release(ext4_inode_ref_t *inode_ref,
+    ext4_extent_t *extent)
+{
+	/* Compute number of the first physical block to release */
+	uint64_t start = ext4_extent_get_start(extent);
+	uint16_t block_count = ext4_extent_get_block_count(extent);
+	
+	return ext4_balloc_free_blocks(inode_ref, start, block_count);
+}
+
+/** Recursively release the whole branch of the extent tree.
+ *
+ * For each entry of the node release the subbranch and finally release
+ * the node. In the leaf node all extents will be released.
+ *
+ * @param inode_ref I-node where the branch is released
+ * @param index     Index in the non-leaf node to be released
+ *                  with the whole subtree
+ *
+ * @return Error code
+ *
+ */
+static int ext4_extent_release_branch(ext4_inode_ref_t *inode_ref,
+		ext4_extent_index_t *index)
+{
+	uint32_t fblock = ext4_extent_index_get_leaf(index);
+	
+	block_t* block;
+	int rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_extent_header_t *header = block->data;
+	
+	if (ext4_extent_header_get_depth(header)) {
+		/* The node is non-leaf, do recursion */
+		ext4_extent_index_t *idx = EXT4_EXTENT_FIRST_INDEX(header);
+		
+		/* Release all subbranches */
+		for (uint32_t i = 0;
+		    i < ext4_extent_header_get_entries_count(header);
+		    ++i, ++idx) {
+			rc = ext4_extent_release_branch(inode_ref, idx);
+			if (rc != EOK)
+				return rc;
+		}
+	} else {
+		/* Leaf node reached */
+		ext4_extent_t *ext = EXT4_EXTENT_FIRST(header);
+		
+		/* Release all extents and stop recursion */
+		for (uint32_t i = 0;
+		    i < ext4_extent_header_get_entries_count(header);
+		    ++i, ++ext) {
+			rc = ext4_extent_release(inode_ref, ext);
+			if (rc != EOK)
+				return rc;
+		}
+	}
+	
+	/* Release data block where the node was stored */
+	
+	rc = block_put(block);
+	if (rc != EOK)
+		return rc;
+	
+	ext4_balloc_free_block(inode_ref, fblock);
+	
+	return EOK;
+}
+
+/** Release all data blocks starting from specified logical block.
+ *
+ * @param inode_ref   I-node to release blocks from
+ * @param iblock_from First logical block to release
+ *
+ */
+int ext4_extent_release_blocks_from(ext4_inode_ref_t *inode_ref,
+    uint32_t iblock_from)
+{
+	/* Find the first extent to modify */
+	ext4_extent_path_t *path;
+	int rc = ext4_extent_find_extent(inode_ref, iblock_from, &path);
+	if (rc != EOK)
+		return rc;
+	
+	/* Jump to last item of the path (extent) */
+	ext4_extent_path_t *path_ptr = path;
+	while (path_ptr->depth != 0)
+		path_ptr++;
+	
+	assert(path_ptr->extent != NULL);
+	
+	/* First extent maybe released partially */
+	uint32_t first_iblock =
+	    ext4_extent_get_first_block(path_ptr->extent);
+	uint32_t first_fblock =
+	    ext4_extent_get_start(path_ptr->extent) + iblock_from - first_iblock;
+	
+	uint16_t block_count = ext4_extent_get_block_count(path_ptr->extent);
+	
+	uint16_t delete_count = block_count -
+	    (ext4_extent_get_start(path_ptr->extent) - first_fblock);
+	
+	/* Release all blocks */
+	rc = ext4_balloc_free_blocks(inode_ref, first_fblock, delete_count);
+	if (rc != EOK)
+		goto cleanup;
+	
+	/* Correct counter */
+	block_count -= delete_count;
+	ext4_extent_set_block_count(path_ptr->extent, block_count);
+	
+	/* Initialize the following loop */
+	uint16_t entries =
+	    ext4_extent_header_get_entries_count(path_ptr->header);
+	ext4_extent_t *tmp_ext = path_ptr->extent + 1;
+	ext4_extent_t *stop_ext = EXT4_EXTENT_FIRST(path_ptr->header) + entries;
+	
+	/* If first extent empty, release it */
+	if (block_count == 0)
+		entries--;
+	
+	/* Release all successors of the first extent in the same node */
+	while (tmp_ext < stop_ext) {
+		first_fblock = ext4_extent_get_start(tmp_ext);
+		delete_count = ext4_extent_get_block_count(tmp_ext);
+		
+		rc = ext4_balloc_free_blocks(inode_ref, first_fblock, delete_count);
+		if (rc != EOK)
+			goto cleanup;
+		
+		entries--;
+		tmp_ext++;
+	}
+	
+	ext4_extent_header_set_entries_count(path_ptr->header, entries);
+	path_ptr->block->dirty = true;
+	
+	/* If leaf node is empty, parent entry must be modified */
+	bool remove_parent_record = false;
+	
+	/* Don't release root block (including inode data) !!! */
+	if ((path_ptr != path) && (entries == 0)) {
+		rc = ext4_balloc_free_block(inode_ref, path_ptr->block->lba);
+		if (rc != EOK)
+			goto cleanup;
+		
+		remove_parent_record = true;
+	}
+	
+	/* Jump to the parent */
+	--path_ptr;
+	
+	/* Release all successors in all tree levels */
+	while (path_ptr >= path) {
+		entries = ext4_extent_header_get_entries_count(path_ptr->header);
+		ext4_extent_index_t *index = path_ptr->index + 1;
+		ext4_extent_index_t *stop =
+		    EXT4_EXTENT_FIRST_INDEX(path_ptr->header) + entries;
+		
+		/* Correct entries count because of changes in the previous iteration */
+		if (remove_parent_record)
+			entries--;
+		
+		/* Iterate over all entries and release the whole subtrees */
+		while (index < stop) {
+			rc = ext4_extent_release_branch(inode_ref, index);
+			if (rc != EOK)
+				goto cleanup;
+			
+			++index;
+			--entries;
+		}
+		
+		ext4_extent_header_set_entries_count(path_ptr->header, entries);
+		path_ptr->block->dirty = true;
+		
+		/* Free the node if it is empty */
+		if ((entries == 0) && (path_ptr != path)) {
+			rc = ext4_balloc_free_block(inode_ref, path_ptr->block->lba);
+			if (rc != EOK)
+				goto cleanup;
+			
+			/* Mark parent to be checked */
+			remove_parent_record = true;
+		} else
+			remove_parent_record = false;
+		
+		--path_ptr;
+	}
+	
+cleanup:
+	/*
+	 * Put loaded blocks
+	 * starting from 1: 0 is a block with inode data
+	 */
+	for (uint16_t i = 1; i <= path->depth; ++i) {
+		if (path[i].block)
+			block_put(path[i].block);
+	}
+	
+	/* Destroy temporary data structure */
+	free(path);
+	
+	return rc;
+}
+
+/** Append new extent to the i-node and do some splitting if necessary.
+ *
+ * @param inode_ref      I-node to append extent to
+ * @param path           Path in the extent tree for possible splitting
+ * @param last_path_item Input/output parameter for pointer to the last
+ *                       valid item in the extent tree path
+ * @param iblock         Logical index of block to append extent for
+ *
+ * @return Error code
+ *
+ */
+static int ext4_extent_append_extent(ext4_inode_ref_t *inode_ref,
+    ext4_extent_path_t *path, uint32_t iblock)
+{
+	ext4_extent_path_t *path_ptr = path + path->depth;
+	
+	uint32_t block_size =
+	    ext4_superblock_get_block_size(inode_ref->fs->superblock);
+	
+	/* Start splitting */
+	while (path_ptr > path) {
+		uint16_t entries =
+		    ext4_extent_header_get_entries_count(path_ptr->header);
+		uint16_t limit =
+		    ext4_extent_header_get_max_entries_count(path_ptr->header);
+		
+		if (entries == limit) {
+			/* Full node - allocate block for new one */
+			uint32_t fblock;
+			int rc = ext4_balloc_alloc_block(inode_ref, &fblock);
+			if (rc != EOK)
+				return rc;
+			
+			block_t *block;
+			rc = block_get(&block, inode_ref->fs->device, fblock,
+			    BLOCK_FLAGS_NOREAD);
+			if (rc != EOK) {
+				ext4_balloc_free_block(inode_ref, fblock);
+				return rc;
+			}
+			
+			/* Put back not modified old block */
+			block_put(path_ptr->block);
+			
+			/* Initialize newly allocated block and remember it */
+			memset(block->data, 0, block_size);
+			path_ptr->block = block;
+			
+			/* Update pointers in extent path structure */
+			path_ptr->header = block->data;
+			if (path_ptr->depth) {
+				path_ptr->index = EXT4_EXTENT_FIRST_INDEX(path_ptr->header);
+				ext4_extent_index_set_first_block(path_ptr->index, iblock);
+				ext4_extent_index_set_leaf(path_ptr->index, (path_ptr + 1)->block->lba);
+				limit = (block_size - sizeof(ext4_extent_header_t)) /
+				    sizeof(ext4_extent_index_t);
+			} else {
+				path_ptr->extent = EXT4_EXTENT_FIRST(path_ptr->header);
+				ext4_extent_set_first_block(path_ptr->extent, iblock);
+				limit = (block_size - sizeof(ext4_extent_header_t)) /
+				    sizeof(ext4_extent_t);
+			}
+			
+			/* Initialize on-disk structure (header) */
+			ext4_extent_header_set_entries_count(path_ptr->header, 1);
+			ext4_extent_header_set_max_entries_count(path_ptr->header, limit);
+			ext4_extent_header_set_magic(path_ptr->header, EXT4_EXTENT_MAGIC);
+			ext4_extent_header_set_depth(path_ptr->header, path_ptr->depth);
+			ext4_extent_header_set_generation(path_ptr->header, 0);
+			
+			path_ptr->block->dirty = true;
+			
+			/* Jump to the preceeding item */
+			path_ptr--;
+		} else {
+			/* Node with free space */
+			if (path_ptr->depth) {
+				path_ptr->index = EXT4_EXTENT_FIRST_INDEX(path_ptr->header) + entries;
+				ext4_extent_index_set_first_block(path_ptr->index, iblock);
+				ext4_extent_index_set_leaf(path_ptr->index, (path_ptr + 1)->block->lba);
+			} else {
+				path_ptr->extent = EXT4_EXTENT_FIRST(path_ptr->header) + entries;
+				ext4_extent_set_first_block(path_ptr->extent, iblock);
+			}
+			
+			ext4_extent_header_set_entries_count(path_ptr->header, entries + 1);
+			path_ptr->block->dirty = true;
+			
+			/* No more splitting needed */
+			return EOK;
+		}
+	}
+	
+	assert(path_ptr == path);
+	
+	/* Should be the root split too? */
+	
+	uint16_t entries = ext4_extent_header_get_entries_count(path->header);
+	uint16_t limit = ext4_extent_header_get_max_entries_count(path->header);
+	
+	if (entries == limit) {
+		uint32_t new_fblock;
+		int rc = ext4_balloc_alloc_block(inode_ref, &new_fblock);
+		if (rc != EOK)
+			return rc;
+		
+		block_t *block;
+		rc = block_get(&block, inode_ref->fs->device, new_fblock,
+		    BLOCK_FLAGS_NOREAD);
+		if (rc != EOK)
+			return rc;
+		
+		/* Initialize newly allocated block */
+		memset(block->data, 0, block_size);
+		
+		/* Move data from root to the new block */
+		memcpy(block->data, inode_ref->inode->blocks,
+		    EXT4_INODE_BLOCKS * sizeof(uint32_t));
+		
+		/* Data block is initialized */
+		
+		block_t *root_block = path->block;
+		uint16_t root_depth = path->depth;
+		ext4_extent_header_t *root_header = path->header;
+		
+		/* Make space for tree growing */
+		ext4_extent_path_t *new_root = path;
+		ext4_extent_path_t *old_root = path + 1;
+		
+		size_t nbytes = sizeof(ext4_extent_path_t) * (path->depth + 1);
+		memmove(old_root, new_root, nbytes);
+		memset(new_root, 0, sizeof(ext4_extent_path_t));
+		
+		/* Update old root structure */
+		old_root->block = block;
+		old_root->header = (ext4_extent_header_t *)block->data;
+		
+		/* Add new entry and update limit for entries */
+		if (old_root->depth) {
+			limit = (block_size - sizeof(ext4_extent_header_t)) /
+			    sizeof(ext4_extent_index_t);
+			old_root->index = EXT4_EXTENT_FIRST_INDEX(old_root->header) + entries;
+			ext4_extent_index_set_first_block(old_root->index, iblock);
+			ext4_extent_index_set_leaf(old_root->index, (old_root + 1)->block->lba);
+			old_root->extent = NULL;
+		} else {
+			limit = (block_size - sizeof(ext4_extent_header_t)) /
+			    sizeof(ext4_extent_t);
+			old_root->extent = EXT4_EXTENT_FIRST(old_root->header) + entries;
+			ext4_extent_set_first_block(old_root->extent, iblock);
+			old_root->index = NULL;
+		}
+		
+		ext4_extent_header_set_entries_count(old_root->header, entries + 1);
+		ext4_extent_header_set_max_entries_count(old_root->header, limit);
+		
+		old_root->block->dirty = true;
+		
+		/* Re-initialize new root metadata */
+		new_root->depth = root_depth + 1;
+		new_root->block = root_block;
+		new_root->header = root_header;
+		new_root->extent = NULL;
+		new_root->index = EXT4_EXTENT_FIRST_INDEX(new_root->header);
+		
+		ext4_extent_header_set_depth(new_root->header, new_root->depth);
+		
+		/* Create new entry in root */
+		ext4_extent_header_set_entries_count(new_root->header, 1);
+		ext4_extent_index_set_first_block(new_root->index, 0);
+		ext4_extent_index_set_leaf(new_root->index, new_fblock);
+		
+		new_root->block->dirty = true;
+	} else {
+		if (path->depth) {
+			path->index = EXT4_EXTENT_FIRST_INDEX(path->header) + entries;
+			ext4_extent_index_set_first_block(path->index, iblock);
+			ext4_extent_index_set_leaf(path->index, (path + 1)->block->lba);
+		} else {
+			path->extent = EXT4_EXTENT_FIRST(path->header) + entries;
+			ext4_extent_set_first_block(path->extent, iblock);
+		}
+		
+		ext4_extent_header_set_entries_count(path->header, entries + 1);
+		path->block->dirty = true;
+	}
+	
+	return EOK;
+}
+
+/** Append data block to the i-node.
+ *
+ * This function allocates data block, tries to append it
+ * to some existing extent or creates new extents.
+ * It includes possible extent tree modifications (splitting).
+ *<
+ * @param inode_ref I-node to append block to
+ * @param iblock    Output logical number of newly allocated block
+ * @param fblock    Output physical block address of newly allocated block
+ *
+ * @return Error code
+ *
+ */
+int ext4_extent_append_block(ext4_inode_ref_t *inode_ref, uint32_t *iblock,
+    uint32_t *fblock, bool update_size)
+{
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Calculate number of new logical block */
+	uint32_t new_block_idx = 0;
+	if (inode_size > 0) {
+		if ((inode_size % block_size) != 0)
+			inode_size += block_size - (inode_size % block_size);
+		
+		new_block_idx = inode_size / block_size;
+	}
+	
+	/* Load the nearest leaf (with extent) */
+	ext4_extent_path_t *path;
+	int rc = ext4_extent_find_extent(inode_ref, new_block_idx, &path);
+	if (rc != EOK)
+		return rc;
+	
+	/* Jump to last item of the path (extent) */
+	ext4_extent_path_t *path_ptr = path;
+	while (path_ptr->depth != 0)
+		path_ptr++;
+	
+	/* Add new extent to the node if not present */
+	if (path_ptr->extent == NULL)
+		goto append_extent;
+	
+	uint16_t block_count = ext4_extent_get_block_count(path_ptr->extent);
+	uint16_t block_limit = (1 << 15);
+	
+	uint32_t phys_block = 0;
+	if (block_count < block_limit) {
+		/* There is space for new block in the extent */
+		if (block_count == 0) {
+			/* Existing extent is empty */
+			rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
+			if (rc != EOK)
+				goto finish;
+			
+			/* Initialize extent */
+			ext4_extent_set_first_block(path_ptr->extent, new_block_idx);
+			ext4_extent_set_start(path_ptr->extent, phys_block);
+			ext4_extent_set_block_count(path_ptr->extent, 1);
+			
+			/* Update i-node */
+			if (update_size) {
+				ext4_inode_set_size(inode_ref->inode, inode_size + block_size);
+				inode_ref->dirty = true;
+			}
+			
+			path_ptr->block->dirty = true;
+			
+			goto finish;
+		} else {
+			/* Existing extent contains some blocks */
+			phys_block = ext4_extent_get_start(path_ptr->extent);
+			phys_block += ext4_extent_get_block_count(path_ptr->extent);
+			
+			/* Check if the following block is free for allocation */
+			bool free;
+			rc = ext4_balloc_try_alloc_block(inode_ref, phys_block, &free);
+			if (rc != EOK)
+				goto finish;
+			
+			if (!free) {
+				/* Target is not free, new block must be appended to new extent */
+				goto append_extent;
+			}
+			
+			/* Update extent */
+			ext4_extent_set_block_count(path_ptr->extent, block_count + 1);
+			
+			/* Update i-node */
+			if (update_size) {
+				ext4_inode_set_size(inode_ref->inode, inode_size + block_size);
+				inode_ref->dirty = true;
+			}
+			
+			path_ptr->block->dirty = true;
+			
+			goto finish;
+		}
+	}
+	
+	
+append_extent:
+	/* Append new extent to the tree */
+	phys_block = 0;
+	
+	/* Allocate new data block */
+	rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
+	if (rc != EOK)
+		goto finish;
+	
+	/* Append extent for new block (includes tree splitting if needed) */
+	rc = ext4_extent_append_extent(inode_ref, path, new_block_idx);
+	if (rc != EOK) {
+		ext4_balloc_free_block(inode_ref, phys_block);
+		goto finish;
+	}
+	
+	uint32_t tree_depth = ext4_extent_header_get_depth(path->header);
+	path_ptr = path + tree_depth;
+	
+	/* Initialize newly created extent */
+	ext4_extent_set_block_count(path_ptr->extent, 1);
+	ext4_extent_set_first_block(path_ptr->extent, new_block_idx);
+	ext4_extent_set_start(path_ptr->extent, phys_block);
+	
+	/* Update i-node */
+	if (update_size) {
+		ext4_inode_set_size(inode_ref->inode, inode_size + block_size);
+		inode_ref->dirty = true;
+	}
+	
+	path_ptr->block->dirty = true;
+	
+finish:
+	/* Set return values */
+	*iblock = new_block_idx;
+	*fblock = phys_block;
+	
+	/*
+	 * Put loaded blocks
+	 * starting from 1: 0 is a block with inode data
+	 */
+	for (uint16_t i = 1; i <= path->depth; ++i) {
+		if (path[i].block)
+			block_put(path[i].block);
+	}
+	
+	/* Destroy temporary data structure */
+	free(path);
+	
+	return rc;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_extent.h
===================================================================
--- uspace/lib/ext4/libext4_extent.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_extent.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_EXTENT_H_
+#define LIBEXT4_LIBEXT4_EXTENT_H_
+
+#include "libext4_types.h"
+
+extern uint32_t ext4_extent_get_first_block(ext4_extent_t *);
+extern void ext4_extent_set_first_block(ext4_extent_t *, uint32_t);
+extern uint16_t ext4_extent_get_block_count(ext4_extent_t *);
+extern void ext4_extent_set_block_count(ext4_extent_t *, uint16_t);
+extern uint64_t ext4_extent_get_start(ext4_extent_t *);
+extern void ext4_extent_set_start(ext4_extent_t *, uint64_t);
+
+extern uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *);
+extern void ext4_extent_index_set_first_block(ext4_extent_index_t *, uint32_t);
+extern uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *);
+extern void ext4_extent_index_set_leaf(ext4_extent_index_t *, uint64_t);
+
+extern uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *);
+extern void ext4_extent_header_set_magic(ext4_extent_header_t *, uint16_t);
+extern uint16_t ext4_extent_header_get_entries_count(ext4_extent_header_t *);
+extern void ext4_extent_header_set_entries_count(ext4_extent_header_t *,
+    uint16_t);
+extern uint16_t ext4_extent_header_get_max_entries_count(ext4_extent_header_t *);
+extern void ext4_extent_header_set_max_entries_count(ext4_extent_header_t *,
+    uint16_t);
+extern uint16_t ext4_extent_header_get_depth(ext4_extent_header_t *);
+extern void ext4_extent_header_set_depth(ext4_extent_header_t *, uint16_t);
+extern uint32_t ext4_extent_header_get_generation(ext4_extent_header_t *);
+extern void ext4_extent_header_set_generation(ext4_extent_header_t *, uint32_t);
+
+extern int ext4_extent_find_block(ext4_inode_ref_t *, uint32_t, uint32_t *);
+extern int ext4_extent_release_blocks_from(ext4_inode_ref_t *, uint32_t);
+
+extern int ext4_extent_append_block(ext4_inode_ref_t *, uint32_t *, uint32_t *,
+    bool);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_filesystem.c
===================================================================
--- uspace/lib/ext4/libext4_filesystem.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_filesystem.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1384 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_filesystem.c
+ * @brief More complex filesystem operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <malloc.h>
+#include "libext4.h"
+
+/** Initialize filesystem and read all needed data.
+ *
+ * @param fs         Filesystem instance to be initialized
+ * @param service_id Identifier if device with the filesystem
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
+    enum cache_mode cmode)
+{
+	fs->device = service_id;
+	
+	/* Initialize block library (4096 is size of communication channel) */
+	int rc = block_init(EXCHANGE_SERIALIZE, fs->device, 4096);
+	if (rc != EOK)
+		return rc;
+	
+	/* Read superblock from device to memory */
+	ext4_superblock_t *temp_superblock;
+	rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
+	if (rc != EOK) {
+		block_fini(fs->device);
+		return rc;
+	}
+	
+	/* Read block size from superblock and check */
+	uint32_t block_size = ext4_superblock_get_block_size(temp_superblock);
+	if (block_size > EXT4_MAX_BLOCK_SIZE) {
+		block_fini(fs->device);
+		return ENOTSUP;
+	}
+	
+	/* Initialize block caching by libblock */
+	rc = block_cache_init(service_id, block_size, 0, cmode);
+	if (rc != EOK) {
+		block_fini(fs->device);
+		return rc;
+	}
+	
+	/* Compute limits for indirect block levels */
+	uint32_t block_ids_per_block = block_size / sizeof(uint32_t);
+	fs->inode_block_limits[0] = EXT4_INODE_DIRECT_BLOCK_COUNT;
+	fs->inode_blocks_per_level[0] = 1;
+	for (unsigned int i = 1; i < 4; i++) {
+		fs->inode_blocks_per_level[i] = fs->inode_blocks_per_level[i - 1] *
+		    block_ids_per_block;
+		fs->inode_block_limits[i] = fs->inode_block_limits[i - 1] +
+		    fs->inode_blocks_per_level[i];
+	}
+	
+	/* Return loaded superblock */
+	fs->superblock = temp_superblock;
+	
+	uint16_t state = ext4_superblock_get_state(fs->superblock);
+	
+	if (((state & EXT4_SUPERBLOCK_STATE_VALID_FS) !=
+	    EXT4_SUPERBLOCK_STATE_VALID_FS) ||
+	    ((state & EXT4_SUPERBLOCK_STATE_ERROR_FS) ==
+	    EXT4_SUPERBLOCK_STATE_ERROR_FS)) {
+		block_cache_fini(fs->device);
+		block_fini(fs->device);
+		return ENOTSUP;
+	}
+	
+	/* Mark system as mounted */
+	ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS);
+	rc = ext4_superblock_write_direct(fs->device, fs->superblock);
+	if (rc != EOK) {
+		block_cache_fini(fs->device);
+		block_fini(fs->device);
+		return rc;
+	}
+	
+	uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
+	ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
+	
+	return EOK;
+}
+
+/** Destroy filesystem instance (used by unmount operation).
+ *
+ * @param fs Filesystem to be destroyed
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_fini(ext4_filesystem_t *fs)
+{
+	/* Write the superblock to the device */
+	ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
+	int rc = ext4_superblock_write_direct(fs->device, fs->superblock);
+	
+	/* Release memory space for superblock */
+	free(fs->superblock);
+	
+	/* Finish work with block library */
+	block_cache_fini(fs->device);
+	block_fini(fs->device);
+	
+	return rc;
+}
+
+/** Check sanity of the filesystem.
+ *
+ * Main is the check of the superblock structure.
+ *
+ * @param fs Filesystem to be checked
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_check_sanity(ext4_filesystem_t *fs)
+{
+	/* Check superblock */
+	return ext4_superblock_check_sanity(fs->superblock);
+}
+
+/** Check filesystem's features, if supported by this driver
+ *
+ * Function can return EOK and set read_only flag. It mean's that
+ * there are some not-supported features, that can cause problems
+ * during some write operations.
+ *
+ * @param fs        Filesystem to be checked
+ * @param read_only Flag if filesystem should be mounted only for reading
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_check_features(ext4_filesystem_t *fs, bool *read_only)
+{
+	/* Feature flags are present only in higher revisions */
+	if (ext4_superblock_get_rev_level(fs->superblock) == 0) {
+		*read_only = false;
+		return EOK;
+	}
+	
+	/*
+	 * Check incompatible features - if filesystem has some,
+	 * volume can't be mounted
+	 */
+	uint32_t incompatible_features;
+	incompatible_features =
+	    ext4_superblock_get_features_incompatible(fs->superblock);
+	incompatible_features &= ~EXT4_FEATURE_INCOMPAT_SUPP;
+	if (incompatible_features > 0)
+		return ENOTSUP;
+	
+	/*
+	 * Check read-only features, if filesystem has some,
+	 * volume can be mount only in read-only mode
+	 */
+	uint32_t compatible_read_only;
+	compatible_read_only =
+	    ext4_superblock_get_features_read_only(fs->superblock);
+	compatible_read_only &= ~EXT4_FEATURE_RO_COMPAT_SUPP;
+	if (compatible_read_only > 0) {
+		*read_only = true;
+		return EOK;
+	}
+	
+	return EOK;
+}
+
+
+/** Convert block address to relative index in block group.
+ *
+ * @param sb         Superblock pointer
+ * @param block_addr Block number to convert
+ *
+ * @return Relative number of block
+ *
+ */
+uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *sb,
+    uint32_t block_addr)
+{
+	uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
+	uint32_t first_block = ext4_superblock_get_first_data_block(sb);
+	
+	/* First block == 0 or 1 */
+	if (first_block == 0)
+		return block_addr % blocks_per_group;
+	else
+		return (block_addr - 1) % blocks_per_group;
+}
+
+
+/** Convert relative block address in group to absolute address.
+ *
+ * @param sb Superblock pointer
+ *
+ * @return Absolute block address
+ *
+ */
+uint32_t ext4_filesystem_index_in_group2blockaddr(ext4_superblock_t *sb,
+    uint32_t index, uint32_t bgid)
+{
+	uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
+	
+	if (ext4_superblock_get_first_data_block(sb) == 0)
+		return bgid * blocks_per_group + index;
+	else
+		return bgid * blocks_per_group + index + 1;
+}
+
+/** Initialize block bitmap in block group.
+ *
+ * @param bg_ref Reference to block group
+ *
+ * @return Error code
+ *
+ */
+static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
+{
+	/* Load bitmap */
+	uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
+	    bg_ref->block_group, bg_ref->fs->superblock);
+	
+	block_t *bitmap_block;
+	int rc = block_get(&bitmap_block, bg_ref->fs->device,
+	    bitmap_block_addr, BLOCK_FLAGS_NOREAD);
+	if (rc != EOK)
+		return rc;
+	
+	uint8_t *bitmap = bitmap_block->data;
+	
+	/* Initialize all bitmap bits to zero */
+	uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock);
+	memset(bitmap, 0, block_size);
+	
+	/* Determine first block and first data block in group */
+	uint32_t first_idx = 0;
+	
+	uint32_t first_data = ext4_balloc_get_first_data_block_in_group(
+	    bg_ref->fs->superblock, bg_ref);
+	uint32_t first_data_idx = ext4_filesystem_blockaddr2_index_in_group(
+	    bg_ref->fs->superblock, first_data);
+	
+	/* Set bits from to first block to first data block - 1 to one (allocated) */
+	for (uint32_t block = first_idx; block < first_data_idx; ++block)
+		ext4_bitmap_set_bit(bitmap, block);
+	
+	bitmap_block->dirty = true;
+	
+	/* Save bitmap */
+	return block_put(bitmap_block);
+}
+
+/** Initialize i-node bitmap in block group.
+ *
+ * @param bg_ref Reference to block group
+ *
+ * @return Error code
+ *
+ */
+static int ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref)
+{
+	/* Load bitmap */
+	uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
+	    bg_ref->block_group, bg_ref->fs->superblock);
+	block_t *bitmap_block;
+	
+	int rc = block_get(&bitmap_block, bg_ref->fs->device,
+	    bitmap_block_addr, BLOCK_FLAGS_NOREAD);
+	if (rc != EOK)
+		return rc;
+	
+	uint8_t *bitmap = bitmap_block->data;
+	
+	/* Initialize all bitmap bits to zero */
+	uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock);
+	uint32_t inodes_per_group =
+	    ext4_superblock_get_inodes_per_group(bg_ref->fs->superblock);
+	memset(bitmap, 0, (inodes_per_group + 7) / 8);
+	
+	uint32_t start_bit = inodes_per_group;
+	uint32_t end_bit = block_size * 8;
+	
+	uint32_t i;
+	for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
+		ext4_bitmap_set_bit(bitmap, i);
+	
+	if (i < end_bit)
+		memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
+	
+	bitmap_block->dirty = true;
+	
+	/* Save bitmap */
+	return block_put(bitmap_block);
+}
+
+/** Initialize i-node table in block group.
+ *
+ * @param bg_ref Reference to block group
+ *
+ * @return Error code
+ *
+ */
+static int ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref)
+{
+	ext4_superblock_t *sb = bg_ref->fs->superblock;
+	
+	uint32_t inode_size = ext4_superblock_get_inode_size(sb);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	uint32_t inodes_per_block = block_size / inode_size;
+	
+	uint32_t inodes_in_group =
+	    ext4_superblock_get_inodes_in_group(sb, bg_ref->index);
+	
+	uint32_t table_blocks = inodes_in_group / inodes_per_block;
+	
+	if (inodes_in_group % inodes_per_block)
+		table_blocks++;
+	
+	/* Compute initialization bounds */
+	uint32_t first_block = ext4_block_group_get_inode_table_first_block(
+	    bg_ref->block_group, sb);
+	
+	uint32_t last_block = first_block + table_blocks - 1;
+	
+	/* Initialization of all itable blocks */
+	for (uint32_t fblock = first_block; fblock <= last_block; ++fblock) {
+		block_t *block;
+		int rc = block_get(&block, bg_ref->fs->device, fblock,
+		    BLOCK_FLAGS_NOREAD);
+		if (rc != EOK)
+			return rc;
+		
+		memset(block->data, 0, block_size);
+		block->dirty = true;
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+	}
+	
+	return EOK;
+}
+
+/** Get reference to block group specified by index.
+ *
+ * @param fs   Filesystem to find block group on
+ * @param bgid Index of block group to load
+ * @param ref  Output pointer for reference
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid,
+    ext4_block_group_ref_t **ref)
+{
+	/* Allocate memory for new structure */
+	ext4_block_group_ref_t *newref =
+	    malloc(sizeof(ext4_block_group_ref_t));
+	if (newref == NULL)
+		return ENOMEM;
+	
+	/* Compute number of descriptors, that fits in one data block */
+	uint32_t descriptors_per_block =
+	    ext4_superblock_get_block_size(fs->superblock) /
+	    ext4_superblock_get_desc_size(fs->superblock);
+	
+	/* Block group descriptor table starts at the next block after superblock */
+	aoff64_t block_id =
+	    ext4_superblock_get_first_data_block(fs->superblock) + 1;
+	
+	/* Find the block containing the descriptor we are looking for */
+	block_id += bgid / descriptors_per_block;
+	uint32_t offset = (bgid % descriptors_per_block) *
+	    ext4_superblock_get_desc_size(fs->superblock);
+	
+	/* Load block with descriptors */
+	int rc = block_get(&newref->block, fs->device, block_id, 0);
+	if (rc != EOK) {
+		free(newref);
+		return rc;
+	}
+	
+	/* Inititialize in-memory representation */
+	newref->block_group = newref->block->data + offset;
+	newref->fs = fs;
+	newref->index = bgid;
+	newref->dirty = false;
+	
+	*ref = newref;
+	
+	if (ext4_block_group_has_flag(newref->block_group,
+	    EXT4_BLOCK_GROUP_BLOCK_UNINIT)) {
+		rc = ext4_filesystem_init_block_bitmap(newref);
+		if (rc != EOK) {
+			block_put(newref->block);
+			free(newref);
+			return rc;
+		}
+		
+		ext4_block_group_clear_flag(newref->block_group,
+		    EXT4_BLOCK_GROUP_BLOCK_UNINIT);
+		
+		newref->dirty = true;
+	}
+	
+	if (ext4_block_group_has_flag(newref->block_group,
+	    EXT4_BLOCK_GROUP_INODE_UNINIT)) {
+		rc = ext4_filesystem_init_inode_bitmap(newref);
+		if (rc != EOK) {
+			block_put(newref->block);
+			free(newref);
+			return rc;
+		}
+		
+		ext4_block_group_clear_flag(newref->block_group,
+		    EXT4_BLOCK_GROUP_INODE_UNINIT);
+		
+		if (!ext4_block_group_has_flag(newref->block_group,
+		    EXT4_BLOCK_GROUP_ITABLE_ZEROED)) {
+			rc = ext4_filesystem_init_inode_table(newref);
+			if (rc != EOK)
+				return rc;
+			
+			ext4_block_group_set_flag(newref->block_group,
+			    EXT4_BLOCK_GROUP_ITABLE_ZEROED);
+		}
+		
+		newref->dirty = true;
+	}
+	
+	return EOK;
+}
+
+/** Compute checksum of block group descriptor.
+ *
+ * It uses crc functions from Linux kernel implementation.
+ *
+ * @param sb   Superblock
+ * @param bgid Index of block group in the filesystem
+ * @param bg   Block group to compute checksum for
+ *
+ * @return Checksum value
+ *
+ */
+static uint16_t ext4_filesystem_bg_checksum(ext4_superblock_t *sb, uint32_t bgid,
+    ext4_block_group_t *bg)
+{
+	/* If checksum not supported, 0 will be returned */
+	uint16_t crc = 0;
+	
+	/* Compute the checksum only if the filesystem supports it */
+	if (ext4_superblock_has_feature_read_only(sb,
+	    EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
+		void *base = bg;
+		void *checksum = &bg->checksum;
+		
+		uint32_t offset = (uint32_t) (checksum - base);
+		
+		/* Convert block group index to little endian */
+		uint32_t le_group = host2uint32_t_le(bgid);
+		
+		/* Initialization */
+		crc = crc16(~0, sb->uuid, sizeof(sb->uuid));
+		
+		/* Include index of block group */
+		crc = crc16(crc, (uint8_t *) &le_group, sizeof(le_group));
+		
+		/* Compute crc from the first part (stop before checksum field) */
+		crc = crc16(crc, (uint8_t *) bg, offset);
+		
+		/* Skip checksum */
+		offset += sizeof(bg->checksum);
+		
+		/* Checksum of the rest of block group descriptor */
+		if ((ext4_superblock_has_feature_incompatible(sb,
+		    EXT4_FEATURE_INCOMPAT_64BIT)) &&
+		    (offset < ext4_superblock_get_desc_size(sb)))
+			crc = crc16(crc, ((uint8_t *) bg) + offset,
+			    ext4_superblock_get_desc_size(sb) - offset);
+	}
+	
+	return crc;
+}
+
+/** Put reference to block group.
+ *
+ * @oaram ref Pointer for reference to be put back
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref)
+{
+	/* Check if reference modified */
+	if (ref->dirty) {
+		/* Compute new checksum of block group */
+		uint16_t checksum =
+		    ext4_filesystem_bg_checksum(ref->fs->superblock, ref->index,
+		    ref->block_group);
+		ext4_block_group_set_checksum(ref->block_group, checksum);
+		
+		/* Mark block dirty for writing changes to physical device */
+		ref->block->dirty = true;
+	}
+	
+	/* Put back block, that contains block group descriptor */
+	int rc = block_put(ref->block);
+	free(ref);
+	
+	return rc;
+}
+
+/** Get reference to i-node specified by index.
+ *
+ * @param fs    Filesystem to find i-node on
+ * @param index Index of i-node to load
+ * @oaram ref   Output pointer for reference
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index,
+    ext4_inode_ref_t **ref)
+{
+	/* Allocate memory for new structure */
+	ext4_inode_ref_t *newref =
+	    malloc(sizeof(ext4_inode_ref_t));
+	if (newref == NULL)
+		return ENOMEM;
+	
+	/* Compute number of i-nodes, that fits in one data block */
+	uint32_t inodes_per_group =
+	    ext4_superblock_get_inodes_per_group(fs->superblock);
+	
+	/*
+	 * Inode numbers are 1-based, but it is simpler to work with 0-based
+	 * when computing indices
+	 */
+	index -= 1;
+	uint32_t block_group = index / inodes_per_group;
+	uint32_t offset_in_group = index % inodes_per_group;
+	
+	/* Load block group, where i-node is located */
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+	if (rc != EOK) {
+		free(newref);
+		return rc;
+	}
+	
+	/* Load block address, where i-node table is located */
+	uint32_t inode_table_start =
+	    ext4_block_group_get_inode_table_first_block(bg_ref->block_group,
+	    fs->superblock);
+	
+	/* Put back block group reference (not needed more) */
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	if (rc != EOK) {
+		free(newref);
+		return rc;
+	}
+	
+	/* Compute position of i-node in the block group */
+	uint16_t inode_size = ext4_superblock_get_inode_size(fs->superblock);
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
+	uint32_t byte_offset_in_group = offset_in_group * inode_size;
+	
+	/* Compute block address */
+	aoff64_t block_id = inode_table_start + (byte_offset_in_group / block_size);
+	rc = block_get(&newref->block, fs->device, block_id, 0);
+	if (rc != EOK) {
+		free(newref);
+		return rc;
+	}
+	
+	/* Compute position of i-node in the data block */
+	uint32_t offset_in_block = byte_offset_in_group % block_size;
+	newref->inode = newref->block->data + offset_in_block;
+	
+	/* We need to store the original value of index in the reference */
+	newref->index = index + 1;
+	newref->fs = fs;
+	newref->dirty = false;
+	
+	*ref = newref;
+	
+	return EOK;
+}
+
+/** Put reference to i-node.
+ *
+ * @param ref Pointer for reference to be put back
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
+{
+	/* Check if reference modified */
+	if (ref->dirty) {
+		/* Mark block dirty for writing changes to physical device */
+		ref->block->dirty = true;
+	}
+	
+	/* Put back block, that contains i-node */
+	int rc = block_put(ref->block);
+	free(ref);
+	
+	return rc;
+}
+
+/** Allocate new i-node in the filesystem.
+ *
+ * @param fs        Filesystem to allocated i-node on
+ * @param inode_ref Output pointer to return reference to allocated i-node
+ * @param flags     Flags to be set for newly created i-node
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
+    ext4_inode_ref_t **inode_ref, int flags)
+{
+	/* Check if newly allocated i-node will be a directory */
+	bool is_dir = false;
+	if (flags & L_DIRECTORY)
+		is_dir = true;
+	
+	/* Allocate inode by allocation algorithm */
+	uint32_t index;
+	int rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
+	if (rc != EOK)
+		return rc;
+	
+	/* Load i-node from on-disk i-node table */
+	rc = ext4_filesystem_get_inode_ref(fs, index, inode_ref);
+	if (rc != EOK) {
+		ext4_ialloc_free_inode(fs, index, is_dir);
+		return rc;
+	}
+	
+	/* Initialize i-node */
+	ext4_inode_t *inode = (*inode_ref)->inode;
+	
+	uint16_t mode;
+	if (is_dir) {
+		/*
+		 * Default directory permissions to be compatible with other systems
+		 * 0777 (octal) == rwxrwxrwx
+		 */
+		
+		mode = 0777;
+		mode |= EXT4_INODE_MODE_DIRECTORY;
+		ext4_inode_set_mode(fs->superblock, inode, mode);
+		ext4_inode_set_links_count(inode, 1);  /* '.' entry */
+	} else {
+		/*
+		 * Default file permissions to be compatible with other systems
+		 * 0666 (octal) == rw-rw-rw-
+		 */
+		
+		mode = 0666;
+		mode |= EXT4_INODE_MODE_FILE;
+		ext4_inode_set_mode(fs->superblock, inode, mode);
+		ext4_inode_set_links_count(inode, 0);
+	}
+	
+	ext4_inode_set_uid(inode, 0);
+	ext4_inode_set_gid(inode, 0);
+	ext4_inode_set_size(inode, 0);
+	ext4_inode_set_access_time(inode, 0);
+	ext4_inode_set_change_inode_time(inode, 0);
+	ext4_inode_set_modification_time(inode, 0);
+	ext4_inode_set_deletion_time(inode, 0);
+	ext4_inode_set_blocks_count(fs->superblock, inode, 0);
+	ext4_inode_set_flags(inode, 0);
+	ext4_inode_set_generation(inode, 0);
+	
+	/* Reset blocks array */
+	for (uint32_t i = 0; i < EXT4_INODE_BLOCKS; i++)
+		inode->blocks[i] = 0;
+	
+	/* Initialize extents if needed */
+	if (ext4_superblock_has_feature_incompatible(
+	    fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
+		ext4_inode_set_flag(inode, EXT4_INODE_FLAG_EXTENTS);
+		
+		/* Initialize extent root header */
+		ext4_extent_header_t *header = ext4_inode_get_extent_header(inode);
+		ext4_extent_header_set_depth(header, 0);
+		ext4_extent_header_set_entries_count(header, 0);
+		ext4_extent_header_set_generation(header, 0);
+		ext4_extent_header_set_magic(header, EXT4_EXTENT_MAGIC);
+		
+		uint16_t max_entries = (EXT4_INODE_BLOCKS * sizeof(uint32_t) -
+		    sizeof(ext4_extent_header_t)) / sizeof(ext4_extent_t);
+		
+		ext4_extent_header_set_max_entries_count(header, max_entries);
+	}
+	
+	(*inode_ref)->dirty = true;
+	
+	return EOK;
+}
+
+/** Release i-node and mark it as free.
+ *
+ * @param inode_ref I-node to be released
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref)
+{
+	ext4_filesystem_t *fs = inode_ref->fs;
+	
+	/* For extents must be data block destroyed by other way */
+	if ((ext4_superblock_has_feature_incompatible(fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
+		/* Data structures are released during truncate operation... */
+		goto finish;
+	}
+	
+	/* Release all indirect (no data) blocks */
+	
+	/* 1) Single indirect */
+	uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
+	if (fblock != 0) {
+		int rc = ext4_balloc_free_block(inode_ref, fblock);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_inode_set_indirect_block(inode_ref->inode, 0, 0);
+	}
+	
+	block_t *block;
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
+	uint32_t count = block_size / sizeof(uint32_t);
+	
+	/* 2) Double indirect */
+	fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1);
+	if (fblock != 0) {
+		int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		uint32_t ind_block;
+		for (uint32_t offset = 0; offset < count; ++offset) {
+			ind_block = uint32_t_le2host(((uint32_t *) block->data)[offset]);
+			
+			if (ind_block != 0) {
+				rc = ext4_balloc_free_block(inode_ref, ind_block);
+				if (rc != EOK) {
+					block_put(block);
+					return rc;
+				}
+			}
+		}
+		
+		block_put(block);
+		rc = ext4_balloc_free_block(inode_ref, fblock);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_inode_set_indirect_block(inode_ref->inode, 1, 0);
+	}
+	
+	/* 3) Tripple indirect */
+	block_t *subblock;
+	fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2);
+	if (fblock != 0) {
+		int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
+		if (rc != EOK)
+			return rc;
+		
+		uint32_t ind_block;
+		for (uint32_t offset = 0; offset < count; ++offset) {
+			ind_block = uint32_t_le2host(((uint32_t *) block->data)[offset]);
+			
+			if (ind_block != 0) {
+				rc = block_get(&subblock, fs->device, ind_block,
+				    BLOCK_FLAGS_NONE);
+				if (rc != EOK) {
+					block_put(block);
+					return rc;
+				}
+				
+				uint32_t ind_subblock;
+				for (uint32_t suboffset = 0; suboffset < count;
+				    ++suboffset) {
+					ind_subblock = uint32_t_le2host(((uint32_t *)
+					    subblock->data)[suboffset]);
+					
+					if (ind_subblock != 0) {
+						rc = ext4_balloc_free_block(inode_ref, ind_subblock);
+						if (rc != EOK) {
+							block_put(subblock);
+							block_put(block);
+							return rc;
+						}
+					}
+				}
+				
+				block_put(subblock);
+			}
+			
+			rc = ext4_balloc_free_block(inode_ref, ind_block);
+			if (rc != EOK) {
+				block_put(block);
+				return rc;
+			}
+		}
+		
+		block_put(block);
+		rc = ext4_balloc_free_block(inode_ref, fblock);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_inode_set_indirect_block(inode_ref->inode, 2, 0);
+	}
+	
+finish:
+	/* Mark inode dirty for writing to the physical device */
+	inode_ref->dirty = true;
+	
+	/* Free block with extended attributes if present */
+	uint32_t xattr_block = ext4_inode_get_file_acl(
+	    inode_ref->inode, fs->superblock);
+	if (xattr_block) {
+		int rc = ext4_balloc_free_block(inode_ref, xattr_block);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_inode_set_file_acl(inode_ref->inode, fs->superblock, 0);
+	}
+	
+	/* Free inode by allocator */
+	int rc;
+	if (ext4_inode_is_type(fs->superblock, inode_ref->inode,
+	    EXT4_INODE_MODE_DIRECTORY))
+		rc = ext4_ialloc_free_inode(fs, inode_ref->index, true);
+	else
+		rc = ext4_ialloc_free_inode(fs, inode_ref->index, false);
+	
+	return rc;
+}
+
+/** Truncate i-node data blocks.
+ *
+ * @param inode_ref I-node to be truncated
+ * @param new_size  New size of inode (must be < current size)
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_truncate_inode(ext4_inode_ref_t *inode_ref,
+    aoff64_t new_size)
+{
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	
+	/* Check flags, if i-node can be truncated */
+	if (!ext4_inode_can_truncate(sb, inode_ref->inode))
+		return EINVAL;
+	
+	/* If sizes are equal, nothing has to be done. */
+	aoff64_t old_size = ext4_inode_get_size(sb, inode_ref->inode);
+	if (old_size == new_size)
+		return EOK;
+	
+	/* It's not suppported to make the larger file by truncate operation */
+	if (old_size < new_size)
+		return EINVAL;
+	
+	/* Compute how many blocks will be released */
+	aoff64_t size_diff = old_size - new_size;
+	uint32_t block_size  = ext4_superblock_get_block_size(sb);
+	uint32_t diff_blocks_count = size_diff / block_size;
+	if (size_diff % block_size != 0)
+		diff_blocks_count++;
+	
+	uint32_t old_blocks_count = old_size / block_size;
+	if (old_size % block_size != 0)
+		old_blocks_count++;
+	
+	if ((ext4_superblock_has_feature_incompatible(inode_ref->fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
+		/* Extents require special operation */
+		int rc = ext4_extent_release_blocks_from(inode_ref,
+		    old_blocks_count - diff_blocks_count);
+		if (rc != EOK)
+			return rc;
+	} else {
+		/* Release data blocks from the end of file */
+		
+		/* Starting from 1 because of logical blocks are numbered from 0 */
+		for (uint32_t i = 1; i <= diff_blocks_count; ++i) {
+			int rc = ext4_filesystem_release_inode_block(inode_ref,
+			    old_blocks_count - i);
+			if (rc != EOK)
+				return rc;
+		}
+	}
+	
+	/* Update i-node */
+	ext4_inode_set_size(inode_ref->inode, new_size);
+	inode_ref->dirty = true;
+	
+	return EOK;
+}
+
+/** Get physical block address by logical index of the block.
+ *
+ * @param inode_ref I-node to read block address from
+ * @param iblock    Logical index of block
+ * @param fblock    Output pointer for return physical block address
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref,
+    aoff64_t iblock, uint32_t *fblock)
+{
+	ext4_filesystem_t *fs = inode_ref->fs;
+	
+	/* For empty file is situation simple */
+	if (ext4_inode_get_size(fs->superblock, inode_ref->inode) == 0) {
+		*fblock = 0;
+		return EOK;
+	}
+	
+	uint32_t current_block;
+	
+	/* Handle i-node using extents */
+	if ((ext4_superblock_has_feature_incompatible(fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
+		int rc = ext4_extent_find_block(inode_ref, iblock, &current_block);
+		if (rc != EOK)
+			return rc;
+		
+		*fblock = current_block;
+		return EOK;
+	}
+	
+	ext4_inode_t *inode = inode_ref->inode;
+	
+	/* Direct block are read directly from array in i-node structure */
+	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
+		current_block = ext4_inode_get_direct_block(inode, (uint32_t) iblock);
+		*fblock = current_block;
+		return EOK;
+	}
+	
+	/* Determine indirection level of the target block */
+	unsigned int level = 0;
+	for (unsigned int i = 1; i < 4; i++) {
+		if (iblock < fs->inode_block_limits[i]) {
+			level = i;
+			break;
+		}
+	}
+	
+	if (level == 0)
+		return EIO;
+	
+	/* Compute offsets for the topmost level */
+	aoff64_t block_offset_in_level =
+	    iblock - fs->inode_block_limits[level - 1];
+	current_block = ext4_inode_get_indirect_block(inode, level - 1);
+	uint32_t offset_in_block =
+	    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	
+	/* Sparse file */
+	if (current_block == 0) {
+		*fblock = 0;
+		return EOK;
+	}
+	
+	block_t *block;
+	
+	/*
+	 * Navigate through other levels, until we find the block number
+	 * or find null reference meaning we are dealing with sparse file
+	 */
+	while (level > 0) {
+		/* Load indirect block */
+		int rc = block_get(&block, fs->device, current_block, 0);
+		if (rc != EOK)
+			return rc;
+		
+		/* Read block address from indirect block */
+		current_block =
+		    uint32_t_le2host(((uint32_t *) block->data)[offset_in_block]);
+		
+		/* Put back indirect block untouched */
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+		
+		/* Check for sparse file */
+		if (current_block == 0) {
+			*fblock = 0;
+			return EOK;
+		}
+		
+		/* Jump to the next level */
+		level--;
+		
+		/* Termination condition - we have address of data block loaded */
+		if (level == 0)
+			break;
+		
+		/* Visit the next level */
+		block_offset_in_level %= fs->inode_blocks_per_level[level];
+		offset_in_block =
+		    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	}
+	
+	*fblock = current_block;
+	
+	return EOK;
+}
+
+/** Set physical block address for the block logical address into the i-node.
+ *
+ * @param inode_ref I-node to set block address to
+ * @param iblock    Logical index of block
+ * @param fblock    Physical block address
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref,
+    aoff64_t iblock, uint32_t fblock)
+{
+	ext4_filesystem_t *fs = inode_ref->fs;
+	
+	/* Handle inode using extents */
+	if ((ext4_superblock_has_feature_compatible(fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
+		/* Not reachable */
+		return ENOTSUP;
+	}
+	
+	/* Handle simple case when we are dealing with direct reference */
+	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
+		ext4_inode_set_direct_block(inode_ref->inode, (uint32_t) iblock, fblock);
+		inode_ref->dirty = true;
+		
+		return EOK;
+	}
+	
+	/* Determine the indirection level needed to get the desired block */
+	unsigned int level = 0;
+	for (unsigned int i = 1; i < 4; i++) {
+		if (iblock < fs->inode_block_limits[i]) {
+			level = i;
+			break;
+		}
+	}
+	
+	if (level == 0)
+		return EIO;
+	
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
+	
+	/* Compute offsets for the topmost level */
+	aoff64_t block_offset_in_level =
+	    iblock - fs->inode_block_limits[level - 1];
+	uint32_t current_block =
+	    ext4_inode_get_indirect_block(inode_ref->inode, level - 1);
+	uint32_t offset_in_block =
+	    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	
+	uint32_t new_block_addr;
+	block_t *block;
+	block_t *new_block;
+	
+	/* Is needed to allocate indirect block on the i-node level */
+	if (current_block == 0) {
+		/* Allocate new indirect block */
+		int rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
+		if (rc != EOK)
+			return rc;
+		
+		/* Update i-node */
+		ext4_inode_set_indirect_block(inode_ref->inode, level - 1,
+		    new_block_addr);
+		inode_ref->dirty = true;
+		
+		/* Load newly allocated block */
+		rc = block_get(&new_block, fs->device, new_block_addr,
+		    BLOCK_FLAGS_NOREAD);
+		if (rc != EOK) {
+			ext4_balloc_free_block(inode_ref, new_block_addr);
+			return rc;
+		}
+		
+		/* Initialize new block */
+		memset(new_block->data, 0, block_size);
+		new_block->dirty = true;
+		
+		/* Put back the allocated block */
+		rc = block_put(new_block);
+		if (rc != EOK)
+			return rc;
+		
+		current_block = new_block_addr;
+	}
+	
+	/*
+	 * Navigate through other levels, until we find the block number
+	 * or find null reference meaning we are dealing with sparse file
+	 */
+	while (level > 0) {
+		int rc = block_get(&block, fs->device, current_block, 0);
+		if (rc != EOK)
+			return rc;
+		
+		current_block =
+		    uint32_t_le2host(((uint32_t *) block->data)[offset_in_block]);
+		
+		if ((level > 1) && (current_block == 0)) {
+			/* Allocate new block */
+			rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
+			if (rc != EOK) {
+				block_put(block);
+				return rc;
+			}
+			
+			/* Load newly allocated block */
+			rc = block_get(&new_block, fs->device, new_block_addr,
+			    BLOCK_FLAGS_NOREAD);
+			if (rc != EOK) {
+				block_put(block);
+				return rc;
+			}
+			
+			/* Initialize allocated block */
+			memset(new_block->data, 0, block_size);
+			new_block->dirty = true;
+			
+			rc = block_put(new_block);
+			if (rc != EOK) {
+				block_put(block);
+				return rc;
+			}
+			
+			/* Write block address to the parent */
+			((uint32_t *) block->data)[offset_in_block] =
+			    host2uint32_t_le(new_block_addr);
+			block->dirty = true;
+			current_block = new_block_addr;
+		}
+		
+		/* Will be finished, write the fblock address */
+		if (level == 1) {
+			((uint32_t *) block->data)[offset_in_block] =
+			    host2uint32_t_le(fblock);
+			block->dirty = true;
+		}
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+		
+		level--;
+		
+		/*
+		 * If we are on the last level, break here as
+		 * there is no next level to visit
+		 */
+		if (level == 0)
+			break;
+		
+		/* Visit the next level */
+		block_offset_in_level %= fs->inode_blocks_per_level[level];
+		offset_in_block =
+		    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	}
+	
+	return EOK;
+}
+
+/** Release data block from i-node
+ *
+ * @param inode_ref I-node to release block from
+ * @param iblock    Logical block to be released
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_release_inode_block(ext4_inode_ref_t *inode_ref,
+    uint32_t iblock)
+{
+	uint32_t fblock;
+	
+	ext4_filesystem_t *fs = inode_ref->fs;
+	
+	/* Extents are handled otherwise = there is not support in this function */
+	assert(!(ext4_superblock_has_feature_incompatible(fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))));
+	
+	ext4_inode_t *inode = inode_ref->inode;
+	
+	/* Handle simple case when we are dealing with direct reference */
+	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
+		fblock = ext4_inode_get_direct_block(inode, iblock);
+		
+		/* Sparse file */
+		if (fblock == 0)
+			return EOK;
+		
+		ext4_inode_set_direct_block(inode, iblock, 0);
+		return ext4_balloc_free_block(inode_ref, fblock);
+	}
+	
+	/* Determine the indirection level needed to get the desired block */
+	unsigned int level = 0;
+	for (unsigned int i = 1; i < 4; i++) {
+		if (iblock < fs->inode_block_limits[i]) {
+			level = i;
+			break;
+		}
+	}
+	
+	if (level == 0)
+		return EIO;
+	
+	/* Compute offsets for the topmost level */
+	aoff64_t block_offset_in_level =
+	    iblock - fs->inode_block_limits[level - 1];
+	uint32_t current_block =
+	    ext4_inode_get_indirect_block(inode, level - 1);
+	uint32_t offset_in_block =
+	    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	
+	/*
+	 * Navigate through other levels, until we find the block number
+	 * or find null reference meaning we are dealing with sparse file
+	 */
+	block_t *block;
+	while (level > 0) {
+		int rc = block_get(&block, fs->device, current_block, 0);
+		if (rc != EOK)
+			return rc;
+		
+		current_block =
+		    uint32_t_le2host(((uint32_t *) block->data)[offset_in_block]);
+		
+		/* Set zero if physical data block address found */
+		if (level == 1) {
+			((uint32_t *) block->data)[offset_in_block] =
+			    host2uint32_t_le(0);
+			block->dirty = true;
+		}
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+		
+		level--;
+		
+		/*
+		 * If we are on the last level, break here as
+		 * there is no next level to visit
+		 */
+		if (level == 0)
+			break;
+		
+		/* Visit the next level */
+		block_offset_in_level %= fs->inode_blocks_per_level[level];
+		offset_in_block =
+		    block_offset_in_level / fs->inode_blocks_per_level[level - 1];
+	}
+	
+	fblock = current_block;
+	if (fblock == 0)
+		return EOK;
+	
+	/* Physical block is not referenced, it can be released */
+	return ext4_balloc_free_block(inode_ref, fblock);
+}
+
+/** Append following logical block to the i-node.
+ *
+ * @param inode_ref I-node to append block to
+ * @param fblock    Output physical block address of newly allocated block
+ * @param iblock    Output logical number of newly allocated block
+ *
+ * @return Error code
+ *
+ */
+int ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref,
+    uint32_t *fblock, uint32_t *iblock)
+{
+	/* Handle extents separately */
+	if ((ext4_superblock_has_feature_incompatible(inode_ref->fs->superblock,
+	    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+	    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)))
+		return ext4_extent_append_block(inode_ref, iblock, fblock, true);
+	
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	
+	/* Compute next block index and allocate data block */
+	uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	
+	/* Align size i-node size */
+	if ((inode_size % block_size) != 0)
+		inode_size += block_size - (inode_size % block_size);
+	
+	/* Logical blocks are numbered from 0 */
+	uint32_t new_block_idx = inode_size / block_size;
+	
+	/* Allocate new physical block */
+	uint32_t phys_block;
+	int rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
+	if (rc != EOK)
+		return rc;
+	
+	/* Add physical block address to the i-node */
+	rc = ext4_filesystem_set_inode_data_block_index(inode_ref,
+	    new_block_idx, phys_block);
+	if (rc != EOK) {
+		ext4_balloc_free_block(inode_ref, phys_block);
+		return rc;
+	}
+	
+	/* Update i-node */
+	ext4_inode_set_size(inode_ref->inode, inode_size + block_size);
+	inode_ref->dirty = true;
+	
+	*fblock = phys_block;
+	*iblock = new_block_idx;
+	
+	return EOK;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_filesystem.h
===================================================================
--- uspace/lib/ext4/libext4_filesystem.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_filesystem.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_FILESYSTEM_H_
+#define LIBEXT4_LIBEXT4_FILESYSTEM_H_
+
+#include <libblock.h>
+#include "libext4_types.h"
+
+extern int ext4_filesystem_init(ext4_filesystem_t *, service_id_t,
+    enum cache_mode);
+extern int ext4_filesystem_fini(ext4_filesystem_t *);
+extern int ext4_filesystem_check_sanity(ext4_filesystem_t *);
+extern int ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
+extern uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *,
+    uint32_t);
+extern uint32_t ext4_filesystem_index_in_group2blockaddr(ext4_superblock_t *,
+    uint32_t, uint32_t);
+extern int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *, uint32_t,
+    ext4_block_group_ref_t **);
+extern int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *);
+extern int ext4_filesystem_get_inode_ref(ext4_filesystem_t *, uint32_t,
+    ext4_inode_ref_t **);
+extern int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *);
+extern int ext4_filesystem_alloc_inode(ext4_filesystem_t *, ext4_inode_ref_t **,
+    int);
+extern int ext4_filesystem_free_inode(ext4_inode_ref_t *);
+extern int ext4_filesystem_truncate_inode(ext4_inode_ref_t *, aoff64_t);
+extern int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *,
+    aoff64_t iblock, uint32_t *);
+extern int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *,
+    aoff64_t, uint32_t);
+extern int ext4_filesystem_release_inode_block(ext4_inode_ref_t *, uint32_t);
+extern int ext4_filesystem_append_inode_block(ext4_inode_ref_t *, uint32_t *,
+    uint32_t *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_hash.c
===================================================================
--- uspace/lib/ext4/libext4_hash.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_hash.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_hash.c
+ * @brief Hashing algorithms for ext4 HTree.
+ */
+
+#include <errno.h>
+#include <mem.h>
+#include "libext4.h"
+
+#define TEA_DELTA  0x9E3779B9
+
+/* F, G and H are basic MD4 functions: selection, majority, parity */
+#define F(x, y, z)  ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)  (((x) & (y)) + (((x) ^ (y)) & (z)))
+#define H(x, y, z)  ((x) ^ (y) ^ (z))
+
+/*
+ * The generic round function.  The application is so specific that
+ * we don't bother protecting all the arguments with parens, as is generally
+ * good macro practice, in favor of extra legibility.
+ * Rotation is separate from addition to prevent recomputation
+ */
+#define ROUND(f, a, b, c, d, x, s) \
+	(a += f(b, c, d) + x, a = (a << s) | (a >> (32 - s)))
+
+#define K1  0
+#define K2  013240474631UL
+#define K3  015666365641UL
+
+static void tea_transform(uint32_t buf[4], uint32_t const in[])
+{
+	uint32_t sum = 0;
+	uint32_t b0 = buf[0];
+	uint32_t b1 = buf[1];
+	uint32_t a = in[0];
+	uint32_t b = in[1];
+	uint32_t c = in[2];
+	uint32_t d = in[3];
+	
+	int n = 16;
+	
+	do {
+		sum += TEA_DELTA;
+		b0 += ((b1 << 4) + a) ^ (b1 + sum) ^ ((b1 >> 5) + b);
+		b1 += ((b0 << 4) + c) ^ (b0 + sum) ^ ((b0 >> 5) + d);
+	} while (--n);
+	
+	buf[0] += b0;
+	buf[1] += b1;
+}
+
+
+static void half_md4_transform(uint32_t buf[4], const uint32_t in[8])
+{
+	uint32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];
+	
+	/* Round 1 */
+	ROUND(F, a, b, c, d, in[0] + K1,  3);
+	ROUND(F, d, a, b, c, in[1] + K1,  7);
+	ROUND(F, c, d, a, b, in[2] + K1, 11);
+	ROUND(F, b, c, d, a, in[3] + K1, 19);
+	ROUND(F, a, b, c, d, in[4] + K1,  3);
+	ROUND(F, d, a, b, c, in[5] + K1,  7);
+	ROUND(F, c, d, a, b, in[6] + K1, 11);
+	ROUND(F, b, c, d, a, in[7] + K1, 19);
+	
+	/* Round 2 */
+	ROUND(G, a, b, c, d, in[1] + K2,  3);
+	ROUND(G, d, a, b, c, in[3] + K2,  5);
+	ROUND(G, c, d, a, b, in[5] + K2,  9);
+	ROUND(G, b, c, d, a, in[7] + K2, 13);
+	ROUND(G, a, b, c, d, in[0] + K2,  3);
+	ROUND(G, d, a, b, c, in[2] + K2,  5);
+	ROUND(G, c, d, a, b, in[4] + K2,  9);
+	ROUND(G, b, c, d, a, in[6] + K2, 13);
+	
+	/* Round 3 */
+	ROUND(H, a, b, c, d, in[3] + K3,  3);
+	ROUND(H, d, a, b, c, in[7] + K3,  9);
+	ROUND(H, c, d, a, b, in[2] + K3, 11);
+	ROUND(H, b, c, d, a, in[6] + K3, 15);
+	ROUND(H, a, b, c, d, in[1] + K3,  3);
+	ROUND(H, d, a, b, c, in[5] + K3,  9);
+	ROUND(H, c, d, a, b, in[0] + K3, 11);
+	ROUND(H, b, c, d, a, in[4] + K3, 15);
+	
+	buf[0] += a;
+	buf[1] += b;
+	buf[2] += c;
+	buf[3] += d;
+}
+
+static uint32_t hash_unsigned(const char *name, int len)
+{
+	uint32_t hash;
+	uint32_t hash0 = 0x12a3fe2d;
+	uint32_t hash1 = 0x37abe8f9;
+	const unsigned char *ucp = (const unsigned char *) name;
+	
+	while (len--) {
+		hash = hash1 + (hash0 ^ (((int) *ucp++) * 7152373));
+		
+		if (hash & 0x80000000)
+			hash -= 0x7fffffff;
+		
+		hash1 = hash0;
+		hash0 = hash;
+	}
+	
+	return hash0 << 1;
+}
+
+static uint32_t hash_signed(const char *name, int len)
+{
+	uint32_t hash;
+	uint32_t hash0 = 0x12a3fe2d;
+	uint32_t hash1 = 0x37abe8f9;
+	const signed char *scp = (const signed char *) name;
+	
+	while (len--) {
+		hash = hash1 + (hash0 ^ (((int) *scp++) * 7152373));
+		
+		if (hash & 0x80000000)
+			hash -= 0x7fffffff;
+		
+		hash1 = hash0;
+		hash0 = hash;
+	}
+	
+	return hash0 << 1;
+}
+
+static void str2hashbuf_signed(const char *msg, int len, uint32_t *buf, int num)
+{
+	uint32_t pad, val;
+	int i;
+	const signed char *scp = (const signed char *) msg;
+	
+	pad = (uint32_t) len | ((uint32_t) len << 8);
+	pad |= pad << 16;
+	
+	val = pad;
+	if (len > num * 4)
+		len = num * 4;
+	
+	for (i = 0; i < len; i++) {
+		if ((i % 4) == 0)
+			val = pad;
+		
+		val = ((int) scp[i]) + (val << 8);
+		if ((i % 4) == 3) {
+			*buf++ = val;
+			val = pad;
+			num--;
+		}
+	}
+	
+	if (--num >= 0)
+		*buf++ = val;
+	
+	while (--num >= 0)
+		*buf++ = pad;
+}
+
+static void str2hashbuf_unsigned(const char *msg, int len, uint32_t *buf,
+    int num)
+{
+	uint32_t pad, val;
+	int i;
+	const unsigned char *ucp = (const unsigned char *) msg;
+	
+	pad = (uint32_t) len | ((uint32_t) len << 8);
+	pad |= pad << 16;
+	
+	val = pad;
+	if (len > num * 4)
+		len = num * 4;
+	
+	for (i = 0; i < len; i++) {
+		if ((i % 4) == 0)
+			val = pad;
+		
+		val = ((int) ucp[i]) + (val << 8);
+		if ((i % 4) == 3) {
+			*buf++ = val;
+			val = pad;
+			num--;
+		}
+	}
+	
+	if (--num >= 0)
+		*buf++ = val;
+	
+	while (--num >= 0)
+		*buf++ = pad;
+}
+
+/** Compute hash value of the string.
+ *
+ * @param hinfo Hash info structure with information about
+ *              the algorithm, hash seed and with the place
+ *              for the output hash value
+ * @param len  Length of the name
+ * @param name Name to be hashed
+ *
+ * @return Error code
+ *
+ */
+int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
+{
+	uint32_t hash = 0;
+	uint32_t minor_hash = 0;
+	const char *p;
+	int i;
+	uint32_t in[8], buf[4];
+	void (*str2hashbuf)(const char *, int, uint32_t *, int) =
+	    str2hashbuf_signed;
+	
+	/* Initialize the default seed for the hash checksum functions */
+	buf[0] = 0x67452301;
+	buf[1] = 0xefcdab89;
+	buf[2] = 0x98badcfe;
+	buf[3] = 0x10325476;
+	
+	/* Check if the seed is all zero's */
+	if (hinfo->seed) {
+		for (i = 0; i < 4; i++) {
+			if (hinfo->seed[i] != 0)
+				break;
+			
+		}
+		
+		if (i < 4)
+			memcpy(buf, hinfo->seed, sizeof(buf));
+	}
+	
+	switch (hinfo->hash_version) {
+	case EXT4_HASH_VERSION_LEGACY_UNSIGNED:
+		hash = hash_unsigned(name, len);
+		break;
+	case EXT4_HASH_VERSION_LEGACY:
+		hash = hash_signed(name, len);
+		break;
+	case EXT4_HASH_VERSION_HALF_MD4_UNSIGNED:
+		str2hashbuf = str2hashbuf_unsigned;
+	case EXT4_HASH_VERSION_HALF_MD4:
+		p = name;
+		
+		while (len > 0) {
+			(*str2hashbuf)(p, len, in, 8);
+			half_md4_transform(buf, in);
+			len -= 32;
+			p += 32;
+		}
+		
+		minor_hash = buf[2];
+		hash = buf[1];
+		break;
+	case EXT4_HASH_VERSION_TEA_UNSIGNED:
+		str2hashbuf = str2hashbuf_unsigned;
+	case EXT4_HASH_VERSION_TEA:
+		p = name;
+		
+		while (len > 0) {
+			(*str2hashbuf)(p, len, in, 4);
+			tea_transform(buf, in);
+			len -= 16;
+			p += 16;
+		}
+		
+		hash = buf[0];
+		minor_hash = buf[1];
+		break;
+	default:
+		hinfo->hash = 0;
+		return EINVAL;
+	}
+	
+	hash = hash & ~1;
+	if (hash == (EXT4_DIRECTORY_HTREE_EOF << 1))
+		hash = (EXT4_DIRECTORY_HTREE_EOF - 1) << 1;
+	
+	hinfo->hash = hash;
+	hinfo->minor_hash = minor_hash;
+	
+	return EOK;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_hash.h
===================================================================
--- uspace/lib/ext4/libext4_hash.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_hash.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_HASH_H_
+#define LIBEXT4_LIBEXT4_HASH_H_
+
+#include <sys/types.h>
+#include "libext4_types.h"
+
+extern int ext4_hash_string(ext4_hash_info_t *, int, const char *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_ialloc.c
===================================================================
--- uspace/lib/ext4/libext4_ialloc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_ialloc.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_ialloc.c
+ * @brief I-node (de)allocation operations.
+ */
+
+#include <errno.h>
+#include <time.h>
+#include "libext4.h"
+
+
+/** Convert i-node number to relative index in block group.
+ *
+ * @param sb    Superblock
+ * @param inode I-node number to be converted
+ *
+ * @return Index of the i-node in the block group
+ *
+ */
+static uint32_t ext4_ialloc_inode2index_in_group(ext4_superblock_t *sb,
+    uint32_t inode)
+{
+	uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+	return (inode - 1) % inodes_per_group;
+}
+
+/** Convert relative index of i-node to absolute i-node number.
+ *
+ * @param sb    Superblock
+ * @param inode Index to be converted
+ *
+ * @return Absolute number of the i-node
+ *
+ */
+static uint32_t ext4_ialloc_index_in_group2inode(ext4_superblock_t *sb,
+    uint32_t index, uint32_t bgid)
+{
+	uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+	return bgid * inodes_per_group + (index + 1);
+}
+
+/** Compute block group number from the i-node number.
+ *
+ * @param sb    Superblock
+ * @param inode I-node number to be found the block group for
+ *
+ * @return Block group number computed from i-node number
+ *
+ */
+static uint32_t ext4_ialloc_get_bgid_of_inode(ext4_superblock_t *sb,
+    uint32_t inode)
+{
+	uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+	return (inode - 1) / inodes_per_group;
+}
+
+
+/** Free i-node number and modify filesystem data structers.
+ *
+ * @param fs     Filesystem, where the i-node is located
+ * @param index  Index of i-node to be release
+ * @param is_dir Flag us for information whether i-node is directory or not
+ *
+ */
+int ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir)
+{
+	ext4_superblock_t *sb = fs->superblock;
+	
+	/* Compute index of block group and load it */
+	uint32_t block_group = ext4_ialloc_get_bgid_of_inode(sb, index);
+	
+	ext4_block_group_ref_t *bg_ref;
+	int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Load i-node bitmap */
+	uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
+	    bg_ref->block_group, sb);
+	block_t *bitmap_block;
+	rc = block_get(&bitmap_block, fs->device, bitmap_block_addr,
+	    BLOCK_FLAGS_NONE);
+	if (rc != EOK)
+		return rc;
+	
+	/* Free i-node in the bitmap */
+	uint32_t index_in_group = ext4_ialloc_inode2index_in_group(sb, index);
+	ext4_bitmap_free_bit(bitmap_block->data, index_in_group);
+	bitmap_block->dirty = true;
+	
+	/* Put back the block with bitmap */
+	rc = block_put(bitmap_block);
+	if (rc != EOK) {
+		/* Error in saving bitmap */
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+	
+	/* If released i-node is a directory, decrement used directories count */
+	if (is_dir) {
+		uint32_t bg_used_dirs = ext4_block_group_get_used_dirs_count(
+		    bg_ref->block_group, sb);
+		bg_used_dirs--;
+		ext4_block_group_set_used_dirs_count(bg_ref->block_group, sb,
+		    bg_used_dirs);
+	}
+	
+	/* Update block group free inodes count */
+	uint32_t free_inodes = ext4_block_group_get_free_inodes_count(
+	    bg_ref->block_group, sb);
+	free_inodes++;
+	ext4_block_group_set_free_inodes_count(bg_ref->block_group, sb,
+	    free_inodes);
+	
+	bg_ref->dirty = true;
+	
+	/* Put back the modified block group */
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Update superblock free inodes count */
+	uint32_t sb_free_inodes =
+	    ext4_superblock_get_free_inodes_count(sb);
+	sb_free_inodes++;
+	ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
+	
+	return EOK;
+}
+
+/** I-node allocation algorithm.
+ *
+ * This is more simple algorithm, than Orlov allocator used
+ * in the Linux kernel.
+ *
+ * @param fs     Filesystem to allocate i-node on
+ * @param index  Output value - allocated i-node number
+ * @param is_dir Flag if allocated i-node will be file or directory
+ *
+ * @return Error code
+ *
+ */
+int ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir)
+{
+	ext4_superblock_t *sb = fs->superblock;
+	
+	uint32_t bgid = 0;
+	uint32_t bg_count = ext4_superblock_get_block_group_count(sb);
+	uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb);
+	uint32_t avg_free_inodes = sb_free_inodes / bg_count;
+	
+	/* Try to find free i-node in all block groups */
+	while (bgid < bg_count) {
+		/* Load block group to check */
+		ext4_block_group_ref_t *bg_ref;
+		int rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref);
+		if (rc != EOK)
+			return rc;
+		
+		ext4_block_group_t *bg = bg_ref->block_group;
+		
+		/* Read necessary values for algorithm */
+		uint32_t free_blocks = ext4_block_group_get_free_blocks_count(bg, sb);
+		uint32_t free_inodes = ext4_block_group_get_free_inodes_count(bg, sb);
+		uint32_t used_dirs = ext4_block_group_get_used_dirs_count(bg, sb);
+		
+		/* Check if this block group is good candidate for allocation */
+		if ((free_inodes >= avg_free_inodes) && (free_blocks > 0)) {
+			/* Load block with bitmap */
+			uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
+			    bg_ref->block_group, sb);
+			
+			block_t *bitmap_block;
+			rc = block_get(&bitmap_block, fs->device, bitmap_block_addr,
+			    BLOCK_FLAGS_NONE);
+			if (rc != EOK)
+				return rc;
+			
+			/* Try to allocate i-node in the bitmap */
+			uint32_t inodes_in_group = ext4_superblock_get_inodes_in_group(sb, bgid);
+			uint32_t index_in_group;
+			rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data,
+			    0, &index_in_group, inodes_in_group);
+			
+			/* Block group has not any free i-node */
+			if (rc == ENOSPC) {
+				block_put(bitmap_block);
+				ext4_filesystem_put_block_group_ref(bg_ref);
+				continue;
+			}
+			
+			/* Free i-node found, save the bitmap */
+			bitmap_block->dirty = true;
+			
+			rc = block_put(bitmap_block);
+			if (rc != EOK)
+				return rc;
+			
+			/* Modify filesystem counters */
+			free_inodes--;
+			ext4_block_group_set_free_inodes_count(bg, sb, free_inodes);
+			
+			/* Increment used directories counter */
+			if (is_dir) {
+				used_dirs++;
+				ext4_block_group_set_used_dirs_count(bg, sb, used_dirs);
+			}
+			
+			/* Decrease unused inodes count */
+			if (ext4_block_group_has_flag(bg,
+			    EXT4_BLOCK_GROUP_ITABLE_ZEROED)) {
+				uint32_t unused =
+				    ext4_block_group_get_itable_unused(bg, sb);
+				
+				uint32_t inodes_in_group =
+				    ext4_superblock_get_inodes_in_group(sb, bgid);
+				
+				uint32_t free = inodes_in_group - unused;
+				
+				if (index_in_group >= free) {
+					unused = inodes_in_group - (index_in_group + 1);
+					ext4_block_group_set_itable_unused(bg, sb, unused);
+				}
+			}
+			
+			/* Save modified block group */
+			bg_ref->dirty = true;
+			
+			rc = ext4_filesystem_put_block_group_ref(bg_ref);
+			if (rc != EOK)
+				return rc;
+			
+			/* Update superblock */
+			sb_free_inodes--;
+			ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
+			
+			/* Compute the absolute i-nodex number */
+			*index = ext4_ialloc_index_in_group2inode(sb, index_in_group, bgid);
+			
+			return EOK;
+		}
+		
+		/* Block group not modified, put it and jump to the next block group */
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		++bgid;
+	}
+	
+	return ENOSPC;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_ialloc.h
===================================================================
--- uspace/lib/ext4/libext4_ialloc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_ialloc.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_IALLOC_H_
+#define LIBEXT4_LIBEXT4_IALLOC_H_
+
+#include "libext4_types.h"
+
+extern int ext4_ialloc_free_inode(ext4_filesystem_t *, uint32_t, bool);
+extern int ext4_ialloc_alloc_inode(ext4_filesystem_t *, uint32_t *, bool);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_inode.c
===================================================================
--- uspace/lib/ext4/libext4_inode.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_inode.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,593 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+/**
+ * @file  libext4_inode.c
+ * @brief Ext4 i-node structure operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <libblock.h>
+#include "libext4.h"
+
+/** Compute number of bits for block count.
+ *
+ *  @param block_size Filesystem block_size
+ *
+ *  @return Number of bits
+ *
+ */
+static uint32_t ext4_inode_block_bits_count(uint32_t block_size)
+{
+	uint32_t bits = 8;
+	uint32_t size = block_size;
+	
+	do {
+		bits++;
+		size = size >> 1;
+	} while (size > 256);
+	
+	return bits;
+}
+
+/** Get mode of the i-node.
+ *
+ * @param sb    Superblock
+ * @param inode I-node to load mode from
+ *
+ * @return Mode of the i-node
+ *
+ */
+uint32_t ext4_inode_get_mode(ext4_superblock_t *sb, ext4_inode_t *inode)
+{
+	if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_HURD) {
+		return ((uint32_t) uint16_t_le2host(inode->osd2.hurd2.mode_high)) << 16 |
+		    ((uint32_t) uint16_t_le2host(inode->mode));
+	}
+	
+	return uint16_t_le2host(inode->mode);
+}
+
+/** Set mode of the i-node.
+ *
+ * @param sb    Superblock
+ * @param inode I-node to set mode to
+ * @param mode  Mode to set to i-node
+ *
+ */
+void ext4_inode_set_mode(ext4_superblock_t *sb, ext4_inode_t *inode, uint32_t mode)
+{
+	inode->mode = host2uint16_t_le((mode << 16) >> 16);
+	
+	if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_HURD)
+		inode->osd2.hurd2.mode_high = host2uint16_t_le(mode >> 16);
+}
+
+/** Get ID of the i-node owner (user id).
+ *
+ * @param inode I-node to load uid from
+ *
+ * @return User ID of the i-node owner
+ *
+ */
+uint32_t ext4_inode_get_uid(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->uid);
+}
+
+/** Set ID of the i-node owner.
+ *
+ * @param inode I-node to set uid to
+ * @param uid   ID of the i-node owner
+ *
+ */
+void ext4_inode_set_uid(ext4_inode_t *inode, uint32_t uid)
+{
+	inode->uid = host2uint32_t_le(uid);
+}
+
+/** Get real i-node size.
+ *
+ * @param sb    Superblock
+ * @param inode I-node to load size from
+ *
+ * @return Real size of i-node
+ *
+ */
+uint64_t ext4_inode_get_size(ext4_superblock_t *sb, ext4_inode_t *inode)
+{
+	uint32_t major_rev = ext4_superblock_get_rev_level(sb);
+	
+	if ((major_rev > 0) &&
+	    (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)))
+		return ((uint64_t)uint32_t_le2host(inode->size_hi)) << 32 |
+		    ((uint64_t)uint32_t_le2host(inode->size_lo));
+	
+	return uint32_t_le2host(inode->size_lo);
+}
+
+/** Set real i-node size.
+ *
+ * @param inode I-node to set size to
+ * @param size  Size of the i-node
+ *
+ */
+void ext4_inode_set_size(ext4_inode_t *inode, uint64_t size)
+{
+	inode->size_lo = host2uint32_t_le((size << 32) >> 32);
+	inode->size_hi = host2uint32_t_le(size >> 32);
+}
+
+/** Get time, when i-node was last accessed.
+ *
+ * @param inode I-node
+ *
+ * @return Time of the last access (POSIX)
+ *
+ */
+uint32_t ext4_inode_get_access_time(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->access_time);
+}
+
+/** Set time, when i-node was last accessed.
+ *
+ * @param inode I-node
+ * @param time  Time of the last access (POSIX)
+ *
+ */
+void ext4_inode_set_access_time(ext4_inode_t *inode, uint32_t time)
+{
+	inode->access_time = host2uint32_t_le(time);
+}
+
+/** Get time, when i-node was last changed.
+ *
+ * @param inode I-node
+ *
+ * @return Time of the last change (POSIX)
+ *
+ */
+uint32_t ext4_inode_get_change_inode_time(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->change_inode_time);
+}
+
+/** Set time, when i-node was last changed.
+ *
+ * @param inode I-node
+ * @param time  Time of the last change (POSIX)
+ *
+ */
+void ext4_inode_set_change_inode_time(ext4_inode_t *inode, uint32_t time)
+{
+	inode->change_inode_time = host2uint32_t_le(time);
+}
+
+/** Get time, when i-node content was last modified.
+ *
+ * @param inode I-node
+ *
+ * @return Time of the last content modification (POSIX)
+ *
+ */
+uint32_t ext4_inode_get_modification_time(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->modification_time);
+}
+
+/** Set time, when i-node content was last modified.
+ *
+ * @param inode I-node
+ * @param time  Time of the last content modification (POSIX)
+ *
+ */
+void ext4_inode_set_modification_time(ext4_inode_t *inode, uint32_t time)
+{
+	inode->modification_time = host2uint32_t_le(time);
+}
+
+/** Get time, when i-node was deleted.
+ *
+ * @param inode I-node
+ *
+ * @return Time of the delete action (POSIX)
+ *
+ */
+uint32_t ext4_inode_get_deletion_time(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->deletion_time);
+}
+
+/** Set time, when i-node was deleted.
+ *
+ * @param inode I-node
+ * @param time  Time of the delete action (POSIX)
+ *
+ */
+void ext4_inode_set_deletion_time(ext4_inode_t *inode, uint32_t time)
+{
+	inode->deletion_time = host2uint32_t_le(time);
+}
+
+/** Get ID of the i-node owner's group.
+ *
+ * @param inode I-node to load gid from
+ *
+ * @return Group ID of the i-node owner
+ *
+ */
+uint32_t ext4_inode_get_gid(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->gid);
+}
+
+/** Set ID ot the i-node owner's group.
+ *
+ * @param inode I-node to set gid to
+ * @param gid   Group ID of the i-node owner
+ *
+ */
+void ext4_inode_set_gid(ext4_inode_t *inode, uint32_t gid)
+{
+	inode->gid = host2uint32_t_le(gid);
+}
+
+/** Get number of links to i-node.
+ *
+ * @param inode I-node to load number of links from
+ *
+ * @return Number of links to i-node
+ *
+ */
+uint16_t ext4_inode_get_links_count(ext4_inode_t *inode)
+{
+	return uint16_t_le2host(inode->links_count);
+}
+
+/** Set number of links to i-node.
+ *
+ * @param inode I-node to set number of links to
+ * @param count Number of links to i-node
+ *
+ */
+void ext4_inode_set_links_count(ext4_inode_t *inode, uint16_t count)
+{
+	inode->links_count = host2uint16_t_le(count);
+}
+
+/** Get number of 512-bytes blocks used for i-node.
+ *
+ * @param sb    Superblock
+ * @param inode I-node
+ *
+ * @return Number of 512-bytes blocks
+ *
+ */
+uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode)
+{
+	if (ext4_superblock_has_feature_read_only(sb,
+	    EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
+		/* 48-bit field */
+		uint64_t count = ((uint64_t)
+		    uint16_t_le2host(inode->osd2.linux2.blocks_high)) << 32 |
+		    uint32_t_le2host(inode->blocks_count_lo);
+		
+		if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) {
+			uint32_t block_size = ext4_superblock_get_block_size(sb);
+			uint32_t block_bits = ext4_inode_block_bits_count(block_size);
+			return count << (block_bits - 9);
+		} else
+			return count;
+	} else
+		return uint32_t_le2host(inode->blocks_count_lo);
+}
+
+/** Set number of 512-bytes blocks used for i-node.
+ *
+ * @param sb    Superblock
+ * @param inode I-node
+ * @param count Number of 512-bytes blocks
+ *
+ * @return Error code
+ *
+ */
+int ext4_inode_set_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode,
+    uint64_t count)
+{
+	/* 32-bit maximum */
+	uint64_t max = 0;
+	max = ~max >> 32;
+	
+	if (count <= max) {
+		inode->blocks_count_lo = host2uint32_t_le(count);
+		inode->osd2.linux2.blocks_high = 0;
+		ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
+		
+		return EOK;
+	}
+	
+	/* Check if there can be used huge files (many blocks) */
+	if (!ext4_superblock_has_feature_read_only(sb,
+	    EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
+		return EINVAL;
+	
+	/* 48-bit maximum */
+	max = 0;
+	max = ~max >> 16;
+	
+	if (count <= max) {
+		inode->blocks_count_lo = host2uint32_t_le(count);
+		inode->osd2.linux2.blocks_high = host2uint16_t_le(count >> 32);
+		ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
+	} else {
+		uint32_t block_size = ext4_superblock_get_block_size(sb);
+		uint32_t block_bits = ext4_inode_block_bits_count(block_size);
+		ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
+		count = count >> (block_bits - 9);
+		inode->blocks_count_lo = host2uint32_t_le(count);
+		inode->osd2.linux2.blocks_high = host2uint16_t_le(count >> 32);
+	}
+	
+	return EOK;
+}
+
+/** Get flags (features) of i-node.
+ *
+ * @param inode I-node to get flags from
+ *
+ * @return Flags (bitmap)
+ *
+ */
+uint32_t ext4_inode_get_flags(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->flags);
+}
+
+/** Set flags (features) of i-node.
+ *
+ * @param inode I-node to set flags to
+ * @param flags Flags to set to i-node
+ *
+ */
+void ext4_inode_set_flags(ext4_inode_t *inode, uint32_t flags)
+{
+	inode->flags = host2uint32_t_le(flags);
+}
+
+/** Get file generation (used by NFS).
+ *
+ * @param inode I-node
+ *
+ * @return File generation
+ *
+ */
+uint32_t ext4_inode_get_generation(ext4_inode_t *inode)
+{
+	return uint32_t_le2host(inode->generation);
+}
+
+/** Set file generation (used by NFS).
+ *
+ * @param inode      I-node
+ * @param generation File generation
+ *
+ */
+void ext4_inode_set_generation(ext4_inode_t *inode, uint32_t generation)
+{
+	inode->generation = host2uint32_t_le(generation);
+}
+
+/** Get address of block, where are extended attributes located.
+ *
+ * @param inode I-node
+ * @param sb    Superblock
+ *
+ * @return Block address
+ *
+ */
+uint64_t ext4_inode_get_file_acl(ext4_inode_t *inode, ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_LINUX)
+		return ((uint32_t)
+		    uint16_t_le2host(inode->osd2.linux2.file_acl_high)) << 16 |
+		    (uint32_t_le2host(inode->file_acl_lo));
+	
+	return uint32_t_le2host(inode->file_acl_lo);
+}
+
+/** Set address of block, where are extended attributes located.
+ *
+ * @param inode    I-node
+ * @param sb       Superblock
+ * @param file_acl Block address
+ *
+ */
+void ext4_inode_set_file_acl(ext4_inode_t *inode, ext4_superblock_t *sb,
+    uint64_t file_acl)
+{
+	inode->file_acl_lo = host2uint32_t_le((file_acl << 32) >> 32);
+	
+	if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_LINUX)
+		inode->osd2.linux2.file_acl_high = host2uint16_t_le(file_acl >> 32);
+}
+
+/** Get block address of specified direct block.
+ *
+ * @param inode I-node to load block from
+ * @param idx   Index of logical block
+ *
+ * @return Physical block address
+ *
+ */
+uint32_t ext4_inode_get_direct_block(ext4_inode_t *inode, uint32_t idx)
+{
+	assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT);
+	
+	return uint32_t_le2host(inode->blocks[idx]);
+}
+
+/** Set block address of specified direct block.
+ *
+ * @param inode  I-node to set block address to
+ * @param idx    Index of logical block
+ * @param fblock Physical block address
+ *
+ */
+void ext4_inode_set_direct_block(ext4_inode_t *inode, uint32_t idx, uint32_t fblock)
+{
+	assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT);
+	
+	inode->blocks[idx] = host2uint32_t_le(fblock);
+}
+
+/** Get block address of specified indirect block.
+ *
+ * @param inode I-node to get block address from
+ * @param idx   Index of indirect block 
+ *
+ * @return Physical block address
+ *
+ */
+uint32_t ext4_inode_get_indirect_block(ext4_inode_t *inode, uint32_t idx)
+{
+	return uint32_t_le2host(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]);
+}
+
+/** Set block address of specified indirect block.
+ *
+ * @param inode  I-node to set block address to
+ * @param idx    Index of indirect block
+ * @param fblock Physical block address
+ *
+ */
+void ext4_inode_set_indirect_block(ext4_inode_t *inode, uint32_t idx,
+    uint32_t fblock)
+{
+	inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] =
+	    host2uint32_t_le(fblock);
+}
+
+/** Check if i-node has specified type.
+ *
+ * @param sb    Superblock
+ * @param inode I-node to check type of
+ * @param type  Type to check
+ *
+ * @return Result of check operation
+ *
+ */
+bool ext4_inode_is_type(ext4_superblock_t *sb, ext4_inode_t *inode,
+    uint32_t type)
+{
+	uint32_t mode = ext4_inode_get_mode(sb, inode);
+	return (mode & EXT4_INODE_MODE_TYPE_MASK) == type;
+}
+
+/** Get extent header from the root of the extent tree.
+ *
+ * @param inode I-node to get extent header from
+ *
+ * @return Pointer to extent header of the root node
+ *
+ */
+ext4_extent_header_t * ext4_inode_get_extent_header(ext4_inode_t *inode)
+{
+	return (ext4_extent_header_t *) inode->blocks;
+}
+
+/** Check if i-node has specified flag.
+ *
+ * @param inode I-node to check flags of
+ * @param flag  Flag to check
+ *
+ * @return Result of check operation
+ *
+ */
+bool ext4_inode_has_flag(ext4_inode_t *inode, uint32_t flag)
+{
+	if (ext4_inode_get_flags(inode) & flag)
+		return true;
+	
+	return false;
+}
+
+/** Remove specified flag from i-node.
+ *
+ * @param inode      I-node to clear flag on
+ * @param clear_flag Flag to be cleared
+ *
+ */
+void ext4_inode_clear_flag(ext4_inode_t *inode, uint32_t clear_flag)
+{
+	uint32_t flags = ext4_inode_get_flags(inode);
+	flags = flags & (~clear_flag);
+	ext4_inode_set_flags(inode, flags);
+}
+
+/** Set specified flag to i-node.
+ *
+ * @param inode    I-node to set flag on
+ * @param set_flag Flag to be set
+ *
+ */
+void ext4_inode_set_flag(ext4_inode_t *inode, uint32_t set_flag)
+{
+	uint32_t flags = ext4_inode_get_flags(inode);
+	flags = flags | set_flag;
+	ext4_inode_set_flags(inode, flags);
+}
+
+/** Check if i-node can be truncated.
+ *
+ * @param sb    Superblock
+ * @param inode I-node to check
+ *
+ * @return Result of the check operation
+ *
+ */
+bool ext4_inode_can_truncate(ext4_superblock_t *sb, ext4_inode_t *inode)
+{
+	if ((ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)) ||
+	    (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)))
+		return false;
+	
+	if ((ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) ||
+	    (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)))
+		return true;
+	
+	return false;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_inode.h
===================================================================
--- uspace/lib/ext4/libext4_inode.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_inode.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_INODE_H_
+#define LIBEXT4_LIBEXT4_INODE_H_
+
+#include <libblock.h>
+#include <sys/types.h>
+#include "libext4_types.h"
+
+extern uint32_t ext4_inode_get_mode(ext4_superblock_t *, ext4_inode_t *);
+extern void ext4_inode_set_mode(ext4_superblock_t *, ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_uid(ext4_inode_t *);
+extern void ext4_inode_set_uid(ext4_inode_t *, uint32_t);
+extern uint64_t ext4_inode_get_size(ext4_superblock_t *, ext4_inode_t *);
+extern void ext4_inode_set_size(ext4_inode_t *, uint64_t);
+extern uint32_t ext4_inode_get_access_time(ext4_inode_t *);
+extern void ext4_inode_set_access_time(ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_change_inode_time(ext4_inode_t *);
+extern void ext4_inode_set_change_inode_time(ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_modification_time(ext4_inode_t *);
+extern void ext4_inode_set_modification_time(ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_deletion_time(ext4_inode_t *);
+extern void ext4_inode_set_deletion_time(ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_gid(ext4_inode_t *);
+extern void ext4_inode_set_gid(ext4_inode_t *, uint32_t);
+extern uint16_t ext4_inode_get_links_count(ext4_inode_t *);
+extern void ext4_inode_set_links_count(ext4_inode_t *, uint16_t);
+extern uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *,
+    ext4_inode_t *);
+extern int ext4_inode_set_blocks_count(ext4_superblock_t *, ext4_inode_t *,
+    uint64_t);
+extern uint32_t ext4_inode_get_flags(ext4_inode_t *);
+extern void ext4_inode_set_flags(ext4_inode_t *, uint32_t);
+extern uint32_t ext4_inode_get_generation(ext4_inode_t *);
+extern void ext4_inode_set_generation(ext4_inode_t *, uint32_t);
+extern uint64_t ext4_inode_get_file_acl(ext4_inode_t *, ext4_superblock_t *);
+extern void ext4_inode_set_file_acl(ext4_inode_t *, ext4_superblock_t *,
+    uint64_t);
+
+extern uint32_t ext4_inode_get_direct_block(ext4_inode_t *, uint32_t);
+extern void ext4_inode_set_direct_block(ext4_inode_t *, uint32_t, uint32_t);
+extern uint32_t ext4_inode_get_indirect_block(ext4_inode_t *, uint32_t);
+extern void ext4_inode_set_indirect_block(ext4_inode_t *, uint32_t, uint32_t);
+extern ext4_extent_header_t * ext4_inode_get_extent_header(ext4_inode_t *);
+extern bool ext4_inode_is_type(ext4_superblock_t *, ext4_inode_t *, uint32_t);
+extern bool ext4_inode_has_flag(ext4_inode_t *, uint32_t);
+extern void ext4_inode_clear_flag(ext4_inode_t *, uint32_t);
+extern void ext4_inode_set_flag(ext4_inode_t *, uint32_t);
+extern bool ext4_inode_can_truncate(ext4_superblock_t *, ext4_inode_t *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_superblock.c
===================================================================
--- uspace/lib/ext4/libext4_superblock.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_superblock.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1291 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+/**
+ * @file  libext4_superblock.c
+ * @brief Ext4 superblock operations.
+ */
+
+#include <byteorder.h>
+#include <errno.h>
+#include <libblock.h>
+#include <malloc.h>
+#include "libext4.h"
+
+/** Get number of i-nodes in the whole filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of i-nodes
+ *
+ */
+uint32_t ext4_superblock_get_inodes_count(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->inodes_count);
+}
+
+/** Set number of i-nodes in the whole filesystem.
+ *
+ * @param sb    Superblock
+ * @param count Number of i-nodes
+ *
+ */
+void ext4_superblock_set_inodes_count(ext4_superblock_t *sb, uint32_t count)
+{
+	sb->inodes_count = host2uint32_t_le(count);
+}
+
+/** Get number of data blocks in the whole filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of data blocks
+ *
+ */
+uint64_t ext4_superblock_get_blocks_count(ext4_superblock_t *sb)
+{
+	return ((uint64_t) uint32_t_le2host(sb->blocks_count_hi) << 32) |
+	    uint32_t_le2host(sb->blocks_count_lo);
+}
+
+/** Set number of data blocks in the whole filesystem.
+ *
+ * @param sb    Superblock
+ * @param count Number of data blocks
+ *
+ */
+void ext4_superblock_set_blocks_count(ext4_superblock_t *sb, uint64_t count)
+{
+	sb->blocks_count_lo = host2uint32_t_le((count << 32) >> 32);
+	sb->blocks_count_hi = host2uint32_t_le(count >> 32);
+}
+
+/** Get number of reserved data blocks in the whole filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of reserved data blocks
+ *
+ */
+uint64_t ext4_superblock_get_reserved_blocks_count(ext4_superblock_t *sb)
+{
+	return ((uint64_t)
+	    uint32_t_le2host(sb->reserved_blocks_count_hi) << 32) |
+	    uint32_t_le2host(sb->reserved_blocks_count_lo);
+}
+
+/** Set number of reserved data blocks in the whole filesystem.
+ *
+ * @param sb    Superblock
+ * @param count Number of reserved data blocks
+ *
+ */
+void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *sb,
+    uint64_t count)
+{
+	sb->reserved_blocks_count_lo = host2uint32_t_le((count << 32) >> 32);
+	sb->reserved_blocks_count_hi = host2uint32_t_le(count >> 32);
+}
+
+/** Get number of free data blocks in the whole filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of free data blocks
+ *
+ */
+uint64_t ext4_superblock_get_free_blocks_count(ext4_superblock_t *sb)
+{
+	return ((uint64_t)
+	    uint32_t_le2host(sb->free_blocks_count_hi) << 32) |
+	    uint32_t_le2host(sb->free_blocks_count_lo);
+}
+
+/** Set number of free data blocks in the whole filesystem.
+ *
+ * @param sb    Superblock
+ * @param count Number of free data blocks
+ *
+ */
+void ext4_superblock_set_free_blocks_count(ext4_superblock_t *sb,
+    uint64_t count)
+{
+	sb->free_blocks_count_lo = host2uint32_t_le((count << 32) >> 32);
+	sb->free_blocks_count_hi = host2uint32_t_le(count >> 32);
+}
+
+/** Get number of free i-nodes in the whole filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of free i-nodes
+ *
+ */
+uint32_t ext4_superblock_get_free_inodes_count(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->free_inodes_count);
+}
+
+/** Set number of free i-nodes in the whole filesystem.
+ *
+ * @param sb    Superblock
+ * @param count Number of free i-nodes
+ *
+ */
+void ext4_superblock_set_free_inodes_count(ext4_superblock_t *sb,
+    uint32_t count)
+{
+	sb->free_inodes_count = host2uint32_t_le(count);
+}
+
+/** Get index of first data block (block where the superblock is located)
+ *
+ * @param sb Superblock
+ *
+ * @return Index of the first data block
+ *
+ */
+uint32_t ext4_superblock_get_first_data_block(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->first_data_block);
+}
+
+/** Set index of first data block (block where the superblock is located)
+ *
+ * @param sb    Superblock
+ * @param first Index of the first data block
+ *
+ */
+void ext4_superblock_set_first_data_block(ext4_superblock_t *sb,
+    uint32_t first)
+{
+	sb->first_data_block = host2uint32_t_le(first);
+}
+
+/** Get logarithmic block size (1024 << size == block_size)
+ *
+ * @param sb Superblock
+ *
+ * @return Logarithmic block size
+ *
+ */
+uint32_t ext4_superblock_get_log_block_size(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->log_block_size);
+}
+
+/** Set logarithmic block size (1024 << size == block_size)
+ *
+ * @param sb Superblock
+ *
+ * @return Logarithmic block size
+ *
+ */
+void ext4_superblock_set_log_block_size(ext4_superblock_t *sb,
+    uint32_t log_size)
+{
+	sb->log_block_size = host2uint32_t_le(log_size);
+}
+
+/** Get size of data block (in bytes).
+ *
+ * @param sb Superblock
+ *
+ * @return Size of data block
+ *
+ */
+uint32_t ext4_superblock_get_block_size(ext4_superblock_t *sb)
+{
+	return 1024 << ext4_superblock_get_log_block_size(sb);
+}
+
+/** Set size of data block (in bytes).
+ *
+ * @param sb   Superblock
+ * @param size Size of data block (must be power of 2, at least 1024)
+ *
+ */
+void ext4_superblock_set_block_size(ext4_superblock_t *sb, uint32_t size)
+{
+	uint32_t log = 0;
+	uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE;
+	
+	tmp >>= 1;
+	while (tmp) {
+		log++;
+		tmp >>= 1;
+	}
+	
+	ext4_superblock_set_log_block_size(sb, log);
+}
+
+/** Get logarithmic fragment size (1024 << size)
+ *
+ * @param sb Superblock
+ *
+ * @return Logarithmic fragment size
+ *
+ */
+uint32_t ext4_superblock_get_log_frag_size(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->log_frag_size);
+}
+
+/** Set logarithmic fragment size (1024 << size)
+ *
+ * @param sb        Superblock
+ * @param frag_size Logarithmic fragment size
+ *
+ */
+void ext4_superblock_set_log_frag_size(ext4_superblock_t *sb,
+    uint32_t frag_size)
+{
+	sb->log_frag_size = host2uint32_t_le(frag_size);
+}
+
+/** Get size of fragment (in bytes).
+ *
+ * @param sb Superblock
+ *
+ * @return Size of fragment
+ *
+ */
+uint32_t ext4_superblock_get_frag_size(ext4_superblock_t *sb)
+{
+	return 1024 << ext4_superblock_get_log_frag_size(sb);
+}
+
+/** Set size of fragment (in bytes).
+ *
+ * @param sb   Superblock
+ * @param size Size of fragment (must be power of 2, at least 1024)
+ *
+ */
+void ext4_superblock_set_frag_size(ext4_superblock_t *sb, uint32_t size)
+{
+	uint32_t log = 0;
+	uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE;
+	
+	tmp >>= 1;
+	while (tmp) {
+		log++;
+		tmp >>= 1;
+	}
+	
+	ext4_superblock_set_log_frag_size(sb, log);
+}
+
+/** Get number of data blocks per block group (except last BG)
+ *
+ * @param sb Superblock
+ *
+ * @return Data blocks per block group
+ *
+ */
+uint32_t ext4_superblock_get_blocks_per_group(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->blocks_per_group);
+}
+
+/** Set number of data blocks per block group (except last BG)
+ *
+ * @param sb     Superblock
+ * @param blocks Data blocks per block group
+ *
+ */
+void ext4_superblock_set_blocks_per_group(ext4_superblock_t *sb,
+    uint32_t blocks)
+{
+	sb->blocks_per_group = host2uint32_t_le(blocks);
+}
+
+/** Get number of fragments per block group (except last BG)
+ *
+ * @param sb Superblock
+ *
+ * @return Fragments per block group
+ *
+ */
+uint32_t ext4_superblock_get_frags_per_group(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->frags_per_group);
+}
+
+/** Set number of fragment per block group (except last BG)
+ *
+ * @param sb    Superblock
+ * @param frags Fragments per block group
+ */
+void ext4_superblock_set_frags_per_group(ext4_superblock_t *sb, uint32_t frags)
+{
+	sb->frags_per_group = host2uint32_t_le(frags);
+}
+
+/** Get number of i-nodes per block group (except last BG)
+ *
+ * @param sb Superblock
+ *
+ * @return I-nodes per block group
+ *
+ */
+uint32_t ext4_superblock_get_inodes_per_group(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->inodes_per_group);
+}
+
+/** Set number of i-nodes per block group (except last BG)
+ *
+ * @param sb     Superblock
+ * @param inodes I-nodes per block group
+ *
+ */
+void ext4_superblock_set_inodes_per_group(ext4_superblock_t *sb,
+    uint32_t inodes)
+{
+	sb->inodes_per_group = host2uint32_t_le(inodes);
+}
+
+/** Get time when filesystem was mounted (POSIX time).
+ *
+ * @param sb Superblock
+ *
+ * @return Mount time
+ *
+ */
+uint32_t ext4_superblock_get_mount_time(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->mount_time);
+}
+
+/** Set time when filesystem was mounted (POSIX time).
+ *
+ * @param sb   Superblock
+ * @param time Mount time
+ *
+ */
+void ext4_superblock_set_mount_time(ext4_superblock_t *sb, uint32_t time)
+{
+	sb->mount_time = host2uint32_t_le(time);
+}
+
+/** Get time when filesystem was last accesed by write operation (POSIX time).
+ *
+ * @param sb Superblock
+ *
+ * @return Write time
+ *
+ */
+uint32_t ext4_superblock_get_write_time(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->write_time);
+}
+
+/** Set time when filesystem was last accesed by write operation (POSIX time).
+ *
+ * @param sb   Superblock
+ * @param time Write time
+ *
+ */
+void ext4_superblock_set_write_time(ext4_superblock_t *sb, uint32_t time)
+{
+	sb->write_time = host2uint32_t_le(time);
+}
+
+/** Get number of mount from last filesystem check.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of mounts
+ *
+ */
+uint16_t ext4_superblock_get_mount_count(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->mount_count);
+}
+
+/** Set number of mount from last filesystem check.
+ *
+ * @param sb    Superblock
+ * @param count Number of mounts
+ *
+ */
+void ext4_superblock_set_mount_count(ext4_superblock_t *sb, uint16_t count)
+{
+	sb->mount_count = host2uint16_t_le(count);
+}
+
+/** Get maximum number of mount from last filesystem check.
+ *
+ * @param sb Superblock
+ *
+ * @return Maximum number of mounts
+ *
+ */
+uint16_t ext4_superblock_get_max_mount_count(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->max_mount_count);
+}
+
+/** Set maximum number of mount from last filesystem check.
+ *
+ * @param sb    Superblock
+ * @param count Maximum number of mounts
+ *
+ */
+void ext4_superblock_set_max_mount_count(ext4_superblock_t *sb, uint16_t count)
+{
+	sb->max_mount_count = host2uint16_t_le(count);
+}
+
+/** Get superblock magic value.
+ *
+ * @param sb Superblock
+ *
+ * @return Magic value
+ *
+ */
+uint16_t ext4_superblock_get_magic(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->magic);
+}
+
+/** Set superblock magic value.
+ *
+ * @param sb    Superblock
+ * @param magic Magic value
+ *
+ */
+void ext4_superblock_set_magic(ext4_superblock_t *sb, uint16_t magic)
+{
+	sb->magic = host2uint16_t_le(magic);
+}
+
+/** Get filesystem state.
+ *
+ * @param sb Superblock
+ *
+ * @return Filesystem state
+ *
+ */
+uint16_t ext4_superblock_get_state(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->state);
+}
+
+/** Set filesystem state.
+ *
+ * @param sb    Superblock
+ * @param state Filesystem state
+ *
+ */
+void ext4_superblock_set_state(ext4_superblock_t *sb, uint16_t state)
+{
+	sb->state = host2uint16_t_le(state);
+}
+
+/** Get behavior code when errors detected.
+ *
+ * @param sb Superblock
+ *
+ * @return Behavior code
+ *
+ */
+uint16_t ext4_superblock_get_errors(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->errors);
+}
+
+/** Set behavior code when errors detected.
+ *
+ * @param sb     Superblock
+ * @param errors Behavior code
+ *
+ */
+void ext4_superblock_set_errors(ext4_superblock_t *sb, uint16_t errors)
+{
+	sb->errors = host2uint16_t_le(errors);
+}
+
+/** Get minor revision level of the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Minor revision level
+ *
+ */
+uint16_t ext4_superblock_get_minor_rev_level(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->minor_rev_level);
+}
+
+/** Set minor revision level of the filesystem.
+ *
+ * @param sb    Superblock
+ * @param level Minor revision level
+ *
+ */
+void ext4_superblock_set_minor_rev_level(ext4_superblock_t *sb, uint16_t level)
+{
+	sb->minor_rev_level = host2uint16_t_le(level);
+}
+
+/** Get time of the last filesystem check.
+ *
+ * @param sb Superblock
+ *
+ * @return Time of the last check (POSIX)
+ *
+ */
+uint32_t ext4_superblock_get_last_check_time(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->last_check_time);
+}
+
+/** Set time of the last filesystem check.
+ *
+ * @param sb   Superblock
+ * @param time Time of the last check (POSIX)
+ *
+ */
+void ext4_superblock_set_last_check_time(ext4_superblock_t *sb, uint32_t time)
+{
+	sb->state = host2uint32_t_le(time);
+}
+
+/** Get maximum time interval between two filesystem checks.
+ *
+ * @param sb Superblock
+ *
+ * @return Time interval between two check (POSIX)
+ *
+ */
+uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->check_interval);
+}
+
+/** Set maximum time interval between two filesystem checks.
+ *
+ * @param sb       Superblock
+ * @param interval Time interval between two check (POSIX)
+ *
+ */
+void ext4_superblock_set_check_interval(ext4_superblock_t *sb, uint32_t interval)
+{
+	sb->check_interval = host2uint32_t_le(interval);
+}
+
+/** Get operation system identifier, on which the filesystem was created.
+ *
+ * @param sb Superblock
+ *
+ * @return Operation system identifier
+ *
+ */
+uint32_t ext4_superblock_get_creator_os(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->creator_os);
+}
+
+/** Set operation system identifier, on which the filesystem was created.
+ *
+ * @param sb Superblock
+ * @param os Operation system identifier
+ *
+ */
+void ext4_superblock_set_creator_os(ext4_superblock_t *sb, uint32_t os)
+{
+	sb->creator_os = host2uint32_t_le(os);
+}
+
+/** Get revision level of the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Revision level
+ *
+ */
+uint32_t ext4_superblock_get_rev_level(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->rev_level);
+}
+
+/** Set revision level of the filesystem.
+ *
+ * @param sb    Superblock
+ * @param level Revision level
+ *
+ */
+void ext4_superblock_set_rev_level(ext4_superblock_t *sb, uint32_t level)
+{
+	sb->rev_level = host2uint32_t_le(level);
+}
+
+/** Get default user id for reserved blocks.
+ *
+ * @param sb Superblock
+ *
+ * @return Default user id for reserved blocks.
+ *
+ */
+uint16_t ext4_superblock_get_def_resuid(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->def_resuid);
+}
+
+/** Set default user id for reserved blocks.
+ *
+ * @param sb  Superblock
+ * @param uid Default user id for reserved blocks.
+ *
+ */
+void ext4_superblock_set_def_resuid(ext4_superblock_t *sb, uint16_t uid)
+{
+	sb->def_resuid = host2uint16_t_le(uid);
+}
+
+/** Get default group id for reserved blocks.
+ *
+ * @param sb Superblock
+ *
+ * @return Default group id for reserved blocks.
+ *
+ */
+uint16_t ext4_superblock_get_def_resgid(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->def_resgid);
+}
+
+/** Set default group id for reserved blocks.
+ *
+ * @param sb  Superblock
+ * @param gid Default group id for reserved blocks.
+ *
+ */
+void ext4_superblock_set_def_resgid(ext4_superblock_t *sb, uint16_t gid)
+{
+	sb->def_resgid = host2uint16_t_le(gid);
+}
+
+/** Get index of the first i-node, which can be used for allocation.
+ *
+ * @param sb Superblock
+ *
+ * @return I-node index
+ *
+ */
+uint32_t ext4_superblock_get_first_inode(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->first_inode);
+}
+
+/** Set index of the first i-node, which can be used for allocation.
+ *
+ * @param sb          Superblock
+ * @param first_inode I-node index
+ *
+ */
+void ext4_superblock_set_first_inode(ext4_superblock_t *sb,
+    uint32_t first_inode)
+{
+	sb->first_inode = host2uint32_t_le(first_inode);
+}
+
+/** Get size of i-node structure.
+ *
+ * For the oldest revision return constant number.
+ *
+ * @param sb Superblock
+ *
+ * @return Size of i-node structure
+ *
+ */
+uint16_t ext4_superblock_get_inode_size(ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_rev_level(sb) == 0)
+		return EXT4_REV0_INODE_SIZE;
+	
+	return uint16_t_le2host(sb->inode_size);
+}
+
+/** Set size of i-node structure.
+ *
+ * @param sb   Superblock
+ * @param size Size of i-node structure
+ *
+ */
+void ext4_superblock_set_inode_size(ext4_superblock_t *sb, uint16_t size)
+{
+	sb->inode_size = host2uint16_t_le(size);
+}
+
+/** Get index of block group, where superblock copy is located.
+ *
+ * @param sb Superblock
+ *
+ * @return Block group index
+ *
+ */
+uint16_t ext4_superblock_get_block_group_index(ext4_superblock_t *sb)
+{
+	return uint16_t_le2host(sb->block_group_index);
+}
+
+/** Set index of block group, where superblock copy is located.
+ *
+ * @param sb   Superblock
+ * @param bgid Block group index
+ *
+ */
+void ext4_superblock_set_block_group_index(ext4_superblock_t *sb, uint16_t bgid)
+{
+	sb->block_group_index = host2uint16_t_le(bgid);
+}
+
+/** Get compatible features supported by the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Compatible features bitmap
+ *
+ */
+uint32_t ext4_superblock_get_features_compatible(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->features_compatible);
+}
+
+/** Set compatible features supported by the filesystem.
+ *
+ * @param sb       Superblock
+ * @param features Compatible features bitmap
+ *
+ */
+void ext4_superblock_set_features_compatible(ext4_superblock_t *sb,
+    uint32_t features)
+{
+	sb->features_compatible = host2uint32_t_le(features);
+}
+
+/** Get incompatible features supported by the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Incompatible features bitmap
+ *
+ */
+uint32_t ext4_superblock_get_features_incompatible(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->features_incompatible);
+}
+
+/** Set incompatible features supported by the filesystem.
+ *
+ * @param sb       Superblock
+ * @param features Incompatible features bitmap
+ *
+ */
+void ext4_superblock_set_features_incompatible(ext4_superblock_t *sb,
+    uint32_t features)
+{
+	sb->features_incompatible = host2uint32_t_le(features);
+}
+
+/** Get compatible features supported by the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Read-only compatible features bitmap
+ *
+ */
+uint32_t ext4_superblock_get_features_read_only(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->features_read_only);
+}
+
+/** Set compatible features supported by the filesystem.
+ *
+ * @param sb      Superblock
+ * @param feature Read-only compatible features bitmap
+ *
+ */
+void ext4_superblock_set_features_read_only(ext4_superblock_t *sb,
+    uint32_t features)
+{
+	sb->features_read_only = host2uint32_t_le(features);
+}
+
+/** Get UUID of the filesystem.
+ *
+ * @param sb superblock
+ *
+ * @return Pointer to UUID array
+ *
+ */
+const uint8_t *ext4_superblock_get_uuid(ext4_superblock_t *sb)
+{
+	return sb->uuid;
+}
+
+/** Set UUID of the filesystem.
+ *
+ * @param sb   Superblock
+ * @param uuid Pointer to UUID array
+ *
+ */
+void ext4_superblock_set_uuid(ext4_superblock_t *sb, const uint8_t *uuid)
+{
+	memcpy(sb->uuid, uuid, sizeof(sb->uuid));
+}
+
+/** Get name of the filesystem volume.
+ *
+ * @param sb Superblock
+ *
+ * @return Name of the volume
+ *
+ */
+const char *ext4_superblock_get_volume_name(ext4_superblock_t *sb)
+{
+	return sb->volume_name;
+}
+
+/** Set name of the filesystem volume.
+ *
+ * @param sb   Superblock
+ * @param name New name of the volume
+ */
+void ext4_superblock_set_volume_name(ext4_superblock_t *sb, const char *name)
+{
+	memcpy(sb->volume_name, name, sizeof(sb->volume_name));
+}
+
+/** Get name of the directory, where this filesystem was mounted at last.
+ *
+ * @param sb Superblock
+ *
+ * @return Directory name
+ *
+ */
+const char *ext4_superblock_get_last_mounted(ext4_superblock_t *sb)
+{
+	return sb->last_mounted;
+}
+
+/** Set name of the directory, where this filesystem was mounted at last.
+ *
+ * @param sb   Superblock
+ * @param last Directory name
+ *
+ */
+void ext4_superblock_set_last_mounted(ext4_superblock_t *sb, const char *last)
+{
+	memcpy(sb->last_mounted, last, sizeof(sb->last_mounted));
+}
+
+/** Get last orphaned i-node index.
+ *
+ * Orphans are stored in linked list.
+ *
+ * @param sb Superblock
+ *
+ * @return Last orphaned i-node index
+ *
+ */
+uint32_t ext4_superblock_get_last_orphan(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->last_orphan);
+}
+
+/** Set last orphaned i-node index.
+ *
+ * Orphans are stored in linked list.
+ *
+ * @param sb          Superblock
+ * @param last_orphan Last orphaned i-node index
+ *
+ */
+void ext4_superblock_set_last_orphan(ext4_superblock_t *sb,
+    uint32_t last_orphan)
+{
+	sb->last_orphan = host2uint32_t_le(last_orphan);
+}
+
+/** Get hash seed for directory index hash function.
+ *
+ * @param sb Superblock
+ *
+ * @return Hash seed pointer
+ *
+ */
+const uint32_t *ext4_superblock_get_hash_seed(ext4_superblock_t *sb)
+{
+	return sb->hash_seed;
+}
+
+/** Set hash seed for directory index hash function.
+ *
+ * @param sb   Superblock
+ * @param seed Hash seed pointer
+ *
+ */
+void ext4_superblock_set_hash_seed(ext4_superblock_t *sb, const uint32_t *seed)
+{
+	memcpy(sb->hash_seed, seed, sizeof(sb->hash_seed));
+}
+
+/** Get default version of the hash algorithm version for directory index.
+ *
+ * @param sb Superblock
+ *
+ * @return Default hash version
+ *
+ */
+uint8_t ext4_superblock_get_default_hash_version(ext4_superblock_t *sb)
+{
+	return sb->default_hash_version;
+}
+
+/** Set default version of the hash algorithm version for directory index.
+ *
+ * @param sb      Superblock
+ * @param version Default hash version
+ *
+ */
+void ext4_superblock_set_default_hash_version(ext4_superblock_t *sb,
+    uint8_t version)
+{
+	sb->default_hash_version = version;
+}
+
+/** Get size of block group descriptor structure.
+ *
+ * Output value is checked for minimal size.
+ *
+ * @param sb Superblock
+ *
+ * @return Size of block group descriptor
+ *
+ */
+uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *sb)
+{
+	uint16_t size = uint16_t_le2host(sb->desc_size);
+	
+	if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		size = EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE;
+	
+	return size;
+}
+
+/** Set size of block group descriptor structure.
+ *
+ * Input value is checked for minimal size.
+ *
+ * @param sb   Superblock
+ * @param size Size of block group descriptor
+ *
+ */
+void ext4_superblock_set_desc_size(ext4_superblock_t *sb, uint16_t size)
+{
+	if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		sb->desc_size =
+		    host2uint16_t_le(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE);
+	
+	sb->desc_size = host2uint16_t_le(size);
+}
+
+/** Get superblock flags.
+ *
+ * @param sb Superblock
+ *
+ * @return Flags from the superblock
+ *
+ */
+uint32_t ext4_superblock_get_flags(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->flags);
+}
+
+/** Set superblock flags.
+ *
+ * @param sb    Superblock
+ * @param flags Flags for the superblock
+ *
+ */
+void ext4_superblock_set_flags(ext4_superblock_t *sb, uint32_t flags)
+{
+	sb->flags = host2uint32_t_le(flags);
+}
+
+/*
+ * More complex superblock operations
+ */
+
+/** Check if superblock has specified flag.
+ *
+ * @param sb   Superblock
+ * @param flag Flag to be checked
+ *
+ * @return True, if superblock has the flag
+ *
+ */
+bool ext4_superblock_has_flag(ext4_superblock_t *sb, uint32_t flag)
+{
+	if (ext4_superblock_get_flags(sb) & flag)
+		return true;
+	
+	return false;
+}
+
+/** Check if filesystem supports compatible feature.
+ *
+ * @param sb      Superblock
+ * @param feature Feature to be checked
+ *
+ * @return True, if filesystem supports the feature
+ *
+ */
+bool ext4_superblock_has_feature_compatible(ext4_superblock_t *sb,
+    uint32_t feature)
+{
+	if (ext4_superblock_get_features_compatible(sb) & feature)
+		return true;
+	
+	return false;
+}
+
+/** Check if filesystem supports incompatible feature.
+ *
+ * @param sb      Superblock
+ * @param feature Feature to be checked
+ *
+ * @return True, if filesystem supports the feature
+ *
+ */
+bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *sb,
+    uint32_t feature)
+{
+	if (ext4_superblock_get_features_incompatible(sb) & feature)
+		return true;
+	
+	return false;
+}
+
+/** Check if filesystem supports read-only compatible feature.
+ *
+ * @param sb      Superblock
+ * @param feature Feature to be checked
+ *
+ * @return True, if filesystem supports the feature
+ *
+ */
+bool ext4_superblock_has_feature_read_only(ext4_superblock_t *sb,
+    uint32_t feature)
+{
+	if (ext4_superblock_get_features_read_only(sb) & feature)
+		return true;
+	
+	return false;
+}
+
+/** Read superblock directly from block device.
+ *
+ * @param service_id Block device identifier
+ * @param sb         Output pointer to memory structure
+ *
+ * @return Eerror code.
+ *
+ */
+int ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb)
+{
+	/* Allocated memory for superblock structure */
+	void *data = malloc(EXT4_SUPERBLOCK_SIZE);
+	if (data == NULL)
+		return ENOMEM;
+	
+	/* Read data from block device */
+	int rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET,
+	    EXT4_SUPERBLOCK_SIZE, data);
+	
+	if (rc != EOK) {
+		free(data);
+		return rc;
+	}
+	
+	/* Set output value */
+	(*sb) = data;
+	
+	return EOK;
+}
+
+/** Write superblock structure directly to block device.
+ *
+ * @param service_id Block device identifier
+ * @param sb         Superblock to be written
+ *
+ * @return Error code
+ *
+ */
+int ext4_superblock_write_direct(service_id_t service_id, ext4_superblock_t *sb)
+{
+	/* Load physical block size from block device */
+	size_t phys_block_size;
+	int rc = block_get_bsize(service_id, &phys_block_size);
+	if (rc != EOK)
+		return rc;
+	
+	/* Compute address of the first block */
+	uint64_t first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size;
+	
+	/* Compute number of block to write */
+	size_t block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size;
+	
+	/* Check alignment */
+	if (EXT4_SUPERBLOCK_SIZE % phys_block_size)
+		block_count++;
+	
+	/* Write data */
+	return block_write_direct(service_id, first_block, block_count, sb);
+}
+
+/** Check sanity of the superblock.
+ *
+ * This check is performed at mount time.
+ * Checks are described by one-line comments in the code.
+ *
+ * @param sb Superblock to check
+ *
+ * @return Error code
+ *
+ */
+int ext4_superblock_check_sanity(ext4_superblock_t *sb)
+{
+	if (ext4_superblock_get_magic(sb) != EXT4_SUPERBLOCK_MAGIC)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_inodes_count(sb) == 0)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_blocks_count(sb) == 0)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_blocks_per_group(sb) == 0)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_inodes_per_group(sb) == 0)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_inode_size(sb) < 128)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_first_inode(sb) < 11)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_desc_size(sb) <
+	    EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ENOTSUP;
+	
+	if (ext4_superblock_get_desc_size(sb) >
+	    EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE)
+		return ENOTSUP;
+	
+	return EOK;
+}
+
+/** Compute number of block groups in the filesystem.
+ *
+ * @param sb Superblock
+ *
+ * @return Number of block groups
+ *
+ */
+uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *sb)
+{
+	uint64_t blocks_count = ext4_superblock_get_blocks_count(sb);
+	uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
+	
+	uint32_t block_groups_count = blocks_count / blocks_per_group;
+	
+	if (blocks_count % blocks_per_group)
+		block_groups_count++;
+	
+	return block_groups_count;
+}
+
+/** Compute number of blocks in specified block group.
+ *
+ * @param sb   Superblock
+ * @param bgid Block group index
+ *
+ * @return Number of blocks
+ *
+ */
+uint32_t ext4_superblock_get_blocks_in_group(ext4_superblock_t *sb, uint32_t bgid)
+{
+	uint32_t block_group_count =
+	    ext4_superblock_get_block_group_count(sb);
+	uint32_t blocks_per_group =
+	    ext4_superblock_get_blocks_per_group(sb);
+	uint64_t total_blocks =
+	    ext4_superblock_get_blocks_count(sb);
+	
+	if (bgid < block_group_count - 1)
+		return blocks_per_group;
+	else
+		return (total_blocks - ((block_group_count - 1) * blocks_per_group));
+}
+
+/** Compute number of i-nodes in specified block group.
+ *
+ * @param sb   Superblock
+ * @param bgid Block group index
+ *
+ * @return Number of i-nodes
+ *
+ */
+uint32_t ext4_superblock_get_inodes_in_group(ext4_superblock_t *sb, uint32_t bgid)
+{
+	uint32_t block_group_count =
+	    ext4_superblock_get_block_group_count(sb);
+	uint32_t inodes_per_group =
+	    ext4_superblock_get_inodes_per_group(sb);
+	uint32_t total_inodes =
+	    ext4_superblock_get_inodes_count(sb);
+	
+	if (bgid < block_group_count - 1)
+		return inodes_per_group;
+	else
+		return (total_inodes - ((block_group_count - 1) * inodes_per_group));
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_superblock.h
===================================================================
--- uspace/lib/ext4/libext4_superblock.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_superblock.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_SUPERBLOCK_H_
+#define LIBEXT4_LIBEXT4_SUPERBLOCK_H_
+
+#include <libblock.h>
+#include <sys/types.h>
+#include "libext4_types.h"
+
+extern uint32_t ext4_superblock_get_inodes_count(ext4_superblock_t *);
+extern void ext4_superblock_set_inodes_count(ext4_superblock_t *, uint32_t);
+extern uint64_t ext4_superblock_get_blocks_count(ext4_superblock_t *);
+extern void ext4_superblock_set_blocks_count(ext4_superblock_t *, uint64_t);
+extern uint64_t ext4_superblock_get_reserved_blocks_count(ext4_superblock_t *);
+extern void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *,
+    uint64_t);
+extern uint64_t ext4_superblock_get_free_blocks_count(ext4_superblock_t *);
+extern void ext4_superblock_set_free_blocks_count(ext4_superblock_t *,
+    uint64_t);
+extern uint32_t ext4_superblock_get_free_inodes_count(ext4_superblock_t *);
+extern void ext4_superblock_set_free_inodes_count(ext4_superblock_t *,
+    uint32_t);
+extern uint32_t ext4_superblock_get_first_data_block(ext4_superblock_t *);
+extern void ext4_superblock_set_first_data_block(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_log_block_size(ext4_superblock_t *);
+extern void ext4_superblock_set_log_block_size(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_block_size(ext4_superblock_t *);
+extern void ext4_superblock_set_block_size(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_log_frag_size(ext4_superblock_t *);
+extern void ext4_superblock_set_log_frag_size(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_frag_size(ext4_superblock_t *);
+extern void ext4_superblock_set_frag_size(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_blocks_per_group(ext4_superblock_t *);
+extern void ext4_superblock_set_blocks_per_group(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_frags_per_group(ext4_superblock_t *);
+extern void ext4_superblock_set_frags_per_group(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_inodes_per_group(ext4_superblock_t *);
+extern void ext4_superblock_set_inodes_per_group(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_mount_time(ext4_superblock_t *);
+extern void ext4_superblock_set_mount_time(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_write_time(ext4_superblock_t *);
+extern void ext4_superblock_set_write_time(ext4_superblock_t *, uint32_t);
+extern uint16_t ext4_superblock_get_mount_count(ext4_superblock_t *);
+extern void ext4_superblock_set_mount_count(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_max_mount_count(ext4_superblock_t *);
+extern void ext4_superblock_set_max_mount_count(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_magic(ext4_superblock_t *);
+extern void ext4_superblock_set_magic(ext4_superblock_t *sb, uint16_t magic);
+extern uint16_t ext4_superblock_get_state(ext4_superblock_t *);
+extern void ext4_superblock_set_state(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_errors(ext4_superblock_t *);
+extern void ext4_superblock_set_errors(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_minor_rev_level(ext4_superblock_t *);
+extern void ext4_superblock_set_minor_rev_level(ext4_superblock_t *, uint16_t);
+extern uint32_t ext4_superblock_get_last_check_time(ext4_superblock_t *);
+extern void ext4_superblock_set_last_check_time(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *);
+extern void ext4_superblock_set_check_interval(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_creator_os(ext4_superblock_t *);
+extern void ext4_superblock_set_creator_os(ext4_superblock_t *, uint32_t);
+extern uint32_t ext4_superblock_get_rev_level(ext4_superblock_t *);
+extern void ext4_superblock_set_rev_level(ext4_superblock_t *, uint32_t);
+extern uint16_t ext4_superblock_get_def_resuid(ext4_superblock_t *);
+extern void ext4_superblock_set_def_resuid(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_def_resgid(ext4_superblock_t *);
+extern void ext4_superblock_set_def_resgid(ext4_superblock_t *, uint16_t);
+extern uint32_t ext4_superblock_get_first_inode(ext4_superblock_t *);
+extern void ext4_superblock_set_first_inode(ext4_superblock_t *, uint32_t);
+extern uint16_t ext4_superblock_get_inode_size(ext4_superblock_t *);
+extern void ext4_superblock_set_inode_size(ext4_superblock_t *, uint16_t);
+extern uint16_t ext4_superblock_get_block_group_index(ext4_superblock_t *);
+extern void ext4_superblock_set_block_group_index(ext4_superblock_t *,
+    uint16_t);
+extern uint32_t ext4_superblock_get_features_compatible(ext4_superblock_t *);
+extern void ext4_superblock_set_features_compatible(ext4_superblock_t *,
+    uint32_t);
+extern uint32_t ext4_superblock_get_features_incompatible(ext4_superblock_t *);
+extern void ext4_superblock_set_features_incompatible(ext4_superblock_t *,
+    uint32_t);
+extern uint32_t ext4_superblock_get_features_read_only(ext4_superblock_t *);
+extern void ext4_superblock_set_features_read_only(ext4_superblock_t *,
+    uint32_t);
+
+extern const uint8_t * ext4_superblock_get_uuid(ext4_superblock_t *);
+extern void ext4_superblock_set_uuid(ext4_superblock_t *, const uint8_t *);
+extern const char * ext4_superblock_get_volume_name(ext4_superblock_t *);
+extern void ext4_superblock_set_volume_name(ext4_superblock_t *, const char *);
+extern const char * ext4_superblock_get_last_mounted(ext4_superblock_t *);
+extern void ext4_superblock_set_last_mounted(ext4_superblock_t *, const char *);
+
+extern uint32_t ext4_superblock_get_last_orphan(ext4_superblock_t *);
+extern void ext4_superblock_set_last_orphan(ext4_superblock_t *, uint32_t);
+extern const uint32_t * ext4_superblock_get_hash_seed(ext4_superblock_t *);
+extern void ext4_superblock_set_hash_seed(ext4_superblock_t *,
+    const uint32_t *);
+extern uint8_t ext4_superblock_get_default_hash_version(ext4_superblock_t *);
+extern void ext4_superblock_set_default_hash_version(ext4_superblock_t *,
+    uint8_t);
+
+extern uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *);
+extern void ext4_superblock_set_desc_size(ext4_superblock_t *, uint16_t);
+
+extern uint32_t ext4_superblock_get_flags(ext4_superblock_t *);
+extern void ext4_superblock_set_flags(ext4_superblock_t *, uint32_t);
+
+/* More complex superblock functions */
+extern bool ext4_superblock_has_flag(ext4_superblock_t *, uint32_t);
+extern bool ext4_superblock_has_feature_compatible(ext4_superblock_t *,
+    uint32_t);
+extern bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *,
+    uint32_t);
+extern bool ext4_superblock_has_feature_read_only(ext4_superblock_t *,
+    uint32_t);
+extern int ext4_superblock_read_direct(service_id_t, ext4_superblock_t **);
+extern int ext4_superblock_write_direct(service_id_t, ext4_superblock_t *);
+extern int ext4_superblock_check_sanity(ext4_superblock_t *);
+
+extern uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *);
+extern uint32_t ext4_superblock_get_blocks_in_group(ext4_superblock_t *,
+    uint32_t);
+extern uint32_t ext4_superblock_get_inodes_in_group(ext4_superblock_t *,
+    uint32_t);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/libext4_types.h
===================================================================
--- uspace/lib/ext4/libext4_types.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/lib/ext4/libext4_types.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,546 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libext4
+ * @{
+ */
+
+#ifndef LIBEXT4_LIBEXT4_TYPES_H_
+#define LIBEXT4_LIBEXT4_TYPES_H_
+
+#include <libblock.h>
+
+/*
+ * Structure of the super block
+ */
+typedef struct ext4_superblock {
+	uint32_t inodes_count;              /* I-nodes count */
+	uint32_t blocks_count_lo;           /* Blocks count */
+	uint32_t reserved_blocks_count_lo;  /* Reserved blocks count */
+	uint32_t free_blocks_count_lo;      /* Free blocks count */
+	uint32_t free_inodes_count;         /* Free inodes count */
+	uint32_t first_data_block;          /* First Data Block */
+	uint32_t log_block_size;            /* Block size */
+	uint32_t log_frag_size;             /* Obsoleted fragment size */
+	uint32_t blocks_per_group;          /* Number of blocks per group */
+	uint32_t frags_per_group;           /* Obsoleted fragments per group */
+	uint32_t inodes_per_group;          /* Number of inodes per group */
+	uint32_t mount_time;                /* Mount time */
+	uint32_t write_time;                /* Write time */
+	uint16_t mount_count;               /* Mount count */
+	uint16_t max_mount_count;           /* Maximal mount count */
+	uint16_t magic;                     /* Magic signature */
+	uint16_t state;                     /* File system state */
+	uint16_t errors;                    /* Behaviour when detecting errors */
+	uint16_t minor_rev_level;           /* Minor revision level */
+	uint32_t last_check_time;           /* Time of last check */
+	uint32_t check_interval;            /* Maximum time between checks */
+	uint32_t creator_os;                /* Creator OS */
+	uint32_t rev_level;                 /* Revision level */
+	uint16_t def_resuid;                /* Default uid for reserved blocks */
+	uint16_t def_resgid;                /* Default gid for reserved blocks */
+	
+	/* Fields for EXT4_DYNAMIC_REV superblocks only. */
+	uint32_t first_inode;             /* First non-reserved inode */
+	uint16_t inode_size;              /* Size of inode structure */
+	uint16_t block_group_index;       /* Block group index of this superblock */
+	uint32_t features_compatible;     /* Compatible feature set */
+	uint32_t features_incompatible;   /* Incompatible feature set */
+	uint32_t features_read_only;      /* Readonly-compatible feature set */
+	uint8_t uuid[16];                 /* 128-bit uuid for volume */
+	char volume_name[16];             /* Volume name */
+	char last_mounted[64];            /* Directory where last mounted */
+	uint32_t algorithm_usage_bitmap;  /* For compression */
+	
+	/*
+	 * Performance hints. Directory preallocation should only
+	 * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
+	 */
+	uint8_t s_prealloc_blocks;       /* Number of blocks to try to preallocate */
+	uint8_t s_prealloc_dir_blocks;   /* Number to preallocate for dirs */
+	uint16_t s_reserved_gdt_blocks;  /* Per group desc for online growth */
+	
+	/*
+	 * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
+	 */
+	uint8_t journal_uuid[16];       /* UUID of journal superblock */
+	uint32_t journal_inode_number;  /* Inode number of journal file */
+	uint32_t journal_dev;           /* Device number of journal file */
+	uint32_t last_orphan;           /* Head of list of inodes to delete */
+	uint32_t hash_seed[4];          /* HTREE hash seed */
+	uint8_t default_hash_version;   /* Default hash version to use */
+	uint8_t journal_backup_type;
+	uint16_t desc_size;             /* Size of group descriptor */
+	uint32_t default_mount_opts;    /* Default mount options */
+	uint32_t first_meta_bg;         /* First metablock block group */
+	uint32_t mkfs_time;             /* When the filesystem was created */
+	uint32_t journal_blocks[17];    /* Backup of the journal inode */
+
+	/* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
+	uint32_t blocks_count_hi;           /* Blocks count */
+	uint32_t reserved_blocks_count_hi;  /* Reserved blocks count */
+	uint32_t free_blocks_count_hi;      /* Free blocks count */
+	uint16_t min_extra_isize;           /* All inodes have at least # bytes */
+	uint16_t want_extra_isize;          /* New inodes should reserve # bytes */
+	uint32_t flags;                     /* Miscellaneous flags */
+	uint16_t raid_stride;               /* RAID stride */
+	uint16_t mmp_interval;              /* # seconds to wait in MMP checking */
+	uint64_t mmp_block;                 /* Block for multi-mount protection */
+	uint32_t raid_stripe_width;         /* Blocks on all data disks (N * stride) */
+	uint8_t log_groups_per_flex;        /* FLEX_BG group size */
+	uint8_t reserved_char_pad;
+	uint16_t reserved_pad;
+	uint64_t kbytes_written;            /* Number of lifetime kilobytes written */
+	uint32_t snapshot_inum;             /* I-node number of active snapshot */
+	uint32_t snapshot_id;               /* Sequential ID of active snapshot */
+	uint64_t snapshot_r_blocks_count;   /* Reserved blocks for active snapshot's future use */
+	uint32_t snapshot_list;             /* I-node number of the head of the on-disk snapshot list */
+	uint32_t error_count;               /* Number of file system errors */
+	uint32_t first_error_time;          /* First time an error happened */
+	uint32_t first_error_ino;           /* I-node involved in first error */
+	uint64_t first_error_block;         /* Block involved of first error */
+	uint8_t first_error_func[32];       /* Function where the error happened */
+	uint32_t first_error_line;          /* Line number where error happened */
+	uint32_t last_error_time;           /* Most recent time of an error */
+	uint32_t last_error_ino;            /* I-node involved in last error */
+	uint32_t last_error_line;           /* Line number where error happened */
+	uint64_t last_error_block;          /* Block involved of last error */
+	uint8_t last_error_func[32];        /* Function where the error happened */
+	uint8_t mount_opts[64];
+	uint32_t padding[112];              /* Padding to the end of the block */
+} __attribute__((packed)) ext4_superblock_t;
+
+
+#define EXT4_SUPERBLOCK_MAGIC   0xEF53
+#define EXT4_SUPERBLOCK_SIZE    1024
+#define EXT4_SUPERBLOCK_OFFSET  1024
+
+#define EXT4_SUPERBLOCK_OS_LINUX  0
+#define EXT4_SUPERBLOCK_OS_HURD   1
+
+/*
+ * Misc. filesystem flags
+ */
+#define EXT4_SUPERBLOCK_FLAGS_SIGNED_HASH    0x0001  /* Signed dirhash in use */
+#define EXT4_SUPERBLOCK_FLAGS_UNSIGNED_HASH  0x0002  /* Unsigned dirhash in use */
+#define EXT4_SUPERBLOCK_FLAGS_TEST_FILESYS   0x0004  /* to test development code */
+
+/*
+ * Filesystem states
+ */
+#define EXT4_SUPERBLOCK_STATE_VALID_FS   0x0001  /* Unmounted cleanly */
+#define EXT4_SUPERBLOCK_STATE_ERROR_FS   0x0002  /* Errors detected */
+#define EXT4_SUPERBLOCK_STATE_ORPHAN_FS  0x0004  /* Orphans being recovered */
+
+/*
+ * Behaviour when errors detected
+ */
+#define EXT4_SUPERBLOCK_ERRORS_CONTINUE  1  /* Continue execution */
+#define EXT4_SUPERBLOCK_ERRORS_RO        2  /* Remount fs read-only */
+#define EXT4_SUPERBLOCK_ERRORS_PANIC     3  /* Panic */
+#define EXT4_SUPERBLOCK_ERRORS_DEFAULT   EXT4_ERRORS_CONTINUE
+
+/*
+ * Compatible features
+ */
+#define EXT4_FEATURE_COMPAT_DIR_PREALLOC   0x0001
+#define EXT4_FEATURE_COMPAT_IMAGIC_INODES  0x0002
+#define EXT4_FEATURE_COMPAT_HAS_JOURNAL    0x0004
+#define EXT4_FEATURE_COMPAT_EXT_ATTR       0x0008
+#define EXT4_FEATURE_COMPAT_RESIZE_INODE   0x0010
+#define EXT4_FEATURE_COMPAT_DIR_INDEX      0x0020
+
+/*
+ * Read-only compatible features
+ */
+#define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER  0x0001
+#define EXT4_FEATURE_RO_COMPAT_LARGE_FILE    0x0002
+#define EXT4_FEATURE_RO_COMPAT_BTREE_DIR     0x0004
+#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE     0x0008
+#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM      0x0010
+#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK     0x0020
+#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE   0x0040
+
+/*
+ * Incompatible features
+ */
+#define EXT4_FEATURE_INCOMPAT_COMPRESSION  0x0001
+#define EXT4_FEATURE_INCOMPAT_FILETYPE     0x0002
+#define EXT4_FEATURE_INCOMPAT_RECOVER      0x0004  /* Needs recovery */
+#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV  0x0008  /* Journal device */
+#define EXT4_FEATURE_INCOMPAT_META_BG      0x0010
+#define EXT4_FEATURE_INCOMPAT_EXTENTS      0x0040  /* extents support */
+#define EXT4_FEATURE_INCOMPAT_64BIT        0x0080
+#define EXT4_FEATURE_INCOMPAT_MMP          0x0100
+#define EXT4_FEATURE_INCOMPAT_FLEX_BG      0x0200
+#define EXT4_FEATURE_INCOMPAT_EA_INODE     0x0400  /* EA in inode */
+#define EXT4_FEATURE_INCOMPAT_DIRDATA      0x1000  /* data in dirent */
+
+#define EXT4_FEATURE_COMPAT_SUPP  (EXT4_FEATURE_COMPAT_DIR_INDEX)
+
+#define EXT4_FEATURE_INCOMPAT_SUPP \
+	(EXT4_FEATURE_INCOMPAT_FILETYPE | \
+	EXT4_FEATURE_INCOMPAT_EXTENTS | \
+	EXT4_FEATURE_INCOMPAT_64BIT)
+
+#define EXT4_FEATURE_RO_COMPAT_SUPP \
+	(EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER | \
+	EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
+	EXT4_FEATURE_RO_COMPAT_HUGE_FILE | \
+	EXT4_FEATURE_RO_COMPAT_LARGE_FILE | \
+	EXT4_FEATURE_RO_COMPAT_GDT_CSUM | \
+	EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)
+
+typedef struct ext4_filesystem {
+	service_id_t device;
+	ext4_superblock_t *superblock;
+	aoff64_t inode_block_limits[4];
+	aoff64_t inode_blocks_per_level[4];
+} ext4_filesystem_t;
+
+
+#define EXT4_BLOCK_GROUP_INODE_UNINIT   0x0001  /* Inode table/bitmap not in use */
+#define EXT4_BLOCK_GROUP_BLOCK_UNINIT   0x0002  /* Block bitmap not in use */
+#define EXT4_BLOCK_GROUP_ITABLE_ZEROED  0x0004  /* On-disk itable initialized to zero */
+
+/*
+ * Structure of a blocks group descriptor
+ */
+typedef struct ext4_block_group {
+	uint32_t block_bitmap_lo;             /* Blocks bitmap block */
+	uint32_t inode_bitmap_lo;             /* Inodes bitmap block */
+	uint32_t inode_table_first_block_lo;  /* Inodes table block */
+	uint16_t free_blocks_count_lo;        /* Free blocks count */
+	uint16_t free_inodes_count_lo;        /* Free inodes count */
+	uint16_t used_dirs_count_lo;          /* Directories count */
+	uint16_t flags;                       /* EXT4_BG_flags (INODE_UNINIT, etc) */
+	uint32_t reserved[2];                 /* Likely block/inode bitmap checksum */
+	uint16_t itable_unused_lo;            /* Unused inodes count */
+	uint16_t checksum;                    /* crc16(sb_uuid+group+desc) */
+	
+	uint32_t block_bitmap_hi;             /* Blocks bitmap block MSB */
+	uint32_t inode_bitmap_hi;             /* I-nodes bitmap block MSB */
+	uint32_t inode_table_first_block_hi;  /* I-nodes table block MSB */
+	uint16_t free_blocks_count_hi;        /* Free blocks count MSB */
+	uint16_t free_inodes_count_hi;        /* Free i-nodes count MSB */
+	uint16_t used_dirs_count_hi;          /* Directories count MSB */
+	uint16_t itable_unused_hi;            /* Unused inodes count MSB */
+	uint32_t reserved2[3];                /* Padding */
+} ext4_block_group_t;
+
+typedef struct ext4_block_group_ref {
+	block_t *block;                   /* Reference to a block containing this block group descr */
+	ext4_block_group_t *block_group;
+	ext4_filesystem_t *fs;
+	uint32_t index;
+	bool dirty;
+} ext4_block_group_ref_t;
+
+#define EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE  32
+#define EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE  64
+
+#define EXT4_MIN_BLOCK_SIZE   1024   /* 1 KiB */
+#define EXT4_MAX_BLOCK_SIZE   65536  /* 64 KiB */
+#define EXT4_REV0_INODE_SIZE  128
+
+#define EXT4_INODE_BLOCK_SIZE  512
+
+#define EXT4_INODE_DIRECT_BLOCK_COUNT      12
+#define EXT4_INODE_INDIRECT_BLOCK          EXT4_INODE_DIRECT_BLOCK_COUNT
+#define EXT4_INODE_DOUBLE_INDIRECT_BLOCK   (EXT4_INODE_INDIRECT_BLOCK + 1)
+#define EXT4_INODE_TRIPPLE_INDIRECT_BLOCK  (EXT4_INODE_DOUBLE_INDIRECT_BLOCK + 1)
+#define EXT4_INODE_BLOCKS                  (EXT4_INODE_TRIPPLE_INDIRECT_BLOCK + 1)
+#define EXT4_INODE_INDIRECT_BLOCK_COUNT    (EXT4_INODE_BLOCKS - EXT4_INODE_DIRECT_BLOCK_COUNT)
+
+/*
+ * Structure of an inode on the disk
+ */
+typedef struct ext4_inode {
+	uint16_t mode;                       /* File mode */
+	uint16_t uid;                        /* Low 16 bits of owner uid */
+	uint32_t size_lo;                    /* Size in bytes */
+	uint32_t access_time;                /* Access time */
+	uint32_t change_inode_time;          /* I-node change time */
+	uint32_t modification_time;          /* Modification time */
+	uint32_t deletion_time;              /* Deletion time */
+	uint16_t gid;                        /* Low 16 bits of group id */
+	uint16_t links_count;                /* Links count */
+	uint32_t blocks_count_lo;            /* Blocks count */
+	uint32_t flags;                      /* File flags */
+	uint32_t unused_osd1;                /* OS dependent - not used in HelenOS */
+	uint32_t blocks[EXT4_INODE_BLOCKS];  /* Pointers to blocks */
+	uint32_t generation;                 /* File version (for NFS) */
+	uint32_t file_acl_lo;                /* File ACL */
+	uint32_t size_hi;
+	uint32_t obso_faddr;                 /* Obsoleted fragment address */
+	
+	union {
+		struct {
+			uint16_t blocks_high;
+			uint16_t file_acl_high;
+			uint16_t uid_high;
+			uint16_t gid_high;
+			uint32_t reserved2;
+		} linux2;
+		struct {
+			uint16_t reserved1;
+			uint16_t mode_high;
+			uint16_t uid_high;
+			uint16_t gid_high;
+			uint32_t author;
+		} hurd2;
+	} __attribute__ ((packed)) osd2;
+	
+	uint16_t extra_isize;
+	uint16_t pad1;
+	uint32_t ctime_extra;   /* Extra change time (nsec << 2 | epoch) */
+	uint32_t mtime_extra;   /* Extra Modification time (nsec << 2 | epoch) */
+	uint32_t atime_extra;   /* Extra Access time (nsec << 2 | epoch) */
+	uint32_t crtime;        /* File creation time */
+	uint32_t crtime_extra;  /* Extra file creation time (nsec << 2 | epoch) */
+	uint32_t version_hi;    /* High 32 bits for 64-bit version */
+} __attribute__ ((packed)) ext4_inode_t;
+
+#define EXT4_INODE_MODE_FIFO       0x1000
+#define EXT4_INODE_MODE_CHARDEV    0x2000
+#define EXT4_INODE_MODE_DIRECTORY  0x4000
+#define EXT4_INODE_MODE_BLOCKDEV   0x6000
+#define EXT4_INODE_MODE_FILE       0x8000
+#define EXT4_INODE_MODE_SOFTLINK   0xA000
+#define EXT4_INODE_MODE_SOCKET     0xC000
+#define EXT4_INODE_MODE_TYPE_MASK  0xF000
+
+/*
+ * Inode flags
+ */
+#define EXT4_INODE_FLAG_SECRM      0x00000001  /* Secure deletion */
+#define EXT4_INODE_FLAG_UNRM       0x00000002  /* Undelete */
+#define EXT4_INODE_FLAG_COMPR      0x00000004  /* Compress file */
+#define EXT4_INODE_FLAG_SYNC       0x00000008  /* Synchronous updates */
+#define EXT4_INODE_FLAG_IMMUTABLE  0x00000010  /* Immutable file */
+#define EXT4_INODE_FLAG_APPEND     0x00000020  /* writes to file may only append */
+#define EXT4_INODE_FLAG_NODUMP     0x00000040  /* do not dump file */
+#define EXT4_INODE_FLAG_NOATIME    0x00000080  /* do not update atime */
+
+/* Compression flags */
+#define EXT4_INODE_FLAG_DIRTY     0x00000100
+#define EXT4_INODE_FLAG_COMPRBLK  0x00000200  /* One or more compressed clusters */
+#define EXT4_INODE_FLAG_NOCOMPR   0x00000400  /* Don't compress */
+#define EXT4_INODE_FLAG_ECOMPR    0x00000800  /* Compression error */
+
+#define EXT4_INODE_FLAG_INDEX         0x00001000  /* hash-indexed directory */
+#define EXT4_INODE_FLAG_IMAGIC        0x00002000  /* AFS directory */
+#define EXT4_INODE_FLAG_JOURNAL_DATA  0x00004000  /* File data should be journaled */
+#define EXT4_INODE_FLAG_NOTAIL        0x00008000  /* File tail should not be merged */
+#define EXT4_INODE_FLAG_DIRSYNC       0x00010000  /* Dirsync behaviour (directories only) */
+#define EXT4_INODE_FLAG_TOPDIR        0x00020000  /* Top of directory hierarchies */
+#define EXT4_INODE_FLAG_HUGE_FILE     0x00040000  /* Set to each huge file */
+#define EXT4_INODE_FLAG_EXTENTS       0x00080000  /* Inode uses extents */
+#define EXT4_INODE_FLAG_EA_INODE      0x00200000  /* Inode used for large EA */
+#define EXT4_INODE_FLAG_EOFBLOCKS     0x00400000  /* Blocks allocated beyond EOF */
+#define EXT4_INODE_FLAG_RESERVED      0x80000000  /* reserved for ext4 lib */
+
+#define EXT4_INODE_ROOT_INDEX  2
+
+typedef struct ext4_inode_ref {
+	block_t *block;         /* Reference to a block containing this inode */
+	ext4_inode_t *inode;
+	ext4_filesystem_t *fs;
+	uint32_t index;         /* Index number of this inode */
+	bool dirty;
+} ext4_inode_ref_t;
+
+
+#define EXT4_DIRECTORY_FILENAME_LEN  255
+
+#define EXT4_DIRECTORY_FILETYPE_UNKNOWN   0
+#define EXT4_DIRECTORY_FILETYPE_REG_FILE  1
+#define EXT4_DIRECTORY_FILETYPE_DIR       2
+#define EXT4_DIRECTORY_FILETYPE_CHRDEV    3
+#define EXT4_DIRECTORY_FILETYPE_BLKDEV    4
+#define EXT4_DIRECTORY_FILETYPE_FIFO      5
+#define EXT4_DIRECTORY_FILETYPE_SOCK      6
+#define EXT4_DIRECTORY_FILETYPE_SYMLINK   7
+
+/**
+ * Linked list directory entry structure
+ */
+typedef struct ext4_directory_entry_ll {
+	uint32_t inode;         /* I-node for the entry */
+	uint16_t entry_length;  /* Distance to the next directory entry */
+	uint8_t name_length;    /* Lower 8 bits of name length */
+	
+	union {
+		uint8_t name_length_high;  /* Higher 8 bits of name length */
+		uint8_t inode_type;        /* Type of referenced inode (in rev >= 0.5) */
+	} __attribute__ ((packed));
+	
+	uint8_t name[EXT4_DIRECTORY_FILENAME_LEN];  /* Entry name */
+} __attribute__((packed)) ext4_directory_entry_ll_t;
+
+typedef struct ext4_directory_iterator {
+	ext4_inode_ref_t *inode_ref;
+	block_t *current_block;
+	aoff64_t current_offset;
+	ext4_directory_entry_ll_t *current;
+} ext4_directory_iterator_t;
+
+typedef struct ext4_directory_search_result {
+	block_t *block;
+	ext4_directory_entry_ll_t *dentry;
+} ext4_directory_search_result_t;
+
+/* Structures for indexed directory */
+
+typedef struct ext4_directory_dx_countlimit {
+	uint16_t limit;
+	uint16_t count;
+} ext4_directory_dx_countlimit_t;
+
+typedef struct ext4_directory_dx_dot_entry {
+	uint32_t inode;
+	uint16_t entry_length;
+	uint8_t name_length;
+	uint8_t inode_type;
+	uint8_t name[4];
+} ext4_directory_dx_dot_entry_t;
+
+typedef struct ext4_directory_dx_root_info {
+	uint32_t reserved_zero;
+	uint8_t hash_version;
+	uint8_t info_length;
+	uint8_t indirect_levels;
+	uint8_t unused_flags;
+} ext4_directory_dx_root_info_t;
+
+typedef struct ext4_directory_dx_entry {
+	uint32_t hash;
+	uint32_t block;
+} ext4_directory_dx_entry_t;
+
+typedef struct ext4_directory_dx_root {
+	ext4_directory_dx_dot_entry_t dots[2];
+	ext4_directory_dx_root_info_t info;
+	ext4_directory_dx_entry_t entries[0];
+} ext4_directory_dx_root_t;
+
+typedef struct ext4_fake_directory_entry {
+	uint32_t inode;
+	uint16_t entry_length;
+	uint8_t name_length;
+	uint8_t inode_type;
+} ext4_fake_directory_entry_t;
+
+typedef struct ext4_directory_dx_node {
+	ext4_fake_directory_entry_t fake;
+	ext4_directory_dx_entry_t entries[0];
+} ext4_directory_dx_node_t;
+
+typedef struct ext4_directory_dx_block {
+	block_t *block;
+	ext4_directory_dx_entry_t *entries;
+	ext4_directory_dx_entry_t *position;
+} ext4_directory_dx_block_t;
+
+#define EXT4_ERR_BAD_DX_DIR       (-75000)
+#define EXT4_DIRECTORY_HTREE_EOF  UINT32_C(0x7fffffff)
+
+/*
+ * This is the extent on-disk structure.
+ * It's used at the bottom of the tree.
+ */
+typedef struct ext4_extent {
+	uint32_t first_block;  /* First logical block extent covers */
+	uint16_t block_count;  /* Number of blocks covered by extent */
+	uint16_t start_hi;     /* High 16 bits of physical block */
+	uint32_t start_lo;     /* Low 32 bits of physical block */
+} ext4_extent_t;
+
+/*
+ * This is index on-disk structure.
+ * It's used at all the levels except the bottom.
+ */
+typedef struct ext4_extent_index {
+	uint32_t first_block;  /* Index covers logical blocks from 'block' */
+	
+	/**
+	 * Pointer to the physical block of the next
+	 * level. leaf or next index could be there
+	 * high 16 bits of physical block
+	 */
+	uint32_t leaf_lo;
+	uint16_t leaf_hi;
+	uint16_t padding;
+} ext4_extent_index_t;
+
+/*
+ * Each block (leaves and indexes), even inode-stored has header.
+ */
+typedef struct ext4_extent_header {
+	uint16_t magic;
+	uint16_t entries_count;      /* Number of valid entries */
+	uint16_t max_entries_count;  /* Capacity of store in entries */
+	uint16_t depth;              /* Has tree real underlying blocks? */
+	uint32_t generation;         /* generation of the tree */
+} ext4_extent_header_t;
+
+typedef struct ext4_extent_path {
+	block_t *block;
+	uint16_t depth;
+	ext4_extent_header_t *header;
+	ext4_extent_index_t *index;
+	ext4_extent_t *extent;
+} ext4_extent_path_t;
+
+#define EXT4_EXTENT_MAGIC  0xF30A
+
+#define	EXT4_EXTENT_FIRST(header) \
+	((ext4_extent_t *) (((void *) (header)) + sizeof(ext4_extent_header_t)))
+
+#define	EXT4_EXTENT_FIRST_INDEX(header) \
+	((ext4_extent_index_t *) (((void *) (header)) + sizeof(ext4_extent_header_t)))
+
+#define EXT4_HASH_VERSION_LEGACY             0
+#define EXT4_HASH_VERSION_HALF_MD4           1
+#define EXT4_HASH_VERSION_TEA                2
+#define EXT4_HASH_VERSION_LEGACY_UNSIGNED    3
+#define EXT4_HASH_VERSION_HALF_MD4_UNSIGNED  4
+#define EXT4_HASH_VERSION_TEA_UNSIGNED       5
+
+typedef struct ext4_hash_info {
+	uint32_t hash;
+	uint32_t minor_hash;
+	uint32_t hash_version;
+	const uint32_t *seed;
+} ext4_hash_info_t;
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/srv/bd/ata_bd/ata_bd.c
===================================================================
--- uspace/srv/bd/ata_bd/ata_bd.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/ata_bd/ata_bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -51,7 +51,7 @@
 #include <libarch/ddi.h>
 #include <ddi.h>
-#include <ipc/bd.h>
 #include <async.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <fibril_synch.h>
 #include <stdint.h>
@@ -98,13 +98,20 @@
 
 /** Per-disk state. */
-static disk_t disk[MAX_DISKS];
+static disk_t ata_disk[MAX_DISKS];
 
 static void print_syntax(void);
 static int ata_bd_init(void);
 static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
-static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
-    void *buf);
-static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
-    const void *buf);
+
+static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
+static int ata_bd_close(bd_srv_t *);
+static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
+    size_t);
+static int ata_bd_read_toc(bd_srv_t *, uint8_t session, void *buf, size_t);
+static int ata_bd_write_blocks(bd_srv_t *, uint64_t ba, size_t cnt,
+    const void *buf, size_t);
+static int ata_bd_get_block_size(bd_srv_t *, size_t *);
+static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
     void *buf);
@@ -127,4 +134,19 @@
     unsigned timeout);
 
+static bd_ops_t ata_bd_ops = {
+	.open = ata_bd_open,
+	.close = ata_bd_close,
+	.read_blocks = ata_bd_read_blocks,
+	.read_toc = ata_bd_read_toc,
+	.write_blocks = ata_bd_write_blocks,
+	.get_block_size = ata_bd_get_block_size,
+	.get_num_blocks = ata_bd_get_num_blocks
+};
+
+static disk_t *bd_srv_disk(bd_srv_t *bd)
+{
+	return (disk_t *)bd->srvs->sarg;
+}
+
 int main(int argc, char **argv)
 {
@@ -161,8 +183,8 @@
 		fflush(stdout);
 
-		rc = disk_init(&disk[i], i);
+		rc = disk_init(&ata_disk[i], i);
 
 		if (rc == EOK) {
-			disk_print_summary(&disk[i]);
+			disk_print_summary(&ata_disk[i]);
 		} else {
 			printf("Not found.\n");
@@ -174,9 +196,9 @@
 	for (i = 0; i < MAX_DISKS; i++) {
 		/* Skip unattached drives. */
-		if (disk[i].present == false)
+		if (ata_disk[i].present == false)
 			continue;
 		
 		snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
-		rc = loc_service_register(name, &disk[i].service_id);
+		rc = loc_service_register(name, &ata_disk[i].service_id);
 		if (rc != EOK) {
 			printf(NAME ": Unable to register device %s.\n", name);
@@ -217,6 +239,6 @@
 		case am_chs:
 			printf("CHS %u cylinders, %u heads, %u sectors",
-			    disk->geom.cylinders, disk->geom.heads,
-			    disk->geom.sectors);
+			    d->geom.cylinders, d->geom.heads,
+			    d->geom.sectors);
 			break;
 		case am_lba28:
@@ -273,14 +295,5 @@
 static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
 	service_id_t dsid;
-	size_t comm_size;	/**< Size of the communication area. */
-	unsigned int flags;
-	int retval;
-	uint64_t ba;
-	size_t cnt;
 	int disk_id, i;
 
@@ -291,78 +304,13 @@
 	disk_id = -1;
 	for (i = 0; i < MAX_DISKS; i++)
-		if (disk[i].service_id == dsid)
+		if (ata_disk[i].service_id == dsid)
 			disk_id = i;
 
-	if (disk_id < 0 || disk[disk_id].present == false) {
+	if (disk_id < 0 || ata_disk[disk_id].present == false) {
 		async_answer_0(iid, EINVAL);
 		return;
 	}
 
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * disk[disk_id].block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = ata_bd_read_blocks(disk_id, ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * disk[disk_id].block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = ata_bd_write_blocks(disk_id, ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, disk[disk_id].block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
-			    UPPER32(disk[disk_id].blocks));
-			continue;
-		case BD_READ_TOC:
-			cnt = IPC_GET_ARG1(call);
-			if (disk[disk_id].dev_type == ata_pkt_dev)
-				retval = ata_pcmd_read_toc(disk_id, cnt, fs_va,
-				    disk[disk_id].block_size);
-			else
-				retval = EINVAL;
-			break;
-		default:
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+	bd_conn(iid, icall, &ata_disk[disk_id].bds);
 }
 
@@ -384,6 +332,11 @@
 	unsigned i;
 
+	d->disk_id = disk_id;
 	d->present = false;
 	fibril_mutex_initialize(&d->lock);
+
+	bd_srvs_init(&d->bds);
+	d->bds.ops = &ata_bd_ops;
+	d->bds.sarg = d;
 
 	/* Try identify command. */
@@ -514,16 +467,30 @@
 }
 
+static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+static int ata_bd_close(bd_srv_t *bd)
+{
+	return EOK;
+}
+
 /** Read multiple blocks from the device. */
-static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
-    void *buf) {
-
+static int ata_bd_read_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
+    void *buf, size_t size)
+{
+	disk_t *disk = bd_srv_disk(bd);
 	int rc;
 
+	if (size < cnt * disk->block_size)
+		return EINVAL;
+
 	while (cnt > 0) {
-		if (disk[disk_id].dev_type == ata_reg_dev)
-			rc = ata_rcmd_read(disk_id, ba, 1, buf);
+		if (disk->dev_type == ata_reg_dev)
+			rc = ata_rcmd_read(disk->disk_id, ba, 1, buf);
 		else
-			rc = ata_pcmd_read_12(disk_id, ba, 1, buf,
-			    disk[disk_id].block_size);
+			rc = ata_pcmd_read_12(disk->disk_id, ba, 1, buf,
+			    disk->block_size);
 
 		if (rc != EOK)
@@ -532,21 +499,33 @@
 		++ba;
 		--cnt;
-		buf += disk[disk_id].block_size;
-	}
-
-	return EOK;
+		buf += disk->block_size;
+	}
+
+	return EOK;
+}
+
+/** Read TOC from device. */
+static int ata_bd_read_toc(bd_srv_t *bd, uint8_t session, void *buf, size_t size)
+{
+	disk_t *disk = bd_srv_disk(bd);
+
+	return ata_pcmd_read_toc(disk->disk_id, session, buf, size);
 }
 
 /** Write multiple blocks to the device. */
-static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
-    const void *buf) {
-
+static int ata_bd_write_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	disk_t *disk = bd_srv_disk(bd);
 	int rc;
 
-	if (disk[disk_id].dev_type != ata_reg_dev)
+	if (disk->dev_type != ata_reg_dev)
 		return ENOTSUP;
 
+	if (size < cnt * disk->block_size)
+		return EINVAL;
+
 	while (cnt > 0) {
-		rc = ata_rcmd_write(disk_id, ba, 1, buf);
+		rc = ata_rcmd_write(disk->disk_id, ba, 1, buf);
 		if (rc != EOK)
 			return rc;
@@ -554,7 +533,25 @@
 		++ba;
 		--cnt;
-		buf += disk[disk_id].block_size;
-	}
-
+		buf += disk->block_size;
+	}
+
+	return EOK;
+}
+
+/** Get device block size. */
+static int ata_bd_get_block_size(bd_srv_t *bd, size_t *rbsize)
+{
+	disk_t *disk = bd_srv_disk(bd);
+
+	*rbsize = disk->block_size;
+	return EOK;
+}
+
+/** Get device number of blocks. */
+static int ata_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	disk_t *disk = bd_srv_disk(bd);
+
+	*rnb = disk->blocks;
 	return EOK;
 }
@@ -685,5 +682,5 @@
 	uint16_t val;
 
-	d = &disk[dev_idx];
+	d = &ata_disk[dev_idx];
 	fibril_mutex_lock(&d->lock);
 
@@ -874,5 +871,5 @@
 	block_coord_t bc;
 
-	d = &disk[disk_id];
+	d = &ata_disk[disk_id];
 	
 	/* Silence warning. */
@@ -919,5 +916,5 @@
 		/* Read data from the device buffer. */
 
-		for (i = 0; i < disk[disk_id].block_size / 2; i++) {
+		for (i = 0; i < ata_disk[disk_id].block_size / 2; i++) {
 			data = pio_read_16(&cmd->data_port);
 			((uint16_t *) buf)[i] = data;
@@ -950,5 +947,5 @@
 	block_coord_t bc;
 
-	d = &disk[disk_id];
+	d = &ata_disk[disk_id];
 	
 	/* Silence warning. */
@@ -995,5 +992,5 @@
 		/* Write data to the device buffer. */
 
-		for (i = 0; i < disk[disk_id].block_size / 2; i++) {
+		for (i = 0; i < d->block_size / 2; i++) {
 			pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
 		}
Index: uspace/srv/bd/ata_bd/ata_bd.h
===================================================================
--- uspace/srv/bd/ata_bd/ata_bd.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/ata_bd/ata_bd.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -36,4 +36,5 @@
 #define __ATA_BD_H__
 
+#include <bd_srv.h>
 #include <sys/types.h>
 #include <fibril_synch.h>
@@ -117,4 +118,6 @@
 	fibril_mutex_t lock;
 	service_id_t service_id;
+	int disk_id;
+	bd_srvs_t bds;
 } disk_t;
 
Index: uspace/srv/bd/file_bd/file_bd.c
===================================================================
--- uspace/srv/bd/file_bd/file_bd.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/file_bd/file_bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -41,7 +41,7 @@
 #include <stdio.h>
 #include <unistd.h>
-#include <ipc/bd.h>
 #include <async.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <fibril_synch.h>
 #include <loc.h>
@@ -62,4 +62,5 @@
 
 static service_id_t service_id;
+static bd_srvs_t bd_srvs;
 static fibril_mutex_t dev_lock;
 
@@ -67,6 +68,20 @@
 static int file_bd_init(const char *fname);
 static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
-static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf);
-static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf);
+
+static int file_bd_open(bd_srvs_t *, bd_srv_t *);
+static int file_bd_close(bd_srv_t *);
+static int file_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int file_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int file_bd_get_block_size(bd_srv_t *, size_t *);
+static int file_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t file_bd_ops = {
+	.open = file_bd_open,
+	.close = file_bd_close,
+	.read_blocks = file_bd_read_blocks,
+	.write_blocks = file_bd_write_blocks,
+	.get_block_size = file_bd_get_block_size,
+	.get_num_blocks = file_bd_get_num_blocks
+};
 
 int main(int argc, char **argv)
@@ -139,4 +154,7 @@
 static int file_bd_init(const char *fname)
 {
+	bd_srvs_init(&bd_srvs);
+	bd_srvs.ops = &file_bd_ops;
+	
 	async_set_client_connection(file_bd_connection);
 	int rc = loc_server_register(NAME);
@@ -170,79 +188,28 @@
 static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
-	size_t comm_size;
-	unsigned int flags;
-	int retval;
-	uint64_t ba;
-	size_t cnt;
-
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = file_bd_read_blocks(ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = file_bd_write_blocks(ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(num_blocks),
-			    UPPER32(num_blocks));
-			continue;
-		default:
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+	bd_conn(iid, icall, &bd_srvs);
+}
+
+/** Open device. */
+static int file_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int file_bd_close(bd_srv_t *bd)
+{
+	return EOK;
 }
 
 /** Read blocks from the device. */
-static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf)
+static int file_bd_read_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt, void *buf,
+    size_t size)
 {
 	size_t n_rd;
 	int rc;
+
+	if (size < cnt * block_size)
+		return EINVAL;
 
 	/* Check whether access is within device address bounds. */
@@ -279,8 +246,12 @@
 
 /** Write blocks to the device. */
-static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf)
+static int file_bd_write_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
+    const void *buf, size_t size)
 {
 	size_t n_wr;
 	int rc;
+
+	if (size < cnt * block_size)
+		return EINVAL;
 
 	/* Check whether access is within device address bounds. */
@@ -318,4 +289,18 @@
 }
 
+/** Get device block size. */
+static int file_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	*rsize = block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int file_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	*rnb = num_blocks;
+	return EOK;
+}
+
 /**
  * @}
Index: uspace/srv/bd/gxe_bd/gxe_bd.c
===================================================================
--- uspace/srv/bd/gxe_bd/gxe_bd.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/gxe_bd/gxe_bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -39,7 +39,7 @@
 #include <libarch/ddi.h>
 #include <ddi.h>
-#include <ipc/bd.h>
 #include <async.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <fibril_synch.h>
 #include <loc.h>
@@ -65,4 +65,5 @@
 };
 
+/** GXE disk hardware registers */
 typedef struct {
 	uint32_t offset_lo;
@@ -83,25 +84,49 @@
 
 	uint8_t buffer[512];
+} gxe_bd_hw_t;
+
+/** GXE block device soft state */
+typedef struct {
+	/** Block device service structure */
+	bd_srvs_t bds;
+	int disk_id;
 } gxe_bd_t;
 
-
 static const size_t block_size = 512;
-static size_t comm_size;
 
 static uintptr_t dev_physical = 0x13000000;
-static gxe_bd_t *dev;
+static gxe_bd_hw_t *dev;
 
 static service_id_t service_id[MAX_DISKS];
 
 static fibril_mutex_t dev_lock[MAX_DISKS];
+
+static gxe_bd_t gxe_bd[MAX_DISKS];
 
 static int gxe_bd_init(void);
 static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
-static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt,
-    void *buf);
-static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt,
-    const void *buf);
 static int gxe_bd_read_block(int disk_id, uint64_t ba, void *buf);
 static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf);
+
+static int gxe_bd_open(bd_srvs_t *, bd_srv_t *);
+static int gxe_bd_close(bd_srv_t *);
+static int gxe_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int gxe_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int gxe_bd_get_block_size(bd_srv_t *, size_t *);
+static int gxe_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t gxe_bd_ops = {
+	.open = gxe_bd_open,
+	.close = gxe_bd_close,
+	.read_blocks = gxe_bd_read_blocks,
+	.write_blocks = gxe_bd_write_blocks,
+	.get_block_size = gxe_bd_get_block_size,
+	.get_num_blocks = gxe_bd_get_num_blocks
+};
+
+static gxe_bd_t *bd_srv_gxe(bd_srv_t *bd)
+{
+	return (gxe_bd_t *)bd->srvs->sarg;
+}
 
 int main(int argc, char **argv)
@@ -130,5 +155,5 @@
 	
 	void *vaddr;
-	rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_t), &vaddr);
+	rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_hw_t), &vaddr);
 	if (rc != EOK) {
 		printf("%s: Could not initialize device I/O space.\n", NAME);
@@ -140,4 +165,8 @@
 	for (unsigned int i = 0; i < MAX_DISKS; i++) {
 		char name[16];
+		
+		bd_srvs_init(&gxe_bd[i].bds);
+		gxe_bd[i].bds.ops = &gxe_bd_ops;
+		gxe_bd[i].bds.sarg = (void *)&gxe_bd[i];
 		
 		snprintf(name, 16, "%s/disk%u", NAMESPACE, i);
@@ -157,13 +186,5 @@
 static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
 	service_id_t dsid;
-	unsigned int flags;
-	int retval;
-	uint64_t ba;
-	unsigned cnt;
 	int disk_id, i;
 
@@ -182,73 +203,28 @@
 	}
 
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	if (comm_size < block_size) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = gxe_bd_read_blocks(disk_id, ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = gxe_bd_write_blocks(disk_id, ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			retval = ENOTSUP;
-			break;
-		default:
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+	bd_conn(iid, icall, &gxe_bd[disk_id].bds);
+}
+
+/** Open device. */
+static int gxe_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int gxe_bd_close(bd_srv_t *bd)
+{
+	return EOK;
 }
 
 /** Read multiple blocks from the device. */
-static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt,
-    void *buf) {
-
+static int gxe_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    void *buf, size_t size)
+{
+	int disk_id = bd_srv_gxe(bd)->disk_id;
 	int rc;
+
+	if (size < cnt * block_size)
+		return EINVAL;
 
 	while (cnt > 0) {
@@ -266,8 +242,12 @@
 
 /** Write multiple blocks to the device. */
-static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt,
-    const void *buf) {
-
+static int gxe_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	int disk_id = bd_srv_gxe(bd)->disk_id;
 	int rc;
+
+	if (size < cnt * block_size)
+		return EINVAL;
 
 	while (cnt > 0) {
@@ -282,4 +262,17 @@
 
 	return EOK;
+}
+
+/** Get device block size. */
+static int gxe_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	*rsize = block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int gxe_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	return ENOTSUP;
 }
 
Index: uspace/srv/bd/part/guid_part/guid_part.c
===================================================================
--- uspace/srv/bd/part/guid_part/guid_part.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/part/guid_part/guid_part.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -47,7 +47,7 @@
 #include <stdlib.h>
 #include <unistd.h>
-#include <ipc/bd.h>
 #include <async.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <fibril_synch.h>
 #include <loc.h>
@@ -83,4 +83,6 @@
 	/** Service representing the partition (outbound device) */
 	service_id_t dsid;
+	/** Block device service structure */
+	bd_srvs_t bds;
 	/** Points to next partition structure. */
 	struct part *next;
@@ -100,7 +102,26 @@
 static void gpt_pte_to_part(const gpt_entry_t *pte, part_t *part);
 static void gpt_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
-static int gpt_bd_read(part_t *p, aoff64_t ba, size_t cnt, void *buf);
-static int gpt_bd_write(part_t *p, aoff64_t ba, size_t cnt, const void *buf);
 static int gpt_bsa_translate(part_t *p, aoff64_t ba, size_t cnt, aoff64_t *gba);
+
+static int gpt_bd_open(bd_srvs_t *, bd_srv_t *);
+static int gpt_bd_close(bd_srv_t *);
+static int gpt_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int gpt_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int gpt_bd_get_block_size(bd_srv_t *, size_t *);
+static int gpt_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t gpt_bd_ops = {
+	.open = gpt_bd_open,
+	.close = gpt_bd_close,
+	.read_blocks = gpt_bd_read_blocks,
+	.write_blocks = gpt_bd_write_blocks,
+	.get_block_size = gpt_bd_get_block_size,
+	.get_num_blocks = gpt_bd_get_num_blocks
+};
+
+static part_t *bd_srv_part(bd_srv_t *bd)
+{
+	return (part_t *)bd->srvs->sarg;
+}
 
 int main(int argc, char **argv)
@@ -304,4 +325,8 @@
 	}
 
+	bd_srvs_init(&part->bds);
+	part->bds.ops = &gpt_bd_ops;
+	part->bds.sarg = part;
+
 	part->dsid = 0;
 	part->next = NULL;
@@ -310,14 +335,5 @@
 static void gpt_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	size_t comm_size;
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
 	service_id_t dh;
-	unsigned int flags;
-	int retval;
-	aoff64_t ba;
-	size_t cnt;
 	part_t *part;
 
@@ -341,68 +357,28 @@
 	assert(part->present == true);
 
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = gpt_bd_read(part, ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = gpt_bd_write(part, ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(part->length),
-			    UPPER32(part->length));
-			continue;
-		default:
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+	bd_conn(iid, icall, &part->bds);
+}
+
+/** Open device. */
+static int gpt_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int gpt_bd_close(bd_srv_t *bd)
+{
+	return EOK;
 }
 
 /** Read blocks from partition. */
-static int gpt_bd_read(part_t *p, aoff64_t ba, size_t cnt, void *buf)
-{
+static int gpt_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt, void *buf,
+    size_t size)
+{
+	part_t *p = bd_srv_part(bd);
 	aoff64_t gba;
+
+	if (cnt * block_size < size)
+		return EINVAL;
 
 	if (gpt_bsa_translate(p, ba, cnt, &gba) != EOK)
@@ -413,7 +389,12 @@
 
 /** Write blocks to partition. */
-static int gpt_bd_write(part_t *p, aoff64_t ba, size_t cnt, const void *buf)
-{
+static int gpt_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	part_t *p = bd_srv_part(bd);
 	aoff64_t gba;
+
+	if (cnt * block_size < size)
+		return EINVAL;
 
 	if (gpt_bsa_translate(p, ba, cnt, &gba) != EOK)
@@ -422,4 +403,21 @@
 	return block_write_direct(indev_sid, gba, cnt, buf);
 }
+
+/** Get device block size. */
+static int gpt_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	*rsize = block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int gpt_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	part_t *part = bd_srv_part(bd);
+
+	*rnb = part->length;
+	return EOK;
+}
+
 
 /** Translate block segment address with range checking. */
Index: uspace/srv/bd/part/mbr_part/mbr_part.c
===================================================================
--- uspace/srv/bd/part/mbr_part/mbr_part.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/part/mbr_part/mbr_part.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -44,5 +44,5 @@
  *
  * Referemces:
- *	
+ *
  * The source of MBR structures for this driver have been the following
  * Wikipedia articles:
@@ -57,7 +57,7 @@
 #include <stdlib.h>
 #include <unistd.h>
-#include <ipc/bd.h>
 #include <async.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <fibril_synch.h>
 #include <loc.h>
@@ -100,4 +100,6 @@
 	/** Device representing the partition (outbound device) */
 	service_id_t dsid;
+	/** Block device service sturcture */
+	bd_srvs_t bds;
 	/** Points to next partition structure. */
 	struct part *next;
@@ -140,5 +142,5 @@
 
 /** Partitioned device (inbound device) */
-static service_id_t indef_sid;
+static service_id_t indev_sid;
 
 /** List of partitions. This structure is an empty head. */
@@ -150,7 +152,26 @@
 static void mbr_pte_to_part(uint32_t base, const pt_entry_t *pte, part_t *part);
 static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
-static int mbr_bd_read(part_t *p, uint64_t ba, size_t cnt, void *buf);
-static int mbr_bd_write(part_t *p, uint64_t ba, size_t cnt, const void *buf);
 static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba);
+
+static int mbr_bd_open(bd_srvs_t *, bd_srv_t *);
+static int mbr_bd_close(bd_srv_t *);
+static int mbr_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int mbr_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int mbr_bd_get_block_size(bd_srv_t *, size_t *);
+static int mbr_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t mbr_bd_ops = {
+	.open = mbr_bd_open,
+	.close = mbr_bd_close,
+	.read_blocks = mbr_bd_read_blocks,
+	.write_blocks = mbr_bd_write_blocks,
+	.get_block_size = mbr_bd_get_block_size,
+	.get_num_blocks = mbr_bd_get_num_blocks
+};
+
+static part_t *bd_srv_part(bd_srv_t *bd)
+{
+	return (part_t *)bd->srvs->sarg;
+}
 
 int main(int argc, char **argv)
@@ -183,5 +204,5 @@
 	part_t *part;
 
-	rc = loc_service_get_id(dev_name, &indef_sid, 0);
+	rc = loc_service_get_id(dev_name, &indev_sid, 0);
 	if (rc != EOK) {
 		printf(NAME ": could not resolve device `%s'.\n", dev_name);
@@ -189,5 +210,5 @@
 	}
 
-	rc = block_init(EXCHANGE_SERIALIZE, indef_sid, 2048);
+	rc = block_init(EXCHANGE_SERIALIZE, indev_sid, 2048);
 	if (rc != EOK)  {
 		printf(NAME ": could not init libblock.\n");
@@ -197,5 +218,5 @@
 	/* Determine and verify block size. */
 
-	rc = block_get_bsize(indef_sid, &block_size);
+	rc = block_get_bsize(indev_sid, &block_size);
 	if (rc != EOK) {
 		printf(NAME ": error getting block size.\n");
@@ -281,5 +302,5 @@
 	 */
 
-	rc = block_read_direct(indef_sid, 0, 1, brb);
+	rc = block_read_direct(indev_sid, 0, 1, brb);
 	if (rc != EOK) {
 		printf(NAME ": Failed reading MBR block.\n");
@@ -332,5 +353,5 @@
 		 */
 		ba = cp.start_addr;
-		rc = block_read_direct(indef_sid, ba, 1, brb);
+		rc = block_read_direct(indev_sid, ba, 1, brb);
 		if (rc != EOK) {
 			printf(NAME ": Failed reading EBR block at %"
@@ -381,4 +402,8 @@
 	part->present = (pte->ptype != PT_UNUSED) ? true : false;
 
+	bd_srvs_init(&part->bds);
+	part->bds.ops = &mbr_bd_ops;
+	part->bds.sarg = part;
+
 	part->dsid = 0;
 	part->next = NULL;
@@ -387,14 +412,5 @@
 static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	size_t comm_size;
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
 	service_id_t dh;
-	unsigned int flags;
-	int retval;
-	uint64_t ba;
-	size_t cnt;
 	part_t *part;
 
@@ -417,85 +433,65 @@
 
 	assert(part->present == true);
-
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == AS_MAP_FAILED) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (1) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = mbr_bd_read(part, ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = mbr_bd_write(part, ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(part->length),
-			    UPPER32(part->length));
-			continue;
-		default:
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+	bd_conn(iid, icall, &part->bds);
+}
+
+/** Open device. */
+static int mbr_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int mbr_bd_close(bd_srv_t *bd)
+{
+	return EOK;
 }
 
 /** Read blocks from partition. */
-static int mbr_bd_read(part_t *p, uint64_t ba, size_t cnt, void *buf)
-{
-	uint64_t gba;
+static int mbr_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt, void *buf,
+    size_t size)
+{
+	part_t *p = bd_srv_part(bd);
+	aoff64_t gba;
+
+	if (cnt * block_size < size)
+		return EINVAL;
 
 	if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK)
 		return ELIMIT;
 
-	return block_read_direct(indef_sid, gba, cnt, buf);
+	return block_read_direct(indev_sid, gba, cnt, buf);
 }
 
 /** Write blocks to partition. */
-static int mbr_bd_write(part_t *p, uint64_t ba, size_t cnt, const void *buf)
-{
-	uint64_t gba;
+static int mbr_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	part_t *p = bd_srv_part(bd);
+	aoff64_t gba;
+
+	if (cnt * block_size < size)
+		return EINVAL;
 
 	if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK)
 		return ELIMIT;
 
-	return block_write_direct(indef_sid, gba, cnt, buf);
+	return block_write_direct(indev_sid, gba, cnt, buf);
+}
+
+/** Get device block size. */
+static int mbr_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	*rsize = block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int mbr_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	part_t *part = bd_srv_part(bd);
+
+	*rnb = part->length;
+	return EOK;
 }
 
Index: uspace/srv/bd/rd/rd.c
===================================================================
--- uspace/srv/bd/rd/rd.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/rd/rd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -43,4 +43,5 @@
 #include <sysinfo.h>
 #include <as.h>
+#include <bd_srv.h>
 #include <ddi.h>
 #include <align.h>
@@ -53,5 +54,4 @@
 #include <stdio.h>
 #include <loc.h>
-#include <ipc/bd.h>
 #include <macros.h>
 #include <inttypes.h>
@@ -68,6 +68,10 @@
 static const size_t block_size = 512;
 
-static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf);
-static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf);
+static int rd_open(bd_srvs_t *, bd_srv_t *);
+static int rd_close(bd_srv_t *);
+static int rd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int rd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int rd_get_block_size(bd_srv_t *, size_t *);
+static int rd_get_num_blocks(bd_srv_t *, aoff64_t *);
 
 /** This rwlock protects the ramdisk's data.
@@ -78,102 +82,37 @@
  *
  */
-fibril_rwlock_t rd_lock;
-
-/** Handle one connection to ramdisk.
- *
- * @param iid   Hash of the request that opened the connection.
- * @param icall Call data of the request that opened the connection.
- */
-static void rd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-	ipc_callid_t callid;
-	ipc_call_t call;
-	int retval;
-	void *fs_va = NULL;
-	uint64_t ba;
-	size_t cnt;
-	size_t comm_size;
-	
-	/*
-	 * Answer the first IPC_M_CONNECT_ME_TO call.
-	 */
-	async_answer_0(iid, EOK);
-	
-	/*
-	 * Now we wait for the client to send us its communication as_area.
-	 */
-	unsigned int flags;
-	if (async_share_out_receive(&callid, &comm_size, &flags)) {
-		(void) async_share_out_finalize(callid, &fs_va);
-		if (fs_va == AS_MAP_FAILED) {
-			async_answer_0(callid, EHANGUP);
-			return;
-		}
-	} else {
-		/*
-		 * The client doesn't speak the same protocol.
-		 * At this point we can't handle protocol variations.
-		 * Close the connection.
-		 */
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-	
-	while (true) {
-		callid = async_get_call(&call);
-		
-		if (!IPC_GET_IMETHOD(call)) {
-			/*
-			 * The other side has hung up.
-			 * Exit the fibril.
-			 */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (IPC_GET_IMETHOD(call)) {
-		case BD_READ_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = rd_read_blocks(ba, cnt, fs_va);
-			break;
-		case BD_WRITE_BLOCKS:
-			ba = MERGE_LOUP32(IPC_GET_ARG1(call),
-			    IPC_GET_ARG2(call));
-			cnt = IPC_GET_ARG3(call);
-			if (cnt * block_size > comm_size) {
-				retval = ELIMIT;
-				break;
-			}
-			retval = rd_write_blocks(ba, cnt, fs_va);
-			break;
-		case BD_GET_BLOCK_SIZE:
-			async_answer_1(callid, EOK, block_size);
-			continue;
-		case BD_GET_NUM_BLOCKS:
-			async_answer_2(callid, EOK, LOWER32(rd_size / block_size),
-			    UPPER32(rd_size / block_size));
-			continue;
-		default:
-			/*
-			 * The client doesn't speak the same protocol.
-			 * Instead of closing the connection, we just ignore
-			 * the call. This can be useful if the client uses a
-			 * newer version of the protocol.
-			 */
-			retval = EINVAL;
-			break;
-		}
-		async_answer_0(callid, retval);
-	}
+static fibril_rwlock_t rd_lock;
+
+static bd_ops_t rd_bd_ops = {
+	.open = rd_open,
+	.close = rd_close,
+	.read_blocks = rd_read_blocks,
+	.write_blocks = rd_write_blocks,
+	.get_block_size = rd_get_block_size,
+	.get_num_blocks = rd_get_num_blocks
+};
+
+static bd_srvs_t bd_srvs;
+
+static void rd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+	bd_conn(iid, icall, &bd_srvs);
+}
+
+/** Open device. */
+static int rd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int rd_close(bd_srv_t *bd)
+{
+	return EOK;
 }
 
 /** Read blocks from the device. */
-static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf)
+static int rd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt, void *buf,
+    size_t size)
 {
 	if ((ba + cnt) * block_size > rd_size) {
@@ -183,5 +122,5 @@
 	
 	fibril_rwlock_read_lock(&rd_lock);
-	memcpy(buf, rd_addr + ba * block_size, block_size * cnt);
+	memcpy(buf, rd_addr + ba * block_size, min(block_size * cnt, size));
 	fibril_rwlock_read_unlock(&rd_lock);
 	
@@ -190,5 +129,6 @@
 
 /** Write blocks to the device. */
-static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf)
+static int rd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    const void *buf, size_t size)
 {
 	if ((ba + cnt) * block_size > rd_size) {
@@ -198,5 +138,5 @@
 	
 	fibril_rwlock_write_lock(&rd_lock);
-	memcpy(rd_addr + ba * block_size, buf, block_size * cnt);
+	memcpy(rd_addr + ba * block_size, buf, min(block_size * cnt, size));
 	fibril_rwlock_write_unlock(&rd_lock);
 	
@@ -235,5 +175,8 @@
 	    (void *) addr_phys, size);
 	
-	async_set_client_connection(rd_connection);
+	bd_srvs_init(&bd_srvs);
+	bd_srvs.ops = &rd_bd_ops;
+	
+	async_set_client_connection(rd_client_conn);
 	ret = loc_server_register(NAME);
 	if (ret != EOK) {
@@ -254,4 +197,18 @@
 }
 
+/** Get device block size. */
+static int rd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	*rsize = block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int rd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	*rnb = rd_size / block_size;
+	return EOK;
+}
+
 int main(int argc, char **argv)
 {
Index: uspace/srv/bd/sata_bd/sata_bd.c
===================================================================
--- uspace/srv/bd/sata_bd/sata_bd.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/sata_bd/sata_bd.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -38,7 +38,7 @@
 
 #include <sys/types.h>
+#include <bd_srv.h>
 #include <errno.h>
 #include <stdio.h>
-#include <ipc/bd.h>
 #include <str.h>
 #include <loc.h>
@@ -56,4 +56,25 @@
 static sata_bd_dev_t disk[MAXDISKS];
 static int disk_count;
+
+static int sata_bd_open(bd_srvs_t *, bd_srv_t *);
+static int sata_bd_close(bd_srv_t *);
+static int sata_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
+static int sata_bd_write_blocks(bd_srv_t *, aoff64_t, size_t, const void *, size_t);
+static int sata_bd_get_block_size(bd_srv_t *, size_t *);
+static int sata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
+
+static bd_ops_t sata_bd_ops = {
+	.open = sata_bd_open,
+	.close = sata_bd_close,
+	.read_blocks = sata_bd_read_blocks,
+	.write_blocks = sata_bd_write_blocks,
+	.get_block_size = sata_bd_get_block_size,
+	.get_num_blocks = sata_bd_get_num_blocks
+};
+
+static sata_bd_dev_t *bd_srv_sata(bd_srv_t *bd)
+{
+	return (sata_bd_dev_t *)bd->srvs->sarg;
+}
 
 /** Find SATA devices in device tree.
@@ -82,5 +103,9 @@
 		
 		ahci_get_num_blocks(disk[disk_count].sess, &disk[disk_count].blocks);
-				
+		
+		bd_srvs_init(&disk[disk_count].bds);
+		disk[disk_count].bds.ops = &sata_bd_ops;
+		disk[disk_count].bds.sarg = &disk[disk_count];
+		
 		printf("Device %s - %s , blocks: %lu, block_size: %lu\n", 
 		    disk[disk_count].dev_name, disk[disk_count].sata_dev_name,
@@ -141,15 +166,5 @@
 static void sata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-	void *fs_va = NULL;
-	ipc_callid_t callid;
-	ipc_call_t call;
-	sysarg_t method;
 	service_id_t dsid;
-	/* Size of the communication area. */
-	size_t comm_size;	
-	unsigned int flags;
-	int retval = 0;
-	uint64_t ba;
-	size_t cnt;
 	int disk_id, i;
 
@@ -168,61 +183,61 @@
 	}
 
-	/* Answer the IPC_M_CONNECT_ME_TO call. */
-	async_answer_0(iid, EOK);
-
-	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	(void) async_share_out_finalize(callid, &fs_va);
-	if (fs_va == (void *) -1) {
-		async_answer_0(callid, EHANGUP);
-		return;
-	}
-
-	while (true) {
-		callid = async_get_call(&call);
-		method = IPC_GET_IMETHOD(call);
-		
-		if (!method) {
-			/* The other side has hung up. */
-			async_answer_0(callid, EOK);
-			return;
-		}
-		
-		switch (method) {
-			case BD_READ_BLOCKS:
-				ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-				cnt = IPC_GET_ARG3(call);
-				if (cnt * disk[disk_id].block_size > comm_size) {
-					retval = ELIMIT;
-					break;
-				}
-				retval = ahci_read_blocks(disk[disk_id].sess, ba, cnt, fs_va);
-				break;
-			case BD_WRITE_BLOCKS:
-				ba = MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-				cnt = IPC_GET_ARG3(call);
-				if (cnt * disk[disk_id].block_size > comm_size) {
-					retval = ELIMIT;
-					break;
-				}
-				retval = ahci_write_blocks(disk[disk_id].sess, ba, cnt, fs_va);
-				break;
-			case BD_GET_BLOCK_SIZE:
-				async_answer_1(callid, EOK, disk[disk_id].block_size);
-				continue;
-			case BD_GET_NUM_BLOCKS:
-				async_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
-				    UPPER32(disk[disk_id].blocks));
-				break;
-			default:
-				retval = EINVAL;
-				break;
-			}
-		async_answer_0(callid, retval);
-	}
-}
+	bd_conn(iid, icall, &disk[disk_id].bds);
+}
+
+/** Open device. */
+static int sata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Close device. */
+static int sata_bd_close(bd_srv_t *bd)
+{
+	return EOK;
+}
+
+/** Read blocks from partition. */
+static int sata_bd_read_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt, void *buf,
+    size_t size)
+{
+	sata_bd_dev_t *sbd = bd_srv_sata(bd);
+
+	if (size < cnt * sbd->block_size)
+		return EINVAL;
+
+	return ahci_read_blocks(sbd->sess, ba, cnt, buf);
+}
+
+/** Write blocks to partition. */
+static int sata_bd_write_blocks(bd_srv_t *bd, aoff64_t ba, size_t cnt,
+    const void *buf, size_t size)
+{
+	sata_bd_dev_t *sbd = bd_srv_sata(bd);
+
+	if (size < cnt * sbd->block_size)
+		return EINVAL;
+
+	return ahci_write_blocks(sbd->sess, ba, cnt, (void *)buf);
+}
+
+/** Get device block size. */
+static int sata_bd_get_block_size(bd_srv_t *bd, size_t *rsize)
+{
+	sata_bd_dev_t *sbd = bd_srv_sata(bd);
+
+	*rsize = sbd->block_size;
+	return EOK;
+}
+
+/** Get number of blocks on device. */
+static int sata_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
+{
+	sata_bd_dev_t *sbd = bd_srv_sata(bd);
+
+	*rnb = sbd->blocks;
+	return EOK;
+}
+
 
 int main(int argc, char **argv)
Index: uspace/srv/bd/sata_bd/sata_bd.h
===================================================================
--- uspace/srv/bd/sata_bd/sata_bd.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/bd/sata_bd/sata_bd.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -38,21 +38,25 @@
 #define SATA_DEV_NAME_LENGTH 256
 
+#include <async.h>
+#include <bd_srv.h>
+#include <loc.h>
 #include <sys/types.h>
-#include <loc.h>
 
 /** SATA Block Device. */
 typedef struct {
-	/** Device name in device tree. */ 
-	char* dev_name; 
-	/** SATA Device name. */ 
-	char sata_dev_name[SATA_DEV_NAME_LENGTH]; 
+	/** Device name in device tree. */
+	char *dev_name;
+	/** SATA Device name. */
+	char sata_dev_name[SATA_DEV_NAME_LENGTH];
 	/** Session to device methods. */
-	async_sess_t* sess; 
+	async_sess_t *sess;
 	/** Loc service id. */
 	service_id_t service_id;
 	/** Number of blocks. */
-	uint64_t blocks; 
+	uint64_t blocks;
 	/** Size of block. */
-	size_t block_size; 
+	size_t block_size;
+	/** Block device server structure */
+	bd_srvs_t bds;
 } sata_bd_dev_t;
 
Index: uspace/srv/devman/devman.c
===================================================================
--- uspace/srv/devman/devman.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/devman/devman.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -1052,5 +1052,4 @@
 }
 
-
 /** Find the device node structure of the device witch has the specified handle.
  *
@@ -1142,4 +1141,5 @@
 	fun->state = FUN_INIT;
 	atomic_set(&fun->refcnt, 0);
+	fibril_mutex_initialize(&fun->busy_lock);
 	link_initialize(&fun->dev_functions);
 	list_initialize(&fun->match_ids.ids);
@@ -1184,4 +1184,16 @@
 	if (atomic_predec(&fun->refcnt) == 0)
 		delete_fun_node(fun);
+}
+
+/** Make function busy for reconfiguration operations. */
+void fun_busy_lock(fun_node_t *fun)
+{
+	fibril_mutex_lock(&fun->busy_lock);
+}
+
+/** Mark end of reconfiguration operation. */
+void fun_busy_unlock(fun_node_t *fun)
+{
+	fibril_mutex_unlock(&fun->busy_lock);
 }
 
Index: uspace/srv/devman/devman.h
===================================================================
--- uspace/srv/devman/devman.h	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/devman/devman.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -174,4 +174,6 @@
 	/** State */
 	fun_state_t state;
+	/** Locked while performing reconfiguration operations */
+	fibril_mutex_t busy_lock;
 	
 	/** The global unique identifier of the function */
@@ -279,4 +281,5 @@
 extern void dev_add_ref(dev_node_t *);
 extern void dev_del_ref(dev_node_t *);
+
 extern dev_node_t *find_dev_node_no_lock(dev_tree_t *tree,
     devman_handle_t handle);
@@ -290,4 +293,6 @@
 extern void fun_add_ref(fun_node_t *);
 extern void fun_del_ref(fun_node_t *);
+extern void fun_busy_lock(fun_node_t *);
+extern void fun_busy_unlock(fun_node_t *);
 extern fun_node_t *find_fun_node_no_lock(dev_tree_t *tree,
     devman_handle_t handle);
Index: uspace/srv/devman/main.c
===================================================================
--- uspace/srv/devman/main.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/devman/main.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -432,10 +432,20 @@
 	
 	fun_node_t *fun = create_fun_node();
+	/* One reference for creation, one for us */
+	fun_add_ref(fun);
 	fun_add_ref(fun);
 	fun->ftype = ftype;
+	
+	/*
+	 * We can lock the function here even when holding the tree because
+	 * we know it cannot be held by anyone else yet.
+	 */
+	fun_busy_lock(fun);
 	
 	if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
 		fibril_rwlock_write_unlock(&tree->rwlock);
 		dev_del_ref(pdev);
+		fun_busy_unlock(fun);
+		fun_del_ref(fun);
 		delete_fun_node(fun);
 		async_answer_0(callid, ENOMEM);
@@ -450,8 +460,13 @@
 	rc = online_function(fun);
 	if (rc != EOK) {
-		/* XXX clean up */
+		/* XXX Set some failed state? */
+		fun_busy_unlock(fun);
+		fun_del_ref(fun);
 		async_answer_0(callid, rc);
 		return;
 	}
+	
+	fun_busy_unlock(fun);
+	fun_del_ref(fun);
 	
 	/* Return device handle to parent's driver. */
@@ -522,7 +537,10 @@
 	}
 	
+	fun_busy_lock(fun);
+	
 	fibril_rwlock_read_lock(&device_tree.rwlock);
 	if (fun->dev == NULL || fun->dev->drv != drv) {
 		fibril_rwlock_read_unlock(&device_tree.rwlock);
+		fun_busy_unlock(fun);
 		fun_del_ref(fun);
 		async_answer_0(iid, ENOENT);
@@ -533,4 +551,5 @@
 	rc = online_function(fun);
 	if (rc != EOK) {
+		fun_busy_unlock(fun);
 		fun_del_ref(fun);
 		async_answer_0(iid, (sysarg_t) rc);
@@ -538,4 +557,5 @@
 	}
 	
+	fun_busy_unlock(fun);
 	fun_del_ref(fun);
 	
@@ -559,6 +579,9 @@
 	}
 	
+	fun_busy_lock(fun);
+	
 	fibril_rwlock_write_lock(&device_tree.rwlock);
 	if (fun->dev == NULL || fun->dev->drv != drv) {
+		fun_busy_unlock(fun);
 		fun_del_ref(fun);
 		async_answer_0(iid, ENOENT);
@@ -569,4 +592,5 @@
 	rc = offline_function(fun);
 	if (rc != EOK) {
+		fun_busy_unlock(fun);
 		fun_del_ref(fun);
 		async_answer_0(iid, (sysarg_t) rc);
@@ -574,4 +598,5 @@
 	}
 	
+	fun_busy_unlock(fun);
 	fun_del_ref(fun);
 	async_answer_0(iid, (sysarg_t) EOK);
@@ -591,4 +616,6 @@
 	}
 	
+	fun_busy_lock(fun);
+	
 	fibril_rwlock_write_lock(&tree->rwlock);
 	
@@ -598,4 +625,6 @@
 	if (fun->state == FUN_REMOVED) {
 		fibril_rwlock_write_unlock(&tree->rwlock);
+		fun_busy_unlock(fun);
+		fun_del_ref(fun);
 		async_answer_0(callid, ENOENT);
 		return;
@@ -638,4 +667,6 @@
 				if (gone_rc == EOK)
 					gone_rc = ENOTSUP;
+				fun_busy_unlock(fun);
+				fun_del_ref(fun);
 				async_answer_0(callid, gone_rc);
 				return;
@@ -664,4 +695,5 @@
 				    "service.");
 				fibril_rwlock_write_unlock(&tree->rwlock);
+				fun_busy_unlock(fun);
 				fun_del_ref(fun);
 				async_answer_0(callid, EIO);
@@ -673,4 +705,5 @@
 	remove_fun_node(&device_tree, fun);
 	fibril_rwlock_write_unlock(&tree->rwlock);
+	fun_busy_unlock(fun);
 	
 	/* Delete ref added when inserting function into tree */
Index: uspace/srv/fs/ext4fs/Makefile
===================================================================
--- uspace/srv/fs/ext4fs/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/srv/fs/ext4fs/Makefile	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,38 @@
+#
+# Copyright (c) 2012 Frantisek Princ
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+USPACE_PREFIX = ../../..
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBFS_PREFIX)/libfs.a $(LIBEXT4_PREFIX)/libext4.a
+EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX) -I$(LIBEXT4_PREFIX)
+BINARY = ext4fs
+
+SOURCES = \
+	ext4fs.c \
+	ext4fs_ops.c
+
+include $(USPACE_PREFIX)/Makefile.common
Index: uspace/srv/fs/ext4fs/ext4fs.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/srv/fs/ext4fs/ext4fs.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup fs
+ * @{
+ */
+/**
+ * @file  ext4fs.c
+ * @brief Ext4 file system driver for HelenOS.
+ */
+
+#include <async.h>
+#include <errno.h>
+#include <libfs.h>
+#include <ns.h>
+#include <stdio.h>
+#include <task.h>
+#include <ipc/services.h>
+#include "ext4fs.h"
+#include "../../vfs/vfs.h"
+
+#define NAME  "ext4fs"
+
+vfs_info_t ext4fs_vfs_info = {
+	.name = NAME,
+	.instance = 0
+};
+
+int main(int argc, char **argv)
+{
+	printf("%s: HelenOS ext4 file system server\n", NAME);
+	
+	if (argc == 3) {
+		if (!str_cmp(argv[1], "--instance"))
+			ext4fs_vfs_info.instance = strtol(argv[2], NULL, 10);
+		else {
+			printf("%s: Unrecognized parameters\n", NAME);
+			return 1;
+		}
+	}
+	
+	async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
+	    SERVICE_VFS, 0, 0);
+	if (!vfs_sess) {
+		printf("%s: Failed to connect to VFS\n", NAME);
+		return 2;
+	}
+	
+	int rc = ext4fs_global_init();
+	if (rc != EOK) {
+		printf("%s: Global initialization failed\n", NAME);
+		return rc;
+	}
+	
+	rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4fs_ops,
+	    &ext4fs_libfs_ops);
+	if (rc != EOK) {
+		printf("%s: Failed to register file system\n", NAME);
+		return rc;
+	}
+	
+	printf("%s: Accepting connections\n", NAME);
+	task_retval(0);
+	async_manager();
+	
+	/* Not reached */
+	return 0;
+}
+
+/**
+ * @}
+ */
Index: uspace/srv/fs/ext4fs/ext4fs.h
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/srv/fs/ext4fs/ext4fs.h	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup fs
+ * @{
+ */
+
+#ifndef EXT4FS_EXT4FS_H_
+#define EXT4FS_EXT4FS_H_
+
+#include <libfs.h>
+
+extern vfs_out_ops_t ext4fs_ops;
+extern libfs_ops_t ext4fs_libfs_ops;
+
+extern int ext4fs_global_init(void);
+extern int ext4fs_global_fini(void);
+
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/srv/fs/ext4fs/ext4fs_ops.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
+++ uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -0,0 +1,1511 @@
+/*
+ * Copyright (c) 2012 Frantisek Princ
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup fs
+ * @{
+ */
+/**
+ * @file  ext4fs_ops.c
+ * @brief VFS operations for ext4 filesystem.
+ */
+
+#include <errno.h>
+#include <fibril_synch.h>
+#include <libext4.h>
+#include <libfs.h>
+#include <macros.h>
+#include <malloc.h>
+#include <adt/hash_table.h>
+#include <ipc/loc.h>
+#include "ext4fs.h"
+#include "../../vfs/vfs.h"
+
+#define EXT4FS_NODE(node) \
+	((node) ? (ext4fs_node_t *) (node)->data : NULL)
+
+#define OPEN_NODES_KEYS  2
+
+#define OPEN_NODES_DEV_HANDLE_KEY  0
+#define OPEN_NODES_INODE_KEY       1
+
+#define OPEN_NODES_BUCKETS  256
+
+/**
+ * Type for holding an instance of mounted partition.
+ */
+typedef struct ext4fs_instance {
+	link_t link;
+	service_id_t service_id;
+	ext4_filesystem_t *filesystem;
+	unsigned int open_nodes_count;
+} ext4fs_instance_t;
+
+/**
+ * Type for wrapping common fs_node and add some useful pointers.
+ */
+typedef struct ext4fs_node {
+	ext4fs_instance_t *instance;
+	ext4_inode_ref_t *inode_ref;
+	fs_node_t *fs_node;
+	link_t link;
+	unsigned int references;
+} ext4fs_node_t;
+
+/* 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 *,
+    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 int ext4fs_node_get_core(fs_node_t **, ext4fs_instance_t *, fs_index_t);
+static int ext4fs_node_put_core(ext4fs_node_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 *);
+static 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 variables */
+
+static LIST_INITIALIZE(instance_list);
+static FIBRIL_MUTEX_INITIALIZE(instance_list_mutex);
+static hash_table_t open_nodes;
+static FIBRIL_MUTEX_INITIALIZE(open_nodes_lock);
+
+/* Hash table interface for open nodes hash table */
+static hash_index_t open_nodes_hash(unsigned long key[])
+{
+	/* TODO: This is very simple and probably can be improved */
+	return key[OPEN_NODES_INODE_KEY] % OPEN_NODES_BUCKETS;
+}
+
+/** Compare given item with values in hash table.
+ *
+ */
+static int open_nodes_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+	assert(keys > 0);
+	
+	ext4fs_node_t *enode =
+	    hash_table_get_instance(item, ext4fs_node_t, link);
+	
+	if (enode->instance->service_id !=
+	    ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY]))
+		return false;
+	
+	if (keys == 1)
+		return true;
+	
+	assert(keys == 2);
+	
+	return (enode->inode_ref->index == key[OPEN_NODES_INODE_KEY]);
+}
+
+/** Empty callback to correct hash table initialization.
+ *
+ */
+static void open_nodes_remove_cb(link_t *link)
+{
+	/* We don't use remove callback for this hash table */
+}
+
+static hash_table_operations_t open_nodes_ops = {
+	.hash = open_nodes_hash,
+	.compare = open_nodes_compare,
+	.remove_callback = open_nodes_remove_cb,
+};
+
+/** Basic initialization of the driver.
+ *
+ * This is only needed to create the hash table
+ * for storing open nodes.
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_global_init(void)
+{
+	if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
+	    OPEN_NODES_KEYS, &open_nodes_ops))
+		return ENOMEM;
+	
+	return EOK;
+}
+
+/* Finalization of the driver.
+ *
+ * This is only needed to destroy the hash table.
+ *
+ * @return Error code
+ */
+int ext4fs_global_fini(void)
+{
+	hash_table_destroy(&open_nodes);
+	return EOK;
+}
+
+/*
+ * Ext4 libfs operations.
+ */
+
+/** Get instance from internal table by service_id.
+ *
+ * @param service_id Device identifier
+ * @param inst       Output instance if successful operation
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
+{
+	fibril_mutex_lock(&instance_list_mutex);
+	
+	if (list_empty(&instance_list)) {
+		fibril_mutex_unlock(&instance_list_mutex);
+		return EINVAL;
+	}
+	
+	list_foreach(instance_list, link) {
+		ext4fs_instance_t *tmp =
+		    list_get_instance(link, ext4fs_instance_t, link);
+		
+		if (tmp->service_id == service_id) {
+			*inst = tmp;
+			fibril_mutex_unlock(&instance_list_mutex);
+			return EOK;
+		}
+	}
+	
+	fibril_mutex_unlock(&instance_list_mutex);
+	return EINVAL;
+}
+
+/** Get root node of filesystem specified by service_id.
+ * 
+ * @param rfn        Output pointer to loaded node
+ * @param service_id Device to load root node from
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_root_get(fs_node_t **rfn, service_id_t service_id)
+{
+	return ext4fs_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
+}
+
+/** Check if specified name (component) matches with any directory entry.
+ * 
+ * If match is found, load and return matching node.
+ *
+ * @param rfn       Output pointer to node if operation successful
+ * @param pfn       Parent directory node
+ * @param component Name to check directory for
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
+{
+	ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
+	ext4_filesystem_t *fs = eparent->instance->filesystem;
+	
+	if (!ext4_inode_is_type(fs->superblock, eparent->inode_ref->inode,
+	    EXT4_INODE_MODE_DIRECTORY))
+		return ENOTDIR;
+	
+	/* Try to find entry */
+	ext4_directory_search_result_t result;
+	int rc = ext4_directory_find_entry(&result, eparent->inode_ref,
+	    component);
+	if (rc != EOK) {
+		if (rc == ENOENT) {
+			*rfn = NULL;
+			return EOK;
+		}
+		
+		return rc;
+	}
+	
+	/* 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);
+	if (rc != EOK)
+		return rc;
+	
+	/* Destroy search result structure */
+	return ext4_directory_destroy_result(&result);
+}
+
+/** Get node specified by index
+ *
+ * It's wrapper for node_put_core operation
+ *
+ * @param rfn        Output pointer to loaded node if operation successful
+ * @param service_id Device identifier
+ * @param index      Node index (here i-node number)
+ *
+ * @return Error code
+ *
+ */
+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);
+}
+
+/** Main function for getting node from the filesystem. 
+ *
+ * @param rfn   Output point to loaded node if operation successful
+ * @param inst  Instance of filesystem
+ * @param index Index of node (i-node number)
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_node_get_core(fs_node_t **rfn, ext4fs_instance_t *inst,
+    fs_index_t index)
+{
+	fibril_mutex_lock(&open_nodes_lock);
+	
+	/* Check if the node is not already open */
+	unsigned long key[] = {
+		[OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
+		[OPEN_NODES_INODE_KEY] = index
+	};
+	
+	link_t *already_open = hash_table_find(&open_nodes, key);
+	ext4fs_node_t *enode = NULL;
+	if (already_open) {
+		enode = hash_table_get_instance(already_open, ext4fs_node_t, link);
+		*rfn = enode->fs_node;
+		enode->references++;
+		
+		fibril_mutex_unlock(&open_nodes_lock);
+		return EOK;
+	}
+	
+	/* Prepare new enode */
+	enode = malloc(sizeof(ext4fs_node_t));
+	if (enode == NULL) {
+		fibril_mutex_unlock(&open_nodes_lock);
+		return ENOMEM;
+	}
+	
+	/* Prepare new fs_node and initialize */
+	fs_node_t *fs_node = malloc(sizeof(fs_node_t));
+	if (fs_node == NULL) {
+		free(enode);
+		fibril_mutex_unlock(&open_nodes_lock);
+		return ENOMEM;
+	}
+	
+	fs_node_initialize(fs_node);
+	
+	/* Load i-node from filesystem */
+	ext4_inode_ref_t *inode_ref;
+	int rc = ext4_filesystem_get_inode_ref(inst->filesystem, index,
+	    &inode_ref);
+	if (rc != EOK) {
+		free(enode);
+		free(fs_node);
+		fibril_mutex_unlock(&open_nodes_lock);
+		return rc;
+	}
+	
+	/* Initialize enode */
+	enode->inode_ref = inode_ref;
+	enode->instance = inst;
+	enode->references = 1;
+	enode->fs_node = fs_node;
+	link_initialize(&enode->link);
+	
+	fs_node->data = enode;
+	*rfn = fs_node;
+	
+	hash_table_insert(&open_nodes, key, &enode->link);
+	inst->open_nodes_count++;
+	
+	fibril_mutex_unlock(&open_nodes_lock);
+	
+	return EOK;
+}
+
+/** Put previously loaded node.
+ *
+ * @param enode Node to put back
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_node_put_core(ext4fs_node_t *enode)
+{
+	unsigned long key[] = {
+		[OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
+		[OPEN_NODES_INODE_KEY] = enode->inode_ref->index
+	};
+	
+	hash_table_remove(&open_nodes, key, OPEN_NODES_KEYS);
+	assert(enode->instance->open_nodes_count > 0);
+	enode->instance->open_nodes_count--;
+	
+	/* Put inode back in filesystem */
+	int rc = ext4_filesystem_put_inode_ref(enode->inode_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Destroy data structure */
+	free(enode->fs_node);
+	free(enode);
+	
+	return EOK;
+}
+
+/** Open node.
+ *
+ * This operation is stateless in this driver.
+ *
+ * @param fn Node to open
+ *
+ * @return EOK
+ *
+ */
+int ext4fs_node_open(fs_node_t *fn)
+{
+	/* Stateless operation */
+	return EOK;
+}
+
+/** Put previously loaded node.
+ *
+ * A wrapper for node_put_core operation
+ *
+ * @param fn Node to put back
+ * @return Error code
+ *
+ */
+int ext4fs_node_put(fs_node_t *fn)
+{
+	fibril_mutex_lock(&open_nodes_lock);
+	
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	assert(enode->references > 0);
+	enode->references--;
+	if (enode->references == 0) {
+		int rc = ext4fs_node_put_core(enode);
+		if (rc != EOK) {
+			fibril_mutex_unlock(&open_nodes_lock);
+			return rc;
+		}
+	}
+	
+	fibril_mutex_unlock(&open_nodes_lock);
+	
+	return EOK;
+}
+
+/** Create new node in filesystem.
+ *
+ * @param rfn        Output pointer to newly created node if successful
+ * @param service_id Device identifier, where the filesystem is
+ * @param flags      Flags for specification of new node parameters
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_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));
+	if (enode == NULL)
+		return ENOMEM;
+	
+	/* Allocate fs_node */
+	fs_node_t *fs_node;
+	fs_node = malloc(sizeof(fs_node_t));
+	if (fs_node == NULL) {
+		free(enode);
+		return ENOMEM;
+	}
+	
+	/* Load instance */
+	ext4fs_instance_t *inst;
+	int rc = ext4fs_instance_get(service_id, &inst);
+	if (rc != EOK) {
+		free(enode);
+		free(fs_node);
+		return rc;
+	}
+	
+	/* Allocate new i-node in filesystem */
+	ext4_inode_ref_t *inode_ref;
+	rc = ext4_filesystem_alloc_inode(inst->filesystem, &inode_ref, flags);
+	if (rc != EOK) {
+		free(enode);
+		free(fs_node);
+		return rc;
+	}
+	
+	/* Do some interconnections in references */
+	enode->inode_ref = inode_ref;
+	enode->instance = inst;
+	enode->references = 1;
+	
+	link_initialize(&enode->link);
+	
+	unsigned long key[] = {
+		[OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
+		[OPEN_NODES_INODE_KEY] = inode_ref->index
+	};
+	
+	fibril_mutex_lock(&open_nodes_lock);
+	hash_table_insert(&open_nodes, key, &enode->link);
+	fibril_mutex_unlock(&open_nodes_lock);
+	inst->open_nodes_count++;
+	
+	enode->inode_ref->dirty = true;
+	
+	fs_node_initialize(fs_node);
+	fs_node->data = enode;
+	enode->fs_node = fs_node;
+	*rfn = fs_node;
+	
+	return EOK;
+}
+
+/** Destroy existing node.
+ *
+ * @param fs Node to destroy
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_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);
+		return rc;
+	}
+	
+	if (has_children) {
+		ext4fs_node_put(fn);
+		return EINVAL;
+	}
+	
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_inode_ref_t *inode_ref = enode->inode_ref;
+	
+	/* Release data blocks */
+	rc = ext4_filesystem_truncate_inode(inode_ref, 0);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		return rc;
+	}
+	
+	/*
+	 * TODO: Sset real deletion time when it will be supported.
+	 * Temporary set fake deletion time.
+	 */
+	ext4_inode_set_deletion_time(inode_ref->inode, 0xdeadbeef);
+	inode_ref->dirty = true;
+	
+	/* Free inode */
+	rc = ext4_filesystem_free_inode(inode_ref);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		return rc;
+	}
+	
+	return ext4fs_node_put(fn);
+}
+
+/** Link the specfied node to directory.
+ *
+ * @param pfn  Parent node to link in
+ * @param cfn  Node to be linked
+ * @param name Name which will be assigned to directory entry
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+{
+	/* Check maximum name length */
+	if (str_size(name) > EXT4_DIRECTORY_FILENAME_LEN)
+		return ENAMETOOLONG;
+	
+	ext4fs_node_t *parent = EXT4FS_NODE(pfn);
+	ext4fs_node_t *child = EXT4FS_NODE(cfn);
+	ext4_filesystem_t *fs = parent->instance->filesystem;
+	
+	/* Add entry to parent directory */
+	int rc = ext4_directory_add_entry(parent->inode_ref, name,
+	    child->inode_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* Fill new dir -> add '.' and '..' entries */
+	if (ext4_inode_is_type(fs->superblock, child->inode_ref->inode,
+	    EXT4_INODE_MODE_DIRECTORY)) {
+		rc = ext4_directory_add_entry(child->inode_ref, ".",
+		    child->inode_ref);
+		if (rc != EOK) {
+			ext4_directory_remove_entry(parent->inode_ref, name);
+			return rc;
+		}
+		
+		rc = ext4_directory_add_entry(child->inode_ref, "..",
+		    parent->inode_ref);
+		if (rc != EOK) {
+			ext4_directory_remove_entry(parent->inode_ref, name);
+			ext4_directory_remove_entry(child->inode_ref, ".");
+			return rc;
+		}
+		
+		/* Initialize directory index if supported */
+		if (ext4_superblock_has_feature_compatible(fs->superblock,
+		    EXT4_FEATURE_COMPAT_DIR_INDEX)) {
+			rc = ext4_directory_dx_init(child->inode_ref);
+			if (rc != EOK)
+				return rc;
+			
+			ext4_inode_set_flag(child->inode_ref->inode,
+			    EXT4_INODE_FLAG_INDEX);
+			child->inode_ref->dirty = true;
+		}
+	
+		uint16_t parent_links =
+		    ext4_inode_get_links_count(parent->inode_ref->inode);
+		parent_links++;
+		ext4_inode_set_links_count(parent->inode_ref->inode, parent_links);
+		
+		parent->inode_ref->dirty = true;
+	}
+	
+	uint16_t child_links =
+	    ext4_inode_get_links_count(child->inode_ref->inode);
+	child_links++;
+	ext4_inode_set_links_count(child->inode_ref->inode, child_links);
+	
+	child->inode_ref->dirty = true;
+	
+	return EOK;
+}
+
+/** Unlink node from specified directory.
+ *
+ * @param pfn  Parent node to delete node from
+ * @param cfn  Child node to be unlinked from directory
+ * @param name Name of entry that will be removed
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+{
+	bool has_children;
+	int rc = ext4fs_has_children(&has_children, cfn);
+	if (rc != EOK)
+		return rc;
+	
+	/* Cannot unlink non-empty node */
+	if (has_children)
+		return ENOTEMPTY;
+	
+	/* Remove entry from parent directory */
+	ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref;
+	rc = ext4_directory_remove_entry(parent, name);
+	if (rc != EOK)
+		return rc;
+	
+	/* Decrement links count */
+	ext4_inode_ref_t *child_inode_ref = EXT4FS_NODE(cfn)->inode_ref;
+	
+	uint32_t lnk_count =
+	    ext4_inode_get_links_count(child_inode_ref->inode);
+	lnk_count--;
+	
+	/* If directory - handle links from parent */
+	if ((lnk_count <= 1) && (ext4fs_is_directory(cfn))) {
+		assert(lnk_count == 1);
+		
+		lnk_count--;
+		
+		ext4_inode_ref_t *parent_inode_ref = EXT4FS_NODE(pfn)->inode_ref;
+		
+		uint32_t parent_lnk_count = ext4_inode_get_links_count(
+		    parent_inode_ref->inode);
+		
+		parent_lnk_count--;
+		ext4_inode_set_links_count(parent_inode_ref->inode, parent_lnk_count);
+		
+		parent->dirty = true;
+	}
+
+	/*
+	 * TODO: Update timestamps of the parent
+	 * (when we have wall-clock time).
+	 *
+	 * ext4_inode_set_change_inode_time(parent->inode, (uint32_t) now);
+	 * ext4_inode_set_modification_time(parent->inode, (uint32_t) now);
+	 * parent->dirty = true;
+	 */
+	
+	/*
+	 * TODO: Update timestamp for inode.
+	 *
+	 * ext4_inode_set_change_inode_time(child_inode_ref->inode,
+	 *     (uint32_t) now);
+	 */
+	
+	ext4_inode_set_links_count(child_inode_ref->inode, lnk_count);
+	child_inode_ref->dirty = true;
+	
+	return EOK;
+}
+
+/** Check if specified node has children.
+ *
+ * For files is response allways false and check is executed only for directories.
+ *
+ * @param has_children Output value for response
+ * @param fn           Node to check
+ *
+ * @return Error code
+ *
+ */
+int ext4fs_has_children(bool *has_children, fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_filesystem_t *fs = enode->instance->filesystem;
+	
+	/* Check if node is directory */
+	if (!ext4_inode_is_type(fs->superblock, enode->inode_ref->inode,
+	    EXT4_INODE_MODE_DIRECTORY)) {
+		*has_children = false;
+		return EOK;
+	}
+	
+	ext4_directory_iterator_t it;
+	int rc = ext4_directory_iterator_init(&it, enode->inode_ref, 0);
+	if (rc != EOK)
+		return rc;
+	
+	/* Find a non-empty directory entry */
+	bool found = false;
+	while (it.current != NULL) {
+		if (it.current->inode != 0) {
+			uint16_t name_size =
+			    ext4_directory_entry_ll_get_name_length(fs->superblock,
+			    it.current);
+			if (!ext4fs_is_dots(it.current->name, name_size)) {
+				found = true;
+				break;
+			}
+		}
+		
+		rc = ext4_directory_iterator_next(&it);
+		if (rc != EOK) {
+			ext4_directory_iterator_fini(&it);
+			return rc;
+		}
+	}
+	
+	rc = ext4_directory_iterator_fini(&it);
+	if (rc != EOK)
+		return rc;
+	
+	*has_children = found;
+	
+	return EOK;
+}
+
+/** Unpack index number from node.
+ *
+ * @param fn Node to load index from
+ *
+ * @return Index number of i-node
+ *
+ */
+fs_index_t ext4fs_index_get(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	return enode->inode_ref->index;
+}
+
+/** Get real size of file / directory.
+ *
+ * @param fn Node to get size of
+ *
+ * @return Real size of node
+ *
+ */
+aoff64_t ext4fs_size_get(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	return ext4_inode_get_size(sb, enode->inode_ref->inode);
+}
+
+/** Get number of links to specified node.
+ *
+ * @param fn Node to get links to
+ *
+ * @return Number of links
+ *
+ */
+unsigned ext4fs_lnkcnt_get(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
+	
+	if (ext4fs_is_directory(fn)) {
+		if (lnkcnt > 1)
+			return 1;
+		else
+			return 0;
+	}
+	
+	/* For regular files return real links count */
+	return lnkcnt;
+}
+
+/** Check if node is directory.
+ *
+ * @param fn Node to check
+ *
+ * @return Result of check
+ *
+ */
+bool ext4fs_is_directory(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	
+	return ext4_inode_is_type(sb, enode->inode_ref->inode,
+	    EXT4_INODE_MODE_DIRECTORY);
+}
+
+/** Check if node is regular file.
+ *
+ * @param fn Node to check
+ *
+ * @return Result of check
+ *
+ */
+bool ext4fs_is_file(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	
+	return ext4_inode_is_type(sb, enode->inode_ref->inode,
+	    EXT4_INODE_MODE_FILE);
+}
+
+/** Extract device identifier from node.
+ *
+ * @param node Node to extract id from
+ *
+ * @return id of device, where is the filesystem
+ *
+ */
+service_id_t ext4fs_service_get(fs_node_t *fn)
+{
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	return enode->instance->service_id;
+}
+
+/*
+ * 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
+};
+
+/*
+ * VFS operations.
+ */
+
+/** Mount operation.
+ *
+ * Try to mount specified filesystem from device.
+ *
+ * @param service_id Identifier of device
+ * @param opts       Mount options
+ * @param index      Output value - index of root node
+ * @param size       Output value - size of root node
+ * @param lnkcnt     Output value - link count of root node
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_mounted(service_id_t service_id, const char *opts,
+    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
+{
+	/* Allocate libext4 filesystem structure */
+	ext4_filesystem_t *fs = (ext4_filesystem_t *)
+	    malloc(sizeof(ext4_filesystem_t));
+	if (fs == NULL)
+		return ENOMEM;
+	
+	/* Allocate instance structure */
+	ext4fs_instance_t *inst = (ext4fs_instance_t *)
+	    malloc(sizeof(ext4fs_instance_t));
+	if (inst == NULL) {
+		free(fs);
+		return ENOMEM;
+	}
+	
+	enum cache_mode cmode;
+	if (str_cmp(opts, "wtcache") == 0)
+		cmode = CACHE_MODE_WT;
+	else
+		cmode = CACHE_MODE_WB;
+	
+	/* Initialize the filesystem */
+	int rc = ext4_filesystem_init(fs, service_id, cmode);
+	if (rc != EOK) {
+		free(fs);
+		free(inst);
+		return rc;
+	}
+	
+	/* Do some sanity checking */
+	rc = ext4_filesystem_check_sanity(fs);
+	if (rc != EOK) {
+		ext4_filesystem_fini(fs);
+		free(fs);
+		free(inst);
+		return rc;
+	}
+	
+	/* Check flags */
+	bool read_only;
+	rc = ext4_filesystem_check_features(fs, &read_only);
+	if (rc != EOK) {
+		ext4_filesystem_fini(fs);
+		free(fs);
+		free(inst);
+		return rc;
+	}
+	
+	/* Initialize instance */
+	link_initialize(&inst->link);
+	inst->service_id = service_id;
+	inst->filesystem = fs;
+	inst->open_nodes_count = 0;
+	
+	/* Read root node */
+	fs_node_t *root_node;
+	rc = ext4fs_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
+	if (rc != EOK) {
+		ext4_filesystem_fini(fs);
+		free(fs);
+		free(inst);
+		return rc;
+	}
+	
+	/* Add instance to the list */
+	fibril_mutex_lock(&instance_list_mutex);
+	list_append(&inst->link, &instance_list);
+	fibril_mutex_unlock(&instance_list_mutex);
+	
+	ext4fs_node_t *enode = EXT4FS_NODE(root_node);
+	
+	*index = EXT4_INODE_ROOT_INDEX;
+	*size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
+	*lnkcnt = 1;
+	
+	ext4fs_node_put(root_node);
+	
+	return EOK;
+}
+
+/** Unmount operation.
+ *
+ * Correctly release the filesystem.
+ *
+ * @param service_id Device to be unmounted
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_unmounted(service_id_t service_id)
+{
+	ext4fs_instance_t *inst;
+	int rc = ext4fs_instance_get(service_id, &inst);
+	if (rc != EOK)
+		return rc;
+	
+	fibril_mutex_lock(&open_nodes_lock);
+	
+	if (inst->open_nodes_count != 0) {
+		fibril_mutex_unlock(&open_nodes_lock);
+		return EBUSY;
+	}
+	
+	/* Remove the instance from the list */
+	fibril_mutex_lock(&instance_list_mutex);
+	list_remove(&inst->link);
+	fibril_mutex_unlock(&instance_list_mutex);
+	
+	fibril_mutex_unlock(&open_nodes_lock);
+	
+	return ext4_filesystem_fini(inst->filesystem);
+}
+
+/** Read bytes from node.
+ *
+ * @param service_id Device to read data from
+ * @param index      Number of node to read from
+ * @param pos        Position where the read should be started
+ * @param rbytes     Output value, where the real size was returned
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
+    size_t *rbytes)
+{
+	/*
+	 * Receive the read request.
+	 */
+	ipc_callid_t callid;
+	size_t size;
+	if (!async_data_read_receive(&callid, &size)) {
+		async_answer_0(callid, EINVAL);
+		return EINVAL;
+	}
+	
+	ext4fs_instance_t *inst;
+	int rc = ext4fs_instance_get(service_id, &inst);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	/* Load i-node */
+	ext4_inode_ref_t *inode_ref;
+	rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	/* Read from i-node by type */
+	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,
+		    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,
+		    rbytes);
+	} else {
+		/* Other inode types not supported */
+		async_answer_0(callid, ENOTSUP);
+		rc = ENOTSUP;
+	}
+	
+	ext4_filesystem_put_inode_ref(inode_ref);
+	
+	return rc;
+}
+
+/** Check if filename is dot or dotdot (reserved names).
+ *
+ * @param name      Name to check
+ * @param name_size Length of string name
+ *
+ * @return Result of the check
+ *
+ */
+bool ext4fs_is_dots(const uint8_t *name, size_t name_size)
+{
+	if ((name_size == 1) && (name[0] == '.'))
+		return true;
+	
+	if ((name_size == 2) && (name[0] == '.') && (name[1] == '.'))
+		return true;
+	
+	return false;
+}
+
+/** Read data from directory.
+ *
+ * @param callid    IPC id of call (for communication)
+ * @param pos       Position to start reading from
+ * @param size      How many bytes to read
+ * @param inst      Filesystem instance
+ * @param inode_ref Node to read data from
+ * @param rbytes    Output value to return real number of bytes was read
+ *
+ * @return Error code
+ *
+ */
+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)
+{
+	ext4_directory_iterator_t it;
+	int rc = ext4_directory_iterator_init(&it, inode_ref, pos);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	/*
+	 * Find next interesting directory entry.
+	 * We want to skip . and .. entries
+	 * as these are not used in HelenOS
+	 */
+	bool found = false;
+	while (it.current != NULL) {
+		if (it.current->inode == 0)
+			goto skip;
+		
+		uint16_t name_size = ext4_directory_entry_ll_get_name_length(
+		    inst->filesystem->superblock, it.current);
+		
+		/* Skip . and .. */
+		if (ext4fs_is_dots(it.current->name, name_size))
+			goto skip;
+		
+		/*
+		 * The on-disk entry does not contain \0 at the end
+		 * end of entry name, so we copy it to new buffer
+		 * and add the \0 at the end
+		 */
+		uint8_t *buf = malloc(name_size + 1);
+		if (buf == NULL) {
+			ext4_directory_iterator_fini(&it);
+			async_answer_0(callid, ENOMEM);
+			return ENOMEM;
+		}
+		
+		memcpy(buf, &it.current->name, name_size);
+		*(buf + name_size) = 0;
+		found = true;
+		
+		(void) async_data_read_finalize(callid, buf, name_size + 1);
+		free(buf);
+		break;
+		
+skip:
+		rc = ext4_directory_iterator_next(&it);
+		if (rc != EOK) {
+			ext4_directory_iterator_fini(&it);
+			async_answer_0(callid, rc);
+			return rc;
+		}
+	}
+	
+	uint64_t next;
+	if (found) {
+		rc = ext4_directory_iterator_next(&it);
+		if (rc != EOK)
+			return rc;
+		
+		next = it.current_offset;
+	}
+	
+	rc = ext4_directory_iterator_fini(&it);
+	if (rc != EOK)
+		return rc;
+	
+	/* Prepare return values */
+	if (found) {
+		*rbytes = next - pos;
+		return EOK;
+	} else {
+		async_answer_0(callid, ENOENT);
+		return ENOENT;
+	}
+}
+
+/** Read data from file.
+ *
+ * @param callid    IPC id of call (for communication)
+ * @param pos       Position to start reading from
+ * @param size      How many bytes to read
+ * @param inst      Filesystem instance
+ * @param inode_ref Node to read data from
+ * @param rbytes    Output value to return real number of bytes was read
+ *
+ * @return Error code
+ *
+ */
+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)
+{
+	ext4_superblock_t *sb = inst->filesystem->superblock;
+	uint64_t file_size = ext4_inode_get_size(sb, inode_ref->inode);
+	
+	if (pos >= file_size) {
+		/* Read 0 bytes successfully */
+		async_data_read_finalize(callid, NULL, 0);
+		*rbytes = 0;
+		return EOK;
+	}
+	
+	/* For now, we only read data from one block at a time */
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	aoff64_t file_block = pos / block_size;
+	uint32_t offset_in_block = pos % block_size;
+	uint32_t bytes = min(block_size - offset_in_block, size);
+	
+	/* Handle end of file */
+	if (pos + bytes > file_size)
+		bytes = file_size - pos;
+	
+	/* Get the real block number */
+	uint32_t fs_block;
+	int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
+	    file_block, &fs_block);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	/*
+	 * Check for sparse file.
+	 * If ext4_filesystem_get_inode_data_block_index returned
+	 * fs_block == 0, it means that the given block is not allocated for the
+	 * file and we need to return a buffer of zeros
+	 */
+	uint8_t *buffer;
+	if (fs_block == 0) {
+		buffer = malloc(bytes);
+		if (buffer == NULL) {
+			async_answer_0(callid, ENOMEM);
+			return ENOMEM;
+		}
+		
+		memset(buffer, 0, bytes);
+		
+		async_data_read_finalize(callid, buffer, bytes);
+		*rbytes = bytes;
+		
+		free(buffer);
+		return EOK;
+	}
+	
+	/* Usual case - we need to read a block from device */
+	block_t *block;
+	rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	assert(offset_in_block + bytes <= block_size);
+	async_data_read_finalize(callid, block->data + offset_in_block, bytes);
+	
+	rc = block_put(block);
+	if (rc != EOK)
+		return rc;
+	
+	*rbytes = bytes;
+	return EOK;
+}
+
+/** Write bytes to file
+ *
+ * @param service_id Device identifier
+ * @param index      I-node number of file
+ * @param pos        Position in file to start reading from
+ * @param wbytes     Output value - real number of written bytes
+ * @param nsize      Output value - new size of i-node
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_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);
+	if (rc != EOK)
+		return rc;
+	
+	ipc_callid_t callid;
+	size_t len;
+	if (!async_data_write_receive(&callid, &len)) {
+		ext4fs_node_put(fn);
+		async_answer_0(callid, EINVAL);
+		return EINVAL;
+	}
+	
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_filesystem_t *fs = enode->instance->filesystem;
+	
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
+	
+	/* Prevent writing to more than one block */
+	uint32_t bytes = min(len, block_size - (pos % block_size));
+	
+	int flags = BLOCK_FLAGS_NONE;
+	if (bytes == block_size)
+		flags = BLOCK_FLAGS_NOREAD;
+	
+	uint32_t iblock =  pos / block_size;
+	uint32_t fblock;
+	
+	/* Load inode */
+	ext4_inode_ref_t *inode_ref = enode->inode_ref;
+	rc = ext4_filesystem_get_inode_data_block_index(inode_ref, iblock,
+	    &fblock);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	/* Check for sparse file */
+	if (fblock == 0) {
+		if ((ext4_superblock_has_feature_incompatible(fs->superblock,
+		    EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
+		    (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
+			uint32_t last_iblock =
+			    ext4_inode_get_size(fs->superblock, inode_ref->inode) /
+			    block_size;
+			
+			while (last_iblock < iblock) {
+				rc = ext4_extent_append_block(inode_ref, &last_iblock,
+				    &fblock, true);
+				if (rc != EOK) {
+					ext4fs_node_put(fn);
+					async_answer_0(callid, rc);
+					return rc;
+				}
+			}
+			
+			rc = ext4_extent_append_block(inode_ref, &last_iblock,
+			    &fblock, false);
+			if (rc != EOK) {
+				ext4fs_node_put(fn);
+				async_answer_0(callid, rc);
+				return rc;
+			}
+		} else {
+			rc = ext4_balloc_alloc_block(inode_ref, &fblock);
+			if (rc != EOK) {
+				ext4fs_node_put(fn);
+				async_answer_0(callid, rc);
+				return rc;
+			}
+			
+			rc = ext4_filesystem_set_inode_data_block_index(inode_ref,
+			    iblock, fblock);
+			if (rc != EOK) {
+				ext4_balloc_free_block(inode_ref, fblock);
+				ext4fs_node_put(fn);
+				async_answer_0(callid, rc);
+				return rc;
+			}
+		}
+		
+		flags = BLOCK_FLAGS_NOREAD;
+		inode_ref->dirty = true;
+	}
+	
+	/* Load target block */
+	block_t *write_block;
+	rc = block_get(&write_block, service_id, fblock, flags);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		async_answer_0(callid, rc);
+		return rc;
+	}
+	
+	if (flags == BLOCK_FLAGS_NOREAD)
+		memset(write_block->data, 0, block_size);
+	
+	rc = async_data_write_finalize(callid, write_block->data +
+	    (pos % block_size), bytes);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		return rc;
+	}
+	
+	write_block->dirty = true;
+	
+	rc = block_put(write_block);
+	if (rc != EOK) {
+		ext4fs_node_put(fn);
+		return rc;
+	}
+	
+	/* Do some counting */
+	uint32_t old_inode_size = ext4_inode_get_size(fs->superblock,
+	    inode_ref->inode);
+	if (pos + bytes > old_inode_size) {
+		ext4_inode_set_size(inode_ref->inode, pos + bytes);
+		inode_ref->dirty = true;
+	}
+	
+	*nsize = ext4_inode_get_size(fs->superblock, inode_ref->inode);
+	*wbytes = bytes;
+	
+	return ext4fs_node_put(fn);
+}
+
+/** Truncate file.
+ *
+ * Only the direction to shorter file is supported.
+ *
+ * @param service_id Device identifier
+ * @param index      Index if node to truncated
+ * @param new_size   New size of file
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_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);
+	ext4_inode_ref_t *inode_ref = enode->inode_ref;
+	
+	rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
+	ext4fs_node_put(fn);
+	
+	return rc;
+}
+
+/** Close file.
+ *
+ * @param service_id Device identifier
+ * @param index      I-node number
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_close(service_id_t service_id, fs_index_t index)
+{
+	return EOK;
+}
+
+/** Destroy node specified by index.
+ *
+ * @param service_id Device identifier
+ * @param index      I-node to destroy
+ *
+ * @return Error code
+ *
+ */
+static int ext4fs_destroy(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;
+	
+	/* Destroy the inode */
+	return ext4fs_destroy_node(fn);
+}
+
+/** Enforce inode synchronization (write) to device.
+ *
+ * @param service_id Device identifier
+ * @param index      I-node number.
+ *
+ */
+static int ext4fs_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);
+	enode->inode_ref->dirty = true;
+	
+	return ext4fs_node_put(fn);
+}
+
+/** VFS operations
+ *
+ */
+vfs_out_ops_t ext4fs_ops = {
+	.mounted = ext4fs_mounted,
+	.unmounted = ext4fs_unmounted,
+	.read = ext4fs_read,
+	.write = ext4fs_write,
+	.truncate = ext4fs_truncate,
+	.close = ext4fs_close,
+	.destroy = ext4fs_destroy,
+	.sync = ext4fs_sync
+};
+
+/**
+ * @}
+ */
Index: uspace/srv/fs/tmpfs/tmpfs_dump.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_dump.c	(revision f66ca57f67fa0ea52c699112f4682f74c09f6bb9)
+++ uspace/srv/fs/tmpfs/tmpfs_dump.c	(revision affaf2e32d63acee2b44deef78a9bc2876c0cde3)
@@ -49,4 +49,6 @@
 #define TMPFS_COMM_SIZE		1024
 
+static uint8_t tmpfs_buf[TMPFS_COMM_SIZE];
+
 struct rdentry {
 	uint8_t type;
@@ -68,5 +70,5 @@
 		uint32_t size;
 		
-		if (block_seqread(dsid, bufpos, buflen, pos, &entry,
+		if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, &entry,
 		    sizeof(entry)) != EOK)
 			return false;
@@ -88,5 +90,5 @@
 			}
 			
-			if (block_seqread(dsid, bufpos, buflen, pos, fname,
+			if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, fname,
 			    entry.len) != EOK) {
 				(void) ops->destroy(fn);
@@ -104,5 +106,5 @@
 			free(fname);
 			
-			if (block_seqread(dsid, bufpos, buflen, pos, &size,
+			if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, &size,
 			    sizeof(size)) != EOK)
 				return false;
@@ -116,5 +118,5 @@
 			
 			nodep->size = size;
-			if (block_seqread(dsid, bufpos, buflen, pos, nodep->data,
+			if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, nodep->data,
 			    size) != EOK)
 				return false;
@@ -132,5 +134,5 @@
 			}
 			
-			if (block_seqread(dsid, bufpos, buflen, pos, fname,
+			if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, fname,
 			    entry.len) != EOK) {
 				(void) ops->destroy(fn);
@@ -176,5 +178,5 @@
 	
 	char tag[6];
-	if (block_seqread(dsid, &bufpos, &buflen, &pos, tag, 5) != EOK)
+	if (block_seqread(dsid, tmpfs_buf, &bufpos, &buflen, &pos, tag, 5) != EOK)
 		goto error;
 	
