Changeset a35b458 in mainline for uspace/lib/ext4

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:

uspace/lib/ext4

Files:

• include/ext4/types.h (modified) (8 diffs)
• src/balloc.c (modified) (32 diffs)
• src/bitmap.c (modified) (10 diffs)
• src/block_group.c (modified) (4 diffs)
• src/directory.c (modified) (42 diffs)
• src/directory_index.c (modified) (62 diffs)
• src/extent.c (modified) (50 diffs)
• src/filesystem.c (modified) (88 diffs)
• src/ialloc.c (modified) (17 diffs)
• src/inode.c (modified) (13 diffs)
• src/ops.c (modified) (75 diffs)
• src/superblock.c (modified) (17 diffs)

uspace/lib/ext4/include/ext4/types.h

@@ -66 +66 @@
         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 */
@@ -78 +78 @@
         char last_mounted[64];            /* Directory where last mounted */
         uint32_t algorithm_usage_bitmap;  /* For compression */
-        
+
         /*
          * Performance hints. Directory preallocation should only
@@ -86 +86 @@
         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.
@@ -251 +251 @@
         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 */
@@ -307 +307 @@
         uint32_t size_hi;
         uint32_t obso_faddr;                 /* Obsoleted fragment address */
-        
+
         union {
                 struct {
@@ -324 +324 @@
                 } hurd2;
         } __attribute__ ((packed)) osd2;
-        
+
         uint16_t extra_isize;
         uint16_t pad1;
@@ -403 +403 @@
         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;
@@ -495 +495 @@
 typedef struct ext4_extent_index {
         uint32_t first_block;  /* Index covers logical blocks from 'block' */
-        
+
         /**
          * Pointer to the physical block of the next

uspace/lib/ext4/src/balloc.c

@@ -57 +57 @@
         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;
@@ -68 +68 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Load block with bitmap */
         uint32_t bitmap_block_addr =
@@ -78 +78 @@
                 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);
@@ -90 +90 @@
                 return rc;
         }
-        
+
         uint32_t block_size = ext4_superblock_get_block_size(sb);
-        
+
         /* Update superblock free blocks count */
         uint32_t sb_free_blocks =
@@ -98 +98 @@
         sb_free_blocks++;
         ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
-        
+
         /* Update inode blocks count */
         uint64_t ino_blocks =
@@ -105 +105 @@
         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 =
@@ -113 +113 @@
             sb, free_blocks);
         bg_ref->dirty = true;
-        
+
         /* Release block group reference */
         return ext4_filesystem_put_block_group_ref(bg_ref);
@@ -346 +346 @@
 {
         uint32_t allocated_block = 0;
-        
+
         uint32_t bitmap_block_addr;
         block_t *bitmap_block;
@@ -352 +352 @@
         uint32_t free_blocks;
         uint32_t goal;
-        
+
         /* Find GOAL */
         errno_t rc = ext4_balloc_find_goal(inode_ref, &goal);
@@ -359 +359 @@
 
         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;
@@ -378 +378 @@
                 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);
@@ -399 +399 @@
                 return rc;
         }
-        
+
         /* Check if goal is free */
         if (ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group)) {
@@ -409 +409 @@
                         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;
@@ -433 +433 @@
                         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,
@@ -450 +450 @@
                 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,
@@ -466 +466 @@
                 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);
@@ -486 +486 @@
         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,
@@ -509 +509 @@
                 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);
@@ -516 +516 @@
                         return rc;
                 }
-                
+
                 /* Compute indexes */
                 first_in_group =
@@ -523 +523 @@
                     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,
@@ -540 +540 @@
                                 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,
@@ -558 +558 @@
                                 return rc;
                         }
-                        
+
                         allocated_block =
                             ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx,
                             bgid);
-                        
+
                         goto success;
                 }
-                
+
                 rc = block_put(bitmap_block);
                 if (rc != EOK) {
@@ -576 +576 @@
                 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 =
@@ -601 +601 @@
         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 =
@@ -609 +609 @@
             bg_free_blocks);
         bg_ref->dirty = true;
-        
+
         rc = ext4_filesystem_put_block_group_ref(bg_ref);
-        
+
         *fblock = allocated_block;
         return rc;
@@ -629 +629 @@
 {
         errno_t 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;
@@ -643 +643 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Load block with bitmap */
         uint32_t bitmap_block_addr =
@@ -653 +653 @@
                 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) {
@@ -662 +662 @@
                 bitmap_block->dirty = true;
         }
-        
+
         /* Release block with bitmap */
         rc = block_put(bitmap_block);
@@ -670 +670 @@
                 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 =
@@ -688 +688 @@
         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 =
@@ -696 +696 @@
             sb, free_blocks);
         bg_ref->dirty = true;
-        
+
 terminate:
         return ext4_filesystem_put_block_group_ref(bg_ref);

uspace/lib/ext4/src/bitmap.c

@@ -52 +52 @@
         uint32_t byte_index = index / 8;
         uint32_t bit_index = index % 8;
-        
+
         uint8_t *target = bitmap + byte_index;
-        
+
         *target &= ~ (1 << bit_index);
 }
@@ -73 +73 @@
         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--;
@@ -129 +129 @@
         uint32_t byte_index = index / 8;
         uint32_t bit_index = index % 8;
-        
+
         uint8_t *target = bitmap + byte_index;
-        
+
         *target |= 1 << bit_index;
 }
@@ -147 +147 @@
         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;
@@ -173 +173 @@
 {
         uint32_t idx;
-        
+
         /* Align idx */
         if (start % 8)
@@ -179 +179 @@
         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;
@@ -217 +217 @@
         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));
@@ -227 +227 @@
                         return EOK;
                 }
-                
+
                 ++idx;
         }
-        
+
         if (byte_part)
                 ++pos;
-        
+
         /* Check the whole bytes (255 = 11111111 binary) */
         while (idx < max) {
@@ -240 +240 @@
                         break;
                 }
-                
+
                 idx += 8;
                 ++pos;
         }
-        
+
         /* If idx < max, some free bit found */
         if (idx < max) {
@@ -252 +252 @@
                                 /* Free bit found */
                                 *pos |= (1 << i);
-                                
+
                                 *index = idx;
                                 return EOK;
                         }
-                        
+
                         idx++;
                 }
         }
-        
+
         /* Free bit not found */
         return ENOSPC;

uspace/lib/ext4/src/block_group.c

@@ -70 +70 @@
 {
         bg->block_bitmap_lo = host2uint32_t_le((block_bitmap << 32) >> 32);
-        
+
         if (ext4_superblock_get_desc_size(sb) >
             EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
@@ -106 +106 @@
 {
         bg->inode_bitmap_lo = host2uint32_t_le((inode_bitmap << 32) >> 32);
-        
+
         if (ext4_superblock_get_desc_size(sb) >
             EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
@@ -144 +144 @@
         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)
@@ -353 +353 @@
         if (ext4_block_group_get_flags(bg) & flag)
                 return true;
-        
+
         return false;
 }

uspace/lib/ext4/src/directory.c

@@ -110 +110 @@
                 return ((uint16_t)de->name_length_high) << 8 |
                     ((uint16_t)de->name_length);
-        
+
         return de->name_length;
 
@@ -126 +126 @@
 {
         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 */
 }
@@ -148 +148 @@
             (ext4_superblock_get_minor_rev_level(sb) >= 5))
                 return de->inode_type;
-        
+
         return EXT4_DIRECTORY_FILETYPE_UNKNOWN;
 }
