1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
  12#include "xfs_bit.h"
  13#include "xfs_sb.h"
  14#include "xfs_mount.h"
  15#include "xfs_defer.h"
  16#include "xfs_dir2.h"
  17#include "xfs_inode.h"
  18#include "xfs_btree.h"
  19#include "xfs_trans.h"
  20#include "xfs_alloc.h"
  21#include "xfs_bmap.h"
  22#include "xfs_bmap_util.h"
  23#include "xfs_bmap_btree.h"
  24#include "xfs_rtbitmap.h"
  25#include "xfs_errortag.h"
  26#include "xfs_error.h"
  27#include "xfs_quota.h"
  28#include "xfs_trans_space.h"
  29#include "xfs_buf_item.h"
  30#include "xfs_trace.h"
  31#include "xfs_attr_leaf.h"
  32#include "xfs_filestream.h"
  33#include "xfs_rmap.h"
  34#include "xfs_ag.h"
  35#include "xfs_ag_resv.h"
  36#include "xfs_refcount.h"
  37#include "xfs_icache.h"
  38#include "xfs_iomap.h"
  39
  40struct kmem_cache		*xfs_bmap_intent_cache;
 
  41
  42/*
  43 * Miscellaneous helper functions
  44 */
  45
  46/*
  47 * Compute and fill in the value of the maximum depth of a bmap btree
  48 * in this filesystem.  Done once, during mount.
  49 */
  50void
  51xfs_bmap_compute_maxlevels(
  52	xfs_mount_t	*mp,		/* file system mount structure */
  53	int		whichfork)	/* data or attr fork */
  54{
  55	uint64_t	maxblocks;	/* max blocks at this level */
  56	xfs_extnum_t	maxleafents;	/* max leaf entries possible */
  57	int		level;		/* btree level */
 
 
  58	int		maxrootrecs;	/* max records in root block */
  59	int		minleafrecs;	/* min records in leaf block */
  60	int		minnoderecs;	/* min records in node block */
  61	int		sz;		/* root block size */
  62
  63	/*
  64	 * The maximum number of extents in a fork, hence the maximum number of
  65	 * leaf entries, is controlled by the size of the on-disk extent count.
 
 
  66	 *
  67	 * Note that we can no longer assume that if we are in ATTR1 that the
  68	 * fork offset of all the inodes will be
  69	 * (xfs_default_attroffset(ip) >> 3) because we could have mounted with
  70	 * ATTR2 and then mounted back with ATTR1, keeping the i_forkoff's fixed
  71	 * but probably at various positions. Therefore, for both ATTR1 and
  72	 * ATTR2 we have to assume the worst case scenario of a minimum size
  73	 * available.
  74	 */
  75	maxleafents = xfs_iext_max_nextents(xfs_has_large_extent_counts(mp),
  76				whichfork);
  77	if (whichfork == XFS_DATA_FORK)
  78		sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
  79	else
 
  80		sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
  81
  82	maxrootrecs = xfs_bmdr_maxrecs(sz, 0);
  83	minleafrecs = mp->m_bmap_dmnr[0];
  84	minnoderecs = mp->m_bmap_dmnr[1];
  85	maxblocks = howmany_64(maxleafents, minleafrecs);
  86	for (level = 1; maxblocks > 1; level++) {
  87		if (maxblocks <= maxrootrecs)
  88			maxblocks = 1;
  89		else
  90			maxblocks = howmany_64(maxblocks, minnoderecs);
  91	}
  92	mp->m_bm_maxlevels[whichfork] = level;
  93	ASSERT(mp->m_bm_maxlevels[whichfork] <= xfs_bmbt_maxlevels_ondisk());
  94}
  95
  96unsigned int
  97xfs_bmap_compute_attr_offset(
  98	struct xfs_mount	*mp)
  99{
 100	if (mp->m_sb.sb_inodesize == 256)
 101		return XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
 102	return XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
 103}
 104
 105STATIC int				/* error */
 106xfs_bmbt_lookup_eq(
 107	struct xfs_btree_cur	*cur,
 108	struct xfs_bmbt_irec	*irec,
 109	int			*stat)	/* success/failure */
 110{
 111	cur->bc_rec.b = *irec;
 112	return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
 113}
 114
 115STATIC int				/* error */
 116xfs_bmbt_lookup_first(
 117	struct xfs_btree_cur	*cur,
 118	int			*stat)	/* success/failure */
 119{
 120	cur->bc_rec.b.br_startoff = 0;
 121	cur->bc_rec.b.br_startblock = 0;
 122	cur->bc_rec.b.br_blockcount = 0;
 123	return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
 124}
 125
 126/*
 127 * Check if the inode needs to be converted to btree format.
 128 */
 129static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
 130{
 131	struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
 132
 133	return whichfork != XFS_COW_FORK &&
 134		ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
 135		ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork);
 136}
 137
 138/*
 139 * Check if the inode should be converted to extent format.
 140 */
 141static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
 142{
 143	struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
 144
 145	return whichfork != XFS_COW_FORK &&
 146		ifp->if_format == XFS_DINODE_FMT_BTREE &&
 147		ifp->if_nextents <= XFS_IFORK_MAXEXT(ip, whichfork);
 148}
 149
 150/*
 151 * Update the record referred to by cur to the value given by irec
 152 * This either works (return 0) or gets an EFSCORRUPTED error.
 153 */
 154STATIC int
 155xfs_bmbt_update(
 156	struct xfs_btree_cur	*cur,
 157	struct xfs_bmbt_irec	*irec)
 158{
 159	union xfs_btree_rec	rec;
 160
 161	xfs_bmbt_disk_set_all(&rec.bmbt, irec);
 162	return xfs_btree_update(cur, &rec);
 163}
 164
 165/*
 166 * Compute the worst-case number of indirect blocks that will be used
 167 * for ip's delayed extent of length "len".
 168 */
 169STATIC xfs_filblks_t
 170xfs_bmap_worst_indlen(
 171	xfs_inode_t	*ip,		/* incore inode pointer */
 172	xfs_filblks_t	len)		/* delayed extent length */
 173{
 174	int		level;		/* btree level number */
 175	int		maxrecs;	/* maximum record count at this level */
 176	xfs_mount_t	*mp;		/* mount structure */
 177	xfs_filblks_t	rval;		/* return value */
 178
 179	mp = ip->i_mount;
 180	maxrecs = mp->m_bmap_dmxr[0];
 181	for (level = 0, rval = 0;
 182	     level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK);
 183	     level++) {
 184		len += maxrecs - 1;
 185		do_div(len, maxrecs);
 186		rval += len;
 187		if (len == 1)
 188			return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) -
 189				level - 1;
 190		if (level == 0)
 191			maxrecs = mp->m_bmap_dmxr[1];
 192	}
 193	return rval;
 194}
 195
 196/*
 197 * Calculate the default attribute fork offset for newly created inodes.
 198 */
 199uint
 200xfs_default_attroffset(
 201	struct xfs_inode	*ip)
 202{
 203	if (ip->i_df.if_format == XFS_DINODE_FMT_DEV)
 204		return roundup(sizeof(xfs_dev_t), 8);
 205	return M_IGEO(ip->i_mount)->attr_fork_offset;
 
 
 
 
 
 
 
 206}
 207
 208/*
 209 * Helper routine to reset inode i_forkoff field when switching attribute fork
 210 * from local to extent format - we reset it where possible to make space
 211 * available for inline data fork extents.
 212 */
 213STATIC void
 214xfs_bmap_forkoff_reset(
 215	xfs_inode_t	*ip,
 216	int		whichfork)
 217{
 218	if (whichfork == XFS_ATTR_FORK &&
 219	    ip->i_df.if_format != XFS_DINODE_FMT_DEV &&
 220	    ip->i_df.if_format != XFS_DINODE_FMT_BTREE) {
 221		uint	dfl_forkoff = xfs_default_attroffset(ip) >> 3;
 222
 223		if (dfl_forkoff > ip->i_forkoff)
 224			ip->i_forkoff = dfl_forkoff;
 225	}
 226}
 227
 228#ifdef DEBUG
 229STATIC struct xfs_buf *
 230xfs_bmap_get_bp(
 231	struct xfs_btree_cur	*cur,
 232	xfs_fsblock_t		bno)
 233{
 234	struct xfs_log_item	*lip;
 235	int			i;
 236
 237	if (!cur)
 238		return NULL;
 239
 240	for (i = 0; i < cur->bc_maxlevels; i++) {
 241		if (!cur->bc_levels[i].bp)
 242			break;
 243		if (xfs_buf_daddr(cur->bc_levels[i].bp) == bno)
 244			return cur->bc_levels[i].bp;
 245	}
 246
 247	/* Chase down all the log items to see if the bp is there */
 248	list_for_each_entry(lip, &cur->bc_tp->t_items, li_trans) {
 249		struct xfs_buf_log_item	*bip = (struct xfs_buf_log_item *)lip;
 250
 251		if (bip->bli_item.li_type == XFS_LI_BUF &&
 252		    xfs_buf_daddr(bip->bli_buf) == bno)
 253			return bip->bli_buf;
 254	}
 255
 256	return NULL;
 257}
 258
 259STATIC void
 260xfs_check_block(
 261	struct xfs_btree_block	*block,
 262	xfs_mount_t		*mp,
 263	int			root,
 264	short			sz)
 265{
 266	int			i, j, dmxr;
 267	__be64			*pp, *thispa;	/* pointer to block address */
 268	xfs_bmbt_key_t		*prevp, *keyp;
 269
 270	ASSERT(be16_to_cpu(block->bb_level) > 0);
 271
 272	prevp = NULL;
 273	for( i = 1; i <= xfs_btree_get_numrecs(block); i++) {
 274		dmxr = mp->m_bmap_dmxr[0];
 275		keyp = XFS_BMBT_KEY_ADDR(mp, block, i);
 276
 277		if (prevp) {
 278			ASSERT(be64_to_cpu(prevp->br_startoff) <
 279			       be64_to_cpu(keyp->br_startoff));
 280		}
 281		prevp = keyp;
 282
 283		/*
 284		 * Compare the block numbers to see if there are dups.
 285		 */
 286		if (root)
 287			pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);
 288		else
 289			pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr);
 290
 291		for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {
 292			if (root)
 293				thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);
 294			else
 295				thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr);
 296			if (*thispa == *pp) {
 297				xfs_warn(mp, "%s: thispa(%d) == pp(%d) %lld",
 298					__func__, j, i,
 299					(unsigned long long)be64_to_cpu(*thispa));
 300				xfs_err(mp, "%s: ptrs are equal in node\n",
 301					__func__);
 302				xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 303			}
 304		}
 305	}
 306}
 307
 308/*
 309 * Check that the extents for the inode ip are in the right order in all
 310 * btree leaves. THis becomes prohibitively expensive for large extent count
 311 * files, so don't bother with inodes that have more than 10,000 extents in
 312 * them. The btree record ordering checks will still be done, so for such large
 313 * bmapbt constructs that is going to catch most corruptions.
 314 */
 315STATIC void
 316xfs_bmap_check_leaf_extents(
 317	struct xfs_btree_cur	*cur,	/* btree cursor or null */
 318	xfs_inode_t		*ip,		/* incore inode pointer */
 319	int			whichfork)	/* data or attr fork */
 320{
 321	struct xfs_mount	*mp = ip->i_mount;
 322	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
 323	struct xfs_btree_block	*block;	/* current btree block */
 324	xfs_fsblock_t		bno;	/* block # of "block" */
 325	struct xfs_buf		*bp;	/* buffer for "block" */
 326	int			error;	/* error return value */
 327	xfs_extnum_t		i=0, j;	/* index into the extents list */
 328	int			level;	/* btree level, for checking */
 329	__be64			*pp;	/* pointer to block address */
 330	xfs_bmbt_rec_t		*ep;	/* pointer to current extent */
 331	xfs_bmbt_rec_t		last = {0, 0}; /* last extent in prev block */
 332	xfs_bmbt_rec_t		*nextp;	/* pointer to next extent */
 333	int			bp_release = 0;
 334
 335	if (ifp->if_format != XFS_DINODE_FMT_BTREE)
 336		return;
 337
 338	/* skip large extent count inodes */
 339	if (ip->i_df.if_nextents > 10000)
 340		return;
 341
 342	bno = NULLFSBLOCK;
 343	block = ifp->if_broot;
 344	/*
 345	 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
 346	 */
 347	level = be16_to_cpu(block->bb_level);
 348	ASSERT(level > 0);
 349	xfs_check_block(block, mp, 1, ifp->if_broot_bytes);
 350	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
 351	bno = be64_to_cpu(*pp);
 352
 353	ASSERT(bno != NULLFSBLOCK);
 354	ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
 355	ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
 356
 357	/*
 358	 * Go down the tree until leaf level is reached, following the first
 359	 * pointer (leftmost) at each level.
 360	 */
 361	while (level-- > 0) {
 362		/* See if buf is in cur first */
 363		bp_release = 0;
 364		bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
 365		if (!bp) {
 366			bp_release = 1;
 367			error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
 368						XFS_BMAP_BTREE_REF,
 369						&xfs_bmbt_buf_ops);
 370			if (error)
 371				goto error_norelse;
 372		}
 373		block = XFS_BUF_TO_BLOCK(bp);
 374		if (level == 0)
 375			break;
 376
 377		/*
 378		 * Check this block for basic sanity (increasing keys and
 379		 * no duplicate blocks).
 380		 */
 381
 382		xfs_check_block(block, mp, 0, 0);
 383		pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
 384		bno = be64_to_cpu(*pp);
 385		if (XFS_IS_CORRUPT(mp, !xfs_verify_fsbno(mp, bno))) {
 386			error = -EFSCORRUPTED;
 387			goto error0;
 388		}
 389		if (bp_release) {
 390			bp_release = 0;
 391			xfs_trans_brelse(NULL, bp);
 392		}
 393	}
 394
 395	/*
 396	 * Here with bp and block set to the leftmost leaf node in the tree.
 397	 */
 398	i = 0;
 399
 400	/*
 401	 * Loop over all leaf nodes checking that all extents are in the right order.
 402	 */
 403	for (;;) {
 404		xfs_fsblock_t	nextbno;
 405		xfs_extnum_t	num_recs;
 406
 407
 408		num_recs = xfs_btree_get_numrecs(block);
 409
 410		/*
 411		 * Read-ahead the next leaf block, if any.
 412		 */
 413
 414		nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
 415
 416		/*
 417		 * Check all the extents to make sure they are OK.
 418		 * If we had a previous block, the last entry should
 419		 * conform with the first entry in this one.
 420		 */
 421
 422		ep = XFS_BMBT_REC_ADDR(mp, block, 1);
 423		if (i) {
 424			ASSERT(xfs_bmbt_disk_get_startoff(&last) +
 425			       xfs_bmbt_disk_get_blockcount(&last) <=
 426			       xfs_bmbt_disk_get_startoff(ep));
 427		}
 428		for (j = 1; j < num_recs; j++) {
 429			nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1);
 430			ASSERT(xfs_bmbt_disk_get_startoff(ep) +
 431			       xfs_bmbt_disk_get_blockcount(ep) <=
 432			       xfs_bmbt_disk_get_startoff(nextp));
 433			ep = nextp;
 434		}
 435
 436		last = *ep;
 437		i += num_recs;
 438		if (bp_release) {
 439			bp_release = 0;
 440			xfs_trans_brelse(NULL, bp);
 441		}
 442		bno = nextbno;
 443		/*
 444		 * If we've reached the end, stop.
 445		 */
 446		if (bno == NULLFSBLOCK)
 447			break;
 448
 449		bp_release = 0;
 450		bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
 451		if (!bp) {
 452			bp_release = 1;
 453			error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
 454						XFS_BMAP_BTREE_REF,
 455						&xfs_bmbt_buf_ops);
 456			if (error)
 457				goto error_norelse;
 458		}
 459		block = XFS_BUF_TO_BLOCK(bp);
 460	}
 461
 462	return;
 463
 464error0:
 465	xfs_warn(mp, "%s: at error0", __func__);
 466	if (bp_release)
 467		xfs_trans_brelse(NULL, bp);
 468error_norelse:
 469	xfs_warn(mp, "%s: BAD after btree leaves for %llu extents",
 470		__func__, i);
 471	xfs_err(mp, "%s: CORRUPTED BTREE OR SOMETHING", __func__);
 472	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 473	return;
 474}
 475
 476/*
 477 * Validate that the bmbt_irecs being returned from bmapi are valid
 478 * given the caller's original parameters.  Specifically check the
 479 * ranges of the returned irecs to ensure that they only extend beyond
 480 * the given parameters if the XFS_BMAPI_ENTIRE flag was set.
 481 */
 482STATIC void
 483xfs_bmap_validate_ret(
 484	xfs_fileoff_t		bno,
 485	xfs_filblks_t		len,
 486	uint32_t		flags,
 487	xfs_bmbt_irec_t		*mval,
 488	int			nmap,
 489	int			ret_nmap)
 490{
 491	int			i;		/* index to map values */
 492
 493	ASSERT(ret_nmap <= nmap);
 494
 495	for (i = 0; i < ret_nmap; i++) {
 496		ASSERT(mval[i].br_blockcount > 0);
 497		if (!(flags & XFS_BMAPI_ENTIRE)) {
 498			ASSERT(mval[i].br_startoff >= bno);
 499			ASSERT(mval[i].br_blockcount <= len);
 500			ASSERT(mval[i].br_startoff + mval[i].br_blockcount <=
 501			       bno + len);
 502		} else {
 503			ASSERT(mval[i].br_startoff < bno + len);
 504			ASSERT(mval[i].br_startoff + mval[i].br_blockcount >
 505			       bno);
 506		}
 507		ASSERT(i == 0 ||
 508		       mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
 509		       mval[i].br_startoff);
 510		ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
 511		       mval[i].br_startblock != HOLESTARTBLOCK);
 512		ASSERT(mval[i].br_state == XFS_EXT_NORM ||
 513		       mval[i].br_state == XFS_EXT_UNWRITTEN);
 514	}
 515}
 516
 517#else
 518#define xfs_bmap_check_leaf_extents(cur, ip, whichfork)		do { } while (0)
 519#define	xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap)	do { } while (0)
 520#endif /* DEBUG */
 521
 522/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 523 * Inode fork format manipulation functions
 524 */
 525
 526/*
 527 * Convert the inode format to extent format if it currently is in btree format,
 528 * but the extent list is small enough that it fits into the extent format.
 529 *
 530 * Since the extents are already in-core, all we have to do is give up the space
 531 * for the btree root and pitch the leaf block.
 532 */
 533STATIC int				/* error */
 534xfs_bmap_btree_to_extents(
 535	struct xfs_trans	*tp,	/* transaction pointer */
 536	struct xfs_inode	*ip,	/* incore inode pointer */
 537	struct xfs_btree_cur	*cur,	/* btree cursor */
 538	int			*logflagsp, /* inode logging flags */
 539	int			whichfork)  /* data or attr fork */
 540{
 541	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
 542	struct xfs_mount	*mp = ip->i_mount;
 543	struct xfs_btree_block	*rblock = ifp->if_broot;
 544	struct xfs_btree_block	*cblock;/* child btree block */
 545	xfs_fsblock_t		cbno;	/* child block number */
 546	struct xfs_buf		*cbp;	/* child block's buffer */
 547	int			error;	/* error return value */
 548	__be64			*pp;	/* ptr to block address */
 549	struct xfs_owner_info	oinfo;
 550
 551	/* check if we actually need the extent format first: */
 552	if (!xfs_bmap_wants_extents(ip, whichfork))
 553		return 0;
 554
 555	ASSERT(cur);
 556	ASSERT(whichfork != XFS_COW_FORK);
 
 557	ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
 558	ASSERT(be16_to_cpu(rblock->bb_level) == 1);
 559	ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
 560	ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
 561
 562	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
 563	cbno = be64_to_cpu(*pp);
 564#ifdef DEBUG
 565	if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_btree_check_lptr(cur, cbno, 1)))
 566		return -EFSCORRUPTED;
 567#endif
 568	error = xfs_btree_read_bufl(mp, tp, cbno, &cbp, XFS_BMAP_BTREE_REF,
 569				&xfs_bmbt_buf_ops);
 570	if (error)
 571		return error;
 572	cblock = XFS_BUF_TO_BLOCK(cbp);
 573	if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
 574		return error;
 575
 576	xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
 577	error = xfs_free_extent_later(cur->bc_tp, cbno, 1, &oinfo,
 578			XFS_AG_RESV_NONE, false);
 579	if (error)
 580		return error;
 581
 582	ip->i_nblocks--;
 583	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
 584	xfs_trans_binval(tp, cbp);
 585	if (cur->bc_levels[0].bp == cbp)
 586		cur->bc_levels[0].bp = NULL;
 587	xfs_iroot_realloc(ip, -1, whichfork);
 588	ASSERT(ifp->if_broot == NULL);
 
 589	ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 590	*logflagsp |= XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
 591	return 0;
 592}
 593
 594/*
 595 * Convert an extents-format file into a btree-format file.
 596 * The new file will have a root block (in the inode) and a single child block.
 597 */
 598STATIC int					/* error */
 599xfs_bmap_extents_to_btree(
 600	struct xfs_trans	*tp,		/* transaction pointer */
 601	struct xfs_inode	*ip,		/* incore inode pointer */
 602	struct xfs_btree_cur	**curp,		/* cursor returned to caller */
 603	int			wasdel,		/* converting a delayed alloc */
 604	int			*logflagsp,	/* inode logging flags */
 605	int			whichfork)	/* data or attr fork */
 606{
 607	struct xfs_btree_block	*ablock;	/* allocated (child) bt block */
 608	struct xfs_buf		*abp;		/* buffer for ablock */
 609	struct xfs_alloc_arg	args;		/* allocation arguments */
 610	struct xfs_bmbt_rec	*arp;		/* child record pointer */
 611	struct xfs_btree_block	*block;		/* btree root block */
 612	struct xfs_btree_cur	*cur;		/* bmap btree cursor */
 613	int			error;		/* error return value */
 614	struct xfs_ifork	*ifp;		/* inode fork pointer */
 615	struct xfs_bmbt_key	*kp;		/* root block key pointer */
 616	struct xfs_mount	*mp;		/* mount structure */
 617	xfs_bmbt_ptr_t		*pp;		/* root block address pointer */
 618	struct xfs_iext_cursor	icur;
 619	struct xfs_bmbt_irec	rec;
 620	xfs_extnum_t		cnt = 0;
 621
 622	mp = ip->i_mount;
 623	ASSERT(whichfork != XFS_COW_FORK);
 624	ifp = xfs_ifork_ptr(ip, whichfork);
 625	ASSERT(ifp->if_format == XFS_DINODE_FMT_EXTENTS);
 626
 627	/*
 628	 * Make space in the inode incore. This needs to be undone if we fail
 629	 * to expand the root.
 630	 */
 631	xfs_iroot_realloc(ip, 1, whichfork);
 
 632
 633	/*
 634	 * Fill in the root.
 635	 */
 636	block = ifp->if_broot;
 637	xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL,
 638				 XFS_BTNUM_BMAP, 1, 1, ip->i_ino,
 639				 XFS_BTREE_LONG_PTRS);
 640	/*
 641	 * Need a cursor.  Can't allocate until bb_level is filled in.
 642	 */
 643	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
 644	cur->bc_ino.flags = wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
 645	/*
 646	 * Convert to a btree with two levels, one record in root.
 647	 */
 648	ifp->if_format = XFS_DINODE_FMT_BTREE;
 649	memset(&args, 0, sizeof(args));
 650	args.tp = tp;
 651	args.mp = mp;
 652	xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
 653
 
 
 
 
 
 
 
 
 
 654	args.minlen = args.maxlen = args.prod = 1;
 655	args.wasdel = wasdel;
 656	*logflagsp = 0;
 657	error = xfs_alloc_vextent_start_ag(&args,
 658				XFS_INO_TO_FSB(mp, ip->i_ino));
 659	if (error)
 660		goto out_root_realloc;
 661
 662	/*
 663	 * Allocation can't fail, the space was reserved.
 664	 */
 665	if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
 666		error = -ENOSPC;
 667		goto out_root_realloc;
 668	}
 669
 
 
 
 
 
 
 670	cur->bc_ino.allocated++;
 671	ip->i_nblocks++;
 672	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
 673	error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 674			XFS_FSB_TO_DADDR(mp, args.fsbno),
 675			mp->m_bsize, 0, &abp);
 676	if (error)
 677		goto out_unreserve_dquot;
 678
 679	/*
 680	 * Fill in the child block.
 681	 */
 682	abp->b_ops = &xfs_bmbt_buf_ops;
 683	ablock = XFS_BUF_TO_BLOCK(abp);
 684	xfs_btree_init_block_int(mp, ablock, xfs_buf_daddr(abp),
 685				XFS_BTNUM_BMAP, 0, 0, ip->i_ino,
 686				XFS_BTREE_LONG_PTRS);
 687
 688	for_each_xfs_iext(ifp, &icur, &rec) {
 689		if (isnullstartblock(rec.br_startblock))
 690			continue;
 691		arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt);
 692		xfs_bmbt_disk_set_all(arp, &rec);
 693		cnt++;
 694	}
 695	ASSERT(cnt == ifp->if_nextents);
 696	xfs_btree_set_numrecs(ablock, cnt);
 697
 698	/*
 699	 * Fill in the root key and pointer.
 700	 */
 701	kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
 702	arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
 703	kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp));
 704	pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur,
 705						be16_to_cpu(block->bb_level)));
 706	*pp = cpu_to_be64(args.fsbno);
 707
 708	/*
 709	 * Do all this logging at the end so that
 710	 * the root is at the right level.
 711	 */
 712	xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
 713	xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
 714	ASSERT(*curp == NULL);
 715	*curp = cur;
 716	*logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork);
 717	return 0;
 718
 719out_unreserve_dquot:
 720	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
 721out_root_realloc:
 722	xfs_iroot_realloc(ip, -1, whichfork);
 723	ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 724	ASSERT(ifp->if_broot == NULL);
 725	xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
 726
 727	return error;
 728}
 729
 730/*
 731 * Convert a local file to an extents file.
 732 * This code is out of bounds for data forks of regular files,
 733 * since the file data needs to get logged so things will stay consistent.
 734 * (The bmap-level manipulations are ok, though).
 735 */
 736void
 737xfs_bmap_local_to_extents_empty(
 738	struct xfs_trans	*tp,
 739	struct xfs_inode	*ip,
 740	int			whichfork)
 741{
 742	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
 743
 744	ASSERT(whichfork != XFS_COW_FORK);
 745	ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 746	ASSERT(ifp->if_bytes == 0);
 747	ASSERT(ifp->if_nextents == 0);
 748
 749	xfs_bmap_forkoff_reset(ip, whichfork);
 750	ifp->if_data = NULL;
 
 
 751	ifp->if_height = 0;
 752	ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 753	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 754}
 755
 756
 757STATIC int				/* error */
 758xfs_bmap_local_to_extents(
 759	xfs_trans_t	*tp,		/* transaction pointer */
 760	xfs_inode_t	*ip,		/* incore inode pointer */
 761	xfs_extlen_t	total,		/* total blocks needed by transaction */
 762	int		*logflagsp,	/* inode logging flags */
 763	int		whichfork,
 764	void		(*init_fn)(struct xfs_trans *tp,
 765				   struct xfs_buf *bp,
 766				   struct xfs_inode *ip,
 767				   struct xfs_ifork *ifp))
 768{
 769	int		error = 0;
 770	int		flags;		/* logging flags returned */
 771	struct xfs_ifork *ifp;		/* inode fork pointer */
 772	xfs_alloc_arg_t	args;		/* allocation arguments */
 773	struct xfs_buf	*bp;		/* buffer for extent block */
 774	struct xfs_bmbt_irec rec;
 775	struct xfs_iext_cursor icur;
 776
 777	/*
 778	 * We don't want to deal with the case of keeping inode data inline yet.
 779	 * So sending the data fork of a regular inode is invalid.
 780	 */
 781	ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
 782	ifp = xfs_ifork_ptr(ip, whichfork);
 783	ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 784
 785	if (!ifp->if_bytes) {
 786		xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 787		flags = XFS_ILOG_CORE;
 788		goto done;
 789	}
 790
 791	flags = 0;
 792	error = 0;
 
 793	memset(&args, 0, sizeof(args));
 794	args.tp = tp;
 795	args.mp = ip->i_mount;
 796	args.total = total;
 797	args.minlen = args.maxlen = args.prod = 1;
 798	xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
 799
 800	/*
 801	 * Allocate a block.  We know we need only one, since the
 802	 * file currently fits in an inode.
 803	 */
 
 
 
 
 
 
 
 804	args.total = total;
 805	args.minlen = args.maxlen = args.prod = 1;
 806	error = xfs_alloc_vextent_start_ag(&args,
 807			XFS_INO_TO_FSB(args.mp, ip->i_ino));
 808	if (error)
 809		goto done;
 810
 811	/* Can't fail, the space was reserved. */
 812	ASSERT(args.fsbno != NULLFSBLOCK);
 813	ASSERT(args.len == 1);
 
 814	error = xfs_trans_get_buf(tp, args.mp->m_ddev_targp,
 815			XFS_FSB_TO_DADDR(args.mp, args.fsbno),
 816			args.mp->m_bsize, 0, &bp);
 817	if (error)
 818		goto done;
 819
 820	/*
 821	 * Initialize the block, copy the data and log the remote buffer.
 822	 *
 823	 * The callout is responsible for logging because the remote format
 824	 * might differ from the local format and thus we don't know how much to
 825	 * log here. Note that init_fn must also set the buffer log item type
 826	 * correctly.
 827	 */
 828	init_fn(tp, bp, ip, ifp);
 829
 830	/* account for the change in fork size */
 831	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
 832	xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 833	flags |= XFS_ILOG_CORE;
 834
 835	ifp->if_data = NULL;
 836	ifp->if_height = 0;
 837
 838	rec.br_startoff = 0;
 839	rec.br_startblock = args.fsbno;
 840	rec.br_blockcount = 1;
 841	rec.br_state = XFS_EXT_NORM;
 842	xfs_iext_first(ifp, &icur);
 843	xfs_iext_insert(ip, &icur, &rec, 0);
 844
 845	ifp->if_nextents = 1;
 846	ip->i_nblocks = 1;
 847	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
 
 848	flags |= xfs_ilog_fext(whichfork);
 849
 850done:
 851	*logflagsp = flags;
 852	return error;
 853}
 854
 855/*
 856 * Called from xfs_bmap_add_attrfork to handle btree format files.
 857 */
 858STATIC int					/* error */
 859xfs_bmap_add_attrfork_btree(
 860	xfs_trans_t		*tp,		/* transaction pointer */
 861	xfs_inode_t		*ip,		/* incore inode pointer */
 862	int			*flags)		/* inode logging flags */
 863{
 864	struct xfs_btree_block	*block = ip->i_df.if_broot;
 865	struct xfs_btree_cur	*cur;		/* btree cursor */
 866	int			error;		/* error return value */
 867	xfs_mount_t		*mp;		/* file system mount struct */
 868	int			stat;		/* newroot status */
 869
 870	mp = ip->i_mount;
 871
 872	if (XFS_BMAP_BMDR_SPACE(block) <= xfs_inode_data_fork_size(ip))
 873		*flags |= XFS_ILOG_DBROOT;
 874	else {
 875		cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
 876		error = xfs_bmbt_lookup_first(cur, &stat);
 877		if (error)
 878			goto error0;
 879		/* must be at least one entry */
 880		if (XFS_IS_CORRUPT(mp, stat != 1)) {
 881			error = -EFSCORRUPTED;
 882			goto error0;
 883		}
 884		if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
 885			goto error0;
 886		if (stat == 0) {
 887			xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
 888			return -ENOSPC;
 889		}
 890		cur->bc_ino.allocated = 0;
 891		xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
 892	}
 893	return 0;
 894error0:
 895	xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
 896	return error;
 897}
 898
 899/*
 900 * Called from xfs_bmap_add_attrfork to handle extents format files.
 901 */
 902STATIC int					/* error */
 903xfs_bmap_add_attrfork_extents(
 904	struct xfs_trans	*tp,		/* transaction pointer */
 905	struct xfs_inode	*ip,		/* incore inode pointer */
 906	int			*flags)		/* inode logging flags */
 907{
 908	struct xfs_btree_cur	*cur;		/* bmap btree cursor */
 909	int			error;		/* error return value */
 910
 911	if (ip->i_df.if_nextents * sizeof(struct xfs_bmbt_rec) <=
 912	    xfs_inode_data_fork_size(ip))
 913		return 0;
 914	cur = NULL;
 915	error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags,
 916					  XFS_DATA_FORK);
 917	if (cur) {
 918		cur->bc_ino.allocated = 0;
 919		xfs_btree_del_cursor(cur, error);
 920	}
 921	return error;
 922}
 923
 924/*
 925 * Called from xfs_bmap_add_attrfork to handle local format files. Each
 926 * different data fork content type needs a different callout to do the
 927 * conversion. Some are basic and only require special block initialisation
 928 * callouts for the data formating, others (directories) are so specialised they
 929 * handle everything themselves.
 930 *
 931 * XXX (dgc): investigate whether directory conversion can use the generic
 932 * formatting callout. It should be possible - it's just a very complex
 933 * formatter.
 934 */
 935STATIC int					/* error */
 936xfs_bmap_add_attrfork_local(
 937	struct xfs_trans	*tp,		/* transaction pointer */
 938	struct xfs_inode	*ip,		/* incore inode pointer */
 939	int			*flags)		/* inode logging flags */
 940{
 941	struct xfs_da_args	dargs;		/* args for dir/attr code */
 942
 943	if (ip->i_df.if_bytes <= xfs_inode_data_fork_size(ip))
 944		return 0;
 945
 946	if (S_ISDIR(VFS_I(ip)->i_mode)) {
 947		memset(&dargs, 0, sizeof(dargs));
 948		dargs.geo = ip->i_mount->m_dir_geo;
 949		dargs.dp = ip;
 950		dargs.total = dargs.geo->fsbcount;
 951		dargs.whichfork = XFS_DATA_FORK;
 952		dargs.trans = tp;
 953		return xfs_dir2_sf_to_block(&dargs);
 954	}
 955
 956	if (S_ISLNK(VFS_I(ip)->i_mode))
 957		return xfs_bmap_local_to_extents(tp, ip, 1, flags,
 958						 XFS_DATA_FORK,
 959						 xfs_symlink_local_to_remote);
 960
 961	/* should only be called for types that support local format data */
 962	ASSERT(0);
 963	return -EFSCORRUPTED;
 964}
 965
 966/*
 967 * Set an inode attr fork offset based on the format of the data fork.
 968 */
 969static int
 970xfs_bmap_set_attrforkoff(
 971	struct xfs_inode	*ip,
 972	int			size,
 973	int			*version)
 974{
 975	int			default_size = xfs_default_attroffset(ip) >> 3;
 976
 977	switch (ip->i_df.if_format) {
 978	case XFS_DINODE_FMT_DEV:
 979		ip->i_forkoff = default_size;
 980		break;
 981	case XFS_DINODE_FMT_LOCAL:
 982	case XFS_DINODE_FMT_EXTENTS:
 983	case XFS_DINODE_FMT_BTREE:
 984		ip->i_forkoff = xfs_attr_shortform_bytesfit(ip, size);
 985		if (!ip->i_forkoff)
 986			ip->i_forkoff = default_size;
 987		else if (xfs_has_attr2(ip->i_mount) && version)
 988			*version = 2;
 989		break;
 990	default:
 991		ASSERT(0);
 992		return -EINVAL;
 993	}
 994
 995	return 0;
 996}
 997
 998/*
 999 * Convert inode from non-attributed to attributed.
1000 * Must not be in a transaction, ip must not be locked.
1001 */
1002int						/* error code */
1003xfs_bmap_add_attrfork(
1004	xfs_inode_t		*ip,		/* incore inode pointer */
1005	int			size,		/* space new attribute needs */
1006	int			rsvd)		/* xact may use reserved blks */
1007{
1008	xfs_mount_t		*mp;		/* mount structure */
1009	xfs_trans_t		*tp;		/* transaction pointer */
1010	int			blks;		/* space reservation */
1011	int			version = 1;	/* superblock attr version */
1012	int			logflags;	/* logging flags */
1013	int			error;		/* error return value */
1014
1015	ASSERT(xfs_inode_has_attr_fork(ip) == 0);
1016
1017	mp = ip->i_mount;
1018	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1019
1020	blks = XFS_ADDAFORK_SPACE_RES(mp);
1021
1022	error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_addafork, blks, 0,
1023			rsvd, &tp);
1024	if (error)
1025		return error;
1026	if (xfs_inode_has_attr_fork(ip))
 
 
 
 
 
 
 
1027		goto trans_cancel;
1028
 
1029	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1030	error = xfs_bmap_set_attrforkoff(ip, size, &version);
1031	if (error)
1032		goto trans_cancel;
 
 
 
 
1033
1034	xfs_ifork_init_attr(ip, XFS_DINODE_FMT_EXTENTS, 0);
 
1035	logflags = 0;
1036	switch (ip->i_df.if_format) {
1037	case XFS_DINODE_FMT_LOCAL:
1038		error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
1039		break;
1040	case XFS_DINODE_FMT_EXTENTS:
1041		error = xfs_bmap_add_attrfork_extents(tp, ip, &logflags);
1042		break;
1043	case XFS_DINODE_FMT_BTREE:
1044		error = xfs_bmap_add_attrfork_btree(tp, ip, &logflags);
1045		break;
1046	default:
1047		error = 0;
1048		break;
1049	}
1050	if (logflags)
1051		xfs_trans_log_inode(tp, ip, logflags);
1052	if (error)
1053		goto trans_cancel;
1054	if (!xfs_has_attr(mp) ||
1055	   (!xfs_has_attr2(mp) && version == 2)) {
1056		bool log_sb = false;
1057
1058		spin_lock(&mp->m_sb_lock);
1059		if (!xfs_has_attr(mp)) {
1060			xfs_add_attr(mp);
1061			log_sb = true;
1062		}
1063		if (!xfs_has_attr2(mp) && version == 2) {
1064			xfs_add_attr2(mp);
1065			log_sb = true;
1066		}
1067		spin_unlock(&mp->m_sb_lock);
1068		if (log_sb)
1069			xfs_log_sb(tp);
1070	}
1071
1072	error = xfs_trans_commit(tp);
1073	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1074	return error;
1075
1076trans_cancel:
1077	xfs_trans_cancel(tp);
1078	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1079	return error;
1080}
1081
1082/*
1083 * Internal and external extent tree search functions.
1084 */
1085
1086struct xfs_iread_state {
1087	struct xfs_iext_cursor	icur;
1088	xfs_extnum_t		loaded;
1089};
1090
1091int
1092xfs_bmap_complain_bad_rec(
1093	struct xfs_inode		*ip,
1094	int				whichfork,
1095	xfs_failaddr_t			fa,
1096	const struct xfs_bmbt_irec	*irec)
1097{
1098	struct xfs_mount		*mp = ip->i_mount;
1099	const char			*forkname;
1100
1101	switch (whichfork) {
1102	case XFS_DATA_FORK:	forkname = "data"; break;
1103	case XFS_ATTR_FORK:	forkname = "attr"; break;
1104	case XFS_COW_FORK:	forkname = "CoW"; break;
1105	default:		forkname = "???"; break;
1106	}
1107
1108	xfs_warn(mp,
1109 "Bmap BTree record corruption in inode 0x%llx %s fork detected at %pS!",
1110				ip->i_ino, forkname, fa);
1111	xfs_warn(mp,
1112		"Offset 0x%llx, start block 0x%llx, block count 0x%llx state 0x%x",
1113		irec->br_startoff, irec->br_startblock, irec->br_blockcount,
1114		irec->br_state);
1115
1116	return -EFSCORRUPTED;
1117}
1118
1119/* Stuff every bmbt record from this block into the incore extent map. */
1120static int
1121xfs_iread_bmbt_block(
1122	struct xfs_btree_cur	*cur,
1123	int			level,
1124	void			*priv)
1125{
1126	struct xfs_iread_state	*ir = priv;
1127	struct xfs_mount	*mp = cur->bc_mp;
1128	struct xfs_inode	*ip = cur->bc_ino.ip;
1129	struct xfs_btree_block	*block;
1130	struct xfs_buf		*bp;
1131	struct xfs_bmbt_rec	*frp;
1132	xfs_extnum_t		num_recs;
1133	xfs_extnum_t		j;
1134	int			whichfork = cur->bc_ino.whichfork;
1135	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1136
1137	block = xfs_btree_get_block(cur, level, &bp);
1138
1139	/* Abort if we find more records than nextents. */
1140	num_recs = xfs_btree_get_numrecs(block);
1141	if (unlikely(ir->loaded + num_recs > ifp->if_nextents)) {
1142		xfs_warn(ip->i_mount, "corrupt dinode %llu, (btree extents).",
1143				(unsigned long long)ip->i_ino);
1144		xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, block,
1145				sizeof(*block), __this_address);
1146		return -EFSCORRUPTED;
1147	}
1148
1149	/* Copy records into the incore cache. */
1150	frp = XFS_BMBT_REC_ADDR(mp, block, 1);
1151	for (j = 0; j < num_recs; j++, frp++, ir->loaded++) {
1152		struct xfs_bmbt_irec	new;
1153		xfs_failaddr_t		fa;
1154
1155		xfs_bmbt_disk_get_all(frp, &new);
1156		fa = xfs_bmap_validate_extent(ip, whichfork, &new);
1157		if (fa) {
1158			xfs_inode_verifier_error(ip, -EFSCORRUPTED,
1159					"xfs_iread_extents(2)", frp,
1160					sizeof(*frp), fa);
1161			return xfs_bmap_complain_bad_rec(ip, whichfork, fa,
1162					&new);
1163		}
1164		xfs_iext_insert(ip, &ir->icur, &new,
1165				xfs_bmap_fork_to_state(whichfork));
1166		trace_xfs_read_extent(ip, &ir->icur,
1167				xfs_bmap_fork_to_state(whichfork), _THIS_IP_);
1168		xfs_iext_next(ifp, &ir->icur);
1169	}
1170
1171	return 0;
1172}
1173
1174/*
1175 * Read in extents from a btree-format inode.
1176 */
1177int
1178xfs_iread_extents(
1179	struct xfs_trans	*tp,
1180	struct xfs_inode	*ip,
1181	int			whichfork)
1182{
1183	struct xfs_iread_state	ir;
1184	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1185	struct xfs_mount	*mp = ip->i_mount;
1186	struct xfs_btree_cur	*cur;
1187	int			error;
1188
1189	if (!xfs_need_iread_extents(ifp))
1190		return 0;
1191
1192	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1193
 
 
 
 
 
1194	ir.loaded = 0;
1195	xfs_iext_first(ifp, &ir.icur);
1196	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
1197	error = xfs_btree_visit_blocks(cur, xfs_iread_bmbt_block,
1198			XFS_BTREE_VISIT_RECORDS, &ir);
1199	xfs_btree_del_cursor(cur, error);
1200	if (error)
1201		goto out;
1202
1203	if (XFS_IS_CORRUPT(mp, ir.loaded != ifp->if_nextents)) {
1204		error = -EFSCORRUPTED;
1205		goto out;
1206	}
1207	ASSERT(ir.loaded == xfs_iext_count(ifp));
1208	/*
1209	 * Use release semantics so that we can use acquire semantics in
1210	 * xfs_need_iread_extents and be guaranteed to see a valid mapping tree
1211	 * after that load.
1212	 */
1213	smp_store_release(&ifp->if_needextents, 0);
1214	return 0;
1215out:
1216	xfs_iext_destroy(ifp);
1217	return error;
1218}
1219
1220/*
1221 * Returns the relative block number of the first unused block(s) in the given
1222 * fork with at least "len" logically contiguous blocks free.  This is the
1223 * lowest-address hole if the fork has holes, else the first block past the end
1224 * of fork.  Return 0 if the fork is currently local (in-inode).
1225 */
1226int						/* error */
1227xfs_bmap_first_unused(
1228	struct xfs_trans	*tp,		/* transaction pointer */
1229	struct xfs_inode	*ip,		/* incore inode */
1230	xfs_extlen_t		len,		/* size of hole to find */
1231	xfs_fileoff_t		*first_unused,	/* unused block */
1232	int			whichfork)	/* data or attr fork */
1233{
1234	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1235	struct xfs_bmbt_irec	got;
1236	struct xfs_iext_cursor	icur;
1237	xfs_fileoff_t		lastaddr = 0;
1238	xfs_fileoff_t		lowest, max;
1239	int			error;
1240
1241	if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
1242		*first_unused = 0;
1243		return 0;
1244	}
1245
1246	ASSERT(xfs_ifork_has_extents(ifp));
1247
1248	error = xfs_iread_extents(tp, ip, whichfork);
1249	if (error)
1250		return error;
 
 
1251
1252	lowest = max = *first_unused;
1253	for_each_xfs_iext(ifp, &icur, &got) {
1254		/*
1255		 * See if the hole before this extent will work.
1256		 */
1257		if (got.br_startoff >= lowest + len &&
1258		    got.br_startoff - max >= len)
1259			break;
1260		lastaddr = got.br_startoff + got.br_blockcount;
1261		max = XFS_FILEOFF_MAX(lastaddr, lowest);
1262	}
1263
1264	*first_unused = max;
1265	return 0;
1266}
1267
1268/*
1269 * Returns the file-relative block number of the last block - 1 before
1270 * last_block (input value) in the file.
1271 * This is not based on i_size, it is based on the extent records.
1272 * Returns 0 for local files, as they do not have extent records.
1273 */
1274int						/* error */
1275xfs_bmap_last_before(
1276	struct xfs_trans	*tp,		/* transaction pointer */
1277	struct xfs_inode	*ip,		/* incore inode */
1278	xfs_fileoff_t		*last_block,	/* last block */
1279	int			whichfork)	/* data or attr fork */
1280{
1281	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1282	struct xfs_bmbt_irec	got;
1283	struct xfs_iext_cursor	icur;
1284	int			error;
1285
1286	switch (ifp->if_format) {
1287	case XFS_DINODE_FMT_LOCAL:
1288		*last_block = 0;
1289		return 0;
1290	case XFS_DINODE_FMT_BTREE:
1291	case XFS_DINODE_FMT_EXTENTS:
1292		break;
1293	default:
1294		ASSERT(0);
1295		return -EFSCORRUPTED;
1296	}
1297
1298	error = xfs_iread_extents(tp, ip, whichfork);
1299	if (error)
1300		return error;
 
 
1301
1302	if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got))
1303		*last_block = 0;
1304	return 0;
1305}
1306
1307int
1308xfs_bmap_last_extent(
1309	struct xfs_trans	*tp,
1310	struct xfs_inode	*ip,
1311	int			whichfork,
1312	struct xfs_bmbt_irec	*rec,
1313	int			*is_empty)
1314{
1315	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1316	struct xfs_iext_cursor	icur;
1317	int			error;
1318
1319	error = xfs_iread_extents(tp, ip, whichfork);
1320	if (error)
1321		return error;
 
 
1322
1323	xfs_iext_last(ifp, &icur);
1324	if (!xfs_iext_get_extent(ifp, &icur, rec))
1325		*is_empty = 1;
1326	else
1327		*is_empty = 0;
1328	return 0;
1329}
1330
1331/*
1332 * Check the last inode extent to determine whether this allocation will result
1333 * in blocks being allocated at the end of the file. When we allocate new data
1334 * blocks at the end of the file which do not start at the previous data block,
1335 * we will try to align the new blocks at stripe unit boundaries.
1336 *
1337 * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be
1338 * at, or past the EOF.
1339 */
1340STATIC int
1341xfs_bmap_isaeof(
1342	struct xfs_bmalloca	*bma,
1343	int			whichfork)
1344{
1345	struct xfs_bmbt_irec	rec;
1346	int			is_empty;
1347	int			error;
1348
1349	bma->aeof = false;
1350	error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
1351				     &is_empty);
1352	if (error)
1353		return error;
1354
1355	if (is_empty) {
1356		bma->aeof = true;
1357		return 0;
1358	}
1359
1360	/*
1361	 * Check if we are allocation or past the last extent, or at least into
1362	 * the last delayed allocated extent.
1363	 */
1364	bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount ||
1365		(bma->offset >= rec.br_startoff &&
1366		 isnullstartblock(rec.br_startblock));
1367	return 0;
1368}
1369
1370/*
1371 * Returns the file-relative block number of the first block past eof in
1372 * the file.  This is not based on i_size, it is based on the extent records.
1373 * Returns 0 for local files, as they do not have extent records.
1374 */
1375int
1376xfs_bmap_last_offset(
1377	struct xfs_inode	*ip,
1378	xfs_fileoff_t		*last_block,
1379	int			whichfork)
1380{
1381	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1382	struct xfs_bmbt_irec	rec;
1383	int			is_empty;
1384	int			error;
1385
1386	*last_block = 0;
1387
1388	if (ifp->if_format == XFS_DINODE_FMT_LOCAL)
1389		return 0;
1390
1391	if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ifp)))
1392		return -EFSCORRUPTED;
1393
1394	error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
1395	if (error || is_empty)
1396		return error;
1397
1398	*last_block = rec.br_startoff + rec.br_blockcount;
1399	return 0;
1400}
1401
1402/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1403 * Extent tree manipulation functions used during allocation.
1404 */
1405
1406/*
1407 * Convert a delayed allocation to a real allocation.
1408 */
1409STATIC int				/* error */
1410xfs_bmap_add_extent_delay_real(
1411	struct xfs_bmalloca	*bma,
1412	int			whichfork)
1413{
1414	struct xfs_mount	*mp = bma->ip->i_mount;
1415	struct xfs_ifork	*ifp = xfs_ifork_ptr(bma->ip, whichfork);
1416	struct xfs_bmbt_irec	*new = &bma->got;
1417	int			error;	/* error return value */
1418	int			i;	/* temp state */
1419	xfs_fileoff_t		new_endoff;	/* end offset of new entry */
1420	xfs_bmbt_irec_t		r[3];	/* neighbor extent entries */
1421					/* left is 0, right is 1, prev is 2 */
1422	int			rval=0;	/* return value (logging flags) */
1423	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
1424	xfs_filblks_t		da_new; /* new count del alloc blocks used */
1425	xfs_filblks_t		da_old; /* old count del alloc blocks used */
1426	xfs_filblks_t		temp=0;	/* value for da_new calculations */
1427	int			tmp_rval;	/* partial logging flags */
1428	struct xfs_bmbt_irec	old;
1429
1430	ASSERT(whichfork != XFS_ATTR_FORK);
1431	ASSERT(!isnullstartblock(new->br_startblock));
1432	ASSERT(!bma->cur ||
1433	       (bma->cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
1434
1435	XFS_STATS_INC(mp, xs_add_exlist);
1436
1437#define	LEFT		r[0]
1438#define	RIGHT		r[1]
1439#define	PREV		r[2]
1440
1441	/*
1442	 * Set up a bunch of variables to make the tests simpler.
1443	 */
1444	xfs_iext_get_extent(ifp, &bma->icur, &PREV);
1445	new_endoff = new->br_startoff + new->br_blockcount;
1446	ASSERT(isnullstartblock(PREV.br_startblock));
1447	ASSERT(PREV.br_startoff <= new->br_startoff);
1448	ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
1449
1450	da_old = startblockval(PREV.br_startblock);
1451	da_new = 0;
1452
1453	/*
1454	 * Set flags determining what part of the previous delayed allocation
1455	 * extent is being replaced by a real allocation.
1456	 */
1457	if (PREV.br_startoff == new->br_startoff)
1458		state |= BMAP_LEFT_FILLING;
1459	if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
1460		state |= BMAP_RIGHT_FILLING;
1461
1462	/*
1463	 * Check and set flags if this segment has a left neighbor.
1464	 * Don't set contiguous if the combined extent would be too large.
1465	 */
1466	if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) {
1467		state |= BMAP_LEFT_VALID;
1468		if (isnullstartblock(LEFT.br_startblock))
1469			state |= BMAP_LEFT_DELAY;
1470	}
1471
1472	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
1473	    LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
1474	    LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
1475	    LEFT.br_state == new->br_state &&
1476	    LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
1477		state |= BMAP_LEFT_CONTIG;
1478
1479	/*
1480	 * Check and set flags if this segment has a right neighbor.
1481	 * Don't set contiguous if the combined extent would be too large.
1482	 * Also check for all-three-contiguous being too large.
1483	 */
1484	if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) {
1485		state |= BMAP_RIGHT_VALID;
1486		if (isnullstartblock(RIGHT.br_startblock))
1487			state |= BMAP_RIGHT_DELAY;
1488	}
1489
1490	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
1491	    new_endoff == RIGHT.br_startoff &&
1492	    new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
1493	    new->br_state == RIGHT.br_state &&
1494	    new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
1495	    ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1496		       BMAP_RIGHT_FILLING)) !=
1497		      (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1498		       BMAP_RIGHT_FILLING) ||
1499	     LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
1500			<= XFS_MAX_BMBT_EXTLEN))
1501		state |= BMAP_RIGHT_CONTIG;
1502
1503	error = 0;
1504	/*
1505	 * Switch out based on the FILLING and CONTIG state bits.
1506	 */
1507	switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1508			 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
1509	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1510	     BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1511		/*
1512		 * Filling in all of a previously delayed allocation extent.
1513		 * The left and right neighbors are both contiguous with new.
1514		 */
1515		LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
1516
1517		xfs_iext_remove(bma->ip, &bma->icur, state);
1518		xfs_iext_remove(bma->ip, &bma->icur, state);
1519		xfs_iext_prev(ifp, &bma->icur);
1520		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1521		ifp->if_nextents--;
1522
1523		if (bma->cur == NULL)
1524			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1525		else {
1526			rval = XFS_ILOG_CORE;
1527			error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1528			if (error)
1529				goto done;
1530			if (XFS_IS_CORRUPT(mp, i != 1)) {
1531				error = -EFSCORRUPTED;
1532				goto done;
1533			}
1534			error = xfs_btree_delete(bma->cur, &i);
1535			if (error)
1536				goto done;
1537			if (XFS_IS_CORRUPT(mp, i != 1)) {
1538				error = -EFSCORRUPTED;
1539				goto done;
1540			}
1541			error = xfs_btree_decrement(bma->cur, 0, &i);
1542			if (error)
1543				goto done;
1544			if (XFS_IS_CORRUPT(mp, i != 1)) {
1545				error = -EFSCORRUPTED;
1546				goto done;
1547			}
1548			error = xfs_bmbt_update(bma->cur, &LEFT);
1549			if (error)
1550				goto done;
1551		}
1552		break;
1553
1554	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1555		/*
1556		 * Filling in all of a previously delayed allocation extent.
1557		 * The left neighbor is contiguous, the right is not.
1558		 */
1559		old = LEFT;
1560		LEFT.br_blockcount += PREV.br_blockcount;
1561
1562		xfs_iext_remove(bma->ip, &bma->icur, state);
1563		xfs_iext_prev(ifp, &bma->icur);
1564		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1565
1566		if (bma->cur == NULL)
1567			rval = XFS_ILOG_DEXT;
1568		else {
1569			rval = 0;
1570			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1571			if (error)
1572				goto done;
1573			if (XFS_IS_CORRUPT(mp, i != 1)) {
1574				error = -EFSCORRUPTED;
1575				goto done;
1576			}
1577			error = xfs_bmbt_update(bma->cur, &LEFT);
1578			if (error)
1579				goto done;
1580		}
1581		break;
1582
1583	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1584		/*
1585		 * Filling in all of a previously delayed allocation extent.
1586		 * The right neighbor is contiguous, the left is not. Take care
1587		 * with delay -> unwritten extent allocation here because the
1588		 * delalloc record we are overwriting is always written.
1589		 */
1590		PREV.br_startblock = new->br_startblock;
1591		PREV.br_blockcount += RIGHT.br_blockcount;
1592		PREV.br_state = new->br_state;
1593
1594		xfs_iext_next(ifp, &bma->icur);
1595		xfs_iext_remove(bma->ip, &bma->icur, state);
1596		xfs_iext_prev(ifp, &bma->icur);
1597		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1598
1599		if (bma->cur == NULL)
1600			rval = XFS_ILOG_DEXT;
1601		else {
1602			rval = 0;
1603			error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1604			if (error)
1605				goto done;
1606			if (XFS_IS_CORRUPT(mp, i != 1)) {
1607				error = -EFSCORRUPTED;
1608				goto done;
1609			}
1610			error = xfs_bmbt_update(bma->cur, &PREV);
1611			if (error)
1612				goto done;
1613		}
1614		break;
1615
1616	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
1617		/*
1618		 * Filling in all of a previously delayed allocation extent.
1619		 * Neither the left nor right neighbors are contiguous with
1620		 * the new one.
1621		 */
1622		PREV.br_startblock = new->br_startblock;
1623		PREV.br_state = new->br_state;
1624		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1625		ifp->if_nextents++;
1626
1627		if (bma->cur == NULL)
1628			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1629		else {
1630			rval = XFS_ILOG_CORE;
1631			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1632			if (error)
1633				goto done;
1634			if (XFS_IS_CORRUPT(mp, i != 0)) {
1635				error = -EFSCORRUPTED;
1636				goto done;
1637			}
1638			error = xfs_btree_insert(bma->cur, &i);
1639			if (error)
1640				goto done;
1641			if (XFS_IS_CORRUPT(mp, i != 1)) {
1642				error = -EFSCORRUPTED;
1643				goto done;
1644			}
1645		}
1646		break;
1647
1648	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
1649		/*
1650		 * Filling in the first part of a previous delayed allocation.
1651		 * The left neighbor is contiguous.
1652		 */
1653		old = LEFT;
1654		temp = PREV.br_blockcount - new->br_blockcount;
1655		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1656				startblockval(PREV.br_startblock));
1657
1658		LEFT.br_blockcount += new->br_blockcount;
1659
1660		PREV.br_blockcount = temp;
1661		PREV.br_startoff += new->br_blockcount;
1662		PREV.br_startblock = nullstartblock(da_new);
1663
1664		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1665		xfs_iext_prev(ifp, &bma->icur);
1666		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1667
1668		if (bma->cur == NULL)
1669			rval = XFS_ILOG_DEXT;
1670		else {
1671			rval = 0;
1672			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1673			if (error)
1674				goto done;
1675			if (XFS_IS_CORRUPT(mp, i != 1)) {
1676				error = -EFSCORRUPTED;
1677				goto done;
1678			}
1679			error = xfs_bmbt_update(bma->cur, &LEFT);
1680			if (error)
1681				goto done;
1682		}
1683		break;
1684
1685	case BMAP_LEFT_FILLING:
1686		/*
1687		 * Filling in the first part of a previous delayed allocation.
1688		 * The left neighbor is not contiguous.
1689		 */
1690		xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1691		ifp->if_nextents++;
1692
1693		if (bma->cur == NULL)
1694			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1695		else {
1696			rval = XFS_ILOG_CORE;
1697			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1698			if (error)
1699				goto done;
1700			if (XFS_IS_CORRUPT(mp, i != 0)) {
1701				error = -EFSCORRUPTED;
1702				goto done;
1703			}
1704			error = xfs_btree_insert(bma->cur, &i);
1705			if (error)
1706				goto done;
1707			if (XFS_IS_CORRUPT(mp, i != 1)) {
1708				error = -EFSCORRUPTED;
1709				goto done;
1710			}
1711		}
1712
1713		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1714			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1715					&bma->cur, 1, &tmp_rval, whichfork);
1716			rval |= tmp_rval;
1717			if (error)
1718				goto done;
1719		}
1720
1721		temp = PREV.br_blockcount - new->br_blockcount;
1722		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1723			startblockval(PREV.br_startblock) -
1724			(bma->cur ? bma->cur->bc_ino.allocated : 0));
1725
1726		PREV.br_startoff = new_endoff;
1727		PREV.br_blockcount = temp;
1728		PREV.br_startblock = nullstartblock(da_new);
1729		xfs_iext_next(ifp, &bma->icur);
1730		xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1731		xfs_iext_prev(ifp, &bma->icur);
1732		break;
1733
1734	case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1735		/*
1736		 * Filling in the last part of a previous delayed allocation.
1737		 * The right neighbor is contiguous with the new allocation.
1738		 */
1739		old = RIGHT;
1740		RIGHT.br_startoff = new->br_startoff;
1741		RIGHT.br_startblock = new->br_startblock;
1742		RIGHT.br_blockcount += new->br_blockcount;
1743
1744		if (bma->cur == NULL)
1745			rval = XFS_ILOG_DEXT;
1746		else {
1747			rval = 0;
1748			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1749			if (error)
1750				goto done;
1751			if (XFS_IS_CORRUPT(mp, i != 1)) {
1752				error = -EFSCORRUPTED;
1753				goto done;
1754			}
1755			error = xfs_bmbt_update(bma->cur, &RIGHT);
1756			if (error)
1757				goto done;
1758		}
1759
1760		temp = PREV.br_blockcount - new->br_blockcount;
1761		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1762			startblockval(PREV.br_startblock));
1763
1764		PREV.br_blockcount = temp;
1765		PREV.br_startblock = nullstartblock(da_new);
1766
1767		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1768		xfs_iext_next(ifp, &bma->icur);
1769		xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT);
1770		break;
1771
1772	case BMAP_RIGHT_FILLING:
1773		/*
1774		 * Filling in the last part of a previous delayed allocation.
1775		 * The right neighbor is not contiguous.
1776		 */
1777		xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1778		ifp->if_nextents++;
1779
1780		if (bma->cur == NULL)
1781			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1782		else {
1783			rval = XFS_ILOG_CORE;
1784			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1785			if (error)
1786				goto done;
1787			if (XFS_IS_CORRUPT(mp, i != 0)) {
1788				error = -EFSCORRUPTED;
1789				goto done;
1790			}
1791			error = xfs_btree_insert(bma->cur, &i);
1792			if (error)
1793				goto done;
1794			if (XFS_IS_CORRUPT(mp, i != 1)) {
1795				error = -EFSCORRUPTED;
1796				goto done;
1797			}
1798		}
1799
1800		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1801			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1802				&bma->cur, 1, &tmp_rval, whichfork);
1803			rval |= tmp_rval;
1804			if (error)
1805				goto done;
1806		}
1807
1808		temp = PREV.br_blockcount - new->br_blockcount;
1809		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1810			startblockval(PREV.br_startblock) -
1811			(bma->cur ? bma->cur->bc_ino.allocated : 0));
1812
1813		PREV.br_startblock = nullstartblock(da_new);
1814		PREV.br_blockcount = temp;
1815		xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1816		xfs_iext_next(ifp, &bma->icur);
1817		break;
1818
1819	case 0:
1820		/*
1821		 * Filling in the middle part of a previous delayed allocation.
1822		 * Contiguity is impossible here.
1823		 * This case is avoided almost all the time.
1824		 *
1825		 * We start with a delayed allocation:
1826		 *
1827		 * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+
1828		 *  PREV @ idx
1829		 *
1830	         * and we are allocating:
1831		 *                     +rrrrrrrrrrrrrrrrr+
1832		 *			      new
1833		 *
1834		 * and we set it up for insertion as:
1835		 * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+
1836		 *                            new
1837		 *  PREV @ idx          LEFT              RIGHT
1838		 *                      inserted at idx + 1
1839		 */
1840		old = PREV;
1841
1842		/* LEFT is the new middle */
1843		LEFT = *new;
1844
1845		/* RIGHT is the new right */
1846		RIGHT.br_state = PREV.br_state;
1847		RIGHT.br_startoff = new_endoff;
1848		RIGHT.br_blockcount =
1849			PREV.br_startoff + PREV.br_blockcount - new_endoff;
1850		RIGHT.br_startblock =
1851			nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1852					RIGHT.br_blockcount));
1853
1854		/* truncate PREV */
1855		PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
1856		PREV.br_startblock =
1857			nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1858					PREV.br_blockcount));
1859		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1860
1861		xfs_iext_next(ifp, &bma->icur);
1862		xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state);
1863		xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state);
1864		ifp->if_nextents++;
1865
1866		if (bma->cur == NULL)
1867			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1868		else {
1869			rval = XFS_ILOG_CORE;
1870			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1871			if (error)
1872				goto done;
1873			if (XFS_IS_CORRUPT(mp, i != 0)) {
1874				error = -EFSCORRUPTED;
1875				goto done;
1876			}
1877			error = xfs_btree_insert(bma->cur, &i);
1878			if (error)
1879				goto done;
1880			if (XFS_IS_CORRUPT(mp, i != 1)) {
1881				error = -EFSCORRUPTED;
1882				goto done;
1883			}
1884		}
1885
1886		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1887			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1888					&bma->cur, 1, &tmp_rval, whichfork);
1889			rval |= tmp_rval;
1890			if (error)
1891				goto done;
1892		}
1893
1894		da_new = startblockval(PREV.br_startblock) +
1895			 startblockval(RIGHT.br_startblock);
1896		break;
1897
1898	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1899	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1900	case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
1901	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1902	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1903	case BMAP_LEFT_CONTIG:
1904	case BMAP_RIGHT_CONTIG:
1905		/*
1906		 * These cases are all impossible.
1907		 */
1908		ASSERT(0);
1909	}
1910
1911	/* add reverse mapping unless caller opted out */
1912	if (!(bma->flags & XFS_BMAPI_NORMAP))
1913		xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1914
1915	/* convert to a btree if necessary */
1916	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1917		int	tmp_logflags;	/* partial log flag return val */
1918
1919		ASSERT(bma->cur == NULL);
1920		error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1921				&bma->cur, da_old > 0, &tmp_logflags,
1922				whichfork);
1923		bma->logflags |= tmp_logflags;
1924		if (error)
1925			goto done;
1926	}
1927
1928	if (da_new != da_old)
1929		xfs_mod_delalloc(mp, (int64_t)da_new - da_old);
1930
1931	if (bma->cur) {
1932		da_new += bma->cur->bc_ino.allocated;
1933		bma->cur->bc_ino.allocated = 0;
1934	}
1935
1936	/* adjust for changes in reserved delayed indirect blocks */
1937	if (da_new != da_old) {
1938		ASSERT(state == 0 || da_new < da_old);
1939		error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new),
1940				false);
1941	}
1942
1943	xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork);
1944done:
1945	if (whichfork != XFS_COW_FORK)
1946		bma->logflags |= rval;
1947	return error;
1948#undef	LEFT
1949#undef	RIGHT
1950#undef	PREV
1951}
1952
1953/*
1954 * Convert an unwritten allocation to a real allocation or vice versa.
1955 */
1956int					/* error */
1957xfs_bmap_add_extent_unwritten_real(
1958	struct xfs_trans	*tp,
1959	xfs_inode_t		*ip,	/* incore inode pointer */
1960	int			whichfork,
1961	struct xfs_iext_cursor	*icur,
1962	struct xfs_btree_cur	**curp,	/* if *curp is null, not a btree */
1963	xfs_bmbt_irec_t		*new,	/* new data to add to file extents */
1964	int			*logflagsp) /* inode logging flags */
1965{
1966	struct xfs_btree_cur	*cur;	/* btree cursor */
1967	int			error;	/* error return value */
1968	int			i;	/* temp state */
1969	struct xfs_ifork	*ifp;	/* inode fork pointer */
1970	xfs_fileoff_t		new_endoff;	/* end offset of new entry */
1971	xfs_bmbt_irec_t		r[3];	/* neighbor extent entries */
1972					/* left is 0, right is 1, prev is 2 */
1973	int			rval=0;	/* return value (logging flags) */
1974	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
1975	struct xfs_mount	*mp = ip->i_mount;
1976	struct xfs_bmbt_irec	old;
1977
1978	*logflagsp = 0;
1979
1980	cur = *curp;
1981	ifp = xfs_ifork_ptr(ip, whichfork);
1982
1983	ASSERT(!isnullstartblock(new->br_startblock));
1984
1985	XFS_STATS_INC(mp, xs_add_exlist);
1986
1987#define	LEFT		r[0]
1988#define	RIGHT		r[1]
1989#define	PREV		r[2]
1990
1991	/*
1992	 * Set up a bunch of variables to make the tests simpler.
1993	 */
1994	error = 0;
1995	xfs_iext_get_extent(ifp, icur, &PREV);
1996	ASSERT(new->br_state != PREV.br_state);
1997	new_endoff = new->br_startoff + new->br_blockcount;
1998	ASSERT(PREV.br_startoff <= new->br_startoff);
1999	ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
2000
2001	/*
2002	 * Set flags determining what part of the previous oldext allocation
2003	 * extent is being replaced by a newext allocation.
2004	 */
2005	if (PREV.br_startoff == new->br_startoff)
2006		state |= BMAP_LEFT_FILLING;
2007	if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
2008		state |= BMAP_RIGHT_FILLING;
2009
2010	/*
2011	 * Check and set flags if this segment has a left neighbor.
2012	 * Don't set contiguous if the combined extent would be too large.
2013	 */
2014	if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) {
2015		state |= BMAP_LEFT_VALID;
2016		if (isnullstartblock(LEFT.br_startblock))
2017			state |= BMAP_LEFT_DELAY;
2018	}
2019
2020	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2021	    LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
2022	    LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
2023	    LEFT.br_state == new->br_state &&
2024	    LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2025		state |= BMAP_LEFT_CONTIG;
2026
2027	/*
2028	 * Check and set flags if this segment has a right neighbor.
2029	 * Don't set contiguous if the combined extent would be too large.
2030	 * Also check for all-three-contiguous being too large.
2031	 */
2032	if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) {
2033		state |= BMAP_RIGHT_VALID;
2034		if (isnullstartblock(RIGHT.br_startblock))
2035			state |= BMAP_RIGHT_DELAY;
2036	}
2037
2038	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2039	    new_endoff == RIGHT.br_startoff &&
2040	    new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
2041	    new->br_state == RIGHT.br_state &&
2042	    new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2043	    ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2044		       BMAP_RIGHT_FILLING)) !=
2045		      (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2046		       BMAP_RIGHT_FILLING) ||
2047	     LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
2048			<= XFS_MAX_BMBT_EXTLEN))
2049		state |= BMAP_RIGHT_CONTIG;
2050
2051	/*
2052	 * Switch out based on the FILLING and CONTIG state bits.
2053	 */
2054	switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2055			 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
2056	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2057	     BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2058		/*
2059		 * Setting all of a previous oldext extent to newext.
2060		 * The left and right neighbors are both contiguous with new.
2061		 */
2062		LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
2063
2064		xfs_iext_remove(ip, icur, state);
2065		xfs_iext_remove(ip, icur, state);
2066		xfs_iext_prev(ifp, icur);
2067		xfs_iext_update_extent(ip, state, icur, &LEFT);
2068		ifp->if_nextents -= 2;
2069		if (cur == NULL)
2070			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2071		else {
2072			rval = XFS_ILOG_CORE;
2073			error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2074			if (error)
2075				goto done;
2076			if (XFS_IS_CORRUPT(mp, i != 1)) {
2077				error = -EFSCORRUPTED;
2078				goto done;
2079			}
2080			if ((error = xfs_btree_delete(cur, &i)))
2081				goto done;
2082			if (XFS_IS_CORRUPT(mp, i != 1)) {
2083				error = -EFSCORRUPTED;
2084				goto done;
2085			}
2086			if ((error = xfs_btree_decrement(cur, 0, &i)))
2087				goto done;
2088			if (XFS_IS_CORRUPT(mp, i != 1)) {
2089				error = -EFSCORRUPTED;
2090				goto done;
2091			}
2092			if ((error = xfs_btree_delete(cur, &i)))
2093				goto done;
2094			if (XFS_IS_CORRUPT(mp, i != 1)) {
2095				error = -EFSCORRUPTED;
2096				goto done;
2097			}
2098			if ((error = xfs_btree_decrement(cur, 0, &i)))
2099				goto done;
2100			if (XFS_IS_CORRUPT(mp, i != 1)) {
2101				error = -EFSCORRUPTED;
2102				goto done;
2103			}
2104			error = xfs_bmbt_update(cur, &LEFT);
2105			if (error)
2106				goto done;
2107		}
2108		break;
2109
2110	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2111		/*
2112		 * Setting all of a previous oldext extent to newext.
2113		 * The left neighbor is contiguous, the right is not.
2114		 */
2115		LEFT.br_blockcount += PREV.br_blockcount;
2116
2117		xfs_iext_remove(ip, icur, state);
2118		xfs_iext_prev(ifp, icur);
2119		xfs_iext_update_extent(ip, state, icur, &LEFT);
2120		ifp->if_nextents--;
2121		if (cur == NULL)
2122			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2123		else {
2124			rval = XFS_ILOG_CORE;
2125			error = xfs_bmbt_lookup_eq(cur, &PREV, &i);
2126			if (error)
2127				goto done;
2128			if (XFS_IS_CORRUPT(mp, i != 1)) {
2129				error = -EFSCORRUPTED;
2130				goto done;
2131			}
2132			if ((error = xfs_btree_delete(cur, &i)))
2133				goto done;
2134			if (XFS_IS_CORRUPT(mp, i != 1)) {
2135				error = -EFSCORRUPTED;
2136				goto done;
2137			}
2138			if ((error = xfs_btree_decrement(cur, 0, &i)))
2139				goto done;
2140			if (XFS_IS_CORRUPT(mp, i != 1)) {
2141				error = -EFSCORRUPTED;
2142				goto done;
2143			}
2144			error = xfs_bmbt_update(cur, &LEFT);
2145			if (error)
2146				goto done;
2147		}
2148		break;
2149
2150	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2151		/*
2152		 * Setting all of a previous oldext extent to newext.
2153		 * The right neighbor is contiguous, the left is not.
2154		 */
2155		PREV.br_blockcount += RIGHT.br_blockcount;
2156		PREV.br_state = new->br_state;
2157
2158		xfs_iext_next(ifp, icur);
2159		xfs_iext_remove(ip, icur, state);
2160		xfs_iext_prev(ifp, icur);
2161		xfs_iext_update_extent(ip, state, icur, &PREV);
2162		ifp->if_nextents--;
2163
2164		if (cur == NULL)
2165			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2166		else {
2167			rval = XFS_ILOG_CORE;
2168			error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2169			if (error)
2170				goto done;
2171			if (XFS_IS_CORRUPT(mp, i != 1)) {
2172				error = -EFSCORRUPTED;
2173				goto done;
2174			}
2175			if ((error = xfs_btree_delete(cur, &i)))
2176				goto done;
2177			if (XFS_IS_CORRUPT(mp, i != 1)) {
2178				error = -EFSCORRUPTED;
2179				goto done;
2180			}
2181			if ((error = xfs_btree_decrement(cur, 0, &i)))
2182				goto done;
2183			if (XFS_IS_CORRUPT(mp, i != 1)) {
2184				error = -EFSCORRUPTED;
2185				goto done;
2186			}
2187			error = xfs_bmbt_update(cur, &PREV);
2188			if (error)
2189				goto done;
2190		}
2191		break;
2192
2193	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
2194		/*
2195		 * Setting all of a previous oldext extent to newext.
2196		 * Neither the left nor right neighbors are contiguous with
2197		 * the new one.
2198		 */
2199		PREV.br_state = new->br_state;
2200		xfs_iext_update_extent(ip, state, icur, &PREV);
2201
2202		if (cur == NULL)
2203			rval = XFS_ILOG_DEXT;
2204		else {
2205			rval = 0;
2206			error = xfs_bmbt_lookup_eq(cur, new, &i);
2207			if (error)
2208				goto done;
2209			if (XFS_IS_CORRUPT(mp, i != 1)) {
2210				error = -EFSCORRUPTED;
2211				goto done;
2212			}
2213			error = xfs_bmbt_update(cur, &PREV);
2214			if (error)
2215				goto done;
2216		}
2217		break;
2218
2219	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
2220		/*
2221		 * Setting the first part of a previous oldext extent to newext.
2222		 * The left neighbor is contiguous.
2223		 */
2224		LEFT.br_blockcount += new->br_blockcount;
2225
2226		old = PREV;
2227		PREV.br_startoff += new->br_blockcount;
2228		PREV.br_startblock += new->br_blockcount;
2229		PREV.br_blockcount -= new->br_blockcount;
2230
2231		xfs_iext_update_extent(ip, state, icur, &PREV);
2232		xfs_iext_prev(ifp, icur);
2233		xfs_iext_update_extent(ip, state, icur, &LEFT);
2234
2235		if (cur == NULL)
2236			rval = XFS_ILOG_DEXT;
2237		else {
2238			rval = 0;
2239			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2240			if (error)
2241				goto done;
2242			if (XFS_IS_CORRUPT(mp, i != 1)) {
2243				error = -EFSCORRUPTED;
2244				goto done;
2245			}
2246			error = xfs_bmbt_update(cur, &PREV);
2247			if (error)
2248				goto done;
2249			error = xfs_btree_decrement(cur, 0, &i);
2250			if (error)
2251				goto done;
2252			error = xfs_bmbt_update(cur, &LEFT);
2253			if (error)
2254				goto done;
2255		}
2256		break;
2257
2258	case BMAP_LEFT_FILLING:
2259		/*
2260		 * Setting the first part of a previous oldext extent to newext.
2261		 * The left neighbor is not contiguous.
2262		 */
2263		old = PREV;
2264		PREV.br_startoff += new->br_blockcount;
2265		PREV.br_startblock += new->br_blockcount;
2266		PREV.br_blockcount -= new->br_blockcount;
2267
2268		xfs_iext_update_extent(ip, state, icur, &PREV);
2269		xfs_iext_insert(ip, icur, new, state);
2270		ifp->if_nextents++;
2271
2272		if (cur == NULL)
2273			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2274		else {
2275			rval = XFS_ILOG_CORE;
2276			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2277			if (error)
2278				goto done;
2279			if (XFS_IS_CORRUPT(mp, i != 1)) {
2280				error = -EFSCORRUPTED;
2281				goto done;
2282			}
2283			error = xfs_bmbt_update(cur, &PREV);
2284			if (error)
2285				goto done;
2286			cur->bc_rec.b = *new;
2287			if ((error = xfs_btree_insert(cur, &i)))
2288				goto done;
2289			if (XFS_IS_CORRUPT(mp, i != 1)) {
2290				error = -EFSCORRUPTED;
2291				goto done;
2292			}
2293		}
2294		break;
2295
2296	case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2297		/*
2298		 * Setting the last part of a previous oldext extent to newext.
2299		 * The right neighbor is contiguous with the new allocation.
2300		 */
2301		old = PREV;
2302		PREV.br_blockcount -= new->br_blockcount;
2303
2304		RIGHT.br_startoff = new->br_startoff;
2305		RIGHT.br_startblock = new->br_startblock;
2306		RIGHT.br_blockcount += new->br_blockcount;
2307
2308		xfs_iext_update_extent(ip, state, icur, &PREV);
2309		xfs_iext_next(ifp, icur);
2310		xfs_iext_update_extent(ip, state, icur, &RIGHT);
2311
2312		if (cur == NULL)
2313			rval = XFS_ILOG_DEXT;
2314		else {
2315			rval = 0;
2316			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2317			if (error)
2318				goto done;
2319			if (XFS_IS_CORRUPT(mp, i != 1)) {
2320				error = -EFSCORRUPTED;
2321				goto done;
2322			}
2323			error = xfs_bmbt_update(cur, &PREV);
2324			if (error)
2325				goto done;
2326			error = xfs_btree_increment(cur, 0, &i);
2327			if (error)
2328				goto done;
2329			error = xfs_bmbt_update(cur, &RIGHT);
2330			if (error)
2331				goto done;
2332		}
2333		break;
2334
2335	case BMAP_RIGHT_FILLING:
2336		/*
2337		 * Setting the last part of a previous oldext extent to newext.
2338		 * The right neighbor is not contiguous.
2339		 */
2340		old = PREV;
2341		PREV.br_blockcount -= new->br_blockcount;
2342
2343		xfs_iext_update_extent(ip, state, icur, &PREV);
2344		xfs_iext_next(ifp, icur);
2345		xfs_iext_insert(ip, icur, new, state);
2346		ifp->if_nextents++;
2347
2348		if (cur == NULL)
2349			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2350		else {
2351			rval = XFS_ILOG_CORE;
2352			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2353			if (error)
2354				goto done;
2355			if (XFS_IS_CORRUPT(mp, i != 1)) {
2356				error = -EFSCORRUPTED;
2357				goto done;
2358			}
2359			error = xfs_bmbt_update(cur, &PREV);
2360			if (error)
2361				goto done;
2362			error = xfs_bmbt_lookup_eq(cur, new, &i);
2363			if (error)
2364				goto done;
2365			if (XFS_IS_CORRUPT(mp, i != 0)) {
2366				error = -EFSCORRUPTED;
2367				goto done;
2368			}
2369			if ((error = xfs_btree_insert(cur, &i)))
2370				goto done;
2371			if (XFS_IS_CORRUPT(mp, i != 1)) {
2372				error = -EFSCORRUPTED;
2373				goto done;
2374			}
2375		}
2376		break;
2377
2378	case 0:
2379		/*
2380		 * Setting the middle part of a previous oldext extent to
2381		 * newext.  Contiguity is impossible here.
2382		 * One extent becomes three extents.
2383		 */
2384		old = PREV;
2385		PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
2386
2387		r[0] = *new;
2388		r[1].br_startoff = new_endoff;
2389		r[1].br_blockcount =
2390			old.br_startoff + old.br_blockcount - new_endoff;
2391		r[1].br_startblock = new->br_startblock + new->br_blockcount;
2392		r[1].br_state = PREV.br_state;
2393
2394		xfs_iext_update_extent(ip, state, icur, &PREV);
2395		xfs_iext_next(ifp, icur);
2396		xfs_iext_insert(ip, icur, &r[1], state);
2397		xfs_iext_insert(ip, icur, &r[0], state);
2398		ifp->if_nextents += 2;
2399
2400		if (cur == NULL)
2401			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2402		else {
2403			rval = XFS_ILOG_CORE;
2404			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2405			if (error)
2406				goto done;
2407			if (XFS_IS_CORRUPT(mp, i != 1)) {
2408				error = -EFSCORRUPTED;
2409				goto done;
2410			}
2411			/* new right extent - oldext */
2412			error = xfs_bmbt_update(cur, &r[1]);
2413			if (error)
2414				goto done;
2415			/* new left extent - oldext */
2416			cur->bc_rec.b = PREV;
2417			if ((error = xfs_btree_insert(cur, &i)))
2418				goto done;
2419			if (XFS_IS_CORRUPT(mp, i != 1)) {
2420				error = -EFSCORRUPTED;
2421				goto done;
2422			}
2423			/*
2424			 * Reset the cursor to the position of the new extent
2425			 * we are about to insert as we can't trust it after
2426			 * the previous insert.
2427			 */
2428			error = xfs_bmbt_lookup_eq(cur, new, &i);
2429			if (error)
2430				goto done;
2431			if (XFS_IS_CORRUPT(mp, i != 0)) {
2432				error = -EFSCORRUPTED;
2433				goto done;
2434			}
2435			/* new middle extent - newext */
2436			if ((error = xfs_btree_insert(cur, &i)))
2437				goto done;
2438			if (XFS_IS_CORRUPT(mp, i != 1)) {
2439				error = -EFSCORRUPTED;
2440				goto done;
2441			}
2442		}
2443		break;
2444
2445	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2446	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2447	case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
2448	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2449	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2450	case BMAP_LEFT_CONTIG:
2451	case BMAP_RIGHT_CONTIG:
2452		/*
2453		 * These cases are all impossible.
2454		 */
2455		ASSERT(0);
2456	}
2457
2458	/* update reverse mappings */
2459	xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2460
2461	/* convert to a btree if necessary */
2462	if (xfs_bmap_needs_btree(ip, whichfork)) {
2463		int	tmp_logflags;	/* partial log flag return val */
2464
2465		ASSERT(cur == NULL);
2466		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
2467				&tmp_logflags, whichfork);
2468		*logflagsp |= tmp_logflags;
2469		if (error)
2470			goto done;
2471	}
2472
2473	/* clear out the allocated field, done with it now in any case. */
2474	if (cur) {
2475		cur->bc_ino.allocated = 0;
2476		*curp = cur;
2477	}
2478
2479	xfs_bmap_check_leaf_extents(*curp, ip, whichfork);
2480done:
2481	*logflagsp |= rval;
2482	return error;
2483#undef	LEFT
2484#undef	RIGHT
2485#undef	PREV
2486}
2487
2488/*
2489 * Convert a hole to a delayed allocation.
2490 */
2491STATIC void
2492xfs_bmap_add_extent_hole_delay(
2493	xfs_inode_t		*ip,	/* incore inode pointer */
2494	int			whichfork,
2495	struct xfs_iext_cursor	*icur,
2496	xfs_bmbt_irec_t		*new)	/* new data to add to file extents */
2497{
2498	struct xfs_ifork	*ifp;	/* inode fork pointer */
2499	xfs_bmbt_irec_t		left;	/* left neighbor extent entry */
2500	xfs_filblks_t		newlen=0;	/* new indirect size */
2501	xfs_filblks_t		oldlen=0;	/* old indirect size */
2502	xfs_bmbt_irec_t		right;	/* right neighbor extent entry */
2503	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
2504	xfs_filblks_t		temp;	 /* temp for indirect calculations */
2505
2506	ifp = xfs_ifork_ptr(ip, whichfork);
2507	ASSERT(isnullstartblock(new->br_startblock));
2508
2509	/*
2510	 * Check and set flags if this segment has a left neighbor
2511	 */
2512	if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2513		state |= BMAP_LEFT_VALID;
2514		if (isnullstartblock(left.br_startblock))
2515			state |= BMAP_LEFT_DELAY;
2516	}
2517
2518	/*
2519	 * Check and set flags if the current (right) segment exists.
2520	 * If it doesn't exist, we're converting the hole at end-of-file.
2521	 */
2522	if (xfs_iext_get_extent(ifp, icur, &right)) {
2523		state |= BMAP_RIGHT_VALID;
2524		if (isnullstartblock(right.br_startblock))
2525			state |= BMAP_RIGHT_DELAY;
2526	}
2527
2528	/*
2529	 * Set contiguity flags on the left and right neighbors.
2530	 * Don't let extents get too large, even if the pieces are contiguous.
2531	 */
2532	if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&
2533	    left.br_startoff + left.br_blockcount == new->br_startoff &&
2534	    left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2535		state |= BMAP_LEFT_CONTIG;
2536
2537	if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&
2538	    new->br_startoff + new->br_blockcount == right.br_startoff &&
2539	    new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2540	    (!(state & BMAP_LEFT_CONTIG) ||
2541	     (left.br_blockcount + new->br_blockcount +
2542	      right.br_blockcount <= XFS_MAX_BMBT_EXTLEN)))
2543		state |= BMAP_RIGHT_CONTIG;
2544
2545	/*
2546	 * Switch out based on the contiguity flags.
2547	 */
2548	switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2549	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2550		/*
2551		 * New allocation is contiguous with delayed allocations
2552		 * on the left and on the right.
2553		 * Merge all three into a single extent record.
2554		 */
2555		temp = left.br_blockcount + new->br_blockcount +
2556			right.br_blockcount;
2557
2558		oldlen = startblockval(left.br_startblock) +
2559			startblockval(new->br_startblock) +
2560			startblockval(right.br_startblock);
2561		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2562					 oldlen);
2563		left.br_startblock = nullstartblock(newlen);
2564		left.br_blockcount = temp;
2565
2566		xfs_iext_remove(ip, icur, state);
2567		xfs_iext_prev(ifp, icur);
2568		xfs_iext_update_extent(ip, state, icur, &left);
2569		break;
2570
2571	case BMAP_LEFT_CONTIG:
2572		/*
2573		 * New allocation is contiguous with a delayed allocation
2574		 * on the left.
2575		 * Merge the new allocation with the left neighbor.
2576		 */
2577		temp = left.br_blockcount + new->br_blockcount;
2578
2579		oldlen = startblockval(left.br_startblock) +
2580			startblockval(new->br_startblock);
2581		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2582					 oldlen);
2583		left.br_blockcount = temp;
2584		left.br_startblock = nullstartblock(newlen);
2585
2586		xfs_iext_prev(ifp, icur);
2587		xfs_iext_update_extent(ip, state, icur, &left);
2588		break;
2589
2590	case BMAP_RIGHT_CONTIG:
2591		/*
2592		 * New allocation is contiguous with a delayed allocation
2593		 * on the right.
2594		 * Merge the new allocation with the right neighbor.
2595		 */
2596		temp = new->br_blockcount + right.br_blockcount;
2597		oldlen = startblockval(new->br_startblock) +
2598			startblockval(right.br_startblock);
2599		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2600					 oldlen);
2601		right.br_startoff = new->br_startoff;
2602		right.br_startblock = nullstartblock(newlen);
2603		right.br_blockcount = temp;
2604		xfs_iext_update_extent(ip, state, icur, &right);
2605		break;
2606
2607	case 0:
2608		/*
2609		 * New allocation is not contiguous with another
2610		 * delayed allocation.
2611		 * Insert a new entry.
2612		 */
2613		oldlen = newlen = 0;
2614		xfs_iext_insert(ip, icur, new, state);
2615		break;
2616	}
2617	if (oldlen != newlen) {
2618		ASSERT(oldlen > newlen);
2619		xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen),
2620				 false);
2621		/*
2622		 * Nothing to do for disk quota accounting here.
2623		 */
2624		xfs_mod_delalloc(ip->i_mount, (int64_t)newlen - oldlen);
2625	}
2626}
2627
2628/*
2629 * Convert a hole to a real allocation.
2630 */
2631STATIC int				/* error */
2632xfs_bmap_add_extent_hole_real(
2633	struct xfs_trans	*tp,
2634	struct xfs_inode	*ip,
2635	int			whichfork,
2636	struct xfs_iext_cursor	*icur,
2637	struct xfs_btree_cur	**curp,
2638	struct xfs_bmbt_irec	*new,
2639	int			*logflagsp,
2640	uint32_t		flags)
2641{
2642	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
2643	struct xfs_mount	*mp = ip->i_mount;
2644	struct xfs_btree_cur	*cur = *curp;
2645	int			error;	/* error return value */
2646	int			i;	/* temp state */
2647	xfs_bmbt_irec_t		left;	/* left neighbor extent entry */
2648	xfs_bmbt_irec_t		right;	/* right neighbor extent entry */
2649	int			rval=0;	/* return value (logging flags) */
2650	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
2651	struct xfs_bmbt_irec	old;
2652
2653	ASSERT(!isnullstartblock(new->br_startblock));
2654	ASSERT(!cur || !(cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
2655
2656	XFS_STATS_INC(mp, xs_add_exlist);
2657
2658	/*
2659	 * Check and set flags if this segment has a left neighbor.
2660	 */
2661	if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2662		state |= BMAP_LEFT_VALID;
2663		if (isnullstartblock(left.br_startblock))
2664			state |= BMAP_LEFT_DELAY;
2665	}
2666
2667	/*
2668	 * Check and set flags if this segment has a current value.
2669	 * Not true if we're inserting into the "hole" at eof.
2670	 */
2671	if (xfs_iext_get_extent(ifp, icur, &right)) {
2672		state |= BMAP_RIGHT_VALID;
2673		if (isnullstartblock(right.br_startblock))
2674			state |= BMAP_RIGHT_DELAY;
2675	}
2676
2677	/*
2678	 * We're inserting a real allocation between "left" and "right".
2679	 * Set the contiguity flags.  Don't let extents get too large.
2680	 */
2681	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2682	    left.br_startoff + left.br_blockcount == new->br_startoff &&
2683	    left.br_startblock + left.br_blockcount == new->br_startblock &&
2684	    left.br_state == new->br_state &&
2685	    left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2686		state |= BMAP_LEFT_CONTIG;
2687
2688	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2689	    new->br_startoff + new->br_blockcount == right.br_startoff &&
2690	    new->br_startblock + new->br_blockcount == right.br_startblock &&
2691	    new->br_state == right.br_state &&
2692	    new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2693	    (!(state & BMAP_LEFT_CONTIG) ||
2694	     left.br_blockcount + new->br_blockcount +
2695	     right.br_blockcount <= XFS_MAX_BMBT_EXTLEN))
2696		state |= BMAP_RIGHT_CONTIG;
2697
2698	error = 0;
2699	/*
2700	 * Select which case we're in here, and implement it.
2701	 */
2702	switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2703	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2704		/*
2705		 * New allocation is contiguous with real allocations on the
2706		 * left and on the right.
2707		 * Merge all three into a single extent record.
2708		 */
2709		left.br_blockcount += new->br_blockcount + right.br_blockcount;
2710
2711		xfs_iext_remove(ip, icur, state);
2712		xfs_iext_prev(ifp, icur);
2713		xfs_iext_update_extent(ip, state, icur, &left);
2714		ifp->if_nextents--;
2715
2716		if (cur == NULL) {
2717			rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2718		} else {
2719			rval = XFS_ILOG_CORE;
2720			error = xfs_bmbt_lookup_eq(cur, &right, &i);
2721			if (error)
2722				goto done;
2723			if (XFS_IS_CORRUPT(mp, i != 1)) {
2724				error = -EFSCORRUPTED;
2725				goto done;
2726			}
2727			error = xfs_btree_delete(cur, &i);
2728			if (error)
2729				goto done;
2730			if (XFS_IS_CORRUPT(mp, i != 1)) {
2731				error = -EFSCORRUPTED;
2732				goto done;
2733			}
2734			error = xfs_btree_decrement(cur, 0, &i);
2735			if (error)
2736				goto done;
2737			if (XFS_IS_CORRUPT(mp, i != 1)) {
2738				error = -EFSCORRUPTED;
2739				goto done;
2740			}
2741			error = xfs_bmbt_update(cur, &left);
2742			if (error)
2743				goto done;
2744		}
2745		break;
2746
2747	case BMAP_LEFT_CONTIG:
2748		/*
2749		 * New allocation is contiguous with a real allocation
2750		 * on the left.
2751		 * Merge the new allocation with the left neighbor.
2752		 */
2753		old = left;
2754		left.br_blockcount += new->br_blockcount;
2755
2756		xfs_iext_prev(ifp, icur);
2757		xfs_iext_update_extent(ip, state, icur, &left);
2758
2759		if (cur == NULL) {
2760			rval = xfs_ilog_fext(whichfork);
2761		} else {
2762			rval = 0;
2763			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2764			if (error)
2765				goto done;
2766			if (XFS_IS_CORRUPT(mp, i != 1)) {
2767				error = -EFSCORRUPTED;
2768				goto done;
2769			}
2770			error = xfs_bmbt_update(cur, &left);
2771			if (error)
2772				goto done;
2773		}
2774		break;
2775
2776	case BMAP_RIGHT_CONTIG:
2777		/*
2778		 * New allocation is contiguous with a real allocation
2779		 * on the right.
2780		 * Merge the new allocation with the right neighbor.
2781		 */
2782		old = right;
2783
2784		right.br_startoff = new->br_startoff;
2785		right.br_startblock = new->br_startblock;
2786		right.br_blockcount += new->br_blockcount;
2787		xfs_iext_update_extent(ip, state, icur, &right);
2788
2789		if (cur == NULL) {
2790			rval = xfs_ilog_fext(whichfork);
2791		} else {
2792			rval = 0;
2793			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2794			if (error)
2795				goto done;
2796			if (XFS_IS_CORRUPT(mp, i != 1)) {
2797				error = -EFSCORRUPTED;
2798				goto done;
2799			}
2800			error = xfs_bmbt_update(cur, &right);
2801			if (error)
2802				goto done;
2803		}
2804		break;
2805
2806	case 0:
2807		/*
2808		 * New allocation is not contiguous with another
2809		 * real allocation.
2810		 * Insert a new entry.
2811		 */
2812		xfs_iext_insert(ip, icur, new, state);
2813		ifp->if_nextents++;
2814
2815		if (cur == NULL) {
2816			rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2817		} else {
2818			rval = XFS_ILOG_CORE;
2819			error = xfs_bmbt_lookup_eq(cur, new, &i);
2820			if (error)
2821				goto done;
2822			if (XFS_IS_CORRUPT(mp, i != 0)) {
2823				error = -EFSCORRUPTED;
2824				goto done;
2825			}
2826			error = xfs_btree_insert(cur, &i);
2827			if (error)
2828				goto done;
2829			if (XFS_IS_CORRUPT(mp, i != 1)) {
2830				error = -EFSCORRUPTED;
2831				goto done;
2832			}
2833		}
2834		break;
2835	}
2836
2837	/* add reverse mapping unless caller opted out */
2838	if (!(flags & XFS_BMAPI_NORMAP))
2839		xfs_rmap_map_extent(tp, ip, whichfork, new);
2840
2841	/* convert to a btree if necessary */
2842	if (xfs_bmap_needs_btree(ip, whichfork)) {
2843		int	tmp_logflags;	/* partial log flag return val */
2844
2845		ASSERT(cur == NULL);
2846		error = xfs_bmap_extents_to_btree(tp, ip, curp, 0,
2847				&tmp_logflags, whichfork);
2848		*logflagsp |= tmp_logflags;
2849		cur = *curp;
2850		if (error)
2851			goto done;
2852	}
2853
2854	/* clear out the allocated field, done with it now in any case. */
2855	if (cur)
2856		cur->bc_ino.allocated = 0;
2857
2858	xfs_bmap_check_leaf_extents(cur, ip, whichfork);
2859done:
2860	*logflagsp |= rval;
2861	return error;
2862}
2863
2864/*
2865 * Functions used in the extent read, allocate and remove paths
2866 */
2867
2868/*
2869 * Adjust the size of the new extent based on i_extsize and rt extsize.
2870 */
2871int
2872xfs_bmap_extsize_align(
2873	xfs_mount_t	*mp,
2874	xfs_bmbt_irec_t	*gotp,		/* next extent pointer */
2875	xfs_bmbt_irec_t	*prevp,		/* previous extent pointer */
2876	xfs_extlen_t	extsz,		/* align to this extent size */
2877	int		rt,		/* is this a realtime inode? */
2878	int		eof,		/* is extent at end-of-file? */
2879	int		delay,		/* creating delalloc extent? */
2880	int		convert,	/* overwriting unwritten extent? */
2881	xfs_fileoff_t	*offp,		/* in/out: aligned offset */
2882	xfs_extlen_t	*lenp)		/* in/out: aligned length */
2883{
2884	xfs_fileoff_t	orig_off;	/* original offset */
2885	xfs_extlen_t	orig_alen;	/* original length */
2886	xfs_fileoff_t	orig_end;	/* original off+len */
2887	xfs_fileoff_t	nexto;		/* next file offset */
2888	xfs_fileoff_t	prevo;		/* previous file offset */
2889	xfs_fileoff_t	align_off;	/* temp for offset */
2890	xfs_extlen_t	align_alen;	/* temp for length */
2891	xfs_extlen_t	temp;		/* temp for calculations */
2892
2893	if (convert)
2894		return 0;
2895
2896	orig_off = align_off = *offp;
2897	orig_alen = align_alen = *lenp;
2898	orig_end = orig_off + orig_alen;
2899
2900	/*
2901	 * If this request overlaps an existing extent, then don't
2902	 * attempt to perform any additional alignment.
2903	 */
2904	if (!delay && !eof &&
2905	    (orig_off >= gotp->br_startoff) &&
2906	    (orig_end <= gotp->br_startoff + gotp->br_blockcount)) {
2907		return 0;
2908	}
2909
2910	/*
2911	 * If the file offset is unaligned vs. the extent size
2912	 * we need to align it.  This will be possible unless
2913	 * the file was previously written with a kernel that didn't
2914	 * perform this alignment, or if a truncate shot us in the
2915	 * foot.
2916	 */
2917	div_u64_rem(orig_off, extsz, &temp);
2918	if (temp) {
2919		align_alen += temp;
2920		align_off -= temp;
2921	}
2922
2923	/* Same adjustment for the end of the requested area. */
2924	temp = (align_alen % extsz);
2925	if (temp)
2926		align_alen += extsz - temp;
2927
2928	/*
2929	 * For large extent hint sizes, the aligned extent might be larger than
2930	 * XFS_BMBT_MAX_EXTLEN. In that case, reduce the size by an extsz so
2931	 * that it pulls the length back under XFS_BMBT_MAX_EXTLEN. The outer
2932	 * allocation loops handle short allocation just fine, so it is safe to
2933	 * do this. We only want to do it when we are forced to, though, because
2934	 * it means more allocation operations are required.
2935	 */
2936	while (align_alen > XFS_MAX_BMBT_EXTLEN)
2937		align_alen -= extsz;
2938	ASSERT(align_alen <= XFS_MAX_BMBT_EXTLEN);
2939
2940	/*
2941	 * If the previous block overlaps with this proposed allocation
2942	 * then move the start forward without adjusting the length.
2943	 */
2944	if (prevp->br_startoff != NULLFILEOFF) {
2945		if (prevp->br_startblock == HOLESTARTBLOCK)
2946			prevo = prevp->br_startoff;
2947		else
2948			prevo = prevp->br_startoff + prevp->br_blockcount;
2949	} else
2950		prevo = 0;
2951	if (align_off != orig_off && align_off < prevo)
2952		align_off = prevo;
2953	/*
2954	 * If the next block overlaps with this proposed allocation
2955	 * then move the start back without adjusting the length,
2956	 * but not before offset 0.
2957	 * This may of course make the start overlap previous block,
2958	 * and if we hit the offset 0 limit then the next block
2959	 * can still overlap too.
2960	 */
2961	if (!eof && gotp->br_startoff != NULLFILEOFF) {
2962		if ((delay && gotp->br_startblock == HOLESTARTBLOCK) ||
2963		    (!delay && gotp->br_startblock == DELAYSTARTBLOCK))
2964			nexto = gotp->br_startoff + gotp->br_blockcount;
2965		else
2966			nexto = gotp->br_startoff;
2967	} else
2968		nexto = NULLFILEOFF;
2969	if (!eof &&
2970	    align_off + align_alen != orig_end &&
2971	    align_off + align_alen > nexto)
2972		align_off = nexto > align_alen ? nexto - align_alen : 0;
2973	/*
2974	 * If we're now overlapping the next or previous extent that
2975	 * means we can't fit an extsz piece in this hole.  Just move
2976	 * the start forward to the first valid spot and set
2977	 * the length so we hit the end.
2978	 */
2979	if (align_off != orig_off && align_off < prevo)
2980		align_off = prevo;
2981	if (align_off + align_alen != orig_end &&
2982	    align_off + align_alen > nexto &&
2983	    nexto != NULLFILEOFF) {
2984		ASSERT(nexto > prevo);
2985		align_alen = nexto - align_off;
2986	}
2987
2988	/*
2989	 * If realtime, and the result isn't a multiple of the realtime
2990	 * extent size we need to remove blocks until it is.
2991	 */
2992	if (rt && (temp = xfs_extlen_to_rtxmod(mp, align_alen))) {
2993		/*
2994		 * We're not covering the original request, or
2995		 * we won't be able to once we fix the length.
2996		 */
2997		if (orig_off < align_off ||
2998		    orig_end > align_off + align_alen ||
2999		    align_alen - temp < orig_alen)
3000			return -EINVAL;
3001		/*
3002		 * Try to fix it by moving the start up.
3003		 */
3004		if (align_off + temp <= orig_off) {
3005			align_alen -= temp;
3006			align_off += temp;
3007		}
3008		/*
3009		 * Try to fix it by moving the end in.
3010		 */
3011		else if (align_off + align_alen - temp >= orig_end)
3012			align_alen -= temp;
3013		/*
3014		 * Set the start to the minimum then trim the length.
3015		 */
3016		else {
3017			align_alen -= orig_off - align_off;
3018			align_off = orig_off;
3019			align_alen -= xfs_extlen_to_rtxmod(mp, align_alen);
3020		}
3021		/*
3022		 * Result doesn't cover the request, fail it.
3023		 */
3024		if (orig_off < align_off || orig_end > align_off + align_alen)
3025			return -EINVAL;
3026	} else {
3027		ASSERT(orig_off >= align_off);
3028		/* see XFS_BMBT_MAX_EXTLEN handling above */
3029		ASSERT(orig_end <= align_off + align_alen ||
3030		       align_alen + extsz > XFS_MAX_BMBT_EXTLEN);
3031	}
3032
3033#ifdef DEBUG
3034	if (!eof && gotp->br_startoff != NULLFILEOFF)
3035		ASSERT(align_off + align_alen <= gotp->br_startoff);
3036	if (prevp->br_startoff != NULLFILEOFF)
3037		ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount);
3038#endif
3039
3040	*lenp = align_alen;
3041	*offp = align_off;
3042	return 0;
3043}
3044
3045#define XFS_ALLOC_GAP_UNITS	4
3046
3047/* returns true if ap->blkno was modified */
3048bool
3049xfs_bmap_adjacent(
3050	struct xfs_bmalloca	*ap)	/* bmap alloc argument struct */
3051{
3052	xfs_fsblock_t	adjust;		/* adjustment to block numbers */
 
3053	xfs_mount_t	*mp;		/* mount point structure */
 
3054	int		rt;		/* true if inode is realtime */
3055
3056#define	ISVALID(x,y)	\
3057	(rt ? \
3058		(x) < mp->m_sb.sb_rblocks : \
3059		XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
3060		XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
3061		XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
3062
3063	mp = ap->ip->i_mount;
 
3064	rt = XFS_IS_REALTIME_INODE(ap->ip) &&
3065		(ap->datatype & XFS_ALLOC_USERDATA);
 
 
3066	/*
3067	 * If allocating at eof, and there's a previous real block,
3068	 * try to use its last block as our starting point.
3069	 */
3070	if (ap->eof && ap->prev.br_startoff != NULLFILEOFF &&
3071	    !isnullstartblock(ap->prev.br_startblock) &&
3072	    ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount,
3073		    ap->prev.br_startblock)) {
3074		ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount;
3075		/*
3076		 * Adjust for the gap between prevp and us.
3077		 */
3078		adjust = ap->offset -
3079			(ap->prev.br_startoff + ap->prev.br_blockcount);
3080		if (adjust &&
3081		    ISVALID(ap->blkno + adjust, ap->prev.br_startblock))
3082			ap->blkno += adjust;
3083		return true;
3084	}
3085	/*
3086	 * If not at eof, then compare the two neighbor blocks.
3087	 * Figure out whether either one gives us a good starting point,
3088	 * and pick the better one.
3089	 */
3090	if (!ap->eof) {
3091		xfs_fsblock_t	gotbno;		/* right side block number */
3092		xfs_fsblock_t	gotdiff=0;	/* right side difference */
3093		xfs_fsblock_t	prevbno;	/* left side block number */
3094		xfs_fsblock_t	prevdiff=0;	/* left side difference */
3095
3096		/*
3097		 * If there's a previous (left) block, select a requested
3098		 * start block based on it.
3099		 */
3100		if (ap->prev.br_startoff != NULLFILEOFF &&
3101		    !isnullstartblock(ap->prev.br_startblock) &&
3102		    (prevbno = ap->prev.br_startblock +
3103			       ap->prev.br_blockcount) &&
3104		    ISVALID(prevbno, ap->prev.br_startblock)) {
3105			/*
3106			 * Calculate gap to end of previous block.
3107			 */
3108			adjust = prevdiff = ap->offset -
3109				(ap->prev.br_startoff +
3110				 ap->prev.br_blockcount);
3111			/*
3112			 * Figure the startblock based on the previous block's
3113			 * end and the gap size.
3114			 * Heuristic!
3115			 * If the gap is large relative to the piece we're
3116			 * allocating, or using it gives us an invalid block
3117			 * number, then just use the end of the previous block.
3118			 */
3119			if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3120			    ISVALID(prevbno + prevdiff,
3121				    ap->prev.br_startblock))
3122				prevbno += adjust;
3123			else
3124				prevdiff += adjust;
 
 
 
 
 
 
 
3125		}
3126		/*
3127		 * No previous block or can't follow it, just default.
3128		 */
3129		else
3130			prevbno = NULLFSBLOCK;
3131		/*
3132		 * If there's a following (right) block, select a requested
3133		 * start block based on it.
3134		 */
3135		if (!isnullstartblock(ap->got.br_startblock)) {
3136			/*
3137			 * Calculate gap to start of next block.
3138			 */
3139			adjust = gotdiff = ap->got.br_startoff - ap->offset;
3140			/*
3141			 * Figure the startblock based on the next block's
3142			 * start and the gap size.
3143			 */
3144			gotbno = ap->got.br_startblock;
3145			/*
3146			 * Heuristic!
3147			 * If the gap is large relative to the piece we're
3148			 * allocating, or using it gives us an invalid block
3149			 * number, then just use the start of the next block
3150			 * offset by our length.
3151			 */
3152			if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3153			    ISVALID(gotbno - gotdiff, gotbno))
3154				gotbno -= adjust;
3155			else if (ISVALID(gotbno - ap->length, gotbno)) {
3156				gotbno -= ap->length;
3157				gotdiff += adjust - ap->length;
3158			} else
3159				gotdiff += adjust;
 
 
 
 
 
 
 
3160		}
3161		/*
3162		 * No next block, just default.
3163		 */
3164		else
3165			gotbno = NULLFSBLOCK;
3166		/*
3167		 * If both valid, pick the better one, else the only good
3168		 * one, else ap->blkno is already set (to 0 or the inode block).
3169		 */
3170		if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) {
3171			ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno;
3172			return true;
3173		}
3174		if (prevbno != NULLFSBLOCK) {
3175			ap->blkno = prevbno;
3176			return true;
3177		}
3178		if (gotbno != NULLFSBLOCK) {
3179			ap->blkno = gotbno;
3180			return true;
3181		}
3182	}
3183#undef ISVALID
3184	return false;
3185}
3186
3187int
3188xfs_bmap_longest_free_extent(
3189	struct xfs_perag	*pag,
3190	struct xfs_trans	*tp,
3191	xfs_extlen_t		*blen)
 
 
3192{
 
 
3193	xfs_extlen_t		longest;
3194	int			error = 0;
3195
3196	if (!xfs_perag_initialised_agf(pag)) {
3197		error = xfs_alloc_read_agf(pag, tp, XFS_ALLOC_FLAG_TRYLOCK,
3198				NULL);
3199		if (error)
3200			return error;
 
 
 
 
 
 
3201	}
3202
3203	longest = xfs_alloc_longest_free_extent(pag,
3204				xfs_alloc_min_freelist(pag->pag_mount, pag),
3205				xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
3206	if (*blen < longest)
3207		*blen = longest;
3208
3209	return 0;
 
 
3210}
3211
3212static xfs_extlen_t
3213xfs_bmap_select_minlen(
3214	struct xfs_bmalloca	*ap,
3215	struct xfs_alloc_arg	*args,
3216	xfs_extlen_t		blen)
 
3217{
3218
3219	/*
3220	 * Since we used XFS_ALLOC_FLAG_TRYLOCK in _longest_free_extent(), it is
3221	 * possible that there is enough contiguous free space for this request.
3222	 */
3223	if (blen < ap->minlen)
3224		return ap->minlen;
3225
3226	/*
3227	 * If the best seen length is less than the request length,
3228	 * use the best as the minimum, otherwise we've got the maxlen we
3229	 * were asked for.
3230	 */
3231	if (blen < args->maxlen)
3232		return blen;
3233	return args->maxlen;
 
 
 
3234}
3235
3236static int
3237xfs_bmap_btalloc_select_lengths(
3238	struct xfs_bmalloca	*ap,
3239	struct xfs_alloc_arg	*args,
3240	xfs_extlen_t		*blen)
3241{
3242	struct xfs_mount	*mp = args->mp;
3243	struct xfs_perag	*pag;
3244	xfs_agnumber_t		agno, startag;
3245	int			error = 0;
3246
3247	if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3248		args->total = ap->minlen;
3249		args->minlen = ap->minlen;
3250		return 0;
3251	}
3252
 
3253	args->total = ap->total;
3254	startag = XFS_FSB_TO_AGNO(mp, ap->blkno);
 
3255	if (startag == NULLAGNUMBER)
3256		startag = 0;
3257
3258	*blen = 0;
3259	for_each_perag_wrap(mp, startag, agno, pag) {
3260		error = xfs_bmap_longest_free_extent(pag, args->tp, blen);
3261		if (error && error != -EAGAIN)
3262			break;
3263		error = 0;
3264		if (*blen >= args->maxlen)
 
 
3265			break;
3266	}
3267	if (pag)
3268		xfs_perag_rele(pag);
3269
3270	args->minlen = xfs_bmap_select_minlen(ap, args, *blen);
3271	return error;
3272}
3273
3274/* Update all inode and quota accounting for the allocation we just did. */
3275void
3276xfs_bmap_alloc_account(
3277	struct xfs_bmalloca	*ap)
 
3278{
3279	bool			isrt = XFS_IS_REALTIME_INODE(ap->ip) &&
3280					!(ap->flags & XFS_BMAPI_ATTRFORK);
3281	uint			fld;
 
 
 
 
3282
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3283	if (ap->flags & XFS_BMAPI_COWFORK) {
3284		/*
3285		 * COW fork blocks are in-core only and thus are treated as
3286		 * in-core quota reservation (like delalloc blocks) even when
3287		 * converted to real blocks. The quota reservation is not
3288		 * accounted to disk until blocks are remapped to the data
3289		 * fork. So if these blocks were previously delalloc, we
3290		 * already have quota reservation and there's nothing to do
3291		 * yet.
3292		 */
3293		if (ap->wasdel) {
3294			xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)ap->length);
3295			return;
3296		}
3297
3298		/*
3299		 * Otherwise, we've allocated blocks in a hole. The transaction
3300		 * has acquired in-core quota reservation for this extent.
3301		 * Rather than account these as real blocks, however, we reduce
3302		 * the transaction quota reservation based on the allocation.
3303		 * This essentially transfers the transaction quota reservation
3304		 * to that of a delalloc extent.
3305		 */
3306		ap->ip->i_delayed_blks += ap->length;
3307		xfs_trans_mod_dquot_byino(ap->tp, ap->ip, isrt ?
3308				XFS_TRANS_DQ_RES_RTBLKS : XFS_TRANS_DQ_RES_BLKS,
3309				-(long)ap->length);
3310		return;
3311	}
3312
3313	/* data/attr fork only */
3314	ap->ip->i_nblocks += ap->length;
3315	xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
3316	if (ap->wasdel) {
3317		ap->ip->i_delayed_blks -= ap->length;
3318		xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)ap->length);
3319		fld = isrt ? XFS_TRANS_DQ_DELRTBCOUNT : XFS_TRANS_DQ_DELBCOUNT;
3320	} else {
3321		fld = isrt ? XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
3322	}
3323
3324	xfs_trans_mod_dquot_byino(ap->tp, ap->ip, fld, ap->length);
 
3325}
3326
3327static int
3328xfs_bmap_compute_alignments(
3329	struct xfs_bmalloca	*ap,
3330	struct xfs_alloc_arg	*args)
3331{
3332	struct xfs_mount	*mp = args->mp;
3333	xfs_extlen_t		align = 0; /* minimum allocation alignment */
3334	int			stripe_align = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3335
3336	/* stripe alignment for allocation is determined by mount parameters */
3337	if (mp->m_swidth && xfs_has_swalloc(mp))
 
3338		stripe_align = mp->m_swidth;
3339	else if (mp->m_dalign)
3340		stripe_align = mp->m_dalign;
3341
3342	if (ap->flags & XFS_BMAPI_COWFORK)
3343		align = xfs_get_cowextsz_hint(ap->ip);
3344	else if (ap->datatype & XFS_ALLOC_USERDATA)
3345		align = xfs_get_extsz_hint(ap->ip);
3346	if (align) {
3347		if (xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, align, 0,
3348					ap->eof, 0, ap->conv, &ap->offset,
3349					&ap->length))
3350			ASSERT(0);
3351		ASSERT(ap->length);
3352	}
3353
3354	/* apply extent size hints if obtained earlier */
3355	if (align) {
3356		args->prod = align;
3357		div_u64_rem(ap->offset, args->prod, &args->mod);
3358		if (args->mod)
3359			args->mod = args->prod - args->mod;
3360	} else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) {
3361		args->prod = 1;
3362		args->mod = 0;
3363	} else {
3364		args->prod = PAGE_SIZE >> mp->m_sb.sb_blocklog;
3365		div_u64_rem(ap->offset, args->prod, &args->mod);
3366		if (args->mod)
3367			args->mod = args->prod - args->mod;
3368	}
3369
3370	return stripe_align;
3371}
3372
3373static void
3374xfs_bmap_process_allocated_extent(
3375	struct xfs_bmalloca	*ap,
3376	struct xfs_alloc_arg	*args,
3377	xfs_fileoff_t		orig_offset,
3378	xfs_extlen_t		orig_length)
3379{
3380	ap->blkno = args->fsbno;
3381	ap->length = args->len;
3382	/*
3383	 * If the extent size hint is active, we tried to round the
3384	 * caller's allocation request offset down to extsz and the
3385	 * length up to another extsz boundary.  If we found a free
3386	 * extent we mapped it in starting at this new offset.  If the
3387	 * newly mapped space isn't long enough to cover any of the
3388	 * range of offsets that was originally requested, move the
3389	 * mapping up so that we can fill as much of the caller's
3390	 * original request as possible.  Free space is apparently
3391	 * very fragmented so we're unlikely to be able to satisfy the
3392	 * hints anyway.
3393	 */
3394	if (ap->length <= orig_length)
3395		ap->offset = orig_offset;
3396	else if (ap->offset + ap->length < orig_offset + orig_length)
3397		ap->offset = orig_offset + orig_length - ap->length;
3398	xfs_bmap_alloc_account(ap);
3399}
3400
3401#ifdef DEBUG
3402static int
3403xfs_bmap_exact_minlen_extent_alloc(
3404	struct xfs_bmalloca	*ap)
3405{
3406	struct xfs_mount	*mp = ap->ip->i_mount;
3407	struct xfs_alloc_arg	args = { .tp = ap->tp, .mp = mp };
3408	xfs_fileoff_t		orig_offset;
3409	xfs_extlen_t		orig_length;
3410	int			error;
3411
3412	ASSERT(ap->length);
3413
3414	if (ap->minlen != 1) {
3415		ap->blkno = NULLFSBLOCK;
3416		ap->length = 0;
3417		return 0;
3418	}
3419
3420	orig_offset = ap->offset;
3421	orig_length = ap->length;
3422
3423	args.alloc_minlen_only = 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
3424
3425	xfs_bmap_compute_alignments(ap, &args);
3426
3427	/*
3428	 * Unlike the longest extent available in an AG, we don't track
3429	 * the length of an AG's shortest extent.
3430	 * XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and
3431	 * hence we can afford to start traversing from the 0th AG since
3432	 * we need not be concerned about a drop in performance in
3433	 * "debug only" code paths.
3434	 */
3435	ap->blkno = XFS_AGB_TO_FSB(mp, 0, 0);
3436
 
 
 
 
 
 
 
 
 
 
3437	args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
3438	args.minlen = args.maxlen = ap->minlen;
3439	args.total = ap->total;
3440
3441	args.alignment = 1;
3442	args.minalignslop = 0;
3443
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3444	args.minleft = ap->minleft;
3445	args.wasdel = ap->wasdel;
3446	args.resv = XFS_AG_RESV_NONE;
3447	args.datatype = ap->datatype;
3448
3449	error = xfs_alloc_vextent_first_ag(&args, ap->blkno);
3450	if (error)
3451		return error;
3452
3453	if (args.fsbno != NULLFSBLOCK) {
3454		xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3455			orig_length);
3456	} else {
3457		ap->blkno = NULLFSBLOCK;
3458		ap->length = 0;
3459	}
3460
3461	return 0;
3462}
3463#else
3464
3465#define xfs_bmap_exact_minlen_extent_alloc(bma) (-EFSCORRUPTED)
3466
3467#endif
3468
3469/*
3470 * If we are not low on available data blocks and we are allocating at
3471 * EOF, optimise allocation for contiguous file extension and/or stripe
3472 * alignment of the new extent.
3473 *
3474 * NOTE: ap->aeof is only set if the allocation length is >= the
3475 * stripe unit and the allocation offset is at the end of file.
3476 */
3477static int
3478xfs_bmap_btalloc_at_eof(
3479	struct xfs_bmalloca	*ap,
3480	struct xfs_alloc_arg	*args,
3481	xfs_extlen_t		blen,
3482	int			stripe_align,
3483	bool			ag_only)
3484{
3485	struct xfs_mount	*mp = args->mp;
3486	struct xfs_perag	*caller_pag = args->pag;
3487	int			error;
3488
3489	/*
3490	 * If there are already extents in the file, try an exact EOF block
3491	 * allocation to extend the file as a contiguous extent. If that fails,
3492	 * or it's the first allocation in a file, just try for a stripe aligned
3493	 * allocation.
3494	 */
3495	if (ap->offset) {
3496		xfs_extlen_t	nextminlen = 0;
3497
3498		/*
3499		 * Compute the minlen+alignment for the next case.  Set slop so
3500		 * that the value of minlen+alignment+slop doesn't go up between
3501		 * the calls.
3502		 */
3503		args->alignment = 1;
3504		if (blen > stripe_align && blen <= args->maxlen)
3505			nextminlen = blen - stripe_align;
3506		else
3507			nextminlen = args->minlen;
3508		if (nextminlen + stripe_align > args->minlen + 1)
3509			args->minalignslop = nextminlen + stripe_align -
3510					args->minlen - 1;
3511		else
3512			args->minalignslop = 0;
3513
3514		if (!caller_pag)
3515			args->pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, ap->blkno));
3516		error = xfs_alloc_vextent_exact_bno(args, ap->blkno);
3517		if (!caller_pag) {
3518			xfs_perag_put(args->pag);
3519			args->pag = NULL;
3520		}
3521		if (error)
3522			return error;
3523
3524		if (args->fsbno != NULLFSBLOCK)
3525			return 0;
3526		/*
3527		 * Exact allocation failed. Reset to try an aligned allocation
3528		 * according to the original allocation specification.
3529		 */
3530		args->alignment = stripe_align;
3531		args->minlen = nextminlen;
3532		args->minalignslop = 0;
3533	} else {
 
 
 
 
 
 
3534		/*
3535		 * Adjust minlen to try and preserve alignment if we
3536		 * can't guarantee an aligned maxlen extent.
3537		 */
3538		args->alignment = stripe_align;
3539		if (blen > args->alignment &&
3540		    blen <= args->maxlen + args->alignment)
3541			args->minlen = blen - args->alignment;
3542		args->minalignslop = 0;
3543	}
3544
3545	if (ag_only) {
3546		error = xfs_alloc_vextent_near_bno(args, ap->blkno);
3547	} else {
3548		args->pag = NULL;
3549		error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3550		ASSERT(args->pag == NULL);
3551		args->pag = caller_pag;
3552	}
3553	if (error)
3554		return error;
3555
3556	if (args->fsbno != NULLFSBLOCK)
3557		return 0;
3558
3559	/*
3560	 * Allocation failed, so turn return the allocation args to their
3561	 * original non-aligned state so the caller can proceed on allocation
3562	 * failure as if this function was never called.
3563	 */
3564	args->alignment = 1;
3565	return 0;
3566}
3567
3568/*
3569 * We have failed multiple allocation attempts so now are in a low space
3570 * allocation situation. Try a locality first full filesystem minimum length
3571 * allocation whilst still maintaining necessary total block reservation
3572 * requirements.
3573 *
3574 * If that fails, we are now critically low on space, so perform a last resort
3575 * allocation attempt: no reserve, no locality, blocking, minimum length, full
3576 * filesystem free space scan. We also indicate to future allocations in this
3577 * transaction that we are critically low on space so they don't waste time on
3578 * allocation modes that are unlikely to succeed.
3579 */
3580int
3581xfs_bmap_btalloc_low_space(
3582	struct xfs_bmalloca	*ap,
3583	struct xfs_alloc_arg	*args)
3584{
3585	int			error;
3586
3587	if (args->minlen > ap->minlen) {
3588		args->minlen = ap->minlen;
3589		error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3590		if (error || args->fsbno != NULLFSBLOCK)
3591			return error;
3592	}
3593
3594	/* Last ditch attempt before failure is declared. */
3595	args->total = ap->minlen;
3596	error = xfs_alloc_vextent_first_ag(args, 0);
3597	if (error)
3598		return error;
3599	ap->tp->t_flags |= XFS_TRANS_LOWMODE;
3600	return 0;
3601}
3602
3603static int
3604xfs_bmap_btalloc_filestreams(
3605	struct xfs_bmalloca	*ap,
3606	struct xfs_alloc_arg	*args,
3607	int			stripe_align)
3608{
3609	xfs_extlen_t		blen = 0;
3610	int			error = 0;
3611
3612
3613	error = xfs_filestream_select_ag(ap, args, &blen);
3614	if (error)
3615		return error;
3616	ASSERT(args->pag);
3617
3618	/*
3619	 * If we are in low space mode, then optimal allocation will fail so
3620	 * prepare for minimal allocation and jump to the low space algorithm
3621	 * immediately.
3622	 */
3623	if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3624		args->minlen = ap->minlen;
3625		ASSERT(args->fsbno == NULLFSBLOCK);
3626		goto out_low_space;
3627	}
3628
3629	args->minlen = xfs_bmap_select_minlen(ap, args, blen);
3630	if (ap->aeof)
3631		error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align,
3632				true);
3633
3634	if (!error && args->fsbno == NULLFSBLOCK)
3635		error = xfs_alloc_vextent_near_bno(args, ap->blkno);
3636
3637out_low_space:
3638	/*
3639	 * We are now done with the perag reference for the filestreams
3640	 * association provided by xfs_filestream_select_ag(). Release it now as
3641	 * we've either succeeded, had a fatal error or we are out of space and
3642	 * need to do a full filesystem scan for free space which will take it's
3643	 * own references.
3644	 */
3645	xfs_perag_rele(args->pag);
3646	args->pag = NULL;
3647	if (error || args->fsbno != NULLFSBLOCK)
3648		return error;
3649
3650	return xfs_bmap_btalloc_low_space(ap, args);
3651}
3652
3653static int
3654xfs_bmap_btalloc_best_length(
3655	struct xfs_bmalloca	*ap,
3656	struct xfs_alloc_arg	*args,
3657	int			stripe_align)
3658{
3659	xfs_extlen_t		blen = 0;
3660	int			error;
3661
3662	ap->blkno = XFS_INO_TO_FSB(args->mp, ap->ip->i_ino);
3663	xfs_bmap_adjacent(ap);
3664
3665	/*
3666	 * Search for an allocation group with a single extent large enough for
3667	 * the request.  If one isn't found, then adjust the minimum allocation
3668	 * size to the largest space found.
3669	 */
3670	error = xfs_bmap_btalloc_select_lengths(ap, args, &blen);
3671	if (error)
3672		return error;
3673
3674	/*
3675	 * Don't attempt optimal EOF allocation if previous allocations barely
3676	 * succeeded due to being near ENOSPC. It is highly unlikely we'll get
3677	 * optimal or even aligned allocations in this case, so don't waste time
3678	 * trying.
3679	 */
3680	if (ap->aeof && !(ap->tp->t_flags & XFS_TRANS_LOWMODE)) {
3681		error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align,
3682				false);
3683		if (error || args->fsbno != NULLFSBLOCK)
3684			return error;
 
3685	}
3686
3687	error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3688	if (error || args->fsbno != NULLFSBLOCK)
3689		return error;
3690
3691	return xfs_bmap_btalloc_low_space(ap, args);
3692}
3693
3694static int
3695xfs_bmap_btalloc(
3696	struct xfs_bmalloca	*ap)
3697{
3698	struct xfs_mount	*mp = ap->ip->i_mount;
3699	struct xfs_alloc_arg	args = {
3700		.tp		= ap->tp,
3701		.mp		= mp,
3702		.fsbno		= NULLFSBLOCK,
3703		.oinfo		= XFS_RMAP_OINFO_SKIP_UPDATE,
3704		.minleft	= ap->minleft,
3705		.wasdel		= ap->wasdel,
3706		.resv		= XFS_AG_RESV_NONE,
3707		.datatype	= ap->datatype,
3708		.alignment	= 1,
3709		.minalignslop	= 0,
3710	};
3711	xfs_fileoff_t		orig_offset;
3712	xfs_extlen_t		orig_length;
3713	int			error;
3714	int			stripe_align;
3715
3716	ASSERT(ap->length);
3717	orig_offset = ap->offset;
3718	orig_length = ap->length;
3719
3720	stripe_align = xfs_bmap_compute_alignments(ap, &args);
3721
3722	/* Trim the allocation back to the maximum an AG can fit. */
3723	args.maxlen = min(ap->length, mp->m_ag_max_usable);
3724
3725	if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3726	    xfs_inode_is_filestream(ap->ip))
3727		error = xfs_bmap_btalloc_filestreams(ap, &args, stripe_align);
3728	else
3729		error = xfs_bmap_btalloc_best_length(ap, &args, stripe_align);
3730	if (error)
3731		return error;
3732
3733	if (args.fsbno != NULLFSBLOCK) {
3734		xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3735			orig_length);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3736	} else {
3737		ap->blkno = NULLFSBLOCK;
3738		ap->length = 0;
3739	}
3740	return 0;
3741}
3742
3743/* Trim extent to fit a logical block range. */
3744void
3745xfs_trim_extent(
3746	struct xfs_bmbt_irec	*irec,
3747	xfs_fileoff_t		bno,
3748	xfs_filblks_t		len)
3749{
3750	xfs_fileoff_t		distance;
3751	xfs_fileoff_t		end = bno + len;
3752
3753	if (irec->br_startoff + irec->br_blockcount <= bno ||
3754	    irec->br_startoff >= end) {
3755		irec->br_blockcount = 0;
3756		return;
3757	}
3758
3759	if (irec->br_startoff < bno) {
3760		distance = bno - irec->br_startoff;
3761		if (isnullstartblock(irec->br_startblock))
3762			irec->br_startblock = DELAYSTARTBLOCK;
3763		if (irec->br_startblock != DELAYSTARTBLOCK &&
3764		    irec->br_startblock != HOLESTARTBLOCK)
3765			irec->br_startblock += distance;
3766		irec->br_startoff += distance;
3767		irec->br_blockcount -= distance;
3768	}
3769
3770	if (end < irec->br_startoff + irec->br_blockcount) {
3771		distance = irec->br_startoff + irec->br_blockcount - end;
3772		irec->br_blockcount -= distance;
3773	}
3774}
3775
3776/*
3777 * Trim the returned map to the required bounds
3778 */
3779STATIC void
3780xfs_bmapi_trim_map(
3781	struct xfs_bmbt_irec	*mval,
3782	struct xfs_bmbt_irec	*got,
3783	xfs_fileoff_t		*bno,
3784	xfs_filblks_t		len,
3785	xfs_fileoff_t		obno,
3786	xfs_fileoff_t		end,
3787	int			n,
3788	uint32_t		flags)
3789{
3790	if ((flags & XFS_BMAPI_ENTIRE) ||
3791	    got->br_startoff + got->br_blockcount <= obno) {
3792		*mval = *got;
3793		if (isnullstartblock(got->br_startblock))
3794			mval->br_startblock = DELAYSTARTBLOCK;
3795		return;
3796	}
3797
3798	if (obno > *bno)
3799		*bno = obno;
3800	ASSERT((*bno >= obno) || (n == 0));
3801	ASSERT(*bno < end);
3802	mval->br_startoff = *bno;
3803	if (isnullstartblock(got->br_startblock))
3804		mval->br_startblock = DELAYSTARTBLOCK;
3805	else
3806		mval->br_startblock = got->br_startblock +
3807					(*bno - got->br_startoff);
3808	/*
3809	 * Return the minimum of what we got and what we asked for for
3810	 * the length.  We can use the len variable here because it is
3811	 * modified below and we could have been there before coming
3812	 * here if the first part of the allocation didn't overlap what
3813	 * was asked for.
3814	 */
3815	mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno,
3816			got->br_blockcount - (*bno - got->br_startoff));
3817	mval->br_state = got->br_state;
3818	ASSERT(mval->br_blockcount <= len);
3819	return;
3820}
3821
3822/*
3823 * Update and validate the extent map to return
3824 */
3825STATIC void
3826xfs_bmapi_update_map(
3827	struct xfs_bmbt_irec	**map,
3828	xfs_fileoff_t		*bno,
3829	xfs_filblks_t		*len,
3830	xfs_fileoff_t		obno,
3831	xfs_fileoff_t		end,
3832	int			*n,
3833	uint32_t		flags)
3834{
3835	xfs_bmbt_irec_t	*mval = *map;
3836
3837	ASSERT((flags & XFS_BMAPI_ENTIRE) ||
3838	       ((mval->br_startoff + mval->br_blockcount) <= end));
3839	ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) ||
3840	       (mval->br_startoff < obno));
3841
3842	*bno = mval->br_startoff + mval->br_blockcount;
3843	*len = end - *bno;
3844	if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) {
3845		/* update previous map with new information */
3846		ASSERT(mval->br_startblock == mval[-1].br_startblock);
3847		ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
3848		ASSERT(mval->br_state == mval[-1].br_state);
3849		mval[-1].br_blockcount = mval->br_blockcount;
3850		mval[-1].br_state = mval->br_state;
3851	} else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
3852		   mval[-1].br_startblock != DELAYSTARTBLOCK &&
3853		   mval[-1].br_startblock != HOLESTARTBLOCK &&
3854		   mval->br_startblock == mval[-1].br_startblock +
3855					  mval[-1].br_blockcount &&
3856		   mval[-1].br_state == mval->br_state) {
3857		ASSERT(mval->br_startoff ==
3858		       mval[-1].br_startoff + mval[-1].br_blockcount);
3859		mval[-1].br_blockcount += mval->br_blockcount;
3860	} else if (*n > 0 &&
3861		   mval->br_startblock == DELAYSTARTBLOCK &&
3862		   mval[-1].br_startblock == DELAYSTARTBLOCK &&
3863		   mval->br_startoff ==
3864		   mval[-1].br_startoff + mval[-1].br_blockcount) {
3865		mval[-1].br_blockcount += mval->br_blockcount;
3866		mval[-1].br_state = mval->br_state;
3867	} else if (!((*n == 0) &&
3868		     ((mval->br_startoff + mval->br_blockcount) <=
3869		      obno))) {
3870		mval++;
3871		(*n)++;
3872	}
3873	*map = mval;
3874}
3875
3876/*
3877 * Map file blocks to filesystem blocks without allocation.
3878 */
3879int
3880xfs_bmapi_read(
3881	struct xfs_inode	*ip,
3882	xfs_fileoff_t		bno,
3883	xfs_filblks_t		len,
3884	struct xfs_bmbt_irec	*mval,
3885	int			*nmap,
3886	uint32_t		flags)
3887{
3888	struct xfs_mount	*mp = ip->i_mount;
3889	int			whichfork = xfs_bmapi_whichfork(flags);
3890	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
3891	struct xfs_bmbt_irec	got;
3892	xfs_fileoff_t		obno;
3893	xfs_fileoff_t		end;
3894	struct xfs_iext_cursor	icur;
3895	int			error;
3896	bool			eof = false;
3897	int			n = 0;
3898
3899	ASSERT(*nmap >= 1);
3900	ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_ENTIRE)));
3901	ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL));
3902
3903	if (WARN_ON_ONCE(!ifp))
3904		return -EFSCORRUPTED;
3905
3906	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
3907	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT))
3908		return -EFSCORRUPTED;
3909
3910	if (xfs_is_shutdown(mp))
3911		return -EIO;
3912
3913	XFS_STATS_INC(mp, xs_blk_mapr);
3914
3915	error = xfs_iread_extents(NULL, ip, whichfork);
3916	if (error)
3917		return error;
 
 
3918
3919	if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
3920		eof = true;
3921	end = bno + len;
3922	obno = bno;
3923
3924	while (bno < end && n < *nmap) {
3925		/* Reading past eof, act as though there's a hole up to end. */
3926		if (eof)
3927			got.br_startoff = end;
3928		if (got.br_startoff > bno) {
3929			/* Reading in a hole.  */
3930			mval->br_startoff = bno;
3931			mval->br_startblock = HOLESTARTBLOCK;
3932			mval->br_blockcount =
3933				XFS_FILBLKS_MIN(len, got.br_startoff - bno);
3934			mval->br_state = XFS_EXT_NORM;
3935			bno += mval->br_blockcount;
3936			len -= mval->br_blockcount;
3937			mval++;
3938			n++;
3939			continue;
3940		}
3941
3942		/* set up the extent map to return. */
3943		xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
3944		xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
3945
3946		/* If we're done, stop now. */
3947		if (bno >= end || n >= *nmap)
3948			break;
3949
3950		/* Else go on to the next record. */
3951		if (!xfs_iext_next_extent(ifp, &icur, &got))
3952			eof = true;
3953	}
3954	*nmap = n;
3955	return 0;
3956}
3957
3958/*
3959 * Add a delayed allocation extent to an inode. Blocks are reserved from the
3960 * global pool and the extent inserted into the inode in-core extent tree.
3961 *
3962 * On entry, got refers to the first extent beyond the offset of the extent to
3963 * allocate or eof is specified if no such extent exists. On return, got refers
3964 * to the extent record that was inserted to the inode fork.
3965 *
3966 * Note that the allocated extent may have been merged with contiguous extents
3967 * during insertion into the inode fork. Thus, got does not reflect the current
3968 * state of the inode fork on return. If necessary, the caller can use lastx to
3969 * look up the updated record in the inode fork.
3970 */
3971int
3972xfs_bmapi_reserve_delalloc(
3973	struct xfs_inode	*ip,
3974	int			whichfork,
3975	xfs_fileoff_t		off,
3976	xfs_filblks_t		len,
3977	xfs_filblks_t		prealloc,
3978	struct xfs_bmbt_irec	*got,
3979	struct xfs_iext_cursor	*icur,
3980	int			eof)
3981{
3982	struct xfs_mount	*mp = ip->i_mount;
3983	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
3984	xfs_extlen_t		alen;
3985	xfs_extlen_t		indlen;
3986	int			error;
3987	xfs_fileoff_t		aoff = off;
3988
3989	/*
3990	 * Cap the alloc length. Keep track of prealloc so we know whether to
3991	 * tag the inode before we return.
3992	 */
3993	alen = XFS_FILBLKS_MIN(len + prealloc, XFS_MAX_BMBT_EXTLEN);
3994	if (!eof)
3995		alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
3996	if (prealloc && alen >= len)
3997		prealloc = alen - len;
3998
3999	/* Figure out the extent size, adjust alen */
4000	if (whichfork == XFS_COW_FORK) {
4001		struct xfs_bmbt_irec	prev;
4002		xfs_extlen_t		extsz = xfs_get_cowextsz_hint(ip);
4003
4004		if (!xfs_iext_peek_prev_extent(ifp, icur, &prev))
4005			prev.br_startoff = NULLFILEOFF;
4006
4007		error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof,
4008					       1, 0, &aoff, &alen);
4009		ASSERT(!error);
4010	}
4011
4012	/*
4013	 * Make a transaction-less quota reservation for delayed allocation
4014	 * blocks.  This number gets adjusted later.  We return if we haven't
4015	 * allocated blocks already inside this loop.
4016	 */
4017	error = xfs_quota_reserve_blkres(ip, alen);
 
