From 2fb30affc7ff103995524c1ffbbd8db53ff42c8f Mon Sep 17 00:00:00 2001 From: gkostka Date: Tue, 16 Jun 2015 10:03:39 +0100 Subject: [PATCH] clang-format: ext4_dir --- lwext4/ext4_dir.c | 160 +++++++++++++++++++++------------------------- 1 file changed, 72 insertions(+), 88 deletions(-) diff --git a/lwext4/ext4_dir.c b/lwext4/ext4_dir.c index eabfa8d..cb15299 100644 --- a/lwext4/ext4_dir.c +++ b/lwext4/ext4_dir.c @@ -47,8 +47,6 @@ #include - - /****************************************************************************/ /**@brief Do some checks before returning iterator. @@ -57,7 +55,7 @@ * @return Error code */ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it, - uint32_t block_size) + uint32_t block_size) { it->current = NULL; @@ -72,7 +70,7 @@ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it, return EIO; struct ext4_directory_entry_ll *entry = - (void *)(it->current_block.data + offset_in_block); + (void *)(it->current_block.data + offset_in_block); /* Ensure that the whole entry does not overflow the block */ uint16_t length = ext4_dir_entry_ll_get_entry_length(entry); @@ -80,8 +78,8 @@ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it, return EIO; /* Ensure the name length is not too large */ - if (ext4_dir_entry_ll_get_name_length( - &it->inode_ref->fs->sb, entry) > length-8) + if (ext4_dir_entry_ll_get_name_length(&it->inode_ref->fs->sb, entry) > + length - 8) return EIO; /* Everything OK - "publish" the entry */ @@ -96,10 +94,10 @@ static int ext4_dir_iterator_set(struct ext4_directory_iterator *it, * @return Error code */ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, - uint64_t pos) + uint64_t pos) { - uint64_t size = ext4_inode_get_size(&it->inode_ref->fs->sb, - it->inode_ref->inode); + uint64_t size = + ext4_inode_get_size(&it->inode_ref->fs->sb, it->inode_ref->inode); /* The iterator is not valid until we seek to the desired position */ it->current = NULL; @@ -108,8 +106,8 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, if (pos >= size) { if (it->current_block.lb_id) { - int rc = ext4_block_set(it->inode_ref->fs->bdev, - &it->current_block); + int rc = + ext4_block_set(it->inode_ref->fs->bdev, &it->current_block); it->current_block.lb_id = 0; if (rc != EOK) @@ -121,8 +119,7 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, } /* Compute next block address */ - uint32_t block_size = - ext4_sb_get_block_size(&it->inode_ref->fs->sb); + uint32_t block_size = ext4_sb_get_block_size(&it->inode_ref->fs->sb); uint64_t current_block_idx = it->current_offset / block_size; uint64_t next_block_idx = pos / block_size; @@ -131,9 +128,10 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, * we need to get another block */ if ((it->current_block.lb_id == 0) || - (current_block_idx != next_block_idx)) { + (current_block_idx != next_block_idx)) { if (it->current_block.lb_id) { - int rc = ext4_block_set(it->inode_ref->fs->bdev, &it->current_block); + int rc = + ext4_block_set(it->inode_ref->fs->bdev, &it->current_block); it->current_block.lb_id = 0; if (rc != EOK) @@ -141,14 +139,13 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, } uint32_t next_block_phys_idx; - int rc = ext4_fs_get_inode_data_block_index(it->inode_ref, - next_block_idx, &next_block_phys_idx); + int rc = ext4_fs_get_inode_data_block_index( + it->inode_ref, next_block_idx, &next_block_phys_idx); if (rc != EOK) return rc; - rc = ext4_block_get(it->inode_ref->fs->bdev, &it->current_block, - next_block_phys_idx); + next_block_phys_idx); if (rc != EOK) { it->current_block.lb_id = 0; return rc; @@ -160,9 +157,8 @@ static int ext4_dir_iterator_seek(struct ext4_directory_iterator *it, return ext4_dir_iterator_set(it, block_size); } - int ext4_dir_iterator_init(struct ext4_directory_iterator *it, - struct ext4_inode_ref *inode_ref, uint64_t pos) + struct ext4_inode_ref *inode_ref, uint64_t pos) { it->inode_ref = inode_ref; it->current = 0; @@ -177,14 +173,14 @@ int ext4_dir_iterator_next(struct ext4_directory_iterator *it) int r = EOK; uint16_t skip; - while(r == EOK){ + while (r == EOK) { skip = ext4_dir_entry_ll_get_entry_length(it->current); r = ext4_dir_iterator_seek(it, it->current_offset + skip); - if(!it->current) + if (!it->current) break; /*Skip NULL referenced entry*/ - if(it->current->inode != 0) + if (it->current->inode != 0) break; } @@ -202,8 +198,9 @@ int ext4_dir_iterator_fini(struct ext4_directory_iterator *it) } void ext4_dir_write_entry(struct ext4_sblock *sb, - struct ext4_directory_entry_ll *entry, uint16_t entry_len, - struct ext4_inode_ref *child, const char *name, size_t name_len) + struct ext4_directory_entry_ll *entry, + uint16_t entry_len, struct ext4_inode_ref *child, + const char *name, size_t name_len) { /* Check maximum entry length */ ext4_assert(entry_len <= ext4_sb_get_block_size(sb)); @@ -219,22 +216,22 @@ void ext4_dir_write_entry(struct ext4_sblock *sb, /* Set type of entry */ if (ext4_inode_is_type(sb, child->inode, EXT4_INODE_MODE_DIRECTORY)) ext4_dir_entry_ll_set_inode_type(sb, entry, - EXT4_DIRECTORY_FILETYPE_DIR); + EXT4_DIRECTORY_FILETYPE_DIR); else ext4_dir_entry_ll_set_inode_type(sb, entry, - EXT4_DIRECTORY_FILETYPE_REG_FILE); + EXT4_DIRECTORY_FILETYPE_REG_FILE); } int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name, - uint32_t name_len, struct ext4_inode_ref *child) + uint32_t name_len, struct ext4_inode_ref *child) { struct ext4_fs *fs = parent->fs; #if CONFIG_DIR_INDEX_ENABLE /* Index adding (if allowed) */ if ((ext4_sb_has_feature_compatible(&fs->sb, - EXT4_FEATURE_COMPAT_DIR_INDEX)) && - (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) { + EXT4_FEATURE_COMPAT_DIR_INDEX)) && + (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) { int rc = ext4_dir_dx_add_entry(parent, child, name); /* Check if index is not corrupted */ @@ -258,24 +255,20 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name, uint32_t inode_size = ext4_inode_get_size(&fs->sb, parent->inode); uint32_t total_blocks = inode_size / block_size; - /* Find block, where is space for new entry and try to add */ bool success = false; for (iblock = 0; iblock < total_blocks; ++iblock) { - int rc = ext4_fs_get_inode_data_block_index(parent, - iblock, &fblock); + int rc = ext4_fs_get_inode_data_block_index(parent, iblock, &fblock); if (rc != EOK) return rc; - struct ext4_block block; rc = ext4_block_get(fs->bdev, &block, fblock); if (rc != EOK) return rc; /* If adding is successful, function can finish */ - rc = ext4_dir_try_insert_entry(&fs->sb, &block, - child, name, name_len); + rc = ext4_dir_try_insert_entry(&fs->sb, &block, child, name, name_len); if (rc == EOK) success = true; @@ -305,8 +298,8 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name, /* Fill block with zeroes */ memset(new_block.data, 0, block_size); struct ext4_directory_entry_ll *block_entry = (void *)new_block.data; - ext4_dir_write_entry(&fs->sb, block_entry, block_size, - child, name, name_len); + ext4_dir_write_entry(&fs->sb, block_entry, block_size, child, name, + name_len); /* Save new block */ new_block.dirty = true; @@ -316,18 +309,16 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name, } int ext4_dir_find_entry(struct ext4_directory_search_result *result, - struct ext4_inode_ref *parent, const char *name, uint32_t name_len) + struct ext4_inode_ref *parent, const char *name, + uint32_t name_len) { struct ext4_sblock *sb = &parent->fs->sb; - #if CONFIG_DIR_INDEX_ENABLE /* Index search */ - if ((ext4_sb_has_feature_compatible(sb, - EXT4_FEATURE_COMPAT_DIR_INDEX)) && - (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) { - int rc = ext4_dir_dx_find_entry(result, parent, name_len, - name); + if ((ext4_sb_has_feature_compatible(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) && + (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) { + int rc = ext4_dir_dx_find_entry(result, parent, name_len, name); /* Check if index is not corrupted */ if (rc != EXT4_ERR_BAD_DX_DIR) { @@ -354,21 +345,19 @@ int ext4_dir_find_entry(struct ext4_directory_search_result *result, /* Walk through all data blocks */ for (iblock = 0; iblock < total_blocks; ++iblock) { /* Load block address */ - int rc = ext4_fs_get_inode_data_block_index(parent, iblock, - &fblock); + int rc = ext4_fs_get_inode_data_block_index(parent, iblock, &fblock); if (rc != EOK) return rc; /* Load data block */ struct ext4_block block; - rc = ext4_block_get( parent->fs->bdev, &block, fblock); + rc = ext4_block_get(parent->fs->bdev, &block, fblock); if (rc != EOK) return rc; /* Try to find entry in block */ struct ext4_directory_entry_ll *res_entry; - rc = ext4_dir_find_in_block(&block, sb, name_len, name, - &res_entry); + rc = ext4_dir_find_in_block(&block, sb, name_len, name, &res_entry); if (rc == EOK) { result->block = block; result->dentry = res_entry; @@ -391,11 +380,11 @@ int ext4_dir_find_entry(struct ext4_directory_search_result *result, } int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name, - uint32_t name_len) + uint32_t name_len) { /* Check if removing from directory */ if (!ext4_inode_is_type(&parent->fs->sb, parent->inode, - EXT4_INODE_MODE_DIRECTORY)) + EXT4_INODE_MODE_DIRECTORY)) return ENOTDIR; /* Try to find entry */ @@ -408,7 +397,7 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name, ext4_dir_entry_ll_set_inode(result.dentry, 0); /* Store entry position in block */ - uint32_t pos = (uint8_t *) result.dentry - result.block.data; + uint32_t pos = (uint8_t *)result.dentry - result.block.data; /* * If entry is not the first in block, it must be merged @@ -420,24 +409,22 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name, /* Start from the first entry in block */ struct ext4_directory_entry_ll *tmp_dentry = (void *)result.block.data; uint16_t tmp_dentry_length = - ext4_dir_entry_ll_get_entry_length(tmp_dentry); + ext4_dir_entry_ll_get_entry_length(tmp_dentry); /* Find direct predecessor of removed entry */ while ((offset + tmp_dentry_length) < pos) { - offset += - ext4_dir_entry_ll_get_entry_length(tmp_dentry); + offset += ext4_dir_entry_ll_get_entry_length(tmp_dentry); tmp_dentry = (void *)(result.block.data + offset); - tmp_dentry_length = - ext4_dir_entry_ll_get_entry_length(tmp_dentry); + tmp_dentry_length = ext4_dir_entry_ll_get_entry_length(tmp_dentry); } ext4_assert(tmp_dentry_length + offset == pos); /* Add to removed entry length to predecessor's length */ uint16_t del_entry_length = - ext4_dir_entry_ll_get_entry_length(result.dentry); - ext4_dir_entry_ll_set_entry_length(tmp_dentry, - tmp_dentry_length + del_entry_length); + ext4_dir_entry_ll_get_entry_length(result.dentry); + ext4_dir_entry_ll_set_entry_length(tmp_dentry, tmp_dentry_length + + del_entry_length); } result.block.dirty = true; @@ -446,8 +433,9 @@ int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name, } int ext4_dir_try_insert_entry(struct ext4_sblock *sb, - struct ext4_block *target_block, struct ext4_inode_ref *child, - const char *name, uint32_t name_len) + struct ext4_block *target_block, + struct ext4_inode_ref *child, const char *name, + uint32_t name_len) { /* Compute required length entry and align it to 4 bytes */ uint32_t block_size = ext4_sb_get_block_size(sb); @@ -457,9 +445,9 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb, required_len += 4 - (required_len % 4); /* Initialize pointers, stop means to upper bound */ - struct ext4_directory_entry_ll *dentry = (void *)target_block->data; + struct ext4_directory_entry_ll *dentry = (void *)target_block->data; struct ext4_directory_entry_ll *stop = - (void *)(target_block->data + block_size); + (void *)(target_block->data + block_size); /* * Walk through the block and check for invalid entries @@ -471,8 +459,7 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb, /* If invalid and large enough entry, use it */ if ((inode == 0) && (rec_len >= required_len)) { - ext4_dir_write_entry(sb, dentry, rec_len, child, - name, name_len); + ext4_dir_write_entry(sb, dentry, rec_len, child, name, name_len); target_block->dirty = true; return EOK; @@ -481,10 +468,10 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb, /* Valid entry, try to split it */ if (inode != 0) { uint16_t used_name_len = - ext4_dir_entry_ll_get_name_length(sb, dentry); + ext4_dir_entry_ll_get_name_length(sb, dentry); uint16_t used_space = - sizeof(struct ext4_fake_directory_entry) + used_name_len; + sizeof(struct ext4_fake_directory_entry) + used_name_len; if ((used_name_len % 4) != 0) used_space += 4 - (used_name_len % 4); @@ -496,9 +483,9 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb, /* Cut tail of current entry */ ext4_dir_entry_ll_set_entry_length(dentry, used_space); struct ext4_directory_entry_ll *new_entry = - (void *) ((uint8_t *)dentry + used_space); - ext4_dir_write_entry(sb, new_entry, - free_space, child, name, name_len); + (void *)((uint8_t *)dentry + used_space); + ext4_dir_write_entry(sb, new_entry, free_space, child, name, + name_len); target_block->dirty = true; return EOK; @@ -506,54 +493,51 @@ int ext4_dir_try_insert_entry(struct ext4_sblock *sb, } /* Jump to the next entry */ - dentry = (void *) ((uint8_t *)dentry + rec_len); + dentry = (void *)((uint8_t *)dentry + rec_len); } /* No free space found for new entry */ return ENOSPC; } - int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb, - size_t name_len, const char *name, - struct ext4_directory_entry_ll **res_entry) + size_t name_len, const char *name, + struct ext4_directory_entry_ll **res_entry) { /* Start from the first entry in block */ struct ext4_directory_entry_ll *dentry = - (struct ext4_directory_entry_ll *) block->data; + (struct ext4_directory_entry_ll *)block->data; /* Set upper bound for cycling */ uint8_t *addr_limit = block->data + ext4_sb_get_block_size(sb); /* Walk through the block and check entries */ - while ((uint8_t *) dentry < addr_limit) { + while ((uint8_t *)dentry < addr_limit) { /* Termination condition */ - if ((uint8_t *) dentry + name_len > addr_limit) + if ((uint8_t *)dentry + name_len > addr_limit) break; /* Valid entry - check it */ if (dentry->inode != 0) { /* For more effectivity compare firstly only lengths */ - if (ext4_dir_entry_ll_get_name_length(sb, dentry) == - name_len) { + if (ext4_dir_entry_ll_get_name_length(sb, dentry) == name_len) { /* Compare names */ - if (memcmp((uint8_t *) name, dentry->name, name_len) == 0) { + if (memcmp((uint8_t *)name, dentry->name, name_len) == 0) { *res_entry = dentry; return EOK; } } } - uint16_t dentry_len = - ext4_dir_entry_ll_get_entry_length(dentry); + uint16_t dentry_len = ext4_dir_entry_ll_get_entry_length(dentry); /* Corrupted entry */ if (dentry_len == 0) return EINVAL; /* Jump to next entry */ - dentry = (struct ext4_directory_entry_ll *) - ((uint8_t *) dentry + dentry_len); + dentry = + (struct ext4_directory_entry_ll *)((uint8_t *)dentry + dentry_len); } /* Entry not found */ @@ -561,7 +545,7 @@ int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb, } int ext4_dir_destroy_result(struct ext4_inode_ref *parent, - struct ext4_directory_search_result *result) + struct ext4_directory_search_result *result) { if (result->block.lb_id) return ext4_block_set(parent->fs->bdev, &result->block); -- 2.30.2