Commit debe436e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 

Pull ext4 updates from Ted Ts'o:
 "Only bug fixes and cleanups for ext4 this merge window.

  Of note are fixes for the combination of the inline_data and
  fast_commit fixes, and more accurately calculating when to schedule
  additional lazy inode table init, especially when CONFIG_HZ is 100HZ"

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4:
  ext4: fix error code saved on super block during file system abort
  ext4: inline data inode fast commit replay fixes
  ext4: commit inline data during fast commit
  ext4: scope ret locally in ext4_try_to_trim_range()
  ext4: remove an unused variable warning with CONFIG_QUOTA=n
  ext4: fix boolreturn.cocci warnings in fs/ext4/name.c
  ext4: prevent getting empty inode buffer
  ext4: move ext4_fill_raw_inode() related functions
  ext4: factor out ext4_fill_raw_inode()
  ext4: prevent partial update of the extent blocks
  ext4: check for inconsistent extents between index and leaf block
  ext4: check for out-of-order index extents in ext4_valid_extent_entries()
  ext4: convert from atomic_t to refcount_t on ext4_io_end->count
  ext4: refresh the ext4_ext_path struct after dropping i_data_sem.
  ext4: ensure enough credits in ext4_ext_shift_path_extents
  ext4: correct the left/middle/right debug message for binsearch
  ext4: fix lazy initialization next schedule time computation in more granular unit
  Revert "ext4: enforce buffer head state assertion in ext4_da_map_blocks"
parents 6070dcc8 124e7c61

fs/ext4/ext4.h

+2 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#ifndef _EXT4_H

#define _EXT4_H



#include <linux/refcount.h>

#include <linux/types.h>

#include <linux/blkdev.h>

#include <linux/magic.h>
@@ -241,7 +242,7 @@ typedef struct ext4_io_end { 
	struct bio		*bio;		/* Linked list of completed

						 * bios covering the extent */

	unsigned int		flag;		/* unwritten or not */

	atomic_t		count;		/* reference counter */

	refcount_t		count;		/* reference counter */

	struct list_head	list_vec;	/* list of ext4_io_end_vec */

} ext4_io_end_t;

fs/ext4/extents.c

+103 −72
Original line number Diff line number Diff line
@@ -136,15 +136,25 @@ int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode, 
static int ext4_ext_get_access(handle_t *handle, struct inode *inode,

				struct ext4_ext_path *path)

{

	int err = 0;



	if (path->p_bh) {

		/* path points to block */

		BUFFER_TRACE(path->p_bh, "get_write_access");

		return ext4_journal_get_write_access(handle, inode->i_sb,

		err = ext4_journal_get_write_access(handle, inode->i_sb,

						    path->p_bh, EXT4_JTR_NONE);

		/*

		 * The extent buffer's verified bit will be set again in

		 * __ext4_ext_dirty(). We could leave an inconsistent

		 * buffer if the extents updating procudure break off du

		 * to some error happens, force to check it again.

		 */

		if (!err)

			clear_buffer_verified(path->p_bh);

	}

	/* path points to leaf/index in inode body */

	/* we use in-core data, no need to protect them */

	return 0;

	return err;

}



/*
@@ -165,6 +175,9 @@ static int __ext4_ext_dirty(const char *where, unsigned int line, 
		/* path points to block */

		err = __ext4_handle_dirty_metadata(where, line, handle,

						   inode, path->p_bh);

		/* Extents updating done, re-set verified flag */

		if (!err)

