[linux-block.git] / fs / ext4 / block_validity.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/ext4/block_validity.c
 *
 * Copyright (C) 2009
 * Theodore Ts'o (tytso@mit.edu)
 *
 * Track which blocks in the filesystem are metadata blocks that
 * should never be used as data blocks by files or directories.
 */

#include <linux/time.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/quotaops.h>
#include <linux/buffer_head.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/blkdev.h>
#include <linux/slab.h>
#include "ext4.h"

struct ext4_system_zone {
	struct rb_node	node;
	ext4_fsblk_t	start_blk;
	unsigned int	count;
};

static struct kmem_cache *ext4_system_zone_cachep;

int __init ext4_init_system_zone(void)
{
	ext4_system_zone_cachep = KMEM_CACHE(ext4_system_zone, 0);
	if (ext4_system_zone_cachep == NULL)
		return -ENOMEM;
	return 0;
}

void ext4_exit_system_zone(void)
{
	rcu_barrier();
	kmem_cache_destroy(ext4_system_zone_cachep);
}

static inline int can_merge(struct ext4_system_zone *entry1,
		     struct ext4_system_zone *entry2)
{
	if ((entry1->start_blk + entry1->count) == entry2->start_blk)
		return 1;
	return 0;
}

static void release_system_zone(struct ext4_system_blocks *system_blks)
{
	struct ext4_system_zone	*entry, *n;

	rbtree_postorder_for_each_entry_safe(entry, n,
				&system_blks->root, node)
		kmem_cache_free(ext4_system_zone_cachep, entry);
}

/*
 * Mark a range of blocks as belonging to the "system zone" --- that
 * is, filesystem metadata blocks which should never be used by
 * inodes.
 */
static int add_system_zone(struct ext4_system_blocks *system_blks,
			   ext4_fsblk_t start_blk,
			   unsigned int count)
{
	struct ext4_system_zone *new_entry = NULL, *entry;
	struct rb_node **n = &system_blks->root.rb_node, *node;
	struct rb_node *parent = NULL, *new_node = NULL;

	while (*n) {
		parent = *n;
		entry = rb_entry(parent, struct ext4_system_zone, node);
		if (start_blk < entry->start_blk)
			n = &(*n)->rb_left;
		else if (start_blk >= (entry->start_blk + entry->count))
			n = &(*n)->rb_right;
		else {
			if (start_blk + count > (entry->start_blk +
						 entry->count))
				entry->count = (start_blk + count -
						entry->start_blk);
			new_node = *n;
			new_entry = rb_entry(new_node, struct ext4_system_zone,
					     node);
			break;
		}
	}

	if (!new_entry) {
		new_entry = kmem_cache_alloc(ext4_system_zone_cachep,
					     GFP_KERNEL);
		if (!new_entry)
			return -ENOMEM;
		new_entry->start_blk = start_blk;
		new_entry->count = count;
		new_node = &new_entry->node;

		rb_link_node(new_node, parent, n);
		rb_insert_color(new_node, &system_blks->root);
	}

	/* Can we merge to the left? */
	node = rb_prev(new_node);
	if (node) {
		entry = rb_entry(node, struct ext4_system_zone, node);
		if (can_merge(entry, new_entry)) {
			new_entry->start_blk = entry->start_blk;
			new_entry->count += entry->count;
			rb_erase(node, &system_blks->root);
			kmem_cache_free(ext4_system_zone_cachep, entry);
		}
	}

	/* Can we merge to the right? */
	node = rb_next(new_node);
	if (node) {
		entry = rb_entry(node, struct ext4_system_zone, node);
		if (can_merge(new_entry, entry)) {
			new_entry->count += entry->count;
			rb_erase(node, &system_blks->root);
			kmem_cache_free(ext4_system_zone_cachep, entry);
		}
	}
	return 0;
}