4018	if (error)
4019		return error;
4020
4021	/*
4022	 * Split changing sb for alen and indlen since they could be coming
4023	 * from different places.
4024	 */
4025	indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen);
4026	ASSERT(indlen > 0);
4027
4028	error = xfs_mod_fdblocks(mp, -((int64_t)alen), false);
4029	if (error)
4030		goto out_unreserve_quota;
4031
4032	error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false);
4033	if (error)
4034		goto out_unreserve_blocks;
4035
4036
4037	ip->i_delayed_blks += alen;
4038	xfs_mod_delalloc(ip->i_mount, alen + indlen);
4039
4040	got->br_startoff = aoff;
4041	got->br_startblock = nullstartblock(indlen);
4042	got->br_blockcount = alen;
4043	got->br_state = XFS_EXT_NORM;
4044
4045	xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got);
4046
4047	/*
4048	 * Tag the inode if blocks were preallocated. Note that COW fork
4049	 * preallocation can occur at the start or end of the extent, even when
4050	 * prealloc == 0, so we must also check the aligned offset and length.
4051	 */
4052	if (whichfork == XFS_DATA_FORK && prealloc)
4053		xfs_inode_set_eofblocks_tag(ip);
4054	if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len))
4055		xfs_inode_set_cowblocks_tag(ip);
4056
4057	return 0;
4058
4059out_unreserve_blocks:
4060	xfs_mod_fdblocks(mp, alen, false);
4061out_unreserve_quota:
4062	if (XFS_IS_QUOTA_ON(mp))
4063		xfs_quota_unreserve_blkres(ip, alen);
 