@@ -165 +165 @@
             (ext4_superblock_get_minor_rev_level(sb) >= 5))
                 de->inode_type = type;
-        
+
         /* Else do nothing */
 }
@@ -190 +190 @@
         it->current_offset = 0;
         it->current_block = NULL;
-        
+
         return ext4_directory_iterator_seek(it, pos);
 }
@@ -204 +204 @@
 {
         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);
 }
@@ -224 +224 @@
         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) {
@@ -233 +233 @@
                         errno_t 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 =
@@ -247 +247 @@
         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,
@@ -257 +257 @@
                         errno_t rc = block_put(it->current_block);
                         it->current_block = NULL;
-                        
+
                         if (rc != EOK)
                                 return rc;
                 }
-                
+
                 uint32_t next_block_phys_idx;
                 errno_t rc = ext4_filesystem_get_inode_data_block_index(it->inode_ref,
@@ -267 +267 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 rc = block_get(&it->current_block, it->inode_ref->fs->device,
                     next_block_phys_idx, BLOCK_FLAGS_NONE);
@@ -275 +275 @@
                 }
         }
-        
+
         it->current_offset = pos;
-        
+
         return ext4_directory_iterator_set(it, block_size);
 }
@@ -293 +293 @@
 {
         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;
@@ -335 +335 @@
         it->inode_ref = NULL;
         it->current = NULL;
-        
+
         if (it->current_block)
                 return block_put(it->current_block);
-        
+
         return EOK;
 }
@@ -359 +359 @@
         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))
@@ -390 +390 @@
 {
         ext4_filesystem_t *fs = parent->fs;
-        
+
         /* Index adding (if allowed) */
         if ((ext4_superblock_has_feature_compatible(fs->superblock,
@@ -405 +405 @@
                 parent->dirty = true;
         }
-        
+
         /* Linear algorithm */
-        
+
         uint32_t iblock = 0;
         uint32_t fblock = 0;
@@ -413 +413 @@
         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;
@@ -423 +423 @@
                 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,
@@ -434 +434 @@
                 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;
@@ -450 +450 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Load new block */
         block_t *new_block;
@@ -456 +456 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Fill block with zeroes */
         memset(new_block->data, 0, block_size);
@@ -462 +462 @@
         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;
 }
@@ -483 +483 @@
 {
         uint32_t name_len = str_size(name);
-        
+
         ext4_superblock_t *sb = parent->fs->superblock;
-        
+
         /* Index search */
         if ((ext4_superblock_has_feature_compatible(sb,
@@ -492 +492 @@
                 errno_t 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;
@@ -513 +513 @@
         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) {
@@ -521 +521 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 /* Load data block */
                 block_t *block;
@@ -527 +527 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 /* Try to find entry in block */
                 ext4_directory_entry_ll_t *res_entry;
@@ -537 +537 @@
                         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;
 }
@@ -567 +567 @@
             EXT4_INODE_MODE_DIRECTORY))
                 return ENOTDIR;
-        
+
         /* Try to find entry */
         ext4_directory_search_result_t result;
@@ -573 +573 @@
         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
@@ -586 +586 @@
         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) {
@@ -600 +600 @@
                             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 =
@@ -609 +609 @@
                     tmp_dentry_length + del_entry_length);
         }
-        
+
         result.block->dirty = true;
-        
+
         return ext4_directory_destroy_result(&result);
 }
@@ -633 +633 @@
         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
@@ -648 +648 @@
                 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)) {
@@ -654 +654 @@
                             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) {
@@ -679 +679 @@
                                 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;
@@ -711 +711 @@
         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) {
@@ -720 +720 @@
                 if ((uint8_t *) dentry + name_len > addr_limit)
                         break;
-                
+
                 /* Valid entry - check it */
                 if (dentry->inode != 0) {
@@ -733 +733 @@
                         }
                 }
-                
+
                 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;
@@ -760 +760 @@
         if (result->block)
                 return block_put(result->block);
-        
+
         return EOK;
 }

uspace/lib/ext4/src/directory_index.c

@@ -244 +244 @@
         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);
@@ -274 +274 @@
         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;
@@ -282 +282 @@
                 return rc;
         }
-        
+
         block_t *new_block;
         rc = block_get(&new_block, dir->fs->device, fblock, BLOCK_FLAGS_NOREAD);
@@ -289 +289 @@
                 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);
@@ -301 +301 @@
                 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);
 }
@@ -328 +328 @@
         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);
@@ -348 +348 @@
         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 =
@@ -362 +362 @@
                 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;
 }
@@ -393 +393 @@
         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;
@@ -404 +404 @@
         ext4_directory_dx_entry_t *m;
         ext4_directory_dx_entry_t *at;
-        
+
         /* Walk through the index tree */
         while (true) {
@@ -411 +411 @@
                 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;
@@ -423 +423 @@
                                 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) {
@@ -436 +436 @@
                         return EOK;
                 }
-                
+
                 /* Goto child node */
                 uint32_t next_block = ext4_directory_dx_entry_get_block(at);
-                
+
                 indirect_level--;
-                
+
                 uint32_t fblock;
                 errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
@@ -447 +447 @@
                 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;
@@ -490 +490 @@
         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) {
@@ -496 +496 @@
                 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);
@@ -513 +513 @@
                         return 0;
         }
-        
+
         /* Fill new path */
         while (num_handles--) {
@@ -519 +519 @@
                     ext4_directory_dx_entry_get_block(p->position);
                 uint32_t block_addr;
-                
+
                 errno_t 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;
 }
@@ -566 +566 @@
         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,
@@ -574 +574 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Initialize hash info (compute hash value) */
         ext4_hash_info_t hinfo;
@@ -583 +583 @@
                 return EXT4_ERR_BAD_DX_DIR;
         }
-        
+
         /*
          * Hardcoded number 2 means maximum height of index tree,
@@ -591 +591 @@
         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);
@@ -598 +598 @@
                 return EXT4_ERR_BAD_DX_DIR;
         }
-        
+
         do {
                 /* Load leaf block */
@@ -604 +604 @@
                     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,
@@ -615 +615 @@
                 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) {
@@ -627 +627 @@
                         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,
@@ -643 +643 @@
 
         } 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);
@@ -657 +657 @@
                 ++tmp;
         }
-        
+
         return rc;
 }
@@ -677 +677 @@
         ext4_dx_sort_entry_t const *entry1 = arg1;
         ext4_dx_sort_entry_t const *entry2 = arg2;
-        
+
         if (entry1->hash == entry2->hash)
                 return 0;
-        
+
         if (entry1->hash < entry2->hash)
                 return -1;
@@ -701 +701 @@
         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;
 }
@@ -733 +733 @@
 {
         errno_t rc = EOK;
-        
+
         /* Allocate buffer for directory entries */
         uint32_t block_size =
@@ -740 +740 @@
         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 =
@@ -752 +752 @@
                 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;
@@ -769 +769 @@
                             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);
-        
+
         /* Allocate new block for store the second part of entries */
         uint32_t new_fblock;
@@ -804 +804 @@
                 return rc;
         }