static void debug_print_tree(struct ext4_sb_info *sbi)
{
	struct rb_node *node;
	struct ext4_system_zone *entry;
	struct ext4_system_blocks *system_blks;
	int first = 1;

	printk(KERN_INFO "System zones: ");
	rcu_read_lock();
	system_blks = rcu_dereference(sbi->system_blks);
	node = rb_first(&system_blks->root);
	while (node) {
		entry = rb_entry(node, struct ext4_system_zone, node);
		printk(KERN_CONT "%s%llu-%llu", first ? "" : ", ",
		       entry->start_blk, entry->start_blk + entry->count - 1);
		first = 0;
		node = rb_next(node);
	}
	rcu_read_unlock();
	printk(KERN_CONT "\n");
}

/*
 * Returns 1 if the passed-in block region (start_blk,
 * start_blk+count) is valid; 0 if some part of the block region
 * overlaps with filesystem metadata blocks.
 */
static int ext4_data_block_valid_rcu(struct ext4_sb_info *sbi,
				     struct ext4_system_blocks *system_blks,
				     ext4_fsblk_t start_blk,
				     unsigned int count)
{
	struct ext4_system_zone *entry;
	struct rb_node *n;

	if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
	    (start_blk + count < start_blk) ||
	    (start_blk + count > ext4_blocks_count(sbi->s_es))) {
		sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
		return 0;
	}

	if (system_blks == NULL)
		return 1;

	n = system_blks->root.rb_node;
	while (n) {
		entry = rb_entry(n, struct ext4_system_zone, node);
		if (start_blk + count - 1 < entry->start_blk)
			n = n->rb_left;
		else if (start_blk >= (entry->start_blk + entry->count))
			n = n->rb_right;
		else {
			sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
			return 0;
		}
	}
	return 1;
}

static int ext4_protect_reserved_inode(struct super_block *sb,
				       struct ext4_system_blocks *system_blks,
				       u32 ino)
{
	struct inode *inode;
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_map_blocks map;
	u32 i = 0, num;
	int err = 0, n;

	if ((ino < EXT4_ROOT_INO) ||
	    (ino > le32_to_cpu(sbi->s_es->s_inodes_count)))
		return -EINVAL;
	inode = ext4_iget(sb, ino, EXT4_IGET_SPECIAL);
	if (IS_ERR(inode))
		return PTR_ERR(inode);
	num = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
	while (i < num) {
		cond_resched();
		map.m_lblk = i;
		map.m_len = num - i;
		n = ext4_map_blocks(NULL, inode, &map, 0);
		if (n < 0) {
			err = n;
			break;
		}
		if (n == 0) {
			i++;
		} else {
			if (!ext4_data_block_valid_rcu(sbi, system_blks,
						map.m_pblk, n)) {
				ext4_error(sb, "blocks %llu-%llu from inode %u "
					   "overlap system zone", map.m_pblk,
					   map.m_pblk + map.m_len - 1, ino);
				err = -EFSCORRUPTED;
				break;
			}
			err = add_system_zone(system_blks, map.m_pblk, n);
			if (err < 0)
				break;
			i += n;
		}
	}
	iput(inode);
	return err;
}

static void ext4_destroy_system_zone(struct rcu_head *rcu)
{
	struct ext4_system_blocks *system_blks;

	system_blks = container_of(rcu, struct ext4_system_blocks, rcu);
	release_system_zone(system_blks);
	kfree(system_blks);
}

/*
 * Build system zone rbtree which is used for block validity checking.
 *
 * The update of system_blks pointer in this function is protected by
 * sb->s_umount semaphore. However we have to be careful as we can be
 * racing with ext4_data_block_valid() calls reading system_blks rbtree
 * protected only by RCU. That's why we first build the rbtree and then
 * swap it in place.
 */
