Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 642338ba authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-4.13-merge-5' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull XFS updates from Darrick Wong:
 "Here are some changes for you for 4.13. For the most part it's fixes
  for bugs and deadlock problems, and preparation for online fsck in
  some future merge window.

   - Avoid quotacheck deadlocks

   - Fix transaction overflows when bunmapping fragmented files

   - Refactor directory readahead

   - Allow admin to configure if ASSERT is fatal

   - Improve transaction usage detail logging during overflows

   - Minor cleanups

   - Don't leak log items when the log shuts down

   - Remove double-underscore typedefs

   - Various preparation for online scrubbing

   - Introduce new error injection configuration sysfs knobs

   - Refactor dq_get_next to use extent map directly

   - Fix problems with iterating the page cache for unwritten data

   - Implement SEEK_{HOLE,DATA} via iomap

   - Refactor XFS to use iomap SEEK_HOLE and SEEK_DATA

   - Don't use MAXPATHLEN to check on-disk symlink target lengths"

* tag 'xfs-4.13-merge-5' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (48 commits)
  xfs: don't crash on unexpected holes in dir/attr btrees
  xfs: rename MAXPATHLEN to XFS_SYMLINK_MAXLEN
  xfs: fix contiguous dquot chunk iteration livelock
  xfs: Switch to iomap for SEEK_HOLE / SEEK_DATA
  vfs: Add iomap_seek_hole and iomap_seek_data helpers
  vfs: Add page_cache_seek_hole_data helper
  xfs: remove a whitespace-only line from xfs_fs_get_nextdqblk
  xfs: rewrite xfs_dq_get_next_id using xfs_iext_lookup_extent
  xfs: Check for m_errortag initialization in xfs_errortag_test
  xfs: grab dquots without taking the ilock
  xfs: fix semicolon.cocci warnings
  xfs: Don't clear SGID when inheriting ACLs
  xfs: free cowblocks and retry on buffered write ENOSPC
  xfs: replace log_badcrc_factor knob with error injection tag
  xfs: convert drop_writes to use the errortag mechanism
  xfs: remove unneeded parameter from XFS_TEST_ERROR
  xfs: expose errortag knobs via sysfs
  xfs: make errortag a per-mountpoint structure
  xfs: free uncommitted transactions during log recovery
  xfs: don't allow bmap on rt files
  ...
parents 6618a24a cd87d867

fs/buffer.c

+124 −0
Original line number Diff line number Diff line
@@ -3501,6 +3501,130 @@ int bh_submit_read(struct buffer_head *bh) 
}

EXPORT_SYMBOL(bh_submit_read);



/*

 * Seek for SEEK_DATA / SEEK_HOLE within @page, starting at @lastoff.

 *

 * Returns the offset within the file on success, and -ENOENT otherwise.

 */

static loff_t

page_seek_hole_data(struct page *page, loff_t lastoff, int whence)

{

	loff_t offset = page_offset(page);

	struct buffer_head *bh, *head;

	bool seek_data = whence == SEEK_DATA;



	if (lastoff < offset)

		lastoff = offset;



	bh = head = page_buffers(page);

	do {

		offset += bh->b_size;

		if (lastoff >= offset)

			continue;



		/*

		 * Unwritten extents that have data in the page cache covering

		 * them can be identified by the BH_Unwritten state flag.

		 * Pages with multiple buffers might have a mix of holes, data

		 * and unwritten extents - any buffer with valid data in it

		 * should have BH_Uptodate flag set on it.

		 */



		if ((buffer_unwritten(bh) || buffer_uptodate(bh)) == seek_data)

			return lastoff;



		lastoff = offset;

	} while ((bh = bh->b_this_page) != head);

	return -ENOENT;

}



/*

 * Seek for SEEK_DATA / SEEK_HOLE in the page cache.

 *

 * Within unwritten extents, the page cache determines which parts are holes

 * and which are data: unwritten and uptodate buffer heads count as data;

 * everything else counts as a hole.

 *

 * Returns the resulting offset on successs, and -ENOENT otherwise.

 */

