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

Commit 73d3393a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-4.14-fixes-6' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs fixes from Darrick Wong:

 - fix some more CONFIG_XFS_RT related build problems

 - fix data loss when writeback at eof races eofblocks gc and loses

 - invalidate page cache after fs finishes a dio write

 - remove dirty page state when invalidating pages so releasepage does
   the right thing when handed a dirty page

* tag 'xfs-4.14-fixes-6' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux:
  xfs: move two more RT specific functions into CONFIG_XFS_RT
  xfs: trim writepage mapping to within eof
  fs: invalidate page cache after end_io() in dio completion
  xfs: cancel dirty pages on invalidation
parents 020b3023 785545c8

fs/direct-io.c

+12 −8
Original line number Diff line number Diff line
@@ -265,12 +265,24 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, unsigned int flags) 
	if (ret == 0)

		ret = transferred;



	if (dio->end_io) {

		// XXX: ki_pos??

		err = dio->end_io(dio->iocb, offset, ret, dio->private);

		if (err)

			ret = err;

	}



	/*

	 * Try again to invalidate clean pages which might have been cached by

	 * non-direct readahead, or faulted in by get_user_pages() if the source

	 * of the write was an mmap'ed region of the file we're writing.  Either

	 * one is a pretty crazy thing to do, so we don't support it 100%.  If

	 * this invalidation fails, tough, the write still worked...

	 *

	 * And this page cache invalidation has to be after dio->end_io(), as

	 * some filesystems convert unwritten extents to real allocations in

	 * end_io() when necessary, otherwise a racing buffer read would cache

	 * zeros from unwritten extents.

	 */

	if (flags & DIO_COMPLETE_INVALIDATE &&

	    ret > 0 && dio->op == REQ_OP_WRITE &&
@@ -281,14 +293,6 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, unsigned int flags) 
		WARN_ON_ONCE(err);

	}



	if (dio->end_io) {



		// XXX: ki_pos??

		err = dio->end_io(dio->iocb, offset, ret, dio->private);

		if (err)

			ret = err;

	}



	if (!(dio->flags & DIO_SKIP_DIO_COUNT))

		inode_dio_end(dio->inode);

fs/iomap.c

+24 −17
Original line number Diff line number Diff line
@@ -714,23 +714,9 @@ static ssize_t iomap_dio_complete(struct iomap_dio *dio) 
{

	struct kiocb *iocb = dio->iocb;

	struct inode *inode = file_inode(iocb->ki_filp);

	loff_t offset = iocb->ki_pos;

	ssize_t ret;



	/*

	 * Try again to invalidate clean pages which might have been cached by

	 * non-direct readahead, or faulted in by get_user_pages() if the source

	 * of the write was an mmap'ed region of the file we're writing.  Either

	 * one is a pretty crazy thing to do, so we don't support it 100%.  If

	 * this invalidation fails, tough, the write still worked...

	 */

	if (!dio->error &&

	    (dio->flags & IOMAP_DIO_WRITE) && inode->i_mapping->nrpages) {

		ret = invalidate_inode_pages2_range(inode->i_mapping,

				iocb->ki_pos >> PAGE_SHIFT,

				(iocb->ki_pos + dio->size - 1) >> PAGE_SHIFT);

		WARN_ON_ONCE(ret);

	}



	if (dio->end_io) {

		ret = dio->end_io(iocb,

				dio->error ? dio->error : dio->size,
@@ -742,12 +728,33 @@ static ssize_t iomap_dio_complete(struct iomap_dio *dio) 
	if (likely(!ret)) {

		ret = dio->size;

		/* check for short read */

		if (iocb->ki_pos + ret > dio->i_size &&

		if (offset + ret > dio->i_size &&

		    !(dio->flags & IOMAP_DIO_WRITE))

			ret = dio->i_size - iocb->ki_pos;

			ret = dio->i_size - offset;

		iocb->ki_pos += ret;

	}



	/*

	 * Try again to invalidate clean pages which might have been cached by

	 * non-direct readahead, or faulted in by get_user_pages() if the source

	 * of the write was an mmap'ed region of the file we're writing.  Either

	 * one is a pretty crazy thing to do, so we don't support it 100%.  If

	 * this invalidation fails, tough, the write still worked...

	 *

	 * And this page cache invalidation has to be after dio->end_io(), as

	 * some filesystems convert unwritten extents to real allocations in

	 * end_io() when necessary, otherwise a racing buffer read would cache

	 * zeros from unwritten extents.

	 */

	if (!dio->error &&

	    (dio->flags & IOMAP_DIO_WRITE) && inode->i_mapping->nrpages) {

		int err;

		err = invalidate_inode_pages2_range(inode->i_mapping,

				offset >> PAGE_SHIFT,

				(offset + dio->size - 1) >> PAGE_SHIFT);

		WARN_ON_ONCE(err);

	}



	inode_dio_end(file_inode(iocb->ki_filp));

	kfree(dio);

fs/xfs/libxfs/xfs_bmap.c

+11 −0
Original line number Diff line number Diff line
@@ -3852,6 +3852,17 @@ xfs_trim_extent( 
	}

}



/* trim extent to within eof */

void

xfs_trim_extent_eof(

	struct xfs_bmbt_irec	*irec,

	struct xfs_inode	*ip)



{

	xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount,

					      i_size_read(VFS_I(ip))));

}



/*

 * Trim the returned map to the required bounds

 */

fs/xfs/libxfs/xfs_bmap.h

+1 −0
Original line number Diff line number Diff line
@@ -208,6 +208,7 @@ void xfs_bmap_trace_exlist(struct xfs_inode *ip, xfs_extnum_t cnt, 


void	xfs_trim_extent(struct xfs_bmbt_irec *irec, xfs_fileoff_t bno,

		xfs_filblks_t len);

void	xfs_trim_extent_eof(struct xfs_bmbt_irec *, struct xfs_inode *);

int	xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);

void	xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);

