#include "ext4_errno.h"
#include "ext4_blockdev.h"
#include "ext4_super.h"
-#include "ext4_crc32c.h"
+#include "ext4_crc32.h"
#include "ext4_debug.h"
#include "ext4_block_group.h"
#include "ext4_balloc.h"
uint32_t inode_table_bcnt = inodes_per_group * inode_size / block_size;
struct ext4_block block_bitmap;
- rc = ext4_block_get_noread(bg_ref->fs->bdev, &block_bitmap, bmp_blk);
+ rc = ext4_trans_block_get_noread(bg_ref->fs->bdev, &block_bitmap, bmp_blk);
if (rc != EOK)
return rc;
* 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_trans_set_block_dirty(block_bitmap.buf);
ext4_balloc_set_bitmap_csum(sb, bg_ref->block_group, block_bitmap.data);
bg_ref->dirty = true;
ext4_fsblk_t bitmap_block_addr = ext4_bg_get_inode_bitmap(bg, sb);
struct ext4_block b;
- rc = ext4_block_get_noread(bg_ref->fs->bdev, &b, bitmap_block_addr);
+ rc = ext4_trans_block_get_noread(bg_ref->fs->bdev, &b, bitmap_block_addr);
if (rc != EOK)
return rc;
if (i < end_bit)
memset(b.data + (i >> 3), 0xff, (end_bit - i) >> 3);
- b.dirty = true;
+ ext4_trans_set_block_dirty(b.buf);
ext4_ialloc_set_bitmap_csum(sb, bg, b.data);
bg_ref->dirty = true;
/* Initialization of all itable blocks */
for (fblock = first_block; fblock <= last_block; ++fblock) {
struct ext4_block b;
- int rc = ext4_block_get_noread(bg_ref->fs->bdev, &b, fblock);
+ int rc = ext4_trans_block_get_noread(bg_ref->fs->bdev, &b, fblock);
if (rc != EOK)
return rc;
memset(b.data, 0, block_size);
- b.dirty = true;
+ ext4_trans_set_block_dirty(b.buf);
ext4_block_set(bg_ref->fs->bdev, &b);
if (rc != EOK)
uint32_t offset = (bgid % dsc_cnt) * ext4_sb_get_desc_size(&fs->sb);
- int rc = ext4_block_get(fs->bdev, &ref->block, block_id);
+ int rc = ext4_trans_block_get(fs->bdev, &ref->block, block_id);
if (rc != EOK)
return rc;
ref->block_group->checksum = to_le16(cs);
/* Mark block dirty for writing changes to physical device */
- ref->block.dirty = true;
+ ext4_trans_set_block_dirty(ref->block.buf);
}
/* Put back block, that contains block group descriptor */
* 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_csum(sb, inode_ref->inode, orig_checksum);
ext4_fsblk_t block_id =
inode_table_start + (byte_offset_in_group / block_size);
- rc = ext4_block_get(fs->bdev, &ref->block, block_id);
+ rc = ext4_trans_block_get(fs->bdev, &ref->block, block_id);
if (rc != EOK) {
return rc;
}
if (ref->dirty) {
/* Mark block dirty for writing changes to physical device */
ext4_fs_set_inode_checksum(ref);
- ref->block.dirty = true;
+ ext4_trans_set_block_dirty(ref->block.buf);
}
/* Put back block, that contains i-node */
}
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);
/* 2) Double indirect */
fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1);
if (fblock != 0) {
- int rc = ext4_block_get(fs->bdev, &block, fblock);
+ int rc = ext4_trans_block_get(fs->bdev, &block, fblock);
if (rc != EOK)
return rc;
fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2);
if (fblock == 0)
goto finish;
- rc = ext4_block_get(fs->bdev, &block, fblock);
+ rc = ext4_trans_block_get(fs->bdev, &block, fblock);
if (rc != EOK)
return rc;
if (ind_block == 0)
continue;
- rc = ext4_block_get(fs->bdev, &subblock,
+ rc = ext4_trans_block_get(fs->bdev, &subblock,
ind_block);
if (rc != EOK) {
ext4_block_set(fs->bdev, &block);
if (current_block == 0)
return EOK;
- int rc = ext4_block_get(fs->bdev, &block, current_block);
+ int rc = ext4_trans_block_get(fs->bdev, &block, current_block);
if (rc != EOK)
return rc;
/* 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_trans_set_block_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)
ext4_fsblk_t current_fsblk;
int rc = ext4_extent_get_blocks(inode_ref, iblock, 1,
- ¤t_fsblk, extent_create, NULL);
+ ¤t_fsblk, extent_create, NULL);
if (rc != EOK)
return rc;
*/
while (l > 0) {
/* Load indirect block */
- int rc = ext4_block_get(fs->bdev, &block, current_block);
+ int rc = ext4_trans_block_get(fs->bdev, &block, current_block);
if (rc != EOK)
return rc;
}
-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,
inode_ref->dirty = true;
/* Load newly allocated block */
- rc = ext4_block_get_noread(fs->bdev, &new_block, new_blk);
+ rc = ext4_trans_block_get_noread(fs->bdev, &new_block, new_blk);
if (rc != EOK) {
ext4_balloc_free_block(inode_ref, new_blk);
return rc;
/* Initialize new block */
memset(new_block.data, 0, block_size);
- new_block.dirty = true;
+ ext4_trans_set_block_dirty(new_block.buf);
/* Put back the allocated block */
rc = ext4_block_set(fs->bdev, &new_block);
* or find null reference meaning we are dealing with sparse file
*/
while (l > 0) {
- int rc = ext4_block_get(fs->bdev, &block, current_block);
+ int rc = ext4_trans_block_get(fs->bdev, &block, current_block);
if (rc != EOK)
return rc;
}
/* Load newly allocated block */
- rc = ext4_block_get_noread(fs->bdev, &new_block,
+ rc = ext4_trans_block_get_noread(fs->bdev, &new_block,
new_blk);
if (rc != EOK) {
/* Initialize allocated block */
memset(new_block.data, 0, block_size);
- new_block.dirty = true;
+ ext4_trans_set_block_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_trans_set_block_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_trans_set_block_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