1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * Copyright (c) 2012 Red Hat, Inc.
   5 * All Rights Reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
   6 */
   7#include "xfs.h"
   8#include "xfs_fs.h"
   9#include "xfs_shared.h"
  10#include "xfs_format.h"
  11#include "xfs_log_format.h"
  12#include "xfs_trans_resv.h"
  13#include "xfs_bit.h"
  14#include "xfs_mount.h"
 
  15#include "xfs_defer.h"
  16#include "xfs_inode.h"
  17#include "xfs_btree.h"
  18#include "xfs_trans.h"
 
  19#include "xfs_alloc.h"
  20#include "xfs_bmap.h"
  21#include "xfs_bmap_util.h"
  22#include "xfs_bmap_btree.h"
  23#include "xfs_rtalloc.h"
  24#include "xfs_error.h"
  25#include "xfs_quota.h"
  26#include "xfs_trans_space.h"
  27#include "xfs_trace.h"
  28#include "xfs_icache.h"
 
 
  29#include "xfs_iomap.h"
  30#include "xfs_reflink.h"
 
  31
  32/* Kernel only BMAP related definitions and functions */
  33
  34/*
  35 * Convert the given file system block to a disk block.  We have to treat it
  36 * differently based on whether the file is a real time file or not, because the
  37 * bmap code does.
  38 */
  39xfs_daddr_t
  40xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
  41{
  42	if (XFS_IS_REALTIME_INODE(ip))
  43		return XFS_FSB_TO_BB(ip->i_mount, fsb);
  44	return XFS_FSB_TO_DADDR(ip->i_mount, fsb);
  45}
  46
  47/*
  48 * Routine to zero an extent on disk allocated to the specific inode.
  49 *
  50 * The VFS functions take a linearised filesystem block offset, so we have to
  51 * convert the sparse xfs fsb to the right format first.
  52 * VFS types are real funky, too.
  53 */
  54int
  55xfs_zero_extent(
  56	struct xfs_inode	*ip,
  57	xfs_fsblock_t		start_fsb,
  58	xfs_off_t		count_fsb)
  59{
  60	struct xfs_mount	*mp = ip->i_mount;
  61	struct xfs_buftarg	*target = xfs_inode_buftarg(ip);
  62	xfs_daddr_t		sector = xfs_fsb_to_db(ip, start_fsb);
  63	sector_t		block = XFS_BB_TO_FSBT(mp, sector);
  64
  65	return blkdev_issue_zeroout(target->bt_bdev,
  66		block << (mp->m_super->s_blocksize_bits - 9),
  67		count_fsb << (mp->m_super->s_blocksize_bits - 9),
  68		GFP_NOFS, 0);
  69}
  70
  71#ifdef CONFIG_XFS_RT
  72int
  73xfs_bmap_rtalloc(
  74	struct xfs_bmalloca	*ap)
  75{
  76	struct xfs_mount	*mp = ap->ip->i_mount;
  77	xfs_fileoff_t		orig_offset = ap->offset;
  78	xfs_rtblock_t		rtb;
  79	xfs_extlen_t		prod = 0;  /* product factor for allocators */
  80	xfs_extlen_t		mod = 0;   /* product factor for allocators */
  81	xfs_extlen_t		ralen = 0; /* realtime allocation length */
  82	xfs_extlen_t		align;     /* minimum allocation alignment */
  83	xfs_extlen_t		orig_length = ap->length;
  84	xfs_extlen_t		minlen = mp->m_sb.sb_rextsize;
  85	xfs_extlen_t		raminlen;
  86	bool			rtlocked = false;
  87	bool			ignore_locality = false;
  88	int			error;
  89
 
  90	align = xfs_get_extsz_hint(ap->ip);
  91retry:
  92	prod = align / mp->m_sb.sb_rextsize;
  93	error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
  94					align, 1, ap->eof, 0,
  95					ap->conv, &ap->offset, &ap->length);
  96	if (error)
  97		return error;
  98	ASSERT(ap->length);
  99	ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
 100
 101	/*
 102	 * If we shifted the file offset downward to satisfy an extent size
 103	 * hint, increase minlen by that amount so that the allocator won't
 104	 * give us an allocation that's too short to cover at least one of the
 105	 * blocks that the caller asked for.
 106	 */
 107	if (ap->offset != orig_offset)
 108		minlen += orig_offset - ap->offset;
 109
 110	/*
 111	 * If the offset & length are not perfectly aligned
 112	 * then kill prod, it will just get us in trouble.
 113	 */
 114	div_u64_rem(ap->offset, align, &mod);
 115	if (mod || ap->length % align)
 116		prod = 1;
 117	/*
 118	 * Set ralen to be the actual requested length in rtextents.
 119	 */
 120	ralen = ap->length / mp->m_sb.sb_rextsize;
 121	/*
 122	 * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that
 123	 * we rounded up to it, cut it back so it's valid again.
 124	 * Note that if it's a really large request (bigger than
 125	 * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't
 126	 * adjust the starting point to match it.
 127	 */
 128	if (ralen * mp->m_sb.sb_rextsize >= XFS_MAX_BMBT_EXTLEN)
 129		ralen = XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize;
 130
 131	/*
 132	 * Lock out modifications to both the RT bitmap and summary inodes
 133	 */
 134	if (!rtlocked) {
 135		xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
 136		xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
 137		xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
 138		xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
 139		rtlocked = true;
 140	}
 141
 142	/*
 143	 * If it's an allocation to an empty file at offset 0,
 144	 * pick an extent that will space things out in the rt area.
 145	 */
 146	if (ap->eof && ap->offset == 0) {
 147		xfs_rtblock_t rtx; /* realtime extent no */
 148
 149		error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
 150		if (error)
 151			return error;
 152		ap->blkno = rtx * mp->m_sb.sb_rextsize;
 153	} else {
 154		ap->blkno = 0;
 155	}
 156
 157	xfs_bmap_adjacent(ap);
 158
 159	/*
 160	 * Realtime allocation, done through xfs_rtallocate_extent.
 161	 */
 162	if (ignore_locality)
 163		ap->blkno = 0;
 164	else
 165		do_div(ap->blkno, mp->m_sb.sb_rextsize);
 166	rtb = ap->blkno;
 167	ap->length = ralen;
 168	raminlen = max_t(xfs_extlen_t, 1, minlen / mp->m_sb.sb_rextsize);
 169	error = xfs_rtallocate_extent(ap->tp, ap->blkno, raminlen, ap->length,
 170			&ralen, ap->wasdel, prod, &rtb);
 171	if (error)
 172		return error;
 173
 174	if (rtb != NULLRTBLOCK) {
 175		ap->blkno = rtb * mp->m_sb.sb_rextsize;
 176		ap->length = ralen * mp->m_sb.sb_rextsize;
 177		ap->ip->i_nblocks += ap->length;
 
 
 
 
 
 
 178		xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
 179		if (ap->wasdel)
 180			ap->ip->i_delayed_blks -= ap->length;
 181		/*
 182		 * Adjust the disk quota also. This was reserved
 183		 * earlier.
 184		 */
 185		xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
 186			ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
 187					XFS_TRANS_DQ_RTBCOUNT, ap->length);
 188		return 0;
 189	}
 190
 191	if (align > mp->m_sb.sb_rextsize) {
 192		/*
 193		 * We previously enlarged the request length to try to satisfy
 194		 * an extent size hint.  The allocator didn't return anything,
 195		 * so reset the parameters to the original values and try again
 196		 * without alignment criteria.
 197		 */
 198		ap->offset = orig_offset;
 199		ap->length = orig_length;
 200		minlen = align = mp->m_sb.sb_rextsize;
 201		goto retry;
 202	}
 
 
 203
 204	if (!ignore_locality && ap->blkno != 0) {
 205		/*
 206		 * If we can't allocate near a specific rt extent, try again
 207		 * without locality criteria.
 208		 */
 209		ignore_locality = true;
 210		goto retry;
 211	}
 
 
 
 
 
 
 212
 213	ap->blkno = NULLFSBLOCK;
 214	ap->length = 0;
 
 
 
 215	return 0;
 216}
 217#endif /* CONFIG_XFS_RT */
 218
 219/*
 220 * Extent tree block counting routines.
 221 */
 222
 223/*
 224 * Count leaf blocks given a range of extent records.  Delayed allocation
 225 * extents are not counted towards the totals.
 226 */
 227xfs_extnum_t
 228xfs_bmap_count_leaves(
 229	struct xfs_ifork	*ifp,
 230	xfs_filblks_t		*count)
 231{
 232	struct xfs_iext_cursor	icur;
 233	struct xfs_bmbt_irec	got;
 234	xfs_extnum_t		numrecs = 0;
 235
 236	for_each_xfs_iext(ifp, &icur, &got) {
 237		if (!isnullstartblock(got.br_startblock)) {
 238			*count += got.br_blockcount;
 239			numrecs++;
 240		}
 241	}
 242
 243	return numrecs;
 244}
 245
 246/*
 247 * Count fsblocks of the given fork.  Delayed allocation extents are
 248 * not counted towards the totals.
 249 */
 250int
 251xfs_bmap_count_blocks(
 252	struct xfs_trans	*tp,
 253	struct xfs_inode	*ip,
 254	int			whichfork,
 255	xfs_extnum_t		*nextents,
 256	xfs_filblks_t		*count)
 257{
 258	struct xfs_mount	*mp = ip->i_mount;
 259	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
 260	struct xfs_btree_cur	*cur;
 261	xfs_extlen_t		btblocks = 0;
 262	int			error;
 263
 264	*nextents = 0;
 265	*count = 0;
 266
 267	if (!ifp)
 268		return 0;
 269
 270	switch (ifp->if_format) {
 271	case XFS_DINODE_FMT_BTREE:
 272		error = xfs_iread_extents(tp, ip, whichfork);
 273		if (error)
 274			return error;
 275
 276		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
 277		error = xfs_btree_count_blocks(cur, &btblocks);
 278		xfs_btree_del_cursor(cur, error);
 279		if (error)
 280			return error;
 281
 282		/*
 283		 * xfs_btree_count_blocks includes the root block contained in
 284		 * the inode fork in @btblocks, so subtract one because we're
 285		 * only interested in allocated disk blocks.
 286		 */
 287		*count += btblocks - 1;
 288
 289		fallthrough;
 290	case XFS_DINODE_FMT_EXTENTS:
 291		*nextents = xfs_bmap_count_leaves(ifp, count);
 292		break;
 293	}
 294
 295	return 0;
 296}
 297
 298static int
 299xfs_getbmap_report_one(
 300	struct xfs_inode	*ip,
 301	struct getbmapx		*bmv,
 302	struct kgetbmap		*out,
 303	int64_t			bmv_end,
 304	struct xfs_bmbt_irec	*got)
 
 
 
 
 
 305{
 306	struct kgetbmap		*p = out + bmv->bmv_entries;
 307	bool			shared = false;
 308	int			error;
 
 
 
 
 
 
 
 309
 310	error = xfs_reflink_trim_around_shared(ip, got, &shared);
 
 311	if (error)
 312		return error;
 
 
 313
 314	if (isnullstartblock(got->br_startblock) ||
 315	    got->br_startblock == DELAYSTARTBLOCK) {
 316		/*
 317		 * Delalloc extents that start beyond EOF can occur due to
 318		 * speculative EOF allocation when the delalloc extent is larger
 319		 * than the largest freespace extent at conversion time.  These
 320		 * extents cannot be converted by data writeback, so can exist
 321		 * here even if we are not supposed to be finding delalloc
 322		 * extents.
 323		 */
 324		if (got->br_startoff < XFS_B_TO_FSB(ip->i_mount, XFS_ISIZE(ip)))
 325			ASSERT((bmv->bmv_iflags & BMV_IF_DELALLOC) != 0);
 
 
 326
 327		p->bmv_oflags |= BMV_OF_DELALLOC;
 328		p->bmv_block = -2;
 
 
 
 
 
 
 
 
 
 329	} else {
 330		p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 331	}
 
 
 332
 333	if (got->br_state == XFS_EXT_UNWRITTEN &&
 334	    (bmv->bmv_iflags & BMV_IF_PREALLOC))
 335		p->bmv_oflags |= BMV_OF_PREALLOC;
 336
 337	if (shared)
 338		p->bmv_oflags |= BMV_OF_SHARED;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 339
 340	p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff);
 341	p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 342
 343	bmv->bmv_offset = p->bmv_offset + p->bmv_length;
 344	bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
 345	bmv->bmv_entries++;
 346	return 0;
 347}
 348
 349static void
 350xfs_getbmap_report_hole(
 351	struct xfs_inode	*ip,
 352	struct getbmapx		*bmv,
 353	struct kgetbmap		*out,
 354	int64_t			bmv_end,
 355	xfs_fileoff_t		bno,
 356	xfs_fileoff_t		end)
 357{
 358	struct kgetbmap		*p = out + bmv->bmv_entries;
 359
 360	if (bmv->bmv_iflags & BMV_IF_NO_HOLES)
 361		return;
 362
 363	p->bmv_block = -1;
 364	p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno);
 365	p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 366
 367	bmv->bmv_offset = p->bmv_offset + p->bmv_length;
 368	bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
 369	bmv->bmv_entries++;
 370}
 371
 372static inline bool
 373xfs_getbmap_full(
 374	struct getbmapx		*bmv)
 375{
 376	return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1;
 377}
 
 
 
 
 
 
 
 
 
 
 378
 379static bool
 380xfs_getbmap_next_rec(
 381	struct xfs_bmbt_irec	*rec,
 382	xfs_fileoff_t		total_end)
 383{
 384	xfs_fileoff_t		end = rec->br_startoff + rec->br_blockcount;
 
 
 
 
 385
 386	if (end == total_end)
 387		return false;
 
 
 
 
 388
 389	rec->br_startoff += rec->br_blockcount;
 390	if (!isnullstartblock(rec->br_startblock) &&
 391	    rec->br_startblock != DELAYSTARTBLOCK)
 392		rec->br_startblock += rec->br_blockcount;
 393	rec->br_blockcount = total_end - end;
 394	return true;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 395}
 396
 397/*
 398 * Get inode's extents as described in bmv, and format for output.
 399 * Calls formatter to fill the user's buffer until all extents
 400 * are mapped, until the passed-in bmv->bmv_count slots have
 401 * been filled, or until the formatter short-circuits the loop,
 402 * if it is tracking filled-in extents on its own.
 403 */
 404int						/* error code */
 405xfs_getbmap(
 406	struct xfs_inode	*ip,
 407	struct getbmapx		*bmv,		/* user bmap structure */
 408	struct kgetbmap		*out)
 
 409{
 410	struct xfs_mount	*mp = ip->i_mount;
 411	int			iflags = bmv->bmv_iflags;
 412	int			whichfork, lock, error = 0;
 413	int64_t			bmv_end, max_len;
 414	xfs_fileoff_t		bno, first_bno;
 415	struct xfs_ifork	*ifp;
 416	struct xfs_bmbt_irec	got, rec;
 417	xfs_filblks_t		len;
 418	struct xfs_iext_cursor	icur;
 
 
 
 
 
 
 
 
 
 
 
 
 419
 420	if (bmv->bmv_iflags & ~BMV_IF_VALID)
 421		return -EINVAL;
 422#ifndef DEBUG
 423	/* Only allow CoW fork queries if we're debugging. */
 424	if (iflags & BMV_IF_COWFORK)
 425		return -EINVAL;
 426#endif
 427	if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK))
 428		return -EINVAL;
 429
 430	if (bmv->bmv_length < -1)
 431		return -EINVAL;
 432	bmv->bmv_entries = 0;
 433	if (bmv->bmv_length == 0)
 434		return 0;
 435
 436	if (iflags & BMV_IF_ATTRFORK)
 437		whichfork = XFS_ATTR_FORK;
 438	else if (iflags & BMV_IF_COWFORK)
 439		whichfork = XFS_COW_FORK;
 440	else
 441		whichfork = XFS_DATA_FORK;
 442
 443	xfs_ilock(ip, XFS_IOLOCK_SHARED);
 444	switch (whichfork) {
 445	case XFS_ATTR_FORK:
 446		lock = xfs_ilock_attr_map_shared(ip);
 447		if (!xfs_inode_has_attr_fork(ip))
 448			goto out_unlock_ilock;
 
 
 
 
 
 
 
 
 
 449
 450		max_len = 1LL << 32;
 
 451		break;
 452	case XFS_COW_FORK:
 453		lock = XFS_ILOCK_SHARED;
 454		xfs_ilock(ip, lock);
 455
 456		/* No CoW fork? Just return */
 457		if (!xfs_ifork_ptr(ip, whichfork))
 458			goto out_unlock_ilock;
 
 
 
 
 
 
 
 
 
 
 459
 460		if (xfs_get_cowextsz_hint(ip))
 461			max_len = mp->m_super->s_maxbytes;
 462		else
 463			max_len = XFS_ISIZE(ip);
 
 
 
 
 464		break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 465	case XFS_DATA_FORK:
 466		if (!(iflags & BMV_IF_DELALLOC) &&
 467		    (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_disk_size)) {
 468			error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
 469			if (error)
 470				goto out_unlock_iolock;
 471
 472			/*
 473			 * Even after flushing the inode, there can still be
 474			 * delalloc blocks on the inode beyond EOF due to
 475			 * speculative preallocation.  These are not removed
 476			 * until the release function is called or the inode
 477			 * is inactivated.  Hence we cannot assert here that
 478			 * ip->i_delayed_blks == 0.
 479			 */
 480		}
 481
 482		if (xfs_get_extsz_hint(ip) ||
 483		    (ip->i_diflags &
 484		     (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
 485			max_len = mp->m_super->s_maxbytes;
 486		else
 487			max_len = XFS_ISIZE(ip);
 488
 489		lock = xfs_ilock_data_map_shared(ip);
 490		break;
 
 
 
 
 
 
 
 491	}
 492
 493	ifp = xfs_ifork_ptr(ip, whichfork);
 
 
 
 
 
 494
 495	switch (ifp->if_format) {
 496	case XFS_DINODE_FMT_EXTENTS:
 497	case XFS_DINODE_FMT_BTREE:
 498		break;
 499	case XFS_DINODE_FMT_LOCAL:
 500		/* Local format inode forks report no extents. */
 501		goto out_unlock_ilock;
 502	default:
 503		error = -EINVAL;
 
 
 504		goto out_unlock_ilock;
 505	}
 506
 507	if (bmv->bmv_length == -1) {
 508		max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len));
 509		bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset);
 
 
 
 510	}
 511
 512	bmv_end = bmv->bmv_offset + bmv->bmv_length;
 
 
 
 
 
 
 
 513
 514	first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset);
 515	len = XFS_BB_TO_FSB(mp, bmv->bmv_length);
 
 
 
 
 
 
 
 
 
 
 
 516
 517	error = xfs_iread_extents(NULL, ip, whichfork);
 518	if (error)
 519		goto out_unlock_ilock;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 520
 521	if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
 522		/*
 523		 * Report a whole-file hole if the delalloc flag is set to
 524		 * stay compatible with the old implementation.
 525		 */
 526		if (iflags & BMV_IF_DELALLOC)
 527			xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
 528					XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
 529		goto out_unlock_ilock;
 530	}
 531
 532	while (!xfs_getbmap_full(bmv)) {
 533		xfs_trim_extent(&got, first_bno, len);
 
 
 
 
 
 
 
 
 
 534
 535		/*
 536		 * Report an entry for a hole if this extent doesn't directly
 537		 * follow the previous one.
 538		 */
 539		if (got.br_startoff > bno) {
 540			xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
 541					got.br_startoff);
 542			if (xfs_getbmap_full(bmv))
 543				break;
 544		}
 545
 546		/*
 547		 * In order to report shared extents accurately, we report each
 548		 * distinct shared / unshared part of a single bmbt record with
 549		 * an individual getbmapx record.
 550		 */
 551		bno = got.br_startoff + got.br_blockcount;
 552		rec = got;
 553		do {
 554			error = xfs_getbmap_report_one(ip, bmv, out, bmv_end,
 555					&rec);
 556			if (error || xfs_getbmap_full(bmv))
 557				goto out_unlock_ilock;
 558		} while (xfs_getbmap_next_rec(&rec, bno));
 559
 560		if (!xfs_iext_next_extent(ifp, &icur, &got)) {
 561			xfs_fileoff_t	end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
 562
 563			out[bmv->bmv_entries - 1].bmv_oflags |= BMV_OF_LAST;
 564
 565			if (whichfork != XFS_ATTR_FORK && bno < end &&
 566			    !xfs_getbmap_full(bmv)) {
 567				xfs_getbmap_report_hole(ip, bmv, out, bmv_end,
 568						bno, end);
 569			}
 570			break;
 
 571		}
 
 572
 573		if (bno >= first_bno + len)
 
 
 
 
 
 
 
 
 
 
 
 
 574			break;
 575	}
 576
 577out_unlock_ilock:
 578	xfs_iunlock(ip, lock);
 579out_unlock_iolock:
 580	xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 581	return error;
 582}
 583
 584/*
 585 * Dead simple method of punching delalyed allocation blocks from a range in
 586 * the inode.  This will always punch out both the start and end blocks, even
 587 * if the ranges only partially overlap them, so it is up to the caller to
 588 * ensure that partial blocks are not passed in.
 
 
 589 */
 590int
 591xfs_bmap_punch_delalloc_range(
 592	struct xfs_inode	*ip,
 593	xfs_off_t		start_byte,
 594	xfs_off_t		end_byte)
 595{
 596	struct xfs_mount	*mp = ip->i_mount;
 597	struct xfs_ifork	*ifp = &ip->i_df;
 598	xfs_fileoff_t		start_fsb = XFS_B_TO_FSBT(mp, start_byte);
 599	xfs_fileoff_t		end_fsb = XFS_B_TO_FSB(mp, end_byte);
 600	struct xfs_bmbt_irec	got, del;
 601	struct xfs_iext_cursor	icur;
 602	int			error = 0;
 603
 604	ASSERT(!xfs_need_iread_extents(ifp));
 605
 606	xfs_ilock(ip, XFS_ILOCK_EXCL);
 607	if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
 608		goto out_unlock;
 609
 610	while (got.br_startoff + got.br_blockcount > start_fsb) {
 611		del = got;
 612		xfs_trim_extent(&del, start_fsb, end_fsb - start_fsb);
 613
 614		/*
 615		 * A delete can push the cursor forward. Step back to the
 616		 * previous extent on non-delalloc or extents outside the
 617		 * target range.
 
 618		 */
 619		if (!del.br_blockcount ||
 620		    !isnullstartblock(del.br_startblock)) {
 621			if (!xfs_iext_prev_extent(ifp, &icur, &got))
 622				break;
 623			continue;
 
 
 
 
 
 
 624		}
 
 
 
 
 
 
 
 
 
 625
 626		error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
 627						  &got, &del);
 628		if (error || !xfs_iext_get_extent(ifp, &icur, &got))
 
 
 
 
 
 
 
 629			break;
 630	}
 631
 632out_unlock:
 633	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 
 
 
 
 634	return error;
 635}
 636
 637/*
 638 * Test whether it is appropriate to check an inode for and free post EOF
 639 * blocks. The 'force' parameter determines whether we should also consider
 640 * regular files that are marked preallocated or append-only.
 641 */
 642bool
 643xfs_can_free_eofblocks(
 644	struct xfs_inode	*ip,
 645	bool			force)
 646{
 647	struct xfs_bmbt_irec	imap;
 648	struct xfs_mount	*mp = ip->i_mount;
 649	xfs_fileoff_t		end_fsb;
 650	xfs_fileoff_t		last_fsb;
 651	int			nimaps = 1;
 652	int			error;
 653
 654	/*
 655	 * Caller must either hold the exclusive io lock; or be inactivating
 656	 * the inode, which guarantees there are no other users of the inode.
 657	 */
 658	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL) ||
 659	       (VFS_I(ip)->i_state & I_FREEING));
 660
 661	/* prealloc/delalloc exists only on regular files */
 662	if (!S_ISREG(VFS_I(ip)->i_mode))
 663		return false;
 664
 665	/*
 666	 * Zero sized files with no cached pages and delalloc blocks will not
 667	 * have speculative prealloc/delalloc blocks to remove.
 668	 */
 669	if (VFS_I(ip)->i_size == 0 &&
 670	    VFS_I(ip)->i_mapping->nrpages == 0 &&
 671	    ip->i_delayed_blks == 0)
 672		return false;
 673
 674	/* If we haven't read in the extent list, then don't do it now. */
 675	if (xfs_need_iread_extents(&ip->i_df))
 676		return false;
 677
 678	/*
 679	 * Do not free real preallocated or append-only files unless the file
 680	 * has delalloc blocks and we are forced to remove them.
 681	 */
 682	if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
 683		if (!force || ip->i_delayed_blks == 0)
 684			return false;
 685
 686	/*
 687	 * Do not try to free post-EOF blocks if EOF is beyond the end of the
 688	 * range supported by the page cache, because the truncation will loop
 689	 * forever.
 690	 */
 691	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
 692	if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1)
 693		end_fsb = roundup_64(end_fsb, mp->m_sb.sb_rextsize);
 694	last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
 695	if (last_fsb <= end_fsb)
 696		return false;
 697
 698	/*
 699	 * Look up the mapping for the first block past EOF.  If we can't find
 700	 * it, there's nothing to free.
 701	 */
 702	xfs_ilock(ip, XFS_ILOCK_SHARED);
 703	error = xfs_bmapi_read(ip, end_fsb, last_fsb - end_fsb, &imap, &nimaps,
 704			0);
 705	xfs_iunlock(ip, XFS_ILOCK_SHARED);
 706	if (error || nimaps == 0)
 707		return false;
 708
 709	/*
 710	 * If there's a real mapping there or there are delayed allocation
 711	 * reservations, then we have post-EOF blocks to try to free.
 712	 */
 713	return imap.br_startblock != HOLESTARTBLOCK || ip->i_delayed_blks;
 714}
 715
 716/*
 717 * This is called to free any blocks beyond eof. The caller must hold
 718 * IOLOCK_EXCL unless we are in the inode reclaim path and have the only
 719 * reference to the inode.
 720 */
 721int
 722xfs_free_eofblocks(
 723	struct xfs_inode	*ip)
 724{
 725	struct xfs_trans	*tp;
 726	struct xfs_mount	*mp = ip->i_mount;
 727	int			error;
 
 
 
 
 
 
 728
 729	/* Attach the dquots to the inode up front. */
 730	error = xfs_qm_dqattach(ip);
 731	if (error)
 732		return error;
 733
 734	/* Wait on dio to ensure i_size has settled. */
 735	inode_dio_wait(VFS_I(ip));
 736
 737	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
 738	if (error) {
 739		ASSERT(xfs_is_shutdown(mp));
 740		return error;
 741	}
 
 
 
 
 742
 743	xfs_ilock(ip, XFS_ILOCK_EXCL);
 744	xfs_trans_ijoin(tp, ip, 0);
 
 
 745
 746	/*
 747	 * Do not update the on-disk file size.  If we update the on-disk file
 748	 * size and then the system crashes before the contents of the file are
 749	 * flushed to disk then the files may be full of holes (ie NULL files
 750	 * bug).
 751	 */
 752	error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK,
 753				XFS_ISIZE(ip), XFS_BMAPI_NODISCARD);
 754	if (error)
 755		goto err_cancel;
 
 
 
 
 
 756
 757	error = xfs_trans_commit(tp);
 758	if (error)
 759		goto out_unlock;
 760
 761	xfs_inode_clear_eofblocks_tag(ip);
 762	goto out_unlock;
 
 
 
 
 763
 764err_cancel:
 765	/*
 766	 * If we get an error at this point we simply don't
 767	 * bother truncating the file.
 768	 */
 769	xfs_trans_cancel(tp);
 770out_unlock:
 771	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 772	return error;
 773}
 774
 775int
 776xfs_alloc_file_space(
 777	struct xfs_inode	*ip,
 778	xfs_off_t		offset,
 779	xfs_off_t		len)
 
 780{
 781	xfs_mount_t		*mp = ip->i_mount;
 782	xfs_off_t		count;
 783	xfs_filblks_t		allocated_fsb;
 784	xfs_filblks_t		allocatesize_fsb;
 785	xfs_extlen_t		extsz, temp;
 786	xfs_fileoff_t		startoffset_fsb;
 787	xfs_fileoff_t		endoffset_fsb;
 788	int			nimaps;
 
 789	int			rt;
 790	xfs_trans_t		*tp;
 791	xfs_bmbt_irec_t		imaps[1], *imapp;
 
 
 792	int			error;
 793
 794	trace_xfs_alloc_file_space(ip);
 795
 796	if (xfs_is_shutdown(mp))
 797		return -EIO;
 798
 799	error = xfs_qm_dqattach(ip);
 800	if (error)
 801		return error;
 802
 803	if (len <= 0)
 804		return -EINVAL;
 805
 806	rt = XFS_IS_REALTIME_INODE(ip);
 807	extsz = xfs_get_extsz_hint(ip);
 808
 809	count = len;
 810	imapp = &imaps[0];
 811	nimaps = 1;
 812	startoffset_fsb	= XFS_B_TO_FSBT(mp, offset);
 813	endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
 814	allocatesize_fsb = endoffset_fsb - startoffset_fsb;
 815
 816	/*
 817	 * Allocate file space until done or until there is an error
 818	 */
 819	while (allocatesize_fsb && !error) {
 820		xfs_fileoff_t	s, e;
 821		unsigned int	dblocks, rblocks, resblks;
 822
 823		/*
 824		 * Determine space reservations for data/realtime.
 825		 */
 826		if (unlikely(extsz)) {
 827			s = startoffset_fsb;
 828			do_div(s, extsz);
 829			s *= extsz;
 830			e = startoffset_fsb + allocatesize_fsb;
 831			div_u64_rem(startoffset_fsb, extsz, &temp);
 832			if (temp)
 833				e += temp;
 834			div_u64_rem(e, extsz, &temp);
 835			if (temp)
 836				e += extsz - temp;
 837		} else {
 838			s = 0;
 839			e = allocatesize_fsb;
 840		}
 841
 842		/*
 843		 * The transaction reservation is limited to a 32-bit block
 844		 * count, hence we need to limit the number of blocks we are
 845		 * trying to reserve to avoid an overflow. We can't allocate
 846		 * more than @nimaps extents, and an extent is limited on disk
 847		 * to XFS_BMBT_MAX_EXTLEN (21 bits), so use that to enforce the
 848		 * limit.
 849		 */
 850		resblks = min_t(xfs_fileoff_t, (e - s),
 851				(XFS_MAX_BMBT_EXTLEN * nimaps));
 852		if (unlikely(rt)) {
 853			dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
 854			rblocks = resblks;
 
 
 855		} else {
 856			dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
 857			rblocks = 0;
 
 858		}
 859
 860		error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
 861				dblocks, rblocks, false, &tp);
 862		if (error)
 863			break;
 
 864
 865		error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
 866				XFS_IEXT_ADD_NOSPLIT_CNT);
 867		if (error == -EFBIG)
 868			error = xfs_iext_count_upgrade(tp, ip,
 869					XFS_IEXT_ADD_NOSPLIT_CNT);
 
 
 
 
 
 
 
 
 870		if (error)
 871			goto error;
 872
 
 
 
 873		error = xfs_bmapi_write(tp, ip, startoffset_fsb,
 874				allocatesize_fsb, XFS_BMAPI_PREALLOC, 0, imapp,
 875				&nimaps);
 876		if (error)
 877			goto error;
 878
 879		ip->i_diflags |= XFS_DIFLAG_PREALLOC;
 880		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
 
 
 
 881
 882		error = xfs_trans_commit(tp);
 883		xfs_iunlock(ip, XFS_ILOCK_EXCL);
 884		if (error)
 885			break;
 886
 887		allocated_fsb = imapp->br_blockcount;
 888
 889		if (nimaps == 0) {
 890			error = -ENOSPC;
 891			break;
 892		}
 893
 894		startoffset_fsb += allocated_fsb;
 895		allocatesize_fsb -= allocated_fsb;
 896	}
 897
 898	return error;
 899
 900error:
 
 
 
 
 901	xfs_trans_cancel(tp);
 902	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 903	return error;
 904}
 905
 906static int
 907xfs_unmap_extent(
 908	struct xfs_inode	*ip,
 909	xfs_fileoff_t		startoffset_fsb,
 910	xfs_filblks_t		len_fsb,
 911	int			*done)
 912{
 913	struct xfs_mount	*mp = ip->i_mount;
 914	struct xfs_trans	*tp;
 
 
 915	uint			resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
 916	int			error;
 917
 918	error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
 919			false, &tp);
 920	if (error)
 921		return error;
 
 922
 923	error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
 924			XFS_IEXT_PUNCH_HOLE_CNT);
 925	if (error == -EFBIG)
 926		error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
 927	if (error)
 928		goto out_trans_cancel;
 929
 930	error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done);
 
 
 
 
 931	if (error)
 932		goto out_trans_cancel;
 
 
 
 
 933
 934	error = xfs_trans_commit(tp);
 935out_unlock:
 936	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 937	return error;
 938
 
 
 939out_trans_cancel:
 940	xfs_trans_cancel(tp);
 941	goto out_unlock;
 942}
 943
 944/* Caller must first wait for the completion of any pending DIOs if required. */
 945int
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 946xfs_flush_unmap_range(
 947	struct xfs_inode	*ip,
 948	xfs_off_t		offset,
 949	xfs_off_t		len)
 950{
 951	struct xfs_mount	*mp = ip->i_mount;
 952	struct inode		*inode = VFS_I(ip);
 953	xfs_off_t		rounding, start, end;
 954	int			error;
 955
 956	rounding = max_t(xfs_off_t, mp->m_sb.sb_blocksize, PAGE_SIZE);
 
 
 
 957	start = round_down(offset, rounding);
 958	end = round_up(offset + len, rounding) - 1;
 959
 960	error = filemap_write_and_wait_range(inode->i_mapping, start, end);
 961	if (error)
 962		return error;
 963	truncate_pagecache_range(inode, start, end);
 964	return 0;
 965}
 966
 967int
 968xfs_free_file_space(
 969	struct xfs_inode	*ip,
 970	xfs_off_t		offset,
 971	xfs_off_t		len)
 972{
 973	struct xfs_mount	*mp = ip->i_mount;
 974	xfs_fileoff_t		startoffset_fsb;
 975	xfs_fileoff_t		endoffset_fsb;
 976	int			done = 0, error;
 977
 978	trace_xfs_free_file_space(ip);
 979
 980	error = xfs_qm_dqattach(ip);
 981	if (error)
 982		return error;
 983
 984	if (len <= 0)	/* if nothing being freed */
 985		return 0;
 986
 
 
 
 
 987	startoffset_fsb = XFS_B_TO_FSB(mp, offset);
 988	endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
 989
 990	/* We can only free complete realtime extents. */
 991	if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
 992		startoffset_fsb = roundup_64(startoffset_fsb,
 993					     mp->m_sb.sb_rextsize);
 994		endoffset_fsb = rounddown_64(endoffset_fsb,
 995					     mp->m_sb.sb_rextsize);
 
 
 
 
 
 
 996	}
 997
 998	/*
 999	 * Need to zero the stuff we're not freeing, on disk.
1000	 */
1001	if (endoffset_fsb > startoffset_fsb) {
1002		while (!done) {
1003			error = xfs_unmap_extent(ip, startoffset_fsb,
1004					endoffset_fsb - startoffset_fsb, &done);
1005			if (error)
1006				return error;
1007		}
1008	}
1009
1010	/*
1011	 * Now that we've unmap all full blocks we'll have to zero out any
1012	 * partial block at the beginning and/or end.  xfs_zero_range is smart
1013	 * enough to skip any holes, including those we just created, but we
1014	 * must take care not to zero beyond EOF and enlarge i_size.
1015	 */
 
