Changeset d9bbe45 in mainline

Timestamp:

2012-01-22T13:22:56Z (12 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

fcae007

Parents:

b7e0260

Message:

Refafctorization - principle of locality in variables declaration

Location:

uspace/lib/ext4

Files:

• libext4_directory.c (modified) (6 diffs)
• libext4_directory_index.c (modified) (18 diffs)
• libext4_filesystem.c (modified) (28 diffs)
• libext4_ialloc.c (modified) (2 diffs)
• libext4_inode.c (modified) (3 diffs)
• libext4_superblock.c (modified) (3 diffs)

uspace/lib/ext4/libext4_directory.c

@@ -125 +125 @@
         int rc;
 
-        uint64_t size;
-        aoff64_t current_block_idx;
-        aoff64_t next_block_idx;
-        uint32_t next_block_phys_idx;
-        uint32_t block_size;
-
-        size = ext4_inode_get_size(it->fs->superblock, it->inode_ref->inode);
+        uint64_t size = ext4_inode_get_size(it->fs->superblock, it->inode_ref->inode);
 
         /* The iterator is not valid until we seek to the desired position */
@@ -150 +144 @@
         }
 
-        block_size = ext4_superblock_get_block_size(it->fs->superblock);
-        current_block_idx = it->current_offset / block_size;
-        next_block_idx = pos / block_size;
+        uint32_t block_size = ext4_superblock_get_block_size(it->fs->superblock);
+        aoff64_t current_block_idx = it->current_offset / block_size;
+        aoff64_t next_block_idx = pos / block_size;
 
         /* If we don't have a block or are moving accross block boundary,
@@ -166 +160 @@
                 }
 
+                uint32_t next_block_phys_idx;
                 rc = ext4_filesystem_get_inode_data_block_index(it->fs,
                     it->inode_ref->inode, next_block_idx, &next_block_phys_idx);
@@ -188 +183 @@
     uint32_t block_size)
 {
+
+        it->current = NULL;
+
         uint32_t offset_in_block = it->current_offset % block_size;
-
-        it->current = NULL;
 
         /* Ensure proper alignment */
@@ -439 +435 @@
 {
         int rc;
-        ext4_directory_iterator_t it;
 
         if (!ext4_inode_is_type(fs->superblock, parent->inode,
@@ -446 +441 @@
         }
 
+        ext4_directory_iterator_t it;
         rc = ext4_directory_iterator_init(&it, fs, parent, 0);
         if (rc != EOK) {

uspace/lib/ext4/libext4_directory_index.c

@@ -130 +130 @@
                 ext4_superblock_t *sb, size_t name_len, const char *name)
 {
-        uint32_t block_size, entry_space;
-        uint16_t limit;
-        ext4_directory_dx_root_t *root;
-
-        root = (ext4_directory_dx_root_t *)root_block->data;
+
+        ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data;
 
         if (root->info.hash_version != EXT4_HASH_VERSION_TEA &&
@@ -154 +151 @@
         }
 
-        block_size = ext4_superblock_get_block_size(sb);
-
-        entry_space = block_size;
+        uint32_t block_size = ext4_superblock_get_block_size(sb);
+
+        uint32_t entry_space = block_size;
         entry_space -= 2 * sizeof(ext4_directory_dx_dot_entry_t);
         entry_space -= sizeof(ext4_directory_dx_root_info_t);
     entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
 
-    limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)&root->entries);
+    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;
@@ -187 +184 @@
 {
         int rc;
-        uint16_t count, limit, entry_space;
-        uint8_t indirect_level;
-        ext4_directory_dx_root_t *root;
+
+        ext4_directory_dx_block_t *tmp_dx_block = dx_blocks;
+
+        ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data;
+        ext4_directory_dx_entry_t *entries = (ext4_directory_dx_entry_t *)&root->entries;
+
+        uint16_t limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
+        uint8_t indirect_level = ext4_directory_dx_root_info_get_indirect_levels(&root->info);
+
+        block_t *tmp_block = root_block;
         ext4_directory_dx_entry_t *p, *q, *m, *at;
-        ext4_directory_dx_entry_t *entries;
-        block_t *tmp_block = root_block;
-        uint32_t fblock, next_block;
-        ext4_directory_dx_block_t *tmp_dx_block = dx_blocks;
-
-        root = (ext4_directory_dx_root_t *)root_block->data;
-        entries = (ext4_directory_dx_entry_t *)&root->entries;
-
-        limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
-        indirect_level = ext4_directory_dx_root_info_get_indirect_levels(&root->info);
-
         while (true) {
 
-                count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)entries);
+                uint16_t count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)entries);
                 if ((count == 0) || (count > limit)) {
                         return EXT4_ERR_BAD_DX_DIR;
@@ -232 +225 @@
         }
 