4064	return error;
4065}
4066
4067static int
4068xfs_bmap_alloc_userdata(
4069	struct xfs_bmalloca	*bma)
4070{
4071	struct xfs_mount	*mp = bma->ip->i_mount;
4072	int			whichfork = xfs_bmapi_whichfork(bma->flags);
4073	int			error;
4074
4075	/*
4076	 * Set the data type being allocated. For the data fork, the first data
4077	 * in the file is treated differently to all other allocations. For the
4078	 * attribute fork, we only need to ensure the allocated range is not on
4079	 * the busy list.
4080	 */
4081	bma->datatype = XFS_ALLOC_NOBUSY;
4082	if (whichfork == XFS_DATA_FORK || whichfork == XFS_COW_FORK) {
4083		bma->datatype |= XFS_ALLOC_USERDATA;
4084		if (bma->offset == 0)
4085			bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA;
4086
4087		if (mp->m_dalign && bma->length >= mp->m_dalign) {
4088			error = xfs_bmap_isaeof(bma, whichfork);
4089			if (error)
4090				return error;
4091		}
4092
4093		if (XFS_IS_REALTIME_INODE(bma->ip))
4094			return xfs_bmap_rtalloc(bma);
4095	}
4096
4097	if (unlikely(XFS_TEST_ERROR(false, mp,
4098			XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4099		return xfs_bmap_exact_minlen_extent_alloc(bma);
4100
4101	return xfs_bmap_btalloc(bma);
4102}
4103
4104static int
4105xfs_bmapi_allocate(
4106	struct xfs_bmalloca	*bma)
4107{
4108	struct xfs_mount	*mp = bma->ip->i_mount;
4109	int			whichfork = xfs_bmapi_whichfork(bma->flags);
4110	struct xfs_ifork	*ifp = xfs_ifork_ptr(bma->ip, whichfork);
4111	int			tmp_logflags = 0;
4112	int			error;
4113
4114	ASSERT(bma->length > 0);
4115
4116	/*
4117	 * For the wasdelay case, we could also just allocate the stuff asked
4118	 * for in this bmap call but that wouldn't be as good.
4119	 */
4120	if (bma->wasdel) {
4121		bma->length = (xfs_extlen_t)bma->got.br_blockcount;
4122		bma->offset = bma->got.br_startoff;
4123		if (!xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev))
4124			bma->prev.br_startoff = NULLFILEOFF;
4125	} else {
4126		bma->length = XFS_FILBLKS_MIN(bma->length, XFS_MAX_BMBT_EXTLEN);
4127		if (!bma->eof)
4128			bma->length = XFS_FILBLKS_MIN(bma->length,
4129					bma->got.br_startoff - bma->offset);
4130	}
4131
4132	if (bma->flags & XFS_BMAPI_CONTIG)
4133		bma->minlen = bma->length;
4134	else
4135		bma->minlen = 1;
4136
4137	if (bma->flags & XFS_BMAPI_METADATA) {
4138		if (unlikely(XFS_TEST_ERROR(false, mp,
4139				XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4140			error = xfs_bmap_exact_minlen_extent_alloc(bma);
4141		else
4142			error = xfs_bmap_btalloc(bma);
4143	} else {
4144		error = xfs_bmap_alloc_userdata(bma);
4145	}
4146	if (error || bma->blkno == NULLFSBLOCK)
4147		return error;
4148
4149	if (bma->flags & XFS_BMAPI_ZERO) {
4150		error = xfs_zero_extent(bma->ip, bma->blkno, bma->length);
4151		if (error)
4152			return error;
4153	}
4154
4155	if (ifp->if_format == XFS_DINODE_FMT_BTREE && !bma->cur)
4156		bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
4157	/*
4158	 * Bump the number of extents we've allocated
4159	 * in this call.
4160	 */
4161	bma->nallocs++;
4162
4163	if (bma->cur)
4164		bma->cur->bc_ino.flags =
4165			bma->wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
4166
4167	bma->got.br_startoff = bma->offset;
4168	bma->got.br_startblock = bma->blkno;
4169	bma->got.br_blockcount = bma->length;
4170	bma->got.br_state = XFS_EXT_NORM;
4171
4172	if (bma->flags & XFS_BMAPI_PREALLOC)
4173		bma->got.br_state = XFS_EXT_UNWRITTEN;
4174
4175	if (bma->wasdel)
4176		error = xfs_bmap_add_extent_delay_real(bma, whichfork);
4177	else
4178		error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip,
4179				whichfork, &bma->icur, &bma->cur, &bma->got,
4180				&bma->logflags, bma->flags);
4181
4182	bma->logflags |= tmp_logflags;
4183	if (error)
4184		return error;
4185
4186	/*
4187	 * Update our extent pointer, given that xfs_bmap_add_extent_delay_real
4188	 * or xfs_bmap_add_extent_hole_real might have merged it into one of
4189	 * the neighbouring ones.
4190	 */
4191	xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4192
4193	ASSERT(bma->got.br_startoff <= bma->offset);
4194	ASSERT(bma->got.br_startoff + bma->got.br_blockcount >=
4195	       bma->offset + bma->length);
4196	ASSERT(bma->got.br_state == XFS_EXT_NORM ||
4197	       bma->got.br_state == XFS_EXT_UNWRITTEN);
4198	return 0;
4199}
4200
4201STATIC int
4202xfs_bmapi_convert_unwritten(
4203	struct xfs_bmalloca	*bma,
4204	struct xfs_bmbt_irec	*mval,
4205	xfs_filblks_t		len,
4206	uint32_t		flags)
4207{
4208	int			whichfork = xfs_bmapi_whichfork(flags);
4209	struct xfs_ifork	*ifp = xfs_ifork_ptr(bma->ip, whichfork);
4210	int			tmp_logflags = 0;
4211	int			error;
4212
4213	/* check if we need to do unwritten->real conversion */
4214	if (mval->br_state == XFS_EXT_UNWRITTEN &&
4215	    (flags & XFS_BMAPI_PREALLOC))
4216		return 0;
4217
4218	/* check if we need to do real->unwritten conversion */
4219	if (mval->br_state == XFS_EXT_NORM &&
4220	    (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) !=
4221			(XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT))
4222		return 0;
4223
4224	/*
4225	 * Modify (by adding) the state flag, if writing.
4226	 */
4227	ASSERT(mval->br_blockcount <= len);
4228	if (ifp->if_format == XFS_DINODE_FMT_BTREE && !bma->cur) {
4229		bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
4230					bma->ip, whichfork);
4231	}
4232	mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
4233				? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
4234
4235	/*
4236	 * Before insertion into the bmbt, zero the range being converted
4237	 * if required.
4238	 */
4239	if (flags & XFS_BMAPI_ZERO) {
4240		error = xfs_zero_extent(bma->ip, mval->br_startblock,
4241					mval->br_blockcount);
4242		if (error)
4243			return error;
4244	}
4245
4246	error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork,
4247			&bma->icur, &bma->cur, mval, &tmp_logflags);
4248	/*
4249	 * Log the inode core unconditionally in the unwritten extent conversion
4250	 * path because the conversion might not have done so (e.g., if the
4251	 * extent count hasn't changed). We need to make sure the inode is dirty
4252	 * in the transaction for the sake of fsync(), even if nothing has
4253	 * changed, because fsync() will not force the log for this transaction
4254	 * unless it sees the inode pinned.
4255	 *
4256	 * Note: If we're only converting cow fork extents, there aren't
4257	 * any on-disk updates to make, so we don't need to log anything.
4258	 */
4259	if (whichfork != XFS_COW_FORK)
4260		bma->logflags |= tmp_logflags | XFS_ILOG_CORE;
4261	if (error)
4262		return error;
4263
4264	/*
4265	 * Update our extent pointer, given that
4266	 * xfs_bmap_add_extent_unwritten_real might have merged it into one
4267	 * of the neighbouring ones.
4268	 */
4269	xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4270
4271	/*
4272	 * We may have combined previously unwritten space with written space,
4273	 * so generate another request.
4274	 */
4275	if (mval->br_blockcount < len)
4276		return -EAGAIN;
4277	return 0;
4278}
4279
4280xfs_extlen_t
4281xfs_bmapi_minleft(
4282	struct xfs_trans	*tp,
4283	struct xfs_inode	*ip,
4284	int			fork)
4285{
4286	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, fork);
4287
4288	if (tp && tp->t_highest_agno != NULLAGNUMBER)
4289		return 0;
4290	if (ifp->if_format != XFS_DINODE_FMT_BTREE)
4291		return 1;
4292	return be16_to_cpu(ifp->if_broot->bb_level) + 1;
4293}
4294
4295/*
4296 * Log whatever the flags say, even if error.  Otherwise we might miss detecting
4297 * a case where the data is changed, there's an error, and it's not logged so we
4298 * don't shutdown when we should.  Don't bother logging extents/btree changes if
4299 * we converted to the other format.
4300 */
4301static void
4302xfs_bmapi_finish(
4303	struct xfs_bmalloca	*bma,
4304	int			whichfork,
4305	int			error)
4306{
4307	struct xfs_ifork	*ifp = xfs_ifork_ptr(bma->ip, whichfork);
4308
4309	if ((bma->logflags & xfs_ilog_fext(whichfork)) &&
4310	    ifp->if_format != XFS_DINODE_FMT_EXTENTS)
4311		bma->logflags &= ~xfs_ilog_fext(whichfork);
4312	else if ((bma->logflags & xfs_ilog_fbroot(whichfork)) &&
4313		 ifp->if_format != XFS_DINODE_FMT_BTREE)
4314		bma->logflags &= ~xfs_ilog_fbroot(whichfork);
4315
4316	if (bma->logflags)
4317		xfs_trans_log_inode(bma->tp, bma->ip, bma->logflags);
4318	if (bma->cur)
4319		xfs_btree_del_cursor(bma->cur, error);
4320}
4321
4322/*
4323 * Map file blocks to filesystem blocks, and allocate blocks or convert the
4324 * extent state if necessary.  Details behaviour is controlled by the flags
4325 * parameter.  Only allocates blocks from a single allocation group, to avoid
4326 * locking problems.
4327 */
4328int
4329xfs_bmapi_write(
4330	struct xfs_trans	*tp,		/* transaction pointer */
4331	struct xfs_inode	*ip,		/* incore inode */
4332	xfs_fileoff_t		bno,		/* starting file offs. mapped */
4333	xfs_filblks_t		len,		/* length to map in file */
4334	uint32_t		flags,		/* XFS_BMAPI_... */
4335	xfs_extlen_t		total,		/* total blocks needed */
4336	struct xfs_bmbt_irec	*mval,		/* output: map values */
4337	int			*nmap)		/* i/o: mval size/count */
4338{
4339	struct xfs_bmalloca	bma = {
4340		.tp		= tp,
4341		.ip		= ip,
4342		.total		= total,
4343	};
4344	struct xfs_mount	*mp = ip->i_mount;
4345	int			whichfork = xfs_bmapi_whichfork(flags);
4346	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
4347	xfs_fileoff_t		end;		/* end of mapped file region */
4348	bool			eof = false;	/* after the end of extents */
4349	int			error;		/* error return */
4350	int			n;		/* current extent index */
4351	xfs_fileoff_t		obno;		/* old block number (offset) */
4352
4353#ifdef DEBUG
4354	xfs_fileoff_t		orig_bno;	/* original block number value */
4355	int			orig_flags;	/* original flags arg value */
4356	xfs_filblks_t		orig_len;	/* original value of len arg */
4357	struct xfs_bmbt_irec	*orig_mval;	/* original value of mval */
4358	int			orig_nmap;	/* original value of *nmap */
4359
4360	orig_bno = bno;
4361	orig_len = len;
4362	orig_flags = flags;
4363	orig_mval = mval;
4364	orig_nmap = *nmap;
4365#endif
4366
4367	ASSERT(*nmap >= 1);
4368	ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4369	ASSERT(tp != NULL);
4370	ASSERT(len > 0);
4371	ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
4372	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4373	ASSERT(!(flags & XFS_BMAPI_REMAP));
4374
4375	/* zeroing is for currently only for data extents, not metadata */
4376	ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) !=
4377			(XFS_BMAPI_METADATA | XFS_BMAPI_ZERO));
4378	/*
4379	 * we can allocate unwritten extents or pre-zero allocated blocks,
4380	 * but it makes no sense to do both at once. This would result in
4381	 * zeroing the unwritten extent twice, but it still being an
4382	 * unwritten extent....
4383	 */
4384	ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
4385			(XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
4386
4387	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4388	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4389		return -EFSCORRUPTED;
4390	}
4391
4392	if (xfs_is_shutdown(mp))
4393		return -EIO;
4394
4395	XFS_STATS_INC(mp, xs_blk_mapw);
4396
4397	error = xfs_iread_extents(tp, ip, whichfork);
4398	if (error)
4399		goto error0;
 
 
4400
4401	if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got))
4402		eof = true;
4403	if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4404		bma.prev.br_startoff = NULLFILEOFF;
4405	bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4406
4407	n = 0;
4408	end = bno + len;
4409	obno = bno;
4410	while (bno < end && n < *nmap) {
4411		bool			need_alloc = false, wasdelay = false;
4412
4413		/* in hole or beyond EOF? */
4414		if (eof || bma.got.br_startoff > bno) {
4415			/*
4416			 * CoW fork conversions should /never/ hit EOF or
4417			 * holes.  There should always be something for us
4418			 * to work on.
4419			 */
4420			ASSERT(!((flags & XFS_BMAPI_CONVERT) &&
4421			         (flags & XFS_BMAPI_COWFORK)));
4422
4423			need_alloc = true;
4424		} else if (isnullstartblock(bma.got.br_startblock)) {
4425			wasdelay = true;
4426		}
4427
4428		/*
4429		 * First, deal with the hole before the allocated space
4430		 * that we found, if any.
4431		 */
4432		if (need_alloc || wasdelay) {
4433			bma.eof = eof;
4434			bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4435			bma.wasdel = wasdelay;
4436			bma.offset = bno;
4437			bma.flags = flags;
4438
4439			/*
4440			 * There's a 32/64 bit type mismatch between the
4441			 * allocation length request (which can be 64 bits in
4442			 * length) and the bma length request, which is
4443			 * xfs_extlen_t and therefore 32 bits. Hence we have to
4444			 * check for 32-bit overflows and handle them here.
4445			 */
4446			if (len > (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN)
4447				bma.length = XFS_MAX_BMBT_EXTLEN;
4448			else
4449				bma.length = len;
4450
4451			ASSERT(len > 0);
4452			ASSERT(bma.length > 0);
4453			error = xfs_bmapi_allocate(&bma);
4454			if (error)
4455				goto error0;
4456			if (bma.blkno == NULLFSBLOCK)
4457				break;
4458
4459			/*
4460			 * If this is a CoW allocation, record the data in
4461			 * the refcount btree for orphan recovery.
4462			 */
4463			if (whichfork == XFS_COW_FORK)
4464				xfs_refcount_alloc_cow_extent(tp, bma.blkno,
4465						bma.length);
4466		}
4467
4468		/* Deal with the allocated space we found.  */
4469		xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno,
4470							end, n, flags);
4471
4472		/* Execute unwritten extent conversion if necessary */
4473		error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
4474		if (error == -EAGAIN)
4475			continue;
4476		if (error)
4477			goto error0;
4478
4479		/* update the extent map to return */
4480		xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4481
4482		/*
4483		 * If we're done, stop now.  Stop when we've allocated
4484		 * XFS_BMAP_MAX_NMAP extents no matter what.  Otherwise
4485		 * the transaction may get too big.
4486		 */
4487		if (bno >= end || n >= *nmap || bma.nallocs >= *nmap)
4488			break;
4489
4490		/* Else go on to the next record. */
4491		bma.prev = bma.got;
4492		if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got))
4493			eof = true;
4494	}
4495	*nmap = n;
4496
4497	error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4498			whichfork);
4499	if (error)
4500		goto error0;
4501
4502	ASSERT(ifp->if_format != XFS_DINODE_FMT_BTREE ||
4503	       ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork));
4504	xfs_bmapi_finish(&bma, whichfork, 0);
4505	xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
4506		orig_nmap, *nmap);
4507	return 0;
4508error0:
4509	xfs_bmapi_finish(&bma, whichfork, error);
4510	return error;
4511}
4512
4513/*
4514 * Convert an existing delalloc extent to real blocks based on file offset. This
4515 * attempts to allocate the entire delalloc extent and may require multiple
4516 * invocations to allocate the target offset if a large enough physical extent
4517 * is not available.
4518 */
4519int
4520xfs_bmapi_convert_delalloc(
4521	struct xfs_inode	*ip,
4522	int			whichfork,
4523	xfs_off_t		offset,
4524	struct iomap		*iomap,
4525	unsigned int		*seq)
4526{
4527	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
4528	struct xfs_mount	*mp = ip->i_mount;
4529	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
4530	struct xfs_bmalloca	bma = { NULL };
4531	uint16_t		flags = 0;
4532	struct xfs_trans	*tp;
4533	int			error;
4534
4535	if (whichfork == XFS_COW_FORK)
4536		flags |= IOMAP_F_SHARED;
4537
4538	/*
4539	 * Space for the extent and indirect blocks was reserved when the
4540	 * delalloc extent was created so there's no need to do so here.
4541	 */
4542	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0,
4543				XFS_TRANS_RESERVE, &tp);
4544	if (error)
4545		return error;
4546
4547	xfs_ilock(ip, XFS_ILOCK_EXCL);
4548	xfs_trans_ijoin(tp, ip, 0);
4549
4550	error = xfs_iext_count_may_overflow(ip, whichfork,
4551			XFS_IEXT_ADD_NOSPLIT_CNT);
4552	if (error == -EFBIG)
4553		error = xfs_iext_count_upgrade(tp, ip,
4554				XFS_IEXT_ADD_NOSPLIT_CNT);
4555	if (error)
4556		goto out_trans_cancel;
4557
4558	if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &bma.icur, &bma.got) ||
4559	    bma.got.br_startoff > offset_fsb) {
4560		/*
4561		 * No extent found in the range we are trying to convert.  This
4562		 * should only happen for the COW fork, where another thread
4563		 * might have moved the extent to the data fork in the meantime.
4564		 */
4565		WARN_ON_ONCE(whichfork != XFS_COW_FORK);
4566		error = -EAGAIN;
4567		goto out_trans_cancel;
4568	}
4569
4570	/*
4571	 * If we find a real extent here we raced with another thread converting
4572	 * the extent.  Just return the real extent at this offset.
4573	 */
4574	if (!isnullstartblock(bma.got.br_startblock)) {
4575		xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
4576				xfs_iomap_inode_sequence(ip, flags));
4577		*seq = READ_ONCE(ifp->if_seq);
4578		goto out_trans_cancel;
4579	}
4580
4581	bma.tp = tp;
4582	bma.ip = ip;
4583	bma.wasdel = true;
4584	bma.offset = bma.got.br_startoff;
4585	bma.length = max_t(xfs_filblks_t, bma.got.br_blockcount,
4586			XFS_MAX_BMBT_EXTLEN);
4587	bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4588
4589	/*
4590	 * When we're converting the delalloc reservations backing dirty pages
4591	 * in the page cache, we must be careful about how we create the new
4592	 * extents:
4593	 *
4594	 * New CoW fork extents are created unwritten, turned into real extents
4595	 * when we're about to write the data to disk, and mapped into the data
4596	 * fork after the write finishes.  End of story.
4597	 *
4598	 * New data fork extents must be mapped in as unwritten and converted
4599	 * to real extents after the write succeeds to avoid exposing stale
4600	 * disk contents if we crash.
4601	 */
4602	bma.flags = XFS_BMAPI_PREALLOC;
4603	if (whichfork == XFS_COW_FORK)
4604		bma.flags |= XFS_BMAPI_COWFORK;
4605
4606	if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4607		bma.prev.br_startoff = NULLFILEOFF;
4608
4609	error = xfs_bmapi_allocate(&bma);
4610	if (error)
4611		goto out_finish;
4612
4613	error = -ENOSPC;
4614	if (WARN_ON_ONCE(bma.blkno == NULLFSBLOCK))
4615		goto out_finish;
4616	error = -EFSCORRUPTED;
4617	if (WARN_ON_ONCE(!xfs_valid_startblock(ip, bma.got.br_startblock)))
4618		goto out_finish;
4619
4620	XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, bma.length));
4621	XFS_STATS_INC(mp, xs_xstrat_quick);
4622
4623	ASSERT(!isnullstartblock(bma.got.br_startblock));
4624	xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
4625				xfs_iomap_inode_sequence(ip, flags));
4626	*seq = READ_ONCE(ifp->if_seq);
4627
4628	if (whichfork == XFS_COW_FORK)
4629		xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
4630
4631	error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4632			whichfork);
4633	if (error)
4634		goto out_finish;
4635
4636	xfs_bmapi_finish(&bma, whichfork, 0);
4637	error = xfs_trans_commit(tp);
4638	xfs_iunlock(ip, XFS_ILOCK_EXCL);
4639	return error;
4640
4641out_finish:
4642	xfs_bmapi_finish(&bma, whichfork, error);
4643out_trans_cancel:
4644	xfs_trans_cancel(tp);
4645	xfs_iunlock(ip, XFS_ILOCK_EXCL);
4646	return error;
4647}
4648
4649int
4650xfs_bmapi_remap(
4651	struct xfs_trans	*tp,
4652	struct xfs_inode	*ip,
4653	xfs_fileoff_t		bno,
4654	xfs_filblks_t		len,
4655	xfs_fsblock_t		startblock,
4656	uint32_t		flags)
4657{
4658	struct xfs_mount	*mp = ip->i_mount;
4659	struct xfs_ifork	*ifp;
4660	struct xfs_btree_cur	*cur = NULL;
4661	struct xfs_bmbt_irec	got;
4662	struct xfs_iext_cursor	icur;
4663	int			whichfork = xfs_bmapi_whichfork(flags);
4664	int			logflags = 0, error;
4665
4666	ifp = xfs_ifork_ptr(ip, whichfork);
4667	ASSERT(len > 0);
4668	ASSERT(len <= (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN);
4669	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4670	ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
4671			   XFS_BMAPI_NORMAP)));
4672	ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
4673			(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
4674
4675	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4676	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4677		return -EFSCORRUPTED;
4678	}
4679
4680	if (xfs_is_shutdown(mp))
4681		return -EIO;
4682
4683	error = xfs_iread_extents(tp, ip, whichfork);
4684	if (error)
4685		return error;
 
 
4686
4687	if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
4688		/* make sure we only reflink into a hole. */
4689		ASSERT(got.br_startoff > bno);
4690		ASSERT(got.br_startoff - bno >= len);
4691	}
4692
4693	ip->i_nblocks += len;
4694	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4695
4696	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
4697		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
4698		cur->bc_ino.flags = 0;
4699	}
4700
4701	got.br_startoff = bno;
4702	got.br_startblock = startblock;
4703	got.br_blockcount = len;
4704	if (flags & XFS_BMAPI_PREALLOC)
4705		got.br_state = XFS_EXT_UNWRITTEN;
4706	else
4707		got.br_state = XFS_EXT_NORM;
4708
4709	error = xfs_bmap_add_extent_hole_real(tp, ip, whichfork, &icur,
4710			&cur, &got, &logflags, flags);
4711	if (error)
4712		goto error0;
4713
4714	error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags, whichfork);
4715
4716error0:
4717	if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS)
4718		logflags &= ~XFS_ILOG_DEXT;
4719	else if (ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
4720		logflags &= ~XFS_ILOG_DBROOT;
4721
4722	if (logflags)
4723		xfs_trans_log_inode(tp, ip, logflags);
4724	if (cur)
4725		xfs_btree_del_cursor(cur, error);
4726	return error;
4727}
4728
4729/*
4730 * When a delalloc extent is split (e.g., due to a hole punch), the original
4731 * indlen reservation must be shared across the two new extents that are left
4732 * behind.
4733 *
4734 * Given the original reservation and the worst case indlen for the two new
4735 * extents (as calculated by xfs_bmap_worst_indlen()), split the original
4736 * reservation fairly across the two new extents. If necessary, steal available
4737 * blocks from a deleted extent to make up a reservation deficiency (e.g., if
4738 * ores == 1). The number of stolen blocks is returned. The availability and
4739 * subsequent accounting of stolen blocks is the responsibility of the caller.
4740 */
4741static xfs_filblks_t
4742xfs_bmap_split_indlen(
4743	xfs_filblks_t			ores,		/* original res. */
4744	xfs_filblks_t			*indlen1,	/* ext1 worst indlen */
4745	xfs_filblks_t			*indlen2,	/* ext2 worst indlen */
4746	xfs_filblks_t			avail)		/* stealable blocks */
4747{
4748	xfs_filblks_t			len1 = *indlen1;
4749	xfs_filblks_t			len2 = *indlen2;
4750	xfs_filblks_t			nres = len1 + len2; /* new total res. */
4751	xfs_filblks_t			stolen = 0;
4752	xfs_filblks_t			resfactor;
4753
4754	/*
4755	 * Steal as many blocks as we can to try and satisfy the worst case
4756	 * indlen for both new extents.
4757	 */
4758	if (ores < nres && avail)
4759		stolen = XFS_FILBLKS_MIN(nres - ores, avail);
4760	ores += stolen;
4761
4762	 /* nothing else to do if we've satisfied the new reservation */
4763	if (ores >= nres)
4764		return stolen;
4765
4766	/*
4767	 * We can't meet the total required reservation for the two extents.
4768	 * Calculate the percent of the overall shortage between both extents
4769	 * and apply this percentage to each of the requested indlen values.
4770	 * This distributes the shortage fairly and reduces the chances that one
4771	 * of the two extents is left with nothing when extents are repeatedly
4772	 * split.
4773	 */
4774	resfactor = (ores * 100);
4775	do_div(resfactor, nres);
4776	len1 *= resfactor;
4777	do_div(len1, 100);
4778	len2 *= resfactor;
4779	do_div(len2, 100);
4780	ASSERT(len1 + len2 <= ores);
4781	ASSERT(len1 < *indlen1 && len2 < *indlen2);
4782
4783	/*
4784	 * Hand out the remainder to each extent. If one of the two reservations
4785	 * is zero, we want to make sure that one gets a block first. The loop
4786	 * below starts with len1, so hand len2 a block right off the bat if it
4787	 * is zero.
4788	 */
4789	ores -= (len1 + len2);
4790	ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores);
4791	if (ores && !len2 && *indlen2) {
4792		len2++;
4793		ores--;
4794	}
4795	while (ores) {
4796		if (len1 < *indlen1) {
4797			len1++;
4798			ores--;
4799		}
4800		if (!ores)
4801			break;
4802		if (len2 < *indlen2) {
4803			len2++;
4804			ores--;
4805		}
4806	}
4807
4808	*indlen1 = len1;
4809	*indlen2 = len2;
4810
4811	return stolen;
4812}
4813
4814int
4815xfs_bmap_del_extent_delay(
4816	struct xfs_inode	*ip,
4817	int			whichfork,
4818	struct xfs_iext_cursor	*icur,
4819	struct xfs_bmbt_irec	*got,
4820	struct xfs_bmbt_irec	*del)
4821{
4822	struct xfs_mount	*mp = ip->i_mount;
4823	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
4824	struct xfs_bmbt_irec	new;
4825	int64_t			da_old, da_new, da_diff = 0;
4826	xfs_fileoff_t		del_endoff, got_endoff;
4827	xfs_filblks_t		got_indlen, new_indlen, stolen;
4828	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
4829	int			error = 0;
4830	bool			isrt;
4831
4832	XFS_STATS_INC(mp, xs_del_exlist);
4833
4834	isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
4835	del_endoff = del->br_startoff + del->br_blockcount;
4836	got_endoff = got->br_startoff + got->br_blockcount;
4837	da_old = startblockval(got->br_startblock);
4838	da_new = 0;
4839
4840	ASSERT(del->br_blockcount > 0);
4841	ASSERT(got->br_startoff <= del->br_startoff);
4842	ASSERT(got_endoff >= del_endoff);
4843
4844	if (isrt)
4845		xfs_mod_frextents(mp, xfs_rtb_to_rtx(mp, del->br_blockcount));
 
 
 
 
4846
4847	/*
4848	 * Update the inode delalloc counter now and wait to update the
4849	 * sb counters as we might have to borrow some blocks for the
4850	 * indirect block accounting.
4851	 */
4852	ASSERT(!isrt);
4853	error = xfs_quota_unreserve_blkres(ip, del->br_blockcount);
 
4854	if (error)
4855		return error;
4856	ip->i_delayed_blks -= del->br_blockcount;
4857
4858	if (got->br_startoff == del->br_startoff)
4859		state |= BMAP_LEFT_FILLING;
4860	if (got_endoff == del_endoff)
4861		state |= BMAP_RIGHT_FILLING;
4862
4863	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
4864	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4865		/*
4866		 * Matches the whole extent.  Delete the entry.
4867		 */
4868		xfs_iext_remove(ip, icur, state);
4869		xfs_iext_prev(ifp, icur);
4870		break;
4871	case BMAP_LEFT_FILLING:
4872		/*
4873		 * Deleting the first part of the extent.
4874		 */
4875		got->br_startoff = del_endoff;
4876		got->br_blockcount -= del->br_blockcount;
4877		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4878				got->br_blockcount), da_old);
4879		got->br_startblock = nullstartblock((int)da_new);
4880		xfs_iext_update_extent(ip, state, icur, got);
4881		break;
4882	case BMAP_RIGHT_FILLING:
4883		/*
4884		 * Deleting the last part of the extent.
4885		 */
4886		got->br_blockcount = got->br_blockcount - del->br_blockcount;
4887		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4888				got->br_blockcount), da_old);
4889		got->br_startblock = nullstartblock((int)da_new);
4890		xfs_iext_update_extent(ip, state, icur, got);
4891		break;
4892	case 0:
4893		/*
4894		 * Deleting the middle of the extent.
4895		 *
4896		 * Distribute the original indlen reservation across the two new
4897		 * extents.  Steal blocks from the deleted extent if necessary.
4898		 * Stealing blocks simply fudges the fdblocks accounting below.
4899		 * Warn if either of the new indlen reservations is zero as this
4900		 * can lead to delalloc problems.
4901		 */
4902		got->br_blockcount = del->br_startoff - got->br_startoff;
4903		got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount);
4904
4905		new.br_blockcount = got_endoff - del_endoff;
4906		new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount);
4907
4908		WARN_ON_ONCE(!got_indlen || !new_indlen);
4909		stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen,
4910						       del->br_blockcount);
4911
4912		got->br_startblock = nullstartblock((int)got_indlen);
4913
4914		new.br_startoff = del_endoff;
4915		new.br_state = got->br_state;
4916		new.br_startblock = nullstartblock((int)new_indlen);
4917
4918		xfs_iext_update_extent(ip, state, icur, got);
4919		xfs_iext_next(ifp, icur);
4920		xfs_iext_insert(ip, icur, &new, state);
4921
4922		da_new = got_indlen + new_indlen - stolen;
4923		del->br_blockcount -= stolen;
4924		break;
4925	}
4926
4927	ASSERT(da_old >= da_new);
4928	da_diff = da_old - da_new;
4929	if (!isrt)
4930		da_diff += del->br_blockcount;
4931	if (da_diff) {
4932		xfs_mod_fdblocks(mp, da_diff, false);
4933		xfs_mod_delalloc(mp, -da_diff);
4934	}
4935	return error;
4936}
4937
4938void
4939xfs_bmap_del_extent_cow(
4940	struct xfs_inode	*ip,
4941	struct xfs_iext_cursor	*icur,
4942	struct xfs_bmbt_irec	*got,
4943	struct xfs_bmbt_irec	*del)
4944{
4945	struct xfs_mount	*mp = ip->i_mount;
4946	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
4947	struct xfs_bmbt_irec	new;
4948	xfs_fileoff_t		del_endoff, got_endoff;
4949	uint32_t		state = BMAP_COWFORK;
4950
4951	XFS_STATS_INC(mp, xs_del_exlist);
4952
4953	del_endoff = del->br_startoff + del->br_blockcount;
4954	got_endoff = got->br_startoff + got->br_blockcount;
4955
4956	ASSERT(del->br_blockcount > 0);
4957	ASSERT(got->br_startoff <= del->br_startoff);
4958	ASSERT(got_endoff >= del_endoff);
4959	ASSERT(!isnullstartblock(got->br_startblock));
4960
4961	if (got->br_startoff == del->br_startoff)
4962		state |= BMAP_LEFT_FILLING;
4963	if (got_endoff == del_endoff)
4964		state |= BMAP_RIGHT_FILLING;
4965
4966	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
4967	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4968		/*
4969		 * Matches the whole extent.  Delete the entry.
4970		 */
4971		xfs_iext_remove(ip, icur, state);
4972		xfs_iext_prev(ifp, icur);
4973		break;
4974	case BMAP_LEFT_FILLING:
4975		/*
4976		 * Deleting the first part of the extent.
4977		 */
4978		got->br_startoff = del_endoff;
4979		got->br_blockcount -= del->br_blockcount;
4980		got->br_startblock = del->br_startblock + del->br_blockcount;
4981		xfs_iext_update_extent(ip, state, icur, got);
4982		break;
4983	case BMAP_RIGHT_FILLING:
4984		/*
4985		 * Deleting the last part of the extent.
4986		 */
4987		got->br_blockcount -= del->br_blockcount;
4988		xfs_iext_update_extent(ip, state, icur, got);
4989		break;
4990	case 0:
4991		/*
4992		 * Deleting the middle of the extent.
4993		 */
4994		got->br_blockcount = del->br_startoff - got->br_startoff;
4995
4996		new.br_startoff = del_endoff;
4997		new.br_blockcount = got_endoff - del_endoff;
4998		new.br_state = got->br_state;
4999		new.br_startblock = del->br_startblock + del->br_blockcount;
5000
5001		xfs_iext_update_extent(ip, state, icur, got);
5002		xfs_iext_next(ifp, icur);
5003		xfs_iext_insert(ip, icur, &new, state);
5004		break;
5005	}
5006	ip->i_delayed_blks -= del->br_blockcount;
5007}
5008
5009/*
5010 * Called by xfs_bmapi to update file extent records and the btree
5011 * after removing space.
5012 */
5013STATIC int				/* error */
5014xfs_bmap_del_extent_real(
5015	xfs_inode_t		*ip,	/* incore inode pointer */
5016	xfs_trans_t		*tp,	/* current transaction pointer */
5017	struct xfs_iext_cursor	*icur,
5018	struct xfs_btree_cur	*cur,	/* if null, not a btree */
5019	xfs_bmbt_irec_t		*del,	/* data to remove from extents */
5020	int			*logflagsp, /* inode logging flags */
5021	int			whichfork, /* data or attr fork */
5022	uint32_t		bflags)	/* bmapi flags */
5023{
5024	xfs_fsblock_t		del_endblock=0;	/* first block past del */
5025	xfs_fileoff_t		del_endoff;	/* first offset past del */
5026	int			do_fx;	/* free extent at end of routine */
5027	int			error;	/* error return value */
 
5028	struct xfs_bmbt_irec	got;	/* current extent entry */
5029	xfs_fileoff_t		got_endoff;	/* first offset past got */
5030	int			i;	/* temp state */
5031	struct xfs_ifork	*ifp;	/* inode fork pointer */
5032	xfs_mount_t		*mp;	/* mount structure */
5033	xfs_filblks_t		nblks;	/* quota/sb block count */
5034	xfs_bmbt_irec_t		new;	/* new record to be inserted */
5035	/* REFERENCED */
5036	uint			qfield;	/* quota field to update */
5037	uint32_t		state = xfs_bmap_fork_to_state(whichfork);
5038	struct xfs_bmbt_irec	old;
5039
5040	*logflagsp = 0;
5041
5042	mp = ip->i_mount;
5043	XFS_STATS_INC(mp, xs_del_exlist);
5044
5045	ifp = xfs_ifork_ptr(ip, whichfork);
5046	ASSERT(del->br_blockcount > 0);
5047	xfs_iext_get_extent(ifp, icur, &got);
5048	ASSERT(got.br_startoff <= del->br_startoff);
5049	del_endoff = del->br_startoff + del->br_blockcount;
5050	got_endoff = got.br_startoff + got.br_blockcount;
5051	ASSERT(got_endoff >= del_endoff);
5052	ASSERT(!isnullstartblock(got.br_startblock));
5053	qfield = 0;
 
5054
5055	/*
5056	 * If it's the case where the directory code is running with no block
5057	 * reservation, and the deleted block is in the middle of its extent,
5058	 * and the resulting insert of an extent would cause transformation to
5059	 * btree format, then reject it.  The calling code will then swap blocks
5060	 * around instead.  We have to do this now, rather than waiting for the
5061	 * conversion to btree format, since the transaction will be dirty then.
5062	 */
5063	if (tp->t_blk_res == 0 &&
5064	    ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
5065	    ifp->if_nextents >= XFS_IFORK_MAXEXT(ip, whichfork) &&
5066	    del->br_startoff > got.br_startoff && del_endoff < got_endoff)
5067		return -ENOSPC;
5068
5069	*logflagsp = XFS_ILOG_CORE;
5070	if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) {
5071		if (!(bflags & XFS_BMAPI_REMAP)) {
5072			error = xfs_rtfree_blocks(tp, del->br_startblock,
5073					del->br_blockcount);
5074			if (error)
5075				return error;
5076		}
 
 
 
 
5077
 
 
 
5078		do_fx = 0;
 
5079		qfield = XFS_TRANS_DQ_RTBCOUNT;
5080	} else {
5081		do_fx = 1;
 
5082		qfield = XFS_TRANS_DQ_BCOUNT;
5083	}
5084	nblks = del->br_blockcount;
5085
5086	del_endblock = del->br_startblock + del->br_blockcount;
5087	if (cur) {
5088		error = xfs_bmbt_lookup_eq(cur, &got, &i);
5089		if (error)
5090			return error;
5091		if (XFS_IS_CORRUPT(mp, i != 1))
5092			return -EFSCORRUPTED;
 
 
5093	}
5094
5095	if (got.br_startoff == del->br_startoff)
5096		state |= BMAP_LEFT_FILLING;
5097	if (got_endoff == del_endoff)
5098		state |= BMAP_RIGHT_FILLING;
5099
5100	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
5101	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
5102		/*
5103		 * Matches the whole extent.  Delete the entry.
5104		 */
5105		xfs_iext_remove(ip, icur, state);
5106		xfs_iext_prev(ifp, icur);
5107		ifp->if_nextents--;
5108
5109		*logflagsp |= XFS_ILOG_CORE;
5110		if (!cur) {
5111			*logflagsp |= xfs_ilog_fext(whichfork);
5112			break;
5113		}
5114		if ((error = xfs_btree_delete(cur, &i)))
5115			return error;
5116		if (XFS_IS_CORRUPT(mp, i != 1))
5117			return -EFSCORRUPTED;
 
 
5118		break;
5119	case BMAP_LEFT_FILLING:
5120		/*
5121		 * Deleting the first part of the extent.
5122		 */
5123		got.br_startoff = del_endoff;
5124		got.br_startblock = del_endblock;
5125		got.br_blockcount -= del->br_blockcount;
5126		xfs_iext_update_extent(ip, state, icur, &got);
5127		if (!cur) {
5128			*logflagsp |= xfs_ilog_fext(whichfork);
5129			break;
5130		}
5131		error = xfs_bmbt_update(cur, &got);
5132		if (error)
5133			return error;
5134		break;
5135	case BMAP_RIGHT_FILLING:
5136		/*
5137		 * Deleting the last part of the extent.
5138		 */
5139		got.br_blockcount -= del->br_blockcount;
5140		xfs_iext_update_extent(ip, state, icur, &got);
5141		if (!cur) {
5142			*logflagsp |= xfs_ilog_fext(whichfork);
5143			break;
5144		}
5145		error = xfs_bmbt_update(cur, &got);
5146		if (error)
5147			return error;
5148		break;
5149	case 0:
5150		/*
5151		 * Deleting the middle of the extent.
5152		 */
5153
5154		old = got;
5155
5156		got.br_blockcount = del->br_startoff - got.br_startoff;
5157		xfs_iext_update_extent(ip, state, icur, &got);
5158
5159		new.br_startoff = del_endoff;
5160		new.br_blockcount = got_endoff - del_endoff;
5161		new.br_state = got.br_state;
5162		new.br_startblock = del_endblock;
5163
5164		*logflagsp |= XFS_ILOG_CORE;
5165		if (cur) {
5166			error = xfs_bmbt_update(cur, &got);
5167			if (error)
5168				return error;
5169			error = xfs_btree_increment(cur, 0, &i);
5170			if (error)
5171				return error;
5172			cur->bc_rec.b = new;
5173			error = xfs_btree_insert(cur, &i);
5174			if (error && error != -ENOSPC)
5175				return error;
5176			/*
5177			 * If get no-space back from btree insert, it tried a
5178			 * split, and we have a zero block reservation.  Fix up
5179			 * our state and return the error.
5180			 */
5181			if (error == -ENOSPC) {
5182				/*
5183				 * Reset the cursor, don't trust it after any
5184				 * insert operation.
5185				 */
5186				error = xfs_bmbt_lookup_eq(cur, &got, &i);
5187				if (error)
5188					return error;
5189				if (XFS_IS_CORRUPT(mp, i != 1))
5190					return -EFSCORRUPTED;
 
 
5191				/*
5192				 * Update the btree record back
5193				 * to the original value.
5194				 */
5195				error = xfs_bmbt_update(cur, &old);
5196				if (error)
5197					return error;
5198				/*
5199				 * Reset the extent record back
5200				 * to the original value.
5201				 */
5202				xfs_iext_update_extent(ip, state, icur, &old);
5203				*logflagsp = 0;
5204				return -ENOSPC;
 
 
 
 
 
5205			}
5206			if (XFS_IS_CORRUPT(mp, i != 1))
5207				return -EFSCORRUPTED;
5208		} else
5209			*logflagsp |= xfs_ilog_fext(whichfork);
5210
5211		ifp->if_nextents++;
5212		xfs_iext_next(ifp, icur);
5213		xfs_iext_insert(ip, icur, &new, state);
5214		break;
5215	}
5216
5217	/* remove reverse mapping */
5218	xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5219
5220	/*
5221	 * If we need to, add to list of extents to delete.
5222	 */
5223	if (do_fx && !(bflags & XFS_BMAPI_REMAP)) {
5224		if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
5225			xfs_refcount_decrease_extent(tp, del);
5226		} else {
5227			error = xfs_free_extent_later(tp, del->br_startblock,
5228					del->br_blockcount, NULL,
5229					XFS_AG_RESV_NONE,
5230					((bflags & XFS_BMAPI_NODISCARD) ||
5231					del->br_state == XFS_EXT_UNWRITTEN));
5232			if (error)
5233				return error;
5234		}
5235	}
5236
5237	/*
5238	 * Adjust inode # blocks in the file.
5239	 */
5240	if (nblks)
5241		ip->i_nblocks -= nblks;
5242	/*
5243	 * Adjust quota data.
5244	 */
5245	if (qfield && !(bflags & XFS_BMAPI_REMAP))
5246		xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks);
5247
5248	return 0;
 
 
5249}
5250
5251/*
5252 * Unmap (remove) blocks from a file.
5253 * If nexts is nonzero then the number of extents to remove is limited to
5254 * that value.  If not all extents in the block range can be removed then
5255 * *done is set.
5256 */
5257static int
5258__xfs_bunmapi(
5259	struct xfs_trans	*tp,		/* transaction pointer */
5260	struct xfs_inode	*ip,		/* incore inode */
5261	xfs_fileoff_t		start,		/* first file offset deleted */
5262	xfs_filblks_t		*rlen,		/* i/o: amount remaining */
5263	uint32_t		flags,		/* misc flags */
5264	xfs_extnum_t		nexts)		/* number of extents max */
5265{
5266	struct xfs_btree_cur	*cur;		/* bmap btree cursor */
5267	struct xfs_bmbt_irec	del;		/* extent being deleted */
5268	int			error;		/* error return value */
5269	xfs_extnum_t		extno;		/* extent number in list */
5270	struct xfs_bmbt_irec	got;		/* current extent record */
5271	struct xfs_ifork	*ifp;		/* inode fork pointer */
5272	int			isrt;		/* freeing in rt area */
5273	int			logflags;	/* transaction logging flags */
5274	xfs_extlen_t		mod;		/* rt extent offset */
5275	struct xfs_mount	*mp = ip->i_mount;
5276	int			tmp_logflags;	/* partial logging flags */
5277	int			wasdel;		/* was a delayed alloc extent */
5278	int			whichfork;	/* data or attribute fork */
 
5279	xfs_filblks_t		len = *rlen;	/* length to unmap in file */
 
 
5280	xfs_fileoff_t		end;
5281	struct xfs_iext_cursor	icur;
5282	bool			done = false;
5283
5284	trace_xfs_bunmap(ip, start, len, flags, _RET_IP_);
5285
5286	whichfork = xfs_bmapi_whichfork(flags);
5287	ASSERT(whichfork != XFS_COW_FORK);
5288	ifp = xfs_ifork_ptr(ip, whichfork);
5289	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)))
5290		return -EFSCORRUPTED;
5291	if (xfs_is_shutdown(mp))
5292		return -EIO;
5293
5294	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5295	ASSERT(len > 0);
5296	ASSERT(nexts >= 0);
5297
5298	error = xfs_iread_extents(tp, ip, whichfork);
5299	if (error)
5300		return error;
 
 
 
 
 
 
5301
 
 
 