1016	if (offset >= XFS_ISIZE(ip))
1017		return 0;
 
1018	if (offset + len > XFS_ISIZE(ip))
1019		len = XFS_ISIZE(ip) - offset;
1020	error = xfs_zero_range(ip, offset, len, NULL);
1021	if (error)
1022		return error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1023
1024	/*
1025	 * If we zeroed right up to EOF and EOF straddles a page boundary we
1026	 * must make sure that the post-EOF area is also zeroed because the
1027	 * page could be mmap'd and xfs_zero_range doesn't do that for us.
1028	 * Writeback of the eof page will do this, albeit clumsily.
1029	 */
1030	if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) {
1031		error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
1032				round_down(offset + len, PAGE_SIZE), LLONG_MAX);
1033	}
 
 
1034
 
 
 
 
 
1035	return error;
 
1036}
1037
 
 
 
 
 
 
 
 
1038static int
1039xfs_prepare_shift(
1040	struct xfs_inode	*ip,
1041	loff_t			offset)
 
 
1042{
 
1043	struct xfs_mount	*mp = ip->i_mount;
 
1044	int			error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1045
1046	/*
1047	 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1048	 * into the accessible region of the file.
1049	 */
1050	if (xfs_can_free_eofblocks(ip, true)) {
1051		error = xfs_free_eofblocks(ip);
1052		if (error)
1053			return error;
1054	}
1055
1056	/*
1057	 * Shift operations must stabilize the start block offset boundary along
1058	 * with the full range of the operation. If we don't, a COW writeback
1059	 * completion could race with an insert, front merge with the start
1060	 * extent (after split) during the shift and corrupt the file. Start
1061	 * with the block just prior to the start to stabilize the boundary.
1062	 */
1063	offset = round_down(offset, mp->m_sb.sb_blocksize);
1064	if (offset)
1065		offset -= mp->m_sb.sb_blocksize;
1066
1067	/*
1068	 * Writeback and invalidate cache for the remainder of the file as we're
1069	 * about to shift down every extent from offset to EOF.
1070	 */
1071	error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
 
 
 
 
 
1072	if (error)
1073		return error;
1074
1075	/*
1076	 * Clean out anything hanging around in the cow fork now that
1077	 * we've flushed all the dirty data out to disk to avoid having
1078	 * CoW extents at the wrong offsets.
1079	 */
1080	if (xfs_inode_has_cow_data(ip)) {
1081		error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF,
1082				true);
1083		if (error)
1084			return error;
1085	}
1086
1087	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1088}
1089
1090/*
1091 * xfs_collapse_file_space()
1092 *	This routine frees disk space and shift extent for the given file.
1093 *	The first thing we do is to free data blocks in the specified range
1094 *	by calling xfs_free_file_space(). It would also sync dirty data
1095 *	and invalidate page cache over the region on which collapse range
1096 *	is working. And Shift extent records to the left to cover a hole.
1097 * RETURNS:
1098 *	0 on success
1099 *	errno on error
1100 *
1101 */
1102int
1103xfs_collapse_file_space(
1104	struct xfs_inode	*ip,
1105	xfs_off_t		offset,
1106	xfs_off_t		len)
1107{
1108	struct xfs_mount	*mp = ip->i_mount;
1109	struct xfs_trans	*tp;
1110	int			error;
1111	xfs_fileoff_t		next_fsb = XFS_B_TO_FSB(mp, offset + len);
1112	xfs_fileoff_t		shift_fsb = XFS_B_TO_FSB(mp, len);
1113	bool			done = false;
1114
1115	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1116	ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1117
1118	trace_xfs_collapse_file_space(ip);
1119
1120	error = xfs_free_file_space(ip, offset, len);
1121	if (error)
1122		return error;
1123
1124	error = xfs_prepare_shift(ip, offset);
1125	if (error)
1126		return error;
1127
1128	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1129	if (error)
1130		return error;
1131
1132	xfs_ilock(ip, XFS_ILOCK_EXCL);
1133	xfs_trans_ijoin(tp, ip, 0);
1134
1135	while (!done) {
1136		error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
1137				&done);
1138		if (error)
1139			goto out_trans_cancel;
1140		if (done)
1141			break;
1142
1143		/* finish any deferred frees and roll the transaction */
1144		error = xfs_defer_finish(&tp);
1145		if (error)
1146			goto out_trans_cancel;
1147	}
1148
1149	error = xfs_trans_commit(tp);
1150	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1151	return error;
1152
1153out_trans_cancel:
1154	xfs_trans_cancel(tp);
1155	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1156	return error;
1157}
1158
1159/*
1160 * xfs_insert_file_space()
1161 *	This routine create hole space by shifting extents for the given file.
1162 *	The first thing we do is to sync dirty data and invalidate page cache
1163 *	over the region on which insert range is working. And split an extent
1164 *	to two extents at given offset by calling xfs_bmap_split_extent.
1165 *	And shift all extent records which are laying between [offset,
1166 *	last allocated extent] to the right to reserve hole range.
1167 * RETURNS:
1168 *	0 on success
1169 *	errno on error
1170 */
1171int
1172xfs_insert_file_space(
1173	struct xfs_inode	*ip,
1174	loff_t			offset,
1175	loff_t			len)
1176{
1177	struct xfs_mount	*mp = ip->i_mount;
1178	struct xfs_trans	*tp;
1179	int			error;
1180	xfs_fileoff_t		stop_fsb = XFS_B_TO_FSB(mp, offset);
1181	xfs_fileoff_t		next_fsb = NULLFSBLOCK;
1182	xfs_fileoff_t		shift_fsb = XFS_B_TO_FSB(mp, len);
1183	bool			done = false;
1184
1185	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1186	ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1187
1188	trace_xfs_insert_file_space(ip);
1189
1190	error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
1191	if (error)
1192		return error;
1193
1194	error = xfs_prepare_shift(ip, offset);
1195	if (error)
1196		return error;
1197
1198	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
1199			XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
1200	if (error)
1201		return error;
1202
1203	xfs_ilock(ip, XFS_ILOCK_EXCL);
1204	xfs_trans_ijoin(tp, ip, 0);
1205
1206	error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
1207			XFS_IEXT_PUNCH_HOLE_CNT);
1208	if (error == -EFBIG)
1209		error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
1210	if (error)
1211		goto out_trans_cancel;
1212
1213	/*
1214	 * The extent shifting code works on extent granularity. So, if stop_fsb
1215	 * is not the starting block of extent, we need to split the extent at
1216	 * stop_fsb.
1217	 */
1218	error = xfs_bmap_split_extent(tp, ip, stop_fsb);
1219	if (error)
1220		goto out_trans_cancel;
1221
1222	do {
1223		error = xfs_defer_finish(&tp);
1224		if (error)
1225			goto out_trans_cancel;
1226
1227		error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb,
1228				&done, stop_fsb);
1229		if (error)
1230			goto out_trans_cancel;
1231	} while (!done);
1232
1233	error = xfs_trans_commit(tp);
1234	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1235	return error;
1236
1237out_trans_cancel:
1238	xfs_trans_cancel(tp);
1239	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1240	return error;
1241}
1242
1243/*
1244 * We need to check that the format of the data fork in the temporary inode is
1245 * valid for the target inode before doing the swap. This is not a problem with
1246 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1247 * data fork depending on the space the attribute fork is taking so we can get
1248 * invalid formats on the target inode.
1249 *
1250 * E.g. target has space for 7 extents in extent format, temp inode only has
1251 * space for 6.  If we defragment down to 7 extents, then the tmp format is a
1252 * btree, but when swapped it needs to be in extent format. Hence we can't just
1253 * blindly swap data forks on attr2 filesystems.
1254 *
1255 * Note that we check the swap in both directions so that we don't end up with
1256 * a corrupt temporary inode, either.
1257 *
1258 * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1259 * inode will prevent this situation from occurring, so all we do here is
1260 * reject and log the attempt. basically we are putting the responsibility on
1261 * userspace to get this right.
1262 */
1263static int
1264xfs_swap_extents_check_format(
1265	struct xfs_inode	*ip,	/* target inode */
1266	struct xfs_inode	*tip)	/* tmp inode */
1267{
1268	struct xfs_ifork	*ifp = &ip->i_df;
1269	struct xfs_ifork	*tifp = &tip->i_df;
1270
1271	/* User/group/project quota ids must match if quotas are enforced. */
1272	if (XFS_IS_QUOTA_ON(ip->i_mount) &&
1273	    (!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) ||
1274	     !gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) ||
1275	     ip->i_projid != tip->i_projid))
1276		return -EINVAL;
1277
1278	/* Should never get a local format */
1279	if (ifp->if_format == XFS_DINODE_FMT_LOCAL ||
1280	    tifp->if_format == XFS_DINODE_FMT_LOCAL)
1281		return -EINVAL;
1282
1283	/*
1284	 * if the target inode has less extents that then temporary inode then
1285	 * why did userspace call us?
1286	 */
1287	if (ifp->if_nextents < tifp->if_nextents)
1288		return -EINVAL;
1289
1290	/*
1291	 * If we have to use the (expensive) rmap swap method, we can
1292	 * handle any number of extents and any format.
1293	 */
1294	if (xfs_has_rmapbt(ip->i_mount))
1295		return 0;
1296
1297	/*
1298	 * if the target inode is in extent form and the temp inode is in btree
1299	 * form then we will end up with the target inode in the wrong format
1300	 * as we already know there are less extents in the temp inode.
1301	 */
1302	if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1303	    tifp->if_format == XFS_DINODE_FMT_BTREE)
1304		return -EINVAL;
1305
1306	/* Check temp in extent form to max in target */
1307	if (tifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1308	    tifp->if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
 
1309		return -EINVAL;
1310
1311	/* Check target in extent form to max in temp */
1312	if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1313	    ifp->if_nextents > XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
 
1314		return -EINVAL;
1315
1316	/*
1317	 * If we are in a btree format, check that the temp root block will fit
1318	 * in the target and that it has enough extents to be in btree format
1319	 * in the target.
1320	 *
1321	 * Note that we have to be careful to allow btree->extent conversions
1322	 * (a common defrag case) which will occur when the temp inode is in
1323	 * extent format...
1324	 */
1325	if (tifp->if_format == XFS_DINODE_FMT_BTREE) {
1326		if (xfs_inode_has_attr_fork(ip) &&
1327		    XFS_BMAP_BMDR_SPACE(tifp->if_broot) > xfs_inode_fork_boff(ip))
1328			return -EINVAL;
1329		if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
 
1330			return -EINVAL;
1331	}
1332
1333	/* Reciprocal target->temp btree format checks */
1334	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
1335		if (xfs_inode_has_attr_fork(tip) &&
1336		    XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > xfs_inode_fork_boff(tip))
1337			return -EINVAL;
1338		if (ifp->if_nextents <= XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
 
1339			return -EINVAL;
1340	}
1341
1342	return 0;
1343}
1344
1345static int
1346xfs_swap_extent_flush(
1347	struct xfs_inode	*ip)
1348{
1349	int	error;
1350
1351	error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1352	if (error)
1353		return error;
1354	truncate_pagecache_range(VFS_I(ip), 0, -1);
1355
1356	/* Verify O_DIRECT for ftmp */
1357	if (VFS_I(ip)->i_mapping->nrpages)
1358		return -EINVAL;
1359	return 0;
1360}
1361
1362/*
1363 * Move extents from one file to another, when rmap is enabled.
1364 */
1365STATIC int
1366xfs_swap_extent_rmap(
1367	struct xfs_trans		**tpp,
1368	struct xfs_inode		*ip,
1369	struct xfs_inode		*tip)
1370{
1371	struct xfs_trans		*tp = *tpp;
1372	struct xfs_bmbt_irec		irec;
1373	struct xfs_bmbt_irec		uirec;
1374	struct xfs_bmbt_irec		tirec;
1375	xfs_fileoff_t			offset_fsb;
1376	xfs_fileoff_t			end_fsb;
1377	xfs_filblks_t			count_fsb;
 
 
1378	int				error;
1379	xfs_filblks_t			ilen;
1380	xfs_filblks_t			rlen;
1381	int				nimaps;
1382	uint64_t			tip_flags2;
1383
1384	/*
1385	 * If the source file has shared blocks, we must flag the donor
1386	 * file as having shared blocks so that we get the shared-block
1387	 * rmap functions when we go to fix up the rmaps.  The flags
1388	 * will be switch for reals later.
1389	 */
1390	tip_flags2 = tip->i_diflags2;
1391	if (ip->i_diflags2 & XFS_DIFLAG2_REFLINK)
1392		tip->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1393
1394	offset_fsb = 0;
1395	end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));
1396	count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb);
1397
1398	while (count_fsb) {
1399		/* Read extent from the donor file */
1400		nimaps = 1;
1401		error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec,
1402				&nimaps, 0);
1403		if (error)
1404			goto out;
1405		ASSERT(nimaps == 1);
1406		ASSERT(tirec.br_startblock != DELAYSTARTBLOCK);
1407
1408		trace_xfs_swap_extent_rmap_remap(tip, &tirec);
1409		ilen = tirec.br_blockcount;
1410
1411		/* Unmap the old blocks in the source file. */
1412		while (tirec.br_blockcount) {
1413			ASSERT(tp->t_firstblock == NULLFSBLOCK);
1414			trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
1415
1416			/* Read extent from the source file */
1417			nimaps = 1;
1418			error = xfs_bmapi_read(ip, tirec.br_startoff,
1419					tirec.br_blockcount, &irec,
1420					&nimaps, 0);
1421			if (error)
1422				goto out;
1423			ASSERT(nimaps == 1);
1424			ASSERT(tirec.br_startoff == irec.br_startoff);
1425			trace_xfs_swap_extent_rmap_remap_piece(ip, &irec);
1426
1427			/* Trim the extent. */
1428			uirec = tirec;
1429			uirec.br_blockcount = rlen = min_t(xfs_filblks_t,
1430					tirec.br_blockcount,
1431					irec.br_blockcount);
1432			trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec);
1433
1434			if (xfs_bmap_is_real_extent(&uirec)) {
1435				error = xfs_iext_count_may_overflow(ip,
1436						XFS_DATA_FORK,
1437						XFS_IEXT_SWAP_RMAP_CNT);
1438				if (error == -EFBIG)
1439					error = xfs_iext_count_upgrade(tp, ip,
1440							XFS_IEXT_SWAP_RMAP_CNT);
1441				if (error)
1442					goto out;
1443			}
1444
1445			if (xfs_bmap_is_real_extent(&irec)) {
1446				error = xfs_iext_count_may_overflow(tip,
1447						XFS_DATA_FORK,
1448						XFS_IEXT_SWAP_RMAP_CNT);
1449				if (error == -EFBIG)
1450					error = xfs_iext_count_upgrade(tp, ip,
1451							XFS_IEXT_SWAP_RMAP_CNT);
1452				if (error)
1453					goto out;
1454			}
1455
1456			/* Remove the mapping from the donor file. */
1457			xfs_bmap_unmap_extent(tp, tip, &uirec);
 
 
 
