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