Commit 66ae56a5 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Darrick J. Wong
Browse files

xfs: introduce an always_cow mode 



Add a mode where XFS never overwrites existing blocks in place.  This
is to aid debugging our COW code, and also put infatructure in place
for things like possible future support for zoned block devices, which
can't support overwrites.

This mode is enabled globally by doing a:

    echo 1 > /sys/fs/xfs/debug/always_cow

Note that the parameter is global to allow running all tests in xfstests
easily in this mode, which would not easily be possible with a per-fs
sysfs file.

In always_cow mode persistent preallocations are disabled, and fallocate
will fail when called with a 0 mode (with our without
FALLOC_FL_KEEP_SIZE), and not create unwritten extent for zeroed space
when called with FALLOC_FL_ZERO_RANGE or FALLOC_FL_UNSHARE_RANGE.

There are a few interesting xfstests failures when run in always_cow
mode:

 - generic/392 fails because the bytes used in the file used to test
   hole punch recovery are less after the log replay.  This is
   because the blocks written and then punched out are only freed
   with a delay due to the logging mechanism.
 - xfs/170 will fail as the already fragile file streams mechanism
   doesn't seem to interact well with the COW allocator
 - xfs/180 xfs/182 xfs/192 xfs/198 xfs/204 and xfs/208 will claim
   the file system is badly fragmented, but there is not much we
   can do to avoid that when always writing out of place
 - xfs/205 fails because overwriting a file in always_cow mode
   will require new space allocation and the assumption in the
   test thus don't work anymore.
 - xfs/326 fails to modify the file at all in always_cow mode after
   injecting the refcount error, leading to an unexpected md5sum
   after the remount, but that again is expected

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent c4feb0b1

fs/xfs/xfs_aops.c

+1 −1
Original line number Diff line number Diff line
@@ -1023,7 +1023,7 @@ xfs_vm_bmap( 
	 * Since we don't pass back blockdev info, we can't return bmap

	 * information for rt files either.

	 */

	if (xfs_is_reflink_inode(ip) || XFS_IS_REALTIME_INODE(ip))

	if (xfs_is_cow_inode(ip) || XFS_IS_REALTIME_INODE(ip))

		return 0;

	return iomap_bmap(mapping, block, &xfs_iomap_ops);

}

fs/xfs/xfs_bmap_util.c