1458
1459			/* Remove the mapping from the source file. */
1460			xfs_bmap_unmap_extent(tp, ip, &irec);
 
 
 
1461
1462			/* Map the donor file's blocks into the source file. */
1463			xfs_bmap_map_extent(tp, ip, &uirec);
 
 
 
1464
1465			/* Map the source file's blocks into the donor file. */
1466			xfs_bmap_map_extent(tp, tip, &irec);
 
 
 
1467
1468			error = xfs_defer_finish(tpp);
1469			tp = *tpp;
1470			if (error)
1471				goto out;
1472
1473			tirec.br_startoff += rlen;
1474			if (tirec.br_startblock != HOLESTARTBLOCK &&
1475			    tirec.br_startblock != DELAYSTARTBLOCK)
1476				tirec.br_startblock += rlen;
1477			tirec.br_blockcount -= rlen;
1478		}
1479
1480		/* Roll on... */
1481		count_fsb -= ilen;
1482		offset_fsb += ilen;
1483	}
1484
1485	tip->i_diflags2 = tip_flags2;
1486	return 0;
1487
 
 
1488out:
1489	trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_);
1490	tip->i_diflags2 = tip_flags2;
1491	return error;
1492}
1493
1494/* Swap the extents of two files by swapping data forks. */
1495STATIC int
1496xfs_swap_extent_forks(
1497	struct xfs_trans	*tp,
1498	struct xfs_inode	*ip,
1499	struct xfs_inode	*tip,
1500	int			*src_log_flags,
1501	int			*target_log_flags)
1502{
1503	xfs_filblks_t		aforkblks = 0;
1504	xfs_filblks_t		taforkblks = 0;
1505	xfs_extnum_t		junk;
1506	uint64_t		tmp;
 
1507	int			error;
1508
1509	/*
1510	 * Count the number of extended attribute blocks
1511	 */
1512	if (xfs_inode_has_attr_fork(ip) && ip->i_af.if_nextents > 0 &&
1513	    ip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1514		error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk,
1515				&aforkblks);
1516		if (error)
1517			return error;
1518	}
1519	if (xfs_inode_has_attr_fork(tip) && tip->i_af.if_nextents > 0 &&
1520	    tip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1521		error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, &junk,
1522				&taforkblks);
1523		if (error)
1524			return error;
1525	}
1526
1527	/*
1528	 * Btree format (v3) inodes have the inode number stamped in the bmbt
1529	 * block headers. We can't start changing the bmbt blocks until the
1530	 * inode owner change is logged so recovery does the right thing in the
1531	 * event of a crash. Set the owner change log flags now and leave the
1532	 * bmbt scan as the last step.
1533	 */
1534	if (xfs_has_v3inodes(ip->i_mount)) {
1535		if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1536			(*target_log_flags) |= XFS_ILOG_DOWNER;
1537		if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1538			(*src_log_flags) |= XFS_ILOG_DOWNER;
 
 
 
 
 
 
 
 
 
 
 
1539	}
1540
1541	/*
1542	 * Swap the data forks of the inodes
1543	 */
1544	swap(ip->i_df, tip->i_df);
 
 
 
 
1545
1546	/*
1547	 * Fix the on-disk inode values
1548	 */
1549	tmp = (uint64_t)ip->i_nblocks;
1550	ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks;
1551	tip->i_nblocks = tmp + taforkblks - aforkblks;
 
 
 
 
 
 
 
 
1552
1553	/*
1554	 * The extents in the source inode could still contain speculative
1555	 * preallocation beyond EOF (e.g. the file is open but not modified
1556	 * while defrag is in progress). In that case, we need to copy over the
1557	 * number of delalloc blocks the data fork in the source inode is
1558	 * tracking beyond EOF so that when the fork is truncated away when the
1559	 * temporary inode is unlinked we don't underrun the i_delayed_blks
1560	 * counter on that inode.
1561	 */
1562	ASSERT(tip->i_delayed_blks == 0);
1563	tip->i_delayed_blks = ip->i_delayed_blks;
1564	ip->i_delayed_blks = 0;
1565
1566	switch (ip->i_df.if_format) {
1567	case XFS_DINODE_FMT_EXTENTS:
 
 
 
 
 
 
 
1568		(*src_log_flags) |= XFS_ILOG_DEXT;
1569		break;
1570	case XFS_DINODE_FMT_BTREE:
1571		ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1572		       (*src_log_flags & XFS_ILOG_DOWNER));
1573		(*src_log_flags) |= XFS_ILOG_DBROOT;
1574		break;
1575	}
1576
1577	switch (tip->i_df.if_format) {
1578	case XFS_DINODE_FMT_EXTENTS:
 
 
 
 
 
 
 
1579		(*target_log_flags) |= XFS_ILOG_DEXT;
1580		break;
1581	case XFS_DINODE_FMT_BTREE:
1582		(*target_log_flags) |= XFS_ILOG_DBROOT;
1583		ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1584		       (*target_log_flags & XFS_ILOG_DOWNER));
1585		break;
1586	}
1587
1588	return 0;
1589}
1590
1591/*
1592 * Fix up the owners of the bmbt blocks to refer to the current inode. The
1593 * change owner scan attempts to order all modified buffers in the current
1594 * transaction. In the event of ordered buffer failure, the offending buffer is
1595 * physically logged as a fallback and the scan returns -EAGAIN. We must roll
1596 * the transaction in this case to replenish the fallback log reservation and
1597 * restart the scan. This process repeats until the scan completes.
1598 */
1599static int
1600xfs_swap_change_owner(
1601	struct xfs_trans	**tpp,
1602	struct xfs_inode	*ip,
1603	struct xfs_inode	*tmpip)
1604{
1605	int			error;
1606	struct xfs_trans	*tp = *tpp;
1607
1608	do {
1609		error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino,
1610					      NULL);
1611		/* success or fatal error */
1612		if (error != -EAGAIN)
1613			break;
1614
1615		error = xfs_trans_roll(tpp);
1616		if (error)
1617			break;
1618		tp = *tpp;
1619
1620		/*
1621		 * Redirty both inodes so they can relog and keep the log tail
1622		 * moving forward.
1623		 */
1624		xfs_trans_ijoin(tp, ip, 0);
1625		xfs_trans_ijoin(tp, tmpip, 0);
1626		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1627		xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE);
1628	} while (true);
1629
1630	return error;
1631}
1632
1633int
1634xfs_swap_extents(
1635	struct xfs_inode	*ip,	/* target inode */
1636	struct xfs_inode	*tip,	/* tmp inode */
1637	struct xfs_swapext	*sxp)
1638{
1639	struct xfs_mount	*mp = ip->i_mount;
1640	struct xfs_trans	*tp;
1641	struct xfs_bstat	*sbp = &sxp->sx_stat;
1642	int			src_log_flags, target_log_flags;
1643	int			error = 0;
1644	uint64_t		f;
1645	int			resblks = 0;
1646	unsigned int		flags = 0;
 
1647
1648	/*
1649	 * Lock the inodes against other IO, page faults and truncate to
1650	 * begin with.  Then we can ensure the inodes are flushed and have no
1651	 * page cache safely. Once we have done this we can take the ilocks and
1652	 * do the rest of the checks.
1653	 */
1654	lock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1655	filemap_invalidate_lock_two(VFS_I(ip)->i_mapping,
1656				    VFS_I(tip)->i_mapping);
1657
1658	/* Verify that both files have the same format */
1659	if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) {
1660		error = -EINVAL;
1661		goto out_unlock;
1662	}
1663
1664	/* Verify both files are either real-time or non-realtime */
1665	if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1666		error = -EINVAL;
1667		goto out_unlock;
1668	}
1669
1670	error = xfs_qm_dqattach(ip);
1671	if (error)
1672		goto out_unlock;
1673
1674	error = xfs_qm_dqattach(tip);
1675	if (error)
1676		goto out_unlock;
1677
1678	error = xfs_swap_extent_flush(ip);
1679	if (error)
1680		goto out_unlock;
1681	error = xfs_swap_extent_flush(tip);
1682	if (error)
1683		goto out_unlock;
1684
1685	if (xfs_inode_has_cow_data(tip)) {
1686		error = xfs_reflink_cancel_cow_range(tip, 0, NULLFILEOFF, true);
1687		if (error)
1688			goto out_unlock;
1689	}
1690
1691	/*
1692	 * Extent "swapping" with rmap requires a permanent reservation and
1693	 * a block reservation because it's really just a remap operation
1694	 * performed with log redo items!
1695	 */
1696	if (xfs_has_rmapbt(mp)) {
1697		int		w = XFS_DATA_FORK;
1698		uint32_t	ipnext = ip->i_df.if_nextents;
1699		uint32_t	tipnext	= tip->i_df.if_nextents;
1700
1701		/*
1702		 * Conceptually this shouldn't affect the shape of either bmbt,
1703		 * but since we atomically move extents one by one, we reserve
1704		 * enough space to rebuild both trees.
1705		 */
1706		resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w);
1707		resblks +=  XFS_SWAP_RMAP_SPACE_RES(mp, tipnext, w);
1708
1709		/*
1710		 * If either inode straddles a bmapbt block allocation boundary,
1711		 * the rmapbt algorithm triggers repeated allocs and frees as
1712		 * extents are remapped. This can exhaust the block reservation
1713		 * prematurely and cause shutdown. Return freed blocks to the
1714		 * transaction reservation to counter this behavior.
1715		 */
1716		flags |= XFS_TRANS_RES_FDBLKS;
1717	}
1718	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags,
1719				&tp);
 
 
 
 
 
 
 
