xref: /linux/fs/xfs/xfs_bmap_util.c (revision c4ee0af3fa0dc65f690fc908f02b8355f9576ea0)
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * Copyright (c) 2012 Red Hat, Inc.
4  * All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it would be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write the Free Software Foundation,
17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19 #include "xfs.h"
20 #include "xfs_fs.h"
21 #include "xfs_shared.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
25 #include "xfs_bit.h"
26 #include "xfs_sb.h"
27 #include "xfs_ag.h"
28 #include "xfs_mount.h"
29 #include "xfs_da_format.h"
30 #include "xfs_inode.h"
31 #include "xfs_btree.h"
32 #include "xfs_trans.h"
33 #include "xfs_extfree_item.h"
34 #include "xfs_alloc.h"
35 #include "xfs_bmap.h"
36 #include "xfs_bmap_util.h"
37 #include "xfs_bmap_btree.h"
38 #include "xfs_rtalloc.h"
39 #include "xfs_error.h"
40 #include "xfs_quota.h"
41 #include "xfs_trans_space.h"
42 #include "xfs_trace.h"
43 #include "xfs_icache.h"
44 #include "xfs_log.h"
45 #include "xfs_dinode.h"
46 
47 /* Kernel only BMAP related definitions and functions */
48 
49 /*
50  * Convert the given file system block to a disk block.  We have to treat it
51  * differently based on whether the file is a real time file or not, because the
52  * bmap code does.
53  */
54 xfs_daddr_t
55 xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
56 {
57 	return (XFS_IS_REALTIME_INODE(ip) ? \
58 		 (xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \
59 		 XFS_FSB_TO_DADDR((ip)->i_mount, (fsb)));
60 }
61 
62 /*
63  * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
64  * caller.  Frees all the extents that need freeing, which must be done
65  * last due to locking considerations.  We never free any extents in
66  * the first transaction.
67  *
68  * Return 1 if the given transaction was committed and a new one
69  * started, and 0 otherwise in the committed parameter.
70  */
71 int						/* error */
72 xfs_bmap_finish(
73 	xfs_trans_t		**tp,		/* transaction pointer addr */
74 	xfs_bmap_free_t		*flist,		/* i/o: list extents to free */
75 	int			*committed)	/* xact committed or not */
76 {
77 	xfs_efd_log_item_t	*efd;		/* extent free data */
78 	xfs_efi_log_item_t	*efi;		/* extent free intention */
79 	int			error;		/* error return value */
80 	xfs_bmap_free_item_t	*free;		/* free extent item */
81 	struct xfs_trans_res	tres;		/* new log reservation */
82 	xfs_mount_t		*mp;		/* filesystem mount structure */
83 	xfs_bmap_free_item_t	*next;		/* next item on free list */
84 	xfs_trans_t		*ntp;		/* new transaction pointer */
85 
86 	ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
87 	if (flist->xbf_count == 0) {
88 		*committed = 0;
89 		return 0;
90 	}
91 	ntp = *tp;
92 	efi = xfs_trans_get_efi(ntp, flist->xbf_count);
93 	for (free = flist->xbf_first; free; free = free->xbfi_next)
94 		xfs_trans_log_efi_extent(ntp, efi, free->xbfi_startblock,
95 			free->xbfi_blockcount);
96 
97 	tres.tr_logres = ntp->t_log_res;
98 	tres.tr_logcount = ntp->t_log_count;
99 	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
100 	ntp = xfs_trans_dup(*tp);
101 	error = xfs_trans_commit(*tp, 0);
102 	*tp = ntp;
103 	*committed = 1;
104 	/*
105 	 * We have a new transaction, so we should return committed=1,
106 	 * even though we're returning an error.
107 	 */
108 	if (error)
109 		return error;
110 
111 	/*
112 	 * transaction commit worked ok so we can drop the extra ticket
113 	 * reference that we gained in xfs_trans_dup()
114 	 */
115 	xfs_log_ticket_put(ntp->t_ticket);
116 
117 	error = xfs_trans_reserve(ntp, &tres, 0, 0);
118 	if (error)
119 		return error;
120 	efd = xfs_trans_get_efd(ntp, efi, flist->xbf_count);
121 	for (free = flist->xbf_first; free != NULL; free = next) {
122 		next = free->xbfi_next;
123 		if ((error = xfs_free_extent(ntp, free->xbfi_startblock,
124 				free->xbfi_blockcount))) {
125 			/*
126 			 * The bmap free list will be cleaned up at a
127 			 * higher level.  The EFI will be canceled when
128 			 * this transaction is aborted.
129 			 * Need to force shutdown here to make sure it
130 			 * happens, since this transaction may not be
131 			 * dirty yet.
132 			 */
133 			mp = ntp->t_mountp;
134 			if (!XFS_FORCED_SHUTDOWN(mp))
135 				xfs_force_shutdown(mp,
136 						   (error == EFSCORRUPTED) ?
137 						   SHUTDOWN_CORRUPT_INCORE :
138 						   SHUTDOWN_META_IO_ERROR);
139 			return error;
140 		}
141 		xfs_trans_log_efd_extent(ntp, efd, free->xbfi_startblock,
142 			free->xbfi_blockcount);
143 		xfs_bmap_del_free(flist, NULL, free);
144 	}
145 	return 0;
146 }
147 
148 int
149 xfs_bmap_rtalloc(
150 	struct xfs_bmalloca	*ap)	/* bmap alloc argument struct */
151 {
152 	xfs_alloctype_t	atype = 0;	/* type for allocation routines */
153 	int		error;		/* error return value */
154 	xfs_mount_t	*mp;		/* mount point structure */
155 	xfs_extlen_t	prod = 0;	/* product factor for allocators */
156 	xfs_extlen_t	ralen = 0;	/* realtime allocation length */
157 	xfs_extlen_t	align;		/* minimum allocation alignment */
158 	xfs_rtblock_t	rtb;
159 
160 	mp = ap->ip->i_mount;
161 	align = xfs_get_extsz_hint(ap->ip);
162 	prod = align / mp->m_sb.sb_rextsize;
163 	error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
164 					align, 1, ap->eof, 0,
165 					ap->conv, &ap->offset, &ap->length);
166 	if (error)
167 		return error;
168 	ASSERT(ap->length);
169 	ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
170 
171 	/*
172 	 * If the offset & length are not perfectly aligned
173 	 * then kill prod, it will just get us in trouble.
174 	 */
175 	if (do_mod(ap->offset, align) || ap->length % align)
176 		prod = 1;
177 	/*
178 	 * Set ralen to be the actual requested length in rtextents.
179 	 */
180 	ralen = ap->length / mp->m_sb.sb_rextsize;
181 	/*
182 	 * If the old value was close enough to MAXEXTLEN that
183 	 * we rounded up to it, cut it back so it's valid again.
184 	 * Note that if it's a really large request (bigger than
185 	 * MAXEXTLEN), we don't hear about that number, and can't
186 	 * adjust the starting point to match it.
187 	 */
188 	if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN)
189 		ralen = MAXEXTLEN / mp->m_sb.sb_rextsize;
190 
191 	/*
192 	 * Lock out other modifications to the RT bitmap inode.
193 	 */
194 	xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
195 	xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
196 
197 	/*
198 	 * If it's an allocation to an empty file at offset 0,
199 	 * pick an extent that will space things out in the rt area.
200 	 */
201 	if (ap->eof && ap->offset == 0) {
202 		xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */
203 
204 		error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
205 		if (error)
206 			return error;
207 		ap->blkno = rtx * mp->m_sb.sb_rextsize;
208 	} else {
209 		ap->blkno = 0;
210 	}
211 
212 	xfs_bmap_adjacent(ap);
213 
214 	/*
215 	 * Realtime allocation, done through xfs_rtallocate_extent.
216 	 */
217 	atype = ap->blkno == 0 ?  XFS_ALLOCTYPE_ANY_AG : XFS_ALLOCTYPE_NEAR_BNO;
218 	do_div(ap->blkno, mp->m_sb.sb_rextsize);
219 	rtb = ap->blkno;
220 	ap->length = ralen;
221 	if ((error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, ap->length,
222 				&ralen, atype, ap->wasdel, prod, &rtb)))
223 		return error;
224 	if (rtb == NULLFSBLOCK && prod > 1 &&
225 	    (error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1,
226 					   ap->length, &ralen, atype,
227 					   ap->wasdel, 1, &rtb)))
228 		return error;
229 	ap->blkno = rtb;
230 	if (ap->blkno != NULLFSBLOCK) {
231 		ap->blkno *= mp->m_sb.sb_rextsize;
232 		ralen *= mp->m_sb.sb_rextsize;
233 		ap->length = ralen;
234 		ap->ip->i_d.di_nblocks += ralen;
235 		xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
236 		if (ap->wasdel)
237 			ap->ip->i_delayed_blks -= ralen;
238 		/*
239 		 * Adjust the disk quota also. This was reserved
240 		 * earlier.
241 		 */
242 		xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
243 			ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
244 					XFS_TRANS_DQ_RTBCOUNT, (long) ralen);
245 	} else {
246 		ap->length = 0;
247 	}
248 	return 0;
249 }
250 
251 /*
252  * Stack switching interfaces for allocation
253  */
254 static void
255 xfs_bmapi_allocate_worker(
256 	struct work_struct	*work)
257 {
258 	struct xfs_bmalloca	*args = container_of(work,
259 						struct xfs_bmalloca, work);
260 	unsigned long		pflags;
261 
262 	/* we are in a transaction context here */
263 	current_set_flags_nested(&pflags, PF_FSTRANS);
264 
265 	args->result = __xfs_bmapi_allocate(args);
266 	complete(args->done);
267 
268 	current_restore_flags_nested(&pflags, PF_FSTRANS);
269 }
270 
271 /*
272  * Some allocation requests often come in with little stack to work on. Push
273  * them off to a worker thread so there is lots of stack to use. Otherwise just
274  * call directly to avoid the context switch overhead here.
275  */
276 int
277 xfs_bmapi_allocate(
278 	struct xfs_bmalloca	*args)
279 {
280 	DECLARE_COMPLETION_ONSTACK(done);
281 
282 	if (!args->stack_switch)
283 		return __xfs_bmapi_allocate(args);
284 
285 
286 	args->done = &done;
287 	INIT_WORK_ONSTACK(&args->work, xfs_bmapi_allocate_worker);
288 	queue_work(xfs_alloc_wq, &args->work);
289 	wait_for_completion(&done);
290 	return args->result;
291 }
292 
293 /*
294  * Check if the endoff is outside the last extent. If so the caller will grow
295  * the allocation to a stripe unit boundary.  All offsets are considered outside
296  * the end of file for an empty fork, so 1 is returned in *eof in that case.
297  */
298 int
299 xfs_bmap_eof(
300 	struct xfs_inode	*ip,
301 	xfs_fileoff_t		endoff,
302 	int			whichfork,
303 	int			*eof)
304 {
305 	struct xfs_bmbt_irec	rec;
306 	int			error;
307 
308 	error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, eof);
309 	if (error || *eof)
310 		return error;
311 
312 	*eof = endoff >= rec.br_startoff + rec.br_blockcount;
313 	return 0;
314 }
315 
316 /*
317  * Extent tree block counting routines.
318  */
319 
320 /*
321  * Count leaf blocks given a range of extent records.
322  */
323 STATIC void
324 xfs_bmap_count_leaves(
325 	xfs_ifork_t		*ifp,
326 	xfs_extnum_t		idx,
327 	int			numrecs,
328 	int			*count)
329 {
330 	int		b;
331 
332 	for (b = 0; b < numrecs; b++) {
333 		xfs_bmbt_rec_host_t *frp = xfs_iext_get_ext(ifp, idx + b);
334 		*count += xfs_bmbt_get_blockcount(frp);
335 	}
336 }
337 
338 /*
339  * Count leaf blocks given a range of extent records originally
340  * in btree format.
341  */
342 STATIC void
343 xfs_bmap_disk_count_leaves(
344 	struct xfs_mount	*mp,
345 	struct xfs_btree_block	*block,
346 	int			numrecs,
347 	int			*count)
348 {
349 	int		b;
350 	xfs_bmbt_rec_t	*frp;
351 
352 	for (b = 1; b <= numrecs; b++) {
353 		frp = XFS_BMBT_REC_ADDR(mp, block, b);
354 		*count += xfs_bmbt_disk_get_blockcount(frp);
355 	}
356 }
357 
358 /*
359  * Recursively walks each level of a btree
360  * to count total fsblocks in use.
361  */
362 STATIC int                                     /* error */
363 xfs_bmap_count_tree(
364 	xfs_mount_t     *mp,            /* file system mount point */
365 	xfs_trans_t     *tp,            /* transaction pointer */
366 	xfs_ifork_t	*ifp,		/* inode fork pointer */
367 	xfs_fsblock_t   blockno,	/* file system block number */
368 	int             levelin,	/* level in btree */
369 	int		*count)		/* Count of blocks */
370 {
371 	int			error;
372 	xfs_buf_t		*bp, *nbp;
373 	int			level = levelin;
374 	__be64			*pp;
375 	xfs_fsblock_t           bno = blockno;
376 	xfs_fsblock_t		nextbno;
377 	struct xfs_btree_block	*block, *nextblock;
378 	int			numrecs;
379 
380 	error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF,
381 						&xfs_bmbt_buf_ops);
382 	if (error)
383 		return error;
384 	*count += 1;
385 	block = XFS_BUF_TO_BLOCK(bp);
386 
387 	if (--level) {
388 		/* Not at node above leaves, count this level of nodes */
389 		nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
390 		while (nextbno != NULLFSBLOCK) {
391 			error = xfs_btree_read_bufl(mp, tp, nextbno, 0, &nbp,
392 						XFS_BMAP_BTREE_REF,
393 						&xfs_bmbt_buf_ops);
394 			if (error)
395 				return error;
396 			*count += 1;
397 			nextblock = XFS_BUF_TO_BLOCK(nbp);
398 			nextbno = be64_to_cpu(nextblock->bb_u.l.bb_rightsib);
399 			xfs_trans_brelse(tp, nbp);
400 		}
401 
402 		/* Dive to the next level */
403 		pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
404 		bno = be64_to_cpu(*pp);
405 		if (unlikely((error =
406 		     xfs_bmap_count_tree(mp, tp, ifp, bno, level, count)) < 0)) {
407 			xfs_trans_brelse(tp, bp);
408 			XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
409 					 XFS_ERRLEVEL_LOW, mp);
410 			return XFS_ERROR(EFSCORRUPTED);
411 		}
412 		xfs_trans_brelse(tp, bp);
413 	} else {
414 		/* count all level 1 nodes and their leaves */
415 		for (;;) {
416 			nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
417 			numrecs = be16_to_cpu(block->bb_numrecs);
418 			xfs_bmap_disk_count_leaves(mp, block, numrecs, count);
419 			xfs_trans_brelse(tp, bp);
420 			if (nextbno == NULLFSBLOCK)
421 				break;
422 			bno = nextbno;
423 			error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
424 						XFS_BMAP_BTREE_REF,
425 						&xfs_bmbt_buf_ops);
426 			if (error)
427 				return error;
428 			*count += 1;
429 			block = XFS_BUF_TO_BLOCK(bp);
430 		}
431 	}
432 	return 0;
433 }
434 
435 /*
436  * Count fsblocks of the given fork.
437  */
438 int						/* error */
439 xfs_bmap_count_blocks(
440 	xfs_trans_t		*tp,		/* transaction pointer */
441 	xfs_inode_t		*ip,		/* incore inode */
442 	int			whichfork,	/* data or attr fork */
443 	int			*count)		/* out: count of blocks */
444 {
445 	struct xfs_btree_block	*block;	/* current btree block */
446 	xfs_fsblock_t		bno;	/* block # of "block" */
447 	xfs_ifork_t		*ifp;	/* fork structure */
448 	int			level;	/* btree level, for checking */
449 	xfs_mount_t		*mp;	/* file system mount structure */
450 	__be64			*pp;	/* pointer to block address */
451 
452 	bno = NULLFSBLOCK;
453 	mp = ip->i_mount;
454 	ifp = XFS_IFORK_PTR(ip, whichfork);
455 	if ( XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS ) {
456 		xfs_bmap_count_leaves(ifp, 0,
457 			ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t),
458 			count);
459 		return 0;
460 	}
461 
462 	/*
463 	 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
464 	 */
465 	block = ifp->if_broot;
466 	level = be16_to_cpu(block->bb_level);
467 	ASSERT(level > 0);
468 	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
469 	bno = be64_to_cpu(*pp);
470 	ASSERT(bno != NULLDFSBNO);
471 	ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
472 	ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
473 
474 	if (unlikely(xfs_bmap_count_tree(mp, tp, ifp, bno, level, count) < 0)) {
475 		XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW,
476 				 mp);
477 		return XFS_ERROR(EFSCORRUPTED);
478 	}
479 
480 	return 0;
481 }
482 
483 /*
484  * returns 1 for success, 0 if we failed to map the extent.
485  */
486 STATIC int
487 xfs_getbmapx_fix_eof_hole(
488 	xfs_inode_t		*ip,		/* xfs incore inode pointer */
489 	struct getbmapx		*out,		/* output structure */
490 	int			prealloced,	/* this is a file with
491 						 * preallocated data space */
492 	__int64_t		end,		/* last block requested */
493 	xfs_fsblock_t		startblock)
494 {
495 	__int64_t		fixlen;
496 	xfs_mount_t		*mp;		/* file system mount point */
497 	xfs_ifork_t		*ifp;		/* inode fork pointer */
498 	xfs_extnum_t		lastx;		/* last extent pointer */
499 	xfs_fileoff_t		fileblock;
500 
501 	if (startblock == HOLESTARTBLOCK) {
502 		mp = ip->i_mount;
503 		out->bmv_block = -1;
504 		fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
505 		fixlen -= out->bmv_offset;
506 		if (prealloced && out->bmv_offset + out->bmv_length == end) {
507 			/* Came to hole at EOF. Trim it. */
508 			if (fixlen <= 0)
509 				return 0;
510 			out->bmv_length = fixlen;
511 		}
512 	} else {
513 		if (startblock == DELAYSTARTBLOCK)
514 			out->bmv_block = -2;
515 		else
516 			out->bmv_block = xfs_fsb_to_db(ip, startblock);
517 		fileblock = XFS_BB_TO_FSB(ip->i_mount, out->bmv_offset);
518 		ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
519 		if (xfs_iext_bno_to_ext(ifp, fileblock, &lastx) &&
520 		   (lastx == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))-1))
521 			out->bmv_oflags |= BMV_OF_LAST;
522 	}
523 
524 	return 1;
525 }
526 
527 /*
528  * Get inode's extents as described in bmv, and format for output.
529  * Calls formatter to fill the user's buffer until all extents
530  * are mapped, until the passed-in bmv->bmv_count slots have
531  * been filled, or until the formatter short-circuits the loop,
532  * if it is tracking filled-in extents on its own.
533  */
534 int						/* error code */
535 xfs_getbmap(
536 	xfs_inode_t		*ip,
537 	struct getbmapx		*bmv,		/* user bmap structure */
538 	xfs_bmap_format_t	formatter,	/* format to user */
539 	void			*arg)		/* formatter arg */
540 {
541 	__int64_t		bmvend;		/* last block requested */
542 	int			error = 0;	/* return value */
543 	__int64_t		fixlen;		/* length for -1 case */
544 	int			i;		/* extent number */
545 	int			lock;		/* lock state */
546 	xfs_bmbt_irec_t		*map;		/* buffer for user's data */
547 	xfs_mount_t		*mp;		/* file system mount point */
548 	int			nex;		/* # of user extents can do */
549 	int			nexleft;	/* # of user extents left */
550 	int			subnex;		/* # of bmapi's can do */
551 	int			nmap;		/* number of map entries */
552 	struct getbmapx		*out;		/* output structure */
553 	int			whichfork;	/* data or attr fork */
554 	int			prealloced;	/* this is a file with
555 						 * preallocated data space */
556 	int			iflags;		/* interface flags */
557 	int			bmapi_flags;	/* flags for xfs_bmapi */
558 	int			cur_ext = 0;
559 
560 	mp = ip->i_mount;
561 	iflags = bmv->bmv_iflags;
562 	whichfork = iflags & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK;
563 
564 	if (whichfork == XFS_ATTR_FORK) {
565 		if (XFS_IFORK_Q(ip)) {
566 			if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS &&
567 			    ip->i_d.di_aformat != XFS_DINODE_FMT_BTREE &&
568 			    ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)
569 				return XFS_ERROR(EINVAL);
570 		} else if (unlikely(
571 			   ip->i_d.di_aformat != 0 &&
572 			   ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS)) {
573 			XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW,
574 					 ip->i_mount);
575 			return XFS_ERROR(EFSCORRUPTED);
576 		}
577 
578 		prealloced = 0;
579 		fixlen = 1LL << 32;
580 	} else {
581 		if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS &&
582 		    ip->i_d.di_format != XFS_DINODE_FMT_BTREE &&
583 		    ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
584 			return XFS_ERROR(EINVAL);
585 
586 		if (xfs_get_extsz_hint(ip) ||
587 		    ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){
588 			prealloced = 1;
589 			fixlen = mp->m_super->s_maxbytes;
590 		} else {
591 			prealloced = 0;
592 			fixlen = XFS_ISIZE(ip);
593 		}
594 	}
595 
596 	if (bmv->bmv_length == -1) {
597 		fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, fixlen));
598 		bmv->bmv_length =
599 			max_t(__int64_t, fixlen - bmv->bmv_offset, 0);
600 	} else if (bmv->bmv_length == 0) {
601 		bmv->bmv_entries = 0;
602 		return 0;
603 	} else if (bmv->bmv_length < 0) {
604 		return XFS_ERROR(EINVAL);
605 	}
606 
607 	nex = bmv->bmv_count - 1;
608 	if (nex <= 0)
609 		return XFS_ERROR(EINVAL);
610 	bmvend = bmv->bmv_offset + bmv->bmv_length;
611 
612 
613 	if (bmv->bmv_count > ULONG_MAX / sizeof(struct getbmapx))
614 		return XFS_ERROR(ENOMEM);
615 	out = kmem_zalloc_large(bmv->bmv_count * sizeof(struct getbmapx), 0);
616 	if (!out)
617 		return XFS_ERROR(ENOMEM);
618 
619 	xfs_ilock(ip, XFS_IOLOCK_SHARED);
620 	if (whichfork == XFS_DATA_FORK && !(iflags & BMV_IF_DELALLOC)) {
621 		if (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size) {
622 			error = -filemap_write_and_wait(VFS_I(ip)->i_mapping);
623 			if (error)
624 				goto out_unlock_iolock;
625 		}
626 		/*
627 		 * even after flushing the inode, there can still be delalloc
628 		 * blocks on the inode beyond EOF due to speculative
629 		 * preallocation. These are not removed until the release
630 		 * function is called or the inode is inactivated. Hence we
631 		 * cannot assert here that ip->i_delayed_blks == 0.
632 		 */
633 	}
634 
635 	lock = xfs_ilock_map_shared(ip);
636 
637 	/*
638 	 * Don't let nex be bigger than the number of extents
639 	 * we can have assuming alternating holes and real extents.
640 	 */
641 	if (nex > XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1)
642 		nex = XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1;
643 
644 	bmapi_flags = xfs_bmapi_aflag(whichfork);
645 	if (!(iflags & BMV_IF_PREALLOC))
646 		bmapi_flags |= XFS_BMAPI_IGSTATE;
647 
648 	/*
649 	 * Allocate enough space to handle "subnex" maps at a time.
650 	 */
651 	error = ENOMEM;
652 	subnex = 16;
653 	map = kmem_alloc(subnex * sizeof(*map), KM_MAYFAIL | KM_NOFS);
654 	if (!map)
655 		goto out_unlock_ilock;
656 
657 	bmv->bmv_entries = 0;
658 
659 	if (XFS_IFORK_NEXTENTS(ip, whichfork) == 0 &&
660 	    (whichfork == XFS_ATTR_FORK || !(iflags & BMV_IF_DELALLOC))) {
661 		error = 0;
662 		goto out_free_map;
663 	}
664 
665 	nexleft = nex;
666 
667 	do {
668 		nmap = (nexleft > subnex) ? subnex : nexleft;
669 		error = xfs_bmapi_read(ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset),
670 				       XFS_BB_TO_FSB(mp, bmv->bmv_length),
671 				       map, &nmap, bmapi_flags);
672 		if (error)
673 			goto out_free_map;
674 		ASSERT(nmap <= subnex);
675 
676 		for (i = 0; i < nmap && nexleft && bmv->bmv_length; i++) {
677 			out[cur_ext].bmv_oflags = 0;
678 			if (map[i].br_state == XFS_EXT_UNWRITTEN)
679 				out[cur_ext].bmv_oflags |= BMV_OF_PREALLOC;
680 			else if (map[i].br_startblock == DELAYSTARTBLOCK)
681 				out[cur_ext].bmv_oflags |= BMV_OF_DELALLOC;
682 			out[cur_ext].bmv_offset =
683 				XFS_FSB_TO_BB(mp, map[i].br_startoff);
684 			out[cur_ext].bmv_length =
685 				XFS_FSB_TO_BB(mp, map[i].br_blockcount);
686 			out[cur_ext].bmv_unused1 = 0;
687 			out[cur_ext].bmv_unused2 = 0;
688 
689 			/*
690 			 * delayed allocation extents that start beyond EOF can
691 			 * occur due to speculative EOF allocation when the
692 			 * delalloc extent is larger than the largest freespace
693 			 * extent at conversion time. These extents cannot be
694 			 * converted by data writeback, so can exist here even
695 			 * if we are not supposed to be finding delalloc
696 			 * extents.
697 			 */
698 			if (map[i].br_startblock == DELAYSTARTBLOCK &&
699 			    map[i].br_startoff <= XFS_B_TO_FSB(mp, XFS_ISIZE(ip)))
700 				ASSERT((iflags & BMV_IF_DELALLOC) != 0);
701 
702                         if (map[i].br_startblock == HOLESTARTBLOCK &&
703 			    whichfork == XFS_ATTR_FORK) {
704 				/* came to the end of attribute fork */
705 				out[cur_ext].bmv_oflags |= BMV_OF_LAST;
706 				goto out_free_map;
707 			}
708 
709 			if (!xfs_getbmapx_fix_eof_hole(ip, &out[cur_ext],
710 					prealloced, bmvend,
711 					map[i].br_startblock))
712 				goto out_free_map;
713 
714 			bmv->bmv_offset =
715 				out[cur_ext].bmv_offset +
716 				out[cur_ext].bmv_length;
717 			bmv->bmv_length =
718 				max_t(__int64_t, 0, bmvend - bmv->bmv_offset);
719 
720 			/*
721 			 * In case we don't want to return the hole,
722 			 * don't increase cur_ext so that we can reuse
723 			 * it in the next loop.
724 			 */
725 			if ((iflags & BMV_IF_NO_HOLES) &&
726 			    map[i].br_startblock == HOLESTARTBLOCK) {
727 				memset(&out[cur_ext], 0, sizeof(out[cur_ext]));
728 				continue;
729 			}
730 
731 			nexleft--;
732 			bmv->bmv_entries++;
733 			cur_ext++;
734 		}
735 	} while (nmap && nexleft && bmv->bmv_length);
736 
737  out_free_map:
738 	kmem_free(map);
739  out_unlock_ilock:
740 	xfs_iunlock_map_shared(ip, lock);
741  out_unlock_iolock:
742 	xfs_iunlock(ip, XFS_IOLOCK_SHARED);
743 
744 	for (i = 0; i < cur_ext; i++) {
745 		int full = 0;	/* user array is full */
746 
747 		/* format results & advance arg */
748 		error = formatter(&arg, &out[i], &full);
749 		if (error || full)
750 			break;
751 	}
752 
753 	kmem_free(out);
754 	return error;
755 }
756 
757 /*
758  * dead simple method of punching delalyed allocation blocks from a range in
759  * the inode. Walks a block at a time so will be slow, but is only executed in
760  * rare error cases so the overhead is not critical. This will always punch out
761  * both the start and end blocks, even if the ranges only partially overlap
762  * them, so it is up to the caller to ensure that partial blocks are not
763  * passed in.
764  */
765 int
766 xfs_bmap_punch_delalloc_range(
767 	struct xfs_inode	*ip,
768 	xfs_fileoff_t		start_fsb,
769 	xfs_fileoff_t		length)
770 {
771 	xfs_fileoff_t		remaining = length;
772 	int			error = 0;
773 
774 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
775 
776 	do {
777 		int		done;
778 		xfs_bmbt_irec_t	imap;
779 		int		nimaps = 1;
780 		xfs_fsblock_t	firstblock;
781 		xfs_bmap_free_t flist;
782 
783 		/*
784 		 * Map the range first and check that it is a delalloc extent
785 		 * before trying to unmap the range. Otherwise we will be
786 		 * trying to remove a real extent (which requires a
787 		 * transaction) or a hole, which is probably a bad idea...
788 		 */
789 		error = xfs_bmapi_read(ip, start_fsb, 1, &imap, &nimaps,
790 				       XFS_BMAPI_ENTIRE);
791 
792 		if (error) {
793 			/* something screwed, just bail */
794 			if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
795 				xfs_alert(ip->i_mount,
796 			"Failed delalloc mapping lookup ino %lld fsb %lld.",
797 						ip->i_ino, start_fsb);
798 			}
799 			break;
800 		}
801 		if (!nimaps) {
802 			/* nothing there */
803 			goto next_block;
804 		}
805 		if (imap.br_startblock != DELAYSTARTBLOCK) {
806 			/* been converted, ignore */
807 			goto next_block;
808 		}
809 		WARN_ON(imap.br_blockcount == 0);
810 
811 		/*
812 		 * Note: while we initialise the firstblock/flist pair, they
813 		 * should never be used because blocks should never be
814 		 * allocated or freed for a delalloc extent and hence we need
815 		 * don't cancel or finish them after the xfs_bunmapi() call.
816 		 */
817 		xfs_bmap_init(&flist, &firstblock);
818 		error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock,
819 					&flist, &done);
820 		if (error)
821 			break;
822 
823 		ASSERT(!flist.xbf_count && !flist.xbf_first);
824 next_block:
825 		start_fsb++;
826 		remaining--;
827 	} while(remaining > 0);
828 
829 	return error;
830 }
831 
832 /*
833  * Test whether it is appropriate to check an inode for and free post EOF
834  * blocks. The 'force' parameter determines whether we should also consider
835  * regular files that are marked preallocated or append-only.
836  */
837 bool
838 xfs_can_free_eofblocks(struct xfs_inode *ip, bool force)
839 {
840 	/* prealloc/delalloc exists only on regular files */
841 	if (!S_ISREG(ip->i_d.di_mode))
842 		return false;
843 
844 	/*
845 	 * Zero sized files with no cached pages and delalloc blocks will not
846 	 * have speculative prealloc/delalloc blocks to remove.
847 	 */
848 	if (VFS_I(ip)->i_size == 0 &&
849 	    VN_CACHED(VFS_I(ip)) == 0 &&
850 	    ip->i_delayed_blks == 0)
851 		return false;
852 
853 	/* If we haven't read in the extent list, then don't do it now. */
854 	if (!(ip->i_df.if_flags & XFS_IFEXTENTS))
855 		return false;
856 
857 	/*
858 	 * Do not free real preallocated or append-only files unless the file
859 	 * has delalloc blocks and we are forced to remove them.
860 	 */
861 	if (ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
862 		if (!force || ip->i_delayed_blks == 0)
863 			return false;
864 
865 	return true;
866 }
867 
868 /*
869  * This is called by xfs_inactive to free any blocks beyond eof
870  * when the link count isn't zero and by xfs_dm_punch_hole() when
871  * punching a hole to EOF.
872  */
873 int
874 xfs_free_eofblocks(
875 	xfs_mount_t	*mp,
876 	xfs_inode_t	*ip,
877 	bool		need_iolock)
878 {
879 	xfs_trans_t	*tp;
880 	int		error;
881 	xfs_fileoff_t	end_fsb;
882 	xfs_fileoff_t	last_fsb;
883 	xfs_filblks_t	map_len;
884 	int		nimaps;
885 	xfs_bmbt_irec_t	imap;
886 
887 	/*
888 	 * Figure out if there are any blocks beyond the end
889 	 * of the file.  If not, then there is nothing to do.
890 	 */
891 	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
892 	last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
893 	if (last_fsb <= end_fsb)
894 		return 0;
895 	map_len = last_fsb - end_fsb;
896 
897 	nimaps = 1;
898 	xfs_ilock(ip, XFS_ILOCK_SHARED);
899 	error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
900 	xfs_iunlock(ip, XFS_ILOCK_SHARED);
901 
902 	if (!error && (nimaps != 0) &&
903 	    (imap.br_startblock != HOLESTARTBLOCK ||
904 	     ip->i_delayed_blks)) {
905 		/*
906 		 * Attach the dquots to the inode up front.
907 		 */
908 		error = xfs_qm_dqattach(ip, 0);
909 		if (error)
910 			return error;
911 
912 		/*
913 		 * There are blocks after the end of file.
914 		 * Free them up now by truncating the file to
915 		 * its current size.
916 		 */
917 		tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
918 
919 		if (need_iolock) {
920 			if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
921 				xfs_trans_cancel(tp, 0);
922 				return EAGAIN;
923 			}
924 		}
925 
926 		error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
927 		if (error) {
928 			ASSERT(XFS_FORCED_SHUTDOWN(mp));
929 			xfs_trans_cancel(tp, 0);
930 			if (need_iolock)
931 				xfs_iunlock(ip, XFS_IOLOCK_EXCL);
932 			return error;
933 		}
934 
935 		xfs_ilock(ip, XFS_ILOCK_EXCL);
936 		xfs_trans_ijoin(tp, ip, 0);
937 
938 		/*
939 		 * Do not update the on-disk file size.  If we update the
940 		 * on-disk file size and then the system crashes before the
941 		 * contents of the file are flushed to disk then the files
942 		 * may be full of holes (ie NULL files bug).
943 		 */
944 		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
945 					      XFS_ISIZE(ip));
946 		if (error) {
947 			/*
948 			 * If we get an error at this point we simply don't
949 			 * bother truncating the file.
950 			 */
951 			xfs_trans_cancel(tp,
952 					 (XFS_TRANS_RELEASE_LOG_RES |
953 					  XFS_TRANS_ABORT));
954 		} else {
955 			error = xfs_trans_commit(tp,
956 						XFS_TRANS_RELEASE_LOG_RES);
957 			if (!error)
958 				xfs_inode_clear_eofblocks_tag(ip);
959 		}
960 
961 		xfs_iunlock(ip, XFS_ILOCK_EXCL);
962 		if (need_iolock)
963 			xfs_iunlock(ip, XFS_IOLOCK_EXCL);
964 	}
965 	return error;
966 }
967 
968 int
969 xfs_alloc_file_space(
970 	struct xfs_inode	*ip,
971 	xfs_off_t		offset,
972 	xfs_off_t		len,
973 	int			alloc_type)
974 {
975 	xfs_mount_t		*mp = ip->i_mount;
976 	xfs_off_t		count;
977 	xfs_filblks_t		allocated_fsb;
978 	xfs_filblks_t		allocatesize_fsb;
979 	xfs_extlen_t		extsz, temp;
980 	xfs_fileoff_t		startoffset_fsb;
981 	xfs_fsblock_t		firstfsb;
982 	int			nimaps;
983 	int			quota_flag;
984 	int			rt;
985 	xfs_trans_t		*tp;
986 	xfs_bmbt_irec_t		imaps[1], *imapp;
987 	xfs_bmap_free_t		free_list;
988 	uint			qblocks, resblks, resrtextents;
989 	int			committed;
990 	int			error;
991 
992 	trace_xfs_alloc_file_space(ip);
993 
994 	if (XFS_FORCED_SHUTDOWN(mp))
995 		return XFS_ERROR(EIO);
996 
997 	error = xfs_qm_dqattach(ip, 0);
998 	if (error)
999 		return error;
1000 
1001 	if (len <= 0)
1002 		return XFS_ERROR(EINVAL);
1003 
1004 	rt = XFS_IS_REALTIME_INODE(ip);
1005 	extsz = xfs_get_extsz_hint(ip);
1006 
1007 	count = len;
1008 	imapp = &imaps[0];
1009 	nimaps = 1;
1010 	startoffset_fsb	= XFS_B_TO_FSBT(mp, offset);
1011 	allocatesize_fsb = XFS_B_TO_FSB(mp, count);
1012 
1013 	/*
1014 	 * Allocate file space until done or until there is an error
1015 	 */
1016 	while (allocatesize_fsb && !error) {
1017 		xfs_fileoff_t	s, e;
1018 
1019 		/*
1020 		 * Determine space reservations for data/realtime.
1021 		 */
1022 		if (unlikely(extsz)) {
1023 			s = startoffset_fsb;
1024 			do_div(s, extsz);
1025 			s *= extsz;
1026 			e = startoffset_fsb + allocatesize_fsb;
1027 			if ((temp = do_mod(startoffset_fsb, extsz)))
1028 				e += temp;
1029 			if ((temp = do_mod(e, extsz)))
1030 				e += extsz - temp;
1031 		} else {
1032 			s = 0;
1033 			e = allocatesize_fsb;
1034 		}
1035 
1036 		/*
1037 		 * The transaction reservation is limited to a 32-bit block
1038 		 * count, hence we need to limit the number of blocks we are
1039 		 * trying to reserve to avoid an overflow. We can't allocate
1040 		 * more than @nimaps extents, and an extent is limited on disk
1041 		 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
1042 		 */
1043 		resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
1044 		if (unlikely(rt)) {
1045 			resrtextents = qblocks = resblks;
1046 			resrtextents /= mp->m_sb.sb_rextsize;
1047 			resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1048 			quota_flag = XFS_QMOPT_RES_RTBLKS;
1049 		} else {
1050 			resrtextents = 0;
1051 			resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
1052 			quota_flag = XFS_QMOPT_RES_REGBLKS;
1053 		}
1054 
1055 		/*
1056 		 * Allocate and setup the transaction.
1057 		 */
1058 		tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1059 		error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
1060 					  resblks, resrtextents);
1061 		/*
1062 		 * Check for running out of space
1063 		 */
1064 		if (error) {
1065 			/*
1066 			 * Free the transaction structure.
1067 			 */
1068 			ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1069 			xfs_trans_cancel(tp, 0);
1070 			break;
1071 		}
1072 		xfs_ilock(ip, XFS_ILOCK_EXCL);
1073 		error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
1074 						      0, quota_flag);
1075 		if (error)
1076 			goto error1;
1077 
1078 		xfs_trans_ijoin(tp, ip, 0);
1079 
1080 		xfs_bmap_init(&free_list, &firstfsb);
1081 		error = xfs_bmapi_write(tp, ip, startoffset_fsb,
1082 					allocatesize_fsb, alloc_type, &firstfsb,
1083 					0, imapp, &nimaps, &free_list);
1084 		if (error) {
1085 			goto error0;
1086 		}
1087 
1088 		/*
1089 		 * Complete the transaction
1090 		 */
1091 		error = xfs_bmap_finish(&tp, &free_list, &committed);
1092 		if (error) {
1093 			goto error0;
1094 		}
1095 
1096 		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1097 		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1098 		if (error) {
1099 			break;
1100 		}
1101 
1102 		allocated_fsb = imapp->br_blockcount;
1103 
1104 		if (nimaps == 0) {
1105 			error = XFS_ERROR(ENOSPC);
1106 			break;
1107 		}
1108 
1109 		startoffset_fsb += allocated_fsb;
1110 		allocatesize_fsb -= allocated_fsb;
1111 	}
1112 
1113 	return error;
1114 
1115 error0:	/* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1116 	xfs_bmap_cancel(&free_list);
1117 	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
1118 
1119 error1:	/* Just cancel transaction */
1120 	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1121 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1122 	return error;
1123 }
1124 
1125 /*
1126  * Zero file bytes between startoff and endoff inclusive.
1127  * The iolock is held exclusive and no blocks are buffered.
1128  *
1129  * This function is used by xfs_free_file_space() to zero
1130  * partial blocks when the range to free is not block aligned.
1131  * When unreserving space with boundaries that are not block
1132  * aligned we round up the start and round down the end
1133  * boundaries and then use this function to zero the parts of
1134  * the blocks that got dropped during the rounding.
1135  */
1136 STATIC int
1137 xfs_zero_remaining_bytes(
1138 	xfs_inode_t		*ip,
1139 	xfs_off_t		startoff,
1140 	xfs_off_t		endoff)
1141 {
1142 	xfs_bmbt_irec_t		imap;
1143 	xfs_fileoff_t		offset_fsb;
1144 	xfs_off_t		lastoffset;
1145 	xfs_off_t		offset;
1146 	xfs_buf_t		*bp;
1147 	xfs_mount_t		*mp = ip->i_mount;
1148 	int			nimap;
1149 	int			error = 0;
1150 
1151 	/*
1152 	 * Avoid doing I/O beyond eof - it's not necessary
1153 	 * since nothing can read beyond eof.  The space will
1154 	 * be zeroed when the file is extended anyway.
1155 	 */
1156 	if (startoff >= XFS_ISIZE(ip))
1157 		return 0;
1158 
1159 	if (endoff > XFS_ISIZE(ip))
1160 		endoff = XFS_ISIZE(ip);
1161 
1162 	bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
1163 					mp->m_rtdev_targp : mp->m_ddev_targp,
1164 				  BTOBB(mp->m_sb.sb_blocksize), 0);
1165 	if (!bp)
1166 		return XFS_ERROR(ENOMEM);
1167 
1168 	xfs_buf_unlock(bp);
1169 
1170 	for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
1171 		offset_fsb = XFS_B_TO_FSBT(mp, offset);
1172 		nimap = 1;
1173 		error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
1174 		if (error || nimap < 1)
1175 			break;
1176 		ASSERT(imap.br_blockcount >= 1);
1177 		ASSERT(imap.br_startoff == offset_fsb);
1178 		lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
1179 		if (lastoffset > endoff)
1180 			lastoffset = endoff;
1181 		if (imap.br_startblock == HOLESTARTBLOCK)
1182 			continue;
1183 		ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1184 		if (imap.br_state == XFS_EXT_UNWRITTEN)
1185 			continue;
1186 		XFS_BUF_UNDONE(bp);
1187 		XFS_BUF_UNWRITE(bp);
1188 		XFS_BUF_READ(bp);
1189 		XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
1190 
1191 		if (XFS_FORCED_SHUTDOWN(mp)) {
1192 			error = XFS_ERROR(EIO);
1193 			break;
1194 		}
1195 		xfs_buf_iorequest(bp);
1196 		error = xfs_buf_iowait(bp);
1197 		if (error) {
1198 			xfs_buf_ioerror_alert(bp,
1199 					"xfs_zero_remaining_bytes(read)");
1200 			break;
1201 		}
1202 		memset(bp->b_addr +
1203 			(offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
1204 		      0, lastoffset - offset + 1);
1205 		XFS_BUF_UNDONE(bp);
1206 		XFS_BUF_UNREAD(bp);
1207 		XFS_BUF_WRITE(bp);
1208 
1209 		if (XFS_FORCED_SHUTDOWN(mp)) {
1210 			error = XFS_ERROR(EIO);
1211 			break;
1212 		}
1213 		xfs_buf_iorequest(bp);
1214 		error = xfs_buf_iowait(bp);
1215 		if (error) {
1216 			xfs_buf_ioerror_alert(bp,
1217 					"xfs_zero_remaining_bytes(write)");
1218 			break;
1219 		}
1220 	}
1221 	xfs_buf_free(bp);
1222 	return error;
1223 }
1224 
1225 int
1226 xfs_free_file_space(
1227 	struct xfs_inode	*ip,
1228 	xfs_off_t		offset,
1229 	xfs_off_t		len)
1230 {
1231 	int			committed;
1232 	int			done;
1233 	xfs_fileoff_t		endoffset_fsb;
1234 	int			error;
1235 	xfs_fsblock_t		firstfsb;
1236 	xfs_bmap_free_t		free_list;
1237 	xfs_bmbt_irec_t		imap;
1238 	xfs_off_t		ioffset;
1239 	xfs_extlen_t		mod=0;
1240 	xfs_mount_t		*mp;
1241 	int			nimap;
1242 	uint			resblks;
1243 	xfs_off_t		rounding;
1244 	int			rt;
1245 	xfs_fileoff_t		startoffset_fsb;
1246 	xfs_trans_t		*tp;
1247 
1248 	mp = ip->i_mount;
1249 
1250 	trace_xfs_free_file_space(ip);
1251 
1252 	error = xfs_qm_dqattach(ip, 0);
1253 	if (error)
1254 		return error;
1255 
1256 	error = 0;
1257 	if (len <= 0)	/* if nothing being freed */
1258 		return error;
1259 	rt = XFS_IS_REALTIME_INODE(ip);
1260 	startoffset_fsb	= XFS_B_TO_FSB(mp, offset);
1261 	endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
1262 
1263 	/* wait for the completion of any pending DIOs */
1264 	inode_dio_wait(VFS_I(ip));
1265 
1266 	rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
1267 	ioffset = offset & ~(rounding - 1);
1268 	error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
1269 					      ioffset, -1);
1270 	if (error)
1271 		goto out;
1272 	truncate_pagecache_range(VFS_I(ip), ioffset, -1);
1273 
1274 	/*
1275 	 * Need to zero the stuff we're not freeing, on disk.
1276 	 * If it's a realtime file & can't use unwritten extents then we
1277 	 * actually need to zero the extent edges.  Otherwise xfs_bunmapi
1278 	 * will take care of it for us.
1279 	 */
1280 	if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
1281 		nimap = 1;
1282 		error = xfs_bmapi_read(ip, startoffset_fsb, 1,
1283 					&imap, &nimap, 0);
1284 		if (error)
1285 			goto out;
1286 		ASSERT(nimap == 0 || nimap == 1);
1287 		if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
1288 			xfs_daddr_t	block;
1289 
1290 			ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1291 			block = imap.br_startblock;
1292 			mod = do_div(block, mp->m_sb.sb_rextsize);
1293 			if (mod)
1294 				startoffset_fsb += mp->m_sb.sb_rextsize - mod;
1295 		}
1296 		nimap = 1;
1297 		error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
1298 					&imap, &nimap, 0);
1299 		if (error)
1300 			goto out;
1301 		ASSERT(nimap == 0 || nimap == 1);
1302 		if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
1303 			ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1304 			mod++;
1305 			if (mod && (mod != mp->m_sb.sb_rextsize))
1306 				endoffset_fsb -= mod;
1307 		}
1308 	}
1309 	if ((done = (endoffset_fsb <= startoffset_fsb)))
1310 		/*
1311 		 * One contiguous piece to clear
1312 		 */
1313 		error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
1314 	else {
1315 		/*
1316 		 * Some full blocks, possibly two pieces to clear
1317 		 */
1318 		if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
1319 			error = xfs_zero_remaining_bytes(ip, offset,
1320 				XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
1321 		if (!error &&
1322 		    XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
1323 			error = xfs_zero_remaining_bytes(ip,
1324 				XFS_FSB_TO_B(mp, endoffset_fsb),
1325 				offset + len - 1);
1326 	}
1327 
1328 	/*
1329 	 * free file space until done or until there is an error
1330 	 */
1331 	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1332 	while (!error && !done) {
1333 
1334 		/*
1335 		 * allocate and setup the transaction. Allow this
1336 		 * transaction to dip into the reserve blocks to ensure
1337 		 * the freeing of the space succeeds at ENOSPC.
1338 		 */
1339 		tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1340 		tp->t_flags |= XFS_TRANS_RESERVE;
1341 		error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, resblks, 0);
1342 
1343 		/*
1344 		 * check for running out of space
1345 		 */
1346 		if (error) {
1347 			/*
1348 			 * Free the transaction structure.
1349 			 */
1350 			ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1351 			xfs_trans_cancel(tp, 0);
1352 			break;
1353 		}
1354 		xfs_ilock(ip, XFS_ILOCK_EXCL);
1355 		error = xfs_trans_reserve_quota(tp, mp,
1356 				ip->i_udquot, ip->i_gdquot, ip->i_pdquot,
1357 				resblks, 0, XFS_QMOPT_RES_REGBLKS);
1358 		if (error)
1359 			goto error1;
1360 
1361 		xfs_trans_ijoin(tp, ip, 0);
1362 
1363 		/*
1364 		 * issue the bunmapi() call to free the blocks
1365 		 */
1366 		xfs_bmap_init(&free_list, &firstfsb);
1367 		error = xfs_bunmapi(tp, ip, startoffset_fsb,
1368 				  endoffset_fsb - startoffset_fsb,
1369 				  0, 2, &firstfsb, &free_list, &done);
1370 		if (error) {
1371 			goto error0;
1372 		}
1373 
1374 		/*
1375 		 * complete the transaction
1376 		 */
1377 		error = xfs_bmap_finish(&tp, &free_list, &committed);
1378 		if (error) {
1379 			goto error0;
1380 		}
1381 
1382 		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1383 		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1384 	}
1385 
1386  out:
1387 	return error;
1388 
1389  error0:
1390 	xfs_bmap_cancel(&free_list);
1391  error1:
1392 	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1393 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1394 	goto out;
1395 }
1396 
1397 
1398 int
1399 xfs_zero_file_space(
1400 	struct xfs_inode	*ip,
1401 	xfs_off_t		offset,
1402 	xfs_off_t		len)
1403 {
1404 	struct xfs_mount	*mp = ip->i_mount;
1405 	uint			granularity;
1406 	xfs_off_t		start_boundary;
1407 	xfs_off_t		end_boundary;
1408 	int			error;
1409 
1410 	granularity = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
1411 
1412 	/*
1413 	 * Round the range of extents we are going to convert inwards.  If the
1414 	 * offset is aligned, then it doesn't get changed so we zero from the
1415 	 * start of the block offset points to.
1416 	 */
1417 	start_boundary = round_up(offset, granularity);
1418 	end_boundary = round_down(offset + len, granularity);
1419 
1420 	ASSERT(start_boundary >= offset);
1421 	ASSERT(end_boundary <= offset + len);
1422 
1423 	if (start_boundary < end_boundary - 1) {
1424 		/* punch out the page cache over the conversion range */
1425 		truncate_pagecache_range(VFS_I(ip), start_boundary,
1426 					 end_boundary - 1);
1427 		/* convert the blocks */
1428 		error = xfs_alloc_file_space(ip, start_boundary,
1429 					end_boundary - start_boundary - 1,
1430 					XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT);
1431 		if (error)
1432 			goto out;
1433 
1434 		/* We've handled the interior of the range, now for the edges */
1435 		if (start_boundary != offset) {
1436 			error = xfs_iozero(ip, offset, start_boundary - offset);
1437 			if (error)
1438 				goto out;
1439 		}
1440 
1441 		if (end_boundary != offset + len)
1442 			error = xfs_iozero(ip, end_boundary,
1443 					   offset + len - end_boundary);
1444 
1445 	} else {
1446 		/*
1447 		 * It's either a sub-granularity range or the range spanned lies
1448 		 * partially across two adjacent blocks.
1449 		 */
1450 		error = xfs_iozero(ip, offset, len);
1451 	}
1452 
1453 out:
1454 	return error;
1455 
1456 }
1457 
1458 /*
1459  * We need to check that the format of the data fork in the temporary inode is
1460  * valid for the target inode before doing the swap. This is not a problem with
1461  * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1462  * data fork depending on the space the attribute fork is taking so we can get
1463  * invalid formats on the target inode.
1464  *
1465  * E.g. target has space for 7 extents in extent format, temp inode only has
1466  * space for 6.  If we defragment down to 7 extents, then the tmp format is a
1467  * btree, but when swapped it needs to be in extent format. Hence we can't just
1468  * blindly swap data forks on attr2 filesystems.
1469  *
1470  * Note that we check the swap in both directions so that we don't end up with
1471  * a corrupt temporary inode, either.
1472  *
1473  * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1474  * inode will prevent this situation from occurring, so all we do here is
1475  * reject and log the attempt. basically we are putting the responsibility on
1476  * userspace to get this right.
1477  */
1478 static int
1479 xfs_swap_extents_check_format(
1480 	xfs_inode_t	*ip,	/* target inode */
1481 	xfs_inode_t	*tip)	/* tmp inode */
1482 {
1483 
1484 	/* Should never get a local format */
1485 	if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
1486 	    tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
1487 		return EINVAL;
1488 
1489 	/*
1490 	 * if the target inode has less extents that then temporary inode then
1491 	 * why did userspace call us?
1492 	 */
1493 	if (ip->i_d.di_nextents < tip->i_d.di_nextents)
1494 		return EINVAL;
1495 
1496 	/*
1497 	 * if the target inode is in extent form and the temp inode is in btree
1498 	 * form then we will end up with the target inode in the wrong format
1499 	 * as we already know there are less extents in the temp inode.
1500 	 */
1501 	if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1502 	    tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
1503 		return EINVAL;
1504 
1505 	/* Check temp in extent form to max in target */
1506 	if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1507 	    XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >
1508 			XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1509 		return EINVAL;
1510 
1511 	/* Check target in extent form to max in temp */
1512 	if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1513 	    XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >
1514 			XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1515 		return EINVAL;
1516 
1517 	/*
1518 	 * If we are in a btree format, check that the temp root block will fit
1519 	 * in the target and that it has enough extents to be in btree format
1520 	 * in the target.
1521 	 *
1522 	 * Note that we have to be careful to allow btree->extent conversions
1523 	 * (a common defrag case) which will occur when the temp inode is in
1524 	 * extent format...
1525 	 */
1526 	if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1527 		if (XFS_IFORK_BOFF(ip) &&
1528 		    XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip))
1529 			return EINVAL;
1530 		if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
1531 		    XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1532 			return EINVAL;
1533 	}
1534 
1535 	/* Reciprocal target->temp btree format checks */
1536 	if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1537 		if (XFS_IFORK_BOFF(tip) &&
1538 		    XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
1539 			return EINVAL;
1540 		if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
1541 		    XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1542 			return EINVAL;
1543 	}
1544 
1545 	return 0;
1546 }
1547 
1548 int
1549 xfs_swap_extents(
1550 	xfs_inode_t	*ip,	/* target inode */
1551 	xfs_inode_t	*tip,	/* tmp inode */
1552 	xfs_swapext_t	*sxp)
1553 {
1554 	xfs_mount_t	*mp = ip->i_mount;
1555 	xfs_trans_t	*tp;
1556 	xfs_bstat_t	*sbp = &sxp->sx_stat;
1557 	xfs_ifork_t	*tempifp, *ifp, *tifp;
1558 	int		src_log_flags, target_log_flags;
1559 	int		error = 0;
1560 	int		aforkblks = 0;
1561 	int		taforkblks = 0;
1562 	__uint64_t	tmp;
1563 
1564 	tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
1565 	if (!tempifp) {
1566 		error = XFS_ERROR(ENOMEM);
1567 		goto out;
1568 	}
1569 
1570 	/*
1571 	 * we have to do two separate lock calls here to keep lockdep
1572 	 * happy. If we try to get all the locks in one call, lock will
1573 	 * report false positives when we drop the ILOCK and regain them
1574 	 * below.
1575 	 */
1576 	xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL);
1577 	xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
1578 
1579 	/* Verify that both files have the same format */
1580 	if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
1581 		error = XFS_ERROR(EINVAL);
1582 		goto out_unlock;
1583 	}
1584 
1585 	/* Verify both files are either real-time or non-realtime */
1586 	if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1587 		error = XFS_ERROR(EINVAL);
1588 		goto out_unlock;
1589 	}
1590 
1591 	error = -filemap_write_and_wait(VFS_I(tip)->i_mapping);
1592 	if (error)
1593 		goto out_unlock;
1594 	truncate_pagecache_range(VFS_I(tip), 0, -1);
1595 
1596 	/* Verify O_DIRECT for ftmp */
1597 	if (VN_CACHED(VFS_I(tip)) != 0) {
1598 		error = XFS_ERROR(EINVAL);
1599 		goto out_unlock;
1600 	}
1601 
1602 	/* Verify all data are being swapped */
1603 	if (sxp->sx_offset != 0 ||
1604 	    sxp->sx_length != ip->i_d.di_size ||
1605 	    sxp->sx_length != tip->i_d.di_size) {
1606 		error = XFS_ERROR(EFAULT);
1607 		goto out_unlock;
1608 	}
1609 
1610 	trace_xfs_swap_extent_before(ip, 0);
1611 	trace_xfs_swap_extent_before(tip, 1);
1612 
1613 	/* check inode formats now that data is flushed */
1614 	error = xfs_swap_extents_check_format(ip, tip);
1615 	if (error) {
1616 		xfs_notice(mp,
1617 		    "%s: inode 0x%llx format is incompatible for exchanging.",
1618 				__func__, ip->i_ino);
1619 		goto out_unlock;
1620 	}
1621 
1622 	/*
1623 	 * Compare the current change & modify times with that
1624 	 * passed in.  If they differ, we abort this swap.
1625 	 * This is the mechanism used to ensure the calling
1626 	 * process that the file was not changed out from
1627 	 * under it.
1628 	 */
1629 	if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1630 	    (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1631 	    (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1632 	    (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
1633 		error = XFS_ERROR(EBUSY);
1634 		goto out_unlock;
1635 	}
1636 
1637 	/* We need to fail if the file is memory mapped.  Once we have tossed
1638 	 * all existing pages, the page fault will have no option
1639 	 * but to go to the filesystem for pages. By making the page fault call
1640 	 * vop_read (or write in the case of autogrow) they block on the iolock
1641 	 * until we have switched the extents.
1642 	 */
1643 	if (VN_MAPPED(VFS_I(ip))) {
1644 		error = XFS_ERROR(EBUSY);
1645 		goto out_unlock;
1646 	}
1647 
1648 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1649 	xfs_iunlock(tip, XFS_ILOCK_EXCL);
1650 
1651 	/*
1652 	 * There is a race condition here since we gave up the
1653 	 * ilock.  However, the data fork will not change since
1654 	 * we have the iolock (locked for truncation too) so we
1655 	 * are safe.  We don't really care if non-io related
1656 	 * fields change.
1657 	 */
1658 	truncate_pagecache_range(VFS_I(ip), 0, -1);
1659 
1660 	tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
1661 	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1662 	if (error) {
1663 		xfs_iunlock(ip,  XFS_IOLOCK_EXCL);
1664 		xfs_iunlock(tip, XFS_IOLOCK_EXCL);
1665 		xfs_trans_cancel(tp, 0);
1666 		goto out;
1667 	}
1668 	xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
1669 
1670 	/*
1671 	 * Count the number of extended attribute blocks
1672 	 */
1673 	if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) &&
1674 	     (ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
1675 		error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks);
1676 		if (error)
1677 			goto out_trans_cancel;
1678 	}
1679 	if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) &&
1680 	     (tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
1681 		error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK,
1682 			&taforkblks);
1683 		if (error)
1684 			goto out_trans_cancel;
1685 	}
1686 
1687 	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1688 	xfs_trans_ijoin(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1689 
1690 	/*
1691 	 * Before we've swapped the forks, lets set the owners of the forks
1692 	 * appropriately. We have to do this as we are demand paging the btree
1693 	 * buffers, and so the validation done on read will expect the owner
1694 	 * field to be correctly set. Once we change the owners, we can swap the
1695 	 * inode forks.
1696 	 *
1697 	 * Note the trickiness in setting the log flags - we set the owner log
1698 	 * flag on the opposite inode (i.e. the inode we are setting the new
1699 	 * owner to be) because once we swap the forks and log that, log
1700 	 * recovery is going to see the fork as owned by the swapped inode,
1701 	 * not the pre-swapped inodes.
1702 	 */
1703 	src_log_flags = XFS_ILOG_CORE;
1704 	target_log_flags = XFS_ILOG_CORE;
1705 	if (ip->i_d.di_version == 3 &&
1706 	    ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1707 		target_log_flags |= XFS_ILOG_DOWNER;
1708 		error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK,
1709 					      tip->i_ino, NULL);
1710 		if (error)
1711 			goto out_trans_cancel;
1712 	}
1713 
1714 	if (tip->i_d.di_version == 3 &&
1715 	    tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1716 		src_log_flags |= XFS_ILOG_DOWNER;
1717 		error = xfs_bmbt_change_owner(tp, tip, XFS_DATA_FORK,
1718 					      ip->i_ino, NULL);
1719 		if (error)
1720 			goto out_trans_cancel;
1721 	}
1722 
1723 	/*
1724 	 * Swap the data forks of the inodes
1725 	 */
1726 	ifp = &ip->i_df;
1727 	tifp = &tip->i_df;
1728 	*tempifp = *ifp;	/* struct copy */
1729 	*ifp = *tifp;		/* struct copy */
1730 	*tifp = *tempifp;	/* struct copy */
1731 
1732 	/*
1733 	 * Fix the on-disk inode values
1734 	 */
1735 	tmp = (__uint64_t)ip->i_d.di_nblocks;
1736 	ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
1737 	tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
1738 
1739 	tmp = (__uint64_t) ip->i_d.di_nextents;
1740 	ip->i_d.di_nextents = tip->i_d.di_nextents;
1741 	tip->i_d.di_nextents = tmp;
1742 
1743 	tmp = (__uint64_t) ip->i_d.di_format;
1744 	ip->i_d.di_format = tip->i_d.di_format;
1745 	tip->i_d.di_format = tmp;
1746 
1747 	/*
1748 	 * The extents in the source inode could still contain speculative
1749 	 * preallocation beyond EOF (e.g. the file is open but not modified
1750 	 * while defrag is in progress). In that case, we need to copy over the
1751 	 * number of delalloc blocks the data fork in the source inode is
1752 	 * tracking beyond EOF so that when the fork is truncated away when the
1753 	 * temporary inode is unlinked we don't underrun the i_delayed_blks
1754 	 * counter on that inode.
1755 	 */
1756 	ASSERT(tip->i_delayed_blks == 0);
1757 	tip->i_delayed_blks = ip->i_delayed_blks;
1758 	ip->i_delayed_blks = 0;
1759 
1760 	switch (ip->i_d.di_format) {
1761 	case XFS_DINODE_FMT_EXTENTS:
1762 		/* If the extents fit in the inode, fix the
1763 		 * pointer.  Otherwise it's already NULL or
1764 		 * pointing to the extent.
1765 		 */
1766 		if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) {
1767 			ifp->if_u1.if_extents =
1768 				ifp->if_u2.if_inline_ext;
1769 		}
1770 		src_log_flags |= XFS_ILOG_DEXT;
1771 		break;
1772 	case XFS_DINODE_FMT_BTREE:
1773 		ASSERT(ip->i_d.di_version < 3 ||
1774 		       (src_log_flags & XFS_ILOG_DOWNER));
1775 		src_log_flags |= XFS_ILOG_DBROOT;
1776 		break;
1777 	}
1778 
1779 	switch (tip->i_d.di_format) {
1780 	case XFS_DINODE_FMT_EXTENTS:
1781 		/* If the extents fit in the inode, fix the
1782 		 * pointer.  Otherwise it's already NULL or
1783 		 * pointing to the extent.
1784 		 */
1785 		if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) {
1786 			tifp->if_u1.if_extents =
1787 				tifp->if_u2.if_inline_ext;
1788 		}
1789 		target_log_flags |= XFS_ILOG_DEXT;
1790 		break;
1791 	case XFS_DINODE_FMT_BTREE:
1792 		target_log_flags |= XFS_ILOG_DBROOT;
1793 		ASSERT(tip->i_d.di_version < 3 ||
1794 		       (target_log_flags & XFS_ILOG_DOWNER));
1795 		break;
1796 	}
1797 
1798 	xfs_trans_log_inode(tp, ip,  src_log_flags);
1799 	xfs_trans_log_inode(tp, tip, target_log_flags);
1800 
1801 	/*
1802 	 * If this is a synchronous mount, make sure that the
1803 	 * transaction goes to disk before returning to the user.
1804 	 */
1805 	if (mp->m_flags & XFS_MOUNT_WSYNC)
1806 		xfs_trans_set_sync(tp);
1807 
1808 	error = xfs_trans_commit(tp, 0);
1809 
1810 	trace_xfs_swap_extent_after(ip, 0);
1811 	trace_xfs_swap_extent_after(tip, 1);
1812 out:
1813 	kmem_free(tempifp);
1814 	return error;
1815 
1816 out_unlock:
1817 	xfs_iunlock(ip,  XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1818 	xfs_iunlock(tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1819 	goto out;
1820 
1821 out_trans_cancel:
1822 	xfs_trans_cancel(tp, 0);
1823 	goto out_unlock;
1824 }
1825