-        
+
         /* Load new block */
         block_t *new_data_block_tmp;
@@ -814 +814 @@
                 return rc;
         }
-        
+
         /*
          * Distribute entries to two blocks (by size)
@@ -828 +828 @@
                         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))
@@ -852 +852 @@
                         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;
@@ -861 +861 @@
                 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))
@@ -869 +869 @@
                         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;
 }
@@ -907 +907 @@
                 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;
@@ -929 +929 @@
                 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;
@@ -941 +941 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 /* load new block */
                 block_t *new_block;
@@ -948 +948 @@
                 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) {
@@ -961 +961 @@
                         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 =
@@ -971 +971 @@
                         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);
@@ -980 +980 @@
                             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;
@@ -991 +991 @@
                                     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);
@@ -1014 +1014 @@
                             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;
@@ -1032 +1032 @@
                 }
         }
-        
+
         return EOK;
 }
@@ -1049 +1049 @@
 {
         errno_t rc2 = EOK;
-        
+
         /* Get direct block 0 (index root) */
         uint32_t root_block_addr;
@@ -1056 +1056 @@
         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,
@@ -1064 +1064 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Initialize hinfo structure (mainly compute hash) */
         uint32_t name_len = str_size(name);
@@ -1074 +1074 @@
                 return EXT4_ERR_BAD_DX_DIR;
         }
-        
+
         /*
          * Hardcoded number 2 means maximum height of index
@@ -1082 +1082 @@
         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);
@@ -1089 +1089 @@
                 goto release_index;
         }
-        
+
         /* Try to insert to existing data block */
         uint32_t leaf_block_idx =
@@ -1098 +1098 @@
         if (rc != EOK)
                 goto release_index;
-        
+
         block_t *target_block;
         rc = block_get(&target_block, fs->device, leaf_block_addr,
@@ -1104 +1104 @@
         if (rc != EOK)
                 goto release_index;
-        
+
         /* Check if insert operation passed */
         rc = ext4_directory_try_insert_entry(fs->superblock, target_block, child,
@@ -1110 +1110 @@
         if (rc == EOK)
                 goto release_target_index;
-        
+
         /*
          * Check if there is needed to split index node
@@ -1118 +1118 @@
         if (rc != EOK)
                 goto release_target_index;
-        
+
         /* Split entries to two blocks (includes sorting by hash value) */
         block_t *new_block = NULL;
@@ -1127 +1127 @@
                 goto release_target_index;
         }
-        
+
         /* Where to save new entry */
         uint32_t new_block_hash =
@@ -1137 +1137 @@
                 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;
 }

uspace/lib/ext4/src/extent.c

@@ -295 +295 @@
         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;
@@ -313 +313 @@
                         l = m + 1;
         }
-        
+
         /* Set output value */
         *index = l - 1;
@@ -332 +332 @@
         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 */
@@ -341 +341 @@
                 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;
@@ -356 +356 @@
                         l = m + 1;
         }
-        
+
         /* Set output value */
         *extent = l - 1;
@@ -379 +379 @@
         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) {
@@ -390 +390 @@
                 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);
@@ -410 +410 @@
                                 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) {
@@ -431 +431 @@
                 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;
 }
@@ -459 +459 @@
         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;
@@ -480 +480 @@
                 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,
@@ -494 +494 @@
                 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:
         ;
@@ -528 +528 @@
                 }
         }
-        
+
         /* Destroy temporary data structure */
         free(tmp_path);
-        
+
         return rc;
 }
@@ -549 +549 @@
         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);
 }
@@ -569 +569 @@
 {
         uint32_t fblock = ext4_extent_index_get_leaf(index);
-        
+
         block_t* block;
         errno_t 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;
@@ -592 +592 @@
                 /* Leaf node reached */
                 ext4_extent_t *ext = EXT4_EXTENT_FIRST(header);
-                
+
                 /* Release all extents and stop recursion */
                 for (uint32_t i = 0;
@@ -602 +602 @@
                 }
         }
-        
+
         /* 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);
 }
@@ -626 +626 @@
         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 =
@@ -639 +639 @@
         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 =
@@ -659 +659 @@
         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)) {
@@ -688 +688 @@
                 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) {
@@ -701 +701 @@
                 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) {
@@ -711 +711 @@
                         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)) {
@@ -724 +724 @@
                         if (rc != EOK)
                                 goto cleanup;
-                        
+
                         /* Mark parent to be checked */
                         remove_parent_record = true;
                 } else
                         remove_parent_record = false;
-                
+
                 --path_ptr;
         }
-        
+
 cleanup:
         ;
@@ -749 +749 @@
                 }
         }
-        
+
         /* Destroy temporary data structure */
         free(path);
-        
+
         return rc;
 }
@@ -771 +771 @@
 {
         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) {
@@ -781 +781 @@
                 uint16_t limit =
                     ext4_extent_header_get_max_entries_count(path_ptr->header);
-                
+
                 if (entries == limit) {
                         /* Full node - allocate block for new one */
@@ -788 +788 @@
                         if (rc != EOK)
                                 return rc;
-                        
+
                         block_t *block;
                         rc = block_get(&block, inode_ref->fs->device, fblock,
@@ -796 +796 @@
                                 return rc;
                         }
-                        
+
                         /* Put back not modified old block */
                         rc = block_put(path_ptr->block);
@@ -804 +804 @@
                                 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;
@@ -823 +823 @@
                                     sizeof(ext4_extent_t);
                         }
-                        
+
                         /* Initialize on-disk structure (header) */
                         ext4_extent_header_set_entries_count(path_ptr->header, 1);
@@ -830 +830 @@
                         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--;
@@ -845 +845 @@
                                 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;
@@ -866 +866 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 block_t *block;
                 rc = block_get(&block, inode_ref->fs->device, new_fblock,
@@ -872 +872 @@
                 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) {
@@ -913 +913 @@
                         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;
@@ -925 +925 @@
                 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 {
@@ -943 +943 @@
                         ext4_extent_set_first_block(path->extent, iblock);
                 }
-                
+
                 ext4_extent_header_set_entries_count(path->header, entries + 1);
                 path->block->dirty = true;
         }
-        
+
         return EOK;
 }
@@ -970 +970 @@
         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;
@@ -976 +976 @@
                 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;
@@ -985 +985 @@
         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) {
@@ -1006 +1006 @@
                         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) {
@@ -1017 +1017 @@
                                 inode_ref->dirty = true;
                         }
-                        
+
                         path_ptr->block->dirty = true;
-                        
+
                         goto finish;
                 } else {
@@ -1025 +1025 @@
                         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;
@@ -1031 +1031 @@
                         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) {
@@ -1045 +1045 @@
                                 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);
@@ -1068 +1068 @@
                 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) {
@@ -1082 +1082 @@
                 inode_ref->dirty = true;
         }
-        
+
         path_ptr->block->dirty = true;
-        
+
 finish:
         ;
@@ -1093 +1093 @@
         *iblock = new_block_idx;
         *fblock = phys_block;
-        
+
         /*
          * Put loaded blocks
@@ -1105 +1105 @@
                 }
         }
-        
+
         /* Destroy temporary data structure */
         free(path);
-        
+
         return rc;
 }

uspace/lib/ext4/src/filesystem.c

