Index: uspace/lib/ext4/Makefile
===================================================================
--- uspace/lib/ext4/Makefile	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ uspace/lib/ext4/Makefile	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -29,18 +29,18 @@
 USPACE_PREFIX = ../..
 LIBRARY = libext4
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCRYPTO_PREFIX)
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCRYPTO_PREFIX) -Iinclude
 
 SOURCES = \
-	libext4_balloc.c \
-	libext4_bitmap.c \
-	libext4_block_group.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
+	src/balloc.c \
+	src/bitmap.c \
+	src/block_group.c \
+	src/directory.c \
+	src/directory_index.c \
+	src/extent.c \
+	src/filesystem.c \
+	src/hash.c \
+	src/ialloc.c \
+	src/inode.c \
+	src/superblock.c
 
 include $(USPACE_PREFIX)/Makefile.common
Index: uspace/lib/ext4/include/ext4/balloc.h
===================================================================
--- uspace/lib/ext4/include/ext4/balloc.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/balloc.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 "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/include/ext4/bitmap.h
===================================================================
--- uspace/lib/ext4/include/ext4/bitmap.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/bitmap.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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/include/ext4/block_group.h
===================================================================
--- uspace/lib/ext4/include/ext4/block_group.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/block_group.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include <sys/types.h>
+#include "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/include/ext4/directory.h
===================================================================
--- uspace/lib/ext4/include/ext4/directory.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/directory.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 "ext4/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/include/ext4/directory_index.h
===================================================================
--- uspace/lib/ext4/include/ext4/directory_index.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/directory_index.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 "ext4/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/include/ext4/extent.h
===================================================================
--- uspace/lib/ext4/include/ext4/extent.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/extent.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 "ext4/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/include/ext4/filesystem.h
===================================================================
--- uspace/lib/ext4/include/ext4/filesystem.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/filesystem.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include "ext4/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_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 uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_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 *);
+uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg);
+uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
+    ext4_block_group_ref_t *bg_ref);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/include/ext4/hash.h
===================================================================
--- uspace/lib/ext4/include/ext4/hash.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/hash.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 "ext4/types.h"
+
+extern int ext4_hash_string(ext4_hash_info_t *, int, const char *);
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/include/ext4/ialloc.h
===================================================================
--- uspace/lib/ext4/include/ext4/ialloc.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/ialloc.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 "ext4/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/include/ext4/inode.h
===================================================================
--- uspace/lib/ext4/include/ext4/inode.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/inode.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include <sys/types.h>
+#include "ext4/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/include/ext4/libext4.h
===================================================================
--- uspace/lib/ext4/include/ext4/libext4.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/libext4.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,58 @@
+/*
+ * 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 "ext4/balloc.h"
+#include "ext4/bitmap.h"
+#include "ext4/block_group.h"
+#include "ext4/directory.h"
+#include "ext4/directory_index.h"
+#include "ext4/extent.h"
+#include "ext4/filesystem.h"
+#include "ext4/hash.h"
+#include "ext4/ialloc.h"
+#include "ext4/inode.h"
+#include "ext4/superblock.h"
+#include "ext4/types.h"
+
+#include <stdio.h>
+#define EXT4FS_DBG(format, ...) \
+	printf("ext4fs: %s: " format "\n", \
+	    __FUNCTION__, ##__VA_ARGS__) \
+
+#endif
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/include/ext4/superblock.h
===================================================================
--- uspace/lib/ext4/include/ext4/superblock.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/superblock.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include <sys/types.h>
+#include "ext4/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);
+
+extern void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
+    uint32_t *g1, uint32_t *g2);
+extern void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
+    uint32_t g1, uint32_t g2);
+
+extern uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb);
+extern void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
+    uint32_t n);
+
+/* 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 void ext4_superblock_release(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/include/ext4/types.h
===================================================================
--- uspace/lib/ext4/include/ext4/types.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/include/ext4/types.h	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,554 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.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 prealloc_blocks;        /* Number of blocks to try to preallocate */
+	uint8_t prealloc_dir_blocks;    /* Number to preallocate for dirs */
+	uint16_t 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];             /* String containing the mount options */
+	uint32_t usr_quota_inum;            /* Inode number of user quota file */
+	uint32_t grp_quota_inum;            /* Inode number of group quota file */
+	uint32_t overhead_blocks;           /* Overhead blocks/clusters */
+	uint32_t backup_bgs[2];             /* Block groups containing superblock backups (if SPARSE_SUPER2) */
+	uint32_t encrypt_algos;             /* Encrypt algorithm in use */
+	uint32_t padding[105];              /* 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
+#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2  0x0200
+
+/*
+ * 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 | \
+	EXT4_FEATURE_INCOMPAT_FLEX_BG)
+
+#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/lib/ext4/libext4.h
===================================================================
--- uspace/lib/ext4/libext4.h	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,58 +1,0 @@
-/*
- * 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_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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,699 +1,0 @@
-/*
- * 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"
-
-/** 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_filesystem_blockaddr2group(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) {
-		ext4_filesystem_put_block_group_ref(bg_ref);
-		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 */
-	return ext4_filesystem_put_block_group_ref(bg_ref);
-}
-
-static int ext4_balloc_free_blocks_internal(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_filesystem_blockaddr2group(sb,
-	    first);
-	uint32_t block_group_last = ext4_filesystem_blockaddr2group(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) {
-		ext4_filesystem_put_block_group_ref(bg_ref);
-		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 */
-	return ext4_filesystem_put_block_group_ref(bg_ref);
-}
-
-/** 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)
-{
-	int r;
-	uint32_t gid;
-	uint64_t limit;
-	ext4_filesystem_t *fs = inode_ref->fs;
-	ext4_superblock_t *sb = fs->superblock;
-
-	while (count) {
-		gid = ext4_filesystem_blockaddr2group(sb, first);
-		limit = ext4_filesystem_index_in_group2blockaddr(sb, 0,
-		    gid + 1);
-
-		if ((first + count) >= limit) {
-			/* This extent spans over 2 or more block groups,
-			 * we'll break it into smaller parts.
-			 */
-			uint32_t s = limit - first;
-
-			r = ext4_balloc_free_blocks_internal(inode_ref,
-			    first, s);
-			if (r != EOK)
-				return r;
-
-			first = limit;
-			count -= s;
-		} else {
-			return ext4_balloc_free_blocks_internal(inode_ref,
-			    first, count);
-		}
-	}
-
-	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 r;
-	uint64_t itable = ext4_block_group_get_inode_table_first_block(
-	    bg_ref->block_group, sb);
-	uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
-
-	if (!ext4_superblock_has_feature_incompatible(sb,
-	    EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
-		/* If we are not using FLEX_BG, the first data block
-		 * is always after the inode table.
-		 */
-		r = itable + itable_sz;
-		return ext4_filesystem_blockaddr2_index_in_group(sb, r);
-	}
-
-	uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group,
-	    sb);
-	uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group,
-	    sb);
-
-	r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index);
-	r += ext4_filesystem_bg_get_backup_blocks(bg_ref);
-
-	if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index)
-		bbmap = -1; /* Invalid */
-
-	if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index)
-		ibmap = -1;
-
-	while (1) {
-		if (r == bbmap || r == ibmap)
-			r++;
-		else if (r >= itable && r < (itable + itable_sz))
-			r = itable + itable_sz;
-		else
-			break;
-	}
-
-	return r;
-}
-
-/** Compute 'goal' for allocation algorithm.
- *
- * @param inode_ref Reference to inode, to allocate block for
- *
- * @return Goal block number
- *
- */
-static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal)
-{
-	*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 rc;
-
-		if (goal != 0) {
-			(*goal)++;
-			return EOK;
-		}
-		/* 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;
-
-	/* 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;
-
-	*goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
-
-	return ext4_filesystem_put_block_group_ref(bg_ref);
-}
-
-/** 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;
-	uint32_t free_blocks;
-	uint32_t goal;
-	
-	/* Find GOAL */
-	int rc = ext4_balloc_find_goal(inode_ref, &goal);
-	if (rc != EOK)
-		return rc;
-
-	ext4_superblock_t *sb = inode_ref->fs->superblock;
-	
-	/* Load block group number for goal and relative index */
-	uint32_t block_group = ext4_filesystem_blockaddr2group(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;
-	rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
-	    block_group, &bg_ref);
-	if (rc != EOK)
-		return rc;
-
-	free_blocks =
-	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
-	if (free_blocks == 0) {
-		/* This group has no free blocks */
-		goto goal_failed;
-	}
-	
-	/* 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 */
-	rc = block_put(bitmap_block);
-	if (rc != EOK) {
-		ext4_filesystem_put_block_group_ref(bg_ref);
-		return rc;
-	}
-
-goal_failed:
-
-	rc = ext4_filesystem_put_block_group_ref(bg_ref);
-	if (rc != EOK)
-		return rc;
-	
-	/* 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;
-
-		free_blocks =
-		     ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
-		if (free_blocks == 0) {
-			/* This group has no free blocks */
-			goto next_group;
-		}
-
-		/* 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) {
-				ext4_filesystem_put_block_group_ref(bg_ref);
-				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) {
-				ext4_filesystem_put_block_group_ref(bg_ref);
-				return rc;
-			}
-			
-			allocated_block =
-			    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
-			    bgid);
-			
-			goto success;
-		}
-		
-		rc = block_put(bitmap_block);
-		if (rc != EOK) {
-			ext4_filesystem_put_block_group_ref(bg_ref);
-			return rc;
-		}
-
-next_group:
-		rc = ext4_filesystem_put_block_group_ref(bg_ref);
-		if (rc != EOK)
-			return rc;
-		
-		/* 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;
-	
-	rc = ext4_filesystem_put_block_group_ref(bg_ref);
-	
-	*fblock = allocated_block;
-	return rc;
-}
-
-/** 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;
-	
-	ext4_filesystem_t *fs = inode_ref->fs;
-	ext4_superblock_t *sb = fs->superblock;
-	
-	/* Compute indexes */
-	uint32_t block_group = ext4_filesystem_blockaddr2group(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) {
-		ext4_filesystem_put_block_group_ref(bg_ref);
-		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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,50 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,269 +1,0 @@
-/*
- * 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 <block.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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,51 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,386 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,84 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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_directory.c
===================================================================
--- uspace/lib/ext4/libext4_directory.c	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,762 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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)
-			return rc;
-
-		/* 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 (memcmp((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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,81 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,1167 +1,0 @@
-/*
- * 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) */
-		rc = block_put(p->block);
-		if (rc != EOK)
-			return rc;
-		
-		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 rc2;
-	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 */
-		rc2 = block_put(leaf_block);
-		if (rc2 != EOK)
-			goto cleanup;
-		
-		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 != EOK)
-			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) {
-		rc2 = block_put(tmp->block);
-		if (rc == EOK && rc2 != EOK)
-			rc = rc2;
-		++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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,77 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,1112 +1,0 @@
-/*
- * 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)
-{
-	int rc;
-	/* 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) {
-			rc = block_put(block);
-			if (rc != EOK)
-				return rc;
-		}
-		
-		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)
-		rc = block_put(block);
-	
-	return rc;
-}
-
-/** 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:
-	;
-
-	int rc2 = EOK;
-
-	/*
-	 * 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) {
-			rc2 = block_put(tmp_path[i].block);
-			if (rc == EOK && rc2 != EOK)
-				rc = rc2;
-		}
-	}
-	
-	/* 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;
-	
-	return ext4_balloc_free_block(inode_ref, fblock);
-}
-
-/** 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:
-	;
-
-	int rc2 = EOK;
-
-	/*
-	 * 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) {
-			rc2 = block_put(path[i].block);
-			if (rc == EOK && rc2 != EOK)
-				rc = rc2;
-		}
-	}
-	
-	/* 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 */
-			rc = block_put(path_ptr->block);
-			if (rc != EOK) {
-				ext4_balloc_free_block(inode_ref, fblock);
-				block_put(block);
-				return rc;
-			}
-			
-			/* 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:
-	;
-
-	int rc2 = EOK;
-
-	/* 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) {
-			rc2 = block_put(path[i].block);
-			if (rc == EOK && rc2 != EOK)
-				rc = rc2;
-		}
-	}
-	
-	/* Destroy temporary data structure */
-	free(path);
-	
-	return rc;
-}
-
-/**
- * @}
- */
Index: uspace/lib/ext4/libext4_extent.h
===================================================================
--- uspace/lib/ext4/libext4_extent.h	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,73 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,1559 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <ipc/vfs.h>
-#include <align.h>
-#include <crypto.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)
-{
-	int rc;
-	ext4_superblock_t *temp_superblock = NULL;
-
-	fs->device = service_id;
-
-	/* Initialize block library (4096 is size of communication channel) */
-	rc = block_init(fs->device, 4096);
-	if (rc != EOK)
-		goto err;
-
-	/* Read superblock from device to memory */
-	rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
-	if (rc != EOK)
-		goto err_1;
-
-	/* 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) {
-		rc = ENOTSUP;
-		goto err_1;
-	}
-
-	/* Initialize block caching by libblock */
-	rc = block_cache_init(service_id, block_size, 0, cmode);
-	if (rc != EOK)
-		goto err_1;
-
-	/* 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)) {
-		rc = ENOTSUP;
-		goto err_2;
-	}
-	
-	rc = ext4_superblock_check_sanity(fs->superblock);
-	if (rc != EOK)
-		goto err_2;
-
-	/* 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)
-		goto err_2;
-
-	uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
-	ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
-
-	return EOK;
-
-err_2:
-	block_cache_fini(fs->device);
-err_1:
-	block_fini(fs->device);
-err:
-	if (temp_superblock)
-		ext4_superblock_release(temp_superblock);
-	return rc;
-}
-
-/** 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 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;
-}
-
-/** Convert the absolute block number to group number
- *
- * @param sb    Pointer to the superblock
- * @param b     Absolute block number
- *
- * @return      Group number
- */
-uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b)
-{
-	uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
-	uint32_t first_block = ext4_superblock_get_first_data_block(sb);
-
-	return (b - first_block) / blocks_per_group;
-}
-
-/** 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)
-{
-	uint64_t itb;
-	uint32_t sz;
-	uint32_t i;
-
-	/* Load bitmap */
-	ext4_superblock_t *sb = bg_ref->fs->superblock;
-	uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
-	    bg_ref->block_group, bg_ref->fs->superblock);
-	uint64_t bitmap_inode_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(sb);
-	memset(bitmap, 0, block_size);
-	
-	/* Determine the number of reserved blocks in the group */
-	uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref);
-
-	/* Set bits from to first block to first data block - 1 to one (allocated) */
-	for (uint32_t block = 0; block < reserved_cnt; ++block)
-		ext4_bitmap_set_bit(bitmap, block);
-
-	uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb,
-	    bitmap_block_addr);
-	if (bitmap_block_gid == bg_ref->index) {
-		ext4_bitmap_set_bit(bitmap,
-		    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr));
-	}
-
-	uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb,
-	    bitmap_inode_addr);
-	if (bitmap_inode_gid == bg_ref->index) {
-		ext4_bitmap_set_bit(bitmap,
-		    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr));
-	}
-
-	itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group,
-	    sb);
-	sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
-
-	for (i = 0; i < sz; ++i, ++itb) {
-		uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb);
-		if (gid == bg_ref->index) {
-			ext4_bitmap_set_bit(bitmap,
-			    ext4_filesystem_blockaddr2_index_in_group(sb, itb));
-		}
-	}
-
-	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;
-	}
-	
-	/* Initialize 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.
- *
- * @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_ibm(~0, sb->uuid, sizeof(sb->uuid));
-		
-		/* Include index of block group */
-		crc = crc16_ibm(crc, (uint8_t *) &le_group, sizeof(le_group));
-		
-		/* Compute crc from the first part (stop before checksum field) */
-		crc = crc16_ibm(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_ibm(crc, ((uint8_t *) bg) + offset,
-			    ext4_superblock_get_desc_size(sb) - offset);
-	}
-	
-	return crc;
-}
-
-/** Get the size of the block group's inode table
- *
- * @param sb     Pointer to the superblock
- * @param bg_ref Pointer to the block group reference
- *
- * @return       Size of the inode table in blocks.
- */
-uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
-    ext4_block_group_ref_t *bg_ref)
-{
-	uint32_t itable_size;
-	uint32_t block_group_count = ext4_superblock_get_block_group_count(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);
-
-	if (bg_ref->index < block_group_count - 1) {
-		itable_size = 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);
-		itable_size =
-		    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
-		    inode_table_item_size;
-	}
-
-	return ROUND_UP(itable_size, block_size) / block_size;
-}
-
-/* Check if n is a power of p */
-static bool is_power_of(uint32_t n, unsigned p)
-{
-	if (p == 1 && n != p)
-		return false;
-
-	while (n != p) {
-		if (n < p)
-			return false;
-		else if ((n % p) != 0)
-			return false;
-
-		n /= p;
-	}
-
-	return true;
-}
-
-/** Get the number of blocks used by superblock + gdt + reserved gdt backups
- *
- * @param bg    Pointer to block group
- *
- * @return      Number of blocks
- */
-uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg)
-{
-	uint32_t const idx = bg->index;
-	uint32_t r = 0;
-	bool has_backups = false;
-	ext4_superblock_t *sb = bg->fs->superblock;
-
-	/* First step: determine if the block group contains the backups */
-
-	if (idx <= 1)
-		has_backups = true;
-	else {
-		if (ext4_superblock_has_feature_compatible(sb,
-		    EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {
-			uint32_t g1, g2;
-
-			ext4_superblock_get_backup_groups_sparse2(sb,
-			    &g1, &g2);
-
-			if (idx == g1 || idx == g2)
-				has_backups = true;
-		} else if (!ext4_superblock_has_feature_read_only(sb,
-		    EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
-			/* Very old fs were all block groups have
-			 * superblock and block descriptors backups.
-			 */
-			has_backups = true;
-		} else {
-			if ((idx & 1) && (is_power_of(idx, 3) ||
-			    is_power_of(idx, 5) || is_power_of(idx, 7)))
-				has_backups = true;
-		}
-	}
-
-	if (has_backups) {
-		uint32_t bg_count;
-		uint32_t bg_desc_sz;
-		uint32_t gdt_table; /* Size of the GDT in blocks */
-		uint32_t block_size = ext4_superblock_get_block_size(sb);
-
-		/* Now we know that this block group has backups,
-		 * we have to compute how many blocks are reserved
-		 * for them
-		 */
-
-		if (idx == 0 && block_size == 1024) {
-			/* Special case for first group were the boot block
-			 * resides
-			 */
-			r++;
-		}
-
-		/* This accounts for the superblock */
-		r++;
-
-		/* Add the number of blocks used for the GDT */
-		bg_count = ext4_superblock_get_block_group_count(sb);
-		bg_desc_sz = ext4_superblock_get_desc_size(sb);
-		gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) /
-		    block_size;
-
-		r += gdt_table;
-
-		/* And now the number of reserved GDT blocks */
-		r += ext4_superblock_get_reserved_gdt_blocks(sb);
-	}
-
-	return r;
-}
-
-/** Put reference to block group.
- *
- * @param 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;
-				}
-			}
-		}
-		
-		rc = block_put(block);
-		if (rc != EOK)
-			return rc;
-
-		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;
-						}
-					}
-				}
-				
-				rc = block_put(subblock);
-				if (rc != EOK) {
-					block_put(block);
-					return rc;
-				}
-			}
-			
-			rc = ext4_balloc_free_block(inode_ref, ind_block);
-			if (rc != EOK) {
-				block_put(block);
-				return rc;
-			}
-		}
-		
-		rc = block_put(block);
-		if (rc != EOK)
-			return rc;
-
-		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) {
-		
-		/* Sparse check */
-		if (current_block == 0)
-			return EOK;
-		
-		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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,74 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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_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 uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_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 *);
-uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg);
-uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
-    ext4_block_group_ref_t *bg_ref);
-
-#endif
-
-/**
- * @}
- */
Index: uspace/lib/ext4/libext4_hash.c
===================================================================
--- uspace/lib/ext4/libext4_hash.c	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,49 +1,0 @@
-/*
- * 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 "libext4.h"
-#include <errno.h>
-
-int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
-{
-	// TODO
-	hinfo->hash = 0;
-	return ENOTSUP;
-}
-
-/**
- * @}
- */
Index: uspace/lib/ext4/libext4_hash.h
===================================================================
--- uspace/lib/ext4/libext4_hash.h	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,45 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,311 +1,0 @@
-/*
- * 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 a good candidate
-		 * for allocation.
-		 *
-		 * The criterion is based on the average number
-		 * of free inodes, unless we examine the last block
-		 * group. In that case the last block group might
-		 * have less than the average number of free inodes,
-		 * but it still needs to be taken as a candidate
-		 * because the previous block groups have zero free
-		 * blocks.
-		 */
-		if (((free_inodes >= avg_free_inodes) || (bgid == bg_count - 1)) &&
-		    (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) {
-				ext4_filesystem_put_block_group_ref(bg_ref);
-				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) {
-				rc = block_put(bitmap_block);
-				if (rc != EOK) {
-					ext4_filesystem_put_block_group_ref(bg_ref);
-					return rc;
-				}
-
-				rc = ext4_filesystem_put_block_group_ref(bg_ref);
-				if (rc != EOK)
-					return rc;
-
-				bgid++;
-				continue;
-			}
-			
-			/* Free i-node found, save the bitmap */
-			bitmap_block->dirty = true;
-			
-			rc = block_put(bitmap_block);
-			if (rc != EOK) {
-				ext4_filesystem_put_block_group_ref(bg_ref);
-				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 */
-		rc = ext4_filesystem_put_block_group_ref(bg_ref);
-		if (rc != EOK)
-			return rc;
-
-		++bgid;
-	}
-	
-	return ENOSPC;
-}
-
-/**
- * @}
- */
Index: uspace/lib/ext4/libext4_ialloc.h
===================================================================
--- uspace/lib/ext4/libext4_ialloc.h	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,45 +1,0 @@
-/*
- * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,594 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,86 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,1350 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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);
-}
-
-/** Release the memory allocated for the superblock structure
- *
- * @param sb         Superblock to be freed
- *
- */
-void ext4_superblock_release(ext4_superblock_t *sb)
-{
-	free(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));
-}
-
-/** Get the backup groups used with SPARSE_SUPER2
- *
- * @param sb    Pointer to the superblock
- * @param g1    Output pointer to the first backup group
- * @param g2    Output pointer to the second backup group
- */
-void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
-    uint32_t *g1, uint32_t *g2)
-{
-	*g1 = uint32_t_le2host(sb->backup_bgs[0]);
-	*g2 = uint32_t_le2host(sb->backup_bgs[1]);
-}
-
-/** Set the backup groups (SPARSE SUPER2)
- *
- * @param sb    Pointer to the superblock
- * @param g1    Index of the first group
- * @param g2    Index of the second group
- */
-void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
-    uint32_t g1, uint32_t g2)
-{
-	sb->backup_bgs[0] = host2uint32_t_le(g1);
-	sb->backup_bgs[1] = host2uint32_t_le(g2);
-}
-
-/** Get the number of blocks (per group) reserved to GDT expansion
- *
- * @param sb    Pointer to the superblock
- *
- * @return      Number of blocks
- */
-uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb)
-{
-	return uint32_t_le2host(sb->reserved_gdt_blocks);
-}
-
-/** Set the number of blocks (per group) reserved to GDT expansion
- *
- * @param sb    Pointer to the superblock
- * @param n     Number of reserved blocks
- */
-void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
-    uint32_t n)
-{
-	sb->reserved_gdt_blocks = host2uint32_t_le(n);
-}
-
-/**
- * @}
- */
Index: uspace/lib/ext4/libext4_superblock.h
===================================================================
--- uspace/lib/ext4/libext4_superblock.h	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,169 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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);
-
-extern void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
-    uint32_t *g1, uint32_t *g2);
-extern void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
-    uint32_t g1, uint32_t g2);
-
-extern uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb);
-extern void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
-    uint32_t n);
-
-/* 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 void ext4_superblock_release(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 f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ 	(revision )
@@ -1,554 +1,0 @@
-/*
- * Copyright (c) 2011 Martin Sucha
- * 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 <block.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 prealloc_blocks;        /* Number of blocks to try to preallocate */
-	uint8_t prealloc_dir_blocks;    /* Number to preallocate for dirs */
-	uint16_t 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];             /* String containing the mount options */
-	uint32_t usr_quota_inum;            /* Inode number of user quota file */
-	uint32_t grp_quota_inum;            /* Inode number of group quota file */
-	uint32_t overhead_blocks;           /* Overhead blocks/clusters */
-	uint32_t backup_bgs[2];             /* Block groups containing superblock backups (if SPARSE_SUPER2) */
-	uint32_t encrypt_algos;             /* Encrypt algorithm in use */
-	uint32_t padding[105];              /* 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
-#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2  0x0200
-
-/*
- * 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 | \
-	EXT4_FEATURE_INCOMPAT_FLEX_BG)
-
-#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/lib/ext4/src/balloc.c
===================================================================
--- uspace/lib/ext4/src/balloc.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/balloc.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,699 @@
+/*
+ * 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 "ext4/libext4.h"
+
+/** 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_filesystem_blockaddr2group(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) {
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		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 */
+	return ext4_filesystem_put_block_group_ref(bg_ref);
+}
+
+static int ext4_balloc_free_blocks_internal(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_filesystem_blockaddr2group(sb,
+	    first);
+	uint32_t block_group_last = ext4_filesystem_blockaddr2group(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) {
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		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 */
+	return ext4_filesystem_put_block_group_ref(bg_ref);
+}
+
+/** 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)
+{
+	int r;
+	uint32_t gid;
+	uint64_t limit;
+	ext4_filesystem_t *fs = inode_ref->fs;
+	ext4_superblock_t *sb = fs->superblock;
+
+	while (count) {
+		gid = ext4_filesystem_blockaddr2group(sb, first);
+		limit = ext4_filesystem_index_in_group2blockaddr(sb, 0,
+		    gid + 1);
+
+		if ((first + count) >= limit) {
+			/* This extent spans over 2 or more block groups,
+			 * we'll break it into smaller parts.
+			 */
+			uint32_t s = limit - first;
+
+			r = ext4_balloc_free_blocks_internal(inode_ref,
+			    first, s);
+			if (r != EOK)
+				return r;
+
+			first = limit;
+			count -= s;
+		} else {
+			return ext4_balloc_free_blocks_internal(inode_ref,
+			    first, count);
+		}
+	}
+
+	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 r;
+	uint64_t itable = ext4_block_group_get_inode_table_first_block(
+	    bg_ref->block_group, sb);
+	uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
+
+	if (!ext4_superblock_has_feature_incompatible(sb,
+	    EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
+		/* If we are not using FLEX_BG, the first data block
+		 * is always after the inode table.
+		 */
+		r = itable + itable_sz;
+		return ext4_filesystem_blockaddr2_index_in_group(sb, r);
+	}
+
+	uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group,
+	    sb);
+	uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group,
+	    sb);
+
+	r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index);
+	r += ext4_filesystem_bg_get_backup_blocks(bg_ref);
+
+	if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index)
+		bbmap = -1; /* Invalid */
+
+	if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index)
+		ibmap = -1;
+
+	while (1) {
+		if (r == bbmap || r == ibmap)
+			r++;
+		else if (r >= itable && r < (itable + itable_sz))
+			r = itable + itable_sz;
+		else
+			break;
+	}
+
+	return r;
+}
+
+/** Compute 'goal' for allocation algorithm.
+ *
+ * @param inode_ref Reference to inode, to allocate block for
+ *
+ * @return Goal block number
+ *
+ */
+static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal)
+{
+	*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 rc;
+
+		if (goal != 0) {
+			(*goal)++;
+			return EOK;
+		}
+		/* 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;
+
+	/* 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;
+
+	*goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
+
+	return ext4_filesystem_put_block_group_ref(bg_ref);
+}
+
+/** 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;
+	uint32_t free_blocks;
+	uint32_t goal;
+	
+	/* Find GOAL */
+	int rc = ext4_balloc_find_goal(inode_ref, &goal);
+	if (rc != EOK)
+		return rc;
+
+	ext4_superblock_t *sb = inode_ref->fs->superblock;
+	
+	/* Load block group number for goal and relative index */
+	uint32_t block_group = ext4_filesystem_blockaddr2group(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;
+	rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
+	    block_group, &bg_ref);
+	if (rc != EOK)
+		return rc;
+
+	free_blocks =
+	    ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+	if (free_blocks == 0) {
+		/* This group has no free blocks */
+		goto goal_failed;
+	}
+	
+	/* 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 */
+	rc = block_put(bitmap_block);
+	if (rc != EOK) {
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		return rc;
+	}
+
+goal_failed:
+
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	if (rc != EOK)
+		return rc;
+	
+	/* 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;
+
+		free_blocks =
+		     ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb);
+		if (free_blocks == 0) {
+			/* This group has no free blocks */
+			goto next_group;
+		}
+
+		/* 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) {
+				ext4_filesystem_put_block_group_ref(bg_ref);
+				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) {
+				ext4_filesystem_put_block_group_ref(bg_ref);
+				return rc;
+			}
+			
+			allocated_block =
+			    ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
+			    bgid);
+			
+			goto success;
+		}
+		
+		rc = block_put(bitmap_block);
+		if (rc != EOK) {
+			ext4_filesystem_put_block_group_ref(bg_ref);
+			return rc;
+		}
+
+next_group:
+		rc = ext4_filesystem_put_block_group_ref(bg_ref);
+		if (rc != EOK)
+			return rc;
+		
+		/* 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;
+	
+	rc = ext4_filesystem_put_block_group_ref(bg_ref);
+	
+	*fblock = allocated_block;
+	return rc;
+}
+
+/** 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;
+	
+	ext4_filesystem_t *fs = inode_ref->fs;
+	ext4_superblock_t *sb = fs->superblock;
+	
+	/* Compute indexes */
+	uint32_t block_group = ext4_filesystem_blockaddr2group(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) {
+		ext4_filesystem_put_block_group_ref(bg_ref);
+		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/src/bitmap.c
===================================================================
--- uspace/lib/ext4/src/bitmap.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/bitmap.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 <block.h>
+#include <sys/types.h>
+#include "ext4/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/src/block_group.c
===================================================================
--- uspace/lib/ext4/src/block_group.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/block_group.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 "ext4/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/src/directory.c
===================================================================
--- uspace/lib/ext4/src/directory.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/directory.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,762 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 "ext4/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)
+			return rc;
+
+		/* 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 (memcmp((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/src/directory_index.c
===================================================================
--- uspace/lib/ext4/src/directory_index.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/directory_index.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,1167 @@
+/*
+ * 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 "ext4/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) */
+		rc = block_put(p->block);
+		if (rc != EOK)
+			return rc;
+		
+		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 rc2;
+	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 */
+		rc2 = block_put(leaf_block);
+		if (rc2 != EOK)
+			goto cleanup;
+		
+		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 != EOK)
+			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) {
+		rc2 = block_put(tmp->block);
+		if (rc == EOK && rc2 != EOK)
+			rc = rc2;
+		++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/src/extent.c
===================================================================
--- uspace/lib/ext4/src/extent.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/extent.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,1112 @@
+/*
+ * 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 "ext4/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)
+{
+	int rc;
+	/* 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) {
+			rc = block_put(block);
+			if (rc != EOK)
+				return rc;
+		}
+		
+		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)
+		rc = block_put(block);
+	
+	return rc;
+}
+
+/** 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:
+	;
+
+	int rc2 = EOK;
+
+	/*
+	 * 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) {
+			rc2 = block_put(tmp_path[i].block);
+			if (rc == EOK && rc2 != EOK)
+				rc = rc2;
+		}
+	}
+	
+	/* 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;
+	
+	return ext4_balloc_free_block(inode_ref, fblock);
+}
+
+/** 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:
+	;
+
+	int rc2 = EOK;
+
+	/*
+	 * 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) {
+			rc2 = block_put(path[i].block);
+			if (rc == EOK && rc2 != EOK)
+				rc = rc2;
+		}
+	}
+	
+	/* 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 */
+			rc = block_put(path_ptr->block);
+			if (rc != EOK) {
+				ext4_balloc_free_block(inode_ref, fblock);
+				block_put(block);
+				return rc;
+			}
+			
+			/* 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:
+	;
+
+	int rc2 = EOK;
+
+	/* 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) {
+			rc2 = block_put(path[i].block);
+			if (rc == EOK && rc2 != EOK)
+				rc = rc2;
+		}
+	}
+	
+	/* Destroy temporary data structure */
+	free(path);
+	
+	return rc;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/src/filesystem.c
===================================================================
--- uspace/lib/ext4/src/filesystem.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/filesystem.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,1559 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <ipc/vfs.h>
+#include <align.h>
+#include <crypto.h>
+#include "ext4/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)
+{
+	int rc;
+	ext4_superblock_t *temp_superblock = NULL;
+
+	fs->device = service_id;
+
+	/* Initialize block library (4096 is size of communication channel) */
+	rc = block_init(fs->device, 4096);
+	if (rc != EOK)
+		goto err;
+
+	/* Read superblock from device to memory */
+	rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
+	if (rc != EOK)
+		goto err_1;
+
+	/* 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) {
+		rc = ENOTSUP;
+		goto err_1;
+	}
+
+	/* Initialize block caching by libblock */
+	rc = block_cache_init(service_id, block_size, 0, cmode);
+	if (rc != EOK)
+		goto err_1;
+
+	/* 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)) {
+		rc = ENOTSUP;
+		goto err_2;
+	}
+	
+	rc = ext4_superblock_check_sanity(fs->superblock);
+	if (rc != EOK)
+		goto err_2;
+
+	/* 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)
+		goto err_2;
+
+	uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
+	ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
+
+	return EOK;
+
+err_2:
+	block_cache_fini(fs->device);
+err_1:
+	block_fini(fs->device);
+err:
+	if (temp_superblock)
+		ext4_superblock_release(temp_superblock);
+	return rc;
+}
+
+/** 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 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;
+}
+
+/** Convert the absolute block number to group number
+ *
+ * @param sb    Pointer to the superblock
+ * @param b     Absolute block number
+ *
+ * @return      Group number
+ */
+uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b)
+{
+	uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
+	uint32_t first_block = ext4_superblock_get_first_data_block(sb);
+
+	return (b - first_block) / blocks_per_group;
+}
+
+/** 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)
+{
+	uint64_t itb;
+	uint32_t sz;
+	uint32_t i;
+
+	/* Load bitmap */
+	ext4_superblock_t *sb = bg_ref->fs->superblock;
+	uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
+	    bg_ref->block_group, bg_ref->fs->superblock);
+	uint64_t bitmap_inode_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(sb);
+	memset(bitmap, 0, block_size);
+	
+	/* Determine the number of reserved blocks in the group */
+	uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref);
+
+	/* Set bits from to first block to first data block - 1 to one (allocated) */
+	for (uint32_t block = 0; block < reserved_cnt; ++block)
+		ext4_bitmap_set_bit(bitmap, block);
+
+	uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb,
+	    bitmap_block_addr);
+	if (bitmap_block_gid == bg_ref->index) {
+		ext4_bitmap_set_bit(bitmap,
+		    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr));
+	}
+
+	uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb,
+	    bitmap_inode_addr);
+	if (bitmap_inode_gid == bg_ref->index) {
+		ext4_bitmap_set_bit(bitmap,
+		    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr));
+	}
+
+	itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group,
+	    sb);
+	sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
+
+	for (i = 0; i < sz; ++i, ++itb) {
+		uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb);
+		if (gid == bg_ref->index) {
+			ext4_bitmap_set_bit(bitmap,
+			    ext4_filesystem_blockaddr2_index_in_group(sb, itb));
+		}
+	}
+
+	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;
+	}
+	
+	/* Initialize 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.
+ *
+ * @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_ibm(~0, sb->uuid, sizeof(sb->uuid));
+		
+		/* Include index of block group */
+		crc = crc16_ibm(crc, (uint8_t *) &le_group, sizeof(le_group));
+		
+		/* Compute crc from the first part (stop before checksum field) */
+		crc = crc16_ibm(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_ibm(crc, ((uint8_t *) bg) + offset,
+			    ext4_superblock_get_desc_size(sb) - offset);
+	}
+	
+	return crc;
+}
+
+/** Get the size of the block group's inode table
+ *
+ * @param sb     Pointer to the superblock
+ * @param bg_ref Pointer to the block group reference
+ *
+ * @return       Size of the inode table in blocks.
+ */
+uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
+    ext4_block_group_ref_t *bg_ref)
+{
+	uint32_t itable_size;
+	uint32_t block_group_count = ext4_superblock_get_block_group_count(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);
+
+	if (bg_ref->index < block_group_count - 1) {
+		itable_size = 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);
+		itable_size =
+		    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
+		    inode_table_item_size;
+	}
+
+	return ROUND_UP(itable_size, block_size) / block_size;
+}
+
+/* Check if n is a power of p */
+static bool is_power_of(uint32_t n, unsigned p)
+{
+	if (p == 1 && n != p)
+		return false;
+
+	while (n != p) {
+		if (n < p)
+			return false;
+		else if ((n % p) != 0)
+			return false;
+
+		n /= p;
+	}
+
+	return true;
+}
+
+/** Get the number of blocks used by superblock + gdt + reserved gdt backups
+ *
+ * @param bg    Pointer to block group
+ *
+ * @return      Number of blocks
+ */
+uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg)
+{
+	uint32_t const idx = bg->index;
+	uint32_t r = 0;
+	bool has_backups = false;
+	ext4_superblock_t *sb = bg->fs->superblock;
+
+	/* First step: determine if the block group contains the backups */
+
+	if (idx <= 1)
+		has_backups = true;
+	else {
+		if (ext4_superblock_has_feature_compatible(sb,
+		    EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {
+			uint32_t g1, g2;
+
+			ext4_superblock_get_backup_groups_sparse2(sb,
+			    &g1, &g2);
+
+			if (idx == g1 || idx == g2)
+				has_backups = true;
+		} else if (!ext4_superblock_has_feature_read_only(sb,
+		    EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
+			/* Very old fs were all block groups have
+			 * superblock and block descriptors backups.
+			 */
+			has_backups = true;
+		} else {
+			if ((idx & 1) && (is_power_of(idx, 3) ||
+			    is_power_of(idx, 5) || is_power_of(idx, 7)))
+				has_backups = true;
+		}
+	}
+
+	if (has_backups) {
+		uint32_t bg_count;
+		uint32_t bg_desc_sz;
+		uint32_t gdt_table; /* Size of the GDT in blocks */
+		uint32_t block_size = ext4_superblock_get_block_size(sb);
+
+		/* Now we know that this block group has backups,
+		 * we have to compute how many blocks are reserved
+		 * for them
+		 */
+
+		if (idx == 0 && block_size == 1024) {
+			/* Special case for first group were the boot block
+			 * resides
+			 */
+			r++;
+		}
+
+		/* This accounts for the superblock */
+		r++;
+
+		/* Add the number of blocks used for the GDT */
+		bg_count = ext4_superblock_get_block_group_count(sb);
+		bg_desc_sz = ext4_superblock_get_desc_size(sb);
+		gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) /
+		    block_size;
+
+		r += gdt_table;
+
+		/* And now the number of reserved GDT blocks */
+		r += ext4_superblock_get_reserved_gdt_blocks(sb);
+	}
+
+	return r;
+}
+
+/** Put reference to block group.
+ *
+ * @param 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;
+				}
+			}
+		}
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+
+		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;
+						}
+					}
+				}
+				
+				rc = block_put(subblock);
+				if (rc != EOK) {
+					block_put(block);
+					return rc;
+				}
+			}
+			
+			rc = ext4_balloc_free_block(inode_ref, ind_block);
+			if (rc != EOK) {
+				block_put(block);
+				return rc;
+			}
+		}
+		
+		rc = block_put(block);
+		if (rc != EOK)
+			return rc;
+
+		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) {
+		
+		/* Sparse check */
+		if (current_block == 0)
+			return EOK;
+		
+		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/src/hash.c
===================================================================
--- uspace/lib/ext4/src/hash.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/hash.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -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 libext4
+ * @{
+ */
+/**
+ * @file  libext4_hash.c
+ * @brief Hashing algorithms for ext4 HTree.
+ */
+
+#include "ext4/libext4.h"
+#include <errno.h>
+
+int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
+{
+	// TODO
+	hinfo->hash = 0;
+	return ENOTSUP;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/src/ialloc.c
===================================================================
--- uspace/lib/ext4/src/ialloc.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/ialloc.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,311 @@
+/*
+ * 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 "ext4/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 a good candidate
+		 * for allocation.
+		 *
+		 * The criterion is based on the average number
+		 * of free inodes, unless we examine the last block
+		 * group. In that case the last block group might
+		 * have less than the average number of free inodes,
+		 * but it still needs to be taken as a candidate
+		 * because the previous block groups have zero free
+		 * blocks.
+		 */
+		if (((free_inodes >= avg_free_inodes) || (bgid == bg_count - 1)) &&
+		    (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) {
+				ext4_filesystem_put_block_group_ref(bg_ref);
+				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) {
+				rc = block_put(bitmap_block);
+				if (rc != EOK) {
+					ext4_filesystem_put_block_group_ref(bg_ref);
+					return rc;
+				}
+
+				rc = ext4_filesystem_put_block_group_ref(bg_ref);
+				if (rc != EOK)
+					return rc;
+
+				bgid++;
+				continue;
+			}
+			
+			/* Free i-node found, save the bitmap */
+			bitmap_block->dirty = true;
+			
+			rc = block_put(bitmap_block);
+			if (rc != EOK) {
+				ext4_filesystem_put_block_group_ref(bg_ref);
+				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 */
+		rc = ext4_filesystem_put_block_group_ref(bg_ref);
+		if (rc != EOK)
+			return rc;
+
+		++bgid;
+	}
+	
+	return ENOSPC;
+}
+
+/**
+ * @}
+ */
Index: uspace/lib/ext4/src/inode.c
===================================================================
--- uspace/lib/ext4/src/inode.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/inode.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,594 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include "ext4/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/src/superblock.c
===================================================================
--- uspace/lib/ext4/src/superblock.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
+++ uspace/lib/ext4/src/superblock.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -0,0 +1,1350 @@
+/*
+ * Copyright (c) 2011 Martin Sucha
+ * 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 <block.h>
+#include <malloc.h>
+#include "ext4/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);
+}
+
+/** Release the memory allocated for the superblock structure
+ *
+ * @param sb         Superblock to be freed
+ *
+ */
+void ext4_superblock_release(ext4_superblock_t *sb)
+{
+	free(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));
+}
+
+/** Get the backup groups used with SPARSE_SUPER2
+ *
+ * @param sb    Pointer to the superblock
+ * @param g1    Output pointer to the first backup group
+ * @param g2    Output pointer to the second backup group
+ */
+void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
+    uint32_t *g1, uint32_t *g2)
+{
+	*g1 = uint32_t_le2host(sb->backup_bgs[0]);
+	*g2 = uint32_t_le2host(sb->backup_bgs[1]);
+}
+
+/** Set the backup groups (SPARSE SUPER2)
+ *
+ * @param sb    Pointer to the superblock
+ * @param g1    Index of the first group
+ * @param g2    Index of the second group
+ */
+void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
+    uint32_t g1, uint32_t g2)
+{
+	sb->backup_bgs[0] = host2uint32_t_le(g1);
+	sb->backup_bgs[1] = host2uint32_t_le(g2);
+}
+
+/** Get the number of blocks (per group) reserved to GDT expansion
+ *
+ * @param sb    Pointer to the superblock
+ *
+ * @return      Number of blocks
+ */
+uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb)
+{
+	return uint32_t_le2host(sb->reserved_gdt_blocks);
+}
+
+/** Set the number of blocks (per group) reserved to GDT expansion
+ *
+ * @param sb    Pointer to the superblock
+ * @param n     Number of reserved blocks
+ */
+void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
+    uint32_t n)
+{
+	sb->reserved_gdt_blocks = host2uint32_t_le(n);
+}
+
+/**
+ * @}
+ */
Index: uspace/srv/fs/ext4fs/Makefile
===================================================================
--- uspace/srv/fs/ext4fs/Makefile	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ uspace/srv/fs/ext4fs/Makefile	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -30,5 +30,5 @@
 LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBFS_PREFIX)/libfs.a \
     $(LIBEXT4_PREFIX)/libext4.a $(LIBCRYPTO_PREFIX)/libcrypto.a
-EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX) -I$(LIBEXT4_PREFIX) -I$(LIBCRYPTO_PREFIX)
+EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX) -I$(LIBEXT4_PREFIX)/include -I$(LIBCRYPTO_PREFIX)
 BINARY = ext4fs
 STATIC_NEEDED = y
Index: uspace/srv/fs/ext4fs/ext4fs_ops.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision f066a87844b5b81c924cd3bda3e9afda66937cdf)
+++ uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision 3345b8643e43d3ed4e6235473b2897c18e8a697c)
@@ -37,6 +37,6 @@
 
 #include <errno.h>
+#include <ext4/libext4.h>
 #include <fibril_synch.h>
-#include <libext4.h>
 #include <libfs.h>
 #include <macros.h>