			set_buffer_verified(path->p_bh);

	} else {

		/* path points to leaf/index in inode body */

		err = ext4_mark_inode_dirty(handle, inode);
@@ -354,9 +367,13 @@ static int ext4_valid_extent_idx(struct inode *inode, 


static int ext4_valid_extent_entries(struct inode *inode,

				     struct ext4_extent_header *eh,

				     ext4_fsblk_t *pblk, int depth)

				     ext4_lblk_t lblk, ext4_fsblk_t *pblk,

				     int depth)

{

	unsigned short entries;

	ext4_lblk_t lblock = 0;

	ext4_lblk_t prev = 0;



	if (eh->eh_entries == 0)

		return 1;
@@ -365,31 +382,51 @@ static int ext4_valid_extent_entries(struct inode *inode, 
	if (depth == 0) {

		/* leaf entries */

		struct ext4_extent *ext = EXT_FIRST_EXTENT(eh);

		ext4_lblk_t lblock = 0;

		ext4_lblk_t prev = 0;

		int len = 0;



		/*

		 * The logical block in the first entry should equal to

		 * the number in the index block.

		 */

		if (depth != ext_depth(inode) &&

		    lblk != le32_to_cpu(ext->ee_block))

			return 0;

		while (entries) {

			if (!ext4_valid_extent(inode, ext))

				return 0;



			/* Check for overlapping extents */

			lblock = le32_to_cpu(ext->ee_block);

			len = ext4_ext_get_actual_len(ext);

			if ((lblock <= prev) && prev) {

				*pblk = ext4_ext_pblock(ext);

				return 0;

			}

			prev = lblock + ext4_ext_get_actual_len(ext) - 1;

			ext++;

			entries--;

			prev = lblock + len - 1;

		}

	} else {

		struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh);



		/*

		 * The logical block in the first entry should equal to

		 * the number in the parent index block.

		 */

		if (depth != ext_depth(inode) &&

		    lblk != le32_to_cpu(ext_idx->ei_block))

			return 0;

		while (entries) {

			if (!ext4_valid_extent_idx(inode, ext_idx))

				return 0;



			/* Check for overlapping index extents */

			lblock = le32_to_cpu(ext_idx->ei_block);

			if ((lblock <= prev) && prev) {

				*pblk = ext4_idx_pblock(ext_idx);

				return 0;

			}

			ext_idx++;

			entries--;

			prev = lblock;

		}

	}

	return 1;
@@ -397,7 +434,7 @@ static int ext4_valid_extent_entries(struct inode *inode, 


static int __ext4_ext_check(const char *function, unsigned int line,

			    struct inode *inode, struct ext4_extent_header *eh,

			    int depth, ext4_fsblk_t pblk)

			    int depth, ext4_fsblk_t pblk, ext4_lblk_t lblk)

{

	const char *error_msg;

	int max = 0, err = -EFSCORRUPTED;
@@ -423,7 +460,7 @@ static int __ext4_ext_check(const char *function, unsigned int line, 
		error_msg = "invalid eh_entries";

		goto corrupted;

	}

	if (!ext4_valid_extent_entries(inode, eh, &pblk, depth)) {

	if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) {

		error_msg = "invalid extent entries";

		goto corrupted;

	}
@@ -453,7 +490,7 @@ static int __ext4_ext_check(const char *function, unsigned int line, 
}



#define ext4_ext_check(inode, eh, depth, pblk)			\

	__ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk))

	__ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0)



int ext4_ext_check_inode(struct inode *inode)

{
@@ -486,16 +523,18 @@ static void ext4_cache_extents(struct inode *inode, 


static struct buffer_head *

__read_extent_tree_block(const char *function, unsigned int line,

			 struct inode *inode, ext4_fsblk_t pblk, int depth,

			 int flags)

			 struct inode *inode, struct ext4_extent_idx *idx,

			 int depth, int flags)

{

	struct buffer_head		*bh;

	int				err;

	gfp_t				gfp_flags = __GFP_MOVABLE | GFP_NOFS;

	ext4_fsblk_t			pblk;



	if (flags & EXT4_EX_NOFAIL)

		gfp_flags |= __GFP_NOFAIL;



	pblk = ext4_idx_pblock(idx);

	bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags);

	if (unlikely(!bh))

		return ERR_PTR(-ENOMEM);
@@ -508,8 +547,8 @@ __read_extent_tree_block(const char *function, unsigned int line, 
	}

	if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE))

		return bh;

	err = __ext4_ext_check(function, line, inode,

			       ext_block_hdr(bh), depth, pblk);

	err = __ext4_ext_check(function, line, inode, ext_block_hdr(bh),

			       depth, pblk, le32_to_cpu(idx->ei_block));

	if (err)

		goto errout;

	set_buffer_verified(bh);
@@ -527,8 +566,8 @@ __read_extent_tree_block(const char *function, unsigned int line, 


}



