ext4: Use readahead when reading an inode from the inode table (240799cd) · Commits · 戴 / test

Documentation/filesystems/ext4.txt

+6 −0

Original line number	Diff line number	Diff line
		@@ -177,6 +177,11 @@ barrier=<0\|1(*)> This enables/disables the use of write barriers in
		your disks are battery-backed in one way or another,
		disabling barriers may safely improve performance.

		inode_readahead=n This tuning parameter controls the maximum
		number of inode table blocks that ext4's inode
		table readahead algorithm will pre-read into
		the buffer cache. The default value is 32 blocks.

		orlov (*) This enables the new Orlov block allocator. It is
		enabled by default.

		@@ -252,6 +257,7 @@ stripe=n Number of filesystem blocks that mballoc will try
		delalloc (*) Deferring block allocation until write-out time.
		nodelalloc Disable delayed allocation. Blocks are allocation
		when data is copied from user to page cache.

		Data Mode
		=========
		There are 3 different data modes:

Documentation/filesystems/proc.txt

+3 −0

Original line number	Diff line number	Diff line
		@@ -956,6 +956,9 @@ Table 1-10: Files in /proc/fs/ext4/<devname>
		files are packed closely together. Each large file
		will have its blocks allocated out of its own unique
		preallocation pool.
		inode_readahead Tuning parameter which controls the maximum number of
		inode table blocks that ext4's inode table readahead
		algorithm will pre-read into the buffer cache
		..............................................................................

fs/ext4/ext4.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -790,6 +790,8 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
		#define EXT4_DEF_RESUID 0
		#define EXT4_DEF_RESGID 0

		#define EXT4_DEF_INODE_READAHEAD_BLKS 32

		/*
		* Default mount options
		*/

