Commit 6fd058f7 authored by Theodore Ts'o's avatar Theodore Ts'o
Browse files

ext4: Add a comprehensive block validity check to ext4_get_blocks() 



To catch filesystem bugs or corruption which could lead to the
filesystem getting severly damaged, this patch adds a facility for
tracking all of the filesystem metadata blocks by contiguous regions
in a red-black tree.  This allows quick searching of the tree to
locate extents which might overlap with filesystem metadata blocks.

This facility is also used by the multi-block allocator to assure that
it is not allocating blocks out of the system zone, as well as by the
routines used when reading indirect blocks and extents information
from disk to make sure their contents are valid.

Signed-off-by: default avatar"Theodore Ts'o" <tytso@mit.edu>
parent 2ac3b6e0

fs/ext4/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ obj-$(CONFIG_EXT4_FS) += ext4.o 


ext4-y	:= balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \

		ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \

		   ext4_jbd2.o migrate.o mballoc.o

		ext4_jbd2.o migrate.o mballoc.o block_validity.o



ext4-$(CONFIG_EXT4_FS_XATTR)		+= xattr.o xattr_user.o xattr_trusted.o

ext4-$(CONFIG_EXT4_FS_POSIX_ACL)	+= acl.o

fs/ext4/block_validity.c

0 → 100644
+244 −0
Original line number Diff line number Diff line 
/*

 *  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/module.h>

#include <linux/swap.h>

#include <linux/pagemap.h>

#include <linux/version.h>

#include <linux/blkdev.h>

#include <linux/mutex.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 init_ext4_system_zone(void)

{

	ext4_system_zone_cachep = KMEM_CACHE(ext4_system_zone,

					     SLAB_RECLAIM_ACCOUNT);

	if (ext4_system_zone_cachep == NULL)

		return -ENOMEM;

	return 0;

}



void exit_ext4_system_zone(void)

{

	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;

}



/*

 * 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_sb_info *sbi,

			   ext4_fsblk_t start_blk,

			   unsigned int count)

{

	struct ext4_system_zone *new_entry = NULL, *entry;

	struct rb_node **n = &sbi->system_blks.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, &sbi->system_blks);

	}



	/* 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, &sbi->system_blks);

			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, &sbi->system_blks);

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

	while (node) {

		entry = rb_entry(node, struct ext4_system_zone, node);

		printk("%s%llu-%llu", first ? "" : ", ",

		       entry->start_blk, entry->start_blk + entry->count - 1);

		first = 0;

		node = rb_next(node);

	}

	printk("\n");

}



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_group_desc *gdp;

	ext4_group_t i;

	int flex_size = ext4_flex_bg_size(sbi);

	int ret;



	if (!test_opt(sb, BLOCK_VALIDITY)) {

		if (EXT4_SB(sb)->system_blks.rb_node)

			ext4_release_system_zone(sb);

		return 0;

	}

	if (EXT4_SB(sb)->system_blks.rb_node)

		return 0;



	for (i=0; i < ngroups; i++) {

		if (ext4_bg_has_super(sb, i) &&

		    ((i < 5) || ((i % flex_size) == 0)))

			add_system_zone(sbi, ext4_group_first_block_no(sb, i),

					sbi->s_gdb_count + 1);

		gdp = ext4_get_group_desc(sb, i, NULL);

		ret = add_system_zone(sbi, ext4_block_bitmap(sb, gdp), 1);

		if (ret)

			return ret;

		ret = add_system_zone(sbi, ext4_inode_bitmap(sb, gdp), 1);

		if (ret)

			return ret;

		ret = add_system_zone(sbi, ext4_inode_table(sb, gdp),

				sbi->s_itb_per_group);

		if (ret)

			return ret;

	}



	if (test_opt(sb, DEBUG))

		debug_print_tree(EXT4_SB(sb));

	return 0;

}



/* Called when the filesystem is unmounted */

void ext4_release_system_zone(struct super_block *sb)

{

	struct rb_node	*n = EXT4_SB(sb)->system_blks.rb_node;

	struct rb_node	*parent;

	struct ext4_system_zone	*entry;



	while (n) {

		/* Do the node's children first */

		if (n->rb_left) {

			n = n->rb_left;

			continue;

		}

		if (n->rb_right) {

			n = n->rb_right;

			continue;

		}

		/*

		 * The node has no children; free it, and then zero

		 * out parent's link to it.  Finally go to the

		 * beginning of the loop and try to free the parent

		 * node.

		 */

		parent = rb_parent(n);

		entry = rb_entry(n, struct ext4_system_zone, node);

		kmem_cache_free(ext4_system_zone_cachep, entry);

		if (!parent)

			EXT4_SB(sb)->system_blks.rb_node = NULL;

		else if (parent->rb_left == n)

			parent->rb_left = NULL;

		else if (parent->rb_right == n)

			parent->rb_right = NULL;

		n = parent;

	}

	EXT4_SB(sb)->system_blks.rb_node = NULL;

}



/*

 * 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.

 */

int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,

			  unsigned int count)

{

	struct ext4_system_zone *entry;

	struct rb_node *n = sbi->system_blks.rb_node;



	if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||

	    (start_blk + count > ext4_blocks_count(sbi->s_es)))

		return 0;

	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

			return 0;

	}

	return 1;

}

fs/ext4/ext4.h