int ext4_setup_system_zone(struct super_block *sb)
{
	ext4_group_t ngroups = ext4_get_groups_count(sb);
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_system_blocks *system_blks;
	struct ext4_group_desc *gdp;
	ext4_group_t i;
	int flex_size = ext4_flex_bg_size(sbi);
	int ret;

	if (!test_opt(sb, BLOCK_VALIDITY)) {
		if (sbi->system_blks)
			ext4_release_system_zone(sb);
		return 0;
	}
	if (sbi->system_blks)
		return 0;

	system_blks = kzalloc(sizeof(*system_blks), GFP_KERNEL);
	if (!system_blks)
		return -ENOMEM;

	for (i=0; i < ngroups; i++) {
		cond_resched();
		if (ext4_bg_has_super(sb, i) &&
		    ((i < 5) || ((i % flex_size) == 0)))
			add_system_zone(system_blks,
					ext4_group_first_block_no(sb, i),
					ext4_bg_num_gdb(sb, i) + 1);
		gdp = ext4_get_group_desc(sb, i, NULL);
		ret = add_system_zone(system_blks,
				ext4_block_bitmap(sb, gdp), 1);
		if (ret)
			goto err;
		ret = add_system_zone(system_blks,
				ext4_inode_bitmap(sb, gdp), 1);
		if (ret)
			goto err;
		ret = add_system_zone(system_blks,
				ext4_inode_table(sb, gdp),
				sbi->s_itb_per_group);
		if (ret)
			goto err;
	}
	if (ext4_has_feature_journal(sb) && sbi->s_es->s_journal_inum) {
		ret = ext4_protect_reserved_inode(sb, system_blks,
				le32_to_cpu(sbi->s_es->s_journal_inum));
		if (ret)
			goto err;
	}

	/*
	 * System blks rbtree complete, announce it once to prevent racing
	 * with ext4_data_block_valid() accessing the rbtree at the same
	 * time.
	 */
	rcu_assign_pointer(sbi->system_blks, system_blks);

	if (test_opt(sb, DEBUG))
		debug_print_tree(sbi);
	return 0;
err:
	release_system_zone(system_blks);
	kfree(system_blks);
	return ret;
}

/*
 * Called when the filesystem is unmounted or when remounting it with
 * noblock_validity specified.
 *
 * The update of system_blks pointer in this function is protected by
 * sb->s_umount semaphore. However we have to be careful as we can be
 * racing with ext4_data_block_valid() calls reading system_blks rbtree
 * protected only by RCU. So we first clear the system_blks pointer and
 * then free the rbtree only after RCU grace period expires.
 */
void ext4_release_system_zone(struct super_block *sb)
{
	struct ext4_system_blocks *system_blks;

	system_blks = rcu_dereference_protected(EXT4_SB(sb)->system_blks,
					lockdep_is_held(&sb->s_umount));
	rcu_assign_pointer(EXT4_SB(sb)->system_blks, NULL);

	if (system_blks)
		call_rcu(&system_blks->rcu, ext4_destroy_system_zone);
}

int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
			  unsigned int count)
{
	struct ext4_system_blocks *system_blks;
	int ret;

	/*
	 * Lock the system zone to prevent it being released concurrently
	 * when doing a remount which inverse current "[no]block_validity"
	 * mount option.
	 */
	rcu_read_lock();
	system_blks = rcu_dereference(sbi->system_blks);
	ret = ext4_data_block_valid_rcu(sbi, system_blks, start_blk,
					count);
	rcu_read_unlock();
	return ret;
}

int ext4_check_blockref(const char *function, unsigned int line,
			struct inode *inode, __le32 *p, unsigned int max)
{
	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
	__le32 *bref = p;
	unsigned int blk;