#define read_extent_tree_block(inode, pblk, depth, flags)		\

	__read_extent_tree_block(__func__, __LINE__, (inode), (pblk),   \

#define read_extent_tree_block(inode, idx, depth, flags)		\

	__read_extent_tree_block(__func__, __LINE__, (inode), (idx),	\

				 (depth), (flags))



/*
@@ -578,8 +617,7 @@ int ext4_ext_precache(struct inode *inode) 
			i--;

			continue;

		}

		bh = read_extent_tree_block(inode,

					    ext4_idx_pblock(path[i].p_idx++),

		bh = read_extent_tree_block(inode, path[i].p_idx++,

					    depth - i - 1,

					    EXT4_EX_FORCE_CACHE);

		if (IS_ERR(bh)) {
@@ -714,13 +752,14 @@ ext4_ext_binsearch_idx(struct inode *inode, 
	r = EXT_LAST_INDEX(eh);

	while (l <= r) {

		m = l + (r - l) / 2;

		ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,

			  le32_to_cpu(l->ei_block), m, le32_to_cpu(m->ei_block),

			  r, le32_to_cpu(r->ei_block));



		if (block < le32_to_cpu(m->ei_block))

			r = m - 1;

		else

			l = m + 1;

		ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,

			  le32_to_cpu(l->ei_block), m, le32_to_cpu(m->ei_block),

			  r, le32_to_cpu(r->ei_block));

	}



	path->p_idx = l - 1;
@@ -782,13 +821,14 @@ ext4_ext_binsearch(struct inode *inode, 


	while (l <= r) {

		m = l + (r - l) / 2;

		ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,

			  le32_to_cpu(l->ee_block), m, le32_to_cpu(m->ee_block),

			  r, le32_to_cpu(r->ee_block));



		if (block < le32_to_cpu(m->ee_block))

			r = m - 1;

		else

			l = m + 1;

		ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l,

			  le32_to_cpu(l->ee_block), m, le32_to_cpu(m->ee_block),

			  r, le32_to_cpu(r->ee_block));

	}



	path->p_ext = l - 1;
@@ -884,8 +924,7 @@ ext4_find_extent(struct inode *inode, ext4_lblk_t block, 
		path[ppos].p_depth = i;

		path[ppos].p_ext = NULL;



		bh = read_extent_tree_block(inode, path[ppos].p_block, --i,

					    flags);

		bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags);

		if (IS_ERR(bh)) {

			ret = PTR_ERR(bh);

			goto err;
@@ -1494,7 +1533,6 @@ static int ext4_ext_search_right(struct inode *inode, 
	struct ext4_extent_header *eh;

	struct ext4_extent_idx *ix;

	struct ext4_extent *ex;

	ext4_fsblk_t block;

	int depth;	/* Note, NOT eh_depth; depth from top of tree */

	int ee_len;
@@ -1561,20 +1599,17 @@ static int ext4_ext_search_right(struct inode *inode, 
	 * follow it and find the closest allocated

	 * block to the right */

	ix++;

	block = ext4_idx_pblock(ix);

	while (++depth < path->p_depth) {

		/* subtract from p_depth to get proper eh_depth */

		bh = read_extent_tree_block(inode, block,

					    path->p_depth - depth, 0);

		bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);

		if (IS_ERR(bh))

			return PTR_ERR(bh);

		eh = ext_block_hdr(bh);

		ix = EXT_FIRST_INDEX(eh);

		block = ext4_idx_pblock(ix);

		put_bh(bh);

	}



	bh = read_extent_tree_block(inode, block, path->p_depth - depth, 0);

	bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);

	if (IS_ERR(bh))

		return PTR_ERR(bh);

	eh = ext_block_hdr(bh);
@@ -2953,8 +2988,8 @@ int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start, 
			ext_debug(inode, "move to level %d (block %llu)\n",

				  i + 1, ext4_idx_pblock(path[i].p_idx));

			memset(path + i + 1, 0, sizeof(*path));

			bh = read_extent_tree_block(inode,

				ext4_idx_pblock(path[i].p_idx), depth - i - 1,

			bh = read_extent_tree_block(inode, path[i].p_idx,

						    depth - i - 1,

						    EXT4_EX_NOCACHE);

			if (IS_ERR(bh)) {

				/* should we reset i_size? */
@@ -4977,36 +5012,6 @@ int ext4_get_es_cache(struct inode *inode, struct fiemap_extent_info *fieinfo, 
	return ext4_fill_es_cache_info(inode, start_blk, len_blks, fieinfo);

}



/*

 * ext4_access_path:

 * Function to access the path buffer for marking it dirty.

 * It also checks if there are sufficient credits left in the journal handle

 * to update path.

 */

static int

ext4_access_path(handle_t *handle, struct inode *inode,

		struct ext4_ext_path *path)

{

	int credits, err;



	if (!ext4_handle_valid(handle))

		return 0;



	/*

	 * Check if need to extend journal credits

	 * 3 for leaf, sb, and inode plus 2 (bmap and group

	 * descriptor) for each block group; assume two block

	 * groups

	 */

	credits = ext4_writepage_trans_blocks(inode);

	err = ext4_datasem_ensure_credits(handle, inode, 7, credits, 0);

	if (err < 0)

		return err;



	err = ext4_ext_get_access(handle, inode, path);

	return err;

}



/*

 * ext4_ext_shift_path_extents:

 * Shift the extents of a path structure lying between path[depth].p_ext
@@ -5021,6 +5026,7 @@ ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift, 
	int depth, err = 0;

	struct ext4_extent *ex_start, *ex_last;

	bool update = false;

	int credits, restart_credits;

	depth = path->p_depth;



	while (depth >= 0) {
@@ -5030,13 +5036,26 @@ ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift, 
				return -EFSCORRUPTED;



			ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);

			/* leaf + sb + inode */

			credits = 3;

			if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr)) {

				update = true;

				/* extent tree + sb + inode */

				credits = depth + 2;

			}



			err = ext4_access_path(handle, inode, path + depth);

			if (err)

			restart_credits = ext4_writepage_trans_blocks(inode);

			err = ext4_datasem_ensure_credits(handle, inode, credits,

					restart_credits, 0);

			if (err) {

				if (err > 0)

					err = -EAGAIN;

				goto out;

			}



			if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr))

				update = true;

			err = ext4_ext_get_access(handle, inode, path + depth);

			if (err)

				goto out;



			while (ex_start <= ex_last) {

				if (SHIFT == SHIFT_LEFT) {
@@ -5067,7 +5086,7 @@ ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift, 
		}



		/* Update index too */

		err = ext4_access_path(handle, inode, path + depth);

		err = ext4_ext_get_access(handle, inode, path + depth);

		if (err)

			goto out;
@@ -5106,6 +5125,7 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle, 
	int ret = 0, depth;

	struct ext4_extent *extent;

	ext4_lblk_t stop, *iterator, ex_start, ex_end;

	ext4_lblk_t tmp = EXT_MAX_BLOCKS;



	/* Let path point to the last extent */

	path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,
@@ -5159,11 +5179,15 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle, 
	 * till we reach stop. In case of right shift, iterator points to stop

	 * and it is decreased till we reach start.

	 */

again:

	if (SHIFT == SHIFT_LEFT)

		iterator = &start;

	else

		iterator = &stop;



	if (tmp != EXT_MAX_BLOCKS)

		*iterator = tmp;



	/*

	 * Its safe to start updating extents.  Start and stop are unsigned, so

	 * in case of right shift if extent with 0 block is reached, iterator
@@ -5192,6 +5216,7 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle, 
			}

		}



		tmp = *iterator;

		if (SHIFT == SHIFT_LEFT) {

			extent = EXT_LAST_EXTENT(path[depth].p_hdr);

			*iterator = le32_to_cpu(extent->ee_block) +
@@ -5210,6 +5235,9 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle, 
		}

		ret = ext4_ext_shift_path_extents(path, shift, inode,

				handle, SHIFT);

		/* iterator can be NULL which means we should break */

		if (ret == -EAGAIN)

			goto again;

		if (ret)

			break;

	}
