Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4
Pull Ext4 updates from Theodore Ts'o: "The major new feature added in this update is Darrick J Wong's metadata checksum feature, which adds crc32 checksums to ext4's metadata fields. There is also the usual set of cleanups and bug fixes." * tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (44 commits) ext4: hole-punch use truncate_pagecache_range jbd2: use kmem_cache_zalloc wrapper instead of flag ext4: remove mb_groups before tearing down the buddy_cache ext4: add ext4_mb_unload_buddy in the error path ext4: don't trash state flags in EXT4_IOC_SETFLAGS ext4: let getattr report the right blocks in delalloc+bigalloc ext4: add missing save_error_info() to ext4_error() ext4: add debugging trigger for ext4_error() ext4: protect group inode free counting with group lock ext4: use consistent ssize_t type in ext4_file_write() ext4: fix format flag in ext4_ext_binsearch_idx() ext4: cleanup in ext4_discard_allocated_blocks() ext4: return ENOMEM when mounts fail due to lack of memory ext4: remove redundundant "(char *) bh->b_data" casts ext4: disallow hard-linked directory in ext4_lookup ext4: fix potential integer overflow in alloc_flex_gd() ext4: remove needs_recovery in ext4_mb_init() ext4: force ro mount if ext4_setup_super() fails ext4: fix potential NULL dereference in ext4_free_inodes_counts() ext4/jbd2: add metadata checksumming to the list of supported features ...
This commit is contained in:
Linus Torvalds
445
fs/ext4/namei.c
445
fs/ext4/namei.c
@ -145,6 +145,14 @@ struct dx_map_entry
|
||||
u16 size;
|
||||
};
|
||||
|
||||
/*
|
||||
* This goes at the end of each htree block.
|
||||
*/
|
||||
struct dx_tail {
|
||||
u32 dt_reserved;
|
||||
__le32 dt_checksum; /* crc32c(uuid+inum+dirblock) */
|
||||
};
|
||||
|
||||
static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
|
||||
static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
|
||||
static inline unsigned dx_get_hash(struct dx_entry *entry);
|
||||
@ -180,6 +188,230 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
|
||||
static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
struct inode *inode);
|
||||
|
||||
/* checksumming functions */
|
||||
#define EXT4_DIRENT_TAIL(block, blocksize) \
|
||||
((struct ext4_dir_entry_tail *)(((void *)(block)) + \
|
||||
((blocksize) - \
|
||||
sizeof(struct ext4_dir_entry_tail))))
|
||||
|
||||
static void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
|
||||
unsigned int blocksize)
|
||||
{
|
||||
memset(t, 0, sizeof(struct ext4_dir_entry_tail));
|
||||
t->det_rec_len = ext4_rec_len_to_disk(
|
||||
sizeof(struct ext4_dir_entry_tail), blocksize);
|
||||
t->det_reserved_ft = EXT4_FT_DIR_CSUM;
|
||||
}
|
||||
|
||||
/* Walk through a dirent block to find a checksum "dirent" at the tail */
|
||||
static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
|
||||
struct ext4_dir_entry *de)
|
||||
{
|
||||
struct ext4_dir_entry_tail *t;
|
||||
|
||||
#ifdef PARANOID
|
||||
struct ext4_dir_entry *d, *top;
|
||||
|
||||
d = de;
|
||||
top = (struct ext4_dir_entry *)(((void *)de) +
|
||||
(EXT4_BLOCK_SIZE(inode->i_sb) -
|
||||
sizeof(struct ext4_dir_entry_tail)));
|
||||
while (d < top && d->rec_len)
|
||||
d = (struct ext4_dir_entry *)(((void *)d) +
|
||||
le16_to_cpu(d->rec_len));
|
||||
|
||||
if (d != top)
|
||||
return NULL;
|
||||
|
||||
t = (struct ext4_dir_entry_tail *)d;
|
||||
#else
|
||||
t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb));
|
||||
#endif
|
||||
|
||||
if (t->det_reserved_zero1 ||
|
||||
le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
|
||||
t->det_reserved_zero2 ||
|
||||
t->det_reserved_ft != EXT4_FT_DIR_CSUM)
|
||||
return NULL;
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
static __le32 ext4_dirent_csum(struct inode *inode,
|
||||
struct ext4_dir_entry *dirent, int size)
|
||||
{
|
||||
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
||||
struct ext4_inode_info *ei = EXT4_I(inode);
|
||||
__u32 csum;
|
||||
|
||||
csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
|
||||
return cpu_to_le32(csum);
|
||||
}
|
||||
|
||||
int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
|
||||
{
|
||||
struct ext4_dir_entry_tail *t;
|
||||
|
||||
if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
return 1;
|
||||
|
||||
t = get_dirent_tail(inode, dirent);
|
||||
if (!t) {
|
||||
EXT4_ERROR_INODE(inode, "metadata_csum set but no space in dir "
|
||||
"leaf for checksum. Please run e2fsck -D.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (t->det_checksum != ext4_dirent_csum(inode, dirent,
|
||||
(void *)t - (void *)dirent))
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void ext4_dirent_csum_set(struct inode *inode,
|
||||
struct ext4_dir_entry *dirent)
|
||||
{
|
||||
struct ext4_dir_entry_tail *t;
|
||||
|
||||
if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
return;
|
||||
|
||||
t = get_dirent_tail(inode, dirent);
|
||||
if (!t) {
|
||||
EXT4_ERROR_INODE(inode, "metadata_csum set but no space in dir "
|
||||
"leaf for checksum. Please run e2fsck -D.");
|
||||
return;
|
||||
}
|
||||
|
||||
t->det_checksum = ext4_dirent_csum(inode, dirent,
|
||||
(void *)t - (void *)dirent);
|
||||
}
|
||||
|
||||
static inline int ext4_handle_dirty_dirent_node(handle_t *handle,
|
||||
struct inode *inode,
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
|
||||
return ext4_handle_dirty_metadata(handle, inode, bh);
|
||||
}
|
||||
|
||||
static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
|
||||
struct ext4_dir_entry *dirent,
|
||||
int *offset)
|
||||
{
|
||||
struct ext4_dir_entry *dp;
|
||||
struct dx_root_info *root;
|
||||
int count_offset;
|
||||
|
||||
if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
|
||||
count_offset = 8;
|
||||
else if (le16_to_cpu(dirent->rec_len) == 12) {
|
||||
dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
|
||||
if (le16_to_cpu(dp->rec_len) !=
|
||||
EXT4_BLOCK_SIZE(inode->i_sb) - 12)
|
||||
return NULL;
|
||||
root = (struct dx_root_info *)(((void *)dp + 12));
|
||||
if (root->reserved_zero ||
|
||||
root->info_length != sizeof(struct dx_root_info))
|
||||
return NULL;
|
||||
count_offset = 32;
|
||||
} else
|
||||
return NULL;
|
||||
|
||||
if (offset)
|
||||
*offset = count_offset;
|
||||
return (struct dx_countlimit *)(((void *)dirent) + count_offset);
|
||||
}
|
||||
|
||||
static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
|
||||
int count_offset, int count, struct dx_tail *t)
|
||||
{
|
||||
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
||||
struct ext4_inode_info *ei = EXT4_I(inode);
|
||||
__u32 csum, old_csum;
|
||||
int size;
|
||||
|
||||
size = count_offset + (count * sizeof(struct dx_entry));
|
||||
old_csum = t->dt_checksum;
|
||||
t->dt_checksum = 0;
|
||||
csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
|
||||
csum = ext4_chksum(sbi, csum, (__u8 *)t, sizeof(struct dx_tail));
|
||||
t->dt_checksum = old_csum;
|
||||
|
||||
return cpu_to_le32(csum);
|
||||
}
|
||||
|
||||
static int ext4_dx_csum_verify(struct inode *inode,
|
||||
struct ext4_dir_entry *dirent)
|
||||
{
|
||||
struct dx_countlimit *c;
|
||||
struct dx_tail *t;
|
||||
int count_offset, limit, count;
|
||||
|
||||
if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
return 1;
|
||||
|
||||
c = get_dx_countlimit(inode, dirent, &count_offset);
|
||||
if (!c) {
|
||||
EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
|
||||
return 1;
|
||||
}
|
||||
limit = le16_to_cpu(c->limit);
|
||||
count = le16_to_cpu(c->count);
|
||||
if (count_offset + (limit * sizeof(struct dx_entry)) >
|
||||
EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
|
||||
EXT4_ERROR_INODE(inode, "metadata_csum set but no space for "
|
||||
"tree checksum found. Run e2fsck -D.");
|
||||
return 1;
|
||||
}
|
||||
t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
|
||||
|
||||
if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
|
||||
count, t))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
|
||||
{
|
||||
struct dx_countlimit *c;
|
||||
struct dx_tail *t;
|
||||
int count_offset, limit, count;
|
||||
|
||||
if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
return;
|
||||
|
||||
c = get_dx_countlimit(inode, dirent, &count_offset);
|
||||
if (!c) {
|
||||
EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
|
||||
return;
|
||||
}
|
||||
limit = le16_to_cpu(c->limit);
|
||||
count = le16_to_cpu(c->count);
|
||||
if (count_offset + (limit * sizeof(struct dx_entry)) >
|
||||
EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
|
||||
EXT4_ERROR_INODE(inode, "metadata_csum set but no space for "
|
||||
"tree checksum. Run e2fsck -D.");
|
||||
return;
|
||||
}
|
||||
t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
|
||||
|
||||
t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
|
||||
}
|
||||
|
||||
static inline int ext4_handle_dirty_dx_node(handle_t *handle,
|
||||
struct inode *inode,
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
|
||||
return ext4_handle_dirty_metadata(handle, inode, bh);
|
||||
}
|
||||
|
||||
/*
|
||||
* p is at least 6 bytes before the end of page
|
||||
*/
|
||||
@ -239,12 +471,20 @@ static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
|
||||
{
|
||||
unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
|
||||
EXT4_DIR_REC_LEN(2) - infosize;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
entry_space -= sizeof(struct dx_tail);
|
||||
return entry_space / sizeof(struct dx_entry);
|
||||
}
|
||||
|
||||
static inline unsigned dx_node_limit(struct inode *dir)
|
||||
{
|
||||
unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
entry_space -= sizeof(struct dx_tail);
|
||||
return entry_space / sizeof(struct dx_entry);
|
||||
}
|
||||
|
||||
@ -390,6 +630,15 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dx_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data)) {
|
||||
ext4_warning(dir->i_sb, "Root failed checksum");
|
||||
brelse(bh);
|
||||
*err = ERR_BAD_DX_DIR;
|
||||
goto fail;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
|
||||
entries = (struct dx_entry *) (((char *)&root->info) +
|
||||
root->info.info_length);
|
||||
|
||||
@ -450,6 +699,17 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
|
||||
if (!(bh = ext4_bread (NULL,dir, dx_get_block(at), 0, err)))
|
||||
goto fail2;
|
||||
at = entries = ((struct dx_node *) bh->b_data)->entries;
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dx_csum_verify(dir,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
ext4_warning(dir->i_sb, "Node failed checksum");
|
||||
brelse(bh);
|
||||
*err = ERR_BAD_DX_DIR;
|
||||
goto fail;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
|
||||
if (dx_get_limit(entries) != dx_node_limit (dir)) {
|
||||
ext4_warning(dir->i_sb,
|
||||
"dx entry: limit != node limit");
|
||||
@ -549,6 +809,15 @@ static int ext4_htree_next_block(struct inode *dir, __u32 hash,
|
||||
if (!(bh = ext4_bread(NULL, dir, dx_get_block(p->at),
|
||||
0, &err)))
|
||||
return err; /* Failure */
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dx_csum_verify(dir,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
ext4_warning(dir->i_sb, "Node failed checksum");
|
||||
return -EIO;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
|
||||
p++;
|
||||
brelse(p->bh);
|
||||
p->bh = bh;
|
||||
@ -577,6 +846,11 @@ static int htree_dirblock_to_tree(struct file *dir_file,
|
||||
if (!(bh = ext4_bread (NULL, dir, block, 0, &err)))
|
||||
return err;
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data))
|
||||
return -EIO;
|
||||
set_buffer_verified(bh);
|
||||
|
||||
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
||||
top = (struct ext4_dir_entry_2 *) ((char *) de +
|
||||
dir->i_sb->s_blocksize -
|
||||
@ -936,6 +1210,15 @@ restart:
|
||||
brelse(bh);
|
||||
goto next;
|
||||
}
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(dir,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
EXT4_ERROR_INODE(dir, "checksumming directory "
|
||||
"block %lu", (unsigned long)block);
|
||||
brelse(bh);
|
||||
goto next;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
i = search_dirblock(bh, dir, d_name,
|
||||
block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
|
||||
if (i == 1) {
|
||||
@ -987,6 +1270,16 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct q
|
||||
if (!(bh = ext4_bread(NULL, dir, block, 0, err)))
|
||||
goto errout;
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(dir,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
EXT4_ERROR_INODE(dir, "checksumming directory "
|
||||
"block %lu", (unsigned long)block);
|
||||
brelse(bh);
|
||||
*err = -EIO;
|
||||
goto errout;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
retval = search_dirblock(bh, dir, d_name,
|
||||
block << EXT4_BLOCK_SIZE_BITS(sb),
|
||||
res_dir);
|
||||
@ -1037,6 +1330,12 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, stru
|
||||
EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
|
||||
return ERR_PTR(-EIO);
|
||||
}
|
||||
if (unlikely(ino == dir->i_ino)) {
|
||||
EXT4_ERROR_INODE(dir, "'%.*s' linked to parent dir",
|
||||
dentry->d_name.len,
|
||||
dentry->d_name.name);
|
||||
return ERR_PTR(-EIO);
|
||||
}
|
||||
inode = ext4_iget(dir->i_sb, ino);
|
||||
if (inode == ERR_PTR(-ESTALE)) {
|
||||
EXT4_ERROR_INODE(dir,
|
||||
@ -1156,8 +1455,14 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
|
||||
char *data1 = (*bh)->b_data, *data2;
|
||||
unsigned split, move, size;
|
||||
struct ext4_dir_entry_2 *de = NULL, *de2;
|
||||
struct ext4_dir_entry_tail *t;
|
||||
int csum_size = 0;
|
||||
int err = 0, i;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
bh2 = ext4_append (handle, dir, &newblock, &err);
|
||||
if (!(bh2)) {
|
||||
brelse(*bh);
|
||||
@ -1204,10 +1509,20 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
|
||||
/* Fancy dance to stay within two buffers */
|
||||
de2 = dx_move_dirents(data1, data2, map + split, count - split, blocksize);
|
||||
de = dx_pack_dirents(data1, blocksize);
|
||||
de->rec_len = ext4_rec_len_to_disk(data1 + blocksize - (char *) de,
|
||||
de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
|
||||
(char *) de,
|
||||
blocksize);
|
||||
de2->rec_len = ext4_rec_len_to_disk(data2 + blocksize - (char *) de2,
|
||||
de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
|
||||
(char *) de2,
|
||||
blocksize);
|
||||
if (csum_size) {
|
||||
t = EXT4_DIRENT_TAIL(data2, blocksize);
|
||||
initialize_dirent_tail(t, blocksize);
|
||||
|
||||
t = EXT4_DIRENT_TAIL(data1, blocksize);
|
||||
initialize_dirent_tail(t, blocksize);
|
||||
}
|
||||
|
||||
dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data1, blocksize, 1));
|
||||
dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data2, blocksize, 1));
|
||||
|
||||
@ -1218,10 +1533,10 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
|
||||
de = de2;
|
||||
}
|
||||
dx_insert_block(frame, hash2 + continued, newblock);
|
||||
err = ext4_handle_dirty_metadata(handle, dir, bh2);
|
||||
err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
|
||||
if (err)
|
||||
goto journal_error;
|
||||
err = ext4_handle_dirty_metadata(handle, dir, frame->bh);
|
||||
err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
|
||||
if (err)
|
||||
goto journal_error;
|
||||
brelse(bh2);
|
||||
@ -1258,11 +1573,16 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
|
||||
unsigned short reclen;
|
||||
int nlen, rlen, err;
|
||||
char *top;
|
||||
int csum_size = 0;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
reclen = EXT4_DIR_REC_LEN(namelen);
|
||||
if (!de) {
|
||||
de = (struct ext4_dir_entry_2 *)bh->b_data;
|
||||
top = bh->b_data + blocksize - reclen;
|
||||
top = bh->b_data + (blocksize - csum_size) - reclen;
|
||||
while ((char *) de <= top) {
|
||||
if (ext4_check_dir_entry(dir, NULL, de, bh, offset))
|
||||
return -EIO;
|
||||
@ -1295,11 +1615,8 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
|
||||
de = de1;
|
||||
}
|
||||
de->file_type = EXT4_FT_UNKNOWN;
|
||||
if (inode) {
|
||||
de->inode = cpu_to_le32(inode->i_ino);
|
||||
ext4_set_de_type(dir->i_sb, de, inode->i_mode);
|
||||
} else
|
||||
de->inode = 0;
|
||||
de->inode = cpu_to_le32(inode->i_ino);
|
||||
ext4_set_de_type(dir->i_sb, de, inode->i_mode);
|
||||
de->name_len = namelen;
|
||||
memcpy(de->name, name, namelen);
|
||||
/*
|
||||
@ -1318,7 +1635,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
|
||||
dir->i_version++;
|
||||
ext4_mark_inode_dirty(handle, dir);
|
||||
BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
|
||||
err = ext4_handle_dirty_metadata(handle, dir, bh);
|
||||
err = ext4_handle_dirty_dirent_node(handle, dir, bh);
|
||||
if (err)
|
||||
ext4_std_error(dir->i_sb, err);
|
||||
return 0;
|
||||
@ -1339,6 +1656,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
|
||||
struct dx_frame frames[2], *frame;
|
||||
struct dx_entry *entries;
|
||||
struct ext4_dir_entry_2 *de, *de2;
|
||||
struct ext4_dir_entry_tail *t;
|
||||
char *data1, *top;
|
||||
unsigned len;
|
||||
int retval;
|
||||
@ -1346,6 +1664,11 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
|
||||
struct dx_hash_info hinfo;
|
||||
ext4_lblk_t block;
|
||||
struct fake_dirent *fde;
|
||||
int csum_size = 0;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
blocksize = dir->i_sb->s_blocksize;
|
||||
dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
|
||||
@ -1366,7 +1689,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
|
||||
brelse(bh);
|
||||
return -EIO;
|
||||
}
|
||||
len = ((char *) root) + blocksize - (char *) de;
|
||||
len = ((char *) root) + (blocksize - csum_size) - (char *) de;
|
||||
|
||||
/* Allocate new block for the 0th block's dirents */
|
||||
bh2 = ext4_append(handle, dir, &block, &retval);
|
||||
@ -1382,8 +1705,15 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
|
||||
top = data1 + len;
|
||||
while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
|
||||
de = de2;
|
||||
de->rec_len = ext4_rec_len_to_disk(data1 + blocksize - (char *) de,
|
||||
de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
|
||||
(char *) de,
|
||||
blocksize);
|
||||
|
||||
if (csum_size) {
|
||||
t = EXT4_DIRENT_TAIL(data1, blocksize);
|
||||
initialize_dirent_tail(t, blocksize);
|
||||
}
|
||||
|
||||
/* Initialize the root; the dot dirents already exist */
|
||||
de = (struct ext4_dir_entry_2 *) (&root->dotdot);
|
||||
de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
|
||||
@ -1408,8 +1738,8 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
|
||||
frame->bh = bh;
|
||||
bh = bh2;
|
||||
|
||||
ext4_handle_dirty_metadata(handle, dir, frame->bh);
|
||||
ext4_handle_dirty_metadata(handle, dir, bh);
|
||||
ext4_handle_dirty_dx_node(handle, dir, frame->bh);
|
||||
ext4_handle_dirty_dirent_node(handle, dir, bh);
|
||||
|
||||
de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
|
||||
if (!de) {
|
||||
@ -1445,11 +1775,17 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
struct inode *dir = dentry->d_parent->d_inode;
|
||||
struct buffer_head *bh;
|
||||
struct ext4_dir_entry_2 *de;
|
||||
struct ext4_dir_entry_tail *t;
|
||||
struct super_block *sb;
|
||||
int retval;
|
||||
int dx_fallback=0;
|
||||
unsigned blocksize;
|
||||
ext4_lblk_t block, blocks;
|
||||
int csum_size = 0;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
sb = dir->i_sb;
|
||||
blocksize = sb->s_blocksize;
|
||||
@ -1468,6 +1804,11 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
bh = ext4_bread(handle, dir, block, 0, &retval);
|
||||
if(!bh)
|
||||
return retval;
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(dir,
|
||||
(struct ext4_dir_entry *)bh->b_data))
|
||||
return -EIO;
|
||||
set_buffer_verified(bh);
|
||||
retval = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
|
||||
if (retval != -ENOSPC) {
|
||||
brelse(bh);
|
||||
@ -1484,7 +1825,13 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
return retval;
|
||||
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
||||
de->inode = 0;
|
||||
de->rec_len = ext4_rec_len_to_disk(blocksize, blocksize);
|
||||
de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
|
||||
|
||||
if (csum_size) {
|
||||
t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
|
||||
initialize_dirent_tail(t, blocksize);
|
||||
}
|
||||
|
||||
retval = add_dirent_to_buf(handle, dentry, inode, de, bh);
|
||||
brelse(bh);
|
||||
if (retval == 0)
|
||||
@ -1516,6 +1863,11 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
if (!(bh = ext4_bread(handle,dir, dx_get_block(frame->at), 0, &err)))
|
||||
goto cleanup;
|
||||
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(dir, (struct ext4_dir_entry *)bh->b_data))
|
||||
goto journal_error;
|
||||
set_buffer_verified(bh);
|
||||
|
||||
BUFFER_TRACE(bh, "get_write_access");
|
||||
err = ext4_journal_get_write_access(handle, bh);
|
||||
if (err)
|
||||
@ -1583,7 +1935,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
dxtrace(dx_show_index("node", frames[1].entries));
|
||||
dxtrace(dx_show_index("node",
|
||||
((struct dx_node *) bh2->b_data)->entries));
|
||||
err = ext4_handle_dirty_metadata(handle, dir, bh2);
|
||||
err = ext4_handle_dirty_dx_node(handle, dir, bh2);
|
||||
if (err)
|
||||
goto journal_error;
|
||||
brelse (bh2);
|
||||
@ -1609,7 +1961,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
|
||||
if (err)
|
||||
goto journal_error;
|
||||
}
|
||||
err = ext4_handle_dirty_metadata(handle, dir, frames[0].bh);
|
||||
err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
|
||||
if (err) {
|
||||
ext4_std_error(inode->i_sb, err);
|
||||
goto cleanup;
|
||||
@ -1641,12 +1993,17 @@ static int ext4_delete_entry(handle_t *handle,
|
||||
{
|
||||
struct ext4_dir_entry_2 *de, *pde;
|
||||
unsigned int blocksize = dir->i_sb->s_blocksize;
|
||||
int csum_size = 0;
|
||||
int i, err;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
i = 0;
|
||||
pde = NULL;
|
||||
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
||||
while (i < bh->b_size) {
|
||||
while (i < bh->b_size - csum_size) {
|
||||
if (ext4_check_dir_entry(dir, NULL, de, bh, i))
|
||||
return -EIO;
|
||||
if (de == de_del) {
|
||||
@ -1667,7 +2024,7 @@ static int ext4_delete_entry(handle_t *handle,
|
||||
de->inode = 0;
|
||||
dir->i_version++;
|
||||
BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
|
||||
err = ext4_handle_dirty_metadata(handle, dir, bh);
|
||||
err = ext4_handle_dirty_dirent_node(handle, dir, bh);
|
||||
if (unlikely(err)) {
|
||||
ext4_std_error(dir->i_sb, err);
|
||||
return err;
|
||||
@ -1809,9 +2166,15 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
||||
struct inode *inode;
|
||||
struct buffer_head *dir_block = NULL;
|
||||
struct ext4_dir_entry_2 *de;
|
||||
struct ext4_dir_entry_tail *t;
|
||||
unsigned int blocksize = dir->i_sb->s_blocksize;
|
||||
int csum_size = 0;
|
||||
int err, retries = 0;
|
||||
|
||||
if (EXT4_HAS_RO_COMPAT_FEATURE(dir->i_sb,
|
||||
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
|
||||
csum_size = sizeof(struct ext4_dir_entry_tail);
|
||||
|
||||
if (EXT4_DIR_LINK_MAX(dir))
|
||||
return -EMLINK;
|
||||
|
||||
@ -1852,16 +2215,24 @@ retry:
|
||||
ext4_set_de_type(dir->i_sb, de, S_IFDIR);
|
||||
de = ext4_next_entry(de, blocksize);
|
||||
de->inode = cpu_to_le32(dir->i_ino);
|
||||
de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(1),
|
||||
de->rec_len = ext4_rec_len_to_disk(blocksize -
|
||||
(csum_size + EXT4_DIR_REC_LEN(1)),
|
||||
blocksize);
|
||||
de->name_len = 2;
|
||||
strcpy(de->name, "..");
|
||||
ext4_set_de_type(dir->i_sb, de, S_IFDIR);
|
||||
set_nlink(inode, 2);
|
||||
|
||||
if (csum_size) {
|
||||
t = EXT4_DIRENT_TAIL(dir_block->b_data, blocksize);
|
||||
initialize_dirent_tail(t, blocksize);
|
||||
}
|
||||
|
||||
BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
|
||||
err = ext4_handle_dirty_metadata(handle, inode, dir_block);
|
||||
err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
|
||||
if (err)
|
||||
goto out_clear_inode;
|
||||
set_buffer_verified(dir_block);
|
||||
err = ext4_mark_inode_dirty(handle, inode);
|
||||
if (!err)
|
||||
err = ext4_add_entry(handle, dentry, inode);
|
||||
@ -1911,6 +2282,14 @@ static int empty_dir(struct inode *inode)
|
||||
inode->i_ino);
|
||||
return 1;
|
||||
}
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(inode,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
EXT4_ERROR_INODE(inode, "checksum error reading directory "
|
||||
"lblock 0");
|
||||
return -EIO;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
||||
de1 = ext4_next_entry(de, sb->s_blocksize);
|
||||
if (le32_to_cpu(de->inode) != inode->i_ino ||
|
||||
@ -1942,6 +2321,14 @@ static int empty_dir(struct inode *inode)
|
||||
offset += sb->s_blocksize;
|
||||
continue;
|
||||
}
|
||||
if (!buffer_verified(bh) &&
|
||||
!ext4_dirent_csum_verify(inode,
|
||||
(struct ext4_dir_entry *)bh->b_data)) {
|
||||
EXT4_ERROR_INODE(inode, "checksum error "
|
||||
"reading directory lblock 0");
|
||||
return -EIO;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
de = (struct ext4_dir_entry_2 *) bh->b_data;
|
||||
}
|
||||
if (ext4_check_dir_entry(inode, NULL, de, bh, offset)) {
|
||||
@ -2010,7 +2397,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
|
||||
/* Insert this inode at the head of the on-disk orphan list... */
|
||||
NEXT_ORPHAN(inode) = le32_to_cpu(EXT4_SB(sb)->s_es->s_last_orphan);
|
||||
EXT4_SB(sb)->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
|
||||
err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
|
||||
err = ext4_handle_dirty_super_now(handle, sb);
|
||||
rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
|
||||
if (!err)
|
||||
err = rc;
|
||||
@ -2083,7 +2470,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode)
|
||||
if (err)
|
||||
goto out_brelse;
|
||||
sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
|
||||
err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
|
||||
err = ext4_handle_dirty_super_now(handle, inode->i_sb);
|
||||
} else {
|
||||
struct ext4_iloc iloc2;
|
||||
struct inode *i_prev =
|
||||
@ -2442,6 +2829,11 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
|
||||
dir_bh = ext4_bread(handle, old_inode, 0, 0, &retval);
|
||||
if (!dir_bh)
|
||||
goto end_rename;
|
||||
if (!buffer_verified(dir_bh) &&
|
||||
!ext4_dirent_csum_verify(old_inode,
|
||||
(struct ext4_dir_entry *)dir_bh->b_data))
|
||||
goto end_rename;
|
||||
set_buffer_verified(dir_bh);
|
||||
if (le32_to_cpu(PARENT_INO(dir_bh->b_data,
|
||||
old_dir->i_sb->s_blocksize)) != old_dir->i_ino)
|
||||
goto end_rename;
|
||||
@ -2472,7 +2864,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
|
||||
ext4_current_time(new_dir);
|
||||
ext4_mark_inode_dirty(handle, new_dir);
|
||||
BUFFER_TRACE(new_bh, "call ext4_handle_dirty_metadata");
|
||||
retval = ext4_handle_dirty_metadata(handle, new_dir, new_bh);
|
||||
retval = ext4_handle_dirty_dirent_node(handle, new_dir, new_bh);
|
||||
if (unlikely(retval)) {
|
||||
ext4_std_error(new_dir->i_sb, retval);
|
||||
goto end_rename;
|
||||
@ -2526,7 +2918,8 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
|
||||
PARENT_INO(dir_bh->b_data, new_dir->i_sb->s_blocksize) =
|
||||
cpu_to_le32(new_dir->i_ino);
|
||||
BUFFER_TRACE(dir_bh, "call ext4_handle_dirty_metadata");
|
||||
retval = ext4_handle_dirty_metadata(handle, old_inode, dir_bh);
|
||||
retval = ext4_handle_dirty_dirent_node(handle, old_inode,
|
||||
dir_bh);
|
||||
if (retval) {
|
||||
ext4_std_error(old_dir->i_sb, retval);
|
||||
goto end_rename;
|
||||
|
||||
Reference in New Issue
Block a user