	if (ext4_has_feature_journal(inode->i_sb) &&
	    (inode->i_ino ==
	     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
		return 0;

	while (bref < p+max) {
		blk = le32_to_cpu(*bref++);
		if (blk &&
		    unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
						    blk, 1))) {
			es->s_last_error_block = cpu_to_le64(blk);
			ext4_error_inode(inode, function, line, blk,
					 "invalid block");
			return -EFSCORRUPTED;
		}
	}
	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
6fd058f7 TT	2	/*
	3	* linux/fs/ext4/block_validity.c
	4	*
	5	* Copyright (C) 2009
	6	* Theodore Ts'o (tytso@mit.edu)
	7	*
	8	* Track which blocks in the filesystem are metadata blocks that
	9	* should never be used as data blocks by files or directories.
	10	*/
	11
	12	#include <linux/time.h>
	13	#include <linux/fs.h>
	14	#include <linux/namei.h>
	15	#include <linux/quotaops.h>
	16	#include <linux/buffer_head.h>
6fd058f7 TT	17	#include <linux/swap.h>
6fd058f7 TT	18	#include <linux/pagemap.h>
6fd058f7	19	#include <linux/blkdev.h>
5a0e3ad6	20	#include <linux/slab.h>
6fd058f7 TT	21	#include "ext4.h"
	22
	23	struct ext4_system_zone {
	24	struct rb_node node;
	25	ext4_fsblk_t start_blk;
	26	unsigned int count;
	27	};
	28
	29	static struct kmem_cache *ext4_system_zone_cachep;
	30
5dabfc78	31	int __init ext4_init_system_zone(void)
6fd058f7	32	{
16828088	33	ext4_system_zone_cachep = KMEM_CACHE(ext4_system_zone, 0);
6fd058f7 TT	34	if (ext4_system_zone_cachep == NULL)
	35	return -ENOMEM;
	36	return 0;
	37	}
	38
5dabfc78	39	void ext4_exit_system_zone(void)
6fd058f7	40	{
7727ae52	41	rcu_barrier();
6fd058f7 TT	42	kmem_cache_destroy(ext4_system_zone_cachep);
	43	}
	44
	45	static inline int can_merge(struct ext4_system_zone *entry1,
	46	struct ext4_system_zone *entry2)
	47	{
	48	if ((entry1->start_blk + entry1->count) == entry2->start_blk)
	49	return 1;
	50	return 0;
	51	}
	52
7727ae52	53	static void release_system_zone(struct ext4_system_blocks *system_blks)
	54	{
	55	struct ext4_system_zone entry, n;
	56
	57	rbtree_postorder_for_each_entry_safe(entry, n,
	58	&system_blks->root, node)
	59	kmem_cache_free(ext4_system_zone_cachep, entry);
	60	}
	61
6fd058f7 TT	62	/*
	63	* Mark a range of blocks as belonging to the "system zone" --- that
	64	* is, filesystem metadata blocks which should never be used by
	65	* inodes.
	66	*/
7727ae52	67	static int add_system_zone(struct ext4_system_blocks *system_blks,
6fd058f7 TT	68	ext4_fsblk_t start_blk,
	69	unsigned int count)
	70	{
	71	struct ext4_system_zone new_entry = NULL, entry;
7727ae52	72	struct rb_node *n = &system_blks->root.rb_node, node;
6fd058f7 TT	73	struct rb_node parent = NULL, new_node = NULL;
	74
	75	while (*n) {
	76	parent = *n;
	77	entry = rb_entry(parent, struct ext4_system_zone, node);
	78	if (start_blk < entry->start_blk)
	79	n = &(*n)->rb_left;
	80	else if (start_blk >= (entry->start_blk + entry->count))
	81	n = &(*n)->rb_right;
	82	else {
60e6679e	83	if (start_blk + count > (entry->start_blk +
6fd058f7	84	entry->count))
60e6679e	85	entry->count = (start_blk + count -
6fd058f7 TT	86	entry->start_blk);
	87	new_node = *n;
	88	new_entry = rb_entry(new_node, struct ext4_system_zone,
	89	node);
	90	break;
	91	}
	92	}
	93
	94	if (!new_entry) {
	95	new_entry = kmem_cache_alloc(ext4_system_zone_cachep,
	96	GFP_KERNEL);
	97	if (!new_entry)
	98	return -ENOMEM;
	99	new_entry->start_blk = start_blk;
	100	new_entry->count = count;
	101	new_node = &new_entry->node;
	102
	103	rb_link_node(new_node, parent, n);
7727ae52	104	rb_insert_color(new_node, &system_blks->root);
6fd058f7 TT	105	}
	106
	107	/* Can we merge to the left? */
	108	node = rb_prev(new_node);
	109	if (node) {
	110	entry = rb_entry(node, struct ext4_system_zone, node);
	111	if (can_merge(entry, new_entry)) {
	112	new_entry->start_blk = entry->start_blk;
	113	new_entry->count += entry->count;
7727ae52	114	rb_erase(node, &system_blks->root);
6fd058f7 TT	115	kmem_cache_free(ext4_system_zone_cachep, entry);
	116	}
	117	}
	118
	119	/* Can we merge to the right? */
	120	node = rb_next(new_node);
	121	if (node) {
	122	entry = rb_entry(node, struct ext4_system_zone, node);
	123	if (can_merge(new_entry, entry)) {
	124	new_entry->count += entry->count;
7727ae52	125	rb_erase(node, &system_blks->root);
6fd058f7 TT	126	kmem_cache_free(ext4_system_zone_cachep, entry);
	127	}
	128	}
	129	return 0;
	130	}
	131
	132	static void debug_print_tree(struct ext4_sb_info *sbi)
	133	{
	134	struct rb_node *node;
	135	struct ext4_system_zone *entry;
69000d82	136	struct ext4_system_blocks *system_blks;
6fd058f7 TT	137	int first = 1;
	138
	139	printk(KERN_INFO "System zones: ");
69000d82 PT	140	rcu_read_lock();
	141	system_blks = rcu_dereference(sbi->system_blks);
	142	node = rb_first(&system_blks->root);
6fd058f7 TT	143	while (node) {
6fd058f7 TT	144	entry = rb_entry(node, struct ext4_system_zone, node);
d74f3d25	145	printk(KERN_CONT "%s%llu-%llu", first ? "" : ", ",
6fd058f7 TT	146	entry->start_blk, entry->start_blk + entry->count - 1);
	147	first = 0;
	148	node = rb_next(node);
	149	}
69000d82	150	rcu_read_unlock();
d74f3d25	151	printk(KERN_CONT "\n");
6fd058f7 TT	152	}
6fd058f7 TT	153
7727ae52	154	/*
	155	* Returns 1 if the passed-in block region (start_blk,
	156	* start_blk+count) is valid; 0 if some part of the block region
	157	* overlaps with filesystem metadata blocks.
	158	*/
	159	static int ext4_data_block_valid_rcu(struct ext4_sb_info *sbi,
	160	struct ext4_system_blocks *system_blks,
	161	ext4_fsblk_t start_blk,
	162	unsigned int count)
	163	{
	164	struct ext4_system_zone *entry;
	165	struct rb_node *n;
	166
	167	if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) \|\|
	168	(start_blk + count < start_blk) \|\|
	169	(start_blk + count > ext4_blocks_count(sbi->s_es))) {
	170	sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
	171	return 0;
	172	}
	173
	174	if (system_blks == NULL)
	175	return 1;
	176
	177	n = system_blks->root.rb_node;
	178	while (n) {
	179	entry = rb_entry(n, struct ext4_system_zone, node);
	180	if (start_blk + count - 1 < entry->start_blk)
	181	n = n->rb_left;
	182	else if (start_blk >= (entry->start_blk + entry->count))
	183	n = n->rb_right;
	184	else {
	185	sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
	186	return 0;
	187	}
	188	}
	189	return 1;
	190	}
	191
	192	static int ext4_protect_reserved_inode(struct super_block *sb,
	193	struct ext4_system_blocks *system_blks,
	194	u32 ino)