+3 −6
Original line number Diff line number Diff line
@@ -1162,16 +1162,13 @@ xfs_zero_file_space( 
	 * by virtue of the hole punch.

	 */

	error = xfs_free_file_space(ip, offset, len);

	if (error)

		goto out;

	if (error || xfs_is_always_cow_inode(ip))

		return error;



	error = xfs_alloc_file_space(ip, round_down(offset, blksize),

	return xfs_alloc_file_space(ip, round_down(offset, blksize),

				     round_up(offset + len, blksize) -

				     round_down(offset, blksize),

				     XFS_BMAPI_PREALLOC);

out:

	return error;



}



static int

fs/xfs/xfs_file.c

+20 −7
Original line number Diff line number Diff line
@@ -507,7 +507,7 @@ xfs_file_dio_aio_write( 
		 * We can't properly handle unaligned direct I/O to reflink

		 * files yet, as we can't unshare a partial block.

		 */

		if (xfs_is_reflink_inode(ip)) {

		if (xfs_is_cow_inode(ip)) {

			trace_xfs_reflink_bounce_dio_write(ip, iocb->ki_pos, count);

			return -EREMCHG;

		}
@@ -872,14 +872,27 @@ xfs_file_fallocate( 
				goto out_unlock;

		}



		if (mode & FALLOC_FL_ZERO_RANGE)

		if (mode & FALLOC_FL_ZERO_RANGE) {

			error = xfs_zero_file_space(ip, offset, len);

		else {

			if (mode & FALLOC_FL_UNSHARE_RANGE) {

		} else if (mode & FALLOC_FL_UNSHARE_RANGE) {

			error = xfs_reflink_unshare(ip, offset, len);

			if (error)

				goto out_unlock;



			if (!xfs_is_always_cow_inode(ip)) {

				error = xfs_alloc_file_space(ip, offset, len,

						XFS_BMAPI_PREALLOC);

			}

		} else {

			/*

			 * If always_cow mode we can't use preallocations and

			 * thus should not create them.

			 */

			if (xfs_is_always_cow_inode(ip)) {

				error = -EOPNOTSUPP;

				goto out_unlock;

			}



			error = xfs_alloc_file_space(ip, offset, len,

						     XFS_BMAPI_PREALLOC);

		}

fs/xfs/xfs_iomap.c

+18 −10
Original line number Diff line number Diff line
@@ -395,12 +395,13 @@ xfs_quota_calc_throttle( 
STATIC xfs_fsblock_t

xfs_iomap_prealloc_size(

	struct xfs_inode	*ip,

	int			whichfork,

	loff_t			offset,

	loff_t			count,

	struct xfs_iext_cursor	*icur)

{

	struct xfs_mount	*mp = ip->i_mount;

	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);

	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);

	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);

	struct xfs_bmbt_irec	prev;

	int			shift = 0;
@@ -593,7 +594,11 @@ xfs_file_iomap_begin_delay( 
	 * themselves.  Second the lookup in the extent list is generally faster

	 * than going out to the shared extent tree.

	 */

	if (xfs_is_reflink_inode(ip)) {

	if (xfs_is_cow_inode(ip)) {

		if (!ip->i_cowfp) {

			ASSERT(!xfs_is_reflink_inode(ip));

			xfs_ifork_init_cow(ip);

		}

		cow_eof = !xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb,

				&ccur, &cmap);

		if (!cow_eof && cmap.br_startoff <= offset_fsb) {
@@ -609,7 +614,7 @@ xfs_file_iomap_begin_delay( 
		 * overwriting shared extents.   This includes zeroing of

		 * existing extents that contain data.

		 */

		if (!xfs_is_reflink_inode(ip) ||

		if (!xfs_is_cow_inode(ip) ||

		    ((flags & IOMAP_ZERO) && imap.br_state != XFS_EXT_NORM)) {

			trace_xfs_iomap_found(ip, offset, count, XFS_DATA_FORK,

					&imap);
@@ -619,7 +624,7 @@ xfs_file_iomap_begin_delay( 
		xfs_trim_extent(&imap, offset_fsb, end_fsb - offset_fsb);



		/* Trim the mapping to the nearest shared extent boundary. */

		error = xfs_reflink_trim_around_shared(ip, &imap, &shared);

		error = xfs_inode_need_cow(ip, &imap, &shared);

		if (error)

			goto out_unlock;
@@ -648,15 +653,18 @@ xfs_file_iomap_begin_delay( 
		 */

		count = min_t(loff_t, count, 1024 * PAGE_SIZE);

		end_fsb = min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);



		if (xfs_is_always_cow_inode(ip))

			whichfork = XFS_COW_FORK;

	}



	error = xfs_qm_dqattach_locked(ip, false);

	if (error)

		goto out_unlock;



	if (eof && whichfork == XFS_DATA_FORK) {

		prealloc_blocks = xfs_iomap_prealloc_size(ip, offset, count,

				&icur);

	if (eof) {

		prealloc_blocks = xfs_iomap_prealloc_size(ip, whichfork, offset,

				count, &icur);

		if (prealloc_blocks) {

			xfs_extlen_t	align;

			xfs_off_t	end_offset;
@@ -867,7 +875,7 @@ xfs_ilock_for_iomap( 
	 * COW writes may allocate delalloc space or convert unwritten COW

	 * extents, so we need to make sure to take the lock exclusively here.

	 */

	if (xfs_is_reflink_inode(ip) && is_write) {

	if (xfs_is_cow_inode(ip) && is_write) {

		/*

		 * FIXME: It could still overwrite on unshared extents and not

		 * need allocation.
@@ -901,7 +909,7 @@ relock: 
	 * check, so if we got ILOCK_SHARED for a write and but we're now a

	 * reflink inode we have to switch to ILOCK_EXCL and relock.

	 */

	if (mode == XFS_ILOCK_SHARED && is_write && xfs_is_reflink_inode(ip)) {

	if (mode == XFS_ILOCK_SHARED && is_write && xfs_is_cow_inode(ip)) {

		xfs_iunlock(ip, mode);

		mode = XFS_ILOCK_EXCL;

		goto relock;
@@ -973,7 +981,7 @@ xfs_file_iomap_begin( 
	 * Break shared extents if necessary. Checks for non-blocking IO have

	 * been done up front, so we don't need to do them here.

	 */

	if (xfs_is_reflink_inode(ip)) {

	if (xfs_is_cow_inode(ip)) {

		struct xfs_bmbt_irec	orig = imap;



		/* if zeroing doesn't need COW allocation, then we are done. */

fs/xfs/xfs_mount.h

+1 −0
Original line number Diff line number Diff line
@@ -194,6 +194,7 @@ typedef struct xfs_mount { 
	 */

	uint32_t		m_generation;



	bool			m_always_cow;

	bool			m_fail_unmount;

#ifdef DEBUG

	/*

CRA Git | Maintained and supported by SUSTech CRA and CCSE