+11 −0
Original line number Diff line number Diff line
@@ -696,6 +696,7 @@ struct ext4_inode_info { 
#define EXT4_MOUNT_I_VERSION            0x2000000 /* i_version support */

#define EXT4_MOUNT_DELALLOC		0x8000000 /* Delalloc support */

#define EXT4_MOUNT_DATA_ERR_ABORT	0x10000000 /* Abort on file data write */

#define EXT4_MOUNT_BLOCK_VALIDITY	0x20000000 /* Block validity checking */



/* Compatibility, for having both ext2_fs.h and ext4_fs.h included at once */

#ifndef _LINUX_EXT2_FS_H
@@ -887,6 +888,7 @@ struct ext4_sb_info { 
	int s_jquota_fmt;			/* Format of quota to use */

#endif

	unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */

	struct rb_root system_blks;



#ifdef EXTENTS_STATS

	/* ext4 extents stats */
@@ -1618,6 +1620,15 @@ extern struct dentry *ext4_get_parent(struct dentry *child); 
extern const struct inode_operations ext4_symlink_inode_operations;

extern const struct inode_operations ext4_fast_symlink_inode_operations;



/* block_validity */

extern void ext4_release_system_zone(struct super_block *sb);

extern int ext4_setup_system_zone(struct super_block *sb);

extern int __init init_ext4_system_zone(void);

extern void exit_ext4_system_zone(void);

extern int ext4_data_block_valid(struct ext4_sb_info *sbi,

				 ext4_fsblk_t start_blk,

				 unsigned int count);



/* extents.c */

extern int ext4_ext_tree_init(handle_t *handle, struct inode *);

extern int ext4_ext_writepage_trans_blocks(struct inode *, int);

fs/ext4/extents.c

+4 −18
Original line number Diff line number Diff line
@@ -326,32 +326,18 @@ ext4_ext_max_entries(struct inode *inode, int depth) 


static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)

{

	ext4_fsblk_t block = ext_pblock(ext), valid_block;

	ext4_fsblk_t block = ext_pblock(ext);

	int len = ext4_ext_get_actual_len(ext);

	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;



	valid_block = le32_to_cpu(es->s_first_data_block) +

		EXT4_SB(inode->i_sb)->s_gdb_count;

	if (unlikely(block <= valid_block ||

		     ((block + len) > ext4_blocks_count(es))))

		return 0;

	else

		return 1;

	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);

}



static int ext4_valid_extent_idx(struct inode *inode,

				struct ext4_extent_idx *ext_idx)

{

	ext4_fsblk_t block = idx_pblock(ext_idx), valid_block;

	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;

	ext4_fsblk_t block = idx_pblock(ext_idx);



	valid_block = le32_to_cpu(es->s_first_data_block) +

		EXT4_SB(inode->i_sb)->s_gdb_count;

	if (unlikely(block <= valid_block ||

		     (block >= ext4_blocks_count(es))))

		return 0;

	else

		return 1;

	return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);

}



static int ext4_valid_extent_entries(struct inode *inode,

fs/ext4/inode.c

+38 −9
Original line number Diff line number Diff line
@@ -372,20 +372,21 @@ static int ext4_block_to_path(struct inode *inode, 
}



static int __ext4_check_blockref(const char *function, struct inode *inode,

				 __le32 *p, unsigned int max) {



	unsigned int maxblocks = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es);

				 __le32 *p, unsigned int max)

{

	__le32 *bref = p;

	unsigned int blk;



	while (bref < p+max) {

		if (unlikely(le32_to_cpu(*bref) >= maxblocks)) {

		blk = le32_to_cpu(*bref++);

		if (blk && 

		    unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb), 

						    blk, 1))) {

			ext4_error(inode->i_sb, function,

				   "block reference %u >= max (%u) "

				   "in inode #%lu, offset=%d",

				   le32_to_cpu(*bref), maxblocks,

				   inode->i_ino, (int)(bref-p));

				   "invalid block reference %u "

				   "in inode #%lu", blk, inode->i_ino);

 			return -EIO;

 		}

		bref++;

 	}

 	return 0;

}
@@ -1125,6 +1126,21 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used) 
		ext4_discard_preallocations(inode);

}



static int check_block_validity(struct inode *inode, sector_t logical,

				sector_t phys, int len)

{

	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {

		ext4_error(inode->i_sb, "check_block_validity",

			   "inode #%lu logical block %llu mapped to %llu "

			   "(size %d)", inode->i_ino,

			   (unsigned long long) logical,

			   (unsigned long long) phys, len);

		WARN_ON(1);

		return -EIO;

	}

	return 0;

}



/*

 * The ext4_get_blocks() function tries to look up the requested blocks,

 * and returns if the blocks are already mapped.
@@ -1170,6 +1186,13 @@ int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block, 
	}

	up_read((&EXT4_I(inode)->i_data_sem));



	if (retval > 0 && buffer_mapped(bh)) {

		int ret = check_block_validity(inode, block, 

					       bh->b_blocknr, retval);

		if (ret != 0)

			return ret;

	}



	/* If it is only a block(s) look up */

	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)

		return retval;
@@ -1245,6 +1268,12 @@ int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block, 
		ext4_da_update_reserve_space(inode, retval);



	up_write((&EXT4_I(inode)->i_data_sem));

	if (retval > 0 && buffer_mapped(bh)) {

		int ret = check_block_validity(inode, block, 

					       bh->b_blocknr, retval);

		if (ret != 0)

			return ret;

	}

	return retval;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE