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

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.

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