345c0dbf TT	195	{
	196	struct inode *inode;
	197	struct ext4_sb_info *sbi = EXT4_SB(sb);
	198	struct ext4_map_blocks map;
fbbbbd2f CIK	199	u32 i = 0, num;
fbbbbd2f CIK	200	int err = 0, n;
345c0dbf TT	201
	202	if ((ino < EXT4_ROOT_INO) \|\|
	203	(ino > le32_to_cpu(sbi->s_es->s_inodes_count)))
	204	return -EINVAL;
	205	inode = ext4_iget(sb, ino, EXT4_IGET_SPECIAL);
	206	if (IS_ERR(inode))
	207	return PTR_ERR(inode);
	208	num = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
	209	while (i < num) {
af133ade	210	cond_resched();
345c0dbf TT	211	map.m_lblk = i;
	212	map.m_len = num - i;
	213	n = ext4_map_blocks(NULL, inode, &map, 0);
	214	if (n < 0) {
	215	err = n;
	216	break;
	217	}
	218	if (n == 0) {
	219	i++;
	220	} else {
7727ae52	221	if (!ext4_data_block_valid_rcu(sbi, system_blks,
7727ae52	222	map.m_pblk, n)) {
345c0dbf TT	223	ext4_error(sb, "blocks %llu-%llu from inode %u "
	224	"overlap system zone", map.m_pblk,
	225	map.m_pblk + map.m_len - 1, ino);
	226	err = -EFSCORRUPTED;
	227	break;
	228	}
7727ae52	229	err = add_system_zone(system_blks, map.m_pblk, n);
345c0dbf TT	230	if (err < 0)
	231	break;
	232	i += n;
	233	}
	234	}
	235	iput(inode);
	236	return err;
	237	}
	238