@@ -289 +289 @@
                 return EOK;
         }
-        
+
         /*
          * Check incompatible features - if filesystem has some,
@@ -300 +300 @@
         if (incompatible_features > 0)
                 return ENOTSUP;
-        
+
         /*
          * Check read-only features, if filesystem has some,
@@ -313 +313 @@
                 return EOK;
         }
-        
+
         return EOK;
 }
@@ -331 +331 @@
         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)
@@ -351 +351 @@
 {
         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;
@@ -392 +392 @@
         uint64_t bitmap_inode_addr = ext4_block_group_get_inode_bitmap(
             bg_ref->block_group, bg_ref->fs->superblock);
-        
+
         block_t *bitmap_block;
         errno_t rc = block_get(&bitmap_block, bg_ref->fs->device,
@@ -398 +398 @@
         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);
@@ -439 +439 @@
 
         bitmap_block->dirty = true;
-        
+
         /* Save bitmap */
         return block_put(bitmap_block);
@@ -457 +457 @@
             bg_ref->block_group, bg_ref->fs->superblock);
         block_t *bitmap_block;
-        
+
         errno_t 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);
@@ -470 +470 @@
             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);
@@ -497 +497 @@
 {
         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) {
@@ -523 +523 @@
                 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;
 }
@@ -552 +552 @@
         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 */
         errno_t rc = block_get(&newref->block, fs->device, block_id, 0);
@@ -573 +573 @@
                 return rc;
         }
-        
+
         /* Initialize in-memory representation */
         newref->block_group = newref->block->data + offset;
@@ -579 +579 @@
         newref->index = bgid;
         newref->dirty = false;
-        
+
         *ref = newref;
-        
+
         if (ext4_block_group_has_flag(newref->block_group,
             EXT4_BLOCK_GROUP_BLOCK_UNINIT)) {
@@ -590 +590 @@
                         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)) {
@@ -605 +605 @@
                         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)) {
@@ -614 +614 @@
                         if (rc != EOK)
                                 return rc;
-                        
+
                         ext4_block_group_set_flag(newref->block_group,
                             EXT4_BLOCK_GROUP_ITABLE_ZEROED);
                 }
-                
+
                 newref->dirty = true;
         }
-        
+
         return EOK;
 }
@@ -645 +645 @@
                 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,
@@ -670 +670 @@
                             ext4_superblock_get_desc_size(sb) - offset);
         }
-        
+
         return crc;
 }
@@ -813 +813 @@
                     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 */
         errno_t rc = block_put(ref->block);
         free(ref);
-        
+
         return rc;
 }
@@ -842 +842 @@
         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
@@ -854 +854 @@
         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;
@@ -862 +862 @@
                 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);
@@ -874 +874 @@
                 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);
@@ -887 +887 @@
                 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;
 }
@@ -916 +916 @@
                 ref->block->dirty = true;
         }
-        
+
         /* Put back block, that contains i-node */
         errno_t rc = block_put(ref->block);
         free(ref);
-        
+
         return rc;
 }
@@ -940 +940 @@
         if (flags & L_DIRECTORY)
                 is_dir = true;
-        
+
         /* Allocate inode by allocation algorithm */
         uint32_t index;
@@ -946 +946 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Load i-node from on-disk i-node table */
         rc = ext4_filesystem_get_inode_ref(fs, index, inode_ref);
@@ -953 +953 @@
                 return rc;
         }
-        
+
         /* Initialize i-node */
         ext4_inode_t *inode = (*inode_ref)->inode;
-        
+
         uint16_t mode;
         if (is_dir) {
@@ -963 +963 @@
                  * 0777 (octal) == rwxrwxrwx
                  */
-                
+
                 mode = 0777;
                 mode |= EXT4_INODE_MODE_DIRECTORY;
@@ -973 +973 @@
                  * 0666 (octal) == rw-rw-rw-
                  */
-                
+
                 mode = 0666;
                 mode |= EXT4_INODE_MODE_FILE;
@@ -979 +979 @@
                 ext4_inode_set_links_count(inode, 0);
         }
-        
+
         ext4_inode_set_uid(inode, 0);
         ext4_inode_set_gid(inode, 0);
@@ -990 +990 @@
         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);
@@ -1006 +1006 @@
                 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;
 }
@@ -1028 +1028 @@
 {
         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,
@@ -1036 +1036 @@
                 goto finish;
         }
-        
+
         /* Release all indirect (no data) blocks */
-        
+
         /* 1) Single indirect */
         uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
@@ -1045 +1045 @@
                 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);
@@ -1059 +1059 @@
                 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);
@@ -1072 +1072 @@
                         }
                 }
-                
+
                 rc = block_put(block);
                 if (rc != EOK)
@@ -1080 +1080 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 ext4_inode_set_indirect_block(inode_ref->inode, 1, 0);
         }
-        
+
         /* 3) Tripple indirect */
         block_t *subblock;
@@ -1091 +1091 @@
                 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,
@@ -1103 +1103 @@
                                         return rc;
                                 }
-                                
+
                                 uint32_t ind_subblock;
                                 for (uint32_t suboffset = 0; suboffset < count;
@@ -1109 +1109 @@
                                         ind_subblock = uint32_t_le2host(((uint32_t *)
                                             subblock->data)[suboffset]);
-                                        
+
                                         if (ind_subblock != 0) {
                                                 rc = ext4_balloc_free_block(inode_ref, ind_subblock);
@@ -1119 +1119 @@
                                         }
                                 }
-                                
+
                                 rc = block_put(subblock);
                                 if (rc != EOK) {
@@ -1126 +1126 @@
                                 }
                         }
-                        
+
                         rc = ext4_balloc_free_block(inode_ref, ind_block);
                         if (rc != EOK) {
@@ -1133 +1133 @@
                         }
                 }
-                
+
                 rc = block_put(block);
                 if (rc != EOK)
@@ -1141 +1141 @@
                 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(
@@ -1156 +1156 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 ext4_inode_set_file_acl(inode_ref->inode, fs->superblock, 0);
         }
-        
+
         /* Free inode by allocator */
         errno_t rc;
@@ -1167 +1167 @@
         else
                 rc = ext4_ialloc_free_inode(fs, inode_ref->index, false);
-        
+
         return rc;
 }
@@ -1183 +1183 @@
 {
         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;
@@ -1203 +1203 @@
         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)) &&
@@ -1218 +1218 @@
         } 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) {
@@ -1227 +1227 @@
                 }
         }
-        
+
         /* Update i-node */
         ext4_inode_set_size(inode_ref->inode, new_size);
         inode_ref->dirty = true;
-        
+
         return EOK;
 }
