mirror of
https://github.com/torvalds/linux.git
synced 2024-11-21 19:41:42 +00:00
Some ext4 bug fixes (mostly to address Syzbot reports) for v6.4-rc2.
-----BEGIN PGP SIGNATURE----- iQEzBAABCAAdFiEEK2m5VNv+CHkogTfJ8vlZVpUNgaMFAmRgCfAACgkQ8vlZVpUN gaOaOgf5AbFUBsjb95Aq2Y6SKvlyO2xFd2OqJXu6+bGaJScQ8qeoW2byihN4vD/e i5V5vivpk764k1uOUe9fq5BlkaTuvFJI8d81eEnJC3LW4s7r6Gv586dwbE5lr0Bq cZKCVMYdgwz3admGtPXrN0CVgg+Y/wHb1ZmGtt2nAqZfNqYfpX0waDyGr6JebhkO 04VE8QQCvMkO6oOIR9ZfbJmVm5vrGqQVLW4T0hXVTj9r3gUu/61qAkt2XYAu5tKJ ENIoMv2ix0asAgFSbcIzY6YnCzSY9hiV/K6Twtusf63r22T+r6+LXBqUe+8hMx4E Vh8L+5wkeNkCXD8HwnHizPx5r0nLqw== =ouFA -----END PGP SIGNATURE----- Merge tag 'ext4_for_linus_stable' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 Pull ext4 fixes from Ted Ts'o: "Some ext4 bug fixes (mostly to address Syzbot reports)" * tag 'ext4_for_linus_stable' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: ext4: bail out of ext4_xattr_ibody_get() fails for any reason ext4: add bounds checking in get_max_inline_xattr_value_size() ext4: add indication of ro vs r/w mounts in the mount message ext4: fix deadlock when converting an inline directory in nojournal mode ext4: improve error recovery code paths in __ext4_remount() ext4: improve error handling from ext4_dirhash() ext4: don't clear SB_RDONLY when remounting r/w until quota is re-enabled ext4: check iomap type only if ext4_iomap_begin() does not fail ext4: avoid a potential slab-out-of-bounds in ext4_group_desc_csum ext4: fix data races when using cached status extents ext4: avoid deadlock in fs reclaim with page writeback ext4: fix invalid free tracking in ext4_xattr_move_to_block() ext4: remove a BUG_ON in ext4_mb_release_group_pa() ext4: allow ext4_get_group_info() to fail ext4: fix lockdep warning when enabling MMP ext4: fix WARNING in mb_find_extent
This commit is contained in:
Linus Torvalds
commit
bb7c241fae
@ -305,6 +305,38 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
|
||||
return desc;
|
||||
}
|
||||
|
||||
static ext4_fsblk_t ext4_valid_block_bitmap_padding(struct super_block *sb,
|
||||
ext4_group_t block_group,
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
ext4_grpblk_t next_zero_bit;
|
||||
unsigned long bitmap_size = sb->s_blocksize * 8;
|
||||
unsigned int offset = num_clusters_in_group(sb, block_group);
|
||||
|
||||
if (bitmap_size <= offset)
|
||||
return 0;
|
||||
|
||||
next_zero_bit = ext4_find_next_zero_bit(bh->b_data, bitmap_size, offset);
|
||||
|
||||
return (next_zero_bit < bitmap_size ? next_zero_bit : 0);
|
||||
}
|
||||
|
||||
struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
|
||||
ext4_group_t group)
|
||||
{
|
||||
struct ext4_group_info **grp_info;
|
||||
long indexv, indexh;
|
||||
|
||||
if (unlikely(group >= EXT4_SB(sb)->s_groups_count)) {
|
||||
ext4_error(sb, "invalid group %u", group);
|
||||
return NULL;
|
||||
}
|
||||
indexv = group >> (EXT4_DESC_PER_BLOCK_BITS(sb));
|
||||
indexh = group & ((EXT4_DESC_PER_BLOCK(sb)) - 1);
|
||||
grp_info = sbi_array_rcu_deref(EXT4_SB(sb), s_group_info, indexv);
|
||||
return grp_info[indexh];
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the block number which was discovered to be invalid, or 0 if
|
||||
* the block bitmap is valid.
|
||||
@ -379,7 +411,7 @@ static int ext4_validate_block_bitmap(struct super_block *sb,
|
||||
|
||||
if (buffer_verified(bh))
|
||||
return 0;
|
||||
if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
|
||||
if (!grp || EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
|
||||
return -EFSCORRUPTED;
|
||||
|
||||
ext4_lock_group(sb, block_group);
|
||||
@ -402,6 +434,15 @@ static int ext4_validate_block_bitmap(struct super_block *sb,
|
||||
EXT4_GROUP_INFO_BBITMAP_CORRUPT);
|
||||
return -EFSCORRUPTED;
|
||||
}
|
||||
blk = ext4_valid_block_bitmap_padding(sb, block_group, bh);
|
||||
if (unlikely(blk != 0)) {
|
||||
ext4_unlock_group(sb, block_group);
|
||||
ext4_error(sb, "bg %u: block %llu: padding at end of block bitmap is not set",
|
||||
block_group, blk);
|
||||
ext4_mark_group_bitmap_corrupted(sb, block_group,
|
||||
EXT4_GROUP_INFO_BBITMAP_CORRUPT);
|
||||
return -EFSCORRUPTED;
|
||||
}
|
||||
set_buffer_verified(bh);
|
||||
verified:
|
||||
ext4_unlock_group(sb, block_group);
|
||||
|
||||
@ -1684,6 +1684,30 @@ static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
|
||||
return container_of(inode, struct ext4_inode_info, vfs_inode);
|
||||
}
|
||||
|
||||
static inline int ext4_writepages_down_read(struct super_block *sb)
|
||||
{
|
||||
percpu_down_read(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
return memalloc_nofs_save();
|
||||
}
|
||||
|
||||
static inline void ext4_writepages_up_read(struct super_block *sb, int ctx)
|
||||
{
|
||||
memalloc_nofs_restore(ctx);
|
||||
percpu_up_read(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
}
|
||||
|
||||
static inline int ext4_writepages_down_write(struct super_block *sb)
|
||||
{
|
||||
percpu_down_write(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
return memalloc_nofs_save();
|
||||
}
|
||||
|
||||
static inline void ext4_writepages_up_write(struct super_block *sb, int ctx)
|
||||
{
|
||||
memalloc_nofs_restore(ctx);
|
||||
percpu_up_write(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
}
|
||||
|
||||
static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
|
||||
{
|
||||
return ino == EXT4_ROOT_INO ||
|
||||
@ -2625,6 +2649,8 @@ extern void ext4_check_blocks_bitmap(struct super_block *);
|
||||
extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
|
||||
ext4_group_t block_group,
|
||||
struct buffer_head ** bh);
|
||||
extern struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
|
||||
ext4_group_t group);
|
||||
extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
|
||||
|
||||
extern struct buffer_head *ext4_read_block_bitmap_nowait(struct super_block *sb,
|
||||
@ -3232,19 +3258,6 @@ static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
|
||||
raw_inode->i_size_high = cpu_to_le32(i_size >> 32);
|
||||
}
|
||||
|
||||
static inline
|
||||
struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
|
||||
ext4_group_t group)
|
||||
{
|
||||
struct ext4_group_info **grp_info;
|
||||
long indexv, indexh;
|
||||
BUG_ON(group >= EXT4_SB(sb)->s_groups_count);
|
||||
indexv = group >> (EXT4_DESC_PER_BLOCK_BITS(sb));
|
||||
indexh = group & ((EXT4_DESC_PER_BLOCK(sb)) - 1);
|
||||
grp_info = sbi_array_rcu_deref(EXT4_SB(sb), s_group_info, indexv);
|
||||
return grp_info[indexh];
|
||||
}
|
||||
|
||||
/*
|
||||
* Reading s_groups_count requires using smp_rmb() afterwards. See
|
||||
* the locking protocol documented in the comments of ext4_group_add()
|
||||
|
||||
@ -267,14 +267,12 @@ static void __es_find_extent_range(struct inode *inode,
|
||||
|
||||
/* see if the extent has been cached */
|
||||
es->es_lblk = es->es_len = es->es_pblk = 0;
|
||||
if (tree->cache_es) {
|
||||
es1 = tree->cache_es;
|
||||
if (in_range(lblk, es1->es_lblk, es1->es_len)) {
|
||||
es_debug("%u cached by [%u/%u) %llu %x\n",
|
||||
lblk, es1->es_lblk, es1->es_len,
|
||||
ext4_es_pblock(es1), ext4_es_status(es1));
|
||||
goto out;
|
||||
}
|
||||
es1 = READ_ONCE(tree->cache_es);
|
||||
if (es1 && in_range(lblk, es1->es_lblk, es1->es_len)) {
|
||||
es_debug("%u cached by [%u/%u) %llu %x\n",
|
||||
lblk, es1->es_lblk, es1->es_len,
|
||||
ext4_es_pblock(es1), ext4_es_status(es1));
|
||||
goto out;
|
||||
}
|
||||
|
||||
es1 = __es_tree_search(&tree->root, lblk);
|
||||
@ -293,7 +291,7 @@ out:
|
||||
}
|
||||
|
||||
if (es1 && matching_fn(es1)) {
|
||||
tree->cache_es = es1;
|
||||
WRITE_ONCE(tree->cache_es, es1);
|
||||
es->es_lblk = es1->es_lblk;
|
||||
es->es_len = es1->es_len;
|
||||
es->es_pblk = es1->es_pblk;
|
||||
@ -931,14 +929,12 @@ int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
|
||||
|
||||
/* find extent in cache firstly */
|
||||
es->es_lblk = es->es_len = es->es_pblk = 0;
|
||||
if (tree->cache_es) {
|
||||
es1 = tree->cache_es;
|
||||
if (in_range(lblk, es1->es_lblk, es1->es_len)) {
|
||||
es_debug("%u cached by [%u/%u)\n",
|
||||
lblk, es1->es_lblk, es1->es_len);
|
||||
found = 1;
|
||||
goto out;
|
||||
}
|
||||
es1 = READ_ONCE(tree->cache_es);
|
||||
if (es1 && in_range(lblk, es1->es_lblk, es1->es_len)) {
|
||||
es_debug("%u cached by [%u/%u)\n",
|
||||
lblk, es1->es_lblk, es1->es_len);
|
||||
found = 1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
node = tree->root.rb_node;
|
||||
|
||||
@ -277,7 +277,11 @@ static int __ext4fs_dirhash(const struct inode *dir, const char *name, int len,
|
||||
}
|
||||
default:
|
||||
hinfo->hash = 0;
|
||||
return -1;
|
||||
hinfo->minor_hash = 0;
|
||||
ext4_warning(dir->i_sb,
|
||||
"invalid/unsupported hash tree version %u",
|
||||
hinfo->hash_version);
|
||||
return -EINVAL;
|
||||
}
|
||||
hash = hash & ~1;
|
||||
if (hash == (EXT4_HTREE_EOF_32BIT << 1))
|
||||
|
||||
@ -91,7 +91,7 @@ static int ext4_validate_inode_bitmap(struct super_block *sb,
|
||||
|
||||
if (buffer_verified(bh))
|
||||
return 0;
|
||||
if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
|
||||
if (!grp || EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
|
||||
return -EFSCORRUPTED;
|
||||
|
||||
ext4_lock_group(sb, block_group);
|
||||
@ -293,7 +293,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
|
||||
}
|
||||
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) {
|
||||
grp = ext4_get_group_info(sb, block_group);
|
||||
if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
|
||||
if (!grp || unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
|
||||
fatal = -EFSCORRUPTED;
|
||||
goto error_return;
|
||||
}
|
||||
@ -1046,7 +1046,7 @@ got_group:
|
||||
* Skip groups with already-known suspicious inode
|
||||
* tables
|
||||
*/
|
||||
if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
|
||||
if (!grp || EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
|
||||
goto next_group;
|
||||
}
|
||||
|
||||
@ -1183,6 +1183,10 @@ got:
|
||||
|
||||
if (!(sbi->s_mount_state & EXT4_FC_REPLAY)) {
|
||||
grp = ext4_get_group_info(sb, group);
|
||||
if (!grp) {
|
||||
err = -EFSCORRUPTED;
|
||||
goto out;
|
||||
}
|
||||
down_read(&grp->alloc_sem); /*
|
||||
* protect vs itable
|
||||
* lazyinit
|
||||
@ -1526,7 +1530,7 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
|
||||
}
|
||||
|
||||
gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
|
||||
if (!gdp)
|
||||
if (!gdp || !grp)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
|
||||
@ -34,6 +34,7 @@ static int get_max_inline_xattr_value_size(struct inode *inode,
|
||||
struct ext4_xattr_ibody_header *header;
|
||||
struct ext4_xattr_entry *entry;
|
||||
struct ext4_inode *raw_inode;
|
||||
void *end;
|
||||
int free, min_offs;
|
||||
|
||||
if (!EXT4_INODE_HAS_XATTR_SPACE(inode))
|
||||
@ -57,14 +58,23 @@ static int get_max_inline_xattr_value_size(struct inode *inode,
|
||||
raw_inode = ext4_raw_inode(iloc);
|
||||
header = IHDR(inode, raw_inode);
|
||||
entry = IFIRST(header);
|
||||
end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
|
||||
|
||||
/* Compute min_offs. */
|
||||
for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
|
||||
while (!IS_LAST_ENTRY(entry)) {
|
||||
void *next = EXT4_XATTR_NEXT(entry);
|
||||
|
||||
if (next >= end) {
|
||||
EXT4_ERROR_INODE(inode,
|
||||
"corrupt xattr in inline inode");
|
||||
return 0;
|
||||
}
|
||||
if (!entry->e_value_inum && entry->e_value_size) {
|
||||
size_t offs = le16_to_cpu(entry->e_value_offs);
|
||||
if (offs < min_offs)
|
||||
min_offs = offs;
|
||||
}
|
||||
entry = next;
|
||||
}
|
||||
free = min_offs -
|
||||
((void *)entry - (void *)IFIRST(header)) - sizeof(__u32);
|
||||
@ -350,7 +360,7 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode,
|
||||
|
||||
error = ext4_xattr_ibody_get(inode, i.name_index, i.name,
|
||||
value, len);
|
||||
if (error == -ENODATA)
|
||||
if (error < 0)
|
||||
goto out;
|
||||
|
||||
BUFFER_TRACE(is.iloc.bh, "get_write_access");
|
||||
@ -1175,6 +1185,7 @@ static int ext4_finish_convert_inline_dir(handle_t *handle,
|
||||
ext4_initialize_dirent_tail(dir_block,
|
||||
inode->i_sb->s_blocksize);
|
||||
set_buffer_uptodate(dir_block);
|
||||
unlock_buffer(dir_block);
|
||||
err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
|
||||
if (err)
|
||||
return err;
|
||||
@ -1249,6 +1260,7 @@ static int ext4_convert_inline_data_nolock(handle_t *handle,
|
||||
if (!S_ISDIR(inode->i_mode)) {
|
||||
memcpy(data_bh->b_data, buf, inline_size);
|
||||
set_buffer_uptodate(data_bh);
|
||||
unlock_buffer(data_bh);
|
||||
error = ext4_handle_dirty_metadata(handle,
|
||||
inode, data_bh);
|
||||
} else {
|
||||
@ -1256,7 +1268,6 @@ static int ext4_convert_inline_data_nolock(handle_t *handle,
|
||||
buf, inline_size);
|
||||
}
|
||||
|
||||
unlock_buffer(data_bh);
|
||||
out_restore:
|
||||
if (error)
|
||||
ext4_restore_inline_data(handle, inode, iloc, buf, inline_size);
|
||||
|
||||
@ -2783,11 +2783,12 @@ static int ext4_writepages(struct address_space *mapping,
|
||||
.can_map = 1,
|
||||
};
|
||||
int ret;
|
||||
int alloc_ctx;
|
||||
|
||||
if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
|
||||
return -EIO;
|
||||
|
||||
percpu_down_read(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
alloc_ctx = ext4_writepages_down_read(sb);
|
||||
ret = ext4_do_writepages(&mpd);
|
||||
/*
|
||||
* For data=journal writeback we could have come across pages marked
|
||||
@ -2796,7 +2797,7 @@ static int ext4_writepages(struct address_space *mapping,
|
||||
*/
|
||||
if (!ret && mpd.journalled_more_data)
|
||||
ret = ext4_do_writepages(&mpd);
|
||||
percpu_up_read(&EXT4_SB(sb)->s_writepages_rwsem);
|
||||
ext4_writepages_up_read(sb, alloc_ctx);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@ -2824,17 +2825,18 @@ static int ext4_dax_writepages(struct address_space *mapping,
|
||||
long nr_to_write = wbc->nr_to_write;
|
||||
struct inode *inode = mapping->host;
|
||||
struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
|
||||
int alloc_ctx;
|
||||
|
||||
if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
|
||||
return -EIO;
|
||||
|
||||
percpu_down_read(&sbi->s_writepages_rwsem);
|
||||
alloc_ctx = ext4_writepages_down_read(inode->i_sb);
|
||||
trace_ext4_writepages(inode, wbc);
|
||||
|
||||
ret = dax_writeback_mapping_range(mapping, sbi->s_daxdev, wbc);
|
||||
trace_ext4_writepages_result(inode, wbc, ret,
|
||||
nr_to_write - wbc->nr_to_write);
|
||||
percpu_up_read(&sbi->s_writepages_rwsem);
|
||||
ext4_writepages_up_read(inode->i_sb, alloc_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -3375,7 +3377,7 @@ static int ext4_iomap_overwrite_begin(struct inode *inode, loff_t offset,
|
||||
*/
|
||||
flags &= ~IOMAP_WRITE;
|
||||
ret = ext4_iomap_begin(inode, offset, length, flags, iomap, srcmap);
|
||||
WARN_ON_ONCE(iomap->type != IOMAP_MAPPED);
|
||||
WARN_ON_ONCE(!ret && iomap->type != IOMAP_MAPPED);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -5928,7 +5930,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
|
||||
journal_t *journal;
|
||||
handle_t *handle;
|
||||
int err;
|
||||
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
||||
int alloc_ctx;
|
||||
|
||||
/*
|
||||
* We have to be very careful here: changing a data block's
|
||||
@ -5966,7 +5968,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
|
||||
}
|
||||
}
|
||||
|
||||
percpu_down_write(&sbi->s_writepages_rwsem);
|
||||
alloc_ctx = ext4_writepages_down_write(inode->i_sb);
|
||||
jbd2_journal_lock_updates(journal);
|
||||
|
||||
/*
|
||||
@ -5983,7 +5985,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
|
||||
err = jbd2_journal_flush(journal, 0);
|
||||
if (err < 0) {
|
||||
jbd2_journal_unlock_updates(journal);
|
||||
percpu_up_write(&sbi->s_writepages_rwsem);
|
||||
ext4_writepages_up_write(inode->i_sb, alloc_ctx);
|
||||
return err;
|
||||
}
|
||||
ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
|
||||
@ -5991,7 +5993,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
|
||||
ext4_set_aops(inode);
|
||||
|
||||
jbd2_journal_unlock_updates(journal);
|
||||
percpu_up_write(&sbi->s_writepages_rwsem);
|
||||
ext4_writepages_up_write(inode->i_sb, alloc_ctx);
|
||||
|
||||
if (val)
|
||||
filemap_invalidate_unlock(inode->i_mapping);
|
||||
|
||||
@ -745,6 +745,8 @@ static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
|
||||
MB_CHECK_ASSERT(e4b->bd_info->bb_fragments == fragments);
|
||||
|
||||
grp = ext4_get_group_info(sb, e4b->bd_group);
|
||||
if (!grp)
|
||||
return NULL;
|
||||
list_for_each(cur, &grp->bb_prealloc_list) {
|
||||
ext4_group_t groupnr;
|
||||
struct ext4_prealloc_space *pa;
|
||||
@ -1060,9 +1062,9 @@ mb_set_largest_free_order(struct super_block *sb, struct ext4_group_info *grp)
|
||||
|
||||
static noinline_for_stack
|
||||
void ext4_mb_generate_buddy(struct super_block *sb,
|
||||
void *buddy, void *bitmap, ext4_group_t group)
|
||||
void *buddy, void *bitmap, ext4_group_t group,
|
||||
struct ext4_group_info *grp)
|
||||
{
|
||||
struct ext4_group_info *grp = ext4_get_group_info(sb, group);
|
||||
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
||||
ext4_grpblk_t max = EXT4_CLUSTERS_PER_GROUP(sb);
|
||||
ext4_grpblk_t i = 0;
|
||||
@ -1181,6 +1183,8 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp)
|
||||
break;
|
||||
|
||||
grinfo = ext4_get_group_info(sb, group);
|
||||
if (!grinfo)
|
||||
continue;
|
||||
/*
|
||||
* If page is uptodate then we came here after online resize
|
||||
* which added some new uninitialized group info structs, so
|
||||
@ -1246,6 +1250,10 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp)
|
||||
group, page->index, i * blocksize);
|
||||
trace_ext4_mb_buddy_bitmap_load(sb, group);
|
||||
grinfo = ext4_get_group_info(sb, group);
|
||||
if (!grinfo) {
|
||||
err = -EFSCORRUPTED;
|
||||
goto out;
|
||||
}
|
||||
grinfo->bb_fragments = 0;
|
||||
memset(grinfo->bb_counters, 0,
|
||||
sizeof(*grinfo->bb_counters) *
|
||||
@ -1256,7 +1264,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp)
|
||||
ext4_lock_group(sb, group);
|
||||
/* init the buddy */
|
||||
memset(data, 0xff, blocksize);
|
||||
ext4_mb_generate_buddy(sb, data, incore, group);
|
||||
ext4_mb_generate_buddy(sb, data, incore, group, grinfo);
|
||||
ext4_unlock_group(sb, group);
|
||||
incore = NULL;
|
||||
} else {
|
||||
@ -1370,6 +1378,9 @@ int ext4_mb_init_group(struct super_block *sb, ext4_group_t group, gfp_t gfp)
|
||||
might_sleep();
|
||||
mb_debug(sb, "init group %u\n", group);
|
||||
this_grp = ext4_get_group_info(sb, group);
|
||||
if (!this_grp)
|
||||
return -EFSCORRUPTED;
|
||||
|
||||
/*
|
||||
* This ensures that we don't reinit the buddy cache
|
||||
* page which map to the group from which we are already
|
||||
@ -1444,6 +1455,8 @@ ext4_mb_load_buddy_gfp(struct super_block *sb, ext4_group_t group,
|
||||
|
||||
blocks_per_page = PAGE_SIZE / sb->s_blocksize;
|
||||
grp = ext4_get_group_info(sb, group);
|
||||
if (!grp)
|
||||
return -EFSCORRUPTED;
|
||||
|
||||
e4b->bd_blkbits = sb->s_blocksize_bits;
|
||||
e4b->bd_info = grp;
|
||||
@ -2159,6 +2172,8 @@ int ext4_mb_find_by_goal(struct ext4_allocation_context *ac,
|
||||
struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
|
||||
struct ext4_free_extent ex;
|
||||
|
||||
if (!grp)
|
||||
return -EFSCORRUPTED;
|
||||
if (!(ac->ac_flags & (EXT4_MB_HINT_TRY_GOAL | EXT4_MB_HINT_GOAL_ONLY)))
|
||||
return 0;
|
||||
if (grp->bb_free == 0)
|
||||
@ -2385,7 +2400,7 @@ static bool ext4_mb_good_group(struct ext4_allocation_context *ac,
|
||||
|
||||
BUG_ON(cr < 0 || cr >= 4);
|
||||
|
||||
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(grp)))
|
||||
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(grp) || !grp))
|
||||
return false;
|
||||
|
||||
free = grp->bb_free;
|
||||
@ -2454,6 +2469,8 @@ static int ext4_mb_good_group_nolock(struct ext4_allocation_context *ac,
|
||||
ext4_grpblk_t free;
|
||||
int ret = 0;
|
||||
|
||||
if (!grp)
|
||||
return -EFSCORRUPTED;
|
||||
if (sbi->s_mb_stats)
|
||||
atomic64_inc(&sbi->s_bal_cX_groups_considered[ac->ac_criteria]);
|
||||
if (should_lock) {
|
||||
@ -2534,7 +2551,7 @@ ext4_group_t ext4_mb_prefetch(struct super_block *sb, ext4_group_t group,
|
||||
* prefetch once, so we avoid getblk() call, which can
|
||||
* be expensive.
|
||||
*/
|
||||
if (!EXT4_MB_GRP_TEST_AND_SET_READ(grp) &&
|
||||
if (gdp && grp && !EXT4_MB_GRP_TEST_AND_SET_READ(grp) &&
|
||||
EXT4_MB_GRP_NEED_INIT(grp) &&
|
||||
ext4_free_group_clusters(sb, gdp) > 0 &&
|
||||
!(ext4_has_group_desc_csum(sb) &&
|
||||
@ -2578,7 +2595,7 @@ void ext4_mb_prefetch_fini(struct super_block *sb, ext4_group_t group,
|
||||
gdp = ext4_get_group_desc(sb, group, NULL);
|
||||
grp = ext4_get_group_info(sb, group);
|
||||
|
||||
if (EXT4_MB_GRP_NEED_INIT(grp) &&
|
||||
if (grp && gdp && EXT4_MB_GRP_NEED_INIT(grp) &&
|
||||
ext4_free_group_clusters(sb, gdp) > 0 &&
|
||||
!(ext4_has_group_desc_csum(sb) &&
|
||||
(gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)))) {
|
||||
@ -2837,6 +2854,8 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
|
||||
sizeof(struct ext4_group_info);
|
||||
|
||||
grinfo = ext4_get_group_info(sb, group);
|
||||
if (!grinfo)
|
||||
return 0;
|
||||
/* Load the group info in memory only if not already loaded. */
|
||||
if (unlikely(EXT4_MB_GRP_NEED_INIT(grinfo))) {
|
||||
err = ext4_mb_load_buddy(sb, group, &e4b);
|
||||
@ -2847,7 +2866,7 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
|
||||
buddy_loaded = 1;
|
||||
}
|
||||
|
||||
memcpy(&sg, ext4_get_group_info(sb, group), i);
|
||||
memcpy(&sg, grinfo, i);
|
||||
|
||||
if (buddy_loaded)
|
||||
ext4_mb_unload_buddy(&e4b);
|
||||
@ -3208,8 +3227,12 @@ static int ext4_mb_init_backend(struct super_block *sb)
|
||||
|
||||
err_freebuddy:
|
||||
cachep = get_groupinfo_cache(sb->s_blocksize_bits);
|
||||
while (i-- > 0)
|
||||
kmem_cache_free(cachep, ext4_get_group_info(sb, i));
|
||||
while (i-- > 0) {
|
||||
struct ext4_group_info *grp = ext4_get_group_info(sb, i);
|
||||
|
||||
if (grp)
|
||||
kmem_cache_free(cachep, grp);
|
||||
}
|
||||
i = sbi->s_group_info_size;
|
||||
rcu_read_lock();
|
||||
group_info = rcu_dereference(sbi->s_group_info);
|
||||
@ -3522,6 +3545,8 @@ int ext4_mb_release(struct super_block *sb)
|
||||
for (i = 0; i < ngroups; i++) {
|
||||
cond_resched();
|
||||
grinfo = ext4_get_group_info(sb, i);
|
||||
if (!grinfo)
|
||||
continue;
|
||||
mb_group_bb_bitmap_free(grinfo);
|
||||
ext4_lock_group(sb, i);
|
||||
count = ext4_mb_cleanup_pa(grinfo);
|
||||
@ -4606,6 +4631,8 @@ static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
|
||||
struct ext4_free_data *entry;
|
||||
|
||||
grp = ext4_get_group_info(sb, group);
|
||||
if (!grp)
|
||||
return;
|
||||
n = rb_first(&(grp->bb_free_root));
|
||||
|
||||
while (n) {
|
||||
@ -4633,6 +4660,9 @@ void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
|
||||
int preallocated = 0;
|
||||
int len;
|
||||
|
||||
if (!grp)
|
||||
return;
|
||||
|
||||
/* all form of preallocation discards first load group,
|
||||
* so the only competing code is preallocation use.
|
||||
* we don't need any locking here
|
||||
@ -4869,6 +4899,8 @@ adjust_bex:
|
||||
|
||||
ei = EXT4_I(ac->ac_inode);
|
||||
grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
|
||||
if (!grp)
|
||||
return;
|
||||
|
||||
pa->pa_node_lock.inode_lock = &ei->i_prealloc_lock;
|
||||
pa->pa_inode = ac->ac_inode;
|
||||
@ -4918,6 +4950,8 @@ ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
|
||||
atomic_add(pa->pa_free, &EXT4_SB(sb)->s_mb_preallocated);
|
||||
|
||||
grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
|
||||
if (!grp)
|
||||
return;
|
||||
lg = ac->ac_lg;
|
||||
BUG_ON(lg == NULL);
|
||||
|
||||
@ -5013,7 +5047,11 @@ ext4_mb_release_group_pa(struct ext4_buddy *e4b,
|
||||
trace_ext4_mb_release_group_pa(sb, pa);
|
||||
BUG_ON(pa->pa_deleted == 0);
|
||||
ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
|
||||
BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
|
||||
if (unlikely(group != e4b->bd_group && pa->pa_len != 0)) {
|
||||
ext4_warning(sb, "bad group: expected %u, group %u, pa_start %llu",
|
||||
e4b->bd_group, group, pa->pa_pstart);
|
||||
return 0;
|
||||
}
|
||||
mb_free_blocks(pa->pa_inode, e4b, bit, pa->pa_len);
|
||||
atomic_add(pa->pa_len, &EXT4_SB(sb)->s_mb_discarded);
|
||||
trace_ext4_mballoc_discard(sb, NULL, group, bit, pa->pa_len);
|
||||
@ -5043,6 +5081,8 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,
|
||||
int err;
|
||||
int free = 0;
|
||||
|
||||
if (!grp)
|
||||
return 0;
|
||||
mb_debug(sb, "discard preallocation for group %u\n", group);
|
||||
if (list_empty(&grp->bb_prealloc_list))
|
||||
goto out_dbg;
|
||||
@ -5297,6 +5337,9 @@ static inline void ext4_mb_show_pa(struct super_block *sb)
|
||||
struct ext4_prealloc_space *pa;
|
||||
ext4_grpblk_t start;
|
||||
struct list_head *cur;
|
||||
|
||||
if (!grp)
|
||||
continue;
|
||||
ext4_lock_group(sb, i);
|
||||
list_for_each(cur, &grp->bb_prealloc_list) {
|
||||
pa = list_entry(cur, struct ext4_prealloc_space,
|
||||
@ -6064,6 +6107,7 @@ static void ext4_mb_clear_bb(handle_t *handle, struct inode *inode,
|
||||
struct buffer_head *bitmap_bh = NULL;
|
||||
struct super_block *sb = inode->i_sb;
|
||||
struct ext4_group_desc *gdp;
|
||||
struct ext4_group_info *grp;
|
||||
unsigned int overflow;
|
||||
ext4_grpblk_t bit;
|
||||
struct buffer_head *gd_bh;
|
||||
@ -6089,8 +6133,8 @@ do_more:
|
||||
overflow = 0;
|
||||
ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
|
||||
|
||||
if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(
|
||||
ext4_get_group_info(sb, block_group))))
|
||||
grp = ext4_get_group_info(sb, block_group);
|
||||
if (unlikely(!grp || EXT4_MB_GRP_BBITMAP_CORRUPT(grp)))
|
||||
return;
|
||||
|
||||
/*
|
||||
@ -6692,6 +6736,8 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
|
||||
|
||||
for (group = first_group; group <= last_group; group++) {
|
||||
grp = ext4_get_group_info(sb, group);
|
||||
if (!grp)
|
||||
continue;
|
||||
/* We only do this if the grp has never been initialized */
|
||||
if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
|
||||
ret = ext4_mb_init_group(sb, group, GFP_NOFS);
|
||||
|
||||
@ -408,7 +408,6 @@ static int free_ext_block(handle_t *handle, struct inode *inode)
|
||||
|
||||
int ext4_ext_migrate(struct inode *inode)
|
||||
{
|
||||
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
||||
handle_t *handle;
|
||||
int retval = 0, i;
|
||||
__le32 *i_data;
|
||||
@ -418,6 +417,7 @@ int ext4_ext_migrate(struct inode *inode)
|
||||
unsigned long max_entries;
|
||||
__u32 goal, tmp_csum_seed;
|
||||
uid_t owner[2];
|
||||
int alloc_ctx;
|
||||
|
||||
/*
|
||||
* If the filesystem does not support extents, or the inode
|
||||
@ -434,7 +434,7 @@ int ext4_ext_migrate(struct inode *inode)
|
||||
*/
|
||||
return retval;
|
||||
|
||||
percpu_down_write(&sbi->s_writepages_rwsem);
|
||||
alloc_ctx = ext4_writepages_down_write(inode->i_sb);
|
||||
|
||||
/*
|
||||
* Worst case we can touch the allocation bitmaps and a block
|
||||
@ -586,7 +586,7 @@ out_tmp_inode:
|
||||
unlock_new_inode(tmp_inode);
|
||||
iput(tmp_inode);
|
||||
out_unlock:
|
||||
percpu_up_write(&sbi->s_writepages_rwsem);
|
||||
ext4_writepages_up_write(inode->i_sb, alloc_ctx);
|
||||
return retval;
|
||||
}
|
||||
|
||||
@ -605,6 +605,7 @@ int ext4_ind_migrate(struct inode *inode)
|
||||
ext4_fsblk_t blk;
|
||||
handle_t *handle;
|
||||
int ret, ret2 = 0;
|
||||
int alloc_ctx;
|
||||
|
||||
if (!ext4_has_feature_extents(inode->i_sb) ||
|
||||
(!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
|
||||
@ -621,7 +622,7 @@ int ext4_ind_migrate(struct inode *inode)
|
||||
if (test_opt(inode->i_sb, DELALLOC))
|
||||
ext4_alloc_da_blocks(inode);
|
||||
|
||||
percpu_down_write(&sbi->s_writepages_rwsem);
|
||||
alloc_ctx = ext4_writepages_down_write(inode->i_sb);
|
||||
|
||||
handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
|
||||
if (IS_ERR(handle)) {
|
||||
@ -665,6 +666,6 @@ errout:
|
||||
ext4_journal_stop(handle);
|
||||
up_write(&EXT4_I(inode)->i_data_sem);
|
||||
out_unlock:
|
||||
percpu_up_write(&sbi->s_writepages_rwsem);
|
||||
ext4_writepages_up_write(inode->i_sb, alloc_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -39,28 +39,36 @@ static void ext4_mmp_csum_set(struct super_block *sb, struct mmp_struct *mmp)
|
||||
* Write the MMP block using REQ_SYNC to try to get the block on-disk
|
||||
* faster.
|
||||
*/
|
||||
static int write_mmp_block(struct super_block *sb, struct buffer_head *bh)
|
||||
static int write_mmp_block_thawed(struct super_block *sb,
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
struct mmp_struct *mmp = (struct mmp_struct *)(bh->b_data);
|
||||
|
||||
/*
|
||||
* We protect against freezing so that we don't create dirty buffers
|
||||
* on frozen filesystem.
|
||||
*/
|
||||
sb_start_write(sb);
|
||||
ext4_mmp_csum_set(sb, mmp);
|
||||
lock_buffer(bh);
|
||||
bh->b_end_io = end_buffer_write_sync;
|
||||
get_bh(bh);
|
||||
submit_bh(REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO, bh);
|
||||
wait_on_buffer(bh);
|
||||
sb_end_write(sb);
|
||||
if (unlikely(!buffer_uptodate(bh)))
|
||||
return -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int write_mmp_block(struct super_block *sb, struct buffer_head *bh)
|
||||
{
|
||||
int err;
|
||||
|
||||
/*
|
||||
* We protect against freezing so that we don't create dirty buffers
|
||||
* on frozen filesystem.
|
||||
*/
|
||||
sb_start_write(sb);
|
||||
err = write_mmp_block_thawed(sb, bh);
|
||||
sb_end_write(sb);
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read the MMP block. It _must_ be read from disk and hence we clear the
|
||||
* uptodate flag on the buffer.
|
||||
@ -344,7 +352,11 @@ skip:
|
||||
seq = mmp_new_seq();
|
||||
mmp->mmp_seq = cpu_to_le32(seq);
|
||||
|
||||
retval = write_mmp_block(sb, bh);
|
||||
/*
|
||||
* On mount / remount we are protected against fs freezing (by s_umount
|
||||
* semaphore) and grabbing freeze protection upsets lockdep
|
||||
*/
|
||||
retval = write_mmp_block_thawed(sb, bh);
|
||||
if (retval)
|
||||
goto failed;
|
||||
|
||||
|
||||
@ -674,7 +674,7 @@ static struct stats dx_show_leaf(struct inode *dir,
|
||||
len = de->name_len;
|
||||
if (!IS_ENCRYPTED(dir)) {
|
||||
/* Directory is not encrypted */
|
||||
ext4fs_dirhash(dir, de->name,
|
||||
(void) ext4fs_dirhash(dir, de->name,
|
||||
de->name_len, &h);
|
||||
printk("%*.s:(U)%x.%u ", len,
|
||||
name, h.hash,
|
||||
@ -709,8 +709,9 @@ static struct stats dx_show_leaf(struct inode *dir,
|
||||
if (IS_CASEFOLDED(dir))
|
||||
h.hash = EXT4_DIRENT_HASH(de);
|
||||
else
|
||||
ext4fs_dirhash(dir, de->name,
|
||||
de->name_len, &h);
|
||||
(void) ext4fs_dirhash(dir,
|
||||
de->name,
|
||||
de->name_len, &h);
|
||||
printk("%*.s:(E)%x.%u ", len, name,
|
||||
h.hash, (unsigned) ((char *) de
|
||||
- base));
|
||||
@ -720,7 +721,8 @@ static struct stats dx_show_leaf(struct inode *dir,
|
||||
#else
|
||||
int len = de->name_len;
|
||||
char *name = de->name;
|
||||
ext4fs_dirhash(dir, de->name, de->name_len, &h);
|
||||
(void) ext4fs_dirhash(dir, de->name,
|
||||
de->name_len, &h);
|
||||
printk("%*.s:%x.%u ", len, name, h.hash,
|
||||
(unsigned) ((char *) de - base));
|
||||
#endif
|
||||
@ -849,8 +851,14 @@ dx_probe(struct ext4_filename *fname, struct inode *dir,
|
||||
hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
|
||||
/* hash is already computed for encrypted casefolded directory */
|
||||
if (fname && fname_name(fname) &&
|
||||
!(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir)))
|
||||
ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), hinfo);
|
||||
!(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir))) {
|
||||
int ret = ext4fs_dirhash(dir, fname_name(fname),
|
||||
fname_len(fname), hinfo);
|
||||
if (ret < 0) {
|
||||
ret_err = ERR_PTR(ret);
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
hash = hinfo->hash;
|
||||
|
||||
if (root->info.unused_flags & 1) {
|
||||
@ -1111,7 +1119,12 @@ static int htree_dirblock_to_tree(struct file *dir_file,
|
||||
hinfo->minor_hash = 0;
|
||||
}
|
||||
} else {
|
||||
ext4fs_dirhash(dir, de->name, de->name_len, hinfo);
|
||||
err = ext4fs_dirhash(dir, de->name,
|
||||
de->name_len, hinfo);
|
||||
if (err < 0) {
|
||||
count = err;
|
||||
goto errout;
|
||||
}
|
||||
}
|
||||
if ((hinfo->hash < start_hash) ||
|
||||
((hinfo->hash == start_hash) &&
|
||||
@ -1313,8 +1326,12 @@ static int dx_make_map(struct inode *dir, struct buffer_head *bh,
|
||||
if (de->name_len && de->inode) {
|
||||
if (ext4_hash_in_dirent(dir))
|
||||
h.hash = EXT4_DIRENT_HASH(de);
|
||||
else
|
||||
ext4fs_dirhash(dir, de->name, de->name_len, &h);
|
||||
else {
|
||||
int err = ext4fs_dirhash(dir, de->name,
|
||||
de->name_len, &h);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
map_tail--;
|
||||
map_tail->hash = h.hash;
|
||||
map_tail->offs = ((char *) de - base)>>2;
|
||||
@ -1452,10 +1469,9 @@ int ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
|
||||
hinfo->hash_version = DX_HASH_SIPHASH;
|
||||
hinfo->seed = NULL;
|
||||
if (cf_name->name)
|
||||
ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo);
|
||||
return ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo);
|
||||
else
|
||||
ext4fs_dirhash(dir, iname->name, iname->len, hinfo);
|
||||
return 0;
|
||||
return ext4fs_dirhash(dir, iname->name, iname->len, hinfo);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -2298,10 +2314,15 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
|
||||
fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
|
||||
|
||||
/* casefolded encrypted hashes are computed on fname setup */
|
||||
if (!ext4_hash_in_dirent(dir))
|
||||
ext4fs_dirhash(dir, fname_name(fname),
|
||||
fname_len(fname), &fname->hinfo);
|
||||
|
||||
if (!ext4_hash_in_dirent(dir)) {
|
||||
int err = ext4fs_dirhash(dir, fname_name(fname),
|
||||
fname_len(fname), &fname->hinfo);
|
||||
if (err < 0) {
|
||||
brelse(bh2);
|
||||
brelse(bh);
|
||||
return err;
|
||||
}
|
||||
}
|
||||
memset(frames, 0, sizeof(frames));
|
||||
frame = frames;
|
||||
frame->entries = entries;
|
||||
|
||||
@ -1048,6 +1048,8 @@ void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
|
||||
struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
|
||||
int ret;
|
||||
|
||||
if (!grp || !gdp)
|
||||
return;
|
||||
if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
|
||||
ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
|
||||
&grp->bb_state);
|
||||
@ -3238,11 +3240,9 @@ static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
|
||||
crc = crc16(crc, (__u8 *)gdp, offset);
|
||||
offset += sizeof(gdp->bg_checksum); /* skip checksum */
|
||||
/* for checksum of struct ext4_group_desc do the rest...*/
|
||||
if (ext4_has_feature_64bit(sb) &&
|
||||
offset < le16_to_cpu(sbi->s_es->s_desc_size))
|
||||
if (ext4_has_feature_64bit(sb) && offset < sbi->s_desc_size)
|
||||
crc = crc16(crc, (__u8 *)gdp + offset,
|
||||
le16_to_cpu(sbi->s_es->s_desc_size) -
|
||||
offset);
|
||||
sbi->s_desc_size - offset);
|
||||
|
||||
out:
|
||||
return cpu_to_le16(crc);
|
||||
@ -5684,8 +5684,9 @@ static int ext4_fill_super(struct super_block *sb, struct fs_context *fc)
|
||||
descr = "out journal";
|
||||
|
||||
if (___ratelimit(&ext4_mount_msg_ratelimit, "EXT4-fs mount"))
|
||||
ext4_msg(sb, KERN_INFO, "mounted filesystem %pU with%s. "
|
||||
"Quota mode: %s.", &sb->s_uuid, descr,
|
||||
ext4_msg(sb, KERN_INFO, "mounted filesystem %pU %s with%s. "
|
||||
"Quota mode: %s.", &sb->s_uuid,
|
||||
sb_rdonly(sb) ? "ro" : "r/w", descr,
|
||||
ext4_quota_mode(sb));
|
||||
|
||||
/* Update the s_overhead_clusters if necessary */
|
||||
@ -6387,6 +6388,7 @@ static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
|
||||
struct ext4_mount_options old_opts;
|
||||
ext4_group_t g;
|
||||
int err = 0;
|
||||
int enable_rw = 0;
|
||||
#ifdef CONFIG_QUOTA
|
||||
int enable_quota = 0;
|
||||
int i, j;
|
||||
@ -6573,7 +6575,7 @@ static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
|
||||
if (err)
|
||||
goto restore_opts;
|
||||
|
||||
sb->s_flags &= ~SB_RDONLY;
|
||||
enable_rw = 1;
|
||||
if (ext4_has_feature_mmp(sb)) {
|
||||
err = ext4_multi_mount_protect(sb,
|
||||
le64_to_cpu(es->s_mmp_block));
|
||||
@ -6616,9 +6618,6 @@ static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
|
||||
}
|
||||
|
||||
#ifdef CONFIG_QUOTA
|
||||
/* Release old quota file names */
|
||||
for (i = 0; i < EXT4_MAXQUOTAS; i++)
|
||||
kfree(old_opts.s_qf_names[i]);
|
||||
if (enable_quota) {
|
||||
if (sb_any_quota_suspended(sb))
|
||||
dquot_resume(sb, -1);
|
||||
@ -6628,16 +6627,29 @@ static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
|
||||
goto restore_opts;
|
||||
}
|
||||
}
|
||||
/* Release old quota file names */
|
||||
for (i = 0; i < EXT4_MAXQUOTAS; i++)
|
||||
kfree(old_opts.s_qf_names[i]);
|
||||
#endif
|
||||
if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
|
||||
ext4_release_system_zone(sb);
|
||||
|
||||
if (enable_rw)
|
||||
sb->s_flags &= ~SB_RDONLY;
|
||||
|
||||
if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
|
||||
ext4_stop_mmpd(sbi);
|
||||
|
||||
return 0;
|
||||
|
||||
restore_opts:
|
||||
/*
|
||||
* If there was a failing r/w to ro transition, we may need to
|
||||
* re-enable quota
|
||||
*/
|
||||
if ((sb->s_flags & SB_RDONLY) && !(old_sb_flags & SB_RDONLY) &&
|
||||
sb_any_quota_suspended(sb))
|
||||
dquot_resume(sb, -1);
|
||||
sb->s_flags = old_sb_flags;
|
||||
sbi->s_mount_opt = old_opts.s_mount_opt;
|
||||
sbi->s_mount_opt2 = old_opts.s_mount_opt2;
|
||||
@ -6678,8 +6690,9 @@ static int ext4_reconfigure(struct fs_context *fc)
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ext4_msg(sb, KERN_INFO, "re-mounted %pU. Quota mode: %s.",
|
||||
&sb->s_uuid, ext4_quota_mode(sb));
|
||||
ext4_msg(sb, KERN_INFO, "re-mounted %pU %s. Quota mode: %s.",
|
||||
&sb->s_uuid, sb_rdonly(sb) ? "ro" : "r/w",
|
||||
ext4_quota_mode(sb));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2614,6 +2614,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
|
||||
.in_inode = !!entry->e_value_inum,
|
||||
};
|
||||
struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
|
||||
int needs_kvfree = 0;
|
||||
int error;
|
||||
|
||||
is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
|
||||
@ -2636,7 +2637,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
|
||||
error = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
needs_kvfree = 1;
|
||||
error = ext4_xattr_inode_get(inode, entry, buffer, value_size);
|
||||
if (error)
|
||||
goto out;
|
||||
@ -2675,7 +2676,7 @@ static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
|
||||
|
||||
out:
|
||||
kfree(b_entry_name);
|
||||
if (entry->e_value_inum && buffer)
|
||||
if (needs_kvfree && buffer)
|
||||
kvfree(buffer);
|
||||
if (is)
|
||||
brelse(is->iloc.bh);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user