Changeset 8565a42 in mainline for uspace/lib/ext4/src

Timestamp:

2018-03-02T20:34:50Z (7 years ago)

Author:

GitHub <noreply@…>

Branches:

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

Children:

a1a81f69, d5e5fd1

Parents:

3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

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

git-committer:

GitHub <noreply@…> (2018-03-02 20:34:50)

Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:

uspace/lib/ext4/src

Files:

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

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;