1720	if (error)
1721		goto out_unlock;
1722
1723	/*
1724	 * Lock and join the inodes to the tansaction so that transaction commit
1725	 * or cancel will unlock the inodes from this point onwards.
1726	 */
1727	xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL);
 
1728	xfs_trans_ijoin(tp, ip, 0);
1729	xfs_trans_ijoin(tp, tip, 0);
1730
1731
1732	/* Verify all data are being swapped */
1733	if (sxp->sx_offset != 0 ||
1734	    sxp->sx_length != ip->i_disk_size ||
1735	    sxp->sx_length != tip->i_disk_size) {
1736		error = -EFAULT;
1737		goto out_trans_cancel;
1738	}
1739
1740	trace_xfs_swap_extent_before(ip, 0);
1741	trace_xfs_swap_extent_before(tip, 1);
1742
1743	/* check inode formats now that data is flushed */
1744	error = xfs_swap_extents_check_format(ip, tip);
1745	if (error) {
1746		xfs_notice(mp,
1747		    "%s: inode 0x%llx format is incompatible for exchanging.",
1748				__func__, ip->i_ino);
1749		goto out_trans_cancel;
1750	}
1751
1752	/*
1753	 * Compare the current change & modify times with that
1754	 * passed in.  If they differ, we abort this swap.
1755	 * This is the mechanism used to ensure the calling
1756	 * process that the file was not changed out from
1757	 * under it.
1758	 */
1759	if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1760	    (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1761	    (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1762	    (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
1763		error = -EBUSY;
1764		goto out_trans_cancel;
1765	}
1766
1767	/*
1768	 * Note the trickiness in setting the log flags - we set the owner log
1769	 * flag on the opposite inode (i.e. the inode we are setting the new
1770	 * owner to be) because once we swap the forks and log that, log
1771	 * recovery is going to see the fork as owned by the swapped inode,
1772	 * not the pre-swapped inodes.
1773	 */
1774	src_log_flags = XFS_ILOG_CORE;
1775	target_log_flags = XFS_ILOG_CORE;
1776
1777	if (xfs_has_rmapbt(mp))
1778		error = xfs_swap_extent_rmap(&tp, ip, tip);
1779	else
1780		error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags,
1781				&target_log_flags);
1782	if (error)
1783		goto out_trans_cancel;
1784
1785	/* Do we have to swap reflink flags? */
1786	if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
1787	    (tip->i_diflags2 & XFS_DIFLAG2_REFLINK)) {
1788		f = ip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1789		ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1790		ip->i_diflags2 |= tip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1791		tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1792		tip->i_diflags2 |= f & XFS_DIFLAG2_REFLINK;
1793	}
1794
1795	/* Swap the cow forks. */
1796	if (xfs_has_reflink(mp)) {
1797		ASSERT(!ip->i_cowfp ||
1798		       ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1799		ASSERT(!tip->i_cowfp ||
1800		       tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1801
1802		swap(ip->i_cowfp, tip->i_cowfp);
1803
1804		if (ip->i_cowfp && ip->i_cowfp->if_bytes)
1805			xfs_inode_set_cowblocks_tag(ip);
1806		else
1807			xfs_inode_clear_cowblocks_tag(ip);
1808		if (tip->i_cowfp && tip->i_cowfp->if_bytes)
1809			xfs_inode_set_cowblocks_tag(tip);
1810		else
1811			xfs_inode_clear_cowblocks_tag(tip);
1812	}
1813
1814	xfs_trans_log_inode(tp, ip,  src_log_flags);
1815	xfs_trans_log_inode(tp, tip, target_log_flags);
1816
1817	/*
1818	 * The extent forks have been swapped, but crc=1,rmapbt=0 filesystems
1819	 * have inode number owner values in the bmbt blocks that still refer to
1820	 * the old inode. Scan each bmbt to fix up the owner values with the
1821	 * inode number of the current inode.
1822	 */
1823	if (src_log_flags & XFS_ILOG_DOWNER) {
1824		error = xfs_swap_change_owner(&tp, ip, tip);
1825		if (error)
1826			goto out_trans_cancel;
1827	}
1828	if (target_log_flags & XFS_ILOG_DOWNER) {
1829		error = xfs_swap_change_owner(&tp, tip, ip);
1830		if (error)
1831			goto out_trans_cancel;
1832	}
1833
1834	/*
1835	 * If this is a synchronous mount, make sure that the
1836	 * transaction goes to disk before returning to the user.
1837	 */
1838	if (xfs_has_wsync(mp))
1839		xfs_trans_set_sync(tp);
1840
1841	error = xfs_trans_commit(tp);
1842
1843	trace_xfs_swap_extent_after(ip, 0);
1844	trace_xfs_swap_extent_after(tip, 1);
1845
1846out_unlock_ilock:
1847	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1848	xfs_iunlock(tip, XFS_ILOCK_EXCL);
1849out_unlock:
1850	filemap_invalidate_unlock_two(VFS_I(ip)->i_mapping,
1851				      VFS_I(tip)->i_mapping);
1852	unlock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1853	return error;
1854
1855out_trans_cancel:
1856	xfs_trans_cancel(tp);
1857	goto out_unlock_ilock;
1858}