@@ -1248 +1248 @@
 {
         ext4_filesystem_t *fs = inode_ref->fs;
-        
+
         /* For empty file is situation simple */
         if (ext4_inode_get_size(fs->superblock, inode_ref->inode) == 0) {
@@ -1254 +1254 @@
                 return EOK;
         }
-        
+
         uint32_t current_block;
-        
+
         /* Handle i-node using extents */
         if ((ext4_superblock_has_feature_incompatible(fs->superblock,
@@ -1264 +1264 @@
                 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) {
@@ -1277 +1277 @@
                 return EOK;
         }
-        
+
         /* Determine indirection level of the target block */
         unsigned int level = 0;
@@ -1286 +1286 @@
                 }
         }
-        
+
         if (level == 0)
                 return EIO;
-        
+
         /* Compute offsets for the topmost level */
         aoff64_t block_offset_in_level =
@@ -1296 +1296 @@
         uint32_t offset_in_block =
             block_offset_in_level / fs->inode_blocks_per_level[level - 1];
-        
+
         /* Sparse file */
         if (current_block == 0) {
@@ -1302 +1302 @@
                 return EOK;
         }
-        
+
         block_t *block;
-        
+
         /*
          * Navigate through other levels, until we find the block number
@@ -1314 +1314 @@
                 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) {
@@ -1329 +1329 @@
                         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];
@@ -1342 +1342 @@
                     block_offset_in_level / fs->inode_blocks_per_level[level - 1];
         }
-        
+
         *fblock = current_block;
-        
+
         return EOK;
 }
@@ -1361 +1361 @@
 {
         ext4_filesystem_t *fs = inode_ref->fs;
-        
+
         /* Handle inode using extents */
         if ((ext4_superblock_has_feature_compatible(fs->superblock,
@@ -1369 +1369 @@
                 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;
@@ -1386 +1386 @@
                 }
         }
-        
+
         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 =
@@ -1399 +1399 @@
         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) {
@@ -1410 +1410 @@
                 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,
@@ -1423 +1423 @@
                         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
@@ -1444 +1444 @@
                 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 */
@@ -1455 +1455 @@
                                 return rc;
                         }
-                        
+
                         /* Load newly allocated block */
                         rc = block_get(&new_block, fs->device, new_block_addr,
@@ -1463 +1463 @@
                                 return rc;
                         }
-                        
+
                         /* Initialize allocated block */
                         memset(new_block->data, 0, block_size);
                         new_block->dirty = true;
-                        
+
                         rc = block_put(new_block);
                         if (rc != EOK) {
@@ -1473 +1473 @@
                                 return rc;
                         }
-                        
+
                         /* Write block address to the parent */
                         ((uint32_t *) block->data)[offset_in_block] =
@@ -1480 +1480 @@
                         current_block = new_block_addr;
                 }
-                
+
                 /* Will be finished, write the fblock address */
                 if (level == 1) {
@@ -1487 +1487 @@
                         block->dirty = true;
                 }
-                
+
                 rc = block_put(block);
                 if (rc != EOK)
                         return rc;
-                
+
                 level--;
-                
+
                 /*
                  * If we are on the last level, break here as
@@ -1500 +1500 @@
                 if (level == 0)
                         break;
-                
+
                 /* Visit the next level */
                 block_offset_in_level %= fs->inode_blocks_per_level[level];
@@ -1506 +1506 @@
                     block_offset_in_level / fs->inode_blocks_per_level[level - 1];
         }
-        
+
         return EOK;
 }
@@ -1522 +1522 @@
 {
         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;
@@ -1552 +1552 @@
                 }
         }
-        
+
         if (level == 0)
                 return EIO;
-        
+
         /* Compute offsets for the topmost level */
         aoff64_t block_offset_in_level =
@@ -1563 +1563 @@
         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
@@ -1570 +1570 @@
         block_t *block;
         while (level > 0) {
-                
+
                 /* Sparse check */
                 if (current_block == 0)
                         return EOK;
-                
+
                 errno_t 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) {
@@ -1588 +1588 @@
                         block->dirty = true;
                 }
-                
+
                 rc = block_put(block);
                 if (rc != EOK)
                         return rc;
-                
+
                 level--;
-                
+
                 /*
                  * If we are on the last level, break here as
@@ -1601 +1601 @@
                 if (level == 0)
                         break;
-                
+
                 /* Visit the next level */
                 block_offset_in_level %= fs->inode_blocks_per_level[level];
@@ -1607 +1607 @@
                     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);
@@ -1633 +1633 @@
             (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;
@@ -1652 +1652 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Add physical block address to the i-node */
         rc = ext4_filesystem_set_inode_data_block_index(inode_ref,
@@ -1660 +1660 @@
                 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;
 }

uspace/lib/ext4/src/ialloc.c

@@ -100 +100 @@
 {
         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;
         errno_t 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(
@@ -117 +117 @@
         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);
@@ -130 +130 @@
                 return rc;
         }
-        
+
         /* If released i-node is a directory, decrement used directories count */
         if (is_dir) {
@@ -139 +139 @@
                     bg_used_dirs);
         }
-        
+
         /* Update block group free inodes count */
         uint32_t free_inodes = ext4_block_group_get_free_inodes_count(
@@ -146 +146 @@
         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 =
@@ -159 +159 @@
         sb_free_inodes++;
         ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
-        
+
         return EOK;
 }
@@ -178 +178 @@
 {
         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) {
@@ -191 +191 @@
                 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
@@ -216 +216 @@
                         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,
@@ -224 +224 @@
                                 return rc;
                         }
-                        
+
                         /* Try to allocate i-node in the bitmap */
                         uint32_t inodes_in_group = ext4_superblock_get_inodes_in_group(sb, bgid);
@@ -230 +230 @@
                         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) {
@@ -246 +246 @@
                                 continue;
                         }
-                        
+
                         /* Free i-node found, save the bitmap */
                         bitmap_block->dirty = true;
-                        
+
                         rc = block_put(bitmap_block);
                         if (rc != EOK) {
@@ -255 +255 @@
                                 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) {
@@ -265 +265 @@
                                 ext4_block_group_set_used_dirs_count(bg, sb, used_dirs);
                         }
-                        
+
                         /* Decrease unused inodes count */
                         if (ext4_block_group_has_flag(bg,
@@ -271 +271 @@
                                 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);
@@ -282 +282 @@
                                 }
                         }
-                        
+
                         /* 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);
@@ -307 +307 @@
                 ++bgid;
         }
-        
+
         return ENOSPC;
 }

uspace/lib/ext4/src/inode.c

@@ -53 +53 @@
         uint32_t bits = 8;
         uint32_t size = block_size;
-        
+
         do {
                 bits++;
                 size = size >> 1;
         } while (size > 256);
-        
+
         return bits;
 }
@@ -76 +76 @@
                     ((uint32_t) uint16_t_le2host(inode->mode));
         }
-        
+
         return uint16_t_le2host(inode->mode);
 }
@@ -90 +90 @@
 {
         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);
@@ -129 +129 @@
 {
         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);
 }
@@ -304 +304 @@
                     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);
@@ -330 +330 @@
         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);
@@ -360 +360 @@
                 inode->osd2.linux2.blocks_high = host2uint16_t_le(count >> 32);
         }
-        
+
         return EOK;
 }
@@ -424 +424 @@
                     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);
 }
@@ -439 +439 @@
 {
         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);
@@ -455 +455 @@
 {
         assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT);
-        
+
         return uint32_t_le2host(inode->blocks[idx]);
 }
@@ -469 +469 @@
 {
         assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT);
-        
+
         inode->blocks[idx] = host2uint32_t_le(fblock);
 }
@@ -540 +540 @@
         if (ext4_inode_get_flags(inode) & flag)
                 return true;
-        
+
         return false;
 }
@@ -583 +583 @@
             (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;
 }

uspace/lib/ext4/src/ops.c

@@ -117 +117 @@
         node_key_t *key = (node_key_t *)key_arg;
         ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
-        
+
         return key->service_id == enode->instance->service_id
                 && key->index == enode->inode_ref->index;
@@ -142 +142 @@
         if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
                 return ENOMEM;
-        
+
         return EOK;
 }
@@ -173 +173 @@
 {
         fibril_mutex_lock(&instance_list_mutex);
-        
+
         if (list_empty(&instance_list)) {
                 fibril_mutex_unlock(&instance_list_mutex);
                 return EINVAL;
         }
-        
+
         list_foreach(instance_list, link, ext4_instance_t, tmp) {
                 if (tmp->service_id == service_id) {
@@ -186 +186 @@
                 }
         }
-        
+
         fibril_mutex_unlock(&instance_list_mutex);
         return EINVAL;
@@ -219 +219 @@
         ext4_node_t *eparent = EXT4_NODE(pfn);
         ext4_filesystem_t *fs = eparent->instance->filesystem;
-        
+
         if (!ext4_inode_is_type(fs->superblock, eparent->inode_ref->inode,
             EXT4_INODE_MODE_DIRECTORY))
                 return ENOTDIR;
-        
+
         /* Try to find entry */
         ext4_directory_search_result_t result;
