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

Commit 20c59c71 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull xfs updates from Darrick Wong:
 "This merge cycle, we're again some substantive changes to XFS.

  Metadata verifiers have been restructured to provide more detail about
  which part of a metadata structure failed checks, and we've enhanced
  the new online fsck feature to cross-reference extent allocation
  information with the other metadata structures. With this pull, the
  metadata verification part of online fsck is more or less finished,
  though the feature is still experimental and still disabled by
  default.

  We're also preparing to remove the EXPERIMENTAL tag from a couple of
  features this cycle. This week we're committing a bunch of space
  accounting fixes for reflink and removing the EXPERIMENTAL tag from
  reflink; I anticipate that we'll be ready to do the same for the
  reverse mapping feature next week. (I don't have any pending fixes for
  rmap; however I wish to remove the tags one at a time.)

  This giant pile of patches has been run through a full xfstests run
  over the weekend and through a quick xfstests run against this
  morning's master, with no major failures reported. Let me know if
  there's any merge problems -- git merge reported that one of our
  patches touched the same function as the i_version series, but it
  resolved things cleanly.

  Summary:

   - Log faulting code locations when verifiers fail, for improved
     diagnosis of corrupt filesystems.

   - Implement metadata verifiers for local format inode fork data.

   - Online scrub now cross-references metadata records with other
     metadata.

   - Refactor the fs geometry ioctl generation functions.

   - Harden various metadata verifiers.

   - Fix various accounting problems.

   - Fix uncancelled transactions leaking when xattr functions fail.

   - Prevent the copy-on-write speculative preallocation garbage
     collector from racing with writeback.

   - Emit log reservation type information as trace data so that we can
     compare against xfsprogs.

   - Fix some erroneous asserts in the online scrub code.

   - Clean up the transaction reservation calculations.

   - Fix various minor bugs in online scrub.

   - Log complaints about mixed dio/buffered writes once per day and
     less noisily than before.

   - Refactor buffer log item lists to use list_head.

   - Break PNFS leases before reflinking blocks.

   - Reduce lock contention on reflink source files.

   - Fix some quota accounting problems with reflink.

   - Fix a serious corruption problem in the direct cow write code where
     we fed bad iomaps to the vfs iomap consumers.

   - Various other refactorings.

   - Remove EXPERIMENTAL tag from reflink!"

* tag 'xfs-4.16-merge-4' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (94 commits)
  xfs: remove experimental tag for reflinks
  xfs: don't screw up direct writes when freesp is fragmented
  xfs: check reflink allocation mappings
  iomap: warn on zero-length mappings
  xfs: treat CoW fork operations as delalloc for quota accounting
  xfs: only grab shared inode locks for source file during reflink
  xfs: allow xfs_lock_two_inodes to take different EXCL/SHARED modes
  xfs: reflink should break pnfs leases before sharing blocks
  xfs: don't clobber inobt/finobt cursors when xref with rmap
  xfs: skip CoW writes past EOF when writeback races with truncate
  xfs: preserve i_rdev when recycling a reclaimable inode
  xfs: refactor accounting updates out of xfs_bmap_btalloc
  xfs: refactor inode verifier corruption error printing
  xfs: make tracepoint inode number format consistent
  xfs: always zero di_flags2 when we free the inode
  xfs: call xfs_qm_dqattach before performing reflink operations
  xfs: bmap code cleanup
  Use list_head infra-structure for buffer's log items list
  Split buffer's b_fspriv field
  Get rid of xfs_buf_log_item_t typedef
  ...
parents 5a87e37e 1e369b0e

fs/direct-io.c

+23 −1
Original line number Diff line number Diff line
@@ -219,6 +219,27 @@ static inline struct page *dio_get_page(struct dio *dio, 
	return dio->pages[sdio->head];

}



/*

 * Warn about a page cache invalidation failure during a direct io write.

 */

void dio_warn_stale_pagecache(struct file *filp)