void	xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_defer_ops *dfops,

fs/xfs/xfs_aops.c

+35 −12
Original line number Diff line number Diff line
@@ -446,6 +446,19 @@ xfs_imap_valid( 
{

	offset >>= inode->i_blkbits;



	/*

	 * We have to make sure the cached mapping is within EOF to protect

	 * against eofblocks trimming on file release leaving us with a stale

	 * mapping. Otherwise, a page for a subsequent file extending buffered

	 * write could get picked up by this writeback cycle and written to the

	 * wrong blocks.

	 *

	 * Note that what we really want here is a generic mapping invalidation

	 * mechanism to protect us from arbitrary extent modifying contexts, not

	 * just eofblocks.

	 */

	xfs_trim_extent_eof(imap, XFS_I(inode));



	return offset >= imap->br_startoff &&

		offset < imap->br_startoff + imap->br_blockcount;

}
@@ -735,6 +748,14 @@ xfs_vm_invalidatepage( 
{

	trace_xfs_invalidatepage(page->mapping->host, page, offset,

				 length);



	/*

	 * If we are invalidating the entire page, clear the dirty state from it

	 * so that we can check for attempts to release dirty cached pages in

	 * xfs_vm_releasepage().

	 */

	if (offset == 0 && length >= PAGE_SIZE)

		cancel_dirty_page(page);

	block_invalidatepage(page, offset, length);

}
@@ -1190,25 +1211,27 @@ xfs_vm_releasepage( 
	 * mm accommodates an old ext3 case where clean pages might not have had

	 * the dirty bit cleared. Thus, it can send actual dirty pages to

	 * ->releasepage() via shrink_active_list(). Conversely,

	 * block_invalidatepage() can send pages that are still marked dirty

	 * but otherwise have invalidated buffers.

	 * block_invalidatepage() can send pages that are still marked dirty but

	 * otherwise have invalidated buffers.

	 *

	 * We want to release the latter to avoid unnecessary buildup of the

	 * LRU, skip the former and warn if we've left any lingering

	 * delalloc/unwritten buffers on clean pages. Skip pages with delalloc

	 * or unwritten buffers and warn if the page is not dirty. Otherwise

	 * try to release the buffers.

	 * LRU, so xfs_vm_invalidatepage() clears the page dirty flag on pages

	 * that are entirely invalidated and need to be released.  Hence the

	 * only time we should get dirty pages here is through

	 * shrink_active_list() and so we can simply skip those now.

	 *

	 * warn if we've left any lingering delalloc/unwritten buffers on clean

	 * or invalidated pages we are about to release.

	 */

	if (PageDirty(page))

		return 0;



	xfs_count_page_state(page, &delalloc, &unwritten);



	if (delalloc) {

		WARN_ON_ONCE(!PageDirty(page));

	if (WARN_ON_ONCE(delalloc))

		return 0;

	}

	if (unwritten) {

		WARN_ON_ONCE(!PageDirty(page));

	if (WARN_ON_ONCE(unwritten))

		return 0;

	}



	return try_to_free_buffers(page);

}