@@ -233 +233 @@
                         return EOK;
                 }
-                
-                return rc;
-        }
-        
+
+                return rc;
+        }
+
         /* Load node from search result */
         uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry);
@@ -268 +268 @@
         if (rc != EOK)
                 return rc;
-        
+
         return ext4_node_get_core(rfn, inst, index);
 }
@@ -285 +285 @@
 {
         fibril_mutex_lock(&open_nodes_lock);
-        
+
         /* Check if the node is not already open */
         node_key_t key = {
@@ -291 +291 @@
                 .index = index
         };
-        
+
         ht_link_t *already_open = hash_table_find(&open_nodes, &key);
         ext4_node_t *enode = NULL;
@@ -298 +298 @@
                 *rfn = enode->fs_node;
                 enode->references++;
-                
+
                 fibril_mutex_unlock(&open_nodes_lock);
                 return EOK;
         }
-        
+
         /* Prepare new enode */
         enode = malloc(sizeof(ext4_node_t));
@@ -309 +309 @@
                 return ENOMEM;
         }
-        
+
         /* Prepare new fs_node and initialize */
         fs_node_t *fs_node = malloc(sizeof(fs_node_t));
@@ -317 +317 @@
                 return ENOMEM;
         }
-        
+
         fs_node_initialize(fs_node);
-        
+
         /* Load i-node from filesystem */
         ext4_inode_ref_t *inode_ref;
@@ -330 +330 @@
                 return rc;
         }
-        
+
         /* Initialize enode */
         enode->inode_ref = inode_ref;
@@ -336 +336 @@
         enode->references = 1;
         enode->fs_node = fs_node;
-        
+
         fs_node->data = enode;
         *rfn = fs_node;
-        
+
         hash_table_insert(&open_nodes, &enode->link);
         inst->open_nodes_count++;
-        
+
         fibril_mutex_unlock(&open_nodes_lock);
-        
+
         return EOK;
 }
@@ -360 +360 @@
         assert(enode->instance->open_nodes_count > 0);
         enode->instance->open_nodes_count--;
-        
+
         /* Put inode back in filesystem */
         errno_t rc = ext4_filesystem_put_inode_ref(enode->inode_ref);
         if (rc != EOK)
                 return rc;
-        
+
         /* Destroy data structure */
         free(enode->fs_node);
         free(enode);
-        
+
         return EOK;
 }
@@ -399 +399 @@
 {
         fibril_mutex_lock(&open_nodes_lock);
-        
+
         ext4_node_t *enode = EXT4_NODE(fn);
         assert(enode->references > 0);
@@ -410 +410 @@
                 }
         }
-        
+
         fibril_mutex_unlock(&open_nodes_lock);
-        
+
         return EOK;
 }
@@ -432 +432 @@
         if (enode == NULL)
                 return ENOMEM;
-        
+
         /* Allocate fs_node */
         fs_node_t *fs_node;
@@ -440 +440 @@
                 return ENOMEM;
         }
-        
+
         /* Load instance */
         ext4_instance_t *inst;
@@ -449 +449 @@
                 return rc;
         }
-        
+
         /* Allocate new i-node in filesystem */
         ext4_inode_ref_t *inode_ref;
@@ -458 +458 @@
                 return rc;
         }
-        
+
         /* Do some interconnections in references */
         enode->inode_ref = inode_ref;
         enode->instance = inst;
         enode->references = 1;
-        
+
         fibril_mutex_lock(&open_nodes_lock);
         hash_table_insert(&open_nodes, &enode->link);
         fibril_mutex_unlock(&open_nodes_lock);
         inst->open_nodes_count++;
-        
+
         enode->inode_ref->dirty = true;
-        
+
         fs_node_initialize(fs_node);
         fs_node->data = enode;
         enode->fs_node = fs_node;
         *rfn = fs_node;
-        
+
         return EOK;
 }
@@ -495 +495 @@
                 return rc;
         }
-        
+
         if (has_children) {
                 ext4_node_put(fn);
                 return EINVAL;
         }
-        
+
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_inode_ref_t *inode_ref = enode->inode_ref;
-        
+
         /* Release data blocks */
         rc = ext4_filesystem_truncate_inode(inode_ref, 0);
@@ -510 +510 @@
                 return rc;
         }
-        
+
         /*
          * TODO: Sset real deletion time when it will be supported.
@@ -517 +517 @@
         ext4_inode_set_deletion_time(inode_ref->inode, 0xdeadbeef);
         inode_ref->dirty = true;
-        
+
         /* Free inode */
         rc = ext4_filesystem_free_inode(inode_ref);
@@ -524 +524 @@
                 return rc;
         }
-        
+
         return ext4_node_put(fn);
 }
@@ -542 +542 @@
         if (str_size(name) > EXT4_DIRECTORY_FILENAME_LEN)
                 return ENAMETOOLONG;
-        
+
         ext4_node_t *parent = EXT4_NODE(pfn);
         ext4_node_t *child = EXT4_NODE(cfn);
         ext4_filesystem_t *fs = parent->instance->filesystem;
-        
+
         /* Add entry to parent directory */
         errno_t rc = ext4_directory_add_entry(parent->inode_ref, name,
@@ -552 +552 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Fill new dir -> add '.' and '..' entries */
         if (ext4_inode_is_type(fs->superblock, child->inode_ref->inode,
@@ -562 +562 @@
                         return rc;
                 }
-                
+
                 rc = ext4_directory_add_entry(child->inode_ref, "..",
                     parent->inode_ref);
@@ -570 +570 @@
                         return rc;
                 }
-                
+
                 /* Initialize directory index if supported */
                 if (ext4_superblock_has_feature_compatible(fs->superblock,
@@ -577 +577 @@
                         if (rc != EOK)
                                 return rc;
-                        
+
                         ext4_inode_set_flag(child->inode_ref->inode,
                             EXT4_INODE_FLAG_INDEX);
                         child->inode_ref->dirty = true;
                 }
-        
+
                 uint16_t parent_links =
                     ext4_inode_get_links_count(parent->inode_ref->inode);
                 parent_links++;
                 ext4_inode_set_links_count(parent->inode_ref->inode, parent_links);
-                
+
                 parent->inode_ref->dirty = true;
         }
-        
+
         uint16_t child_links =
             ext4_inode_get_links_count(child->inode_ref->inode);
         child_links++;
         ext4_inode_set_links_count(child->inode_ref->inode, child_links);
-        
+
         child->inode_ref->dirty = true;
-        
+
         return EOK;
 }