5302	if (xfs_iext_count(ifp) == 0) {
5303		*rlen = 0;
5304		return 0;
5305	}
5306	XFS_STATS_INC(mp, xs_blk_unmap);
5307	isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
5308	end = start + len;
5309
5310	if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) {
5311		*rlen = 0;
5312		return 0;
5313	}
5314	end--;
5315
5316	logflags = 0;
5317	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
5318		ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
5319		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5320		cur->bc_ino.flags = 0;
5321	} else
5322		cur = NULL;
5323
5324	if (isrt) {
5325		/*
5326		 * Synchronize by locking the bitmap inode.
5327		 */
5328		xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
5329		xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
5330		xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
5331		xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
5332	}
5333
5334	extno = 0;
5335	while (end != (xfs_fileoff_t)-1 && end >= start &&
5336	       (nexts == 0 || extno < nexts)) {
5337		/*
5338		 * Is the found extent after a hole in which end lives?
5339		 * Just back up to the previous extent, if so.
5340		 */
5341		if (got.br_startoff > end &&
5342		    !xfs_iext_prev_extent(ifp, &icur, &got)) {
5343			done = true;
5344			break;
5345		}
5346		/*
5347		 * Is the last block of this extent before the range
5348		 * we're supposed to delete?  If so, we're done.
5349		 */
5350		end = XFS_FILEOFF_MIN(end,
5351			got.br_startoff + got.br_blockcount - 1);
5352		if (end < start)
5353			break;
5354		/*
5355		 * Then deal with the (possibly delayed) allocated space
5356		 * we found.
5357		 */
5358		del = got;
5359		wasdel = isnullstartblock(del.br_startblock);
5360
 
 
 
 
 
 
 
 
 
 
5361		if (got.br_startoff < start) {
5362			del.br_startoff = start;
5363			del.br_blockcount -= start - got.br_startoff;
5364			if (!wasdel)
5365				del.br_startblock += start - got.br_startoff;
5366		}
5367		if (del.br_startoff + del.br_blockcount > end + 1)
5368			del.br_blockcount = end + 1 - del.br_startoff;
5369
 
 
 
 
 
 
 
 
5370		if (!isrt)
5371			goto delete;
5372
5373		mod = xfs_rtb_to_rtxoff(mp,
5374				del.br_startblock + del.br_blockcount);
5375		if (mod) {
5376			/*
5377			 * Realtime extent not lined up at the end.
5378			 * The extent could have been split into written
5379			 * and unwritten pieces, or we could just be
5380			 * unmapping part of it.  But we can't really
5381			 * get rid of part of a realtime extent.
5382			 */
5383			if (del.br_state == XFS_EXT_UNWRITTEN) {
5384				/*
5385				 * This piece is unwritten, or we're not
5386				 * using unwritten extents.  Skip over it.
5387				 */
5388				ASSERT(end >= mod);
5389				end -= mod > del.br_blockcount ?
5390					del.br_blockcount : mod;
5391				if (end < got.br_startoff &&
5392				    !xfs_iext_prev_extent(ifp, &icur, &got)) {
5393					done = true;
5394					break;
5395				}
5396				continue;
5397			}
5398			/*
5399			 * It's written, turn it unwritten.
5400			 * This is better than zeroing it.
5401			 */
5402			ASSERT(del.br_state == XFS_EXT_NORM);
5403			ASSERT(tp->t_blk_res > 0);
5404			/*
5405			 * If this spans a realtime extent boundary,
5406			 * chop it back to the start of the one we end at.
5407			 */
5408			if (del.br_blockcount > mod) {
5409				del.br_startoff += del.br_blockcount - mod;
5410				del.br_startblock += del.br_blockcount - mod;
5411				del.br_blockcount = mod;
5412			}
5413			del.br_state = XFS_EXT_UNWRITTEN;
5414			error = xfs_bmap_add_extent_unwritten_real(tp, ip,
5415					whichfork, &icur, &cur, &del,
5416					&logflags);
5417			if (error)
5418				goto error0;
5419			goto nodelete;
5420		}
5421
5422		mod = xfs_rtb_to_rtxoff(mp, del.br_startblock);
5423		if (mod) {
5424			xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
5425
5426			/*
5427			 * Realtime extent is lined up at the end but not
5428			 * at the front.  We'll get rid of full extents if
5429			 * we can.
5430			 */
5431			if (del.br_blockcount > off) {
5432				del.br_blockcount -= off;
5433				del.br_startoff += off;
5434				del.br_startblock += off;
5435			} else if (del.br_startoff == start &&
5436				   (del.br_state == XFS_EXT_UNWRITTEN ||
5437				    tp->t_blk_res == 0)) {
5438				/*
5439				 * Can't make it unwritten.  There isn't
5440				 * a full extent here so just skip it.
5441				 */
5442				ASSERT(end >= del.br_blockcount);
5443				end -= del.br_blockcount;
5444				if (got.br_startoff > end &&
5445				    !xfs_iext_prev_extent(ifp, &icur, &got)) {
5446					done = true;
5447					break;
5448				}
5449				continue;
5450			} else if (del.br_state == XFS_EXT_UNWRITTEN) {
5451				struct xfs_bmbt_irec	prev;
5452				xfs_fileoff_t		unwrite_start;
5453
5454				/*
5455				 * This one is already unwritten.
5456				 * It must have a written left neighbor.
5457				 * Unwrite the killed part of that one and
5458				 * try again.
5459				 */
5460				if (!xfs_iext_prev_extent(ifp, &icur, &prev))
5461					ASSERT(0);
5462				ASSERT(prev.br_state == XFS_EXT_NORM);
5463				ASSERT(!isnullstartblock(prev.br_startblock));
5464				ASSERT(del.br_startblock ==
5465				       prev.br_startblock + prev.br_blockcount);
5466				unwrite_start = max3(start,
5467						     del.br_startoff - mod,
5468						     prev.br_startoff);
5469				mod = unwrite_start - prev.br_startoff;
5470				prev.br_startoff = unwrite_start;
5471				prev.br_startblock += mod;
5472				prev.br_blockcount -= mod;
5473				prev.br_state = XFS_EXT_UNWRITTEN;
5474				error = xfs_bmap_add_extent_unwritten_real(tp,
5475						ip, whichfork, &icur, &cur,
5476						&prev, &logflags);
5477				if (error)
5478					goto error0;
5479				goto nodelete;
5480			} else {
5481				ASSERT(del.br_state == XFS_EXT_NORM);
5482				del.br_state = XFS_EXT_UNWRITTEN;
5483				error = xfs_bmap_add_extent_unwritten_real(tp,
5484						ip, whichfork, &icur, &cur,
5485						&del, &logflags);
5486				if (error)
5487					goto error0;
5488				goto nodelete;
5489			}
5490		}
5491
5492delete:
5493		if (wasdel) {
5494			error = xfs_bmap_del_extent_delay(ip, whichfork, &icur,
5495					&got, &del);
5496		} else {
5497			error = xfs_bmap_del_extent_real(ip, tp, &icur, cur,
5498					&del, &tmp_logflags, whichfork,
5499					flags);
5500			logflags |= tmp_logflags;
5501		}
5502
5503		if (error)
5504			goto error0;
5505
 
5506		end = del.br_startoff - 1;
5507nodelete:
5508		/*
5509		 * If not done go on to the next (previous) record.
5510		 */
5511		if (end != (xfs_fileoff_t)-1 && end >= start) {
5512			if (!xfs_iext_get_extent(ifp, &icur, &got) ||
5513			    (got.br_startoff > end &&
5514			     !xfs_iext_prev_extent(ifp, &icur, &got))) {
5515				done = true;
5516				break;
5517			}
5518			extno++;
5519		}
5520	}
5521	if (done || end == (xfs_fileoff_t)-1 || end < start)
5522		*rlen = 0;
5523	else
5524		*rlen = end - start + 1;
5525
5526	/*
5527	 * Convert to a btree if necessary.
5528	 */
5529	if (xfs_bmap_needs_btree(ip, whichfork)) {
5530		ASSERT(cur == NULL);
5531		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
5532				&tmp_logflags, whichfork);
5533		logflags |= tmp_logflags;
5534	} else {
5535		error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags,
5536			whichfork);
5537	}
5538
5539error0:
5540	/*
5541	 * Log everything.  Do this after conversion, there's no point in
5542	 * logging the extent records if we've converted to btree format.
5543	 */
5544	if ((logflags & xfs_ilog_fext(whichfork)) &&
5545	    ifp->if_format != XFS_DINODE_FMT_EXTENTS)
5546		logflags &= ~xfs_ilog_fext(whichfork);
5547	else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
5548		 ifp->if_format != XFS_DINODE_FMT_BTREE)
5549		logflags &= ~xfs_ilog_fbroot(whichfork);
5550	/*
5551	 * Log inode even in the error case, if the transaction
5552	 * is dirty we'll need to shut down the filesystem.
5553	 */
5554	if (logflags)
5555		xfs_trans_log_inode(tp, ip, logflags);
5556	if (cur) {
5557		if (!error)
5558			cur->bc_ino.allocated = 0;
5559		xfs_btree_del_cursor(cur, error);
5560	}
5561	return error;
5562}
5563
5564/* Unmap a range of a file. */
5565int
5566xfs_bunmapi(
5567	xfs_trans_t		*tp,
5568	struct xfs_inode	*ip,
5569	xfs_fileoff_t		bno,
5570	xfs_filblks_t		len,
5571	uint32_t		flags,
5572	xfs_extnum_t		nexts,
5573	int			*done)
5574{
5575	int			error;
5576
5577	error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts);
5578	*done = (len == 0);
5579	return error;
5580}
5581
5582/*
5583 * Determine whether an extent shift can be accomplished by a merge with the
5584 * extent that precedes the target hole of the shift.
5585 */
5586STATIC bool
5587xfs_bmse_can_merge(
5588	struct xfs_bmbt_irec	*left,	/* preceding extent */
5589	struct xfs_bmbt_irec	*got,	/* current extent to shift */
5590	xfs_fileoff_t		shift)	/* shift fsb */
5591{
5592	xfs_fileoff_t		startoff;
5593
5594	startoff = got->br_startoff - shift;
5595
5596	/*
5597	 * The extent, once shifted, must be adjacent in-file and on-disk with
5598	 * the preceding extent.
5599	 */
5600	if ((left->br_startoff + left->br_blockcount != startoff) ||
5601	    (left->br_startblock + left->br_blockcount != got->br_startblock) ||
5602	    (left->br_state != got->br_state) ||
5603	    (left->br_blockcount + got->br_blockcount > XFS_MAX_BMBT_EXTLEN))
5604		return false;
5605
5606	return true;
5607}
5608
5609/*
5610 * A bmap extent shift adjusts the file offset of an extent to fill a preceding
5611 * hole in the file. If an extent shift would result in the extent being fully
5612 * adjacent to the extent that currently precedes the hole, we can merge with
5613 * the preceding extent rather than do the shift.
5614 *
5615 * This function assumes the caller has verified a shift-by-merge is possible
5616 * with the provided extents via xfs_bmse_can_merge().
5617 */
5618STATIC int
5619xfs_bmse_merge(
5620	struct xfs_trans		*tp,
5621	struct xfs_inode		*ip,
5622	int				whichfork,
5623	xfs_fileoff_t			shift,		/* shift fsb */
5624	struct xfs_iext_cursor		*icur,
5625	struct xfs_bmbt_irec		*got,		/* extent to shift */
5626	struct xfs_bmbt_irec		*left,		/* preceding extent */
5627	struct xfs_btree_cur		*cur,
5628	int				*logflags)	/* output */
5629{
5630	struct xfs_ifork		*ifp = xfs_ifork_ptr(ip, whichfork);
5631	struct xfs_bmbt_irec		new;
5632	xfs_filblks_t			blockcount;
5633	int				error, i;
5634	struct xfs_mount		*mp = ip->i_mount;
5635
5636	blockcount = left->br_blockcount + got->br_blockcount;
5637
5638	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
5639	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5640	ASSERT(xfs_bmse_can_merge(left, got, shift));
5641
5642	new = *left;
5643	new.br_blockcount = blockcount;
5644
5645	/*
5646	 * Update the on-disk extent count, the btree if necessary and log the
5647	 * inode.
5648	 */
5649	ifp->if_nextents--;
5650	*logflags |= XFS_ILOG_CORE;
5651	if (!cur) {
5652		*logflags |= XFS_ILOG_DEXT;
5653		goto done;
5654	}
5655
5656	/* lookup and remove the extent to merge */
5657	error = xfs_bmbt_lookup_eq(cur, got, &i);
5658	if (error)
5659		return error;
5660	if (XFS_IS_CORRUPT(mp, i != 1))
5661		return -EFSCORRUPTED;
5662
5663	error = xfs_btree_delete(cur, &i);
5664	if (error)
5665		return error;
5666	if (XFS_IS_CORRUPT(mp, i != 1))
5667		return -EFSCORRUPTED;
5668
5669	/* lookup and update size of the previous extent */
5670	error = xfs_bmbt_lookup_eq(cur, left, &i);
5671	if (error)
5672		return error;
5673	if (XFS_IS_CORRUPT(mp, i != 1))
5674		return -EFSCORRUPTED;
5675
5676	error = xfs_bmbt_update(cur, &new);
5677	if (error)
5678		return error;
5679
5680	/* change to extent format if required after extent removal */
5681	error = xfs_bmap_btree_to_extents(tp, ip, cur, logflags, whichfork);
5682	if (error)
5683		return error;
5684
5685done:
5686	xfs_iext_remove(ip, icur, 0);
5687	xfs_iext_prev(ifp, icur);
5688	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5689			&new);
5690
5691	/* update reverse mapping. rmap functions merge the rmaps for us */
5692	xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5693	memcpy(&new, got, sizeof(new));
5694	new.br_startoff = left->br_startoff + left->br_blockcount;
5695	xfs_rmap_map_extent(tp, ip, whichfork, &new);
5696	return 0;
5697}
5698
5699static int
5700xfs_bmap_shift_update_extent(
5701	struct xfs_trans	*tp,
5702	struct xfs_inode	*ip,
5703	int			whichfork,
5704	struct xfs_iext_cursor	*icur,
5705	struct xfs_bmbt_irec	*got,
5706	struct xfs_btree_cur	*cur,
5707	int			*logflags,
5708	xfs_fileoff_t		startoff)
5709{
5710	struct xfs_mount	*mp = ip->i_mount;
5711	struct xfs_bmbt_irec	prev = *got;
5712	int			error, i;
5713
5714	*logflags |= XFS_ILOG_CORE;
5715
5716	got->br_startoff = startoff;
5717
5718	if (cur) {
5719		error = xfs_bmbt_lookup_eq(cur, &prev, &i);
5720		if (error)
5721			return error;
5722		if (XFS_IS_CORRUPT(mp, i != 1))
5723			return -EFSCORRUPTED;
5724
5725		error = xfs_bmbt_update(cur, got);
5726		if (error)
5727			return error;
5728	} else {
5729		*logflags |= XFS_ILOG_DEXT;
5730	}
5731
5732	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5733			got);
5734
5735	/* update reverse mapping */
5736	xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
5737	xfs_rmap_map_extent(tp, ip, whichfork, got);
5738	return 0;
5739}
5740
5741int
5742xfs_bmap_collapse_extents(
5743	struct xfs_trans	*tp,
5744	struct xfs_inode	*ip,
5745	xfs_fileoff_t		*next_fsb,
5746	xfs_fileoff_t		offset_shift_fsb,
5747	bool			*done)
5748{
5749	int			whichfork = XFS_DATA_FORK;
5750	struct xfs_mount	*mp = ip->i_mount;
5751	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
5752	struct xfs_btree_cur	*cur = NULL;
5753	struct xfs_bmbt_irec	got, prev;
5754	struct xfs_iext_cursor	icur;
5755	xfs_fileoff_t		new_startoff;
5756	int			error = 0;
5757	int			logflags = 0;
5758
5759	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
5760	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5761		return -EFSCORRUPTED;
5762	}
5763
5764	if (xfs_is_shutdown(mp))
5765		return -EIO;
5766
5767	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
5768
5769	error = xfs_iread_extents(tp, ip, whichfork);
5770	if (error)
5771		return error;
 
 
5772
5773	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
5774		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5775		cur->bc_ino.flags = 0;
5776	}
5777
5778	if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5779		*done = true;
5780		goto del_cursor;
5781	}
5782	if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
5783		error = -EFSCORRUPTED;
5784		goto del_cursor;
5785	}
5786
5787	new_startoff = got.br_startoff - offset_shift_fsb;
5788	if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) {
5789		if (new_startoff < prev.br_startoff + prev.br_blockcount) {
5790			error = -EINVAL;
5791			goto del_cursor;
5792		}
5793
5794		if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) {
5795			error = xfs_bmse_merge(tp, ip, whichfork,
5796					offset_shift_fsb, &icur, &got, &prev,
5797					cur, &logflags);
5798			if (error)
5799				goto del_cursor;
5800			goto done;
5801		}
5802	} else {
5803		if (got.br_startoff < offset_shift_fsb) {
5804			error = -EINVAL;
5805			goto del_cursor;
5806		}
5807	}
5808
5809	error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
5810			cur, &logflags, new_startoff);
5811	if (error)
5812		goto del_cursor;
5813
5814done:
5815	if (!xfs_iext_next_extent(ifp, &icur, &got)) {
5816		*done = true;
5817		goto del_cursor;
5818	}
5819
5820	*next_fsb = got.br_startoff;
5821del_cursor:
5822	if (cur)
5823		xfs_btree_del_cursor(cur, error);
5824	if (logflags)
5825		xfs_trans_log_inode(tp, ip, logflags);
5826	return error;
5827}
5828
5829/* Make sure we won't be right-shifting an extent past the maximum bound. */
5830int
5831xfs_bmap_can_insert_extents(
5832	struct xfs_inode	*ip,
5833	xfs_fileoff_t		off,
5834	xfs_fileoff_t		shift)
5835{
5836	struct xfs_bmbt_irec	got;
5837	int			is_empty;
5838	int			error = 0;
5839
5840	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
5841
5842	if (xfs_is_shutdown(ip->i_mount))
5843		return -EIO;
5844
5845	xfs_ilock(ip, XFS_ILOCK_EXCL);
5846	error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty);
5847	if (!error && !is_empty && got.br_startoff >= off &&
5848	    ((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff)
5849		error = -EINVAL;
5850	xfs_iunlock(ip, XFS_ILOCK_EXCL);
5851
5852	return error;
5853}
5854
5855int
5856xfs_bmap_insert_extents(
5857	struct xfs_trans	*tp,
5858	struct xfs_inode	*ip,
5859	xfs_fileoff_t		*next_fsb,
5860	xfs_fileoff_t		offset_shift_fsb,
5861	bool			*done,
5862	xfs_fileoff_t		stop_fsb)
5863{
5864	int			whichfork = XFS_DATA_FORK;
5865	struct xfs_mount	*mp = ip->i_mount;
5866	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
5867	struct xfs_btree_cur	*cur = NULL;
5868	struct xfs_bmbt_irec	got, next;
5869	struct xfs_iext_cursor	icur;
5870	xfs_fileoff_t		new_startoff;
5871	int			error = 0;
5872	int			logflags = 0;
5873
5874	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
5875	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5876		return -EFSCORRUPTED;
5877	}
5878
5879	if (xfs_is_shutdown(mp))
5880		return -EIO;
5881
5882	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
5883
5884	error = xfs_iread_extents(tp, ip, whichfork);
5885	if (error)
5886		return error;
 
 
5887
5888	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
5889		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5890		cur->bc_ino.flags = 0;
5891	}
5892
5893	if (*next_fsb == NULLFSBLOCK) {
5894		xfs_iext_last(ifp, &icur);
5895		if (!xfs_iext_get_extent(ifp, &icur, &got) ||
5896		    stop_fsb > got.br_startoff) {
5897			*done = true;
5898			goto del_cursor;
5899		}
5900	} else {
5901		if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5902			*done = true;
5903			goto del_cursor;
5904		}
5905	}
5906	if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
5907		error = -EFSCORRUPTED;
5908		goto del_cursor;
5909	}
5910
5911	if (XFS_IS_CORRUPT(mp, stop_fsb > got.br_startoff)) {
5912		error = -EFSCORRUPTED;
5913		goto del_cursor;
5914	}
5915
5916	new_startoff = got.br_startoff + offset_shift_fsb;
5917	if (xfs_iext_peek_next_extent(ifp, &icur, &next)) {
5918		if (new_startoff + got.br_blockcount > next.br_startoff) {
5919			error = -EINVAL;
5920			goto del_cursor;
5921		}
5922
5923		/*
5924		 * Unlike a left shift (which involves a hole punch), a right
5925		 * shift does not modify extent neighbors in any way.  We should
5926		 * never find mergeable extents in this scenario.  Check anyways
5927		 * and warn if we encounter two extents that could be one.
5928		 */
5929		if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb))
5930			WARN_ON_ONCE(1);
5931	}
5932
5933	error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
5934			cur, &logflags, new_startoff);
5935	if (error)
5936		goto del_cursor;
5937
5938	if (!xfs_iext_prev_extent(ifp, &icur, &got) ||
5939	    stop_fsb >= got.br_startoff + got.br_blockcount) {
5940		*done = true;
5941		goto del_cursor;
5942	}
5943
5944	*next_fsb = got.br_startoff;
5945del_cursor:
5946	if (cur)
5947		xfs_btree_del_cursor(cur, error);
5948	if (logflags)
5949		xfs_trans_log_inode(tp, ip, logflags);
5950	return error;
5951}
5952
5953/*
5954 * Splits an extent into two extents at split_fsb block such that it is the
5955 * first block of the current_ext. @ext is a target extent to be split.
5956 * @split_fsb is a block where the extents is split.  If split_fsb lies in a
5957 * hole or the first block of extents, just return 0.
5958 */
5959int
5960xfs_bmap_split_extent(
5961	struct xfs_trans	*tp,
5962	struct xfs_inode	*ip,
5963	xfs_fileoff_t		split_fsb)
5964{
5965	int				whichfork = XFS_DATA_FORK;
5966	struct xfs_ifork		*ifp = xfs_ifork_ptr(ip, whichfork);
5967	struct xfs_btree_cur		*cur = NULL;
5968	struct xfs_bmbt_irec		got;
5969	struct xfs_bmbt_irec		new; /* split extent */
5970	struct xfs_mount		*mp = ip->i_mount;
5971	xfs_fsblock_t			gotblkcnt; /* new block count for got */
5972	struct xfs_iext_cursor		icur;
5973	int				error = 0;
5974	int				logflags = 0;
5975	int				i = 0;
5976
5977	if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
5978	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5979		return -EFSCORRUPTED;
5980	}
5981
5982	if (xfs_is_shutdown(mp))
5983		return -EIO;
5984
5985	/* Read in all the extents */
5986	error = xfs_iread_extents(tp, ip, whichfork);
5987	if (error)
5988		return error;
 
 
5989
5990	/*
5991	 * If there are not extents, or split_fsb lies in a hole we are done.
5992	 */
5993	if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) ||
5994	    got.br_startoff >= split_fsb)
5995		return 0;
5996
5997	gotblkcnt = split_fsb - got.br_startoff;
5998	new.br_startoff = split_fsb;
5999	new.br_startblock = got.br_startblock + gotblkcnt;
6000	new.br_blockcount = got.br_blockcount - gotblkcnt;
6001	new.br_state = got.br_state;
6002
6003	if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
6004		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
6005		cur->bc_ino.flags = 0;
6006		error = xfs_bmbt_lookup_eq(cur, &got, &i);
6007		if (error)
6008			goto del_cursor;
6009		if (XFS_IS_CORRUPT(mp, i != 1)) {
6010			error = -EFSCORRUPTED;
6011			goto del_cursor;
6012		}
6013	}
6014
6015	got.br_blockcount = gotblkcnt;
6016	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur,
6017			&got);
6018
6019	logflags = XFS_ILOG_CORE;
6020	if (cur) {
6021		error = xfs_bmbt_update(cur, &got);
6022		if (error)
6023			goto del_cursor;
6024	} else
6025		logflags |= XFS_ILOG_DEXT;
6026
6027	/* Add new extent */
6028	xfs_iext_next(ifp, &icur);
6029	xfs_iext_insert(ip, &icur, &new, 0);
6030	ifp->if_nextents++;
6031
6032	if (cur) {
6033		error = xfs_bmbt_lookup_eq(cur, &new, &i);
6034		if (error)
6035			goto del_cursor;
6036		if (XFS_IS_CORRUPT(mp, i != 0)) {
6037			error = -EFSCORRUPTED;
6038			goto del_cursor;
6039		}
6040		error = xfs_btree_insert(cur, &i);
6041		if (error)
6042			goto del_cursor;
6043		if (XFS_IS_CORRUPT(mp, i != 1)) {
6044			error = -EFSCORRUPTED;
6045			goto del_cursor;
6046		}
6047	}
6048
6049	/*
6050	 * Convert to a btree if necessary.
6051	 */
6052	if (xfs_bmap_needs_btree(ip, whichfork)) {
6053		int tmp_logflags; /* partial log flag return val */
6054
6055		ASSERT(cur == NULL);
6056		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
6057				&tmp_logflags, whichfork);
6058		logflags |= tmp_logflags;
6059	}
6060
6061del_cursor:
6062	if (cur) {
6063		cur->bc_ino.allocated = 0;
6064		xfs_btree_del_cursor(cur, error);
6065	}
6066
6067	if (logflags)
6068		xfs_trans_log_inode(tp, ip, logflags);
6069	return error;
6070}
6071
6072/* Deferred mapping is only for real extents in the data fork. */
6073static bool
6074xfs_bmap_is_update_needed(
6075	struct xfs_bmbt_irec	*bmap)
6076{
6077	return  bmap->br_startblock != HOLESTARTBLOCK &&
6078		bmap->br_startblock != DELAYSTARTBLOCK;
6079}
6080
6081/* Record a bmap intent. */
6082static int
6083__xfs_bmap_add(
6084	struct xfs_trans		*tp,
6085	enum xfs_bmap_intent_type	type,
6086	struct xfs_inode		*ip,
6087	int				whichfork,
6088	struct xfs_bmbt_irec		*bmap)
6089{
6090	struct xfs_bmap_intent		*bi;
6091
6092	trace_xfs_bmap_defer(tp->t_mountp,
6093			XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),
6094			type,
6095			XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),
6096			ip->i_ino, whichfork,
6097			bmap->br_startoff,
6098			bmap->br_blockcount,
6099			bmap->br_state);
6100
6101	bi = kmem_cache_alloc(xfs_bmap_intent_cache, GFP_NOFS | __GFP_NOFAIL);
6102	INIT_LIST_HEAD(&bi->bi_list);
6103	bi->bi_type = type;
6104	bi->bi_owner = ip;
6105	bi->bi_whichfork = whichfork;
6106	bi->bi_bmap = *bmap;
6107
6108	xfs_bmap_update_get_group(tp->t_mountp, bi);
6109	xfs_defer_add(tp, &bi->bi_list, &xfs_bmap_update_defer_type);
6110	return 0;
6111}
6112
6113/* Map an extent into a file. */
6114void
6115xfs_bmap_map_extent(
6116	struct xfs_trans	*tp,
6117	struct xfs_inode	*ip,
6118	struct xfs_bmbt_irec	*PREV)
6119{
6120	if (!xfs_bmap_is_update_needed(PREV))
6121		return;
6122
6123	__xfs_bmap_add(tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV);
6124}
6125
6126/* Unmap an extent out of a file. */
6127void
6128xfs_bmap_unmap_extent(
6129	struct xfs_trans	*tp,
6130	struct xfs_inode	*ip,
6131	struct xfs_bmbt_irec	*PREV)
6132{
6133	if (!xfs_bmap_is_update_needed(PREV))
6134		return;
6135
6136	__xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV);
6137}
6138
6139/*
6140 * Process one of the deferred bmap operations.  We pass back the
6141 * btree cursor to maintain our lock on the bmapbt between calls.
6142 */
6143int
6144xfs_bmap_finish_one(
6145	struct xfs_trans		*tp,
6146	struct xfs_bmap_intent		*bi)
 
 
 
 
 
 
6147{
6148	struct xfs_bmbt_irec		*bmap = &bi->bi_bmap;
6149	int				error = 0;
6150
6151	ASSERT(tp->t_highest_agno == NULLAGNUMBER);
6152
6153	trace_xfs_bmap_deferred(tp->t_mountp,
6154			XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),
6155			bi->bi_type,
6156			XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),
6157			bi->bi_owner->i_ino, bi->bi_whichfork,
6158			bmap->br_startoff, bmap->br_blockcount,
6159			bmap->br_state);
6160
6161	if (WARN_ON_ONCE(bi->bi_whichfork != XFS_DATA_FORK))
6162		return -EFSCORRUPTED;
6163
6164	if (XFS_TEST_ERROR(false, tp->t_mountp,
6165			XFS_ERRTAG_BMAP_FINISH_ONE))
6166		return -EIO;
6167
6168	switch (bi->bi_type) {
6169	case XFS_BMAP_MAP:
6170		error = xfs_bmapi_remap(tp, bi->bi_owner, bmap->br_startoff,
6171				bmap->br_blockcount, bmap->br_startblock, 0);
6172		bmap->br_blockcount = 0;
6173		break;
6174	case XFS_BMAP_UNMAP:
6175		error = __xfs_bunmapi(tp, bi->bi_owner, bmap->br_startoff,
6176				&bmap->br_blockcount, XFS_BMAPI_REMAP, 1);
6177		break;
6178	default:
6179		ASSERT(0);
6180		error = -EFSCORRUPTED;
6181	}
6182
6183	return error;
6184}
6185
6186/* Check that an extent does not have invalid flags or bad ranges. */
6187xfs_failaddr_t
6188xfs_bmap_validate_extent_raw(
6189	struct xfs_mount	*mp,
6190	bool			rtfile,
6191	int			whichfork,
6192	struct xfs_bmbt_irec	*irec)
6193{
6194	if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
6195		return __this_address;
 
6196
6197	if (rtfile && whichfork == XFS_DATA_FORK) {
6198		if (!xfs_verify_rtbext(mp, irec->br_startblock,
6199					   irec->br_blockcount))
 
 
 
6200			return __this_address;
6201	} else {
6202		if (!xfs_verify_fsbext(mp, irec->br_startblock,
6203					   irec->br_blockcount))
 
 
 
 
6204			return __this_address;
6205	}
6206	if (irec->br_state != XFS_EXT_NORM && whichfork != XFS_DATA_FORK)
6207		return __this_address;
6208	return NULL;
6209}
6210
6211int __init
6212xfs_bmap_intent_init_cache(void)
6213{
6214	xfs_bmap_intent_cache = kmem_cache_create("xfs_bmap_intent",
6215			sizeof(struct xfs_bmap_intent),
6216			0, 0, NULL);
6217
6218	return xfs_bmap_intent_cache != NULL ? 0 : -ENOMEM;
6219}
6220
6221void
6222xfs_bmap_intent_destroy_cache(void)
6223{
6224	kmem_cache_destroy(xfs_bmap_intent_cache);
6225	xfs_bmap_intent_cache = NULL;
6226}
6227
6228/* Check that an inode's extent does not have invalid flags or bad ranges. */
6229xfs_failaddr_t
6230xfs_bmap_validate_extent(
6231	struct xfs_inode	*ip,
6232	int			whichfork,
6233	struct xfs_bmbt_irec	*irec)
6234{
6235	return xfs_bmap_validate_extent_raw(ip->i_mount,
6236			XFS_IS_REALTIME_INODE(ip), whichfork, irec);
6237}
6238
6239/*
6240 * Used in xfs_itruncate_extents().  This is the maximum number of extents
6241 * freed from a file in a single transaction.
6242 */
6243#define	XFS_ITRUNC_MAX_EXTENTS	2
6244
6245/*
6246 * Unmap every extent in part of an inode's fork.  We don't do any higher level
6247 * invalidation work at all.
6248 */
6249int
6250xfs_bunmapi_range(
6251	struct xfs_trans	**tpp,
6252	struct xfs_inode	*ip,
6253	uint32_t		flags,
6254	xfs_fileoff_t		startoff,
6255	xfs_fileoff_t		endoff)
6256{
6257	xfs_filblks_t		unmap_len = endoff - startoff + 1;
6258	int			error = 0;
6259
6260	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
6261
6262	while (unmap_len > 0) {
6263		ASSERT((*tpp)->t_highest_agno == NULLAGNUMBER);
6264		error = __xfs_bunmapi(*tpp, ip, startoff, &unmap_len, flags,
6265				XFS_ITRUNC_MAX_EXTENTS);
6266		if (error)
6267			goto out;
6268
6269		/* free the just unmapped extents */
6270		error = xfs_defer_finish(tpp);
6271		if (error)
6272			goto out;
6273	}
6274out:
6275	return error;
6276}