loff_t

page_cache_seek_hole_data(struct inode *inode, loff_t offset, loff_t length,

			  int whence)

{

	pgoff_t index = offset >> PAGE_SHIFT;

	pgoff_t end = DIV_ROUND_UP(offset + length, PAGE_SIZE);

	loff_t lastoff = offset;

	struct pagevec pvec;



	if (length <= 0)

		return -ENOENT;



	pagevec_init(&pvec, 0);



	do {

		unsigned want, nr_pages, i;



		want = min_t(unsigned, end - index, PAGEVEC_SIZE);

		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index, want);

		if (nr_pages == 0)

			break;



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

			struct page *page = pvec.pages[i];



			/*

			 * At this point, the page may be truncated or

			 * invalidated (changing page->mapping to NULL), or

			 * even swizzled back from swapper_space to tmpfs file

			 * mapping.  However, page->index will not change

			 * because we have a reference on the page.

                         *

			 * If current page offset is beyond where we've ended,

			 * we've found a hole.

                         */

			if (whence == SEEK_HOLE &&

			    lastoff < page_offset(page))

				goto check_range;



			/* Searching done if the page index is out of range. */

			if (page->index >= end)

				goto not_found;



			lock_page(page);

			if (likely(page->mapping == inode->i_mapping) &&

			    page_has_buffers(page)) {

				lastoff = page_seek_hole_data(page, lastoff, whence);

				if (lastoff >= 0) {

					unlock_page(page);

					goto check_range;

				}

			}

			unlock_page(page);

			lastoff = page_offset(page) + PAGE_SIZE;

		}



		/* Searching done if fewer pages returned than wanted. */

		if (nr_pages < want)

			break;



		index = pvec.pages[i - 1]->index + 1;

		pagevec_release(&pvec);

	} while (index < end);



	/* When no page at lastoff and we are not done, we found a hole. */

	if (whence != SEEK_HOLE)

		goto not_found;



check_range:

	if (lastoff < offset + length)

		goto out;

not_found:

	lastoff = -ENOENT;

out:

	pagevec_release(&pvec);

	return lastoff;

}



void __init buffer_init(void)