@@ -616 +616 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Cannot unlink non-empty node */
         if (has_children)
                 return ENOTEMPTY;
-        
+
         /* Remove entry from parent directory */
         ext4_inode_ref_t *parent = EXT4_NODE(pfn)->inode_ref;
@@ -626 +626 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Decrement links count */
         ext4_inode_ref_t *child_inode_ref = EXT4_NODE(cfn)->inode_ref;
-        
+
         uint32_t lnk_count =
             ext4_inode_get_links_count(child_inode_ref->inode);
         lnk_count--;
-        
+
         /* If directory - handle links from parent */
         if ((lnk_count <= 1) && (ext4_is_directory(cfn))) {
                 assert(lnk_count == 1);
-                
+
                 lnk_count--;
-                
+
                 ext4_inode_ref_t *parent_inode_ref = EXT4_NODE(pfn)->inode_ref;
-                
+
                 uint32_t parent_lnk_count = ext4_inode_get_links_count(
                     parent_inode_ref->inode);
-                
+
                 parent_lnk_count--;
                 ext4_inode_set_links_count(parent_inode_ref->inode, parent_lnk_count);
-                
+
                 parent->dirty = true;
         }
@@ -659 +659 @@
          * parent->dirty = true;
          */
-        
+
         /*
          * TODO: Update timestamp for inode.
@@ -666 +666 @@
          *     (uint32_t) now);
          */
-        
+
         ext4_inode_set_links_count(child_inode_ref->inode, lnk_count);
         child_inode_ref->dirty = true;
-        
+
         return EOK;
 }
@@ -687 +687 @@
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_filesystem_t *fs = enode->instance->filesystem;
-        
+
         /* Check if node is directory */
         if (!ext4_inode_is_type(fs->superblock, enode->inode_ref->inode,
@@ -694 +694 @@
                 return EOK;
         }
-        
+
         ext4_directory_iterator_t it;
         errno_t rc = ext4_directory_iterator_init(&it, enode->inode_ref, 0);
         if (rc != EOK)
                 return rc;
-        
+
         /* Find a non-empty directory entry */
         bool found = false;
@@ -712 +712 @@
                         }
                 }
-                
+
                 rc = ext4_directory_iterator_next(&it);
                 if (rc != EOK) {
@@ -719 +719 @@
                 }
         }
-        
+
         rc = ext4_directory_iterator_fini(&it);
         if (rc != EOK)
                 return rc;
-        
+
         *has_children = found;
-        
+
         return EOK;
 }
@@ -767 +767 @@
         ext4_node_t *enode = EXT4_NODE(fn);
         uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
-        
+
         if (ext4_is_directory(fn)) {
                 if (lnkcnt > 1)
@@ -774 +774 @@
                         return 0;
         }
-        
+
         /* For regular files return real links count */
         return lnkcnt;
@@ -790 +790 @@
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_superblock_t *sb = enode->instance->filesystem->superblock;
-        
+
         return ext4_inode_is_type(sb, enode->inode_ref->inode,
             EXT4_INODE_MODE_DIRECTORY);
@@ -806 +806 @@
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_superblock_t *sb = enode->instance->filesystem->superblock;
-        
+
         return ext4_inode_is_type(sb, enode->inode_ref->inode,
             EXT4_INODE_MODE_FILE);
@@ -928 +928 @@
 {
         ext4_filesystem_t *fs;
-        
+
         /* Allocate instance structure */
         ext4_instance_t *inst = (ext4_instance_t *)
@@ -934 +934 @@
         if (inst == NULL)
                 return ENOMEM;
-        
+
         enum cache_mode cmode;
         if (str_cmp(opts, "wtcache") == 0)
@@ -940 +940 @@
         else
                 cmode = CACHE_MODE_WB;
-        
+
         /* Initialize instance */
         link_initialize(&inst->link);
         inst->service_id = service_id;
         inst->open_nodes_count = 0;
-        
+
         /* Initialize the filesystem */
         aoff64_t rnsize;
@@ -953 +953 @@
                 return rc;
         }
-        
+
         /* Add instance to the list */
         fibril_mutex_lock(&instance_list_mutex);
         list_append(&inst->link, &instance_list);
         fibril_mutex_unlock(&instance_list_mutex);
-        
+
         *index = EXT4_INODE_ROOT_INDEX;
         *size = rnsize;
-        
+
         return EOK;
 }
@@ -980 +980 @@
         if (rc != EOK)
                 return rc;
-        
+
         fibril_mutex_lock(&open_nodes_lock);
-        
+
         if (inst->open_nodes_count != 0) {
                 fibril_mutex_unlock(&open_nodes_lock);
                 return EBUSY;
         }
-        
+
         /* Remove the instance from the list */
         fibril_mutex_lock(&instance_list_mutex);
         list_remove(&inst->link);
         fibril_mutex_unlock(&instance_list_mutex);
-        
+
         fibril_mutex_unlock(&open_nodes_lock);
-        
+
         rc = ext4_filesystem_close(inst->filesystem);
         if (rc != EOK) {
@@ -1028 +1028 @@
                 return EINVAL;
         }
-        
+
         ext4_instance_t *inst;
         errno_t rc = ext4_instance_get(service_id, &inst);
@@ -1035 +1035 @@
                 return rc;
         }
-        
+
         /* Load i-node */
         ext4_inode_ref_t *inode_ref;
@@ -1043 +1043 @@
                 return rc;
         }
-        
+
         /* Read from i-node by type */
         if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
@@ -1058 +1058 @@
                 rc = ENOTSUP;
         }
-        
+
         errno_t const rc2 = ext4_filesystem_put_inode_ref(inode_ref);
-        
+
         return rc == EOK ? rc2 : rc;
 }
@@ -1076 +1076 @@
         if ((name_size == 1) && (name[0] == '.'))
                 return true;
-        
+
         if ((name_size == 2) && (name[0] == '.') && (name[1] == '.'))
                 return true;
-        
+
         return false;
 }
@@ -1104 +1104 @@
                 return rc;
         }
-        
+
         /*
          * Find next interesting directory entry.
@@ -1114 +1114 @@
                 if (it.current->inode == 0)
                         goto skip;
-                
+
                 uint16_t name_size = ext4_directory_entry_ll_get_name_length(
                     inst->filesystem->superblock, it.current);
-                
+
                 /* Skip . and .. */
                 if (ext4_is_dots(it.current->name, name_size))
                         goto skip;
