* of bitmap ), set rest of the block bitmap to 1
*/
ext4_fs_mark_bitmap_end(group_blocks, block_size * 8, block_bitmap.data);
- block_bitmap.dirty = true;
+ ext4_bcache_set_dirty(block_bitmap.buf);
ext4_balloc_set_bitmap_csum(sb, bg_ref->block_group, block_bitmap.data);
bg_ref->dirty = true;
if (i < end_bit)
memset(b.data + (i >> 3), 0xff, (end_bit - i) >> 3);
- b.dirty = true;
+ ext4_bcache_set_dirty(b.buf);
ext4_ialloc_set_bitmap_csum(sb, bg, b.data);
bg_ref->dirty = true;
return rc;
memset(b.data, 0, block_size);
- b.dirty = true;
+ ext4_bcache_set_dirty(b.buf);
ext4_block_set(bg_ref->fs->bdev, &b);
if (rc != EOK)
uint32_t offset = (uint32_t)(checksum - base);
/* Convert block group index to little endian */
- uint32_t le_group = to_le32(bgid);
+ uint32_t group = to_le32(bgid);
/* Initialization */
crc = ext4_bg_crc16(~0, sb->uuid, sizeof(sb->uuid));
/* Include index of block group */
- crc =
- ext4_bg_crc16(crc, (uint8_t *)&le_group, sizeof(le_group));
+ crc = ext4_bg_crc16(crc, (uint8_t *)&group, sizeof(group));
/* Compute crc from the first part (stop before checksum field)
*/
ref->block_group->checksum = to_le16(cs);
/* Mark block dirty for writing changes to physical device */
- ref->block.dirty = true;
+ ext4_bcache_set_dirty(ref->block.buf);
}
/* Put back block, that contains block group descriptor */
to_le32(ext4_inode_get_generation(inode_ref->inode));
/* Preparation: temporarily set bg checksum to 0 */
- orig_checksum = ext4_inode_get_checksum(sb, inode_ref->inode);
- ext4_inode_set_checksum(sb, inode_ref->inode, 0);
+ orig_checksum = ext4_inode_get_csum(sb, inode_ref->inode);
+ ext4_inode_set_csum(sb, inode_ref->inode, 0);
/* First calculate crc32 checksum against fs uuid */
checksum = ext4_crc32c(EXT4_CRC32_INIT, sb->uuid,
* and inode generation */
checksum = ext4_crc32c(checksum, &ino_index, sizeof(ino_index));
checksum = ext4_crc32c(checksum, &ino_gen, sizeof(ino_gen));
- /* Finally calculate crc32 checksum against
+ /* Finally calculate crc32 checksum against
* the entire inode */
checksum = ext4_crc32c(checksum, inode_ref->inode, inode_size);
- ext4_inode_set_checksum(sb, inode_ref->inode, orig_checksum);
+ ext4_inode_set_csum(sb, inode_ref->inode, orig_checksum);
/* If inode size is not large enough to hold the
* upper 16bit of the checksum */
return;
uint32_t csum = ext4_fs_inode_checksum(inode_ref);
- ext4_inode_set_checksum(sb, inode_ref->inode, csum);
+ ext4_inode_set_csum(sb, inode_ref->inode, csum);
}
#if CONFIG_META_CSUM_ENABLE
if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
return true;
- return ext4_inode_get_checksum(sb, inode_ref->inode) ==
+ return ext4_inode_get_csum(sb, inode_ref->inode) ==
ext4_fs_inode_checksum(inode_ref);
}
#else
if (ref->dirty) {
/* Mark block dirty for writing changes to physical device */
ext4_fs_set_inode_checksum(ref);
- ref->block.dirty = true;
+ ext4_bcache_set_dirty(ref->block.buf);
}
/* Put back block, that contains i-node */
uint32_t ext4_fs_correspond_inode_mode(int filetype)
{
switch (filetype) {
- case EXT4_DIRENTRY_DIR:
+ case EXT4_DE_DIR:
return EXT4_INODE_MODE_DIRECTORY;
- case EXT4_DIRENTRY_REG_FILE:
+ case EXT4_DE_REG_FILE:
return EXT4_INODE_MODE_FILE;
- case EXT4_DIRENTRY_SYMLINK:
+ case EXT4_DE_SYMLINK:
return EXT4_INODE_MODE_SOFTLINK;
default:
/* FIXME: right now we only support 3 file type. */
bool is_dir;
uint16_t inode_size = ext4_get16(&fs->sb, inode_size);
- is_dir = (filetype == EXT4_DIRENTRY_DIR);
+ is_dir = (filetype == EXT4_DE_DIR);
/* Allocate inode by allocation algorithm */
uint32_t index;
}
ext4_inode_set_mode(&fs->sb, inode, mode);
- ext4_inode_set_links_count(inode, 0);
+ ext4_inode_set_links_cnt(inode, 0);
ext4_inode_set_uid(inode, 0);
ext4_inode_set_gid(inode, 0);
ext4_inode_set_size(inode, 0);
ext4_inode_set_access_time(inode, 0);
ext4_inode_set_change_inode_time(inode, 0);
- ext4_inode_set_modification_time(inode, 0);
- ext4_inode_set_deletion_time(inode, 0);
+ ext4_inode_set_modif_time(inode, 0);
+ ext4_inode_set_del_time(inode, 0);
ext4_inode_set_blocks_count(&fs->sb, inode, 0);
ext4_inode_set_flags(inode, 0);
ext4_inode_set_generation(inode, 0);
/* Set zero if physical data block address found */
if (level == 1) {
((uint32_t *)block.data)[offset_in_block] = to_le32(0);
- block.dirty = true;
+ ext4_bcache_set_dirty(block.buf);
}
rc = ext4_block_set(fs->bdev, &block);
/* If inode has some blocks, get last block address + 1 */
if (iblock_cnt > 0) {
- r = ext4_fs_get_inode_data_block_index(inode_ref, iblock_cnt - 1,
- goal, false);
+ r = ext4_fs_get_inode_dblk_idx(inode_ref, iblock_cnt - 1,
+ goal, false);
if (r != EOK)
return r;
return ext4_fs_put_block_group_ref(&bg_ref);
}
-static int ext4_fs_get_inode_data_block_idx(struct ext4_inode_ref *inode_ref,
+static int ext4_fs_get_inode_dblk_idx_internal(struct ext4_inode_ref *inode_ref,
uint64_t iblock, ext4_fsblk_t *fblock,
bool extent_create,
bool support_unwritten __unused)
}
-int ext4_fs_get_inode_data_block_index(struct ext4_inode_ref *inode_ref,
- uint64_t iblock, ext4_fsblk_t *fblock,
- bool support_unwritten)
+int ext4_fs_get_inode_dblk_idx(struct ext4_inode_ref *inode_ref,
+ uint64_t iblock, ext4_fsblk_t *fblock,
+ bool support_unwritten)
{
- return ext4_fs_get_inode_data_block_idx(inode_ref, iblock, fblock,
- false, support_unwritten);
+ return ext4_fs_get_inode_dblk_idx_internal(inode_ref, iblock, fblock,
+ false, support_unwritten);
}
-int ext4_fs_init_inode_data_block_index(struct ext4_inode_ref *inode_ref,
- uint64_t iblock, ext4_fsblk_t *fblock)
+int ext4_fs_init_inode_dblk_idx(struct ext4_inode_ref *inode_ref,
+ uint64_t iblock, ext4_fsblk_t *fblock)
{
- return ext4_fs_get_inode_data_block_idx(inode_ref, iblock, fblock,
- true, true);
+ return ext4_fs_get_inode_dblk_idx_internal(inode_ref, iblock, fblock,
+ true, true);
}
static int ext4_fs_set_inode_data_block_index(struct ext4_inode_ref *inode_ref,
/* Initialize new block */
memset(new_block.data, 0, block_size);
- new_block.dirty = true;
+ ext4_bcache_set_dirty(new_block.buf);
/* Put back the allocated block */
rc = ext4_block_set(fs->bdev, &new_block);
/* Initialize allocated block */
memset(new_block.data, 0, block_size);
- new_block.dirty = true;
+ ext4_bcache_set_dirty(new_block.buf);
rc = ext4_block_set(fs->bdev, &new_block);
if (rc != EOK) {
/* Write block address to the parent */
uint32_t * p = (uint32_t * )block.data;
p[off_in_blk] = to_le32((uint32_t)new_blk);
- block.dirty = true;
+ ext4_bcache_set_dirty(block.buf);
current_block = new_blk;
}
if (l == 1) {
uint32_t * p = (uint32_t * )block.data;
p[off_in_blk] = to_le32((uint32_t)fblock);
- block.dirty = true;
+ ext4_bcache_set_dirty(block.buf);
}
rc = ext4_block_set(fs->bdev, &block);
}
-int ext4_fs_append_inode_block(struct ext4_inode_ref *inode_ref,
- ext4_fsblk_t *fblock, uint32_t *iblock)
+int ext4_fs_append_inode_dblk(struct ext4_inode_ref *inode_ref,
+ ext4_fsblk_t *fblock, uint32_t *iblock)
{
#if CONFIG_EXTENT_ENABLE
/* Handle extents separately */
rc = ext4_extent_get_blocks(inode_ref, *iblock, 1,
¤t_fsblk, true, NULL);
-
*fblock = current_fsblk;
ext4_assert(*fblock);
{
uint16_t link;
bool is_dx;
- link = ext4_inode_get_links_count(inode_ref->inode);
+ link = ext4_inode_get_links_cnt(inode_ref->inode);
link++;
- ext4_inode_set_links_count(inode_ref->inode, link);
+ ext4_inode_set_links_cnt(inode_ref->inode, link);
is_dx = ext4_sb_feature_com(&inode_ref->fs->sb, EXT4_FCOM_DIR_INDEX) &&
ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_INDEX);
if (is_dx && link > 1) {
if (link >= EXT4_LINK_MAX || link == 2) {
- ext4_inode_set_links_count(inode_ref->inode, 1);
+ ext4_inode_set_links_cnt(inode_ref->inode, 1);
uint32_t v;
v = ext4_get32(&inode_ref->fs->sb, features_read_only);
void ext4_fs_inode_links_count_dec(struct ext4_inode_ref *inode_ref)
{
- uint16_t links = ext4_inode_get_links_count(inode_ref->inode);
+ uint16_t links = ext4_inode_get_links_cnt(inode_ref->inode);
if (!ext4_inode_is_type(&inode_ref->fs->sb, inode_ref->inode,
EXT4_INODE_MODE_DIRECTORY)) {
if (links > 0)
- ext4_inode_set_links_count(inode_ref->inode, links - 1);
+ ext4_inode_set_links_cnt(inode_ref->inode, links - 1);
return;
}
if (links > 2)
- ext4_inode_set_links_count(inode_ref->inode, links - 1);
+ ext4_inode_set_links_cnt(inode_ref->inode, links - 1);
}
/**
projects / lwext4.git / blobdiff