-                next_block = ext4_directory_dx_entry_get_block(at);
+                uint32_t next_block = ext4_directory_dx_entry_get_block(at);
 
         indirect_level--;
 
+        uint32_t fblock;
         rc = ext4_filesystem_get_inode_data_block_index(fs, inode, next_block, &fblock);
         if (rc != EOK) {
@@ -249 +243 @@
                 limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
 
-        entry_space = ext4_superblock_get_block_size(fs->superblock) - sizeof(ext4_directory_dx_dot_entry_t);
+        uint16_t entry_space = ext4_superblock_get_block_size(fs->superblock)
+                        - sizeof(ext4_directory_dx_dot_entry_t);
         entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
 
@@ -266 +261 @@
 
 
-static int ext4_dirextory_dx_find_dir_entry(block_t *block,
+static int ext4_directory_dx_find_dir_entry(block_t *block,
                 ext4_superblock_t *sb, size_t name_len, const char *name,
                 ext4_directory_entry_ll_t **res_entry, aoff64_t *block_offset)
 {
-        ext4_directory_entry_ll_t *dentry;
-        uint16_t dentry_len;
-        uint8_t *addr_limit;
+
         aoff64_t offset = 0;
-
-        dentry = (ext4_directory_entry_ll_t *)block->data;
-        addr_limit = block->data + ext4_superblock_get_block_size(sb);
+        ext4_directory_entry_ll_t *dentry = (ext4_directory_entry_ll_t *)block->data;
+        uint8_t *addr_limit = block->data + ext4_superblock_get_block_size(sb);
 
         while ((uint8_t *)dentry < addr_limit) {
@@ -297 +289 @@
 
                 // Goto next entry
-                dentry_len = ext4_directory_entry_ll_get_entry_length(dentry);
+                uint16_t dentry_len = ext4_directory_entry_ll_get_entry_length(dentry);
 
         if (dentry_len == 0) {
@@ -314 +306 @@
                 ext4_directory_dx_block_t *handle, ext4_directory_dx_block_t *handles)
 {
-        ext4_directory_dx_block_t *p;
-        uint16_t count;
-        uint32_t num_handles;
-        uint32_t current_hash;
-        block_t *block;
-        uint32_t block_addr, block_idx;
-    int rc;
-
-    num_handles = 0;
-    p = handle;
+        int rc;
+
+
+    uint32_t num_handles = 0;
+    ext4_directory_dx_block_t *p = handle;
 
     while (1) {
 
         p->position++;
-        count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)p->entries);
+        uint16_t count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)p->entries);
 
         if (p->position < p->entries + count) {
@@ -342 +329 @@
     }
 
-    current_hash = ext4_directory_dx_entry_get_hash(p->position);
+    uint32_t current_hash = ext4_directory_dx_entry_get_hash(p->position);
 
     if ((hash & 1) == 0) {
@@ -350 +337 @@
     }
 
+
     while (num_handles--) {
 
-        block_idx = ext4_directory_dx_entry_get_block(p->position);
+        uint32_t block_idx = ext4_directory_dx_entry_get_block(p->position);
+        uint32_t block_addr;
         rc = ext4_filesystem_get_inode_data_block_index(fs, inode, block_idx, &block_addr);
         if (rc != EOK) {
@@ -358 +347 @@
         }
 
+        block_t *block;
         rc = block_get(&block, fs->device, block_addr, BLOCK_FLAGS_NONE);
         if (rc != EOK) {
@@ -379 +369 @@
 {
         int rc;
-        uint32_t root_block_addr, leaf_block_addr, leaf_block_idx;
-        aoff64_t block_offset;
-        block_t *root_block, *leaf_block;
-        ext4_hash_info_t hinfo;
-        ext4_directory_entry_ll_t *res_dentry;
-        ext4_directory_dx_block_t dx_blocks[2], *dx_block;
 
         // get direct block 0 (index root)
+        uint32_t root_block_addr;
         rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, 0, &root_block_addr);
         if (rc != EOK) {
@@ -392 +377 @@
         }
 
+        block_t *root_block;
         rc = block_get(&root_block, fs->device, root_block_addr, BLOCK_FLAGS_NONE);
         if (rc != EOK) {
@@ -398 +384 @@
         }
 
+        ext4_hash_info_t hinfo;
         rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, len, name);
         if (rc != EOK) {
@@ -404 +391 @@
         }
 
+        ext4_directory_dx_block_t dx_blocks[2];
+        ext4_directory_dx_block_t *dx_block;
         rc = ext4_directory_dx_get_leaf(&hinfo, fs, inode_ref->inode, root_block, &dx_block, dx_blocks);
         if (rc != EOK) {
@@ -410 +399 @@
         }
 
+
         do {
 
-                leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position);
-
+                uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position);
+                uint32_t leaf_block_addr;
         rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, leaf_block_idx, &leaf_block_addr);
         if (rc != EOK) {
@@ -419 +409 @@
         }
 
+        block_t *leaf_block;
                 rc = block_get(&leaf_block, fs->device, leaf_block_addr, BLOCK_FLAGS_NONE);
                 if (rc != EOK) {
@@ -424 +415 @@
                 }
 
-                rc = ext4_dirextory_dx_find_dir_entry(leaf_block, fs->superblock, len, name,
+                aoff64_t block_offset;
+                ext4_directory_entry_ll_t *res_dentry;
+                rc = ext4_directory_dx_find_dir_entry(leaf_block, fs->superblock, len, name,
                                 &res_dentry, &block_offset);
 

uspace/lib/ext4/libext4_filesystem.c

@@ -44 +44 @@
 {
         int rc;
-        ext4_superblock_t *temp_superblock;
-        size_t block_size;
-        uint32_t block_ids_per_block;
-        int i;
 
         fs->device = service_id;
@@ -58 +54 @@
 
         /* Read superblock from device */
+        ext4_superblock_t *temp_superblock;
         rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
         if (rc != EOK) {
@@ -65 +62 @@
 
         /* Read block size from superblock and check */
-        block_size = ext4_superblock_get_block_size(temp_superblock);
+        uint32_t block_size = ext4_superblock_get_block_size(temp_superblock);
         if (block_size > EXT4_MAX_BLOCK_SIZE) {
                 block_fini(fs->device);
@@ -78 +75 @@
         }
 
-        block_ids_per_block = block_size / sizeof(uint32_t);
+        uint32_t block_ids_per_block = block_size / sizeof(uint32_t);
         fs->inode_block_limits[0] = EXT4_INODE_DIRECT_BLOCK_COUNT;
         fs->inode_blocks_per_level[0] = 1;
-        for (i = 1; i < 4; i++) {
+        for (int i = 1; i < 4; i++) {
                 fs->inode_blocks_per_level[i] = fs->inode_blocks_per_level[i-1] *
                     block_ids_per_block;
@@ -97 +94 @@
 {
         int rc = EOK;
+
         if (write_sb) {
                 rc = ext4_superblock_write_direct(fs->device, fs->superblock);
@@ -149 +147 @@
 {
         int rc;
-        aoff64_t block_id;
-        uint32_t descriptors_per_block;
-        size_t offset;
-        ext4_block_group_ref_t *newref;
-
-        newref = malloc(sizeof(ext4_block_group_ref_t));
+
+        ext4_block_group_ref_t *newref = malloc(sizeof(ext4_block_group_ref_t));
         if (newref == NULL) {
                 return ENOMEM;
         }
 
-        descriptors_per_block = ext4_superblock_get_block_size(fs->superblock)
+        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 */
-        block_id = ext4_superblock_get_first_data_block(fs->superblock) + 1;
+        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;
-        offset = (bgid % descriptors_per_block) * ext4_superblock_get_desc_size(fs->superblock);
+        uint32_t offset = (bgid % descriptors_per_block) * ext4_superblock_get_desc_size(fs->superblock);
 
         rc = block_get(&newref->block, fs->device, block_id, 0);
@@ -201 +195 @@
 {
         int rc;
-        aoff64_t block_id;
-        uint32_t block_group;
-        uint32_t offset_in_group;
-        uint32_t byte_offset_in_group;
-        size_t offset_in_block;
-        uint32_t inodes_per_group;
-        uint32_t inode_table_start;
-        uint16_t inode_size;
-        uint32_t block_size;
-        ext4_block_group_ref_t *bg_ref;
-        ext4_inode_ref_t *newref;
-
-        newref = malloc(sizeof(ext4_inode_ref_t));
+
+        ext4_inode_ref_t *newref = malloc(sizeof(ext4_inode_ref_t));
         if (newref == NULL) {
                 return ENOMEM;
         }
 
-        inodes_per_group = ext4_superblock_get_inodes_per_group(fs->superblock);
+        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
@@ -224 +208 @@
          */
         index -= 1;
-        block_group = index / inodes_per_group;
-        offset_in_group = index % inodes_per_group;
-
+        uint32_t block_group = index / inodes_per_group;
+        uint32_t offset_in_group = index % inodes_per_group;
+
+        ext4_block_group_ref_t *bg_ref;
         rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
         if (rc != EOK) {
@@ -233 +218 @@
         }
 
-        inode_table_start = ext4_block_group_get_inode_table_first_block(
+        uint32_t inode_table_start = ext4_block_group_get_inode_table_first_block(
             bg_ref->block_group, fs->superblock);
 
@@ -242 +227 @@
         }
 
-        inode_size = ext4_superblock_get_inode_size(fs->superblock);
-        block_size = ext4_superblock_get_block_size(fs->superblock);
-
-        byte_offset_in_group = offset_in_group * inode_size;
-
-        block_id = inode_table_start + (byte_offset_in_group / block_size);
-        offset_in_block = byte_offset_in_group % block_size;
-
+        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;
+
+        aoff64_t block_id = inode_table_start + (byte_offset_in_group / block_size);
         rc = block_get(&newref->block, fs->device, block_id, 0);
         if (rc != EOK) {
@@ -256 +238 @@
         }
 
+        uint32_t offset_in_block = byte_offset_in_group % block_size;
         newref->inode = newref->block->data + offset_in_block;
         /* we decremented index above, but need to store the original value
@@ -322 +305 @@
 {
         int rc;
+
         // release all indirect blocks
 
-        uint32_t fblock;
-
         // 1) Single indirect
-        fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
+        uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
         if (fblock != 0) {
                 rc = ext4_balloc_free_block(fs, inode_ref, fblock);
@@ -437 +419 @@
                 ext4_inode_ref_t *inode_ref, aoff64_t new_size)
 {
-        aoff64_t old_size;
-        aoff64_t size_diff;
-
         if (! ext4_inode_can_truncate(fs->superblock, inode_ref->inode)) {
                 // Unable to truncate
@@ -445 +424 @@
         }
 
-        old_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
-
+        aoff64_t old_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
         if (old_size == new_size) {
                 // Nothing to do
                 return EOK;
         }
-
-        uint32_t block_size;
-        uint32_t blocks_count, total_blocks;
-        uint32_t i;
-
-        block_size  = ext4_superblock_get_block_size(fs->superblock);
 
         if (old_size < new_size) {
@@ -465 +437 @@
         }
 
-        size_diff = old_size - new_size;
-        blocks_count = size_diff / block_size;
+        aoff64_t size_diff = old_size - new_size;
+        uint32_t block_size  = ext4_superblock_get_block_size(fs->superblock);
+        uint32_t blocks_count = size_diff / block_size;
         if (size_diff % block_size != 0) {
                 blocks_count++;
         }
 
-        total_blocks = old_size / block_size;
+        uint32_t total_blocks = old_size / block_size;
         if (old_size % block_size != 0) {
                 total_blocks++;
@@ -477 +450 @@
 
         // starting from 1 because of logical blocks are numbered from 0
-        for (i = 1; i <= blocks_count; ++i) {
+        for (uint32_t i = 1; i <= blocks_count; ++i) {
                 // TODO check retval
                 ext4_filesystem_release_inode_block(fs, inode_ref, total_blocks - i);
@@ -493 +466 @@
 {
         int rc;
-        uint32_t offset_in_block;
+
+
         uint32_t current_block;
-        aoff64_t block_offset_in_level;
-        int i;
-        int level;
-        block_t *block;
 
         /* Handle inode using extents */
@@ -517 +487 @@
 
         /* Determine the indirection level needed to get the desired block */
-        level = -1;
-        for (i = 1; i < 4; i++) {
+        int level = -1;
+        for (int i = 1; i < 4; i++) {
                 if (iblock < fs->inode_block_limits[i]) {
                         level = i;
@@ -530 +500 @@
 
         /* Compute offsets for the topmost level */
-        block_offset_in_level = iblock - fs->inode_block_limits[level-1];
+        aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
         current_block = ext4_inode_get_indirect_block(inode, level-1);
-        offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+        uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
 
         if (current_block == 0) {
@@ -538 +508 @@
                 return EOK;
         }
+
+        block_t *block;
 
         /* Navigate through other levels, until we find the block number
@@ -584 +556 @@
                 ext4_inode_ref_t *inode_ref, aoff64_t iblock, uint32_t fblock)
 {
-
-        int rc;
-        uint32_t offset_in_block;
-        uint32_t current_block, new_block_addr;
-        uint32_t block_size;
-        aoff64_t block_offset_in_level;
-        int i;
-        int level;
-        block_t *block, *new_block;
+        int rc;
+
 
         /* Handle inode using extents */
@@ -609 +574 @@
 
         /* Determine the indirection level needed to get the desired block */
-        level = -1;
-        for (i = 1; i < 4; i++) {
+        int level = -1;
+        for (int i = 1; i < 4; i++) {
                 if (iblock < fs->inode_block_limits[i]) {
                         level = i;
@@ -621 +586 @@
         }
 
-        block_size = ext4_superblock_get_block_size(fs->superblock);
+
+
+        uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
 
         /* Compute offsets for the topmost level */
-        block_offset_in_level = iblock - fs->inode_block_limits[level-1];
-        current_block = ext4_inode_get_indirect_block(inode_ref->inode, level-1);
-        offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+        aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
+        uint32_t current_block = ext4_inode_get_indirect_block(inode_ref->inode, level-1);
+        uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+
+        uint32_t new_block_addr;
+        block_t *block, *new_block;
 
         if (current_block == 0) {
@@ -634 +604 @@
                         EXT4FS_DBG("error in allocation");
                 }
-//              EXT4FS_DBG("AAA: new addr \%u, level = \%u", new_block_addr, level);
 
                 ext4_inode_set_indirect_block(inode_ref->inode, level - 1, new_block_addr);
@@ -677 +646 @@
                                 EXT4FS_DBG("allocation error");
                         }
-//                      EXT4FS_DBG("BBB: new addr \%u, offset = \%u, level = \%u", new_block_addr, offset_in_block, level);
 
                         rc = block_get(&new_block, fs->device, new_block_addr, BLOCK_FLAGS_NOREAD);
@@ -730 +698 @@
 {
         int rc;
+
+
+        /* TODO handle extents */
+
+
         uint32_t fblock;
-        int i;
-        int level;
-        aoff64_t block_offset_in_level;
-        uint32_t current_block;
-        uint32_t offset_in_block;
-        block_t *block;
         ext4_inode_t *inode = inode_ref->inode;
-
-        /* TODO handle extents */
-
 
         /* Handle simple case when we are dealing with direct reference */
@@ -756 +720 @@
 
         /* Determine the indirection level needed to get the desired block */
-        level = -1;
-        for (i = 1; i < 4; i++) {
+        int level = -1;
+        for (int i = 1; i < 4; i++) {
                 if (iblock < fs->inode_block_limits[i]) {
                         level = i;
@@ -769 +733 @@
 
         /* Compute offsets for the topmost level */
-        block_offset_in_level = iblock - fs->inode_block_limits[level-1];
-        current_block = ext4_inode_get_indirect_block(inode, level-1);
-        offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+        aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
+        uint32_t current_block = ext4_inode_get_indirect_block(inode, level-1);
+        uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
 
         /* Navigate through other levels, until we find the block number
          * or find null reference meaning we are dealing with sparse file
          */
+        block_t *block;
         while (level > 0) {
                 rc = block_get(&block, fs->device, current_block, 0);

uspace/lib/ext4/libext4_ialloc.c

@@ -59 +59 @@
 {
         int rc;
+
         uint32_t block_group = ext4_ialloc_get_bgid_of_inode(
-                        fs->superblock, inode_ref->index);
-        uint32_t index_in_group = ext4_ialloc_inode2index_in_group(
                         fs->superblock, inode_ref->index);
 
@@ -80 +79 @@
         }
 
+        uint32_t index_in_group = ext4_ialloc_inode2index_in_group(
+                                fs->superblock, inode_ref->index);
         ext4_bitmap_free_bit(bitmap_block->data, index_in_group);
         bitmap_block->dirty = true;

uspace/lib/ext4/libext4_inode.c

@@ -160 +160 @@
 uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode)
 {
-        uint64_t count;
-
         if (ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
 
                 /* 48-bit field */
-                count = ((uint64_t)uint16_t_le2host(inode->osd2.linux2.blocks_high)) << 32 |
+                uint64_t count = ((uint64_t)uint16_t_le2host(inode->osd2.linux2.blocks_high)) << 32 |
                                 uint32_t_le2host(inode->blocks_count_lo);
 
@@ -283 +281 @@
 uint32_t ext4_inode_get_extent_block(ext4_inode_t *inode, uint64_t idx, service_id_t service_id)
 {
+        int rc;
+
+        block_t* block = NULL;
+
         ext4_extent_header_t *header = ext4_inode_get_extent_header(inode);
-        ext4_extent_t *extent;
-        ext4_extent_index_t *extent_index;
-
-        uint32_t first_block;
-        uint16_t block_count;
-        uint64_t phys_block = 0;
-        uint64_t child;
-
-        int rc;
-        block_t* block = NULL;
-
         while (ext4_extent_header_get_depth(header) != 0) {
 
-                extent_index = EXT4_EXTENT_FIRST_INDEX(header);
+                ext4_extent_index_t *extent_index = EXT4_EXTENT_FIRST_INDEX(header);
 
                 for (uint16_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i) {
-                        if(idx >= ext4_extent_index_get_first_block(extent_index)) {
-
-                                child = ext4_extent_index_get_leaf(extent_index);
+                        if (idx >= ext4_extent_index_get_first_block(extent_index)) {
+
+                                uint64_t child = ext4_extent_index_get_leaf(extent_index);
 
                                 if (block != NULL) {
@@ -319 +310 @@
         }
 
-        extent = EXT4_EXTENT_FIRST(header);
+        ext4_extent_t *extent = EXT4_EXTENT_FIRST(header);
+        uint64_t phys_block = 0;
 
         for (uint16_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i) {
 
-                first_block = ext4_extent_get_first_block(extent);
-                block_count = ext4_extent_get_block_count(extent);
+                uint32_t first_block = ext4_extent_get_first_block(extent);
+                uint16_t block_count = ext4_extent_get_block_count(extent);
 
                 if ((idx >= first_block) && (idx < first_block + block_count)) {
-                        phys_block = ext4_extent_get_start(extent) + idx;
-                        phys_block -= ext4_extent_get_first_block(extent);
-
-                        // Memory leak prevention
-                        if (block != NULL) {
-                                block_put(block);
-                        }
-                        return phys_block;
+                         phys_block = ext4_extent_get_start(extent) + idx;
+                         phys_block -= ext4_extent_get_first_block(extent);
+
+                         // Memory leak prevention
+                         if (block != NULL) {
+                                 block_put(block);
+                         }
+                         return phys_block;
                 }
                 // Go to the next extent

uspace/lib/ext4/libext4_superblock.c

@@ -437 +437 @@
     ext4_superblock_t **superblock)
 {
-        void *data;
         int rc;
 
-        data = malloc(EXT4_SUPERBLOCK_SIZE);
+        void *data = malloc(EXT4_SUPERBLOCK_SIZE);
         if (data == NULL) {
                 return ENOMEM;
@@ -463 +462 @@
         int rc;
         uint32_t phys_block_size;
-        uint64_t first_block;
-        uint32_t block_count;
 
         rc = block_get_bsize(service_id, &phys_block_size);
@@ -472 +469 @@
         }
 
-        first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size;
-        block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size;
+        uint64_t first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size;
+        uint32_t block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size;
 
         if (EXT4_SUPERBLOCK_SIZE % phys_block_size) {