[linux-2.6-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;
	int first = 1;

	printk(KERN_INFO "System zones: ");
	node = rb_first(&sbi->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);
	}
	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) {
		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;
	136	int first = 1;
	137
	138	printk(KERN_INFO "System zones: ");
7727ae52	139	node = rb_first(&sbi->system_blks->root);
6fd058f7 TT	140	while (node) {
6fd058f7 TT	141	entry = rb_entry(node, struct ext4_system_zone, node);
d74f3d25	142	printk(KERN_CONT "%s%llu-%llu", first ? "" : ", ",
6fd058f7 TT	143	entry->start_blk, entry->start_blk + entry->count - 1);
	144	first = 0;
	145	node = rb_next(node);
	146	}
d74f3d25	147	printk(KERN_CONT "\n");
6fd058f7 TT	148	}
6fd058f7 TT	149
7727ae52	150	/*
	151	* Returns 1 if the passed-in block region (start_blk,
	152	* start_blk+count) is valid; 0 if some part of the block region
	153	* overlaps with filesystem metadata blocks.
	154	*/
	155	static int ext4_data_block_valid_rcu(struct ext4_sb_info *sbi,
	156	struct ext4_system_blocks *system_blks,
	157	ext4_fsblk_t start_blk,
	158	unsigned int count)
	159	{
	160	struct ext4_system_zone *entry;
	161	struct rb_node *n;
	162
	163	if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) \|\|
	164	(start_blk + count < start_blk) \|\|
	165	(start_blk + count > ext4_blocks_count(sbi->s_es))) {
	166	sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
	167	return 0;
	168	}
	169
	170	if (system_blks == NULL)
	171	return 1;
	172
	173	n = system_blks->root.rb_node;
	174	while (n) {
	175	entry = rb_entry(n, struct ext4_system_zone, node);
	176	if (start_blk + count - 1 < entry->start_blk)
	177	n = n->rb_left;
	178	else if (start_blk >= (entry->start_blk + entry->count))
	179	n = n->rb_right;
	180	else {
	181	sbi->s_es->s_last_error_block = cpu_to_le64(start_blk);
	182	return 0;
	183	}
	184	}
	185	return 1;
	186	}
	187
	188	static int ext4_protect_reserved_inode(struct super_block *sb,
	189	struct ext4_system_blocks *system_blks,
	190	u32 ino)
345c0dbf TT	191	{
	192	struct inode *inode;
	193	struct ext4_sb_info *sbi = EXT4_SB(sb);
	194	struct ext4_map_blocks map;
fbbbbd2f CIK	195	u32 i = 0, num;
fbbbbd2f CIK	196	int err = 0, n;
345c0dbf TT	197
	198	if ((ino < EXT4_ROOT_INO) \|\|
	199	(ino > le32_to_cpu(sbi->s_es->s_inodes_count)))
	200	return -EINVAL;
	201	inode = ext4_iget(sb, ino, EXT4_IGET_SPECIAL);
	202	if (IS_ERR(inode))
	203	return PTR_ERR(inode);
	204	num = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
	205	while (i < num) {
	206	map.m_lblk = i;
	207	map.m_len = num - i;
	208	n = ext4_map_blocks(NULL, inode, &map, 0);
	209	if (n < 0) {
	210	err = n;
	211	break;
	212	}
	213	if (n == 0) {
	214	i++;
	215	} else {
7727ae52	216	if (!ext4_data_block_valid_rcu(sbi, system_blks,
7727ae52	217	map.m_pblk, n)) {
345c0dbf TT	218	ext4_error(sb, "blocks %llu-%llu from inode %u "
	219	"overlap system zone", map.m_pblk,
	220	map.m_pblk + map.m_len - 1, ino);
	221	err = -EFSCORRUPTED;
	222	break;
	223	}
7727ae52	224	err = add_system_zone(system_blks, map.m_pblk, n);
345c0dbf TT	225	if (err < 0)
	226	break;
	227	i += n;
	228	}
	229	}
	230	iput(inode);
	231	return err;
	232	}
	233
7727ae52	234	static void ext4_destroy_system_zone(struct rcu_head *rcu)
	235	{
	236	struct ext4_system_blocks *system_blks;
	237
	238	system_blks = container_of(rcu, struct ext4_system_blocks, rcu);
	239	release_system_zone(system_blks);
	240	kfree(system_blks);
	241	}
	242
	243	/*
	244	* Build system zone rbtree which is used for block validity checking.
	245	*
	246	* The update of system_blks pointer in this function is protected by
	247	* sb->s_umount semaphore. However we have to be careful as we can be
	248	* racing with ext4_data_block_valid() calls reading system_blks rbtree
	249	* protected only by RCU. That's why we first build the rbtree and then
	250	* swap it in place.
	251	*/