{

	unsigned long nrpages;

fs/iomap.c

+94 −0
Original line number Diff line number Diff line
@@ -584,6 +584,100 @@ int iomap_fiemap(struct inode *inode, struct fiemap_extent_info *fi, 
}

EXPORT_SYMBOL_GPL(iomap_fiemap);



static loff_t

iomap_seek_hole_actor(struct inode *inode, loff_t offset, loff_t length,

		      void *data, struct iomap *iomap)

{

	switch (iomap->type) {

	case IOMAP_UNWRITTEN:

		offset = page_cache_seek_hole_data(inode, offset, length,

						   SEEK_HOLE);

		if (offset < 0)

			return length;

		/* fall through */

	case IOMAP_HOLE:

		*(loff_t *)data = offset;

		return 0;

	default:

		return length;

	}

}



loff_t

iomap_seek_hole(struct inode *inode, loff_t offset, const struct iomap_ops *ops)

{

	loff_t size = i_size_read(inode);

	loff_t length = size - offset;

	loff_t ret;



	/* Nothing to be found beyond the end of the file. */

	if (offset >= size)

		return -ENXIO;



	while (length > 0) {

		ret = iomap_apply(inode, offset, length, IOMAP_REPORT, ops,

				  &offset, iomap_seek_hole_actor);

		if (ret < 0)

			return ret;

		if (ret == 0)

			break;



		offset += ret;

		length -= ret;

	}



	return offset;

}

EXPORT_SYMBOL_GPL(iomap_seek_hole);



static loff_t

iomap_seek_data_actor(struct inode *inode, loff_t offset, loff_t length,

		      void *data, struct iomap *iomap)

{

	switch (iomap->type) {

	case IOMAP_HOLE:

		return length;

	case IOMAP_UNWRITTEN:

		offset = page_cache_seek_hole_data(inode, offset, length,

						   SEEK_DATA);

		if (offset < 0)

			return length;

		/*FALLTHRU*/

	default:

		*(loff_t *)data = offset;

		return 0;

	}

}



loff_t

iomap_seek_data(struct inode *inode, loff_t offset, const struct iomap_ops *ops)

{

	loff_t size = i_size_read(inode);

	loff_t length = size - offset;

	loff_t ret;



	/* Nothing to be found beyond the end of the file. */

	if (offset >= size)

		return -ENXIO;



	while (length > 0) {

		ret = iomap_apply(inode, offset, length, IOMAP_REPORT, ops,

				  &offset, iomap_seek_data_actor);

		if (ret < 0)

			return ret;

		if (ret == 0)

			break;



		offset += ret;

		length -= ret;

	}



	if (length <= 0)

		return -ENXIO;

	return offset;

}

EXPORT_SYMBOL_GPL(iomap_seek_data);



/*

 * Private flags for iomap_dio, must not overlap with the public ones in

 * iomap.h:

fs/xfs/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -96,3 +96,16 @@ config XFS_DEBUG 
	  not useful unless you are debugging a particular problem.



	  Say N unless you are an XFS developer, or you play one on TV.



config XFS_ASSERT_FATAL

	bool "XFS fatal asserts"

	default y

	depends on XFS_FS && XFS_DEBUG

	help

	  Set the default DEBUG mode ASSERT failure behavior.



	  Say Y here to cause DEBUG mode ASSERT failures to result in fatal

	  errors that BUG() the kernel by default. If you say N, ASSERT failures

	  result in warnings.



	  This behavior can be modified at runtime via sysfs.

fs/xfs/libxfs/xfs_ag_resv.c

+1 −2
Original line number Diff line number Diff line
@@ -111,8 +111,7 @@ xfs_ag_resv_critical( 


	/* Critically low if less than 10% or max btree height remains. */

	return XFS_TEST_ERROR(avail < orig / 10 || avail < XFS_BTREE_MAXLEVELS,

			pag->pag_mount, XFS_ERRTAG_AG_RESV_CRITICAL,

			XFS_RANDOM_AG_RESV_CRITICAL);

			pag->pag_mount, XFS_ERRTAG_AG_RESV_CRITICAL);

}



/*

fs/xfs/libxfs/xfs_alloc.c

+3 −5
Original line number Diff line number Diff line
@@ -606,7 +606,7 @@ const struct xfs_buf_ops xfs_agfl_buf_ops = { 
/*

 * Read in the allocation group free block array.

 */

STATIC int				/* error */

int					/* error */

xfs_alloc_read_agfl(

	xfs_mount_t	*mp,		/* mount point structure */

	xfs_trans_t	*tp,		/* transaction pointer */
@@ -2454,8 +2454,7 @@ xfs_agf_read_verify( 
	    !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))

		xfs_buf_ioerror(bp, -EFSBADCRC);

	else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp,

				XFS_ERRTAG_ALLOC_READ_AGF,

				XFS_RANDOM_ALLOC_READ_AGF))

				XFS_ERRTAG_ALLOC_READ_AGF))

		xfs_buf_ioerror(bp, -EFSCORRUPTED);



	if (bp->b_error)
@@ -2842,8 +2841,7 @@ xfs_free_extent( 
	ASSERT(type != XFS_AG_RESV_AGFL);



	if (XFS_TEST_ERROR(false, mp,

			XFS_ERRTAG_FREE_EXTENT,

			XFS_RANDOM_FREE_EXTENT))

			XFS_ERRTAG_FREE_EXTENT))

		return -EIO;



	error = xfs_free_extent_fix_freelist(tp, agno, &agbp);