#include "ext4_blockdev.h"
#include "ext4_fs.h"
#include "ext4_super.h"
+#include "ext4_crc32c.h"
#include "ext4_balloc.h"
#include "ext4_debug.h"
return newblock;
}
+#if CONFIG_META_CSUM_ENABLE
+static uint32_t ext4_ext_block_csum(struct ext4_inode_ref *inode_ref,
+ struct ext4_extent_header *eh)
+{
+ uint32_t checksum = 0;
+ struct ext4_sblock *sb = &inode_ref->fs->sb;
+
+ if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
+ uint32_t ino_index = to_le32(inode_ref->index);
+ uint32_t ino_gen =
+ to_le32(ext4_inode_get_generation(inode_ref->inode));
+ /* First calculate crc32 checksum against fs uuid */
+ checksum = ext4_crc32c(EXT4_CRC32_INIT, sb->uuid,
+ sizeof(sb->uuid));
+ /* Then calculate crc32 checksum against inode number
+ * 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
+ * the entire extent block up to the checksum field */
+ checksum = ext4_crc32c(checksum, eh,
+ EXT4_EXTENT_TAIL_OFFSET(eh));
+ }
+ return checksum;
+}
+#else
+#define ext4_ext_block_csum(...) 0
+#endif
+
+static void ext4_extent_block_csum_set(struct ext4_inode_ref *inode_ref __unused,
+ struct ext4_extent_header *eh)
+{
+ struct ext4_extent_tail *tail;
+
+ tail = find_ext4_extent_tail(eh);
+ tail->et_checksum = to_le32(ext4_ext_block_csum(inode_ref, eh));
+}
+
static int ext4_ext_dirty(struct ext4_inode_ref *inode_ref,
struct ext4_extent_path *path)
{
if (path->block.lb_id)
- path->block.dirty = true;
+ ext4_bcache_set_dirty(path->block.buf);
else
inode_ref->dirty = true;
for (i = 0; i <= depth; i++, path++) {
if (path->block.lb_id) {
+ if (ext4_bcache_test_flag(path->block.buf, BC_DIRTY))
+ ext4_extent_block_csum_set(inode_ref,
+ path->header);
+
ext4_block_set(inode_ref->fs->bdev, &path->block);
}
}
}
-/*
- * Temporarily we don't need to support checksum.
- */
-static uint32_t ext4_ext_block_csum(struct ext4_inode_ref *inode_ref __unused,
- struct ext4_extent_header *eh __unused)
-{
- /*TODO: should we add crc32 here ?*/
- /*return ext4_crc32c(inode->i_csum, eh, EXT4_EXTENT_TAIL_OFFSET(eh));*/
- return 0;
-}
-
-static void ext4_extent_block_csum_set(struct ext4_inode_ref *inode_ref,
- struct ext4_extent_header *eh)
-{
- struct ext4_extent_tail *tail;
-
- tail = find_ext4_extent_tail(eh);
- tail->et_checksum = ext4_ext_block_csum(inode_ref, eh);
-}
-
/*
* Check that whether the basic information inside the extent header
* is correct or not.
ext4_fsblk_t pblk __unused)
{
struct ext4_extent_tail *tail;
+ struct ext4_sblock *sb = &inode_ref->fs->sb;
const char *error_msg;
(void)error_msg;
}
tail = find_ext4_extent_tail(eh);
- if (tail->et_checksum != ext4_ext_block_csum(inode_ref, eh)) {
- /* FIXME: Warning: extent checksum damaged? */
+ if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
+ if (tail->et_checksum != to_le32(ext4_ext_block_csum(inode_ref, eh))) {
+ ext4_dbg(DEBUG_EXTENT,
+ DBG_WARN "Extent block checksum failed."
+ "Blocknr: %" PRIu64"\n",
+ pblk);
+
+ }
}
return EOK;
goto cleanup;
/* For write access.# */
- ret = ext4_block_get(inode_ref->fs->bdev, &bh, newblock);
+ ret = ext4_block_get_noread(inode_ref->fs->bdev, &bh, newblock);
if (ret != EOK)
goto cleanup;
spt->ptr = 0;
} else if (bh.lb_id) {
/* If we got a sibling leaf. */
- bh.dirty = true;
+ ext4_extent_block_csum_set(inode_ref, ext_block_hdr(&bh));
+ ext4_bcache_set_dirty(bh.buf);
spt->path.p_block = ext4_idx_pblock(ix);
spt->path.depth = to_le16(eh->depth);
spt->ptr = 0;
} else if (bh.lb_id) {
/* If we got a sibling leaf. */
- bh.dirty = true;
+ ext4_extent_block_csum_set(inode_ref, ext_block_hdr(&bh));
+ ext4_bcache_set_dirty(bh.buf);
spt->path.p_block = ext4_ext_pblock(ex);
spt->path.depth = to_le16(eh->depth);
return err;
/* # */
- err = ext4_block_get(inode_ref->fs->bdev, &bh, newblock);
+ err = ext4_block_get_noread(inode_ref->fs->bdev, &bh, newblock);
if (err != EOK) {
ext4_ext_free_blocks(inode_ref, newblock, 1, 0);
return err;
}
neh->depth = to_le16(to_le16(neh->depth) + 1);
- bh.dirty = true;
+ ext4_bcache_set_dirty(bh.buf);
inode_ref->dirty = true;
ext4_block_set(inode_ref->fs->bdev, &bh);
int32_t new_len = 0;
int unwritten;
ext4_lblk_t start, new_start;
+ ext4_fsblk_t newblock;
new_start = start = to_le32(ex->first_block);
len = ext4_ext_get_actual_len(ex);
+ newblock = ext4_ext_pblock(ex);
if (start < from) {
len -= from - start;
new_len = from - start;
start = from;
start_ex++;
+ } else {
+ if (start + len - 1 > to) {
+ len -= start + len - 1 - to;
+ new_len = start + len - 1 - to;
+ new_start = to + 1;
+ newblock += to + 1 - start;
+ ex2 = ex;
+ }
}
- /* TODO: More complicated truncate operation. */
- /*if (start + len - 1 > to) {*/
- /*len -= start + len - 1 - to;*/
- /*new_len = start + len - 1 - to;*/
- /*new_start = to + 1;*/
- /*ex2 = ex;*/
- /*}*/
ext4_ext_remove_blocks(inode_ref, ex, start, start + len - 1);
ex->first_block = to_le32(new_start);
else {
unwritten = ext4_ext_is_unwritten(ex);
ex->block_count = to_le16(new_len);
+ ext4_ext_store_pblock(ex, newblock);
if (unwritten)
ext4_ext_mark_unwritten(ex);
}
goto out;
}
+ /* If we do remove_space inside the range of an extent */
+ if ((to_le32(path[depth].extent->first_block) < from) &&
+ (to < to_le32(path[depth].extent->first_block) +
+ ext4_ext_get_actual_len(path[depth].extent) - 1)) {
+
+ struct ext4_extent *ex = path[depth].extent, newex;
+ int unwritten = ext4_ext_is_unwritten(ex);
+ ext4_lblk_t ee_block = to_le32(ex->first_block);
+ int32_t len = ext4_ext_get_actual_len(ex);
+ ext4_fsblk_t newblock =
+ to + 1 - ee_block + ext4_ext_pblock(ex);
+
+ ex->block_count = to_le16(from - ee_block);
+ if (unwritten)
+ ext4_ext_mark_unwritten(ex);
+
+ ext4_ext_dirty(inode_ref, path + depth);
+
+ newex.first_block = to_le32(to + 1);
+ newex.block_count = to_le16(ee_block + len - 1 - to);
+ ext4_ext_store_pblock(&newex, newblock);
+ if (unwritten)
+ ext4_ext_mark_unwritten(&newex);
+
+ ret = ext4_ext_insert_extent(inode_ref, &path, &newex, 0);
+ goto out;
+ }
+
i = depth;
while (i >= 0) {
if (i == depth) {
uint32_t block_size = ext4_sb_get_block_size(&inode_ref->fs->sb);
for (i = 0; i < blocks_count; i++) {
struct ext4_block bh = EXT4_BLOCK_ZERO();
- err = ext4_block_get(inode_ref->fs->bdev, &bh, block + i);
+ err = ext4_block_get_noread(inode_ref->fs->bdev, &bh, block + i);
if (err != EOK)
break;
memset(bh.data, 0, block_size);
- bh.dirty = true;
+ ext4_bcache_set_dirty(bh.buf);
err = ext4_block_set(inode_ref->fs->bdev, &bh);
if (err != EOK)
break;
projects / lwext4.git / blobdiff