@@ -6043,6 +6071,9 @@ int ext4_ext_clear_bb(struct inode *inode) 
	int j, ret = 0;

	struct ext4_map_blocks map;



	if (ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA))

		return 0;



	/* Determin the size of the file first */

	path = ext4_find_extent(inode, EXT_MAX_BLOCKS - 1, NULL,

					EXT4_EX_NOCACHE);

fs/ext4/fast_commit.c

+9 −2
Original line number Diff line number Diff line
@@ -819,7 +819,9 @@ static int ext4_fc_write_inode(struct inode *inode, u32 *crc) 
	if (ret)

		return ret;



	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE)

	if (ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA))

		inode_len = EXT4_INODE_SIZE(inode->i_sb);

	else if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE)

		inode_len += ei->i_extra_isize;



	fc_inode.fc_ino = cpu_to_le32(inode->i_ino);
@@ -1524,6 +1526,7 @@ static int ext4_fc_replay_inode(struct super_block *sb, struct ext4_fc_tl *tl, 
	 * crashing. This should be fixed but until then, we calculate

	 * the number of blocks the inode.

	 */

	if (!ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA))

		ext4_ext_replay_set_iblocks(inode);



	inode->i_generation = le32_to_cpu(ext4_raw_inode(&iloc)->i_generation);
@@ -1842,6 +1845,10 @@ static void ext4_fc_set_bitmaps_and_counters(struct super_block *sb) 
		}

		cur = 0;

		end = EXT_MAX_BLOCKS;

		if (ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA)) {

			iput(inode);

			continue;

		}

		while (cur < end) {

			map.m_lblk = cur;

			map.m_len = end - cur;

fs/ext4/inode.c

+171 −160

File changed.

Preview size limit exceeded, changes collapsed.

fs/ext4/mballoc.c

+2 −3
Original line number Diff line number Diff line
@@ -6299,7 +6299,6 @@ __releases(ext4_group_lock_ptr(sb, e4b->bd_group)) 
{

	ext4_grpblk_t next, count, free_count;

	void *bitmap;

	int ret = 0;



	bitmap = e4b->bd_bitmap;

	start = (e4b->bd_info->bb_first_free > start) ?
@@ -6314,10 +6313,10 @@ __releases(ext4_group_lock_ptr(sb, e4b->bd_group)) 
		next = mb_find_next_bit(bitmap, max + 1, start);



		if ((next - start) >= minblocks) {

			ret = ext4_trim_extent(sb, start, next - start, e4b);

			int ret = ext4_trim_extent(sb, start, next - start, e4b);



			if (ret && ret != -EOPNOTSUPP)

				break;

			ret = 0;

			count += next - start;

		}

		free_count += next - start;