{

	static DEFINE_RATELIMIT_STATE(_rs, 86400 * HZ, DEFAULT_RATELIMIT_BURST);

	char pathname[128];

	struct inode *inode = file_inode(filp);

	char *path;



	errseq_set(&inode->i_mapping->wb_err, -EIO);

	if (__ratelimit(&_rs)) {

		path = file_path(filp, pathname, sizeof(pathname));

		if (IS_ERR(path))

			path = "(unknown)";

		pr_crit("Page cache invalidation failure on direct I/O.  Possible data corruption due to collision with buffered I/O!\n");

		pr_crit("File: %s PID: %d Comm: %.20s\n", path, current->pid,

			current->comm);

	}

}



/**

 * dio_complete() - called when all DIO BIO I/O has been completed

 * @offset: the byte offset in the file of the completed operation
@@ -290,7 +311,8 @@ static ssize_t dio_complete(struct dio *dio, ssize_t ret, unsigned int flags) 
		err = invalidate_inode_pages2_range(dio->inode->i_mapping,

					offset >> PAGE_SHIFT,

					(offset + ret - 1) >> PAGE_SHIFT);

		WARN_ON_ONCE(err);

		if (err)

			dio_warn_stale_pagecache(dio->iocb->ki_filp);

	}



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

fs/iomap.c

+12 −2
Original line number Diff line number Diff line
@@ -65,6 +65,8 @@ iomap_apply(struct inode *inode, loff_t pos, loff_t length, unsigned flags, 
		return ret;

	if (WARN_ON(iomap.offset > pos))

		return -EIO;

	if (WARN_ON(iomap.length == 0))

		return -EIO;



	/*

	 * Cut down the length to the one actually provided by the filesystem,
@@ -753,7 +755,8 @@ static ssize_t iomap_dio_complete(struct iomap_dio *dio) 
		err = invalidate_inode_pages2_range(inode->i_mapping,

				offset >> PAGE_SHIFT,

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

		WARN_ON_ONCE(err);

		if (err)

			dio_warn_stale_pagecache(iocb->ki_filp);

	}



	inode_dio_end(file_inode(iocb->ki_filp));
@@ -1018,9 +1021,16 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, 
	if (ret)

		goto out_free_dio;



	/*

	 * Try to invalidate cache pages for the range we're direct

	 * writing.  If this invalidation fails, tough, the write will

	 * still work, but racing two incompatible write paths is a

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

	 */

	ret = invalidate_inode_pages2_range(mapping,

			start >> PAGE_SHIFT, end >> PAGE_SHIFT);

	WARN_ON_ONCE(ret);

	if (ret)

		dio_warn_stale_pagecache(iocb->ki_filp);

	ret = 0;



	if (iov_iter_rw(iter) == WRITE && !is_sync_kiocb(iocb) &&

fs/xfs/libxfs/xfs_alloc.c

+79 −45
Original line number Diff line number Diff line
@@ -167,7 +167,7 @@ xfs_alloc_lookup_ge( 
 * Lookup the first record less than or equal to [bno, len]

 * in the btree given by cur.

 */

static int				/* error */

int					/* error */

xfs_alloc_lookup_le(

	struct xfs_btree_cur	*cur,	/* btree cursor */

	xfs_agblock_t		bno,	/* starting block of extent */
@@ -520,7 +520,7 @@ xfs_alloc_fixup_trees( 
	return 0;

}



static bool

static xfs_failaddr_t

xfs_agfl_verify(

	struct xfs_buf	*bp)

{
@@ -528,10 +528,19 @@ xfs_agfl_verify( 
	struct xfs_agfl	*agfl = XFS_BUF_TO_AGFL(bp);

	int		i;



	/*

	 * There is no verification of non-crc AGFLs because mkfs does not

	 * initialise the AGFL to zero or NULL. Hence the only valid part of the

	 * AGFL is what the AGF says is active. We can't get to the AGF, so we

	 * can't verify just those entries are valid.

	 */

	if (!xfs_sb_version_hascrc(&mp->m_sb))

		return NULL;



	if (!uuid_equal(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid))

		return false;

		return __this_address;

	if (be32_to_cpu(agfl->agfl_magicnum) != XFS_AGFL_MAGIC)

		return false;

		return __this_address;

	/*

	 * during growfs operations, the perag is not fully initialised,

	 * so we can't use it for any useful checking. growfs ensures we can't
@@ -539,16 +548,17 @@ xfs_agfl_verify( 
	 * so we can detect and avoid this problem.

	 */

	if (bp->b_pag && be32_to_cpu(agfl->agfl_seqno) != bp->b_pag->pag_agno)

		return false;

		return __this_address;



	for (i = 0; i < XFS_AGFL_SIZE(mp); i++) {

		if (be32_to_cpu(agfl->agfl_bno[i]) != NULLAGBLOCK &&

		    be32_to_cpu(agfl->agfl_bno[i]) >= mp->m_sb.sb_agblocks)

			return false;

			return __this_address;

	}



	return xfs_log_check_lsn(mp,

				 be64_to_cpu(XFS_BUF_TO_AGFL(bp)->agfl_lsn));

	if (!xfs_log_check_lsn(mp, be64_to_cpu(XFS_BUF_TO_AGFL(bp)->agfl_lsn)))

		return __this_address;

	return NULL;

}



static void
@@ -556,6 +566,7 @@ xfs_agfl_read_verify( 
	struct xfs_buf	*bp)

{

	struct xfs_mount *mp = bp->b_target->bt_mount;

	xfs_failaddr_t	fa;



	/*

	 * There is no verification of non-crc AGFLs because mkfs does not
@@ -567,12 +578,12 @@ xfs_agfl_read_verify( 
		return;



	if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))

		xfs_buf_ioerror(bp, -EFSBADCRC);

	else if (!xfs_agfl_verify(bp))

		xfs_buf_ioerror(bp, -EFSCORRUPTED);



	if (bp->b_error)

		xfs_verifier_error(bp);

		xfs_verifier_error(bp, -EFSBADCRC, __this_address);

	else {

		fa = xfs_agfl_verify(bp);

		if (fa)

			xfs_verifier_error(bp, -EFSCORRUPTED, fa);

	}

}



static void
@@ -580,15 +591,16 @@ xfs_agfl_write_verify( 
	struct xfs_buf	*bp)

{

	struct xfs_mount	*mp = bp->b_target->bt_mount;

	struct xfs_buf_log_item	*bip = bp->b_fspriv;

	struct xfs_buf_log_item	*bip = bp->b_log_item;

	xfs_failaddr_t		fa;



	/* no verification of non-crc AGFLs */

	if (!xfs_sb_version_hascrc(&mp->m_sb))

		return;



	if (!xfs_agfl_verify(bp)) {

		xfs_buf_ioerror(bp, -EFSCORRUPTED);

		xfs_verifier_error(bp);

	fa = xfs_agfl_verify(bp);

	if (fa) {

		xfs_verifier_error(bp, -EFSCORRUPTED, fa);

		return;

	}
@@ -602,6 +614,7 @@ const struct xfs_buf_ops xfs_agfl_buf_ops = { 
	.name = "xfs_agfl",

	.verify_read = xfs_agfl_read_verify,

	.verify_write = xfs_agfl_write_verify,

	.verify_struct = xfs_agfl_verify,

};



/*
@@ -2397,19 +2410,19 @@ xfs_alloc_put_freelist( 
	return 0;

}



static bool

static xfs_failaddr_t

xfs_agf_verify(

	struct xfs_mount *mp,

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = bp->b_target->bt_mount;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);



	if (xfs_sb_version_hascrc(&mp->m_sb)) {

		if (!uuid_equal(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid))

			return false;

			return __this_address;

		if (!xfs_log_check_lsn(mp,

				be64_to_cpu(XFS_BUF_TO_AGF(bp)->agf_lsn)))

			return false;

			return __this_address;

	}



	if (!(agf->agf_magicnum == cpu_to_be32(XFS_AGF_MAGIC) &&
@@ -2418,18 +2431,18 @@ xfs_agf_verify( 
	      be32_to_cpu(agf->agf_flfirst) < XFS_AGFL_SIZE(mp) &&

	      be32_to_cpu(agf->agf_fllast) < XFS_AGFL_SIZE(mp) &&

	      be32_to_cpu(agf->agf_flcount) <= XFS_AGFL_SIZE(mp)))

		return false;

		return __this_address;



	if (be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) < 1 ||

	    be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) < 1 ||

	    be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) > XFS_BTREE_MAXLEVELS ||

	    be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) > XFS_BTREE_MAXLEVELS)

		return false;

		return __this_address;



	if (xfs_sb_version_hasrmapbt(&mp->m_sb) &&

	    (be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) < 1 ||

	     be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) > XFS_BTREE_MAXLEVELS))

		return false;

		return __this_address;



	/*

	 * during growfs operations, the perag is not fully initialised,
@@ -2438,18 +2451,18 @@ xfs_agf_verify( 
	 * so we can detect and avoid this problem.

	 */

	if (bp->b_pag && be32_to_cpu(agf->agf_seqno) != bp->b_pag->pag_agno)

		return false;

		return __this_address;



	if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&

	    be32_to_cpu(agf->agf_btreeblks) > be32_to_cpu(agf->agf_length))

		return false;

		return __this_address;



	if (xfs_sb_version_hasreflink(&mp->m_sb) &&

	    (be32_to_cpu(agf->agf_refcount_level) < 1 ||

	     be32_to_cpu(agf->agf_refcount_level) > XFS_BTREE_MAXLEVELS))

		return false;

		return __this_address;



	return true;;

	return NULL;



}
@@ -2458,16 +2471,16 @@ xfs_agf_read_verify( 
	struct xfs_buf	*bp)

{

	struct xfs_mount *mp = bp->b_target->bt_mount;

	xfs_failaddr_t	fa;



	if (xfs_sb_version_hascrc(&mp->m_sb) &&

	    !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_buf_ioerror(bp, -EFSCORRUPTED);



	if (bp->b_error)

		xfs_verifier_error(bp);

		xfs_verifier_error(bp, -EFSBADCRC, __this_address);

	else {

		fa = xfs_agf_verify(bp);

		if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_ALLOC_READ_AGF))

			xfs_verifier_error(bp, -EFSCORRUPTED, fa);

	}

}



static void
@@ -2475,11 +2488,12 @@ xfs_agf_write_verify( 
	struct xfs_buf	*bp)

{

	struct xfs_mount	*mp = bp->b_target->bt_mount;

	struct xfs_buf_log_item	*bip = bp->b_fspriv;

	struct xfs_buf_log_item	*bip = bp->b_log_item;

	xfs_failaddr_t		fa;



	if (!xfs_agf_verify(mp, bp)) {

		xfs_buf_ioerror(bp, -EFSCORRUPTED);

		xfs_verifier_error(bp);

	fa = xfs_agf_verify(bp);

	if (fa) {

		xfs_verifier_error(bp, -EFSCORRUPTED, fa);

		return;

	}
@@ -2496,6 +2510,7 @@ const struct xfs_buf_ops xfs_agf_buf_ops = { 
	.name = "xfs_agf",

	.verify_read = xfs_agf_read_verify,

	.verify_write = xfs_agf_write_verify,

	.verify_struct = xfs_agf_verify,

};



/*
@@ -2981,3 +2996,22 @@ xfs_verify_fsbno( 
		return false;

	return xfs_verify_agbno(mp, agno, XFS_FSB_TO_AGBNO(mp, fsbno));

}



/* Is there a record covering a given extent? */

int

xfs_alloc_has_record(

	struct xfs_btree_cur	*cur,

	xfs_agblock_t		bno,

	xfs_extlen_t		len,

	bool			*exists)

{

	union xfs_btree_irec	low;

	union xfs_btree_irec	high;



	memset(&low, 0, sizeof(low));

	low.a.ar_startblock = bno;

	memset(&high, 0xFF, sizeof(high));

	high.a.ar_startblock = bno + len - 1;



	return xfs_btree_has_record(cur, &low, &high, exists);

}

fs/xfs/libxfs/xfs_alloc.h

+10 −0
Original line number Diff line number Diff line
@@ -197,6 +197,13 @@ xfs_free_extent( 
	struct xfs_owner_info	*oinfo,	/* extent owner */

	enum xfs_ag_resv_type	type);	/* block reservation type */



int				/* error */

xfs_alloc_lookup_le(

	struct xfs_btree_cur	*cur,	/* btree cursor */

	xfs_agblock_t		bno,	/* starting block of extent */

	xfs_extlen_t		len,	/* length of extent */

	int			*stat);	/* success/failure */



int				/* error */

xfs_alloc_lookup_ge(

	struct xfs_btree_cur	*cur,	/* btree cursor */
@@ -237,4 +244,7 @@ bool xfs_verify_agbno(struct xfs_mount *mp, xfs_agnumber_t agno, 
		xfs_agblock_t agbno);

bool xfs_verify_fsbno(struct xfs_mount *mp, xfs_fsblock_t fsbno);



int xfs_alloc_has_record(struct xfs_btree_cur *cur, xfs_agblock_t bno,

		xfs_extlen_t len, bool *exist);



#endif	/* __XFS_ALLOC_H__ */

fs/xfs/libxfs/xfs_alloc_btree.c

+28 −19
Original line number Diff line number Diff line
@@ -307,13 +307,14 @@ xfs_cntbt_diff_two_keys( 
		be32_to_cpu(k2->alloc.ar_startblock);

}



static bool

static xfs_failaddr_t

xfs_allocbt_verify(

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = bp->b_target->bt_mount;

	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);

	struct xfs_perag	*pag = bp->b_pag;

	xfs_failaddr_t		fa;

	unsigned int		level;



	/*
@@ -331,29 +332,31 @@ xfs_allocbt_verify( 
	level = be16_to_cpu(block->bb_level);

	switch (block->bb_magic) {

	case cpu_to_be32(XFS_ABTB_CRC_MAGIC):

		if (!xfs_btree_sblock_v5hdr_verify(bp))

			return false;

		fa = xfs_btree_sblock_v5hdr_verify(bp);

		if (fa)

			return fa;

		/* fall through */

	case cpu_to_be32(XFS_ABTB_MAGIC):

		if (pag && pag->pagf_init) {

			if (level >= pag->pagf_levels[XFS_BTNUM_BNOi])

				return false;

				return __this_address;

		} else if (level >= mp->m_ag_maxlevels)

			return false;

			return __this_address;

		break;

	case cpu_to_be32(XFS_ABTC_CRC_MAGIC):

		if (!xfs_btree_sblock_v5hdr_verify(bp))

			return false;

		fa = xfs_btree_sblock_v5hdr_verify(bp);

		if (fa)

			return fa;

		/* fall through */

	case cpu_to_be32(XFS_ABTC_MAGIC):

		if (pag && pag->pagf_init) {

			if (level >= pag->pagf_levels[XFS_BTNUM_CNTi])

				return false;

				return __this_address;

		} else if (level >= mp->m_ag_maxlevels)

			return false;

			return __this_address;

		break;

	default:

		return false;

		return __this_address;

	}



	return xfs_btree_sblock_verify(bp, mp->m_alloc_mxr[level != 0]);
@@ -363,25 +366,30 @@ static void 
xfs_allocbt_read_verify(

	struct xfs_buf	*bp)

{

	xfs_failaddr_t	fa;



	if (!xfs_btree_sblock_verify_crc(bp))

		xfs_buf_ioerror(bp, -EFSBADCRC);

	else if (!xfs_allocbt_verify(bp))

		xfs_buf_ioerror(bp, -EFSCORRUPTED);

		xfs_verifier_error(bp, -EFSBADCRC, __this_address);

	else {

		fa = xfs_allocbt_verify(bp);

		if (fa)

			xfs_verifier_error(bp, -EFSCORRUPTED, fa);

	}



	if (bp->b_error) {

	if (bp->b_error)

		trace_xfs_btree_corrupt(bp, _RET_IP_);

		xfs_verifier_error(bp);

	}

}



static void

xfs_allocbt_write_verify(

	struct xfs_buf	*bp)

{

	if (!xfs_allocbt_verify(bp)) {

	xfs_failaddr_t	fa;



	fa = xfs_allocbt_verify(bp);

	if (fa) {

		trace_xfs_btree_corrupt(bp, _RET_IP_);

		xfs_buf_ioerror(bp, -EFSCORRUPTED);

		xfs_verifier_error(bp);

		xfs_verifier_error(bp, -EFSCORRUPTED, fa);

		return;

	}

	xfs_btree_sblock_calc_crc(bp);
@@ -392,6 +400,7 @@ const struct xfs_buf_ops xfs_allocbt_buf_ops = { 
	.name = "xfs_allocbt",

	.verify_read = xfs_allocbt_read_verify,

	.verify_write = xfs_allocbt_write_verify,

	.verify_struct = xfs_allocbt_verify,

};