Changeset a35b458 in mainline for uspace/lib/ext4/src/directory_index.c

Timestamp:

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

Author:

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

Branches:

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

Children:

f1380b7

Parents:

3061bc1

git-author:

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

git-committer:

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

Message:

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

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

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

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

File:

• uspace/lib/ext4/src/directory_index.c (modified) (62 diffs)

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;
 }