#if CONFIG_META_CSUM_ENABLE
static uint32_t ext4_dir_dx_checksum(struct ext4_inode_ref *inode_ref, void *de,
int count_offset, int count,
- struct ext4_dir_idx_tail *t)
+ struct ext4_dir_idx_tail *t)
{
uint32_t orig_cum, csum = 0;
struct ext4_sblock *sb = &inode_ref->fs->sb;
static struct ext4_dir_idx_climit *
ext4_dir_dx_get_climit(struct ext4_inode_ref *inode_ref,
- struct ext4_dir_entry_ll *dirent, int *offset)
+ struct ext4_dir_en *dirent, int *offset)
{
- struct ext4_dir_entry_ll *dp;
+ struct ext4_dir_en *dp;
struct ext4_dir_idx_root *root;
struct ext4_sblock *sb = &inode_ref->fs->sb;
uint32_t block_size = ext4_sb_get_block_size(sb);
- uint16_t entry_len = ext4_dir_entry_ll_get_entry_length(dirent);
+ uint16_t entry_len = ext4_dir_en_get_entry_len(dirent);
int count_offset;
if (entry_len == 12) {
root = (struct ext4_dir_idx_root *)dirent;
- dp = (struct ext4_dir_entry_ll *)&root->dots[1];
- if (ext4_dir_entry_ll_get_entry_length(dp) != (block_size - 12))
+ dp = (struct ext4_dir_en *)&root->dots[1];
+ if (ext4_dir_en_get_entry_len(dp) != (block_size - 12))
return NULL;
if (root->info.reserved_zero)
return NULL;
* Currently we do not verify the checksum of HTree node.
*/
static bool ext4_dir_dx_csum_verify(struct ext4_inode_ref *inode_ref,
- struct ext4_dir_entry_ll *de)
+ struct ext4_dir_en *de)
{
struct ext4_sblock *sb = &inode_ref->fs->sb;
uint32_t block_size = ext4_sb_get_block_size(sb);
static void ext4_dir_set_dx_csum(struct ext4_inode_ref *inode_ref,
- struct ext4_dir_entry_ll *dirent)
+ struct ext4_dir_en *dirent)
{
int coff, limit, count;
struct ext4_sblock *sb = &inode_ref->fs->sb;
struct ext4_sblock *sb = &dir->fs->sb;
uint32_t block_size = ext4_sb_get_block_size(&dir->fs->sb);
- int rc = ext4_fs_append_inode_block(dir, &fblock, &iblock);
+ int rc = ext4_fs_append_inode_dblk(dir, &fblock, &iblock);
if (rc != EOK)
return rc;
struct ext4_dir_idx_rinfo *info = &(root->info);
memset(root, 0, sizeof(struct ext4_dir_idx_root));
- struct ext4_dir_entry_ll *de;
+ struct ext4_dir_en *de;
/* Initialize dot entries */
- de = (struct ext4_dir_entry_ll *)root->dots;
+ de = (struct ext4_dir_en *)root->dots;
ext4_dir_write_entry(sb, de, 12, dir, ".", strlen("."));
- de = (struct ext4_dir_entry_ll *)(root->dots + 1);
+ de = (struct ext4_dir_en *)(root->dots + 1);
uint16_t elen = block_size - 12;
ext4_dir_write_entry(sb, de, elen, parent, "..", strlen(".."));
ext4_dir_dx_climit_set_count(climit, 1);
uint32_t entry_space;
- entry_space = block_size - 2 * sizeof(struct ext4_dir_idx_dot_entry) -
+ entry_space = block_size - 2 * sizeof(struct ext4_dir_idx_dot_en) -
sizeof(struct ext4_dir_idx_rinfo);
if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
ext4_dir_dx_climit_set_limit(climit, root_limit);
/* Append new block, where will be new entries inserted in the future */
- rc = ext4_fs_append_inode_block(dir, &fblock, &iblock);
+ rc = ext4_fs_append_inode_dblk(dir, &fblock, &iblock);
if (rc != EOK) {
ext4_block_set(dir->fs->bdev, &block);
return rc;
}
/* Fill the whole block with empty entry */
- struct ext4_dir_entry_ll *be = (void *)new_block.data;
+ struct ext4_dir_en *be = (void *)new_block.data;
if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
uint16_t len = block_size - sizeof(struct ext4_dir_entry_tail);
- ext4_dir_entry_ll_set_entry_length(be, len);
- ext4_dir_entry_ll_set_name_length(sb, be, 0);
- ext4_dir_entry_ll_set_inode_type(sb, be, EXT4_DIRENTRY_UNKNOWN);
+ ext4_dir_en_set_entry_len(be, len);
+ ext4_dir_en_set_name_len(sb, be, 0);
+ ext4_dir_en_set_inode_type(sb, be, EXT4_DE_UNKNOWN);
ext4_dir_init_entry_tail(EXT4_DIRENT_TAIL(be, block_size));
ext4_dir_set_csum(dir, be);
} else {
- ext4_dir_entry_ll_set_entry_length(be, block_size);
+ ext4_dir_en_set_entry_len(be, block_size);
}
- ext4_dir_entry_ll_set_inode(be, 0);
+ ext4_dir_en_set_inode(be, 0);
- new_block.dirty = true;
+ ext4_bcache_set_dirty(new_block.buf);
rc = ext4_block_set(dir->fs->bdev, &new_block);
if (rc != EOK) {
ext4_block_set(dir->fs->bdev, &block);
struct ext4_dir_idx_entry *entry = root->en;
ext4_dir_dx_entry_set_block(entry, iblock);
- ext4_dir_set_dx_csum(dir, (struct ext4_dir_entry_ll *)block.data);
- block.dirty = true;
+ ext4_dir_set_dx_csum(dir, (struct ext4_dir_en *)block.data);
+ ext4_bcache_set_dirty(block.buf);
return ext4_block_set(dir->fs->bdev, &block);
}
/* Check if node limit is correct */
uint32_t block_size = ext4_sb_get_block_size(sb);
uint32_t entry_space = block_size;
- entry_space -= 2 * sizeof(struct ext4_dir_idx_dot_entry);
+ entry_space -= 2 * sizeof(struct ext4_dir_idx_dot_en);
entry_space -= sizeof(struct ext4_dir_idx_rinfo);
if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
entry_space -= sizeof(struct ext4_dir_idx_tail);
struct ext4_dir_idx_entry *q;
struct ext4_dir_idx_entry *m;
struct ext4_dir_idx_entry *at;
- ext4_fsblk_t fblock;
+ ext4_fsblk_t fblk;
uint32_t block_size;
uint16_t limit;
uint16_t entry_space;
}
/* Goto child node */
- uint32_t next_block = ext4_dir_dx_entry_get_block(at);
+ uint32_t n_blk = ext4_dir_dx_entry_get_block(at);
ind_level--;
- r = ext4_fs_get_inode_data_block_index(inode_ref, next_block,
- &fblock, false);
+ r = ext4_fs_get_inode_dblk_idx(inode_ref, n_blk, &fblk, false);
if (r != EOK)
return r;
- r = ext4_block_get(inode_ref->fs->bdev, tmp_blk, fblock);
+ r = ext4_block_get(inode_ref->fs->bdev, tmp_blk, fblk);
if (r != EOK)
return r;
"Inode: %" PRIu32", "
"Block: %" PRIu32"\n",
inode_ref->index,
- next_block);
+ n_blk);
}
++tmp_dx_blk;
{
int r;
uint32_t num_handles = 0;
- ext4_fsblk_t block_addr;
+ ext4_fsblk_t blk_adr;
struct ext4_dir_idx_block *p = dx_block;
/* Try to find data block with next bunch of entries */
/* Fill new path */
while (num_handles--) {
- uint32_t block_idx = ext4_dir_dx_entry_get_block(p->position);
-
- r = ext4_fs_get_inode_data_block_index(inode_ref, block_idx,
- &block_addr, false);
+ uint32_t blk = ext4_dir_dx_entry_get_block(p->position);
+ r = ext4_fs_get_inode_dblk_idx(inode_ref, blk, &blk_adr, false);
if (r != EOK)
return r;
struct ext4_block b;
- r = ext4_block_get(inode_ref->fs->bdev, &b, block_addr);
+ r = ext4_block_get(inode_ref->fs->bdev, &b, blk_adr);
if (r != EOK)
return r;
"Inode: %" PRIu32", "
"Block: %" PRIu32"\n",
inode_ref->index,
- block_idx);
+ blk);
}
p++;
ext4_fsblk_t root_block_addr;
int rc2;
int rc;
- rc = ext4_fs_get_inode_data_block_index(inode_ref, 0, &root_block_addr,
- false);
+ rc = ext4_fs_get_inode_dblk_idx(inode_ref, 0, &root_block_addr, false);
if (rc != EOK)
return rc;
struct ext4_block b;
leaf_blk_idx = ext4_dir_dx_entry_get_block(dx_block->position);
- rc = ext4_fs_get_inode_data_block_index(inode_ref, leaf_blk_idx,
- &leaf_block_addr, false);
+ rc = ext4_fs_get_inode_dblk_idx(inode_ref, leaf_blk_idx,
+ &leaf_block_addr, false);
if (rc != EOK)
goto cleanup;
}
/* Linear search inside block */
- struct ext4_dir_entry_ll *de;
+ struct ext4_dir_en *de;
rc = ext4_dir_find_in_block(&b, &fs->sb, name_len, name, &de);
/* Found => return it */
ext4_dir_dx_entry_set_hash(new_index_entry, hash);
ext4_dir_dx_climit_set_count(climit, count + 1);
ext4_dir_set_dx_csum(inode_ref, (void *)index_block->b.data);
- index_block->b.dirty = true;
+ ext4_bcache_set_dirty(index_block->b.buf);
}
/**@brief Split directory entries to two parts preventing node overflow.
return ENOMEM;
/* dot entry has the smallest size available */
- uint32_t max_ecnt = block_size / sizeof(struct ext4_dir_idx_dot_entry);
+ uint32_t max_ecnt = block_size / sizeof(struct ext4_dir_idx_dot_en);
/* Allocate sort entry */
struct ext4_dx_sort_entry *sort;
memcpy(&hinfo_tmp, hinfo, sizeof(struct ext4_hash_info));
/* Load all valid entries to the buffer */
- struct ext4_dir_entry_ll *de = (void *)old_data_block->data;
+ struct ext4_dir_en *de = (void *)old_data_block->data;
uint8_t *entry_buffer_ptr = entry_buffer;
while ((void *)de < (void *)(old_data_block->data + block_size)) {
/* Read only valid entries */
- if (ext4_dir_entry_ll_get_inode(de) && de->name_length) {
- uint8_t len = ext4_dir_entry_ll_get_name_length(sb, de);
+ if (ext4_dir_en_get_inode(de) && de->name_len) {
+ uint8_t len = ext4_dir_en_get_name_len(sb, de);
rc = ext4_dir_dx_hash_string(&hinfo_tmp, len,
(char *)de->name);
if (rc != EOK) {
idx++;
}
- size_t elen = ext4_dir_entry_ll_get_entry_length(de);
+ size_t elen = ext4_dir_en_get_entry_len(de);
de = (void *)((uint8_t *)de + elen);
}
/* Allocate new block for store the second part of entries */
ext4_fsblk_t new_fblock;
uint32_t new_iblock;
- rc = ext4_fs_append_inode_block(inode_ref, &new_fblock, &new_iblock);
+ rc = ext4_fs_append_inode_dblk(inode_ref, &new_fblock, &new_iblock);
if (rc != EOK) {
free(sort);
free(entry_buffer);
ptr = old_data_block->data + off;
memcpy(ptr, sort[i].dentry, sort[i].rec_len);
- struct ext4_dir_entry_ll *t = ptr;
+ struct ext4_dir_en *t = ptr;
if (i < (mid - 1))
- ext4_dir_entry_ll_set_entry_length(t, sort[i].rec_len);
+ ext4_dir_en_set_entry_len(t, sort[i].rec_len);
else
- ext4_dir_entry_ll_set_entry_length(t, block_size - off);
+ ext4_dir_en_set_entry_len(t, block_size - off);
off += sort[i].rec_len;
}
ptr = new_data_block_tmp.data + off;
memcpy(ptr, sort[i].dentry, sort[i].rec_len);
- struct ext4_dir_entry_ll *t = ptr;
+ struct ext4_dir_en *t = ptr;
if (i < (idx - 1))
- ext4_dir_entry_ll_set_entry_length(t, sort[i].rec_len);
+ ext4_dir_en_set_entry_len(t, sort[i].rec_len);
else
- ext4_dir_entry_ll_set_entry_length(t, block_size - off);
+ ext4_dir_en_set_entry_len(t, block_size - off);
off += sort[i].rec_len;
}
}
ext4_dir_set_csum(inode_ref, (void *)old_data_block->data);
ext4_dir_set_csum(inode_ref, (void *)new_data_block_tmp.data);
- old_data_block->dirty = true;
- new_data_block_tmp.dirty = true;
+ ext4_bcache_set_dirty(old_data_block->buf);
+ ext4_bcache_set_dirty(new_data_block_tmp.buf);
free(sort);
free(entry_buffer);
/* Add new block to directory */
ext4_fsblk_t new_fblk;
uint32_t new_iblk;
- r = ext4_fs_append_inode_block(ino_ref, &new_fblk, &new_iblk);
+ r = ext4_fs_append_inode_dblk(ino_ref, &new_fblk, &new_iblk);
if (r != EOK)
return r;
if (position_index >= count_left) {
ext4_dir_set_dx_csum(
ino_ref,
- (struct ext4_dir_entry_ll *)
+ (struct ext4_dir_en *)
dxb->b.data);
- dxb->b.dirty = true;
+ ext4_bcache_set_dirty(dxb->b.buf);
struct ext4_block block_tmp = dxb->b;
/* Finally insert new entry */
ext4_dir_dx_insert_entry(ino_ref, dx_blks, hash_right,
new_iblk);
- ext4_dir_set_dx_csum(ino_ref, (void *)dx_blks[0].b.data);
- ext4_dir_set_dx_csum(ino_ref, (void *)dx_blks[1].b.data);
- dx_blks[0].b.dirty = true;
- dx_blks[1].b.dirty = true;
+ ext4_dir_set_dx_csum(ino_ref, (void*)dx_blks[0].b.data);
+ ext4_dir_set_dx_csum(ino_ref, (void*)dx_blks[1].b.data);
+ ext4_bcache_set_dirty(dx_blks[0].b.buf);
+ ext4_bcache_set_dirty(dx_blks[1].b.buf);
ext4_dir_set_dx_csum(ino_ref, (void *)b.data);
- b.dirty = true;
+ ext4_bcache_set_dirty(b.buf);
return ext4_block_set(ino_ref->fs->bdev, &b);
} else {
size_t sz;
dxb->b = b;
*new_dx_block = dxb;
- ext4_dir_set_dx_csum(ino_ref, (void *)dx_blks[0].b.data);
- ext4_dir_set_dx_csum(ino_ref, (void *)dx_blks[1].b.data);
- dx_blks[0].b.dirty = true;
- dx_blks[1].b.dirty = true;
+ ext4_dir_set_dx_csum(ino_ref, (void*)dx_blks[0].b.data);
+ ext4_dir_set_dx_csum(ino_ref, (void*)dx_blks[1].b.data);
+ ext4_bcache_set_dirty(dx_blks[0].b.buf);
+ ext4_bcache_set_dirty(dx_blks[1].b.buf);
}
}
int r;
/* Get direct block 0 (index root) */
ext4_fsblk_t rblock_addr;
- r = ext4_fs_get_inode_data_block_index(parent, 0, &rblock_addr, false);
+ r = ext4_fs_get_inode_dblk_idx(parent, 0, &rblock_addr, false);
if (r != EOK)
return r;
/* Try to insert to existing data block */
uint32_t leaf_block_idx = ext4_dir_dx_entry_get_block(dx_blk->position);
ext4_fsblk_t leaf_block_addr;
- r = ext4_fs_get_inode_data_block_index(parent, leaf_block_idx,
+ r = ext4_fs_get_inode_dblk_idx(parent, leaf_block_idx,
&leaf_block_addr, false);
if (r != EOK)
goto release_index;
{
/* Load block 0, where will be index root located */
ext4_fsblk_t fblock;
- int rc = ext4_fs_get_inode_data_block_index(dir, 0, &fblock, false);
+ int rc = ext4_fs_get_inode_dblk_idx(dir, 0, &fblock, false);
if (rc != EOK)
return rc;
struct ext4_dir_idx_root *root = (void *)block.data;
/* Fill the inode field with a new parent ino. */
- ext4_dx_dot_entry_set_inode(&root->dots[1], parent_inode);
+ ext4_dx_dot_en_set_inode(&root->dots[1], parent_inode);
ext4_dir_set_dx_csum(dir, (void *)block.data);
- block.dirty = true;
+ ext4_bcache_set_dirty(block.buf);
return ext4_block_set(dir->fs->bdev, &block);
}
projects / lwext4.git / blobdiff