7727ae52	239	static void ext4_destroy_system_zone(struct rcu_head *rcu)
	240	{
	241	struct ext4_system_blocks *system_blks;
	242
	243	system_blks = container_of(rcu, struct ext4_system_blocks, rcu);
	244	release_system_zone(system_blks);
	245	kfree(system_blks);
	246	}
	247
	248	/*
	249	* Build system zone rbtree which is used for block validity checking.
	250	*
	251	* The update of system_blks pointer in this function is protected by
	252	* sb->s_umount semaphore. However we have to be careful as we can be
	253	* racing with ext4_data_block_valid() calls reading system_blks rbtree
	254	* protected only by RCU. That's why we first build the rbtree and then
	255	* swap it in place.
	256	*/
6fd058f7 TT	257	int ext4_setup_system_zone(struct super_block *sb)
	258	{
	259	ext4_group_t ngroups = ext4_get_groups_count(sb);
	260	struct ext4_sb_info *sbi = EXT4_SB(sb);
7727ae52	261	struct ext4_system_blocks *system_blks;
6fd058f7 TT	262	struct ext4_group_desc *gdp;
	263	ext4_group_t i;
	264	int flex_size = ext4_flex_bg_size(sbi);
	265	int ret;
	266
	267	if (!test_opt(sb, BLOCK_VALIDITY)) {
7727ae52	268	if (sbi->system_blks)
6fd058f7 TT	269	ext4_release_system_zone(sb);
	270	return 0;
	271	}
7727ae52	272	if (sbi->system_blks)
6fd058f7 TT	273	return 0;
6fd058f7 TT	274
7727ae52	275	system_blks = kzalloc(sizeof(*system_blks), GFP_KERNEL);
	276	if (!system_blks)
	277	return -ENOMEM;
	278
6fd058f7	279	for (i=0; i < ngroups; i++) {
4b99faa2	280	cond_resched();
6fd058f7 TT	281	if (ext4_bg_has_super(sb, i) &&
6fd058f7 TT	282	((i < 5) \|\| ((i % flex_size) == 0)))
7727ae52	283	add_system_zone(system_blks,
7727ae52	284	ext4_group_first_block_no(sb, i),
1032988c	285	ext4_bg_num_gdb(sb, i) + 1);
6fd058f7	286	gdp = ext4_get_group_desc(sb, i, NULL);
7727ae52	287	ret = add_system_zone(system_blks,
7727ae52	288	ext4_block_bitmap(sb, gdp), 1);
6fd058f7	289	if (ret)
7727ae52	290	goto err;
	291	ret = add_system_zone(system_blks,
	292	ext4_inode_bitmap(sb, gdp), 1);
6fd058f7	293	if (ret)
7727ae52	294	goto err;
	295	ret = add_system_zone(system_blks,
	296	ext4_inode_table(sb, gdp),
6fd058f7 TT	297	sbi->s_itb_per_group);
6fd058f7 TT	298	if (ret)
7727ae52	299	goto err;
6fd058f7	300	}
345c0dbf	301	if (ext4_has_feature_journal(sb) && sbi->s_es->s_journal_inum) {
7727ae52	302	ret = ext4_protect_reserved_inode(sb, system_blks,
345c0dbf TT	303	le32_to_cpu(sbi->s_es->s_journal_inum));
345c0dbf TT	304	if (ret)
7727ae52	305	goto err;
345c0dbf	306	}
6fd058f7	307
7727ae52	308	/*
	309	* System blks rbtree complete, announce it once to prevent racing
	310	* with ext4_data_block_valid() accessing the rbtree at the same
	311	* time.
	312	*/
	313	rcu_assign_pointer(sbi->system_blks, system_blks);
	314
6fd058f7	315	if (test_opt(sb, DEBUG))
49598e04	316	debug_print_tree(sbi);
6fd058f7	317	return 0;
7727ae52	318	err:
	319	release_system_zone(system_blks);
	320	kfree(system_blks);
	321	return ret;
6fd058f7 TT	322	}
6fd058f7 TT	323
7727ae52	324	/*
	325	* Called when the filesystem is unmounted or when remounting it with
	326	* noblock_validity specified.
	327	*
	328	* The update of system_blks pointer in this function is protected by
	329	* sb->s_umount semaphore. However we have to be careful as we can be
	330	* racing with ext4_data_block_valid() calls reading system_blks rbtree
	331	* protected only by RCU. So we first clear the system_blks pointer and
	332	* then free the rbtree only after RCU grace period expires.
	333	*/