fs/ext4/ext4_sb.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,7 @@ struct ext4_sb_info {
		int s_desc_per_block_bits;
		int s_inode_size;
		int s_first_ino;
		unsigned int s_inode_readahead_blks;
		spinlock_t s_next_gen_lock;
		u32 s_next_generation;
		u32 s_hash_seed[4];

fs/ext4/inode.c

+64 −70

Original line number	Diff line number	Diff line
		@@ -3833,41 +3833,6 @@ out_stop:
		ext4_journal_stop(handle);
		}

		static ext4_fsblk_t ext4_get_inode_block(struct super_block *sb,
		unsigned long ino, struct ext4_iloc *iloc)
		{
		ext4_group_t block_group;
		unsigned long offset;
		ext4_fsblk_t block;
		struct ext4_group_desc *gdp;

		if (!ext4_valid_inum(sb, ino)) {
		/*
		* This error is already checked for in namei.c unless we are
		* looking at an NFS filehandle, in which case no error
		* report is needed
		*/
		return 0;
		}

		block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
		gdp = ext4_get_group_desc(sb, block_group, NULL);
		if (!gdp)
		return 0;

		/*
		* Figure out the offset within the block group inode table
		*/
		offset = ((ino - 1) % EXT4_INODES_PER_GROUP(sb)) *
		EXT4_INODE_SIZE(sb);
		block = ext4_inode_table(sb, gdp) +
		(offset >> EXT4_BLOCK_SIZE_BITS(sb));

		iloc->block_group = block_group;
		iloc->offset = offset & (EXT4_BLOCK_SIZE(sb) - 1);
		return block;
		}

		/*
		* ext4_get_inode_loc returns with an extra refcount against the inode's
		* underlying buffer_head on success. If 'in_mem' is true, we have all
		@@ -3877,18 +3842,34 @@ static ext4_fsblk_t ext4_get_inode_block(struct super_block *sb,
		static int __ext4_get_inode_loc(struct inode *inode,
		struct ext4_iloc *iloc, int in_mem)
		{
		ext4_fsblk_t block;
		struct ext4_group_desc *gdp;
		struct buffer_head *bh;
		struct super_block *sb = inode->i_sb;
		ext4_fsblk_t block;
		int inodes_per_block, inode_offset;

		block = ext4_get_inode_block(inode->i_sb, inode->i_ino, iloc);
		if (!block)
		iloc->bh = 0;
		if (!ext4_valid_inum(sb, inode->i_ino))
		return -EIO;

		bh = sb_getblk(inode->i_sb, block);
		iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
		gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
		if (!gdp)
		return -EIO;

		/*
		* Figure out the offset within the block group inode table
		*/
		inodes_per_block = (EXT4_BLOCK_SIZE(sb) / EXT4_INODE_SIZE(sb));
		inode_offset = ((inode->i_ino - 1) %
		EXT4_INODES_PER_GROUP(sb));
		block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
		iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);

		bh = sb_getblk(sb, block);
		if (!bh) {
		ext4_error (inode->i_sb, "ext4_get_inode_loc",
		"unable to read inode block - "
		"inode=%lu, block=%llu",
		ext4_error(sb, "ext4_get_inode_loc", "unable to read "
		"inode block - inode=%lu, block=%llu",
		inode->i_ino, block);
		return -EIO;
		}
		@@ -3917,28 +3898,12 @@ static int __ext4_get_inode_loc(struct inode *inode,
		*/
		if (in_mem) {
		struct buffer_head *bitmap_bh;
		struct ext4_group_desc *desc;
		int inodes_per_buffer;
		int inode_offset, i;
		ext4_group_t block_group;
		int start;

		block_group = (inode->i_ino - 1) /
		EXT4_INODES_PER_GROUP(inode->i_sb);
		inodes_per_buffer = bh->b_size /
		EXT4_INODE_SIZE(inode->i_sb);
		inode_offset = ((inode->i_ino - 1) %
		EXT4_INODES_PER_GROUP(inode->i_sb));
		start = inode_offset & ~(inodes_per_buffer - 1);
		int i, start;

		/* Is the inode bitmap in cache? */
		desc = ext4_get_group_desc(inode->i_sb,
		block_group, NULL);
		if (!desc)
		goto make_io;
		start = inode_offset & ~(inodes_per_block - 1);

		bitmap_bh = sb_getblk(inode->i_sb,
		ext4_inode_bitmap(inode->i_sb, desc));
		/* Is the inode bitmap in cache? */
		bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
		if (!bitmap_bh)
		goto make_io;

		@@ -3951,14 +3916,14 @@ static int __ext4_get_inode_loc(struct inode *inode,
		brelse(bitmap_bh);
		goto make_io;
		}
		for (i = start; i < start + inodes_per_buffer; i++) {
		for (i = start; i < start + inodes_per_block; i++) {
		if (i == inode_offset)
		continue;
		if (ext4_test_bit(i, bitmap_bh->b_data))
		break;
		}
		brelse(bitmap_bh);
		if (i == start + inodes_per_buffer) {
		if (i == start + inodes_per_block) {
		/* all other inodes are free, so skip I/O */
		memset(bh->b_data, 0, bh->b_size);
		set_buffer_uptodate(bh);
		@@ -3968,6 +3933,36 @@ static int __ext4_get_inode_loc(struct inode *inode,
		}

		make_io:
		/*
		* If we need to do any I/O, try to pre-readahead extra
		* blocks from the inode table.
		*/
		if (EXT4_SB(sb)->s_inode_readahead_blks) {
		ext4_fsblk_t b, end, table;
		unsigned num;

		table = ext4_inode_table(sb, gdp);
		/* Make sure s_inode_readahead_blks is a power of 2 */
		while (EXT4_SB(sb)->s_inode_readahead_blks &
		(EXT4_SB(sb)->s_inode_readahead_blks-1))
		EXT4_SB(sb)->s_inode_readahead_blks =
		(EXT4_SB(sb)->s_inode_readahead_blks &
		(EXT4_SB(sb)->s_inode_readahead_blks-1));
		b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
		if (table > b)
		b = table;
		end = b + EXT4_SB(sb)->s_inode_readahead_blks;
		num = EXT4_INODES_PER_GROUP(sb);
		if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
		EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
		num -= le16_to_cpu(gdp->bg_itable_unused);
		table += num / inodes_per_block;
		if (end > table)
		end = table;
		while (b <= end)
		sb_breadahead(sb, b++);
		}

		/*
		* There are other valid inodes in the buffer, this inode
		* has in-inode xattrs, or we don't have this inode in memory.
		@@ -3978,10 +3973,9 @@ make_io:
		submit_bh(READ_META, bh);
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
		ext4_error(inode->i_sb, "ext4_get_inode_loc",
		"unable to read inode block - "
		"inode=%lu, block=%llu",
		inode->i_ino, block);
		ext4_error(sb, __func__,
		"unable to read inode block - inode=%lu, "
		"block=%llu", inode->i_ino, block);
		brelse(bh);
		return -EIO;
		}

Admin message