6fd058f7 TT	252	int ext4_setup_system_zone(struct super_block *sb)
	253	{
	254	ext4_group_t ngroups = ext4_get_groups_count(sb);
	255	struct ext4_sb_info *sbi = EXT4_SB(sb);
7727ae52	256	struct ext4_system_blocks *system_blks;
6fd058f7 TT	257	struct ext4_group_desc *gdp;
	258	ext4_group_t i;
	259	int flex_size = ext4_flex_bg_size(sbi);
	260	int ret;
	261
	262	if (!test_opt(sb, BLOCK_VALIDITY)) {
7727ae52	263	if (sbi->system_blks)
6fd058f7 TT	264	ext4_release_system_zone(sb);
	265	return 0;
	266	}
7727ae52	267	if (sbi->system_blks)
6fd058f7 TT	268	return 0;
6fd058f7 TT	269
7727ae52	270	system_blks = kzalloc(sizeof(*system_blks), GFP_KERNEL);
	271	if (!system_blks)
	272	return -ENOMEM;
	273
6fd058f7	274	for (i=0; i < ngroups; i++) {
4b99faa2	275	cond_resched();
6fd058f7 TT	276	if (ext4_bg_has_super(sb, i) &&
6fd058f7 TT	277	((i < 5) \|\| ((i % flex_size) == 0)))
7727ae52	278	add_system_zone(system_blks,
7727ae52	279	ext4_group_first_block_no(sb, i),
1032988c	280	ext4_bg_num_gdb(sb, i) + 1);
6fd058f7	281	gdp = ext4_get_group_desc(sb, i, NULL);
7727ae52	282	ret = add_system_zone(system_blks,
7727ae52	283	ext4_block_bitmap(sb, gdp), 1);
6fd058f7	284	if (ret)
7727ae52	285	goto err;
	286	ret = add_system_zone(system_blks,
	287	ext4_inode_bitmap(sb, gdp), 1);
6fd058f7	288	if (ret)
7727ae52	289	goto err;
	290	ret = add_system_zone(system_blks,
	291	ext4_inode_table(sb, gdp),
6fd058f7 TT	292	sbi->s_itb_per_group);
6fd058f7 TT	293	if (ret)
7727ae52	294	goto err;
6fd058f7	295	}
345c0dbf	296	if (ext4_has_feature_journal(sb) && sbi->s_es->s_journal_inum) {
7727ae52	297	ret = ext4_protect_reserved_inode(sb, system_blks,
345c0dbf TT	298	le32_to_cpu(sbi->s_es->s_journal_inum));
345c0dbf TT	299	if (ret)
7727ae52	300	goto err;
345c0dbf	301	}
6fd058f7	302
7727ae52	303	/*
	304	* System blks rbtree complete, announce it once to prevent racing
	305	* with ext4_data_block_valid() accessing the rbtree at the same
	306	* time.
	307	*/
	308	rcu_assign_pointer(sbi->system_blks, system_blks);
	309
6fd058f7	310	if (test_opt(sb, DEBUG))
49598e04	311	debug_print_tree(sbi);
6fd058f7	312	return 0;
7727ae52	313	err:
	314	release_system_zone(system_blks);
	315	kfree(system_blks);
	316	return ret;
6fd058f7 TT	317	}
6fd058f7 TT	318
7727ae52	319	/*
	320	* Called when the filesystem is unmounted or when remounting it with
	321	* noblock_validity specified.
	322	*
	323	* The update of system_blks pointer in this function is protected by
	324	* sb->s_umount semaphore. However we have to be careful as we can be
	325	* racing with ext4_data_block_valid() calls reading system_blks rbtree
	326	* protected only by RCU. So we first clear the system_blks pointer and
	327	* then free the rbtree only after RCU grace period expires.
	328	*/
6fd058f7 TT	329	void ext4_release_system_zone(struct super_block *sb)
6fd058f7 TT	330	{
7727ae52	331	struct ext4_system_blocks *system_blks;
d1866bd0	332
7727ae52	333	system_blks = rcu_dereference_protected(EXT4_SB(sb)->system_blks,
	334	lockdep_is_held(&sb->s_umount));
	335	rcu_assign_pointer(EXT4_SB(sb)->system_blks, NULL);
d1866bd0	336
7727ae52	337	if (system_blks)
7727ae52	338	call_rcu(&system_blks->rcu, ext4_destroy_system_zone);
6fd058f7 TT	339	}
6fd058f7 TT	340
6fd058f7 TT	341	int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
	342	unsigned int count)
	343	{
7727ae52	344	struct ext4_system_blocks *system_blks;
7727ae52	345	int ret;
6fd058f7	346
7727ae52	347	/*
	348	* Lock the system zone to prevent it being released concurrently
	349	* when doing a remount which inverse current "[no]block_validity"
	350	* mount option.
	351	*/
	352	rcu_read_lock();
	353	system_blks = rcu_dereference(sbi->system_blks);
	354	ret = ext4_data_block_valid_rcu(sbi, system_blks, start_blk,
	355	count);
	356	rcu_read_unlock();
	357	return ret;
6fd058f7 TT	358	}
6fd058f7 TT	359
1f7d1e77 TT	360	int ext4_check_blockref(const char *function, unsigned int line,
	361	struct inode inode, __le32 p, unsigned int max)
	362	{
	363	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
	364	__le32 *bref = p;
	365	unsigned int blk;
	366
170417c8 TT	367	if (ext4_has_feature_journal(inode->i_sb) &&
	368	(inode->i_ino ==
	369	le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
	370	return 0;
	371
1f7d1e77 TT	372	while (bref < p+max) {
	373	blk = le32_to_cpu(*bref++);
	374	if (blk &&
	375	unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
	376	blk, 1))) {
	377	es->s_last_error_block = cpu_to_le64(blk);
	378	ext4_error_inode(inode, function, line, blk,
	379	"invalid block");
6a797d27	380	return -EFSCORRUPTED;
1f7d1e77 TT	381	}
	382	}
	383	return 0;
	384	}
dae1e52c	385