6fd058f7 TT	334	void ext4_release_system_zone(struct super_block *sb)
6fd058f7 TT	335	{
7727ae52	336	struct ext4_system_blocks *system_blks;
d1866bd0	337
7727ae52	338	system_blks = rcu_dereference_protected(EXT4_SB(sb)->system_blks,
	339	lockdep_is_held(&sb->s_umount));
	340	rcu_assign_pointer(EXT4_SB(sb)->system_blks, NULL);
d1866bd0	341
7727ae52	342	if (system_blks)
7727ae52	343	call_rcu(&system_blks->rcu, ext4_destroy_system_zone);
6fd058f7 TT	344	}
6fd058f7 TT	345
6fd058f7 TT	346	int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
	347	unsigned int count)
	348	{
7727ae52	349	struct ext4_system_blocks *system_blks;
7727ae52	350	int ret;
6fd058f7	351
7727ae52	352	/*
	353	* Lock the system zone to prevent it being released concurrently
	354	* when doing a remount which inverse current "[no]block_validity"
	355	* mount option.
	356	*/
	357	rcu_read_lock();
	358	system_blks = rcu_dereference(sbi->system_blks);
	359	ret = ext4_data_block_valid_rcu(sbi, system_blks, start_blk,
	360	count);
	361	rcu_read_unlock();
	362	return ret;
6fd058f7 TT	363	}
6fd058f7 TT	364
1f7d1e77 TT	365	int ext4_check_blockref(const char *function, unsigned int line,
	366	struct inode inode, __le32 p, unsigned int max)
	367	{
	368	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
	369	__le32 *bref = p;
	370	unsigned int blk;
	371
170417c8 TT	372	if (ext4_has_feature_journal(inode->i_sb) &&
	373	(inode->i_ino ==
	374	le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
	375	return 0;
	376
1f7d1e77 TT	377	while (bref < p+max) {
	378	blk = le32_to_cpu(*bref++);
	379	if (blk &&
	380	unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
	381	blk, 1))) {
	382	es->s_last_error_block = cpu_to_le64(blk);
	383	ext4_error_inode(inode, function, line, blk,
	384	"invalid block");
6a797d27	385	return -EFSCORRUPTED;
1f7d1e77 TT	386	}
	387	}
	388	return 0;
	389	}
dae1e52c	390