-                
+
                 /*
                  * The on-disk entry does not contain \0 at the end
@@ -1133 +1133 @@
                         return ENOMEM;
                 }
-                
+
                 memcpy(buf, &it.current->name, name_size);
                 *(buf + name_size) = 0;
                 found = true;
-                
+
                 (void) async_data_read_finalize(callid, buf, name_size + 1);
                 free(buf);
                 break;
-                
+
 skip:
                 rc = ext4_directory_iterator_next(&it);
@@ -1150 +1150 @@
                 }
         }
-        
+
         uint64_t next;
         if (found) {
@@ -1156 +1156 @@
                 if (rc != EOK)
                         return rc;
-                
+
                 next = it.current_offset;
         }
-        
+
         rc = ext4_directory_iterator_fini(&it);
         if (rc != EOK)
                 return rc;
-        
+
         /* Prepare return values */
         if (found) {
@@ -1191 +1191 @@
         ext4_superblock_t *sb = inst->filesystem->superblock;
         uint64_t file_size = ext4_inode_get_size(sb, inode_ref->inode);
-        
+
         if (pos >= file_size) {
                 /* Read 0 bytes successfully */
@@ -1198 +1198 @@
                 return EOK;
         }
-        
+
         /* For now, we only read data from one block at a time */
         uint32_t block_size = ext4_superblock_get_block_size(sb);
@@ -1204 +1204 @@
         uint32_t offset_in_block = pos % block_size;
         uint32_t bytes = min(block_size - offset_in_block, size);
-        
+
         /* Handle end of file */
         if (pos + bytes > file_size)
                 bytes = file_size - pos;
-        
+
         /* Get the real block number */
         uint32_t fs_block;
@@ -1217 +1217 @@
                 return rc;
         }
-        
+
         /*
          * Check for sparse file.
@@ -1231 +1231 @@
                         return ENOMEM;
                 }
-                
+
                 memset(buffer, 0, bytes);
-                
+
                 rc = async_data_read_finalize(callid, buffer, bytes);
                 *rbytes = bytes;
-                
+
                 free(buffer);
                 return rc;
         }
-        
+
         /* Usual case - we need to read a block from device */
         block_t *block;
@@ -1248 +1248 @@
                 return rc;
         }
-        
+
         assert(offset_in_block + bytes <= block_size);
         rc = async_data_read_finalize(callid, block->data + offset_in_block, bytes);
@@ -1255 +1255 @@
                 return rc;
         }
-        
+
         rc = block_put(block);
         if (rc != EOK)
                 return rc;
-        
+
         *rbytes = bytes;
         return EOK;
@@ -1282 +1282 @@
         if (rc != EOK)
                 return rc;
-        
+
         ipc_callid_t callid;
         size_t len;
@@ -1290 +1290 @@
                 goto exit;
         }
-        
+
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_filesystem_t *fs = enode->instance->filesystem;
-        
+
         uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
-        
+
         /* Prevent writing to more than one block */
         uint32_t bytes = min(len, block_size - (pos % block_size));
-        
+
         int flags = BLOCK_FLAGS_NONE;
         if (bytes == block_size)
                 flags = BLOCK_FLAGS_NOREAD;
-        
+
         uint32_t iblock =  pos / block_size;
         uint32_t fblock;
-        
+
         /* Load inode */
         ext4_inode_ref_t *inode_ref = enode->inode_ref;
@@ -1314 +1314 @@
                 goto exit;
         }
-        
+
         /* Check for sparse file */
         if (fblock == 0) {
@@ -1323 +1323 @@
                             ext4_inode_get_size(fs->superblock, inode_ref->inode) /
                             block_size;
-                        
+
                         while (last_iblock < iblock) {
                                 rc = ext4_extent_append_block(inode_ref, &last_iblock,
@@ -1332 +1332 @@
                                 }
                         }
-                        
+
                         rc = ext4_extent_append_block(inode_ref, &last_iblock,
                             &fblock, false);
@@ -1345 +1345 @@
                                 goto exit;
                         }
-                        
+
                         rc = ext4_filesystem_set_inode_data_block_index(inode_ref,
                             iblock, fblock);
@@ -1354 +1354 @@
                         }
                 }
-                
+
                 flags = BLOCK_FLAGS_NOREAD;
                 inode_ref->dirty = true;
         }
-        
+
         /* Load target block */
         block_t *write_block;
@@ -1366 +1366 @@
                 goto exit;
         }
-        
+
         if (flags == BLOCK_FLAGS_NOREAD)
                 memset(write_block->data, 0, block_size);
@@ -1419 +1419 @@
         if (rc != EOK)
                 return rc;
-        
+
         ext4_node_t *enode = EXT4_NODE(fn);
         ext4_inode_ref_t *inode_ref = enode->inode_ref;
-        
+
         rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
         errno_t const rc2 = ext4_node_put(fn);
-        
+
         return rc == EOK ? rc2 : rc;
 }
@@ -1456 +1456 @@
         if (rc != EOK)
                 return rc;
-        
+
         /* Destroy the inode */
         return ext4_destroy_node(fn);
@@ -1473 +1473 @@
         if (rc != EOK)
                 return rc;
-        
+
         ext4_node_t *enode = EXT4_NODE(fn);
         enode->inode_ref->dirty = true;
-        
+
         return ext4_node_put(fn);
 }

uspace/lib/ext4/src/superblock.c

@@ -241 +241 @@
         uint32_t log = 0;
         uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE;
-        
+
         tmp >>= 1;
         while (tmp) {
@@ -247 +247 @@
                 tmp >>= 1;
         }
-        
+
         ext4_superblock_set_log_block_size(sb, log);
 }
@@ -297 +297 @@
         uint32_t log = 0;
         uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE;
-        
+
         tmp >>= 1;
         while (tmp) {
@@ -303 +303 @@
                 tmp >>= 1;
         }
-        
+
         ext4_superblock_set_log_frag_size(sb, log);
 }
@@ -736 +736 @@
         if (ext4_superblock_get_rev_level(sb) == 0)
                 return EXT4_REV0_INODE_SIZE;
-        
+
         return uint16_t_le2host(sb->inode_size);
 }
@@ -1001 +1001 @@
 {
         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;
 }
@@ -1021 +1021 @@
                 sb->desc_size =
                     host2uint16_t_le(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE);
-        
+
         sb->desc_size = host2uint16_t_le(size);
 }
@@ -1064 +1064 @@
         if (ext4_superblock_get_flags(sb) & flag)
                 return true;
-        
+
         return false;
 }
@@ -1081 +1081 @@
         if (ext4_superblock_get_features_compatible(sb) & feature)
                 return true;
-        
+
         return false;
 }
@@ -1098 +1098 @@
         if (ext4_superblock_get_features_incompatible(sb) & feature)
                 return true;
-        
+
         return false;
 }
@@ -1115 +1115 @@
         if (ext4_superblock_get_features_read_only(sb) & feature)
                 return true;
-        
+
         return false;
 }
@@ -1133 +1133 @@
         if (data == NULL)
                 return ENOMEM;
-        
+
         /* Read data from block device */
         errno_t 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;
 }
@@ -1164 +1164 @@
         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);
@@ -1203 +1203 @@
         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;
 }
@@ -1244 +1244 @@
         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;
 }
@@ -1269 +1269 @@
         uint64_t total_blocks =
             ext4_superblock_get_blocks_count(sb);
-        
+
         if (bgid < block_group_count - 1)
                 return blocks_per_group;
@@ -1292 +1292 @@
         uint32_t total_inodes =
             ext4_superblock_get_inodes_count(sb);
-        
+
         if (bgid < block_group_count - 1)
                 return inodes_per_group;