[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;
	u32		ino;
};

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 &&
	    entry1->ino == entry2->ino)
		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, u32 ino)
{
	struct ext4_system_zone *new_entry, *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	/* Unexpected overlap of system zones. */
			return -EFSCORRUPTED;
	}

	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_entry->ino = ino;
	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->s_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");
}

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 {
			err = add_system_zone(system_blks, map.m_pblk, n, ino);
			if (err < 0) {
				if (err == -EFSCORRUPTED) {
					EXT4_ERROR_INODE_ERR(inode, -err,
						"blocks %llu-%llu from inode overlap system zone",
						map.m_pblk,
						map.m_pblk + map.m_len - 1);
				}
				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_inode_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 ret;

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

	for (i=0; i < ngroups; i++) {
		unsigned int meta_blks = ext4_num_base_meta_blocks(sb, i);

		cond_resched();
		if (meta_blks != 0) {
			ret = add_system_zone(system_blks,
					ext4_group_first_block_no(sb, i),
					meta_blks, 0);
			if (ret)
				goto err;
		}
		gdp = ext4_get_group_desc(sb, i, NULL);
		ret = add_system_zone(system_blks,
				ext4_block_bitmap(sb, gdp), 1, 0);
		if (ret)
			goto err;
		ret = add_system_zone(system_blks,
				ext4_inode_bitmap(sb, gdp), 1, 0);
		if (ret)
			goto err;
		ret = add_system_zone(system_blks,
				ext4_inode_table(sb, gdp),
				sbi->s_itb_per_group, 0);
		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_inode_block_valid() accessing the rbtree at the same
	 * time.
	 */
	rcu_assign_pointer(sbi->s_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_inode_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)->s_system_blks,
					lockdep_is_held(&sb->s_umount));
	rcu_assign_pointer(EXT4_SB(sb)->s_system_blks, NULL);

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

int ext4_sb_block_valid(struct super_block *sb, struct inode *inode,
				ext4_fsblk_t start_blk, unsigned int count)
{
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_system_blocks *system_blks;
	struct ext4_system_zone *entry;
	struct rb_node *n;
	int ret = 1;

	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)))
		return 0;

	/*
	 * 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->s_system_blks);
	if (system_blks == NULL)
		goto out_rcu;

	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 {
			ret = 0;
			if (inode)
				ret = (entry->ino == inode->i_ino);
			break;
		}
	}
out_rcu:
	rcu_read_unlock();
	return ret;
}

/*
 * 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 some other filesystem metadata blocks.
 */
int ext4_inode_block_valid(struct inode *inode, ext4_fsblk_t start_blk,
			  unsigned int count)
{
	return ext4_sb_block_valid(inode->i_sb, inode, start_blk, count);
}

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