xfs_bmap.c 167 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2
/*
3
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
5 6
 */
#include "xfs.h"
7
#include "xfs_fs.h"
8
#include "xfs_shared.h"
9 10 11
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
12
#include "xfs_bit.h"
Linus Torvalds's avatar
Linus Torvalds committed
13
#include "xfs_sb.h"
14
#include "xfs_mount.h"
15
#include "xfs_defer.h"
16
#include "xfs_da_format.h"
17
#include "xfs_da_btree.h"
18
#include "xfs_dir2.h"
Linus Torvalds's avatar
Linus Torvalds committed
19
#include "xfs_inode.h"
20
#include "xfs_btree.h"
21
#include "xfs_trans.h"
22
#include "xfs_inode_item.h"
Linus Torvalds's avatar
Linus Torvalds committed
23 24 25
#include "xfs_extfree_item.h"
#include "xfs_alloc.h"
#include "xfs_bmap.h"
26
#include "xfs_bmap_util.h"
27
#include "xfs_bmap_btree.h"
Linus Torvalds's avatar
Linus Torvalds committed
28
#include "xfs_rtalloc.h"
29
#include "xfs_errortag.h"
Linus Torvalds's avatar
Linus Torvalds committed
30 31 32 33
#include "xfs_error.h"
#include "xfs_quota.h"
#include "xfs_trans_space.h"
#include "xfs_buf_item.h"
34
#include "xfs_trace.h"
35
#include "xfs_symlink.h"
36 37
#include "xfs_attr_leaf.h"
#include "xfs_filestream.h"
38
#include "xfs_rmap.h"
39
#include "xfs_ag_resv.h"
40
#include "xfs_refcount.h"
41
#include "xfs_icache.h"
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45 46


kmem_zone_t		*xfs_bmap_free_item_zone;

/*
47
 * Miscellaneous helper functions
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50
 */

/*
51 52
 * Compute and fill in the value of the maximum depth of a bmap btree
 * in this filesystem.  Done once, during mount.
Linus Torvalds's avatar
Linus Torvalds committed
53
 */
54 55 56 57 58 59 60 61 62 63 64 65
void
xfs_bmap_compute_maxlevels(
	xfs_mount_t	*mp,		/* file system mount structure */
	int		whichfork)	/* data or attr fork */
{
	int		level;		/* btree level */
	uint		maxblocks;	/* max blocks at this level */
	uint		maxleafents;	/* max leaf entries possible */
	int		maxrootrecs;	/* max records in root block */
	int		minleafrecs;	/* min records in leaf block */
	int		minnoderecs;	/* min records in node block */
	int		sz;		/* root block size */
Linus Torvalds's avatar
Linus Torvalds committed
66

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
	/*
	 * The maximum number of extents in a file, hence the maximum
	 * number of leaf entries, is controlled by the type of di_nextents
	 * (a signed 32-bit number, xfs_extnum_t), or by di_anextents
	 * (a signed 16-bit number, xfs_aextnum_t).
	 *
	 * Note that we can no longer assume that if we are in ATTR1 that
	 * the fork offset of all the inodes will be
	 * (xfs_default_attroffset(ip) >> 3) because we could have mounted
	 * with ATTR2 and then mounted back with ATTR1, keeping the
	 * di_forkoff's fixed but probably at various positions. Therefore,
	 * for both ATTR1 and ATTR2 we have to assume the worst case scenario
	 * of a minimum size available.
	 */
	if (whichfork == XFS_DATA_FORK) {
		maxleafents = MAXEXTNUM;
		sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
	} else {
		maxleafents = MAXAEXTNUM;
		sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
	}
88
	maxrootrecs = xfs_bmdr_maxrecs(sz, 0);
89 90 91 92 93 94 95 96 97 98 99
	minleafrecs = mp->m_bmap_dmnr[0];
	minnoderecs = mp->m_bmap_dmnr[1];
	maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
	for (level = 1; maxblocks > 1; level++) {
		if (maxblocks <= maxrootrecs)
			maxblocks = 1;
		else
			maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs;
	}
	mp->m_bm_maxlevels[whichfork] = level;
}
100

101 102 103
STATIC int				/* error */
xfs_bmbt_lookup_eq(
	struct xfs_btree_cur	*cur,
104
	struct xfs_bmbt_irec	*irec,
105 106
	int			*stat)	/* success/failure */
{
107
	cur->bc_rec.b = *irec;
108 109 110 111
	return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
}

STATIC int				/* error */
112
xfs_bmbt_lookup_first(
113 114 115
	struct xfs_btree_cur	*cur,
	int			*stat)	/* success/failure */
{
116 117 118
	cur->bc_rec.b.br_startoff = 0;
	cur->bc_rec.b.br_startblock = 0;
	cur->bc_rec.b.br_blockcount = 0;
119 120 121
	return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
}

122
/*
123 124 125 126
 * Check if the inode needs to be converted to btree format.
 */
static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
{
127 128
	return whichfork != XFS_COW_FORK &&
		XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
129 130 131 132 133 134 135 136 137
		XFS_IFORK_NEXTENTS(ip, whichfork) >
			XFS_IFORK_MAXEXT(ip, whichfork);
}

/*
 * Check if the inode should be converted to extent format.
 */
static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
{
138 139
	return whichfork != XFS_COW_FORK &&
		XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
140 141 142 143 144
		XFS_IFORK_NEXTENTS(ip, whichfork) <=
			XFS_IFORK_MAXEXT(ip, whichfork);
}

/*
145
 * Update the record referred to by cur to the value given by irec
146 147 148 149 150
 * This either works (return 0) or gets an EFSCORRUPTED error.
 */
STATIC int
xfs_bmbt_update(
	struct xfs_btree_cur	*cur,
151
	struct xfs_bmbt_irec	*irec)
152 153 154
{
	union xfs_btree_rec	rec;

155
	xfs_bmbt_disk_set_all(&rec.bmbt, irec);
156 157
	return xfs_btree_update(cur, &rec);
}
158

Linus Torvalds's avatar
Linus Torvalds committed
159
/*
160 161
 * Compute the worst-case number of indirect blocks that will be used
 * for ip's delayed extent of length "len".
Linus Torvalds's avatar
Linus Torvalds committed
162
 */
163 164 165 166
STATIC xfs_filblks_t
xfs_bmap_worst_indlen(
	xfs_inode_t	*ip,		/* incore inode pointer */
	xfs_filblks_t	len)		/* delayed extent length */
Linus Torvalds's avatar
Linus Torvalds committed
167
{
168 169 170 171
	int		level;		/* btree level number */
	int		maxrecs;	/* maximum record count at this level */
	xfs_mount_t	*mp;		/* mount structure */
	xfs_filblks_t	rval;		/* return value */
Linus Torvalds's avatar
Linus Torvalds committed
172 173

	mp = ip->i_mount;
174 175 176 177 178 179 180
	maxrecs = mp->m_bmap_dmxr[0];
	for (level = 0, rval = 0;
	     level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK);
	     level++) {
		len += maxrecs - 1;
		do_div(len, maxrecs);
		rval += len;
181 182
		if (len == 1)
			return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) -
183 184 185
				level - 1;
		if (level == 0)
			maxrecs = mp->m_bmap_dmxr[1];
Linus Torvalds's avatar
Linus Torvalds committed
186
	}
187
	return rval;
Linus Torvalds's avatar
Linus Torvalds committed
188 189 190
}

/*
191
 * Calculate the default attribute fork offset for newly created inodes.
Linus Torvalds's avatar
Linus Torvalds committed
192
 */
193 194 195
uint
xfs_default_attroffset(
	struct xfs_inode	*ip)
Linus Torvalds's avatar
Linus Torvalds committed
196
{
197 198
	struct xfs_mount	*mp = ip->i_mount;
	uint			offset;
Linus Torvalds's avatar
Linus Torvalds committed
199

200
	if (mp->m_sb.sb_inodesize == 256) {
201
		offset = XFS_LITINO(mp, ip->i_d.di_version) -
202 203 204
				XFS_BMDR_SPACE_CALC(MINABTPTRS);
	} else {
		offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
Linus Torvalds's avatar
Linus Torvalds committed
205
	}
206

207
	ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version));
208
	return offset;
Linus Torvalds's avatar
Linus Torvalds committed
209 210 211
}

/*
212 213 214
 * Helper routine to reset inode di_forkoff field when switching
 * attribute fork from local to extent format - we reset it where
 * possible to make space available for inline data fork extents.
215 216
 */
STATIC void
217 218 219
xfs_bmap_forkoff_reset(
	xfs_inode_t	*ip,
	int		whichfork)
220
{
221 222 223 224 225 226 227 228
	if (whichfork == XFS_ATTR_FORK &&
	    ip->i_d.di_format != XFS_DINODE_FMT_DEV &&
	    ip->i_d.di_format != XFS_DINODE_FMT_BTREE) {
		uint	dfl_forkoff = xfs_default_attroffset(ip) >> 3;

		if (dfl_forkoff > ip->i_d.di_forkoff)
			ip->i_d.di_forkoff = dfl_forkoff;
	}
229 230
}

231 232 233 234 235 236
#ifdef DEBUG
STATIC struct xfs_buf *
xfs_bmap_get_bp(
	struct xfs_btree_cur	*cur,
	xfs_fsblock_t		bno)
{
237
	struct xfs_log_item	*lip;
238
	int			i;
239

240 241 242 243 244 245 246 247
	if (!cur)
		return NULL;

	for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) {
		if (!cur->bc_bufs[i])
			break;
		if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno)
			return cur->bc_bufs[i];
Linus Torvalds's avatar
Linus Torvalds committed
248
	}
249

250
	/* Chase down all the log items to see if the bp is there */
251 252 253
	list_for_each_entry(lip, &cur->bc_tp->t_items, li_trans) {
		struct xfs_buf_log_item	*bip = (struct xfs_buf_log_item *)lip;

254 255 256 257
		if (bip->bli_item.li_type == XFS_LI_BUF &&
		    XFS_BUF_ADDR(bip->bli_buf) == bno)
			return bip->bli_buf;
	}
258

259 260
	return NULL;
}
261

262 263 264 265 266 267 268 269 270 271
STATIC void
xfs_check_block(
	struct xfs_btree_block	*block,
	xfs_mount_t		*mp,
	int			root,
	short			sz)
{
	int			i, j, dmxr;
	__be64			*pp, *thispa;	/* pointer to block address */
	xfs_bmbt_key_t		*prevp, *keyp;
Linus Torvalds's avatar
Linus Torvalds committed
272

273
	ASSERT(be16_to_cpu(block->bb_level) > 0);
Christoph Hellwig's avatar
Christoph Hellwig committed
274

275 276 277 278
	prevp = NULL;
	for( i = 1; i <= xfs_btree_get_numrecs(block); i++) {
		dmxr = mp->m_bmap_dmxr[0];
		keyp = XFS_BMBT_KEY_ADDR(mp, block, i);
279

280 281 282
		if (prevp) {
			ASSERT(be64_to_cpu(prevp->br_startoff) <
			       be64_to_cpu(keyp->br_startoff));
Linus Torvalds's avatar
Linus Torvalds committed
283
		}
284
		prevp = keyp;
Linus Torvalds's avatar
Linus Torvalds committed
285 286

		/*
287
		 * Compare the block numbers to see if there are dups.
Linus Torvalds's avatar
Linus Torvalds committed
288
		 */
289 290 291 292
		if (root)
			pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);
		else
			pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr);
293

294 295 296 297 298 299 300 301 302
		for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {
			if (root)
				thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);
			else
				thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr);
			if (*thispa == *pp) {
				xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld",
					__func__, j, i,
					(unsigned long long)be64_to_cpu(*thispa));
303
				xfs_err(mp, "%s: ptrs are equal in node\n",
304
					__func__);
305
				xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
306
			}
Linus Torvalds's avatar
Linus Torvalds committed
307
		}
308 309
	}
}
Linus Torvalds's avatar
Linus Torvalds committed
310

311 312
/*
 * Check that the extents for the inode ip are in the right order in all
313 314 315 316
 * btree leaves. THis becomes prohibitively expensive for large extent count
 * files, so don't bother with inodes that have more than 10,000 extents in
 * them. The btree record ordering checks will still be done, so for such large
 * bmapbt constructs that is going to catch most corruptions.
317 318 319 320 321 322 323 324 325 326 327 328
 */
STATIC void
xfs_bmap_check_leaf_extents(
	xfs_btree_cur_t		*cur,	/* btree cursor or null */
	xfs_inode_t		*ip,		/* incore inode pointer */
	int			whichfork)	/* data or attr fork */
{
	struct xfs_btree_block	*block;	/* current btree block */
	xfs_fsblock_t		bno;	/* block # of "block" */
	xfs_buf_t		*bp;	/* buffer for "block" */
	int			error;	/* error return value */
	xfs_extnum_t		i=0, j;	/* index into the extents list */
329
	struct xfs_ifork	*ifp;	/* fork structure */
330 331 332 333 334 335 336 337 338 339 340 341
	int			level;	/* btree level, for checking */
	xfs_mount_t		*mp;	/* file system mount structure */
	__be64			*pp;	/* pointer to block address */
	xfs_bmbt_rec_t		*ep;	/* pointer to current extent */
	xfs_bmbt_rec_t		last = {0, 0}; /* last extent in prev block */
	xfs_bmbt_rec_t		*nextp;	/* pointer to next extent */
	int			bp_release = 0;

	if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) {
		return;
	}

342 343 344 345
	/* skip large extent count inodes */
	if (ip->i_d.di_nextents > 10000)
		return;

346 347 348 349 350 351 352 353 354 355 356 357 358
	bno = NULLFSBLOCK;
	mp = ip->i_mount;
	ifp = XFS_IFORK_PTR(ip, whichfork);
	block = ifp->if_broot;
	/*
	 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
	 */
	level = be16_to_cpu(block->bb_level);
	ASSERT(level > 0);
	xfs_check_block(block, mp, 1, ifp->if_broot_bytes);
	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
	bno = be64_to_cpu(*pp);

359
	ASSERT(bno != NULLFSBLOCK);
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
	ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
	ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);

	/*
	 * Go down the tree until leaf level is reached, following the first
	 * pointer (leftmost) at each level.
	 */
	while (level-- > 0) {
		/* See if buf is in cur first */
		bp_release = 0;
		bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
		if (!bp) {
			bp_release = 1;
			error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
						XFS_BMAP_BTREE_REF,
						&xfs_bmbt_buf_ops);
376
			if (error)
377
				goto error_norelse;
Linus Torvalds's avatar
Linus Torvalds committed
378
		}
379 380 381
		block = XFS_BUF_TO_BLOCK(bp);
		if (level == 0)
			break;
Linus Torvalds's avatar
Linus Torvalds committed
382 383

		/*
384 385
		 * Check this block for basic sanity (increasing keys and
		 * no duplicate blocks).
Linus Torvalds's avatar
Linus Torvalds committed
386
		 */
387

388 389 390
		xfs_check_block(block, mp, 0, 0);
		pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
		bno = be64_to_cpu(*pp);
391
		XFS_WANT_CORRUPTED_GOTO(mp,
392
					xfs_verify_fsbno(mp, bno), error0);
393 394 395
		if (bp_release) {
			bp_release = 0;
			xfs_trans_brelse(NULL, bp);
Linus Torvalds's avatar
Linus Torvalds committed
396
		}
397
	}
Christoph Hellwig's avatar
Christoph Hellwig committed
398

399 400 401 402 403 404 405 406 407 408 409 410 411 412
	/*
	 * Here with bp and block set to the leftmost leaf node in the tree.
	 */
	i = 0;

	/*
	 * Loop over all leaf nodes checking that all extents are in the right order.
	 */
	for (;;) {
		xfs_fsblock_t	nextbno;
		xfs_extnum_t	num_recs;


		num_recs = xfs_btree_get_numrecs(block);
Linus Torvalds's avatar
Linus Torvalds committed
413 414

		/*
415
		 * Read-ahead the next leaf block, if any.
Linus Torvalds's avatar
Linus Torvalds committed
416
		 */
417

418
		nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
Linus Torvalds's avatar
Linus Torvalds committed
419 420

		/*
421 422 423
		 * Check all the extents to make sure they are OK.
		 * If we had a previous block, the last entry should
		 * conform with the first entry in this one.
Linus Torvalds's avatar
Linus Torvalds committed
424
		 */
Christoph Hellwig's avatar
Christoph Hellwig committed
425

426 427 428 429 430 431 432 433 434 435 436 437 438
		ep = XFS_BMBT_REC_ADDR(mp, block, 1);
		if (i) {
			ASSERT(xfs_bmbt_disk_get_startoff(&last) +
			       xfs_bmbt_disk_get_blockcount(&last) <=
			       xfs_bmbt_disk_get_startoff(ep));
		}
		for (j = 1; j < num_recs; j++) {
			nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1);
			ASSERT(xfs_bmbt_disk_get_startoff(ep) +
			       xfs_bmbt_disk_get_blockcount(ep) <=
			       xfs_bmbt_disk_get_startoff(nextp));
			ep = nextp;
		}
Linus Torvalds's avatar
Linus Torvalds committed
439

440 441 442 443 444 445 446
		last = *ep;
		i += num_recs;
		if (bp_release) {
			bp_release = 0;
			xfs_trans_brelse(NULL, bp);
		}
		bno = nextbno;
Linus Torvalds's avatar
Linus Torvalds committed
447
		/*
448
		 * If we've reached the end, stop.
Linus Torvalds's avatar
Linus Torvalds committed
449
		 */
450 451
		if (bno == NULLFSBLOCK)
			break;
452

453 454 455 456 457 458 459
		bp_release = 0;
		bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
		if (!bp) {
			bp_release = 1;
			error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
						XFS_BMAP_BTREE_REF,
						&xfs_bmbt_buf_ops);
460
			if (error)
461
				goto error_norelse;
Linus Torvalds's avatar
Linus Torvalds committed
462
		}
463
		block = XFS_BUF_TO_BLOCK(bp);
464
	}
465

466
	return;
467

468 469 470 471 472 473 474
error0:
	xfs_warn(mp, "%s: at error0", __func__);
	if (bp_release)
		xfs_trans_brelse(NULL, bp);
error_norelse:
	xfs_warn(mp, "%s: BAD after btree leaves for %d extents",
		__func__, i);
475 476
	xfs_err(mp, "%s: CORRUPTED BTREE OR SOMETHING", __func__);
	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
477
	return;
Linus Torvalds's avatar
Linus Torvalds committed
478 479
}

480 481
/*
 * Validate that the bmbt_irecs being returned from bmapi are valid
482 483
 * given the caller's original parameters.  Specifically check the
 * ranges of the returned irecs to ensure that they only extend beyond
484 485 486 487 488 489 490 491 492 493 494 495
 * the given parameters if the XFS_BMAPI_ENTIRE flag was set.
 */
STATIC void
xfs_bmap_validate_ret(
	xfs_fileoff_t		bno,
	xfs_filblks_t		len,
	int			flags,
	xfs_bmbt_irec_t		*mval,
	int			nmap,
	int			ret_nmap)
{
	int			i;		/* index to map values */
496

497
	ASSERT(ret_nmap <= nmap);
498

499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
	for (i = 0; i < ret_nmap; i++) {
		ASSERT(mval[i].br_blockcount > 0);
		if (!(flags & XFS_BMAPI_ENTIRE)) {
			ASSERT(mval[i].br_startoff >= bno);
			ASSERT(mval[i].br_blockcount <= len);
			ASSERT(mval[i].br_startoff + mval[i].br_blockcount <=
			       bno + len);
		} else {
			ASSERT(mval[i].br_startoff < bno + len);
			ASSERT(mval[i].br_startoff + mval[i].br_blockcount >
			       bno);
		}
		ASSERT(i == 0 ||
		       mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
		       mval[i].br_startoff);
		ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
		       mval[i].br_startblock != HOLESTARTBLOCK);
		ASSERT(mval[i].br_state == XFS_EXT_NORM ||
		       mval[i].br_state == XFS_EXT_UNWRITTEN);
	}
}
520

521 522
#else
#define xfs_bmap_check_leaf_extents(cur, ip, whichfork)		do { } while (0)
523
#define	xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap)	do { } while (0)
524
#endif /* DEBUG */
525

526 527 528
/*
 * bmap free list manipulation functions
 */
529

530 531 532 533 534
/*
 * Add the extent to the list of extents to be free at transaction end.
 * The list is maintained sorted (by block number).
 */
void
535
__xfs_bmap_add_free(
536
	struct xfs_trans		*tp,
537 538
	xfs_fsblock_t			bno,
	xfs_filblks_t			len,
539 540
	struct xfs_owner_info		*oinfo,
	bool				skip_discard)
541
{
542
	struct xfs_extent_free_item	*new;		/* new element */
543
#ifdef DEBUG
544 545 546
	struct xfs_mount		*mp = tp->t_mountp;
	xfs_agnumber_t			agno;
	xfs_agblock_t			agbno;
547 548 549 550 551 552 553 554 555 556 557 558 559

	ASSERT(bno != NULLFSBLOCK);
	ASSERT(len > 0);
	ASSERT(len <= MAXEXTLEN);
	ASSERT(!isnullstartblock(bno));
	agno = XFS_FSB_TO_AGNO(mp, bno);
	agbno = XFS_FSB_TO_AGBNO(mp, bno);
	ASSERT(agno < mp->m_sb.sb_agcount);
	ASSERT(agbno < mp->m_sb.sb_agblocks);
	ASSERT(len < mp->m_sb.sb_agblocks);
	ASSERT(agbno + len <= mp->m_sb.sb_agblocks);
#endif
	ASSERT(xfs_bmap_free_item_zone != NULL);
560

561
	new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
562 563
	new->xefi_startblock = bno;
	new->xefi_blockcount = (xfs_extlen_t)len;
564 565 566 567
	if (oinfo)
		new->xefi_oinfo = *oinfo;
	else
		xfs_rmap_skip_owner_update(&new->xefi_oinfo);
568
	new->xefi_skip_discard = skip_discard;
569 570 571 572
	trace_xfs_bmap_free_defer(tp->t_mountp,
			XFS_FSB_TO_AGNO(tp->t_mountp, bno), 0,
			XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);
	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list);
573
}
574

575 576 577
/*
 * Inode fork format manipulation functions
 */
Linus Torvalds's avatar
Linus Torvalds committed
578

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
/*
 * Transform a btree format file with only one leaf node, where the
 * extents list will fit in the inode, into an extents format file.
 * Since the file extents are already in-core, all we have to do is
 * give up the space for the btree root and pitch the leaf block.
 */
STATIC int				/* error */
xfs_bmap_btree_to_extents(
	xfs_trans_t		*tp,	/* transaction pointer */
	xfs_inode_t		*ip,	/* incore inode pointer */
	xfs_btree_cur_t		*cur,	/* btree cursor */
	int			*logflagsp, /* inode logging flags */
	int			whichfork)  /* data or attr fork */
{
	/* REFERENCED */
	struct xfs_btree_block	*cblock;/* child btree block */
	xfs_fsblock_t		cbno;	/* child block number */
	xfs_buf_t		*cbp;	/* child block's buffer */
	int			error;	/* error return value */
598
	struct xfs_ifork	*ifp;	/* inode fork data */
599 600 601
	xfs_mount_t		*mp;	/* mount point structure */
	__be64			*pp;	/* ptr to block address */
	struct xfs_btree_block	*rblock;/* root btree block */
602
	struct xfs_owner_info	oinfo;
Linus Torvalds's avatar
Linus Torvalds committed
603

604 605
	mp = ip->i_mount;
	ifp = XFS_IFORK_PTR(ip, whichfork);
606
	ASSERT(whichfork != XFS_COW_FORK);
607 608 609 610 611 612 613 614 615 616
	ASSERT(ifp->if_flags & XFS_IFEXTENTS);
	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
	rblock = ifp->if_broot;
	ASSERT(be16_to_cpu(rblock->bb_level) == 1);
	ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
	ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
	cbno = be64_to_cpu(*pp);
	*logflagsp = 0;
#ifdef DEBUG
617 618
	XFS_WANT_CORRUPTED_RETURN(cur->bc_mp,
			xfs_btree_check_lptr(cur, cbno, 1));
619 620 621 622 623 624 625 626
#endif
	error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF,
				&xfs_bmbt_buf_ops);
	if (error)
		return error;
	cblock = XFS_BUF_TO_BLOCK(cbp);
	if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
		return error;
627
	xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
628
	xfs_bmap_add_free(cur->bc_tp, cbno, 1, &oinfo);
629 630 631 632 633 634 635 636 637 638 639 640
	ip->i_d.di_nblocks--;
	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
	xfs_trans_binval(tp, cbp);
	if (cur->bc_bufs[0] == cbp)
		cur->bc_bufs[0] = NULL;
	xfs_iroot_realloc(ip, -1, whichfork);
	ASSERT(ifp->if_broot == NULL);
	ASSERT((ifp->if_flags & XFS_IFBROOT) == 0);
	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
	*logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
	return 0;
}
641

642 643 644 645 646 647
/*
 * Convert an extents-format file into a btree-format file.
 * The new file will have a root block (in the inode) and a single child block.
 */
STATIC int					/* error */
xfs_bmap_extents_to_btree(
648 649 650
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode pointer */
	struct xfs_btree_cur	**curp,		/* cursor returned to caller */
651 652 653 654 655
	int			wasdel,		/* converting a delayed alloc */
	int			*logflagsp,	/* inode logging flags */
	int			whichfork)	/* data or attr fork */
{
	struct xfs_btree_block	*ablock;	/* allocated (child) bt block */
656 657 658
	struct xfs_buf		*abp;		/* buffer for ablock */
	struct xfs_alloc_arg	args;		/* allocation arguments */
	struct xfs_bmbt_rec	*arp;		/* child record pointer */
659
	struct xfs_btree_block	*block;		/* btree root block */
660
	struct xfs_btree_cur	*cur;		/* bmap btree cursor */
661
	int			error;		/* error return value */
662 663 664
	struct xfs_ifork	*ifp;		/* inode fork pointer */
	struct xfs_bmbt_key	*kp;		/* root block key pointer */
	struct xfs_mount	*mp;		/* mount structure */
665
	xfs_bmbt_ptr_t		*pp;		/* root block address pointer */
666
	struct xfs_iext_cursor	icur;
667
	struct xfs_bmbt_irec	rec;
668
	xfs_extnum_t		cnt = 0;
Linus Torvalds's avatar
Linus Torvalds committed
669

670
	mp = ip->i_mount;
671
	ASSERT(whichfork != XFS_COW_FORK);
672 673
	ifp = XFS_IFORK_PTR(ip, whichfork);
	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS);
674

675
	/*
676 677
	 * Make space in the inode incore. This needs to be undone if we fail
	 * to expand the root.
678 679 680
	 */
	xfs_iroot_realloc(ip, 1, whichfork);
	ifp->if_flags |= XFS_IFBROOT;
Christoph Hellwig's avatar
Christoph Hellwig committed
681

682 683 684 685
	/*
	 * Fill in the root.
	 */
	block = ifp->if_broot;
686 687
	xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL,
				 XFS_BTNUM_BMAP, 1, 1, ip->i_ino,
688
				 XFS_BTREE_LONG_PTRS);
689 690 691 692 693 694 695 696 697 698 699 700
	/*
	 * Need a cursor.  Can't allocate until bb_level is filled in.
	 */
	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
	cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
	/*
	 * Convert to a btree with two levels, one record in root.
	 */
	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE);
	memset(&args, 0, sizeof(args));
	args.tp = tp;
	args.mp = mp;
701
	xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
702
	if (tp->t_firstblock == NULLFSBLOCK) {
703 704
		args.type = XFS_ALLOCTYPE_START_BNO;
		args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
705
	} else if (tp->t_flags & XFS_TRANS_LOWMODE) {
706
		args.type = XFS_ALLOCTYPE_START_BNO;
707
		args.fsbno = tp->t_firstblock;
708 709
	} else {
		args.type = XFS_ALLOCTYPE_NEAR_BNO;
710
		args.fsbno = tp->t_firstblock;
711 712 713 714
	}
	args.minlen = args.maxlen = args.prod = 1;
	args.wasdel = wasdel;
	*logflagsp = 0;
715 716 717
	error = xfs_alloc_vextent(&args);
	if (error)
		goto out_root_realloc;
718

719
	if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
720
		error = -ENOSPC;
721
		goto out_root_realloc;
722
	}
723

724 725 726
	/*
	 * Allocation can't fail, the space was reserved.
	 */
727 728
	ASSERT(tp->t_firstblock == NULLFSBLOCK ||
	       args.agno >= XFS_FSB_TO_AGNO(mp, tp->t_firstblock));
729
	tp->t_firstblock = args.fsbno;
730 731 732 733
	cur->bc_private.b.allocated++;
	ip->i_d.di_nblocks++;
	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
	abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0);
734
	if (!abp) {
735 736
		error = -EFSCORRUPTED;
		goto out_unreserve_dquot;
737
	}
738

739 740 741 742 743
	/*
	 * Fill in the child block.
	 */
	abp->b_ops = &xfs_bmbt_buf_ops;
	ablock = XFS_BUF_TO_BLOCK(abp);
744 745
	xfs_btree_init_block_int(mp, ablock, abp->b_bn,
				XFS_BTNUM_BMAP, 0, 0, ip->i_ino,
746 747
				XFS_BTREE_LONG_PTRS);

748
	for_each_xfs_iext(ifp, &icur, &rec) {
749 750 751 752 753
		if (isnullstartblock(rec.br_startblock))
			continue;
		arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt);
		xfs_bmbt_disk_set_all(arp, &rec);
		cnt++;
754 755 756
	}
	ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork));
	xfs_btree_set_numrecs(ablock, cnt);
Linus Torvalds's avatar
Linus Torvalds committed
757

758 759 760 761 762 763 764 765 766
	/*
	 * Fill in the root key and pointer.
	 */
	kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
	arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
	kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp));
	pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur,
						be16_to_cpu(block->bb_level)));
	*pp = cpu_to_be64(args.fsbno);
Christoph Hellwig's avatar
Christoph Hellwig committed
767

768 769 770 771 772 773 774 775 776 777
	/*
	 * Do all this logging at the end so that
	 * the root is at the right level.
	 */
	xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
	xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
	ASSERT(*curp == NULL);
	*curp = cur;
	*logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork);
	return 0;
778

779
out_unreserve_dquot:
780
	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
781
out_root_realloc:
782 783
	xfs_iroot_realloc(ip, -1, whichfork);
	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
784
	ASSERT(ifp->if_broot == NULL);
785 786 787
	xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);

	return error;
788
}
Christoph Hellwig's avatar
Christoph Hellwig committed
789

790 791 792 793 794 795
/*
 * Convert a local file to an extents file.
 * This code is out of bounds for data forks of regular files,
 * since the file data needs to get logged so things will stay consistent.
 * (The bmap-level manipulations are ok, though).
 */
796 797 798 799 800 801 802
void
xfs_bmap_local_to_extents_empty(
	struct xfs_inode	*ip,
	int			whichfork)
{
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);

803
	ASSERT(whichfork != XFS_COW_FORK);
804 805 806 807
	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
	ASSERT(ifp->if_bytes == 0);
	ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0);

808
	xfs_bmap_forkoff_reset(ip, whichfork);
809 810
	ifp->if_flags &= ~XFS_IFINLINE;
	ifp->if_flags |= XFS_IFEXTENTS;
811 812
	ifp->if_u1.if_root = NULL;
	ifp->if_height = 0;
813 814 815 816
	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
}


817 818 819 820 821 822 823
STATIC int				/* error */
xfs_bmap_local_to_extents(
	xfs_trans_t	*tp,		/* transaction pointer */
	xfs_inode_t	*ip,		/* incore inode pointer */
	xfs_extlen_t	total,		/* total blocks needed by transaction */
	int		*logflagsp,	/* inode logging flags */
	int		whichfork,
824 825
	void		(*init_fn)(struct xfs_trans *tp,
				   struct xfs_buf *bp,
826 827 828
				   struct xfs_inode *ip,
				   struct xfs_ifork *ifp))
{
829
	int		error = 0;
830
	int		flags;		/* logging flags returned */
831
	struct xfs_ifork *ifp;		/* inode fork pointer */
832 833
	xfs_alloc_arg_t	args;		/* allocation arguments */
	xfs_buf_t	*bp;		/* buffer for extent block */
834
	struct xfs_bmbt_irec rec;
835
	struct xfs_iext_cursor icur;
836

837 838 839 840
	/*
	 * We don't want to deal with the case of keeping inode data inline yet.
	 * So sending the data fork of a regular inode is invalid.
	 */
841
	ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
842 843
	ifp = XFS_IFORK_PTR(ip, whichfork);
	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
844 845 846 847 848 849 850

	if (!ifp->if_bytes) {
		xfs_bmap_local_to_extents_empty(ip, whichfork);
		flags = XFS_ILOG_CORE;
		goto done;
	}

851 852
	flags = 0;
	error = 0;
853
	ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS)) == XFS_IFINLINE);
854 855 856
	memset(&args, 0, sizeof(args));
	args.tp = tp;
	args.mp = ip->i_mount;
857
	xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
858 859 860 861
	/*
	 * Allocate a block.  We know we need only one, since the
	 * file currently fits in an inode.
	 */
862
	if (tp->t_firstblock == NULLFSBLOCK) {
863 864
		args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino);
		args.type = XFS_ALLOCTYPE_START_BNO;
865
	} else {
866
		args.fsbno = tp->t_firstblock;
867
		args.type = XFS_ALLOCTYPE_NEAR_BNO;
868
	}
869 870 871 872 873 874 875 876 877
	args.total = total;
	args.minlen = args.maxlen = args.prod = 1;
	error = xfs_alloc_vextent(&args);
	if (error)
		goto done;

	/* Can't fail, the space was reserved. */
	ASSERT(args.fsbno != NULLFSBLOCK);
	ASSERT(args.len == 1);
878
	tp->t_firstblock = args.fsbno;
879 880
	bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0);

881
	/*
882
	 * Initialize the block, copy the data and log the remote buffer.
883
	 *
884 885 886 887
	 * The callout is responsible for logging because the remote format
	 * might differ from the local format and thus we don't know how much to
	 * log here. Note that init_fn must also set the buffer log item type
	 * correctly.
888
	 */
889 890
	init_fn(tp, bp, ip, ifp);

891
	/* account for the change in fork size */
892 893
	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
	xfs_bmap_local_to_extents_empty(ip, whichfork);
894
	flags |= XFS_ILOG_CORE;
895

896 897 898
	ifp->if_u1.if_root = NULL;
	ifp->if_height = 0;

899 900 901 902
	rec.br_startoff = 0;
	rec.br_startblock = args.fsbno;
	rec.br_blockcount = 1;
	rec.br_state = XFS_EXT_NORM;
903
	xfs_iext_first(ifp, &icur);
904
	xfs_iext_insert(ip, &icur, &rec, 0);
905

906 907 908 909 910 911
	XFS_IFORK_NEXT_SET(ip, whichfork, 1);
	ip->i_d.di_nblocks = 1;
	xfs_trans_mod_dquot_byino(tp, ip,
		XFS_TRANS_DQ_BCOUNT, 1L);
	flags |= xfs_ilog_fext(whichfork);

912 913 914 915
done:
	*logflagsp = flags;
	return error;
}
Christoph Hellwig's avatar
Christoph Hellwig committed
916

917 918 919 920 921 922 923 924 925 926 927 928 929
/*
 * Called from xfs_bmap_add_attrfork to handle btree format files.
 */
STATIC int					/* error */
xfs_bmap_add_attrfork_btree(
	xfs_trans_t		*tp,		/* transaction pointer */
	xfs_inode_t		*ip,		/* incore inode pointer */
	int			*flags)		/* inode logging flags */
{
	xfs_btree_cur_t		*cur;		/* btree cursor */
	int			error;		/* error return value */
	xfs_mount_t		*mp;		/* file system mount struct */
	int			stat;		/* newroot status */
Christoph Hellwig's avatar
Christoph Hellwig committed
930

931 932 933 934 935
	mp = ip->i_mount;
	if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip))
		*flags |= XFS_ILOG_DBROOT;
	else {
		cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
936 937
		error = xfs_bmbt_lookup_first(cur, &stat);
		if (error)
938 939
			goto error0;
		/* must be at least one entry */
940
		XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0);
941 942 943 944
		if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
			goto error0;
		if (stat == 0) {
			xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
945
			return -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
946
		}
947 948
		cur->bc_private.b.allocated = 0;
		xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
Linus Torvalds's avatar
Linus Torvalds committed
949
	}
950 951 952 953 954
	return 0;
error0:
	xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
	return error;
}
955

956 957 958 959 960
/*
 * Called from xfs_bmap_add_attrfork to handle extents format files.
 */
STATIC int					/* error */
xfs_bmap_add_attrfork_extents(
961 962
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode pointer */
963 964 965 966
	int			*flags)		/* inode logging flags */
{
	xfs_btree_cur_t		*cur;		/* bmap btree cursor */
	int			error;		/* error return value */
967

968 969 970
	if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip))
		return 0;
	cur = NULL;
971 972
	error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags,
					  XFS_DATA_FORK);
973 974
	if (cur) {
		cur->bc_private.b.allocated = 0;
975
		xfs_btree_del_cursor(cur, error);
976
	}
Linus Torvalds's avatar
Linus Torvalds committed
977 978 979
	return error;
}

980 981 982 983 984 985 986 987 988
/*
 * Called from xfs_bmap_add_attrfork to handle local format files. Each
 * different data fork content type needs a different callout to do the
 * conversion. Some are basic and only require special block initialisation
 * callouts for the data formating, others (directories) are so specialised they
 * handle everything themselves.
 *
 * XXX (dgc): investigate whether directory conversion can use the generic
 * formatting callout. It should be possible - it's just a very complex
989
 * formatter.
990 991 992
 */
STATIC int					/* error */
xfs_bmap_add_attrfork_local(
993 994
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode pointer */
995 996
	int			*flags)		/* inode logging flags */
{
997
	struct xfs_da_args	dargs;		/* args for dir/attr code */
998

999 1000
	if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))
		return 0;
1001

1002
	if (S_ISDIR(VFS_I(ip)->i_mode)) {
1003
		memset(&dargs, 0, sizeof(dargs));
1004
		dargs.geo = ip->i_mount->m_dir_geo;
1005
		dargs.dp = ip;
1006
		dargs.total = dargs.geo->fsbcount;
1007 1008 1009
		dargs.whichfork = XFS_DATA_FORK;
		dargs.trans = tp;
		return xfs_dir2_sf_to_block(&dargs);
Linus Torvalds's avatar
Linus Torvalds committed
1010
	}
1011

1012
	if (S_ISLNK(VFS_I(ip)->i_mode))
1013 1014
		return xfs_bmap_local_to_extents(tp, ip, 1, flags,
						 XFS_DATA_FORK,
1015
						 xfs_symlink_local_to_remote);
1016

1017 1018
	/* should only be called for types that support local format data */
	ASSERT(0);
1019
	return -EFSCORRUPTED;
1020
}
1021

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
/* Set an inode attr fork off based on the format */
int
xfs_bmap_set_attrforkoff(
	struct xfs_inode	*ip,
	int			size,
	int			*version)
{
	switch (ip->i_d.di_format) {
	case XFS_DINODE_FMT_DEV:
		ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
		break;
	case XFS_DINODE_FMT_LOCAL:
	case XFS_DINODE_FMT_EXTENTS:
	case XFS_DINODE_FMT_BTREE:
		ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size);
		if (!ip->i_d.di_forkoff)
			ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3;
		else if ((ip->i_mount->m_flags & XFS_MOUNT_ATTR2) && version)
			*version = 2;
		break;
	default:
		ASSERT(0);
		return -EINVAL;
	}

	return 0;
}

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
/*
 * Convert inode from non-attributed to attributed.
 * Must not be in a transaction, ip must not be locked.
 */
int						/* error code */
xfs_bmap_add_attrfork(
	xfs_inode_t		*ip,		/* incore inode pointer */
	int			size,		/* space new attribute needs */
	int			rsvd)		/* xact may use reserved blks */
{
	xfs_mount_t		*mp;		/* mount structure */
	xfs_trans_t		*tp;		/* transaction pointer */
	int			blks;		/* space reservation */
	int			version = 1;	/* superblock attr version */
	int			logflags;	/* logging flags */
	int			error;		/* error return value */
1066

1067
	ASSERT(XFS_IFORK_Q(ip) == 0);
Linus Torvalds's avatar
Linus Torvalds committed
1068

1069 1070
	mp = ip->i_mount;
	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1071

1072
	blks = XFS_ADDAFORK_SPACE_RES(mp);
1073 1074 1075 1076

	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0,
			rsvd ? XFS_TRANS_RESERVE : 0, &tp);
	if (error)
1077
		return error;
1078

1079 1080 1081 1082
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ?
			XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES :
			XFS_QMOPT_RES_REGBLKS);
1083 1084
	if (error)
		goto trans_cancel;
1085
	if (XFS_IFORK_Q(ip))
1086
		goto trans_cancel;
1087 1088 1089 1090
	if (ip->i_d.di_anextents != 0) {
		error = -EFSCORRUPTED;
		goto trans_cancel;
	}
1091
	if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) {
Linus Torvalds's avatar
Linus Torvalds committed
1092
		/*
1093
		 * For inodes coming from pre-6.2 filesystems.
Linus Torvalds's avatar
Linus Torvalds committed
1094
		 */
1095 1096 1097
		ASSERT(ip->i_d.di_aformat == 0);
		ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
	}
Christoph Hellwig's avatar
Christoph Hellwig committed
1098

1099
	xfs_trans_ijoin(tp, ip, 0);
1100
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1101 1102
	error = xfs_bmap_set_attrforkoff(ip, size, &version);
	if (error)
1103
		goto trans_cancel;
1104 1105 1106 1107 1108 1109
	ASSERT(ip->i_afp == NULL);
	ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
	ip->i_afp->if_flags = XFS_IFEXTENTS;
	logflags = 0;
	switch (ip->i_d.di_format) {
	case XFS_DINODE_FMT_LOCAL:
1110
		error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
1111 1112
		break;
	case XFS_DINODE_FMT_EXTENTS:
1113
		error = xfs_bmap_add_attrfork_extents(tp, ip, &logflags);
1114 1115
		break;
	case XFS_DINODE_FMT_BTREE:
1116
		error = xfs_bmap_add_attrfork_btree(tp, ip, &logflags);
1117 1118 1119
		break;
	default:
		error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121
		break;
	}
1122 1123 1124
	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
	if (error)
1125
		goto trans_cancel;
1126 1127
	if (!xfs_sb_version_hasattr(&mp->m_sb) ||
	   (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) {
1128
		bool log_sb = false;
1129 1130 1131 1132

		spin_lock(&mp->m_sb_lock);
		if (!xfs_sb_version_hasattr(&mp->m_sb)) {
			xfs_sb_version_addattr(&mp->m_sb);
1133
			log_sb = true;
1134 1135 1136
		}
		if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) {
			xfs_sb_version_addattr2(&mp->m_sb);
1137
			log_sb = true;
1138
		}
1139
		spin_unlock(&mp->m_sb_lock);
1140 1141
		if (log_sb)
			xfs_log_sb(tp);
Linus Torvalds's avatar
Linus Torvalds committed
1142
	}
1143

1144
	error = xfs_trans_commit(tp);
1145 1146 1147 1148
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return error;

trans_cancel:
1149
	xfs_trans_cancel(tp);
1150 1151
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
1152 1153 1154
}

/*
1155
 * Internal and external extent tree search functions.
Linus Torvalds's avatar
Linus Torvalds committed
1156
 */
1157

1158
/*
1159
 * Read in extents from a btree-format inode.
1160
 */
1161 1162 1163 1164 1165
int
xfs_iread_extents(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	int			whichfork)
1166
{
1167
	struct xfs_mount	*mp = ip->i_mount;
1168
	int			state = xfs_bmap_fork_to_state(whichfork);
1169 1170 1171
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	xfs_extnum_t		nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
	struct xfs_btree_block	*block = ifp->if_broot;
1172
	struct xfs_iext_cursor	icur;
1173
	struct xfs_bmbt_irec	new;
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
	xfs_fsblock_t		bno;
	struct xfs_buf		*bp;
	xfs_extnum_t		i, j;
	int			level;
	__be64			*pp;
	int			error;

	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));

	if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
		return -EFSCORRUPTED;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1188
	/*
1189
	 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
Linus Torvalds's avatar
Linus Torvalds committed
1190
	 */
1191
	level = be16_to_cpu(block->bb_level);
1192 1193 1194 1195
	if (unlikely(level == 0)) {
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
		return -EFSCORRUPTED;
	}
1196 1197
	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
	bno = be64_to_cpu(*pp);
1198

Linus Torvalds's avatar
Linus Torvalds committed
1199
	/*
1200 1201
	 * Go down the tree until leaf level is reached, following the first
	 * pointer (leftmost) at each level.
Linus Torvalds's avatar
Linus Torvalds committed
1202
	 */
1203 1204 1205 1206
	while (level-- > 0) {
		error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
				XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops);
		if (error)
1207
			goto out;
1208 1209 1210 1211 1212
		block = XFS_BUF_TO_BLOCK(bp);
		if (level == 0)
			break;
		pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
		bno = be64_to_cpu(*pp);
1213
		XFS_WANT_CORRUPTED_GOTO(mp,
1214
			xfs_verify_fsbno(mp, bno), out_brelse);
1215
		xfs_trans_brelse(tp, bp);
Linus Torvalds's avatar
Linus Torvalds committed
1216
	}
1217

Linus Torvalds's avatar
Linus Torvalds committed
1218
	/*
1219
	 * Here with bp and block set to the leftmost leaf node in the tree.
Linus Torvalds's avatar
Linus Torvalds committed
1220
	 */
1221
	i = 0;
1222
	xfs_iext_first(ifp, &icur);
1223

Linus Torvalds's avatar
Linus Torvalds committed
1224
	/*
1225
	 * Loop over all leaf nodes.  Copy information to the extent records.
Linus Torvalds's avatar
Linus Torvalds committed
1226
	 */
1227 1228 1229 1230
	for (;;) {
		xfs_bmbt_rec_t	*frp;
		xfs_fsblock_t	nextbno;
		xfs_extnum_t	num_recs;
1231

1232
		num_recs = xfs_btree_get_numrecs(block);
1233
		if (unlikely(i + num_recs > nextents)) {
1234 1235 1236
			xfs_warn(ip->i_mount,
				"corrupt dinode %Lu, (btree extents).",
				(unsigned long long) ip->i_ino);
1237 1238 1239
			xfs_inode_verifier_error(ip, -EFSCORRUPTED,
					__func__, block, sizeof(*block),
					__this_address);
1240 1241
			error = -EFSCORRUPTED;
			goto out_brelse;
Linus Torvalds's avatar
Linus Torvalds committed
1242 1243
		}
		/*
1244
		 * Read-ahead the next leaf block, if any.
Linus Torvalds's avatar
Linus Torvalds committed
1245
		 */
1246 1247 1248 1249
		nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
		if (nextbno != NULLFSBLOCK)
			xfs_btree_reada_bufl(mp, nextbno, 1,
					     &xfs_bmbt_buf_ops);
Linus Torvalds's avatar
Linus Torvalds committed
1250
		/*
1251
		 * Copy records into the extent records.
Linus Torvalds's avatar
Linus Torvalds committed
1252
		 */
1253
		frp = XFS_BMBT_REC_ADDR(mp, block, 1);
1254
		for (j = 0; j < num_recs; j++, frp++, i++) {
1255 1256
			xfs_failaddr_t	fa;

1257
			xfs_bmbt_disk_get_all(frp, &new);
1258 1259
			fa = xfs_bmap_validate_extent(ip, whichfork, &new);
			if (fa) {
1260
				error = -EFSCORRUPTED;
1261 1262 1263
				xfs_inode_verifier_error(ip, error,
						"xfs_iread_extents(2)",
						frp, sizeof(*frp), fa);
1264
				goto out_brelse;
1265
			}
1266
			xfs_iext_insert(ip, &icur, &new, state);
1267 1268
			trace_xfs_read_extent(ip, &icur, state, _THIS_IP_);
			xfs_iext_next(ifp, &icur);
1269 1270 1271
		}
		xfs_trans_brelse(tp, bp);
		bno = nextbno;
Linus Torvalds's avatar
Linus Torvalds committed
1272
		/*
1273
		 * If we've reached the end, stop.
Linus Torvalds's avatar
Linus Torvalds committed
1274
		 */
1275 1276 1277 1278 1279
		if (bno == NULLFSBLOCK)
			break;
		error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
				XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops);
		if (error)
1280
			goto out;
1281
		block = XFS_BUF_TO_BLOCK(bp);
Linus Torvalds's avatar
Linus Torvalds committed
1282
	}
1283 1284 1285 1286 1287

	if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) {
		error = -EFSCORRUPTED;
		goto out;
	}
1288
	ASSERT(i == xfs_iext_count(ifp));
1289 1290

	ifp->if_flags |= XFS_IFEXTENTS;
1291
	return 0;
1292 1293

out_brelse:
1294
	xfs_trans_brelse(tp, bp);
1295 1296 1297
out:
	xfs_iext_destroy(ifp);
	return error;
1298
}
1299

1300
/*
1301 1302 1303 1304
 * Returns the relative block number of the first unused block(s) in the given
 * fork with at least "len" logically contiguous blocks free.  This is the
 * lowest-address hole if the fork has holes, else the first block past the end
 * of fork.  Return 0 if the fork is currently local (in-inode).
1305 1306 1307
 */
int						/* error */
xfs_bmap_first_unused(
1308 1309 1310 1311 1312
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode */
	xfs_extlen_t		len,		/* size of hole to find */
	xfs_fileoff_t		*first_unused,	/* unused block */
	int			whichfork)	/* data or attr fork */
1313
{
1314 1315
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_bmbt_irec	got;
1316
	struct xfs_iext_cursor	icur;
1317 1318 1319
	xfs_fileoff_t		lastaddr = 0;
	xfs_fileoff_t		lowest, max;
	int			error;
1320 1321 1322 1323

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE ||
	       XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS ||
	       XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
1324

1325 1326 1327
	if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
		*first_unused = 0;
		return 0;
1328
	}
1329

1330 1331 1332 1333 1334
	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
	}
1335

1336
	lowest = max = *first_unused;
1337
	for_each_xfs_iext(ifp, &icur, &got) {
1338 1339 1340
		/*
		 * See if the hole before this extent will work.
		 */
1341
		if (got.br_startoff >= lowest + len &&
1342 1343
		    got.br_startoff - max >= len)
			break;
1344
		lastaddr = got.br_startoff + got.br_blockcount;
1345
		max = XFS_FILEOFF_MAX(lastaddr, lowest);
1346
	}
1347

1348 1349 1350 1351 1352
	*first_unused = max;
	return 0;
}

/*
1353
 * Returns the file-relative block number of the last block - 1 before
1354 1355 1356 1357 1358 1359
 * last_block (input value) in the file.
 * This is not based on i_size, it is based on the extent records.
 * Returns 0 for local files, as they do not have extent records.
 */
int						/* error */
xfs_bmap_last_before(
1360 1361 1362 1363
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode */
	xfs_fileoff_t		*last_block,	/* last block */
	int			whichfork)	/* data or attr fork */
1364
{
1365 1366
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_bmbt_irec	got;
1367
	struct xfs_iext_cursor	icur;
1368
	int			error;
1369

1370 1371
	switch (XFS_IFORK_FORMAT(ip, whichfork)) {
	case XFS_DINODE_FMT_LOCAL:
1372 1373
		*last_block = 0;
		return 0;
1374 1375 1376 1377 1378
	case XFS_DINODE_FMT_BTREE:
	case XFS_DINODE_FMT_EXTENTS:
		break;
	default:
		return -EIO;
1379
	}
1380 1381 1382 1383 1384

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
1385
	}
1386

1387
	if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got))
1388
		*last_block = 0;
1389 1390 1391
	return 0;
}

1392
int
1393 1394 1395 1396 1397 1398 1399 1400
xfs_bmap_last_extent(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	int			whichfork,
	struct xfs_bmbt_irec	*rec,
	int			*is_empty)
{
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
1401
	struct xfs_iext_cursor	icur;
1402 1403 1404 1405 1406 1407
	int			error;

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
1408 1409
	}

1410 1411
	xfs_iext_last(ifp, &icur);
	if (!xfs_iext_get_extent(ifp, &icur, rec))
1412
		*is_empty = 1;
1413 1414
	else
		*is_empty = 0;
1415 1416 1417
	return 0;
}

1418 1419 1420 1421 1422 1423
/*
 * Check the last inode extent to determine whether this allocation will result
 * in blocks being allocated at the end of the file. When we allocate new data
 * blocks at the end of the file which do not start at the previous data block,
 * we will try to align the new blocks at stripe unit boundaries.
 *
1424
 * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be
1425 1426 1427 1428 1429 1430
 * at, or past the EOF.
 */
STATIC int
xfs_bmap_isaeof(
	struct xfs_bmalloca	*bma,
	int			whichfork)
Linus Torvalds's avatar
Linus Torvalds committed
1431
{
1432 1433 1434
	struct xfs_bmbt_irec	rec;
	int			is_empty;
	int			error;
Linus Torvalds's avatar
Linus Torvalds committed
1435

1436
	bma->aeof = false;
1437 1438
	error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
				     &is_empty);
1439
	if (error)
1440
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
1441

1442
	if (is_empty) {
1443
		bma->aeof = true;
1444 1445 1446
		return 0;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1447
	/*
1448 1449
	 * Check if we are allocation or past the last extent, or at least into
	 * the last delayed allocated extent.
Linus Torvalds's avatar
Linus Torvalds committed
1450
	 */
1451 1452 1453 1454 1455
	bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount ||
		(bma->offset >= rec.br_startoff &&
		 isnullstartblock(rec.br_startblock));
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
1456

1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
/*
 * Returns the file-relative block number of the first block past eof in
 * the file.  This is not based on i_size, it is based on the extent records.
 * Returns 0 for local files, as they do not have extent records.
 */
int
xfs_bmap_last_offset(
	struct xfs_inode	*ip,
	xfs_fileoff_t		*last_block,
	int			whichfork)
{
	struct xfs_bmbt_irec	rec;
	int			is_empty;
	int			error;
1471

1472
	*last_block = 0;
1473

1474 1475
	if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL)
		return 0;
1476

1477 1478
	if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
	    XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
1479
	       return -EIO;
1480

1481 1482
	error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
	if (error || is_empty)
1483
		return error;
1484 1485

	*last_block = rec.br_startoff + rec.br_blockcount;
1486 1487 1488
	return 0;
}

1489 1490 1491 1492 1493 1494 1495 1496 1497
/*
 * Returns whether the selected fork of the inode has exactly one
 * block or not.  For the data fork we check this matches di_size,
 * implying the file's range is 0..bsize-1.
 */
int					/* 1=>1 block, 0=>otherwise */
xfs_bmap_one_block(
	xfs_inode_t	*ip,		/* incore inode */
	int		whichfork)	/* data or attr fork */
1498
{
1499
	struct xfs_ifork *ifp;		/* inode fork pointer */
1500 1501
	int		rval;		/* return value */
	xfs_bmbt_irec_t	s;		/* internal version of extent */
1502
	struct xfs_iext_cursor icur;
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
#ifndef DEBUG
	if (whichfork == XFS_DATA_FORK)
		return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize;
#endif	/* !DEBUG */
	if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1)
		return 0;
	if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
		return 0;
	ifp = XFS_IFORK_PTR(ip, whichfork);
	ASSERT(ifp->if_flags & XFS_IFEXTENTS);
1514 1515
	xfs_iext_first(ifp, &icur);
	xfs_iext_get_extent(ifp, &icur, &s);
1516 1517 1518 1519 1520
	rval = s.br_startoff == 0 && s.br_blockcount == 1;
	if (rval && whichfork == XFS_DATA_FORK)
		ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize);
	return rval;
}
1521

1522 1523 1524
/*
 * Extent tree manipulation functions used during allocation.
 */
1525

1526 1527 1528 1529 1530
/*
 * Convert a delayed allocation to a real allocation.
 */
STATIC int				/* error */
xfs_bmap_add_extent_delay_real(
1531 1532
	struct xfs_bmalloca	*bma,
	int			whichfork)
1533 1534 1535 1536
{
	struct xfs_bmbt_irec	*new = &bma->got;
	int			error;	/* error return value */
	int			i;	/* temp state */
1537
	struct xfs_ifork	*ifp;	/* inode fork pointer */
1538 1539 1540 1541
	xfs_fileoff_t		new_endoff;	/* end offset of new entry */
	xfs_bmbt_irec_t		r[3];	/* neighbor extent entries */
					/* left is 0, right is 1, prev is 2 */
	int			rval=0;	/* return value (logging flags) */
1542
	int			state = xfs_bmap_fork_to_state(whichfork);
1543 1544 1545 1546
	xfs_filblks_t		da_new; /* new count del alloc blocks used */
	xfs_filblks_t		da_old; /* old count del alloc blocks used */
	xfs_filblks_t		temp=0;	/* value for da_new calculations */
	int			tmp_rval;	/* partial logging flags */
1547
	struct xfs_mount	*mp;
1548
	xfs_extnum_t		*nextents;
1549
	struct xfs_bmbt_irec	old;
1550

1551
	mp = bma->ip->i_mount;
1552
	ifp = XFS_IFORK_PTR(bma->ip, whichfork);
1553 1554 1555
	ASSERT(whichfork != XFS_ATTR_FORK);
	nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents :
						&bma->ip->i_d.di_nextents);
1556

1557 1558 1559
	ASSERT(!isnullstartblock(new->br_startblock));
	ASSERT(!bma->cur ||
	       (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
1560

1561
	XFS_STATS_INC(mp, xs_add_exlist);
1562

1563 1564 1565
#define	LEFT		r[0]
#define	RIGHT		r[1]
#define	PREV		r[2]
1566 1567

	/*
1568
	 * Set up a bunch of variables to make the tests simpler.
1569
	 */
1570
	xfs_iext_get_extent(ifp, &bma->icur, &PREV);
1571
	new_endoff = new->br_startoff + new->br_blockcount;
1572
	ASSERT(isnullstartblock(PREV.br_startblock));
1573 1574 1575 1576 1577 1578
	ASSERT(PREV.br_startoff <= new->br_startoff);
	ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);

	da_old = startblockval(PREV.br_startblock);
	da_new = 0;

1579
	/*
1580 1581
	 * Set flags determining what part of the previous delayed allocation
	 * extent is being replaced by a real allocation.
1582
	 */
1583 1584 1585 1586
	if (PREV.br_startoff == new->br_startoff)
		state |= BMAP_LEFT_FILLING;
	if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
		state |= BMAP_RIGHT_FILLING;
1587 1588

	/*
1589 1590
	 * Check and set flags if this segment has a left neighbor.
	 * Don't set contiguous if the combined extent would be too large.
1591
	 */
1592
	if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) {
1593 1594 1595
		state |= BMAP_LEFT_VALID;
		if (isnullstartblock(LEFT.br_startblock))
			state |= BMAP_LEFT_DELAY;
1596 1597
	}

1598 1599 1600 1601 1602 1603
	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
	    LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
	    LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
	    LEFT.br_state == new->br_state &&
	    LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
		state |= BMAP_LEFT_CONTIG;
1604

Linus Torvalds's avatar
Linus Torvalds committed
1605
	/*
1606 1607 1608
	 * Check and set flags if this segment has a right neighbor.
	 * Don't set contiguous if the combined extent would be too large.
	 * Also check for all-three-contiguous being too large.
Linus Torvalds's avatar
Linus Torvalds committed
1609
	 */
1610
	if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) {
1611 1612 1613
		state |= BMAP_RIGHT_VALID;
		if (isnullstartblock(RIGHT.br_startblock))
			state |= BMAP_RIGHT_DELAY;
Linus Torvalds's avatar
Linus Torvalds committed
1614
	}
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629

	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
	    new_endoff == RIGHT.br_startoff &&
	    new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
	    new->br_state == RIGHT.br_state &&
	    new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
	    ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
		       BMAP_RIGHT_FILLING)) !=
		      (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
		       BMAP_RIGHT_FILLING) ||
	     LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
			<= MAXEXTLEN))
		state |= BMAP_RIGHT_CONTIG;

	error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1630
	/*
1631
	 * Switch out based on the FILLING and CONTIG state bits.
Linus Torvalds's avatar
Linus Torvalds committed
1632
	 */
1633 1634 1635 1636
	switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
			 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
	     BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
Linus Torvalds's avatar
Linus Torvalds committed
1637
		/*
1638 1639
		 * Filling in all of a previously delayed allocation extent.
		 * The left and right neighbors are both contiguous with new.
Linus Torvalds's avatar
Linus Torvalds committed
1640
		 */
1641
		LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
1642

1643 1644
		xfs_iext_remove(bma->ip, &bma->icur, state);
		xfs_iext_remove(bma->ip, &bma->icur, state);
1645 1646
		xfs_iext_prev(ifp, &bma->icur);
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1647
		(*nextents)--;
1648

1649 1650 1651 1652
		if (bma->cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
1653
			error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1654 1655
			if (error)
				goto done;
1656
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1657 1658 1659
			error = xfs_btree_delete(bma->cur, &i);
			if (error)
				goto done;
1660
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1661 1662 1663
			error = xfs_btree_decrement(bma->cur, 0, &i);
			if (error)
				goto done;
1664
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1665
			error = xfs_bmbt_update(bma->cur, &LEFT);
1666 1667 1668 1669 1670 1671
			if (error)
				goto done;
		}
		break;

	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1672
		/*
1673 1674
		 * Filling in all of a previously delayed allocation extent.
		 * The left neighbor is contiguous, the right is not.
1675
		 */
1676 1677
		old = LEFT;
		LEFT.br_blockcount += PREV.br_blockcount;
1678

1679
		xfs_iext_remove(bma->ip, &bma->icur, state);
1680 1681
		xfs_iext_prev(ifp, &bma->icur);
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1682 1683 1684 1685 1686

		if (bma->cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
1687
			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1688 1689
			if (error)
				goto done;
1690
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1691
			error = xfs_bmbt_update(bma->cur, &LEFT);
1692 1693 1694 1695 1696 1697
			if (error)
				goto done;
		}
		break;

	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1698
		/*
1699
		 * Filling in all of a previously delayed allocation extent.
1700 1701 1702
		 * The right neighbor is contiguous, the left is not. Take care
		 * with delay -> unwritten extent allocation here because the
		 * delalloc record we are overwriting is always written.
1703
		 */
1704 1705
		PREV.br_startblock = new->br_startblock;
		PREV.br_blockcount += RIGHT.br_blockcount;
1706
		PREV.br_state = new->br_state;
1707

1708
		xfs_iext_next(ifp, &bma->icur);
1709
		xfs_iext_remove(bma->ip, &bma->icur, state);
1710 1711
		xfs_iext_prev(ifp, &bma->icur);
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1712

1713 1714 1715 1716
		if (bma->cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
1717
			error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1718 1719
			if (error)
				goto done;
1720
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1721
			error = xfs_bmbt_update(bma->cur, &PREV);
1722 1723 1724 1725 1726 1727
			if (error)
				goto done;
		}
		break;

	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
1728
		/*
1729 1730 1731
		 * Filling in all of a previously delayed allocation extent.
		 * Neither the left nor right neighbors are contiguous with
		 * the new one.
1732
		 */
1733 1734
		PREV.br_startblock = new->br_startblock;
		PREV.br_state = new->br_state;
1735
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1736

1737
		(*nextents)++;
1738 1739 1740 1741
		if (bma->cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
1742
			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1743 1744
			if (error)
				goto done;
1745
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1746 1747 1748
			error = xfs_btree_insert(bma->cur, &i);
			if (error)
				goto done;
1749
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1750 1751
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
1752

1753
	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
Linus Torvalds's avatar
Linus Torvalds committed
1754
		/*
1755 1756
		 * Filling in the first part of a previous delayed allocation.
		 * The left neighbor is contiguous.
Linus Torvalds's avatar
Linus Torvalds committed
1757
		 */
1758 1759 1760 1761 1762 1763
		old = LEFT;
		temp = PREV.br_blockcount - new->br_blockcount;
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
				startblockval(PREV.br_startblock));

		LEFT.br_blockcount += new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
1764

1765
		PREV.br_blockcount = temp;
1766 1767
		PREV.br_startoff += new->br_blockcount;
		PREV.br_startblock = nullstartblock(da_new);
1768

1769 1770 1771
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
		xfs_iext_prev(ifp, &bma->icur);
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1772

1773 1774 1775 1776
		if (bma->cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
1777
			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1778 1779
			if (error)
				goto done;
1780
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1781
			error = xfs_bmbt_update(bma->cur, &LEFT);
Christoph Hellwig's avatar
Christoph Hellwig committed
1782
			if (error)
Linus Torvalds's avatar
Linus Torvalds committed
1783 1784
				goto done;
		}
1785 1786 1787
		break;

	case BMAP_LEFT_FILLING:
Linus Torvalds's avatar
Linus Torvalds committed
1788
		/*
1789 1790
		 * Filling in the first part of a previous delayed allocation.
		 * The left neighbor is not contiguous.
Linus Torvalds's avatar
Linus Torvalds committed
1791
		 */
1792
		xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1793
		(*nextents)++;
1794 1795
		if (bma->cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
Linus Torvalds's avatar
Linus Torvalds committed
1796
		else {
1797
			rval = XFS_ILOG_CORE;
1798
			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1799 1800
			if (error)
				goto done;
1801
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1802 1803
			error = xfs_btree_insert(bma->cur, &i);
			if (error)
Linus Torvalds's avatar
Linus Torvalds committed
1804
				goto done;
1805
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
Linus Torvalds's avatar
Linus Torvalds committed
1806
		}
1807

1808
		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1809
			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1810
					&bma->cur, 1, &tmp_rval, whichfork);
1811 1812 1813
			rval |= tmp_rval;
			if (error)
				goto done;
Linus Torvalds's avatar
Linus Torvalds committed
1814
		}
1815 1816

		temp = PREV.br_blockcount - new->br_blockcount;
1817 1818 1819
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
			startblockval(PREV.br_startblock) -
			(bma->cur ? bma->cur->bc_private.b.allocated : 0));
1820 1821 1822 1823

		PREV.br_startoff = new_endoff;
		PREV.br_blockcount = temp;
		PREV.br_startblock = nullstartblock(da_new);
1824
		xfs_iext_next(ifp, &bma->icur);
1825
		xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1826
		xfs_iext_prev(ifp, &bma->icur);
Linus Torvalds's avatar
Linus Torvalds committed
1827 1828
		break;

1829
	case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
Linus Torvalds's avatar
Linus Torvalds committed
1830
		/*
1831 1832
		 * Filling in the last part of a previous delayed allocation.
		 * The right neighbor is contiguous with the new allocation.
Linus Torvalds's avatar
Linus Torvalds committed
1833
		 */
1834 1835 1836 1837 1838
		old = RIGHT;
		RIGHT.br_startoff = new->br_startoff;
		RIGHT.br_startblock = new->br_startblock;
		RIGHT.br_blockcount += new->br_blockcount;

1839 1840 1841 1842
		if (bma->cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
1843
			error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1844 1845
			if (error)
				goto done;
1846
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1847
			error = xfs_bmbt_update(bma->cur, &RIGHT);
1848 1849
			if (error)
				goto done;
Linus Torvalds's avatar
Linus Torvalds committed
1850
		}
1851

1852
		temp = PREV.br_blockcount - new->br_blockcount;
1853 1854
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
			startblockval(PREV.br_startblock));
1855 1856 1857

		PREV.br_blockcount = temp;
		PREV.br_startblock = nullstartblock(da_new);
1858

1859 1860 1861
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
		xfs_iext_next(ifp, &bma->icur);
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT);
Linus Torvalds's avatar
Linus Torvalds committed
1862 1863
		break;

1864
	case BMAP_RIGHT_FILLING:
Linus Torvalds's avatar
Linus Torvalds committed
1865
		/*
1866 1867
		 * Filling in the last part of a previous delayed allocation.
		 * The right neighbor is not contiguous.
Linus Torvalds's avatar
Linus Torvalds committed
1868
		 */
1869
		xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1870
		(*nextents)++;
1871 1872 1873 1874
		if (bma->cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
1875
			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1876 1877
			if (error)
				goto done;
1878
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1879 1880 1881
			error = xfs_btree_insert(bma->cur, &i);
			if (error)
				goto done;
1882
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
Linus Torvalds's avatar
Linus Torvalds committed
1883
		}
1884

1885
		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1886
			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1887
				&bma->cur, 1, &tmp_rval, whichfork);
1888 1889 1890
			rval |= tmp_rval;
			if (error)
				goto done;
Linus Torvalds's avatar
Linus Torvalds committed
1891
		}
1892 1893

		temp = PREV.br_blockcount - new->br_blockcount;
1894 1895 1896
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
			startblockval(PREV.br_startblock) -
			(bma->cur ? bma->cur->bc_private.b.allocated : 0));
1897 1898 1899

		PREV.br_startblock = nullstartblock(da_new);
		PREV.br_blockcount = temp;
1900
		xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1901
		xfs_iext_next(ifp, &bma->icur);
Linus Torvalds's avatar
Linus Torvalds committed
1902 1903 1904 1905
		break;

	case 0:
		/*
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
		 * Filling in the middle part of a previous delayed allocation.
		 * Contiguity is impossible here.
		 * This case is avoided almost all the time.
		 *
		 * We start with a delayed allocation:
		 *
		 * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+
		 *  PREV @ idx
		 *
	         * and we are allocating:
		 *                     +rrrrrrrrrrrrrrrrr+
		 *			      new
		 *
		 * and we set it up for insertion as:
		 * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+
		 *                            new
		 *  PREV @ idx          LEFT              RIGHT
		 *                      inserted at idx + 1
Linus Torvalds's avatar
Linus Torvalds committed
1924
		 */
1925 1926 1927
		old = PREV;

		/* LEFT is the new middle */
1928
		LEFT = *new;
1929 1930

		/* RIGHT is the new right */
1931 1932
		RIGHT.br_state = PREV.br_state;
		RIGHT.br_startoff = new_endoff;
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
		RIGHT.br_blockcount =
			PREV.br_startoff + PREV.br_blockcount - new_endoff;
		RIGHT.br_startblock =
			nullstartblock(xfs_bmap_worst_indlen(bma->ip,
					RIGHT.br_blockcount));

		/* truncate PREV */
		PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
		PREV.br_startblock =
			nullstartblock(xfs_bmap_worst_indlen(bma->ip,
					PREV.br_blockcount));
1944
		xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1945

1946
		xfs_iext_next(ifp, &bma->icur);
1947 1948
		xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state);
		xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state);
1949
		(*nextents)++;
1950

1951 1952 1953 1954
		if (bma->cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
1955
			error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1956 1957
			if (error)
				goto done;
1958
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1959 1960 1961
			error = xfs_btree_insert(bma->cur, &i);
			if (error)
				goto done;
1962
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
Linus Torvalds's avatar
Linus Torvalds committed
1963 1964
		}

1965
		if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1966
			error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1967
					&bma->cur, 1, &tmp_rval, whichfork);
1968 1969 1970 1971
			rval |= tmp_rval;
			if (error)
				goto done;
		}
1972 1973 1974

		da_new = startblockval(PREV.br_startblock) +
			 startblockval(RIGHT.br_startblock);
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
		break;

	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_LEFT_CONTIG:
	case BMAP_RIGHT_CONTIG:
		/*
		 * These cases are all impossible.
		 */
		ASSERT(0);
	}

1990 1991
	/* add reverse mapping unless caller opted out */
	if (!(bma->flags & XFS_BMAPI_NORMAP)) {
1992
		error = xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1993 1994 1995
		if (error)
			goto done;
	}
1996

1997
	/* convert to a btree if necessary */
1998
	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1999 2000 2001 2002
		int	tmp_logflags;	/* partial log flag return val */

		ASSERT(bma->cur == NULL);
		error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
2003 2004
				&bma->cur, da_old > 0, &tmp_logflags,
				whichfork);
2005 2006 2007 2008 2009
		bma->logflags |= tmp_logflags;
		if (error)
			goto done;
	}

2010 2011 2012
	if (bma->cur) {
		da_new += bma->cur->bc_private.b.allocated;
		bma->cur->bc_private.b.allocated = 0;
2013
	}
2014

2015 2016 2017 2018 2019 2020
	/* adjust for changes in reserved delayed indirect blocks */
	if (da_new != da_old) {
		ASSERT(state == 0 || da_new < da_old);
		error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new),
				false);
	}
2021

2022
	xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork);
Linus Torvalds's avatar
Linus Torvalds committed
2023
done:
2024 2025
	if (whichfork != XFS_COW_FORK)
		bma->logflags |= rval;
Linus Torvalds's avatar
Linus Torvalds committed
2026
	return error;
2027 2028 2029
#undef	LEFT
#undef	RIGHT
#undef	PREV
Linus Torvalds's avatar
Linus Torvalds committed
2030 2031 2032
}

/*
2033
 * Convert an unwritten allocation to a real allocation or vice versa.
Linus Torvalds's avatar
Linus Torvalds committed
2034
 */
2035 2036 2037 2038
STATIC int				/* error */
xfs_bmap_add_extent_unwritten_real(
	struct xfs_trans	*tp,
	xfs_inode_t		*ip,	/* incore inode pointer */
2039
	int			whichfork,
2040
	struct xfs_iext_cursor	*icur,
2041 2042 2043
	xfs_btree_cur_t		**curp,	/* if *curp is null, not a btree */
	xfs_bmbt_irec_t		*new,	/* new data to add to file extents */
	int			*logflagsp) /* inode logging flags */
Linus Torvalds's avatar
Linus Torvalds committed
2044
{
2045 2046 2047
	xfs_btree_cur_t		*cur;	/* btree cursor */
	int			error;	/* error return value */
	int			i;	/* temp state */
2048
	struct xfs_ifork	*ifp;	/* inode fork pointer */
2049 2050 2051 2052
	xfs_fileoff_t		new_endoff;	/* end offset of new entry */
	xfs_bmbt_irec_t		r[3];	/* neighbor extent entries */
					/* left is 0, right is 1, prev is 2 */
	int			rval=0;	/* return value (logging flags) */
2053
	int			state = xfs_bmap_fork_to_state(whichfork);
2054
	struct xfs_mount	*mp = ip->i_mount;
2055
	struct xfs_bmbt_irec	old;
Linus Torvalds's avatar
Linus Torvalds committed
2056

2057
	*logflagsp = 0;
Linus Torvalds's avatar
Linus Torvalds committed
2058

2059
	cur = *curp;
2060
	ifp = XFS_IFORK_PTR(ip, whichfork);
2061

2062 2063
	ASSERT(!isnullstartblock(new->br_startblock));

2064
	XFS_STATS_INC(mp, xs_add_exlist);
2065 2066 2067 2068

#define	LEFT		r[0]
#define	RIGHT		r[1]
#define	PREV		r[2]
2069

Linus Torvalds's avatar
Linus Torvalds committed
2070
	/*
2071
	 * Set up a bunch of variables to make the tests simpler.
Linus Torvalds's avatar
Linus Torvalds committed
2072
	 */
2073
	error = 0;
2074
	xfs_iext_get_extent(ifp, icur, &PREV);
2075
	ASSERT(new->br_state != PREV.br_state);
2076 2077 2078
	new_endoff = new->br_startoff + new->br_blockcount;
	ASSERT(PREV.br_startoff <= new->br_startoff);
	ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
2079

Linus Torvalds's avatar
Linus Torvalds committed
2080
	/*
2081 2082
	 * Set flags determining what part of the previous oldext allocation
	 * extent is being replaced by a newext allocation.
Linus Torvalds's avatar
Linus Torvalds committed
2083
	 */
2084 2085 2086 2087 2088
	if (PREV.br_startoff == new->br_startoff)
		state |= BMAP_LEFT_FILLING;
	if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
		state |= BMAP_RIGHT_FILLING;

Linus Torvalds's avatar
Linus Torvalds committed
2089
	/*
2090 2091
	 * Check and set flags if this segment has a left neighbor.
	 * Don't set contiguous if the combined extent would be too large.
Linus Torvalds's avatar
Linus Torvalds committed
2092
	 */
2093
	if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) {
2094 2095 2096
		state |= BMAP_LEFT_VALID;
		if (isnullstartblock(LEFT.br_startblock))
			state |= BMAP_LEFT_DELAY;
Linus Torvalds's avatar
Linus Torvalds committed
2097
	}
2098 2099 2100 2101

	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
	    LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
	    LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
2102
	    LEFT.br_state == new->br_state &&
2103 2104 2105
	    LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
		state |= BMAP_LEFT_CONTIG;

Linus Torvalds's avatar
Linus Torvalds committed
2106
	/*
2107 2108 2109
	 * Check and set flags if this segment has a right neighbor.
	 * Don't set contiguous if the combined extent would be too large.
	 * Also check for all-three-contiguous being too large.
Linus Torvalds's avatar
Linus Torvalds committed
2110
	 */
2111
	if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) {
2112 2113 2114
		state |= BMAP_RIGHT_VALID;
		if (isnullstartblock(RIGHT.br_startblock))
			state |= BMAP_RIGHT_DELAY;
Linus Torvalds's avatar
Linus Torvalds committed
2115
	}
2116

2117 2118 2119
	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
	    new_endoff == RIGHT.br_startoff &&
	    new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
2120
	    new->br_state == RIGHT.br_state &&
2121 2122 2123 2124 2125 2126 2127 2128
	    new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
	    ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
		       BMAP_RIGHT_FILLING)) !=
		      (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
		       BMAP_RIGHT_FILLING) ||
	     LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
			<= MAXEXTLEN))
		state |= BMAP_RIGHT_CONTIG;
2129

Linus Torvalds's avatar
Linus Torvalds committed
2130
	/*
2131
	 * Switch out based on the FILLING and CONTIG state bits.
Linus Torvalds's avatar
Linus Torvalds committed
2132
	 */
2133 2134 2135 2136 2137 2138 2139 2140
	switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
			 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
	     BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
		/*
		 * Setting all of a previous oldext extent to newext.
		 * The left and right neighbors are both contiguous with new.
		 */
2141
		LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
Christoph Hellwig's avatar
Christoph Hellwig committed
2142

2143 2144
		xfs_iext_remove(ip, icur, state);
		xfs_iext_remove(ip, icur, state);
2145 2146
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &LEFT);
2147 2148
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) - 2);
2149 2150 2151 2152
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2153 2154
			error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
			if (error)
2155
				goto done;
2156
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2157 2158
			if ((error = xfs_btree_delete(cur, &i)))
				goto done;
2159
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2160 2161
			if ((error = xfs_btree_decrement(cur, 0, &i)))
				goto done;
2162
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2163 2164
			if ((error = xfs_btree_delete(cur, &i)))
				goto done;
2165
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2166 2167
			if ((error = xfs_btree_decrement(cur, 0, &i)))
				goto done;
2168
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2169
			error = xfs_bmbt_update(cur, &LEFT);
2170
			if (error)
2171 2172 2173
				goto done;
		}
		break;
Christoph Hellwig's avatar
Christoph Hellwig committed
2174

2175 2176 2177 2178 2179
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
		/*
		 * Setting all of a previous oldext extent to newext.
		 * The left neighbor is contiguous, the right is not.
		 */
2180
		LEFT.br_blockcount += PREV.br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2181

2182
		xfs_iext_remove(ip, icur, state);
2183 2184
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &LEFT);
2185 2186
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
2187 2188 2189 2190
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2191 2192
			error = xfs_bmbt_lookup_eq(cur, &PREV, &i);
			if (error)
2193
				goto done;
2194
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2195 2196
			if ((error = xfs_btree_delete(cur, &i)))
				goto done;
2197
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2198 2199
			if ((error = xfs_btree_decrement(cur, 0, &i)))
				goto done;
2200
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2201
			error = xfs_bmbt_update(cur, &LEFT);
2202
			if (error)
2203 2204 2205
				goto done;
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2206

2207
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
Linus Torvalds's avatar
Linus Torvalds committed
2208
		/*
2209 2210
		 * Setting all of a previous oldext extent to newext.
		 * The right neighbor is contiguous, the left is not.
Linus Torvalds's avatar
Linus Torvalds committed
2211
		 */
2212 2213
		PREV.br_blockcount += RIGHT.br_blockcount;
		PREV.br_state = new->br_state;
2214

2215
		xfs_iext_next(ifp, icur);
2216
		xfs_iext_remove(ip, icur, state);
2217 2218
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &PREV);
2219

2220 2221
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
2222 2223 2224 2225
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2226 2227
			error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
			if (error)
2228
				goto done;
2229
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2230 2231
			if ((error = xfs_btree_delete(cur, &i)))
				goto done;
2232
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2233 2234
			if ((error = xfs_btree_decrement(cur, 0, &i)))
				goto done;
2235
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2236
			error = xfs_bmbt_update(cur, &PREV);
2237
			if (error)
2238
				goto done;
Linus Torvalds's avatar
Linus Torvalds committed
2239
		}
2240
		break;
2241

2242 2243 2244 2245 2246 2247
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
		/*
		 * Setting all of a previous oldext extent to newext.
		 * Neither the left nor right neighbors are contiguous with
		 * the new one.
		 */
2248
		PREV.br_state = new->br_state;
2249
		xfs_iext_update_extent(ip, state, icur, &PREV);
2250

2251 2252 2253 2254
		if (cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
2255 2256
			error = xfs_bmbt_lookup_eq(cur, new, &i);
			if (error)
2257
				goto done;
2258
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2259
			error = xfs_bmbt_update(cur, &PREV);
2260
			if (error)
2261 2262 2263
				goto done;
		}
		break;
2264

2265 2266 2267 2268 2269
	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
		/*
		 * Setting the first part of a previous oldext extent to newext.
		 * The left neighbor is contiguous.
		 */
2270
		LEFT.br_blockcount += new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2271

2272 2273 2274 2275
		old = PREV;
		PREV.br_startoff += new->br_blockcount;
		PREV.br_startblock += new->br_blockcount;
		PREV.br_blockcount -= new->br_blockcount;
2276

2277 2278 2279
		xfs_iext_update_extent(ip, state, icur, &PREV);
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &LEFT);
2280

2281 2282 2283 2284
		if (cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
2285
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2286
			if (error)
2287
				goto done;
2288
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2289
			error = xfs_bmbt_update(cur, &PREV);
2290
			if (error)
2291
				goto done;
2292 2293
			error = xfs_btree_decrement(cur, 0, &i);
			if (error)
2294
				goto done;
2295
			error = xfs_bmbt_update(cur, &LEFT);
2296 2297
			if (error)
				goto done;
2298
		}
2299
		break;
2300

2301 2302 2303 2304 2305
	case BMAP_LEFT_FILLING:
		/*
		 * Setting the first part of a previous oldext extent to newext.
		 * The left neighbor is not contiguous.
		 */
2306 2307 2308 2309
		old = PREV;
		PREV.br_startoff += new->br_blockcount;
		PREV.br_startblock += new->br_blockcount;
		PREV.br_blockcount -= new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2310

2311
		xfs_iext_update_extent(ip, state, icur, &PREV);
2312
		xfs_iext_insert(ip, icur, new, state);
2313 2314
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
2315 2316 2317 2318
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2319
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2320
			if (error)
2321
				goto done;
2322
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2323
			error = xfs_bmbt_update(cur, &PREV);
2324
			if (error)
2325 2326 2327 2328
				goto done;
			cur->bc_rec.b = *new;
			if ((error = xfs_btree_insert(cur, &i)))
				goto done;
2329
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2330 2331
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2332

2333 2334 2335 2336 2337
	case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
		/*
		 * Setting the last part of a previous oldext extent to newext.
		 * The right neighbor is contiguous with the new allocation.
		 */
2338 2339
		old = PREV;
		PREV.br_blockcount -= new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2340

2341 2342 2343
		RIGHT.br_startoff = new->br_startoff;
		RIGHT.br_startblock = new->br_startblock;
		RIGHT.br_blockcount += new->br_blockcount;
2344

2345 2346 2347
		xfs_iext_update_extent(ip, state, icur, &PREV);
		xfs_iext_next(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &RIGHT);
Linus Torvalds's avatar
Linus Torvalds committed
2348

2349 2350 2351 2352
		if (cur == NULL)
			rval = XFS_ILOG_DEXT;
		else {
			rval = 0;
2353
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2354
			if (error)
2355
				goto done;
2356
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2357
			error = xfs_bmbt_update(cur, &PREV);
2358
			if (error)
2359
				goto done;
2360 2361
			error = xfs_btree_increment(cur, 0, &i);
			if (error)
2362
				goto done;
2363
			error = xfs_bmbt_update(cur, &RIGHT);
2364
			if (error)
2365 2366 2367
				goto done;
		}
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2368

2369 2370 2371 2372 2373
	case BMAP_RIGHT_FILLING:
		/*
		 * Setting the last part of a previous oldext extent to newext.
		 * The right neighbor is not contiguous.
		 */
2374 2375
		old = PREV;
		PREV.br_blockcount -= new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2376

2377 2378
		xfs_iext_update_extent(ip, state, icur, &PREV);
		xfs_iext_next(ifp, icur);
2379
		xfs_iext_insert(ip, icur, new, state);
2380

2381 2382
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
2383 2384 2385 2386
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2387
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2388
			if (error)
2389
				goto done;
2390
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2391
			error = xfs_bmbt_update(cur, &PREV);
2392
			if (error)
2393
				goto done;
2394 2395
			error = xfs_bmbt_lookup_eq(cur, new, &i);
			if (error)
2396
				goto done;
2397
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
2398 2399
			if ((error = xfs_btree_insert(cur, &i)))
				goto done;
2400
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2401 2402 2403 2404
		}
		break;

	case 0:
Linus Torvalds's avatar
Linus Torvalds committed
2405
		/*
2406 2407 2408
		 * Setting the middle part of a previous oldext extent to
		 * newext.  Contiguity is impossible here.
		 * One extent becomes three extents.
Linus Torvalds's avatar
Linus Torvalds committed
2409
		 */
2410 2411
		old = PREV;
		PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
2412

2413 2414 2415
		r[0] = *new;
		r[1].br_startoff = new_endoff;
		r[1].br_blockcount =
2416
			old.br_startoff + old.br_blockcount - new_endoff;
2417
		r[1].br_startblock = new->br_startblock + new->br_blockcount;
2418
		r[1].br_state = PREV.br_state;
2419

2420 2421
		xfs_iext_update_extent(ip, state, icur, &PREV);
		xfs_iext_next(ifp, icur);
2422 2423
		xfs_iext_insert(ip, icur, &r[1], state);
		xfs_iext_insert(ip, icur, &r[0], state);
2424

2425 2426
		XFS_IFORK_NEXT_SET(ip, whichfork,
				XFS_IFORK_NEXTENTS(ip, whichfork) + 2);
2427 2428 2429 2430
		if (cur == NULL)
			rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
		else {
			rval = XFS_ILOG_CORE;
2431
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2432
			if (error)
2433
				goto done;
2434
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2435
			/* new right extent - oldext */
2436 2437
			error = xfs_bmbt_update(cur, &r[1]);
			if (error)
2438 2439 2440 2441 2442
				goto done;
			/* new left extent - oldext */
			cur->bc_rec.b = PREV;
			if ((error = xfs_btree_insert(cur, &i)))
				goto done;
2443
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2444 2445 2446 2447 2448
			/*
			 * Reset the cursor to the position of the new extent
			 * we are about to insert as we can't trust it after
			 * the previous insert.
			 */
2449 2450
			error = xfs_bmbt_lookup_eq(cur, new, &i);
			if (error)
2451
				goto done;
2452
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
2453 2454 2455
			/* new middle extent - newext */
			if ((error = xfs_btree_insert(cur, &i)))
				goto done;
2456
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2457
		}
Linus Torvalds's avatar
Linus Torvalds committed
2458
		break;
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469

	case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
	case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
	case BMAP_LEFT_CONTIG:
	case BMAP_RIGHT_CONTIG:
		/*
		 * These cases are all impossible.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
2470 2471
		ASSERT(0);
	}
2472

2473
	/* update reverse mappings */
2474
	error = xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2475 2476 2477
	if (error)
		goto done;

2478
	/* convert to a btree if necessary */
2479
	if (xfs_bmap_needs_btree(ip, whichfork)) {
2480 2481 2482
		int	tmp_logflags;	/* partial log flag return val */

		ASSERT(cur == NULL);
2483 2484
		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
				&tmp_logflags, whichfork);
2485 2486 2487
		*logflagsp |= tmp_logflags;
		if (error)
			goto done;
Linus Torvalds's avatar
Linus Torvalds committed
2488
	}
2489

2490 2491 2492 2493
	/* clear out the allocated field, done with it now in any case. */
	if (cur) {
		cur->bc_private.b.allocated = 0;
		*curp = cur;
Linus Torvalds's avatar
Linus Torvalds committed
2494
	}
2495

2496
	xfs_bmap_check_leaf_extents(*curp, ip, whichfork);
2497 2498
done:
	*logflagsp |= rval;
Linus Torvalds's avatar
Linus Torvalds committed
2499
	return error;
2500 2501 2502
#undef	LEFT
#undef	RIGHT
#undef	PREV
Linus Torvalds's avatar
Linus Torvalds committed
2503 2504 2505
}

/*
2506
 * Convert a hole to a delayed allocation.
Linus Torvalds's avatar
Linus Torvalds committed
2507
 */
2508 2509 2510
STATIC void
xfs_bmap_add_extent_hole_delay(
	xfs_inode_t		*ip,	/* incore inode pointer */
2511
	int			whichfork,
2512
	struct xfs_iext_cursor	*icur,
2513
	xfs_bmbt_irec_t		*new)	/* new data to add to file extents */
Linus Torvalds's avatar
Linus Torvalds committed
2514
{
2515
	struct xfs_ifork	*ifp;	/* inode fork pointer */
2516 2517 2518 2519
	xfs_bmbt_irec_t		left;	/* left neighbor extent entry */
	xfs_filblks_t		newlen=0;	/* new indirect size */
	xfs_filblks_t		oldlen=0;	/* old indirect size */
	xfs_bmbt_irec_t		right;	/* right neighbor extent entry */
2520
	int			state = xfs_bmap_fork_to_state(whichfork);
2521
	xfs_filblks_t		temp;	 /* temp for indirect calculations */
Linus Torvalds's avatar
Linus Torvalds committed
2522

2523
	ifp = XFS_IFORK_PTR(ip, whichfork);
2524
	ASSERT(isnullstartblock(new->br_startblock));
Linus Torvalds's avatar
Linus Torvalds committed
2525 2526

	/*
2527
	 * Check and set flags if this segment has a left neighbor
Linus Torvalds's avatar
Linus Torvalds committed
2528
	 */
2529
	if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2530 2531 2532
		state |= BMAP_LEFT_VALID;
		if (isnullstartblock(left.br_startblock))
			state |= BMAP_LEFT_DELAY;
Linus Torvalds's avatar
Linus Torvalds committed
2533 2534
	}

2535 2536 2537 2538
	/*
	 * Check and set flags if the current (right) segment exists.
	 * If it doesn't exist, we're converting the hole at end-of-file.
	 */
2539
	if (xfs_iext_get_extent(ifp, icur, &right)) {
2540 2541 2542
		state |= BMAP_RIGHT_VALID;
		if (isnullstartblock(right.br_startblock))
			state |= BMAP_RIGHT_DELAY;
Linus Torvalds's avatar
Linus Torvalds committed
2543
	}
2544

Linus Torvalds's avatar
Linus Torvalds committed
2545
	/*
2546 2547
	 * Set contiguity flags on the left and right neighbors.
	 * Don't let extents get too large, even if the pieces are contiguous.
Linus Torvalds's avatar
Linus Torvalds committed
2548
	 */
2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&
	    left.br_startoff + left.br_blockcount == new->br_startoff &&
	    left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
		state |= BMAP_LEFT_CONTIG;

	if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&
	    new->br_startoff + new->br_blockcount == right.br_startoff &&
	    new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
	    (!(state & BMAP_LEFT_CONTIG) ||
	     (left.br_blockcount + new->br_blockcount +
	      right.br_blockcount <= MAXEXTLEN)))
		state |= BMAP_RIGHT_CONTIG;
2561 2562

	/*
2563
	 * Switch out based on the contiguity flags.
2564
	 */
2565 2566 2567 2568 2569 2570 2571 2572 2573
	switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
		/*
		 * New allocation is contiguous with delayed allocations
		 * on the left and on the right.
		 * Merge all three into a single extent record.
		 */
		temp = left.br_blockcount + new->br_blockcount +
			right.br_blockcount;
2574

2575 2576 2577
		oldlen = startblockval(left.br_startblock) +
			startblockval(new->br_startblock) +
			startblockval(right.br_startblock);
2578 2579
		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
					 oldlen);
2580 2581
		left.br_startblock = nullstartblock(newlen);
		left.br_blockcount = temp;
Linus Torvalds's avatar
Linus Torvalds committed
2582

2583
		xfs_iext_remove(ip, icur, state);
2584 2585
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &left);
2586
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2587

2588 2589 2590 2591 2592 2593 2594
	case BMAP_LEFT_CONTIG:
		/*
		 * New allocation is contiguous with a delayed allocation
		 * on the left.
		 * Merge the new allocation with the left neighbor.
		 */
		temp = left.br_blockcount + new->br_blockcount;
Linus Torvalds's avatar
Linus Torvalds committed
2595

2596 2597
		oldlen = startblockval(left.br_startblock) +
			startblockval(new->br_startblock);
2598 2599
		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
					 oldlen);
2600 2601
		left.br_blockcount = temp;
		left.br_startblock = nullstartblock(newlen);
2602

2603 2604
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &left);
2605
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2606

2607 2608 2609 2610 2611 2612 2613 2614 2615
	case BMAP_RIGHT_CONTIG:
		/*
		 * New allocation is contiguous with a delayed allocation
		 * on the right.
		 * Merge the new allocation with the right neighbor.
		 */
		temp = new->br_blockcount + right.br_blockcount;
		oldlen = startblockval(new->br_startblock) +
			startblockval(right.br_startblock);
2616 2617
		newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
					 oldlen);
2618 2619 2620
		right.br_startoff = new->br_startoff;
		right.br_startblock = nullstartblock(newlen);
		right.br_blockcount = temp;
2621
		xfs_iext_update_extent(ip, state, icur, &right);
2622 2623 2624 2625 2626 2627 2628 2629 2630
		break;

	case 0:
		/*
		 * New allocation is not contiguous with another
		 * delayed allocation.
		 * Insert a new entry.
		 */
		oldlen = newlen = 0;
2631
		xfs_iext_insert(ip, icur, new, state);
2632
		break;
Linus Torvalds's avatar
Linus Torvalds committed
2633
	}
2634 2635
	if (oldlen != newlen) {
		ASSERT(oldlen > newlen);
2636 2637
		xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen),
				 false);
Linus Torvalds's avatar
Linus Torvalds committed
2638
		/*
2639
		 * Nothing to do for disk quota accounting here.
Linus Torvalds's avatar
Linus Torvalds committed
2640 2641 2642 2643 2644
		 */
	}
}

/*
2645
 * Convert a hole to a real allocation.
Linus Torvalds's avatar
Linus Torvalds committed
2646
 */
2647 2648
STATIC int				/* error */
xfs_bmap_add_extent_hole_real(
2649 2650 2651
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	int			whichfork,
2652
	struct xfs_iext_cursor	*icur,
2653 2654
	struct xfs_btree_cur	**curp,
	struct xfs_bmbt_irec	*new,
2655 2656
	int			*logflagsp,
	int			flags)
2657
{
2658 2659 2660
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_btree_cur	*cur = *curp;
2661 2662 2663 2664 2665
	int			error;	/* error return value */
	int			i;	/* temp state */
	xfs_bmbt_irec_t		left;	/* left neighbor extent entry */
	xfs_bmbt_irec_t		right;	/* right neighbor extent entry */
	int			rval=0;	/* return value (logging flags) */
2666
	int			state = xfs_bmap_fork_to_state(whichfork);
2667
	struct xfs_bmbt_irec	old;
2668

2669
	ASSERT(!isnullstartblock(new->br_startblock));
2670
	ASSERT(!cur || !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
2671

2672
	XFS_STATS_INC(mp, xs_add_exlist);
2673

2674 2675 2676
	/*
	 * Check and set flags if this segment has a left neighbor.
	 */
2677
	if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2678 2679 2680 2681
		state |= BMAP_LEFT_VALID;
		if (isnullstartblock(left.br_startblock))
			state |= BMAP_LEFT_DELAY;
	}
2682 2683

	/*
2684 2685
	 * Check and set flags if this segment has a current value.
	 * Not true if we're inserting into the "hole" at eof.
2686
	 */
2687
	if (xfs_iext_get_extent(ifp, icur, &right)) {
2688 2689 2690 2691
		state |= BMAP_RIGHT_VALID;
		if (isnullstartblock(right.br_startblock))
			state |= BMAP_RIGHT_DELAY;
	}
2692

2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
	/*
	 * We're inserting a real allocation between "left" and "right".
	 * Set the contiguity flags.  Don't let extents get too large.
	 */
	if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
	    left.br_startoff + left.br_blockcount == new->br_startoff &&
	    left.br_startblock + left.br_blockcount == new->br_startblock &&
	    left.br_state == new->br_state &&
	    left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
		state |= BMAP_LEFT_CONTIG;
2703

2704 2705 2706 2707 2708 2709 2710 2711 2712
	if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
	    new->br_startoff + new->br_blockcount == right.br_startoff &&
	    new->br_startblock + new->br_blockcount == right.br_startblock &&
	    new->br_state == right.br_state &&
	    new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
	    (!(state & BMAP_LEFT_CONTIG) ||
	     left.br_blockcount + new->br_blockcount +
	     right.br_blockcount <= MAXEXTLEN))
		state |= BMAP_RIGHT_CONTIG;
2713

2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724
	error = 0;
	/*
	 * Select which case we're in here, and implement it.
	 */
	switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
	case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
		/*
		 * New allocation is contiguous with real allocations on the
		 * left and on the right.
		 * Merge all three into a single extent record.
		 */
2725
		left.br_blockcount += new->br_blockcount + right.br_blockcount;
2726

2727
		xfs_iext_remove(ip, icur, state);
2728 2729
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &left);
2730

2731 2732 2733
		XFS_IFORK_NEXT_SET(ip, whichfork,
			XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
		if (cur == NULL) {
2734 2735 2736
			rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
		} else {
			rval = XFS_ILOG_CORE;
2737
			error = xfs_bmbt_lookup_eq(cur, &right, &i);
2738 2739
			if (error)
				goto done;
2740
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2741
			error = xfs_btree_delete(cur, &i);
2742 2743
			if (error)
				goto done;
2744
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2745
			error = xfs_btree_decrement(cur, 0, &i);
2746 2747
			if (error)
				goto done;
2748
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2749
			error = xfs_bmbt_update(cur, &left);
2750 2751 2752 2753
			if (error)
				goto done;
		}
		break;
2754

2755 2756 2757 2758 2759 2760
	case BMAP_LEFT_CONTIG:
		/*
		 * New allocation is contiguous with a real allocation
		 * on the left.
		 * Merge the new allocation with the left neighbor.
		 */
2761 2762
		old = left;
		left.br_blockcount += new->br_blockcount;
2763

2764 2765
		xfs_iext_prev(ifp, icur);
		xfs_iext_update_extent(ip, state, icur, &left);
Linus Torvalds's avatar
Linus Torvalds committed
2766

2767
		if (cur == NULL) {
2768 2769 2770
			rval = xfs_ilog_fext(whichfork);
		} else {
			rval = 0;
2771
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2772 2773
			if (error)
				goto done;
2774
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2775
			error = xfs_bmbt_update(cur, &left);
2776 2777 2778 2779
			if (error)
				goto done;
		}
		break;
2780

2781 2782 2783 2784 2785 2786
	case BMAP_RIGHT_CONTIG:
		/*
		 * New allocation is contiguous with a real allocation
		 * on the right.
		 * Merge the new allocation with the right neighbor.
		 */
2787
		old = right;
2788

2789 2790 2791
		right.br_startoff = new->br_startoff;
		right.br_startblock = new->br_startblock;
		right.br_blockcount += new->br_blockcount;
2792
		xfs_iext_update_extent(ip, state, icur, &right);
2793

2794
		if (cur == NULL) {
2795 2796 2797
			rval = xfs_ilog_fext(whichfork);
		} else {
			rval = 0;
2798
			error = xfs_bmbt_lookup_eq(cur, &old, &i);
2799 2800
			if (error)
				goto done;
2801
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2802
			error = xfs_bmbt_update(cur, &right);
2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
			if (error)
				goto done;
		}
		break;

	case 0:
		/*
		 * New allocation is not contiguous with another
		 * real allocation.
		 * Insert a new entry.
		 */
2814
		xfs_iext_insert(ip, icur, new, state);
2815 2816 2817
		XFS_IFORK_NEXT_SET(ip, whichfork,
			XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
		if (cur == NULL) {
2818 2819 2820
			rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
		} else {
			rval = XFS_ILOG_CORE;
2821
			error = xfs_bmbt_lookup_eq(cur, new, &i);
2822 2823
			if (error)
				goto done;
2824
			XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
2825
			error = xfs_btree_insert(cur, &i);
2826 2827
			if (error)
				goto done;
2828
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
2829 2830 2831 2832
		}
		break;
	}

2833 2834
	/* add reverse mapping unless caller opted out */
	if (!(flags & XFS_BMAPI_NORMAP)) {
2835
		error = xfs_rmap_map_extent(tp, ip, whichfork, new);
2836 2837 2838
		if (error)
			goto done;
	}
2839

2840
	/* convert to a btree if necessary */
2841
	if (xfs_bmap_needs_btree(ip, whichfork)) {
2842 2843
		int	tmp_logflags;	/* partial log flag return val */

2844
		ASSERT(cur == NULL);
2845 2846
		error = xfs_bmap_extents_to_btree(tp, ip, curp, 0,
				&tmp_logflags, whichfork);
2847 2848
		*logflagsp |= tmp_logflags;
		cur = *curp;
2849 2850 2851 2852 2853
		if (error)
			goto done;
	}

	/* clear out the allocated field, done with it now in any case. */
2854 2855
	if (cur)
		cur->bc_private.b.allocated = 0;
2856

2857
	xfs_bmap_check_leaf_extents(cur, ip, whichfork);
2858
done:
2859
	*logflagsp |= rval;
2860
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
2861 2862 2863
}

/*
2864
 * Functions used in the extent read, allocate and remove paths
Linus Torvalds's avatar
Linus Torvalds committed
2865 2866
 */

2867 2868 2869
/*
 * Adjust the size of the new extent based on di_extsize and rt extsize.
 */
2870
int
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881
xfs_bmap_extsize_align(
	xfs_mount_t	*mp,
	xfs_bmbt_irec_t	*gotp,		/* next extent pointer */
	xfs_bmbt_irec_t	*prevp,		/* previous extent pointer */
	xfs_extlen_t	extsz,		/* align to this extent size */
	int		rt,		/* is this a realtime inode? */
	int		eof,		/* is extent at end-of-file? */
	int		delay,		/* creating delalloc extent? */
	int		convert,	/* overwriting unwritten extent? */
	xfs_fileoff_t	*offp,		/* in/out: aligned offset */
	xfs_extlen_t	*lenp)		/* in/out: aligned length */
2882
{
2883 2884 2885 2886 2887 2888 2889 2890
	xfs_fileoff_t	orig_off;	/* original offset */
	xfs_extlen_t	orig_alen;	/* original length */
	xfs_fileoff_t	orig_end;	/* original off+len */
	xfs_fileoff_t	nexto;		/* next file offset */
	xfs_fileoff_t	prevo;		/* previous file offset */
	xfs_fileoff_t	align_off;	/* temp for offset */
	xfs_extlen_t	align_alen;	/* temp for length */
	xfs_extlen_t	temp;		/* temp for calculations */
2891

2892
	if (convert)
2893 2894
		return 0;

2895 2896 2897
	orig_off = align_off = *offp;
	orig_alen = align_alen = *lenp;
	orig_end = orig_off + orig_alen;
Linus Torvalds's avatar
Linus Torvalds committed
2898 2899

	/*
2900 2901
	 * If this request overlaps an existing extent, then don't
	 * attempt to perform any additional alignment.
Linus Torvalds's avatar
Linus Torvalds committed
2902
	 */
2903 2904 2905 2906 2907 2908
	if (!delay && !eof &&
	    (orig_off >= gotp->br_startoff) &&
	    (orig_end <= gotp->br_startoff + gotp->br_blockcount)) {
		return 0;
	}

Linus Torvalds's avatar
Linus Torvalds committed
2909
	/*
2910 2911 2912 2913 2914
	 * If the file offset is unaligned vs. the extent size
	 * we need to align it.  This will be possible unless
	 * the file was previously written with a kernel that didn't
	 * perform this alignment, or if a truncate shot us in the
	 * foot.
Linus Torvalds's avatar
Linus Torvalds committed
2915
	 */
2916
	div_u64_rem(orig_off, extsz, &temp);
2917 2918 2919
	if (temp) {
		align_alen += temp;
		align_off -= temp;
Linus Torvalds's avatar
Linus Torvalds committed
2920
	}
2921 2922 2923 2924 2925 2926

	/* Same adjustment for the end of the requested area. */
	temp = (align_alen % extsz);
	if (temp)
		align_alen += extsz - temp;

Linus Torvalds's avatar
Linus Torvalds committed
2927
	/*
2928 2929 2930 2931 2932 2933
	 * For large extent hint sizes, the aligned extent might be larger than
	 * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls
	 * the length back under MAXEXTLEN. The outer allocation loops handle
	 * short allocation just fine, so it is safe to do this. We only want to
	 * do it when we are forced to, though, because it means more allocation
	 * operations are required.
Linus Torvalds's avatar
Linus Torvalds committed
2934
	 */
2935 2936 2937 2938
	while (align_alen > MAXEXTLEN)
		align_alen -= extsz;
	ASSERT(align_alen <= MAXEXTLEN);

Linus Torvalds's avatar
Linus Torvalds committed
2939
	/*
2940 2941
	 * If the previous block overlaps with this proposed allocation
	 * then move the start forward without adjusting the length.
Linus Torvalds's avatar
Linus Torvalds committed
2942
	 */
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
	if (prevp->br_startoff != NULLFILEOFF) {
		if (prevp->br_startblock == HOLESTARTBLOCK)
			prevo = prevp->br_startoff;
		else
			prevo = prevp->br_startoff + prevp->br_blockcount;
	} else
		prevo = 0;
	if (align_off != orig_off && align_off < prevo)
		align_off = prevo;
	/*
	 * If the next block overlaps with this proposed allocation
	 * then move the start back without adjusting the length,
	 * but not before offset 0.
	 * This may of course make the start overlap previous block,
	 * and if we hit the offset 0 limit then the next block
	 * can still overlap too.
	 */
	if (!eof && gotp->br_startoff != NULLFILEOFF) {
		if ((delay && gotp->br_startblock == HOLESTARTBLOCK) ||
		    (!delay && gotp->br_startblock == DELAYSTARTBLOCK))
			nexto = gotp->br_startoff + gotp->br_blockcount;
		else
			nexto = gotp->br_startoff;
	} else
		nexto = NULLFILEOFF;
	if (!eof &&
	    align_off + align_alen != orig_end &&
	    align_off + align_alen > nexto)
		align_off = nexto > align_alen ? nexto - align_alen : 0;
	/*
	 * If we're now overlapping the next or previous extent that
	 * means we can't fit an extsz piece in this hole.  Just move
	 * the start forward to the first valid spot and set
	 * the length so we hit the end.
	 */
	if (align_off != orig_off && align_off < prevo)
		align_off = prevo;
	if (align_off + align_alen != orig_end &&
	    align_off + align_alen > nexto &&
	    nexto != NULLFILEOFF) {
		ASSERT(nexto > prevo);
		align_alen = nexto - align_off;
	}
Linus Torvalds's avatar
Linus Torvalds committed
2986

2987 2988 2989 2990 2991
	/*
	 * If realtime, and the result isn't a multiple of the realtime
	 * extent size we need to remove blocks until it is.
	 */
	if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) {
Linus Torvalds's avatar
Linus Torvalds committed
2992
		/*
2993 2994
		 * We're not covering the original request, or
		 * we won't be able to once we fix the length.
Linus Torvalds's avatar
Linus Torvalds committed
2995
		 */
2996 2997 2998
		if (orig_off < align_off ||
		    orig_end > align_off + align_alen ||
		    align_alen - temp < orig_alen)
2999
			return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
3000
		/*
3001
		 * Try to fix it by moving the start up.
Linus Torvalds's avatar
Linus Torvalds committed
3002
		 */
3003 3004 3005
		if (align_off + temp <= orig_off) {
			align_alen -= temp;
			align_off += temp;
Linus Torvalds's avatar
Linus Torvalds committed
3006
		}
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
		/*
		 * Try to fix it by moving the end in.
		 */
		else if (align_off + align_alen - temp >= orig_end)
			align_alen -= temp;
		/*
		 * Set the start to the minimum then trim the length.
		 */
		else {
			align_alen -= orig_off - align_off;
			align_off = orig_off;
			align_alen -= align_alen % mp->m_sb.sb_rextsize;
Linus Torvalds's avatar
Linus Torvalds committed
3019 3020
		}
		/*
3021
		 * Result doesn't cover the request, fail it.
Linus Torvalds's avatar
Linus Torvalds committed
3022
		 */
3023
		if (orig_off < align_off || orig_end > align_off + align_alen)
3024
			return -EINVAL;
3025 3026
	} else {
		ASSERT(orig_off >= align_off);
3027 3028 3029
		/* see MAXEXTLEN handling above */
		ASSERT(orig_end <= align_off + align_alen ||
		       align_alen + extsz > MAXEXTLEN);
Linus Torvalds's avatar
Linus Torvalds committed
3030 3031
	}

3032
#ifdef DEBUG
3033 3034 3035 3036 3037
	if (!eof && gotp->br_startoff != NULLFILEOFF)
		ASSERT(align_off + align_alen <= gotp->br_startoff);
	if (prevp->br_startoff != NULLFILEOFF)
		ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
3038

3039 3040 3041
	*lenp = align_alen;
	*offp = align_off;
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3042 3043
}

3044 3045
#define XFS_ALLOC_GAP_UNITS	4

3046
void
3047
xfs_bmap_adjacent(
3048
	struct xfs_bmalloca	*ap)	/* bmap alloc argument struct */
Linus Torvalds's avatar
Linus Torvalds committed
3049
{
3050 3051 3052 3053 3054
	xfs_fsblock_t	adjust;		/* adjustment to block numbers */
	xfs_agnumber_t	fb_agno;	/* ag number of ap->firstblock */
	xfs_mount_t	*mp;		/* mount point structure */
	int		nullfb;		/* true if ap->firstblock isn't set */
	int		rt;		/* true if inode is realtime */
Linus Torvalds's avatar
Linus Torvalds committed
3055

3056 3057 3058 3059 3060 3061
#define	ISVALID(x,y)	\
	(rt ? \
		(x) < mp->m_sb.sb_rblocks : \
		XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
		XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
		XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
Linus Torvalds's avatar
Linus Torvalds committed
3062

3063
	mp = ap->ip->i_mount;
3064
	nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
3065 3066
	rt = XFS_IS_REALTIME_INODE(ap->ip) &&
		xfs_alloc_is_userdata(ap->datatype);
3067 3068
	fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
							ap->tp->t_firstblock);
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133
	/*
	 * If allocating at eof, and there's a previous real block,
	 * try to use its last block as our starting point.
	 */
	if (ap->eof && ap->prev.br_startoff != NULLFILEOFF &&
	    !isnullstartblock(ap->prev.br_startblock) &&
	    ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount,
		    ap->prev.br_startblock)) {
		ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount;
		/*
		 * Adjust for the gap between prevp and us.
		 */
		adjust = ap->offset -
			(ap->prev.br_startoff + ap->prev.br_blockcount);
		if (adjust &&
		    ISVALID(ap->blkno + adjust, ap->prev.br_startblock))
			ap->blkno += adjust;
	}
	/*
	 * If not at eof, then compare the two neighbor blocks.
	 * Figure out whether either one gives us a good starting point,
	 * and pick the better one.
	 */
	else if (!ap->eof) {
		xfs_fsblock_t	gotbno;		/* right side block number */
		xfs_fsblock_t	gotdiff=0;	/* right side difference */
		xfs_fsblock_t	prevbno;	/* left side block number */
		xfs_fsblock_t	prevdiff=0;	/* left side difference */

		/*
		 * If there's a previous (left) block, select a requested
		 * start block based on it.
		 */
		if (ap->prev.br_startoff != NULLFILEOFF &&
		    !isnullstartblock(ap->prev.br_startblock) &&
		    (prevbno = ap->prev.br_startblock +
			       ap->prev.br_blockcount) &&
		    ISVALID(prevbno, ap->prev.br_startblock)) {
			/*
			 * Calculate gap to end of previous block.
			 */
			adjust = prevdiff = ap->offset -
				(ap->prev.br_startoff +
				 ap->prev.br_blockcount);
			/*
			 * Figure the startblock based on the previous block's
			 * end and the gap size.
			 * Heuristic!
			 * If the gap is large relative to the piece we're
			 * allocating, or using it gives us an invalid block
			 * number, then just use the end of the previous block.
			 */
			if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
			    ISVALID(prevbno + prevdiff,
				    ap->prev.br_startblock))
				prevbno += adjust;
			else
				prevdiff += adjust;
			/*
			 * If the firstblock forbids it, can't use it,
			 * must use default.
			 */
			if (!rt && !nullfb &&
			    XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno)
				prevbno = NULLFSBLOCK;
Linus Torvalds's avatar
Linus Torvalds committed
3134
		}
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191
		/*
		 * No previous block or can't follow it, just default.
		 */
		else
			prevbno = NULLFSBLOCK;
		/*
		 * If there's a following (right) block, select a requested
		 * start block based on it.
		 */
		if (!isnullstartblock(ap->got.br_startblock)) {
			/*
			 * Calculate gap to start of next block.
			 */
			adjust = gotdiff = ap->got.br_startoff - ap->offset;
			/*
			 * Figure the startblock based on the next block's
			 * start and the gap size.
			 */
			gotbno = ap->got.br_startblock;
			/*
			 * Heuristic!
			 * If the gap is large relative to the piece we're
			 * allocating, or using it gives us an invalid block
			 * number, then just use the start of the next block
			 * offset by our length.
			 */
			if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
			    ISVALID(gotbno - gotdiff, gotbno))
				gotbno -= adjust;
			else if (ISVALID(gotbno - ap->length, gotbno)) {
				gotbno -= ap->length;
				gotdiff += adjust - ap->length;
			} else
				gotdiff += adjust;
			/*
			 * If the firstblock forbids it, can't use it,
			 * must use default.
			 */
			if (!rt && !nullfb &&
			    XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno)
				gotbno = NULLFSBLOCK;
		}
		/*
		 * No next block, just default.
		 */
		else
			gotbno = NULLFSBLOCK;
		/*
		 * If both valid, pick the better one, else the only good
		 * one, else ap->blkno is already set (to 0 or the inode block).
		 */
		if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK)
			ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno;
		else if (prevbno != NULLFSBLOCK)
			ap->blkno = prevbno;
		else if (gotbno != NULLFSBLOCK)
			ap->blkno = gotbno;
Linus Torvalds's avatar
Linus Torvalds committed
3192
	}
3193
#undef ISVALID
Linus Torvalds's avatar
Linus Torvalds committed
3194 3195
}

3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219
static int
xfs_bmap_longest_free_extent(
	struct xfs_trans	*tp,
	xfs_agnumber_t		ag,
	xfs_extlen_t		*blen,
	int			*notinit)
{
	struct xfs_mount	*mp = tp->t_mountp;
	struct xfs_perag	*pag;
	xfs_extlen_t		longest;
	int			error = 0;

	pag = xfs_perag_get(mp, ag);
	if (!pag->pagf_init) {
		error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK);
		if (error)
			goto out;

		if (!pag->pagf_init) {
			*notinit = 1;
			goto out;
		}
	}

3220
	longest = xfs_alloc_longest_free_extent(pag,
3221 3222
				xfs_alloc_min_freelist(mp, pag),
				xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
	if (*blen < longest)
		*blen = longest;

out:
	xfs_perag_put(pag);
	return error;
}

static void
xfs_bmap_select_minlen(
	struct xfs_bmalloca	*ap,
	struct xfs_alloc_arg	*args,
	xfs_extlen_t		*blen,
	int			notinit)
{
	if (notinit || *blen < ap->minlen) {
		/*
		 * Since we did a BUF_TRYLOCK above, it is possible that
		 * there is space for this request.
		 */
		args->minlen = ap->minlen;
	} else if (*blen < args->maxlen) {
		/*
		 * If the best seen length is less than the request length,
		 * use the best as the minimum.
		 */
		args->minlen = *blen;
	} else {
		/*
		 * Otherwise we've seen an extent as big as maxlen, use that
		 * as the minimum.
		 */
		args->minlen = args->maxlen;
	}
}

3259
STATIC int
3260 3261 3262 3263
xfs_bmap_btalloc_nullfb(
	struct xfs_bmalloca	*ap,
	struct xfs_alloc_arg	*args,
	xfs_extlen_t		*blen)
3264
{
3265 3266 3267
	struct xfs_mount	*mp = ap->ip->i_mount;
	xfs_agnumber_t		ag, startag;
	int			notinit = 0;
3268 3269
	int			error;

3270
	args->type = XFS_ALLOCTYPE_START_BNO;
3271
	args->total = ap->total;
3272

3273 3274 3275
	startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno);
	if (startag == NULLAGNUMBER)
		startag = ag = 0;
3276

3277
	while (*blen < args->maxlen) {
3278 3279 3280 3281
		error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
						     &notinit);
		if (error)
			return error;
3282

3283 3284 3285 3286 3287
		if (++ag == mp->m_sb.sb_agcount)
			ag = 0;
		if (ag == startag)
			break;
	}
3288

3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327
	xfs_bmap_select_minlen(ap, args, blen, notinit);
	return 0;
}

STATIC int
xfs_bmap_btalloc_filestreams(
	struct xfs_bmalloca	*ap,
	struct xfs_alloc_arg	*args,
	xfs_extlen_t		*blen)
{
	struct xfs_mount	*mp = ap->ip->i_mount;
	xfs_agnumber_t		ag;
	int			notinit = 0;
	int			error;

	args->type = XFS_ALLOCTYPE_NEAR_BNO;
	args->total = ap->total;

	ag = XFS_FSB_TO_AGNO(mp, args->fsbno);
	if (ag == NULLAGNUMBER)
		ag = 0;

	error = xfs_bmap_longest_free_extent(args->tp, ag, blen, &notinit);
	if (error)
		return error;

	if (*blen < args->maxlen) {
		error = xfs_filestream_new_ag(ap, &ag);
		if (error)
			return error;

		error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
						     &notinit);
		if (error)
			return error;

	}

	xfs_bmap_select_minlen(ap, args, blen, notinit);
3328 3329

	/*
3330 3331
	 * Set the failure fallback case to look in the selected AG as stream
	 * may have moved.
3332
	 */
3333
	ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0);
3334 3335 3336
	return 0;
}

3337 3338 3339 3340 3341 3342
/* Update all inode and quota accounting for the allocation we just did. */
static void
xfs_bmap_btalloc_accounting(
	struct xfs_bmalloca	*ap,
	struct xfs_alloc_arg	*args)
{
3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
	if (ap->flags & XFS_BMAPI_COWFORK) {
		/*
		 * COW fork blocks are in-core only and thus are treated as
		 * in-core quota reservation (like delalloc blocks) even when
		 * converted to real blocks. The quota reservation is not
		 * accounted to disk until blocks are remapped to the data
		 * fork. So if these blocks were previously delalloc, we
		 * already have quota reservation and there's nothing to do
		 * yet.
		 */
		if (ap->wasdel)
			return;

		/*
		 * Otherwise, we've allocated blocks in a hole. The transaction
		 * has acquired in-core quota reservation for this extent.
		 * Rather than account these as real blocks, however, we reduce
		 * the transaction quota reservation based on the allocation.
		 * This essentially transfers the transaction quota reservation
		 * to that of a delalloc extent.
		 */
		ap->ip->i_delayed_blks += args->len;
		xfs_trans_mod_dquot_byino(ap->tp, ap->ip, XFS_TRANS_DQ_RES_BLKS,
				-(long)args->len);
		return;
	}

	/* data/attr fork only */
	ap->ip->i_d.di_nblocks += args->len;
3372 3373 3374 3375 3376 3377 3378 3379
	xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
	if (ap->wasdel)
		ap->ip->i_delayed_blks -= args->len;
	xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
		ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : XFS_TRANS_DQ_BCOUNT,
		args->len);
}

3380 3381
STATIC int
xfs_bmap_btalloc(
3382
	struct xfs_bmalloca	*ap)	/* bmap alloc argument struct */
3383
{
3384 3385
	xfs_mount_t	*mp;		/* mount point structure */
	xfs_alloctype_t	atype = 0;	/* type for allocation routines */
3386
	xfs_extlen_t	align = 0;	/* minimum allocation alignment */
3387 3388 3389
	xfs_agnumber_t	fb_agno;	/* ag number of ap->firstblock */
	xfs_agnumber_t	ag;
	xfs_alloc_arg_t	args;
3390 3391
	xfs_fileoff_t	orig_offset;
	xfs_extlen_t	orig_length;
3392 3393 3394 3395 3396 3397
	xfs_extlen_t	blen;
	xfs_extlen_t	nextminlen = 0;
	int		nullfb;		/* true if ap->firstblock isn't set */
	int		isaligned;
	int		tryagain;
	int		error;
3398
	int		stripe_align;
3399

3400
	ASSERT(ap->length);
3401 3402
	orig_offset = ap->offset;
	orig_length = ap->length;
3403

3404
	mp = ap->ip->i_mount;
3405 3406 3407 3408 3409 3410 3411 3412

	/* stripe alignment for allocation is determined by mount parameters */
	stripe_align = 0;
	if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC))
		stripe_align = mp->m_swidth;
	else if (mp->m_dalign)
		stripe_align = mp->m_dalign;

3413 3414 3415
	if (ap->flags & XFS_BMAPI_COWFORK)
		align = xfs_get_cowextsz_hint(ap->ip);
	else if (xfs_alloc_is_userdata(ap->datatype))
3416
		align = xfs_get_extsz_hint(ap->ip);
3417
	if (align) {
3418 3419 3420 3421 3422
		error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
						align, 0, ap->eof, 0, ap->conv,
						&ap->offset, &ap->length);
		ASSERT(!error);
		ASSERT(ap->length);
3423
	}
3424 3425


3426 3427 3428
	nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
	fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
							ap->tp->t_firstblock);
3429
	if (nullfb) {
3430 3431
		if (xfs_alloc_is_userdata(ap->datatype) &&
		    xfs_inode_is_filestream(ap->ip)) {
3432 3433 3434 3435 3436 3437 3438
			ag = xfs_filestream_lookup_ag(ap->ip);
			ag = (ag != NULLAGNUMBER) ? ag : 0;
			ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0);
		} else {
			ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
		}
	} else
3439
		ap->blkno = ap->tp->t_firstblock;
3440

3441
	xfs_bmap_adjacent(ap);
3442

3443 3444 3445 3446 3447 3448 3449
	/*
	 * If allowed, use ap->blkno; otherwise must use firstblock since
	 * it's in the right allocation group.
	 */
	if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno)
		;
	else
3450
		ap->blkno = ap->tp->t_firstblock;
3451 3452 3453 3454 3455 3456 3457 3458
	/*
	 * Normal allocation, done through xfs_alloc_vextent.
	 */
	tryagain = isaligned = 0;
	memset(&args, 0, sizeof(args));
	args.tp = ap->tp;
	args.mp = mp;
	args.fsbno = ap->blkno;
3459
	xfs_rmap_skip_owner_update(&args.oinfo);
3460

3461
	/* Trim the allocation back to the maximum an AG can fit. */
Dave Chinner's avatar
Dave Chinner committed
3462
	args.maxlen = min(ap->length, mp->m_ag_max_usable);
3463 3464
	blen = 0;
	if (nullfb) {
3465 3466 3467 3468 3469
		/*
		 * Search for an allocation group with a single extent large
		 * enough for the request.  If one isn't found, then adjust
		 * the minimum allocation size to the largest space found.
		 */
3470 3471
		if (xfs_alloc_is_userdata(ap->datatype) &&
		    xfs_inode_is_filestream(ap->ip))
3472 3473 3474
			error = xfs_bmap_btalloc_filestreams(ap, &args, &blen);
		else
			error = xfs_bmap_btalloc_nullfb(ap, &args, &blen);
3475 3476
		if (error)
			return error;
3477
	} else if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3478 3479 3480 3481 3482 3483 3484 3485 3486
		if (xfs_inode_is_filestream(ap->ip))
			args.type = XFS_ALLOCTYPE_FIRST_AG;
		else
			args.type = XFS_ALLOCTYPE_START_BNO;
		args.total = args.minlen = ap->minlen;
	} else {
		args.type = XFS_ALLOCTYPE_NEAR_BNO;
		args.total = ap->total;
		args.minlen = ap->minlen;
3487
	}
3488
	/* apply extent size hints if obtained earlier */
3489
	if (align) {
3490
		args.prod = align;
3491 3492 3493
		div_u64_rem(ap->offset, args.prod, &args.mod);
		if (args.mod)
			args.mod = args.prod - args.mod;
3494
	} else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) {
3495 3496 3497
		args.prod = 1;
		args.mod = 0;
	} else {
3498
		args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog;
3499 3500 3501
		div_u64_rem(ap->offset, args.prod, &args.mod);
		if (args.mod)
			args.mod = args.prod - args.mod;
3502
	}
3503
	/*
3504 3505 3506 3507 3508 3509 3510
	 * If we are not low on available data blocks, and the
	 * underlying logical volume manager is a stripe, and
	 * the file offset is zero then try to allocate data
	 * blocks on stripe unit boundary.
	 * NOTE: ap->aeof is only set if the allocation length
	 * is >= the stripe unit and the allocation offset is
	 * at the end of file.
3511
	 */
3512
	if (!(ap->tp->t_flags & XFS_TRANS_LOWMODE) && ap->aeof) {
3513
		if (!ap->offset) {
3514
			args.alignment = stripe_align;
3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538
			atype = args.type;
			isaligned = 1;
			/*
			 * Adjust for alignment
			 */
			if (blen > args.alignment && blen <= args.maxlen)
				args.minlen = blen - args.alignment;
			args.minalignslop = 0;
		} else {
			/*
			 * First try an exact bno allocation.
			 * If it fails then do a near or start bno
			 * allocation with alignment turned on.
			 */
			atype = args.type;
			tryagain = 1;
			args.type = XFS_ALLOCTYPE_THIS_BNO;
			args.alignment = 1;
			/*
			 * Compute the minlen+alignment for the
			 * next case.  Set slop so that the value
			 * of minlen+alignment+slop doesn't go up
			 * between the calls.
			 */
3539 3540
			if (blen > stripe_align && blen <= args.maxlen)
				nextminlen = blen - stripe_align;
3541 3542
			else
				nextminlen = args.minlen;
3543
			if (nextminlen + stripe_align > args.minlen + 1)
3544
				args.minalignslop =
3545
					nextminlen + stripe_align -
3546 3547 3548
					args.minlen - 1;
			else
				args.minalignslop = 0;
3549 3550
		}
	} else {
3551 3552
		args.alignment = 1;
		args.minalignslop = 0;
3553
	}
3554 3555
	args.minleft = ap->minleft;
	args.wasdel = ap->wasdel;
3556
	args.resv = XFS_AG_RESV_NONE;
3557 3558
	args.datatype = ap->datatype;
	if (ap->datatype & XFS_ALLOC_USERDATA_ZERO)
3559 3560 3561 3562
		args.ip = ap->ip;

	error = xfs_alloc_vextent(&args);
	if (error)
3563
		return error;
3564

3565 3566 3567 3568 3569 3570 3571
	if (tryagain && args.fsbno == NULLFSBLOCK) {
		/*
		 * Exact allocation failed. Now try with alignment
		 * turned on.
		 */
		args.type = atype;
		args.fsbno = ap->blkno;
3572
		args.alignment = stripe_align;
3573 3574 3575 3576 3577
		args.minlen = nextminlen;
		args.minalignslop = 0;
		isaligned = 1;
		if ((error = xfs_alloc_vextent(&args)))
			return error;
3578
	}
3579 3580 3581 3582 3583 3584 3585 3586 3587
	if (isaligned && args.fsbno == NULLFSBLOCK) {
		/*
		 * allocation failed, so turn off alignment and
		 * try again.
		 */
		args.type = atype;
		args.fsbno = ap->blkno;
		args.alignment = 0;
		if ((error = xfs_alloc_vextent(&args)))
3588 3589
			return error;
	}
3590 3591 3592 3593 3594 3595 3596
	if (args.fsbno == NULLFSBLOCK && nullfb &&
	    args.minlen > ap->minlen) {
		args.minlen = ap->minlen;
		args.type = XFS_ALLOCTYPE_START_BNO;
		args.fsbno = ap->blkno;
		if ((error = xfs_alloc_vextent(&args)))
			return error;
3597
	}
3598 3599 3600 3601 3602 3603
	if (args.fsbno == NULLFSBLOCK && nullfb) {
		args.fsbno = 0;
		args.type = XFS_ALLOCTYPE_FIRST_AG;
		args.total = ap->minlen;
		if ((error = xfs_alloc_vextent(&args)))
			return error;
3604
		ap->tp->t_flags |= XFS_TRANS_LOWMODE;
3605 3606 3607 3608 3609 3610
	}
	if (args.fsbno != NULLFSBLOCK) {
		/*
		 * check the allocation happened at the same or higher AG than
		 * the first block that was allocated.
		 */
3611 3612
		ASSERT(ap->tp->t_firstblock == NULLFSBLOCK ||
		       XFS_FSB_TO_AGNO(mp, ap->tp->t_firstblock) <=
3613
		       XFS_FSB_TO_AGNO(mp, args.fsbno));
3614

3615
		ap->blkno = args.fsbno;
3616 3617
		if (ap->tp->t_firstblock == NULLFSBLOCK)
			ap->tp->t_firstblock = args.fsbno;
3618
		ASSERT(nullfb || fb_agno <= args.agno);
3619
		ap->length = args.len;
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635
		/*
		 * If the extent size hint is active, we tried to round the
		 * caller's allocation request offset down to extsz and the
		 * length up to another extsz boundary.  If we found a free
		 * extent we mapped it in starting at this new offset.  If the
		 * newly mapped space isn't long enough to cover any of the
		 * range of offsets that was originally requested, move the
		 * mapping up so that we can fill as much of the caller's
		 * original request as possible.  Free space is apparently
		 * very fragmented so we're unlikely to be able to satisfy the
		 * hints anyway.
		 */
		if (ap->length <= orig_length)
			ap->offset = orig_offset;
		else if (ap->offset + ap->length < orig_offset + orig_length)
			ap->offset = orig_offset + orig_length - ap->length;
3636
		xfs_bmap_btalloc_accounting(ap, &args);
3637 3638 3639 3640 3641 3642
	} else {
		ap->blkno = NULLFSBLOCK;
		ap->length = 0;
	}
	return 0;
}
3643

3644 3645 3646 3647 3648 3649
/*
 * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
 * It figures out where to ask the underlying allocator to put the new extent.
 */
STATIC int
xfs_bmap_alloc(
3650
	struct xfs_bmalloca	*ap)	/* bmap alloc argument struct */
3651
{
3652 3653
	if (XFS_IS_REALTIME_INODE(ap->ip) &&
	    xfs_alloc_is_userdata(ap->datatype))
3654 3655 3656
		return xfs_bmap_rtalloc(ap);
	return xfs_bmap_btalloc(ap);
}
3657

Darrick J. Wong's avatar
Darrick J. Wong committed
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690
/* Trim extent to fit a logical block range. */
void
xfs_trim_extent(
	struct xfs_bmbt_irec	*irec,
	xfs_fileoff_t		bno,
	xfs_filblks_t		len)
{
	xfs_fileoff_t		distance;
	xfs_fileoff_t		end = bno + len;

	if (irec->br_startoff + irec->br_blockcount <= bno ||
	    irec->br_startoff >= end) {
		irec->br_blockcount = 0;
		return;
	}

	if (irec->br_startoff < bno) {
		distance = bno - irec->br_startoff;
		if (isnullstartblock(irec->br_startblock))
			irec->br_startblock = DELAYSTARTBLOCK;
		if (irec->br_startblock != DELAYSTARTBLOCK &&
		    irec->br_startblock != HOLESTARTBLOCK)
			irec->br_startblock += distance;
		irec->br_startoff += distance;
		irec->br_blockcount -= distance;
	}

	if (end < irec->br_startoff + irec->br_blockcount) {
		distance = irec->br_startoff + irec->br_blockcount - end;
		irec->br_blockcount -= distance;
	}
}

3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
/* trim extent to within eof */
void
xfs_trim_extent_eof(
	struct xfs_bmbt_irec	*irec,
	struct xfs_inode	*ip)

{
	xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount,
					      i_size_read(VFS_I(ip))));
}

3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722
/*
 * Trim the returned map to the required bounds
 */
STATIC void
xfs_bmapi_trim_map(
	struct xfs_bmbt_irec	*mval,
	struct xfs_bmbt_irec	*got,
	xfs_fileoff_t		*bno,
	xfs_filblks_t		len,
	xfs_fileoff_t		obno,
	xfs_fileoff_t		end,
	int			n,
	int			flags)
{
	if ((flags & XFS_BMAPI_ENTIRE) ||
	    got->br_startoff + got->br_blockcount <= obno) {
		*mval = *got;
		if (isnullstartblock(got->br_startblock))
			mval->br_startblock = DELAYSTARTBLOCK;
		return;
	}
3723

3724 3725 3726 3727 3728 3729 3730 3731 3732 3733
	if (obno > *bno)
		*bno = obno;
	ASSERT((*bno >= obno) || (n == 0));
	ASSERT(*bno < end);
	mval->br_startoff = *bno;
	if (isnullstartblock(got->br_startblock))
		mval->br_startblock = DELAYSTARTBLOCK;
	else
		mval->br_startblock = got->br_startblock +
					(*bno - got->br_startoff);
3734
	/*
3735 3736 3737 3738 3739
	 * Return the minimum of what we got and what we asked for for
	 * the length.  We can use the len variable here because it is
	 * modified below and we could have been there before coming
	 * here if the first part of the allocation didn't overlap what
	 * was asked for.
3740
	 */
3741 3742 3743 3744 3745
	mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno,
			got->br_blockcount - (*bno - got->br_startoff));
	mval->br_state = got->br_state;
	ASSERT(mval->br_blockcount <= len);
	return;
3746 3747
}

3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759
/*
 * Update and validate the extent map to return
 */
STATIC void
xfs_bmapi_update_map(
	struct xfs_bmbt_irec	**map,
	xfs_fileoff_t		*bno,
	xfs_filblks_t		*len,
	xfs_fileoff_t		obno,
	xfs_fileoff_t		end,
	int			*n,
	int			flags)
3760
{
3761
	xfs_bmbt_irec_t	*mval = *map;
3762

3763 3764 3765 3766
	ASSERT((flags & XFS_BMAPI_ENTIRE) ||
	       ((mval->br_startoff + mval->br_blockcount) <= end));
	ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) ||
	       (mval->br_startoff < obno));
3767

3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781
	*bno = mval->br_startoff + mval->br_blockcount;
	*len = end - *bno;
	if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) {
		/* update previous map with new information */
		ASSERT(mval->br_startblock == mval[-1].br_startblock);
		ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
		ASSERT(mval->br_state == mval[-1].br_state);
		mval[-1].br_blockcount = mval->br_blockcount;
		mval[-1].br_state = mval->br_state;
	} else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
		   mval[-1].br_startblock != DELAYSTARTBLOCK &&
		   mval[-1].br_startblock != HOLESTARTBLOCK &&
		   mval->br_startblock == mval[-1].br_startblock +
					  mval[-1].br_blockcount &&
3782
		   mval[-1].br_state == mval->br_state) {
3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799
		ASSERT(mval->br_startoff ==
		       mval[-1].br_startoff + mval[-1].br_blockcount);
		mval[-1].br_blockcount += mval->br_blockcount;
	} else if (*n > 0 &&
		   mval->br_startblock == DELAYSTARTBLOCK &&
		   mval[-1].br_startblock == DELAYSTARTBLOCK &&
		   mval->br_startoff ==
		   mval[-1].br_startoff + mval[-1].br_blockcount) {
		mval[-1].br_blockcount += mval->br_blockcount;
		mval[-1].br_state = mval->br_state;
	} else if (!((*n == 0) &&
		     ((mval->br_startoff + mval->br_blockcount) <=
		      obno))) {
		mval++;
		(*n)++;
	}
	*map = mval;
3800 3801 3802
}

/*
3803
 * Map file blocks to filesystem blocks without allocation.
3804 3805
 */
int
3806 3807 3808
xfs_bmapi_read(
	struct xfs_inode	*ip,
	xfs_fileoff_t		bno,
3809
	xfs_filblks_t		len,
3810 3811
	struct xfs_bmbt_irec	*mval,
	int			*nmap,
3812
	int			flags)
3813
{
3814 3815 3816 3817 3818
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp;
	struct xfs_bmbt_irec	got;
	xfs_fileoff_t		obno;
	xfs_fileoff_t		end;
3819
	struct xfs_iext_cursor	icur;
3820
	int			error;
3821
	bool			eof = false;
3822
	int			n = 0;
3823
	int			whichfork = xfs_bmapi_whichfork(flags);
3824

3825 3826
	ASSERT(*nmap >= 1);
	ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE|
3827
			   XFS_BMAPI_COWFORK)));
3828
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL));
3829

3830 3831 3832
	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
3833
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
3834
		XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
3835
		return -EFSCORRUPTED;
3836
	}
3837

3838
	if (XFS_FORCED_SHUTDOWN(mp))
3839
		return -EIO;
3840

3841
	XFS_STATS_INC(mp, xs_blk_mapr);
3842 3843

	ifp = XFS_IFORK_PTR(ip, whichfork);
3844 3845 3846 3847 3848 3849 3850 3851 3852 3853
	if (!ifp) {
		/* No CoW fork?  Return a hole. */
		if (whichfork == XFS_COW_FORK) {
			mval->br_startoff = bno;
			mval->br_startblock = HOLESTARTBLOCK;
			mval->br_blockcount = len;
			mval->br_state = XFS_EXT_NORM;
			*nmap = 1;
			return 0;
		}
3854

3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865
		/*
		 * A missing attr ifork implies that the inode says we're in
		 * extents or btree format but failed to pass the inode fork
		 * verifier while trying to load it.  Treat that as a file
		 * corruption too.
		 */
#ifdef DEBUG
		xfs_alert(mp, "%s: inode %llu missing fork %d",
				__func__, ip->i_ino, whichfork);
#endif /* DEBUG */
		return -EFSCORRUPTED;
3866 3867
	}

3868 3869 3870 3871
	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(NULL, ip, whichfork);
		if (error)
			return error;
3872 3873
	}

3874
	if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
3875
		eof = true;
3876 3877
	end = bno + len;
	obno = bno;
3878

3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
	while (bno < end && n < *nmap) {
		/* Reading past eof, act as though there's a hole up to end. */
		if (eof)
			got.br_startoff = end;
		if (got.br_startoff > bno) {
			/* Reading in a hole.  */
			mval->br_startoff = bno;
			mval->br_startblock = HOLESTARTBLOCK;
			mval->br_blockcount =
				XFS_FILBLKS_MIN(len, got.br_startoff - bno);
			mval->br_state = XFS_EXT_NORM;
			bno += mval->br_blockcount;
			len -= mval->br_blockcount;
			mval++;
			n++;
			continue;
		}
3896

3897 3898 3899 3900 3901 3902 3903 3904 3905
		/* set up the extent map to return. */
		xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
		xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);

		/* If we're done, stop now. */
		if (bno >= end || n >= *nmap)
			break;

		/* Else go on to the next record. */
3906
		if (!xfs_iext_next_extent(ifp, &icur, &got))
3907
			eof = true;
3908 3909
	}
	*nmap = n;
3910 3911 3912
	return 0;
}

3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925
/*
 * Add a delayed allocation extent to an inode. Blocks are reserved from the
 * global pool and the extent inserted into the inode in-core extent tree.
 *
 * On entry, got refers to the first extent beyond the offset of the extent to
 * allocate or eof is specified if no such extent exists. On return, got refers
 * to the extent record that was inserted to the inode fork.
 *
 * Note that the allocated extent may have been merged with contiguous extents
 * during insertion into the inode fork. Thus, got does not reflect the current
 * state of the inode fork on return. If necessary, the caller can use lastx to
 * look up the updated record in the inode fork.
 */
3926
int
3927 3928
xfs_bmapi_reserve_delalloc(
	struct xfs_inode	*ip,
3929
	int			whichfork,
3930
	xfs_fileoff_t		off,
3931
	xfs_filblks_t		len,
3932
	xfs_filblks_t		prealloc,
3933
	struct xfs_bmbt_irec	*got,
3934
	struct xfs_iext_cursor	*icur,
3935
	int			eof)
Linus Torvalds's avatar
Linus Torvalds committed
3936
{
3937
	struct xfs_mount	*mp = ip->i_mount;
3938
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
3939 3940 3941
	xfs_extlen_t		alen;
	xfs_extlen_t		indlen;
	int			error;
3942
	xfs_fileoff_t		aoff = off;
3943

3944 3945 3946 3947 3948
	/*
	 * Cap the alloc length. Keep track of prealloc so we know whether to
	 * tag the inode before we return.
	 */
	alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN);
3949 3950
	if (!eof)
		alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
3951 3952
	if (prealloc && alen >= len)
		prealloc = alen - len;
Linus Torvalds's avatar
Linus Torvalds committed
3953

3954
	/* Figure out the extent size, adjust alen */
Shan Hai's avatar
Shan Hai committed
3955
	if (whichfork == XFS_COW_FORK) {
3956
		struct xfs_bmbt_irec	prev;
Shan Hai's avatar
Shan Hai committed
3957
		xfs_extlen_t		extsz = xfs_get_cowextsz_hint(ip);
3958

3959
		if (!xfs_iext_peek_prev_extent(ifp, icur, &prev))
3960 3961
			prev.br_startoff = NULLFILEOFF;

Shan Hai's avatar
Shan Hai committed
3962
		error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof,
3963 3964 3965 3966 3967 3968 3969 3970 3971 3972
					       1, 0, &aoff, &alen);
		ASSERT(!error);
	}

	/*
	 * Make a transaction-less quota reservation for delayed allocation
	 * blocks.  This number gets adjusted later.  We return if we haven't
	 * allocated blocks already inside this loop.
	 */
	error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0,
Shan Hai's avatar
Shan Hai committed
3973
						XFS_QMOPT_RES_REGBLKS);
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983
	if (error)
		return error;

	/*
	 * Split changing sb for alen and indlen since they could be coming
	 * from different places.
	 */
	indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen);
	ASSERT(indlen > 0);

Shan Hai's avatar
Shan Hai committed
3984
	error = xfs_mod_fdblocks(mp, -((int64_t)alen), false);
3985 3986 3987
	if (error)
		goto out_unreserve_quota;

3988
	error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false);
3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
	if (error)
		goto out_unreserve_blocks;


	ip->i_delayed_blks += alen;

	got->br_startoff = aoff;
	got->br_startblock = nullstartblock(indlen);
	got->br_blockcount = alen;
	got->br_state = XFS_EXT_NORM;

4000
	xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got);
4001

4002 4003 4004 4005 4006 4007 4008 4009 4010 4011
	/*
	 * Tag the inode if blocks were preallocated. Note that COW fork
	 * preallocation can occur at the start or end of the extent, even when
	 * prealloc == 0, so we must also check the aligned offset and length.
	 */
	if (whichfork == XFS_DATA_FORK && prealloc)
		xfs_inode_set_eofblocks_tag(ip);
	if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len))
		xfs_inode_set_cowblocks_tag(ip);

4012 4013 4014
	return 0;

out_unreserve_blocks:
Shan Hai's avatar
Shan Hai committed
4015
	xfs_mod_fdblocks(mp, alen, false);
4016 4017
out_unreserve_quota:
	if (XFS_IS_QUOTA_ON(mp))
Shan Hai's avatar
Shan Hai committed
4018 4019
		xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0,
						XFS_QMOPT_RES_REGBLKS);
4020 4021 4022
	return error;
}

4023 4024
static int
xfs_bmapi_allocate(
4025 4026 4027
	struct xfs_bmalloca	*bma)
{
	struct xfs_mount	*mp = bma->ip->i_mount;
4028
	int			whichfork = xfs_bmapi_whichfork(bma->flags);
4029 4030 4031 4032 4033 4034
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(bma->ip, whichfork);
	int			tmp_logflags = 0;
	int			error;

	ASSERT(bma->length > 0);

Linus Torvalds's avatar
Linus Torvalds committed
4035
	/*
4036 4037
	 * For the wasdelay case, we could also just allocate the stuff asked
	 * for in this bmap call but that wouldn't be as good.
Linus Torvalds's avatar
Linus Torvalds committed
4038
	 */
4039 4040 4041
	if (bma->wasdel) {
		bma->length = (xfs_extlen_t)bma->got.br_blockcount;
		bma->offset = bma->got.br_startoff;
4042
		xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev);
4043 4044 4045 4046 4047
	} else {
		bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN);
		if (!bma->eof)
			bma->length = XFS_FILBLKS_MIN(bma->length,
					bma->got.br_startoff - bma->offset);
Linus Torvalds's avatar
Linus Torvalds committed
4048 4049
	}

4050
	/*
4051 4052 4053 4054
	 * Set the data type being allocated. For the data fork, the first data
	 * in the file is treated differently to all other allocations. For the
	 * attribute fork, we only need to ensure the allocated range is not on
	 * the busy list.
4055 4056
	 */
	if (!(bma->flags & XFS_BMAPI_METADATA)) {
4057 4058 4059 4060 4061 4062 4063
		bma->datatype = XFS_ALLOC_NOBUSY;
		if (whichfork == XFS_DATA_FORK) {
			if (bma->offset == 0)
				bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA;
			else
				bma->datatype |= XFS_ALLOC_USERDATA;
		}
4064
		if (bma->flags & XFS_BMAPI_ZERO)
4065
			bma->datatype |= XFS_ALLOC_USERDATA_ZERO;
4066
	}
Linus Torvalds's avatar
Linus Torvalds committed
4067

4068
	bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1;
4069

4070 4071 4072 4073 4074 4075 4076 4077 4078
	/*
	 * Only want to do the alignment at the eof if it is userdata and
	 * allocation length is larger than a stripe unit.
	 */
	if (mp->m_dalign && bma->length >= mp->m_dalign &&
	    !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) {
		error = xfs_bmap_isaeof(bma, whichfork);
		if (error)
			return error;
Linus Torvalds's avatar
Linus Torvalds committed
4079
	}
4080

4081 4082
	error = xfs_bmap_alloc(bma);
	if (error)
Linus Torvalds's avatar
Linus Torvalds committed
4083
		return error;
4084 4085

	if (bma->blkno == NULLFSBLOCK)
Linus Torvalds's avatar
Linus Torvalds committed
4086
		return 0;
4087
	if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur)
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
		bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
	/*
	 * Bump the number of extents we've allocated
	 * in this call.
	 */
	bma->nallocs++;

	if (bma->cur)
		bma->cur->bc_private.b.flags =
			bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;

	bma->got.br_startoff = bma->offset;
	bma->got.br_startblock = bma->blkno;
	bma->got.br_blockcount = bma->length;
	bma->got.br_state = XFS_EXT_NORM;
4103

Linus Torvalds's avatar
Linus Torvalds committed
4104
	/*
4105 4106 4107 4108 4109 4110 4111
	 * In the data fork, a wasdelay extent has been initialized, so
	 * shouldn't be flagged as unwritten.
	 *
	 * For the cow fork, however, we convert delalloc reservations
	 * (extents allocated for speculative preallocation) to
	 * allocated unwritten extents, and only convert the unwritten
	 * extents to real extents when we're about to write the data.
Linus Torvalds's avatar
Linus Torvalds committed
4112
	 */
4113 4114
	if ((!bma->wasdel || (bma->flags & XFS_BMAPI_COWFORK)) &&
	    (bma->flags & XFS_BMAPI_PREALLOC) &&
4115 4116 4117 4118
	    xfs_sb_version_hasextflgbit(&mp->m_sb))
		bma->got.br_state = XFS_EXT_UNWRITTEN;

	if (bma->wasdel)
4119
		error = xfs_bmap_add_extent_delay_real(bma, whichfork);
4120
	else
4121
		error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip,
4122
				whichfork, &bma->icur, &bma->cur, &bma->got,
4123
				&bma->logflags, bma->flags);
4124 4125 4126 4127 4128 4129 4130 4131 4132 4133

	bma->logflags |= tmp_logflags;
	if (error)
		return error;

	/*
	 * Update our extent pointer, given that xfs_bmap_add_extent_delay_real
	 * or xfs_bmap_add_extent_hole_real might have merged it into one of
	 * the neighbouring ones.
	 */
4134
	xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150

	ASSERT(bma->got.br_startoff <= bma->offset);
	ASSERT(bma->got.br_startoff + bma->got.br_blockcount >=
	       bma->offset + bma->length);
	ASSERT(bma->got.br_state == XFS_EXT_NORM ||
	       bma->got.br_state == XFS_EXT_UNWRITTEN);
	return 0;
}

STATIC int
xfs_bmapi_convert_unwritten(
	struct xfs_bmalloca	*bma,
	struct xfs_bmbt_irec	*mval,
	xfs_filblks_t		len,
	int			flags)
{
4151
	int			whichfork = xfs_bmapi_whichfork(flags);
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(bma->ip, whichfork);
	int			tmp_logflags = 0;
	int			error;

	/* check if we need to do unwritten->real conversion */
	if (mval->br_state == XFS_EXT_UNWRITTEN &&
	    (flags & XFS_BMAPI_PREALLOC))
		return 0;

	/* check if we need to do real->unwritten conversion */
	if (mval->br_state == XFS_EXT_NORM &&
	    (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) !=
			(XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT))
		return 0;

	/*
	 * Modify (by adding) the state flag, if writing.
	 */
	ASSERT(mval->br_blockcount <= len);
	if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) {
		bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
					bma->ip, whichfork);
Linus Torvalds's avatar
Linus Torvalds committed
4174
	}
4175 4176
	mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
				? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
4177

4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188
	/*
	 * Before insertion into the bmbt, zero the range being converted
	 * if required.
	 */
	if (flags & XFS_BMAPI_ZERO) {
		error = xfs_zero_extent(bma->ip, mval->br_startblock,
					mval->br_blockcount);
		if (error)
			return error;
	}

4189
	error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork,
4190
			&bma->icur, &bma->cur, mval, &tmp_logflags);
4191 4192 4193 4194 4195 4196 4197
	/*
	 * Log the inode core unconditionally in the unwritten extent conversion
	 * path because the conversion might not have done so (e.g., if the
	 * extent count hasn't changed). We need to make sure the inode is dirty
	 * in the transaction for the sake of fsync(), even if nothing has
	 * changed, because fsync() will not force the log for this transaction
	 * unless it sees the inode pinned.
4198 4199 4200
	 *
	 * Note: If we're only converting cow fork extents, there aren't
	 * any on-disk updates to make, so we don't need to log anything.
4201
	 */
4202 4203
	if (whichfork != XFS_COW_FORK)
		bma->logflags |= tmp_logflags | XFS_ILOG_CORE;
4204 4205 4206 4207 4208 4209 4210 4211
	if (error)
		return error;

	/*
	 * Update our extent pointer, given that
	 * xfs_bmap_add_extent_unwritten_real might have merged it into one
	 * of the neighbouring ones.
	 */
4212
	xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4213 4214 4215 4216 4217 4218

	/*
	 * We may have combined previously unwritten space with written space,
	 * so generate another request.
	 */
	if (mval->br_blockcount < len)
4219
		return -EAGAIN;
4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237
	return 0;
}

/*
 * Map file blocks to filesystem blocks, and allocate blocks or convert the
 * extent state if necessary.  Details behaviour is controlled by the flags
 * parameter.  Only allocates blocks from a single allocation group, to avoid
 * locking problems.
 */
int
xfs_bmapi_write(
	struct xfs_trans	*tp,		/* transaction pointer */
	struct xfs_inode	*ip,		/* incore inode */
	xfs_fileoff_t		bno,		/* starting file offs. mapped */
	xfs_filblks_t		len,		/* length to map in file */
	int			flags,		/* XFS_BMAPI_... */
	xfs_extlen_t		total,		/* total blocks needed */
	struct xfs_bmbt_irec	*mval,		/* output: map values */
4238
	int			*nmap)		/* i/o: mval size/count */
4239 4240 4241
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp;
4242
	struct xfs_bmalloca	bma = { NULL };	/* args for xfs_bmap_alloc */
4243
	xfs_fileoff_t		end;		/* end of mapped file region */
4244
	bool			eof = false;	/* after the end of extents */
4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262
	int			error;		/* error return */
	int			n;		/* current extent index */
	xfs_fileoff_t		obno;		/* old block number (offset) */
	int			whichfork;	/* data or attr fork */

#ifdef DEBUG
	xfs_fileoff_t		orig_bno;	/* original block number value */
	int			orig_flags;	/* original flags arg value */
	xfs_filblks_t		orig_len;	/* original value of len arg */
	struct xfs_bmbt_irec	*orig_mval;	/* original value of mval */
	int			orig_nmap;	/* original value of *nmap */

	orig_bno = bno;
	orig_len = len;
	orig_flags = flags;
	orig_mval = mval;
	orig_nmap = *nmap;
#endif
4263
	whichfork = xfs_bmapi_whichfork(flags);
4264 4265 4266

	ASSERT(*nmap >= 1);
	ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4267 4268 4269
	ASSERT(tp != NULL ||
	       (flags & (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)) ==
			(XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK));
4270
	ASSERT(len > 0);
4271
	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL);
4272
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4273
	ASSERT(!(flags & XFS_BMAPI_REMAP));
4274

4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286
	/* zeroing is for currently only for data extents, not metadata */
	ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) !=
			(XFS_BMAPI_METADATA | XFS_BMAPI_ZERO));
	/*
	 * we can allocate unwritten extents or pre-zero allocated blocks,
	 * but it makes no sense to do both at once. This would result in
	 * zeroing the unwritten extent twice, but it still being an
	 * unwritten extent....
	 */
	ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
			(XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));

4287 4288
	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
4289
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
4290
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
4291
		XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
4292
		return -EFSCORRUPTED;
4293 4294
	}

4295
	if (XFS_FORCED_SHUTDOWN(mp))
4296
		return -EIO;
4297 4298 4299

	ifp = XFS_IFORK_PTR(ip, whichfork);

4300
	XFS_STATS_INC(mp, xs_blk_mapw);
4301

4302
	if (!tp || tp->t_firstblock == NULLFSBLOCK) {
4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320
		if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE)
			bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1;
		else
			bma.minleft = 1;
	} else {
		bma.minleft = 0;
	}

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			goto error0;
	}

	n = 0;
	end = bno + len;
	obno = bno;

4321
	if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got))
4322
		eof = true;
4323
	if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4324
		bma.prev.br_startoff = NULLFILEOFF;
4325 4326 4327
	bma.tp = tp;
	bma.ip = ip;
	bma.total = total;
4328
	bma.datatype = 0;
4329 4330

	while (bno < end && n < *nmap) {
4331 4332
		bool			need_alloc = false, wasdelay = false;

4333
		/* in hole or beyond EOF? */
4334
		if (eof || bma.got.br_startoff > bno) {
4335 4336 4337 4338 4339 4340 4341 4342
			/*
			 * CoW fork conversions should /never/ hit EOF or
			 * holes.  There should always be something for us
			 * to work on.
			 */
			ASSERT(!((flags & XFS_BMAPI_CONVERT) &&
			         (flags & XFS_BMAPI_COWFORK)));

4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362
			if (flags & XFS_BMAPI_DELALLOC) {
				/*
				 * For the COW fork we can reasonably get a
				 * request for converting an extent that races
				 * with other threads already having converted
				 * part of it, as there converting COW to
				 * regular blocks is not protected using the
				 * IOLOCK.
				 */
				ASSERT(flags & XFS_BMAPI_COWFORK);
				if (!(flags & XFS_BMAPI_COWFORK)) {
					error = -EIO;
					goto error0;
				}

				if (eof || bno >= end)
					break;
			} else {
				need_alloc = true;
			}
4363 4364
		} else if (isnullstartblock(bma.got.br_startblock)) {
			wasdelay = true;
4365
		}
4366

Linus Torvalds's avatar
Linus Torvalds committed
4367
		/*
4368 4369
		 * First, deal with the hole before the allocated space
		 * that we found, if any.
Linus Torvalds's avatar
Linus Torvalds committed
4370
		 */
4371 4372
		if ((need_alloc || wasdelay) &&
		    !(flags & XFS_BMAPI_CONVERT_ONLY)) {
4373 4374 4375 4376 4377 4378
			bma.eof = eof;
			bma.conv = !!(flags & XFS_BMAPI_CONVERT);
			bma.wasdel = wasdelay;
			bma.offset = bno;
			bma.flags = flags;

Linus Torvalds's avatar
Linus Torvalds committed
4379
			/*
4380 4381 4382 4383 4384
			 * There's a 32/64 bit type mismatch between the
			 * allocation length request (which can be 64 bits in
			 * length) and the bma length request, which is
			 * xfs_extlen_t and therefore 32 bits. Hence we have to
			 * check for 32-bit overflows and handle them here.
Linus Torvalds's avatar
Linus Torvalds committed
4385
			 */
4386 4387 4388 4389 4390 4391 4392 4393
			if (len > (xfs_filblks_t)MAXEXTLEN)
				bma.length = MAXEXTLEN;
			else
				bma.length = len;

			ASSERT(len > 0);
			ASSERT(bma.length > 0);
			error = xfs_bmapi_allocate(&bma);
Linus Torvalds's avatar
Linus Torvalds committed
4394 4395
			if (error)
				goto error0;
4396 4397
			if (bma.blkno == NULLFSBLOCK)
				break;
4398 4399 4400 4401 4402 4403

			/*
			 * If this is a CoW allocation, record the data in
			 * the refcount btree for orphan recovery.
			 */
			if (whichfork == XFS_COW_FORK) {
4404 4405
				error = xfs_refcount_alloc_cow_extent(tp,
						bma.blkno, bma.length);
4406 4407 4408
				if (error)
					goto error0;
			}
Linus Torvalds's avatar
Linus Torvalds committed
4409
		}
4410 4411 4412 4413 4414 4415 4416

		/* Deal with the allocated space we found.  */
		xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno,
							end, n, flags);

		/* Execute unwritten extent conversion if necessary */
		error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
4417
		if (error == -EAGAIN)
4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434
			continue;
		if (error)
			goto error0;

		/* update the extent map to return */
		xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);

		/*
		 * If we're done, stop now.  Stop when we've allocated
		 * XFS_BMAP_MAX_NMAP extents no matter what.  Otherwise
		 * the transaction may get too big.
		 */
		if (bno >= end || n >= *nmap || bma.nallocs >= *nmap)
			break;

		/* Else go on to the next record. */
		bma.prev = bma.got;
4435
		if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got))
4436
			eof = true;
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477
	}
	*nmap = n;

	/*
	 * Transform from btree to extents, give it cur.
	 */
	if (xfs_bmap_wants_extents(ip, whichfork)) {
		int		tmp_logflags = 0;

		ASSERT(bma.cur);
		error = xfs_bmap_btree_to_extents(tp, ip, bma.cur,
			&tmp_logflags, whichfork);
		bma.logflags |= tmp_logflags;
		if (error)
			goto error0;
	}

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE ||
	       XFS_IFORK_NEXTENTS(ip, whichfork) >
		XFS_IFORK_MAXEXT(ip, whichfork));
	error = 0;
error0:
	/*
	 * Log everything.  Do this after conversion, there's no point in
	 * logging the extent records if we've converted to btree format.
	 */
	if ((bma.logflags & xfs_ilog_fext(whichfork)) &&
	    XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
		bma.logflags &= ~xfs_ilog_fext(whichfork);
	else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) &&
		 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
		bma.logflags &= ~xfs_ilog_fbroot(whichfork);
	/*
	 * Log whatever the flags say, even if error.  Otherwise we might miss
	 * detecting a case where the data is changed, there's an error,
	 * and it's not logged so we don't shutdown when we should.
	 */
	if (bma.logflags)
		xfs_trans_log_inode(tp, ip, bma.logflags);

	if (bma.cur) {
4478
		xfs_btree_del_cursor(bma.cur, error);
4479 4480 4481 4482 4483 4484
	}
	if (!error)
		xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
			orig_nmap, *nmap);
	return error;
}
4485

4486
int
4487 4488 4489 4490 4491 4492
xfs_bmapi_remap(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	xfs_fileoff_t		bno,
	xfs_filblks_t		len,
	xfs_fsblock_t		startblock,
4493
	int			flags)
4494 4495
{
	struct xfs_mount	*mp = ip->i_mount;
4496
	struct xfs_ifork	*ifp;
4497 4498
	struct xfs_btree_cur	*cur = NULL;
	struct xfs_bmbt_irec	got;
4499
	struct xfs_iext_cursor	icur;
4500
	int			whichfork = xfs_bmapi_whichfork(flags);
4501 4502
	int			logflags = 0, error;

4503
	ifp = XFS_IFORK_PTR(ip, whichfork);
4504 4505 4506
	ASSERT(len > 0);
	ASSERT(len <= (xfs_filblks_t)MAXEXTLEN);
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4507 4508 4509 4510
	ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
			   XFS_BMAPI_NORMAP)));
	ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
			(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
4511 4512

	if (unlikely(XFS_TEST_ERROR(
4513 4514
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
4515
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
4516 4517 4518 4519 4520 4521 4522 4523
		XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp);
		return -EFSCORRUPTED;
	}

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4524
		error = xfs_iread_extents(tp, ip, whichfork);
4525 4526 4527 4528
		if (error)
			return error;
	}

4529
	if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
4530 4531 4532 4533 4534
		/* make sure we only reflink into a hole. */
		ASSERT(got.br_startoff > bno);
		ASSERT(got.br_startoff - bno >= len);
	}

4535 4536
	ip->i_d.di_nblocks += len;
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4537 4538

	if (ifp->if_flags & XFS_IFBROOT) {
4539
		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
4540 4541 4542 4543 4544 4545
		cur->bc_private.b.flags = 0;
	}

	got.br_startoff = bno;
	got.br_startblock = startblock;
	got.br_blockcount = len;
4546 4547 4548 4549
	if (flags & XFS_BMAPI_PREALLOC)
		got.br_state = XFS_EXT_UNWRITTEN;
	else
		got.br_state = XFS_EXT_NORM;
4550

4551
	error = xfs_bmap_add_extent_hole_real(tp, ip, whichfork, &icur,
4552
			&cur, &got, &logflags, flags);
4553 4554 4555
	if (error)
		goto error0;

4556
	if (xfs_bmap_wants_extents(ip, whichfork)) {
4557 4558 4559
		int		tmp_logflags = 0;

		error = xfs_bmap_btree_to_extents(tp, ip, cur,
4560
			&tmp_logflags, whichfork);
4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571
		logflags |= tmp_logflags;
	}

error0:
	if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS)
		logflags &= ~XFS_ILOG_DEXT;
	else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE)
		logflags &= ~XFS_ILOG_DBROOT;

	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
4572 4573
	if (cur)
		xfs_btree_del_cursor(cur, error);
4574 4575 4576
	return error;
}

4577 4578 4579 4580 4581 4582 4583
/*
 * When a delalloc extent is split (e.g., due to a hole punch), the original
 * indlen reservation must be shared across the two new extents that are left
 * behind.
 *
 * Given the original reservation and the worst case indlen for the two new
 * extents (as calculated by xfs_bmap_worst_indlen()), split the original
4584 4585 4586 4587
 * reservation fairly across the two new extents. If necessary, steal available
 * blocks from a deleted extent to make up a reservation deficiency (e.g., if
 * ores == 1). The number of stolen blocks is returned. The availability and
 * subsequent accounting of stolen blocks is the responsibility of the caller.
4588
 */
4589
static xfs_filblks_t
4590 4591 4592
xfs_bmap_split_indlen(
	xfs_filblks_t			ores,		/* original res. */
	xfs_filblks_t			*indlen1,	/* ext1 worst indlen */
4593 4594
	xfs_filblks_t			*indlen2,	/* ext2 worst indlen */
	xfs_filblks_t			avail)		/* stealable blocks */
4595 4596 4597 4598
{
	xfs_filblks_t			len1 = *indlen1;
	xfs_filblks_t			len2 = *indlen2;
	xfs_filblks_t			nres = len1 + len2; /* new total res. */
4599
	xfs_filblks_t			stolen = 0;
4600
	xfs_filblks_t			resfactor;
4601 4602 4603 4604 4605

	/*
	 * Steal as many blocks as we can to try and satisfy the worst case
	 * indlen for both new extents.
	 */
4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629
	if (ores < nres && avail)
		stolen = XFS_FILBLKS_MIN(nres - ores, avail);
	ores += stolen;

	 /* nothing else to do if we've satisfied the new reservation */
	if (ores >= nres)
		return stolen;

	/*
	 * We can't meet the total required reservation for the two extents.
	 * Calculate the percent of the overall shortage between both extents
	 * and apply this percentage to each of the requested indlen values.
	 * This distributes the shortage fairly and reduces the chances that one
	 * of the two extents is left with nothing when extents are repeatedly
	 * split.
	 */
	resfactor = (ores * 100);
	do_div(resfactor, nres);
	len1 *= resfactor;
	do_div(len1, 100);
	len2 *= resfactor;
	do_div(len2, 100);
	ASSERT(len1 + len2 <= ores);
	ASSERT(len1 < *indlen1 && len2 < *indlen2);
4630 4631

	/*
4632 4633 4634 4635
	 * Hand out the remainder to each extent. If one of the two reservations
	 * is zero, we want to make sure that one gets a block first. The loop
	 * below starts with len1, so hand len2 a block right off the bat if it
	 * is zero.
4636
	 */
4637 4638 4639 4640 4641 4642 4643 4644 4645 4646
	ores -= (len1 + len2);
	ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores);
	if (ores && !len2 && *indlen2) {
		len2++;
		ores--;
	}
	while (ores) {
		if (len1 < *indlen1) {
			len1++;
			ores--;
4647
		}
4648
		if (!ores)
4649
			break;
4650 4651 4652
		if (len2 < *indlen2) {
			len2++;
			ores--;
4653 4654 4655 4656 4657
		}
	}

	*indlen1 = len1;
	*indlen2 = len2;
4658 4659

	return stolen;
4660 4661
}

4662 4663 4664 4665
int
xfs_bmap_del_extent_delay(
	struct xfs_inode	*ip,
	int			whichfork,
4666
	struct xfs_iext_cursor	*icur,
4667 4668 4669 4670 4671 4672 4673 4674 4675
	struct xfs_bmbt_irec	*got,
	struct xfs_bmbt_irec	*del)
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_bmbt_irec	new;
	int64_t			da_old, da_new, da_diff = 0;
	xfs_fileoff_t		del_endoff, got_endoff;
	xfs_filblks_t		got_indlen, new_indlen, stolen;
4676 4677
	int			state = xfs_bmap_fork_to_state(whichfork);
	int			error = 0;
4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
	bool			isrt;

	XFS_STATS_INC(mp, xs_del_exlist);

	isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
	del_endoff = del->br_startoff + del->br_blockcount;
	got_endoff = got->br_startoff + got->br_blockcount;
	da_old = startblockval(got->br_startblock);
	da_new = 0;

	ASSERT(del->br_blockcount > 0);
	ASSERT(got->br_startoff <= del->br_startoff);
	ASSERT(got_endoff >= del_endoff);

	if (isrt) {
Eric Sandeen's avatar
Eric Sandeen committed
4693
		uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount);
4694 4695 4696 4697 4698 4699 4700 4701 4702 4703

		do_div(rtexts, mp->m_sb.sb_rextsize);
		xfs_mod_frextents(mp, rtexts);
	}

	/*
	 * Update the inode delalloc counter now and wait to update the
	 * sb counters as we might have to borrow some blocks for the
	 * indirect block accounting.
	 */
4704 4705
	error = xfs_trans_reserve_quota_nblks(NULL, ip,
			-((long)del->br_blockcount), 0,
4706
			isrt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS);
4707 4708
	if (error)
		return error;
4709 4710 4711
	ip->i_delayed_blks -= del->br_blockcount;

	if (got->br_startoff == del->br_startoff)
4712
		state |= BMAP_LEFT_FILLING;
4713
	if (got_endoff == del_endoff)
4714
		state |= BMAP_RIGHT_FILLING;
4715

4716 4717
	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4718 4719 4720
		/*
		 * Matches the whole extent.  Delete the entry.
		 */
4721
		xfs_iext_remove(ip, icur, state);
4722
		xfs_iext_prev(ifp, icur);
4723
		break;
4724
	case BMAP_LEFT_FILLING:
4725 4726 4727 4728 4729 4730 4731 4732
		/*
		 * Deleting the first part of the extent.
		 */
		got->br_startoff = del_endoff;
		got->br_blockcount -= del->br_blockcount;
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
				got->br_blockcount), da_old);
		got->br_startblock = nullstartblock((int)da_new);
4733
		xfs_iext_update_extent(ip, state, icur, got);
4734
		break;
4735
	case BMAP_RIGHT_FILLING:
4736 4737 4738 4739 4740 4741 4742
		/*
		 * Deleting the last part of the extent.
		 */
		got->br_blockcount = got->br_blockcount - del->br_blockcount;
		da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
				got->br_blockcount), da_old);
		got->br_startblock = nullstartblock((int)da_new);
4743
		xfs_iext_update_extent(ip, state, icur, got);
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770
		break;
	case 0:
		/*
		 * Deleting the middle of the extent.
		 *
		 * Distribute the original indlen reservation across the two new
		 * extents.  Steal blocks from the deleted extent if necessary.
		 * Stealing blocks simply fudges the fdblocks accounting below.
		 * Warn if either of the new indlen reservations is zero as this
		 * can lead to delalloc problems.
		 */
		got->br_blockcount = del->br_startoff - got->br_startoff;
		got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount);

		new.br_blockcount = got_endoff - del_endoff;
		new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount);

		WARN_ON_ONCE(!got_indlen || !new_indlen);
		stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen,
						       del->br_blockcount);

		got->br_startblock = nullstartblock((int)got_indlen);

		new.br_startoff = del_endoff;
		new.br_state = got->br_state;
		new.br_startblock = nullstartblock((int)new_indlen);

4771 4772
		xfs_iext_update_extent(ip, state, icur, got);
		xfs_iext_next(ifp, icur);
4773
		xfs_iext_insert(ip, icur, &new, state);
4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791

		da_new = got_indlen + new_indlen - stolen;
		del->br_blockcount -= stolen;
		break;
	}

	ASSERT(da_old >= da_new);
	da_diff = da_old - da_new;
	if (!isrt)
		da_diff += del->br_blockcount;
	if (da_diff)
		xfs_mod_fdblocks(mp, da_diff, false);
	return error;
}

void
xfs_bmap_del_extent_cow(
	struct xfs_inode	*ip,
4792
	struct xfs_iext_cursor	*icur,
4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812
	struct xfs_bmbt_irec	*got,
	struct xfs_bmbt_irec	*del)
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
	struct xfs_bmbt_irec	new;
	xfs_fileoff_t		del_endoff, got_endoff;
	int			state = BMAP_COWFORK;

	XFS_STATS_INC(mp, xs_del_exlist);

	del_endoff = del->br_startoff + del->br_blockcount;
	got_endoff = got->br_startoff + got->br_blockcount;

	ASSERT(del->br_blockcount > 0);
	ASSERT(got->br_startoff <= del->br_startoff);
	ASSERT(got_endoff >= del_endoff);
	ASSERT(!isnullstartblock(got->br_startblock));

	if (got->br_startoff == del->br_startoff)
4813
		state |= BMAP_LEFT_FILLING;
4814
	if (got_endoff == del_endoff)
4815
		state |= BMAP_RIGHT_FILLING;
4816

4817 4818
	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4819 4820 4821
		/*
		 * Matches the whole extent.  Delete the entry.
		 */
4822
		xfs_iext_remove(ip, icur, state);
4823
		xfs_iext_prev(ifp, icur);
4824
		break;
4825
	case BMAP_LEFT_FILLING:
4826 4827 4828 4829 4830 4831
		/*
		 * Deleting the first part of the extent.
		 */
		got->br_startoff = del_endoff;
		got->br_blockcount -= del->br_blockcount;
		got->br_startblock = del->br_startblock + del->br_blockcount;
4832
		xfs_iext_update_extent(ip, state, icur, got);
4833
		break;
4834
	case BMAP_RIGHT_FILLING:
4835 4836 4837 4838
		/*
		 * Deleting the last part of the extent.
		 */
		got->br_blockcount -= del->br_blockcount;
4839
		xfs_iext_update_extent(ip, state, icur, got);
4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851
		break;
	case 0:
		/*
		 * Deleting the middle of the extent.
		 */
		got->br_blockcount = del->br_startoff - got->br_startoff;

		new.br_startoff = del_endoff;
		new.br_blockcount = got_endoff - del_endoff;
		new.br_state = got->br_state;
		new.br_startblock = del->br_startblock + del->br_blockcount;

4852 4853
		xfs_iext_update_extent(ip, state, icur, got);
		xfs_iext_next(ifp, icur);
4854
		xfs_iext_insert(ip, icur, &new, state);
4855 4856
		break;
	}
4857
	ip->i_delayed_blks -= del->br_blockcount;
4858 4859
}

4860 4861
/*
 * Called by xfs_bmapi to update file extent records and the btree
4862
 * after removing space.
4863 4864
 */
STATIC int				/* error */
4865
xfs_bmap_del_extent_real(
4866 4867
	xfs_inode_t		*ip,	/* incore inode pointer */
	xfs_trans_t		*tp,	/* current transaction pointer */
4868
	struct xfs_iext_cursor	*icur,
4869 4870 4871
	xfs_btree_cur_t		*cur,	/* if null, not a btree */
	xfs_bmbt_irec_t		*del,	/* data to remove from extents */
	int			*logflagsp, /* inode logging flags */
4872 4873
	int			whichfork, /* data or attr fork */
	int			bflags)	/* bmapi flags */
4874 4875 4876 4877 4878
{
	xfs_fsblock_t		del_endblock=0;	/* first block past del */
	xfs_fileoff_t		del_endoff;	/* first offset past del */
	int			do_fx;	/* free extent at end of routine */
	int			error;	/* error return value */
4879
	int			flags = 0;/* inode logging flags */
4880
	struct xfs_bmbt_irec	got;	/* current extent entry */
4881 4882
	xfs_fileoff_t		got_endoff;	/* first offset past got */
	int			i;	/* temp state */
4883
	struct xfs_ifork	*ifp;	/* inode fork pointer */
4884 4885 4886 4887 4888
	xfs_mount_t		*mp;	/* mount structure */
	xfs_filblks_t		nblks;	/* quota/sb block count */
	xfs_bmbt_irec_t		new;	/* new record to be inserted */
	/* REFERENCED */
	uint			qfield;	/* quota field to update */
4889
	int			state = xfs_bmap_fork_to_state(whichfork);
4890
	struct xfs_bmbt_irec	old;
4891

4892 4893
	mp = ip->i_mount;
	XFS_STATS_INC(mp, xs_del_exlist);
4894 4895 4896

	ifp = XFS_IFORK_PTR(ip, whichfork);
	ASSERT(del->br_blockcount > 0);
4897
	xfs_iext_get_extent(ifp, icur, &got);
4898 4899 4900 4901
	ASSERT(got.br_startoff <= del->br_startoff);
	del_endoff = del->br_startoff + del->br_blockcount;
	got_endoff = got.br_startoff + got.br_blockcount;
	ASSERT(got_endoff >= del_endoff);
4902
	ASSERT(!isnullstartblock(got.br_startblock));
4903 4904
	qfield = 0;
	error = 0;
4905

4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921
	/*
	 * If it's the case where the directory code is running with no block
	 * reservation, and the deleted block is in the middle of its extent,
	 * and the resulting insert of an extent would cause transformation to
	 * btree format, then reject it.  The calling code will then swap blocks
	 * around instead.  We have to do this now, rather than waiting for the
	 * conversion to btree format, since the transaction will be dirty then.
	 */
	if (tp->t_blk_res == 0 &&
	    XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
	    XFS_IFORK_NEXTENTS(ip, whichfork) >=
			XFS_IFORK_MAXEXT(ip, whichfork) &&
	    del->br_startoff > got.br_startoff && del_endoff < got_endoff)
		return -ENOSPC;

	flags = XFS_ILOG_CORE;
4922 4923 4924
	if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) {
		xfs_fsblock_t	bno;
		xfs_filblks_t	len;
4925 4926 4927 4928 4929 4930 4931 4932
		xfs_extlen_t	mod;

		bno = div_u64_rem(del->br_startblock, mp->m_sb.sb_rextsize,
				  &mod);
		ASSERT(mod == 0);
		len = div_u64_rem(del->br_blockcount, mp->m_sb.sb_rextsize,
				  &mod);
		ASSERT(mod == 0);
4933 4934 4935 4936

		error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len);
		if (error)
			goto done;
4937
		do_fx = 0;
4938 4939 4940 4941 4942 4943 4944 4945 4946 4947
		nblks = len * mp->m_sb.sb_rextsize;
		qfield = XFS_TRANS_DQ_RTBCOUNT;
	} else {
		do_fx = 1;
		nblks = del->br_blockcount;
		qfield = XFS_TRANS_DQ_BCOUNT;
	}

	del_endblock = del->br_startblock + del->br_blockcount;
	if (cur) {
4948
		error = xfs_bmbt_lookup_eq(cur, &got, &i);
4949 4950 4951
		if (error)
			goto done;
		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
Linus Torvalds's avatar
Linus Torvalds committed
4952
	}
4953

4954 4955 4956 4957 4958 4959 4960
	if (got.br_startoff == del->br_startoff)
		state |= BMAP_LEFT_FILLING;
	if (got_endoff == del_endoff)
		state |= BMAP_RIGHT_FILLING;

	switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4961 4962 4963
		/*
		 * Matches the whole extent.  Delete the entry.
		 */
4964
		xfs_iext_remove(ip, icur, state);
4965
		xfs_iext_prev(ifp, icur);
4966 4967 4968 4969 4970 4971 4972 4973 4974
		XFS_IFORK_NEXT_SET(ip, whichfork,
			XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
		flags |= XFS_ILOG_CORE;
		if (!cur) {
			flags |= xfs_ilog_fext(whichfork);
			break;
		}
		if ((error = xfs_btree_delete(cur, &i)))
			goto done;
4975
		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
4976
		break;
4977
	case BMAP_LEFT_FILLING:
4978 4979 4980
		/*
		 * Deleting the first part of the extent.
		 */
4981 4982 4983
		got.br_startoff = del_endoff;
		got.br_startblock = del_endblock;
		got.br_blockcount -= del->br_blockcount;
4984
		xfs_iext_update_extent(ip, state, icur, &got);
4985 4986 4987 4988
		if (!cur) {
			flags |= xfs_ilog_fext(whichfork);
			break;
		}
4989
		error = xfs_bmbt_update(cur, &got);
4990
		if (error)
4991 4992
			goto done;
		break;
4993
	case BMAP_RIGHT_FILLING:
4994 4995 4996
		/*
		 * Deleting the last part of the extent.
		 */
4997
		got.br_blockcount -= del->br_blockcount;
4998
		xfs_iext_update_extent(ip, state, icur, &got);
4999 5000 5001 5002
		if (!cur) {
			flags |= xfs_ilog_fext(whichfork);
			break;
		}
5003
		error = xfs_bmbt_update(cur, &got);
5004
		if (error)
5005 5006 5007 5008 5009 5010
			goto done;
		break;
	case 0:
		/*
		 * Deleting the middle of the extent.
		 */
5011
		old = got;
5012

5013
		got.br_blockcount = del->br_startoff - got.br_startoff;
5014
		xfs_iext_update_extent(ip, state, icur, &got);
5015

5016
		new.br_startoff = del_endoff;
5017
		new.br_blockcount = got_endoff - del_endoff;
5018
		new.br_state = got.br_state;
5019
		new.br_startblock = del_endblock;
5020

5021 5022
		flags |= XFS_ILOG_CORE;
		if (cur) {
5023
			error = xfs_bmbt_update(cur, &got);
5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038
			if (error)
				goto done;
			error = xfs_btree_increment(cur, 0, &i);
			if (error)
				goto done;
			cur->bc_rec.b = new;
			error = xfs_btree_insert(cur, &i);
			if (error && error != -ENOSPC)
				goto done;
			/*
			 * If get no-space back from btree insert, it tried a
			 * split, and we have a zero block reservation.  Fix up
			 * our state and return the error.
			 */
			if (error == -ENOSPC) {
5039
				/*
5040 5041
				 * Reset the cursor, don't trust it after any
				 * insert operation.
5042
				 */
5043
				error = xfs_bmbt_lookup_eq(cur, &got, &i);
5044
				if (error)
5045
					goto done;
5046
				XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
5047 5048 5049 5050
				/*
				 * Update the btree record back
				 * to the original value.
				 */
5051
				error = xfs_bmbt_update(cur, &old);
5052 5053 5054 5055 5056 5057
				if (error)
					goto done;
				/*
				 * Reset the extent record back
				 * to the original value.
				 */
5058
				xfs_iext_update_extent(ip, state, icur, &old);
5059 5060 5061 5062 5063 5064 5065 5066 5067
				flags = 0;
				error = -ENOSPC;
				goto done;
			}
			XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
		} else
			flags |= xfs_ilog_fext(whichfork);
		XFS_IFORK_NEXT_SET(ip, whichfork,
			XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
5068
		xfs_iext_next(ifp, icur);
5069
		xfs_iext_insert(ip, icur, &new, state);
5070
		break;
Linus Torvalds's avatar
Linus Torvalds committed
5071
	}
5072 5073

	/* remove reverse mapping */
5074
	error = xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5075 5076
	if (error)
		goto done;
5077

Linus Torvalds's avatar
Linus Torvalds committed
5078
	/*
5079
	 * If we need to, add to list of extents to delete.
Linus Torvalds's avatar
Linus Torvalds committed
5080
	 */
5081
	if (do_fx && !(bflags & XFS_BMAPI_REMAP)) {
5082
		if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
5083
			error = xfs_refcount_decrease_extent(tp, del);
5084 5085
			if (error)
				goto done;
5086
		} else {
5087
			__xfs_bmap_add_free(tp, del->br_startblock,
5088 5089 5090
					del->br_blockcount, NULL,
					(bflags & XFS_BMAPI_NODISCARD) ||
					del->br_state == XFS_EXT_UNWRITTEN);
5091
		}
5092 5093
	}

Linus Torvalds's avatar
Linus Torvalds committed
5094
	/*
5095
	 * Adjust inode # blocks in the file.
Linus Torvalds's avatar
Linus Torvalds committed
5096
	 */
5097 5098
	if (nblks)
		ip->i_d.di_nblocks -= nblks;
Linus Torvalds's avatar
Linus Torvalds committed
5099
	/*
5100
	 * Adjust quota data.
Linus Torvalds's avatar
Linus Torvalds committed
5101
	 */
5102
	if (qfield && !(bflags & XFS_BMAPI_REMAP))
5103 5104 5105 5106
		xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks);

done:
	*logflagsp = flags;
Linus Torvalds's avatar
Linus Torvalds committed
5107 5108 5109
	return error;
}

5110
/*
5111 5112 5113 5114
 * Unmap (remove) blocks from a file.
 * If nexts is nonzero then the number of extents to remove is limited to
 * that value.  If not all extents in the block range can be removed then
 * *done is set.
5115
 */
5116
int						/* error */
5117
__xfs_bunmapi(
5118
	struct xfs_trans	*tp,		/* transaction pointer */
5119
	struct xfs_inode	*ip,		/* incore inode */
5120
	xfs_fileoff_t		start,		/* first file offset deleted */
5121
	xfs_filblks_t		*rlen,		/* i/o: amount remaining */
5122
	int			flags,		/* misc flags */
5123
	xfs_extnum_t		nexts)		/* number of extents max */
5124
{
5125 5126
	struct xfs_btree_cur	*cur;		/* bmap btree cursor */
	struct xfs_bmbt_irec	del;		/* extent being deleted */
5127 5128
	int			error;		/* error return value */
	xfs_extnum_t		extno;		/* extent number in list */
5129
	struct xfs_bmbt_irec	got;		/* current extent record */
5130
	struct xfs_ifork	*ifp;		/* inode fork pointer */
5131 5132 5133
	int			isrt;		/* freeing in rt area */
	int			logflags;	/* transaction logging flags */
	xfs_extlen_t		mod;		/* rt extent offset */
5134
	struct xfs_mount	*mp;		/* mount structure */
5135 5136 5137 5138
	int			tmp_logflags;	/* partial logging flags */
	int			wasdel;		/* was a delayed alloc extent */
	int			whichfork;	/* data or attribute fork */
	xfs_fsblock_t		sum;
5139
	xfs_filblks_t		len = *rlen;	/* length to unmap in file */
5140
	xfs_fileoff_t		max_len;
5141
	xfs_agnumber_t		prev_agno = NULLAGNUMBER, agno;
5142
	xfs_fileoff_t		end;
5143 5144
	struct xfs_iext_cursor	icur;
	bool			done = false;
Linus Torvalds's avatar
Linus Torvalds committed
5145

5146
	trace_xfs_bunmap(ip, start, len, flags, _RET_IP_);
Linus Torvalds's avatar
Linus Torvalds committed
5147

5148 5149
	whichfork = xfs_bmapi_whichfork(flags);
	ASSERT(whichfork != XFS_COW_FORK);
5150 5151 5152 5153 5154 5155
	ifp = XFS_IFORK_PTR(ip, whichfork);
	if (unlikely(
	    XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	    XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
		XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW,
				 ip->i_mount);
5156
		return -EFSCORRUPTED;
Linus Torvalds's avatar
Linus Torvalds committed
5157
	}
5158 5159
	mp = ip->i_mount;
	if (XFS_FORCED_SHUTDOWN(mp))
5160
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
5161

5162
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5163 5164
	ASSERT(len > 0);
	ASSERT(nexts >= 0);
Linus Torvalds's avatar
Linus Torvalds committed
5165

5166 5167 5168 5169 5170
	/*
	 * Guesstimate how many blocks we can unmap without running the risk of
	 * blowing out the transaction with a mix of EFIs and reflink
	 * adjustments.
	 */
5171
	if (tp && xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK)
5172 5173 5174 5175
		max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res));
	else
		max_len = len;

5176 5177 5178
	if (!(ifp->if_flags & XFS_IFEXTENTS) &&
	    (error = xfs_iread_extents(tp, ip, whichfork)))
		return error;
5179
	if (xfs_iext_count(ifp) == 0) {
5180
		*rlen = 0;
5181 5182
		return 0;
	}
5183
	XFS_STATS_INC(mp, xs_blk_unmap);
5184
	isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
5185
	end = start + len;
Linus Torvalds's avatar
Linus Torvalds committed
5186

5187
	if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) {
5188 5189
		*rlen = 0;
		return 0;
5190
	}
5191
	end--;
5192

5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204
	logflags = 0;
	if (ifp->if_flags & XFS_IFBROOT) {
		ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
		cur->bc_private.b.flags = 0;
	} else
		cur = NULL;

	if (isrt) {
		/*
		 * Synchronize by locking the bitmap inode.
		 */
5205
		xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
5206
		xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
5207 5208
		xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
		xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
5209
	}
5210

5211
	extno = 0;
5212
	while (end != (xfs_fileoff_t)-1 && end >= start &&
5213
	       (nexts == 0 || extno < nexts) && max_len > 0) {
5214
		/*
5215
		 * Is the found extent after a hole in which end lives?
5216 5217
		 * Just back up to the previous extent, if so.
		 */
5218 5219 5220 5221
		if (got.br_startoff > end &&
		    !xfs_iext_prev_extent(ifp, &icur, &got)) {
			done = true;
			break;
5222 5223 5224 5225 5226
		}
		/*
		 * Is the last block of this extent before the range
		 * we're supposed to delete?  If so, we're done.
		 */
5227
		end = XFS_FILEOFF_MIN(end,
5228
			got.br_startoff + got.br_blockcount - 1);
5229
		if (end < start)
5230 5231 5232 5233 5234 5235 5236
			break;
		/*
		 * Then deal with the (possibly delayed) allocated space
		 * we found.
		 */
		del = got;
		wasdel = isnullstartblock(del.br_startblock);
5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247

		/*
		 * Make sure we don't touch multiple AGF headers out of order
		 * in a single transaction, as that could cause AB-BA deadlocks.
		 */
		if (!wasdel) {
			agno = XFS_FSB_TO_AGNO(mp, del.br_startblock);
			if (prev_agno != NULLAGNUMBER && prev_agno > agno)
				break;
			prev_agno = agno;
		}
5248 5249 5250 5251 5252 5253
		if (got.br_startoff < start) {
			del.br_startoff = start;
			del.br_blockcount -= start - got.br_startoff;
			if (!wasdel)
				del.br_startblock += start - got.br_startoff;
		}
5254 5255
		if (del.br_startoff + del.br_blockcount > end + 1)
			del.br_blockcount = end + 1 - del.br_startoff;
5256 5257 5258 5259 5260 5261 5262 5263 5264

		/* How much can we safely unmap? */
		if (max_len < del.br_blockcount) {
			del.br_startoff += del.br_blockcount - max_len;
			if (!wasdel)
				del.br_startblock += del.br_blockcount - max_len;
			del.br_blockcount = max_len;
		}

5265 5266 5267
		if (!isrt)
			goto delete;

5268
		sum = del.br_startblock + del.br_blockcount;
5269 5270
		div_u64_rem(sum, mp->m_sb.sb_rextsize, &mod);
		if (mod) {
5271
			/*
5272 5273 5274 5275 5276
			 * Realtime extent not lined up at the end.
			 * The extent could have been split into written
			 * and unwritten pieces, or we could just be
			 * unmapping part of it.  But we can't really
			 * get rid of part of a realtime extent.
5277
			 */
5278 5279 5280 5281 5282 5283
			if (del.br_state == XFS_EXT_UNWRITTEN ||
			    !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
				/*
				 * This piece is unwritten, or we're not
				 * using unwritten extents.  Skip over it.
				 */
5284 5285
				ASSERT(end >= mod);
				end -= mod > del.br_blockcount ?
5286
					del.br_blockcount : mod;
5287 5288 5289 5290
				if (end < got.br_startoff &&
				    !xfs_iext_prev_extent(ifp, &icur, &got)) {
					done = true;
					break;
5291 5292
				}
				continue;
Linus Torvalds's avatar
Linus Torvalds committed
5293
			}
5294
			/*
5295 5296
			 * It's written, turn it unwritten.
			 * This is better than zeroing it.
5297
			 */
5298
			ASSERT(del.br_state == XFS_EXT_NORM);
5299
			ASSERT(tp->t_blk_res > 0);
5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310
			/*
			 * If this spans a realtime extent boundary,
			 * chop it back to the start of the one we end at.
			 */
			if (del.br_blockcount > mod) {
				del.br_startoff += del.br_blockcount - mod;
				del.br_startblock += del.br_blockcount - mod;
				del.br_blockcount = mod;
			}
			del.br_state = XFS_EXT_UNWRITTEN;
			error = xfs_bmap_add_extent_unwritten_real(tp, ip,
5311
					whichfork, &icur, &cur, &del,
5312
					&logflags);
5313 5314 5315 5316
			if (error)
				goto error0;
			goto nodelete;
		}
5317 5318
		div_u64_rem(del.br_startblock, mp->m_sb.sb_rextsize, &mod);
		if (mod) {
5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330
			/*
			 * Realtime extent is lined up at the end but not
			 * at the front.  We'll get rid of full extents if
			 * we can.
			 */
			mod = mp->m_sb.sb_rextsize - mod;
			if (del.br_blockcount > mod) {
				del.br_blockcount -= mod;
				del.br_startoff += mod;
				del.br_startblock += mod;
			} else if ((del.br_startoff == start &&
				    (del.br_state == XFS_EXT_UNWRITTEN ||
5331
				     tp->t_blk_res == 0)) ||
5332 5333 5334 5335 5336
				   !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
				/*
				 * Can't make it unwritten.  There isn't
				 * a full extent here so just skip it.
				 */
5337 5338
				ASSERT(end >= del.br_blockcount);
				end -= del.br_blockcount;
5339 5340 5341 5342 5343
				if (got.br_startoff > end &&
				    !xfs_iext_prev_extent(ifp, &icur, &got)) {
					done = true;
					break;
				}
5344
				continue;
5345
			} else if (del.br_state == XFS_EXT_UNWRITTEN) {
5346 5347
				struct xfs_bmbt_irec	prev;

5348 5349 5350 5351 5352 5353
				/*
				 * This one is already unwritten.
				 * It must have a written left neighbor.
				 * Unwrite the killed part of that one and
				 * try again.
				 */
5354 5355
				if (!xfs_iext_prev_extent(ifp, &icur, &prev))
					ASSERT(0);
5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367
				ASSERT(prev.br_state == XFS_EXT_NORM);
				ASSERT(!isnullstartblock(prev.br_startblock));
				ASSERT(del.br_startblock ==
				       prev.br_startblock + prev.br_blockcount);
				if (prev.br_startoff < start) {
					mod = start - prev.br_startoff;
					prev.br_blockcount -= mod;
					prev.br_startblock += mod;
					prev.br_startoff = start;
				}
				prev.br_state = XFS_EXT_UNWRITTEN;
				error = xfs_bmap_add_extent_unwritten_real(tp,
5368
						ip, whichfork, &icur, &cur,
5369
						&prev, &logflags);
5370 5371 5372 5373 5374 5375 5376
				if (error)
					goto error0;
				goto nodelete;
			} else {
				ASSERT(del.br_state == XFS_EXT_NORM);
				del.br_state = XFS_EXT_UNWRITTEN;
				error = xfs_bmap_add_extent_unwritten_real(tp,
5377
						ip, whichfork, &icur, &cur,
5378
						&del, &logflags);
5379 5380 5381
				if (error)
					goto error0;
				goto nodelete;
5382
			}
Linus Torvalds's avatar
Linus Torvalds committed
5383 5384
		}

5385
delete:
5386
		if (wasdel) {
5387
			error = xfs_bmap_del_extent_delay(ip, whichfork, &icur,
5388 5389
					&got, &del);
		} else {
5390 5391
			error = xfs_bmap_del_extent_real(ip, tp, &icur, cur,
					&del, &tmp_logflags, whichfork,
5392 5393
					flags);
			logflags |= tmp_logflags;
5394
		}
5395

5396 5397
		if (error)
			goto error0;
5398

5399
		max_len -= del.br_blockcount;
5400
		end = del.br_startoff - 1;
5401
nodelete:
Linus Torvalds's avatar
Linus Torvalds committed
5402
		/*
5403
		 * If not done go on to the next (previous) record.
Linus Torvalds's avatar
Linus Torvalds committed
5404
		 */
5405
		if (end != (xfs_fileoff_t)-1 && end >= start) {
5406 5407 5408 5409 5410
			if (!xfs_iext_get_extent(ifp, &icur, &got) ||
			    (got.br_startoff > end &&
			     !xfs_iext_prev_extent(ifp, &icur, &got))) {
				done = true;
				break;
Linus Torvalds's avatar
Linus Torvalds committed
5411
			}
5412
			extno++;
Linus Torvalds's avatar
Linus Torvalds committed
5413 5414
		}
	}
5415
	if (done || end == (xfs_fileoff_t)-1 || end < start)
5416 5417
		*rlen = 0;
	else
5418
		*rlen = end - start + 1;
5419

Linus Torvalds's avatar
Linus Torvalds committed
5420
	/*
5421
	 * Convert to a btree if necessary.
Linus Torvalds's avatar
Linus Torvalds committed
5422
	 */
5423 5424
	if (xfs_bmap_needs_btree(ip, whichfork)) {
		ASSERT(cur == NULL);
5425 5426
		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
				&tmp_logflags, whichfork);
5427 5428 5429
		logflags |= tmp_logflags;
		if (error)
			goto error0;
Linus Torvalds's avatar
Linus Torvalds committed
5430 5431
	}
	/*
5432
	 * transform from btree to extents, give it cur
Linus Torvalds's avatar
Linus Torvalds committed
5433
	 */
5434 5435 5436 5437 5438 5439 5440 5441
	else if (xfs_bmap_wants_extents(ip, whichfork)) {
		ASSERT(cur != NULL);
		error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags,
			whichfork);
		logflags |= tmp_logflags;
		if (error)
			goto error0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
5442
	/*
5443
	 * transform from extents to local?
Linus Torvalds's avatar
Linus Torvalds committed
5444
	 */
5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463
	error = 0;
error0:
	/*
	 * Log everything.  Do this after conversion, there's no point in
	 * logging the extent records if we've converted to btree format.
	 */
	if ((logflags & xfs_ilog_fext(whichfork)) &&
	    XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
		logflags &= ~xfs_ilog_fext(whichfork);
	else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
		 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
		logflags &= ~xfs_ilog_fbroot(whichfork);
	/*
	 * Log inode even in the error case, if the transaction
	 * is dirty we'll need to shut down the filesystem.
	 */
	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
	if (cur) {
5464
		if (!error)
5465
			cur->bc_private.b.allocated = 0;
5466
		xfs_btree_del_cursor(cur, error);
5467 5468 5469
	}
	return error;
}
5470

5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483
/* Unmap a range of a file. */
int
xfs_bunmapi(
	xfs_trans_t		*tp,
	struct xfs_inode	*ip,
	xfs_fileoff_t		bno,
	xfs_filblks_t		len,
	int			flags,
	xfs_extnum_t		nexts,
	int			*done)
{
	int			error;

5484
	error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts);
5485 5486 5487 5488
	*done = (len == 0);
	return error;
}

5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526
/*
 * Determine whether an extent shift can be accomplished by a merge with the
 * extent that precedes the target hole of the shift.
 */
STATIC bool
xfs_bmse_can_merge(
	struct xfs_bmbt_irec	*left,	/* preceding extent */
	struct xfs_bmbt_irec	*got,	/* current extent to shift */
	xfs_fileoff_t		shift)	/* shift fsb */
{
	xfs_fileoff_t		startoff;

	startoff = got->br_startoff - shift;

	/*
	 * The extent, once shifted, must be adjacent in-file and on-disk with
	 * the preceding extent.
	 */
	if ((left->br_startoff + left->br_blockcount != startoff) ||
	    (left->br_startblock + left->br_blockcount != got->br_startblock) ||
	    (left->br_state != got->br_state) ||
	    (left->br_blockcount + got->br_blockcount > MAXEXTLEN))
		return false;

	return true;
}

/*
 * A bmap extent shift adjusts the file offset of an extent to fill a preceding
 * hole in the file. If an extent shift would result in the extent being fully
 * adjacent to the extent that currently precedes the hole, we can merge with
 * the preceding extent rather than do the shift.
 *
 * This function assumes the caller has verified a shift-by-merge is possible
 * with the provided extents via xfs_bmse_can_merge().
 */
STATIC int
xfs_bmse_merge(
5527
	struct xfs_trans		*tp,
5528 5529 5530
	struct xfs_inode		*ip,
	int				whichfork,
	xfs_fileoff_t			shift,		/* shift fsb */
5531
	struct xfs_iext_cursor		*icur,
5532 5533
	struct xfs_bmbt_irec		*got,		/* extent to shift */
	struct xfs_bmbt_irec		*left,		/* preceding extent */
5534
	struct xfs_btree_cur		*cur,
5535
	int				*logflags)	/* output */
5536
{
5537
	struct xfs_bmbt_irec		new;
5538 5539
	xfs_filblks_t			blockcount;
	int				error, i;
5540
	struct xfs_mount		*mp = ip->i_mount;
5541

5542
	blockcount = left->br_blockcount + got->br_blockcount;
5543 5544 5545

	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5546
	ASSERT(xfs_bmse_can_merge(left, got, shift));
5547

5548 5549
	new = *left;
	new.br_blockcount = blockcount;
5550 5551 5552 5553 5554 5555 5556 5557 5558 5559

	/*
	 * Update the on-disk extent count, the btree if necessary and log the
	 * inode.
	 */
	XFS_IFORK_NEXT_SET(ip, whichfork,
			   XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
	*logflags |= XFS_ILOG_CORE;
	if (!cur) {
		*logflags |= XFS_ILOG_DEXT;
5560
		goto done;
5561 5562 5563
	}

	/* lookup and remove the extent to merge */
5564
	error = xfs_bmbt_lookup_eq(cur, got, &i);
5565
	if (error)
5566
		return error;
5567
	XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
5568 5569 5570

	error = xfs_btree_delete(cur, &i);
	if (error)
5571
		return error;
5572
	XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
5573 5574

	/* lookup and update size of the previous extent */
5575
	error = xfs_bmbt_lookup_eq(cur, left, &i);
5576
	if (error)
5577
		return error;
5578
	XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
5579

5580
	error = xfs_bmbt_update(cur, &new);
5581 5582 5583 5584
	if (error)
		return error;

done:
5585
	xfs_iext_remove(ip, icur, 0);
5586 5587 5588
	xfs_iext_prev(XFS_IFORK_PTR(ip, whichfork), icur);
	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
			&new);
5589

5590
	/* update reverse mapping. rmap functions merge the rmaps for us */
5591
	error = xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5592 5593
	if (error)
		return error;
5594 5595
	memcpy(&new, got, sizeof(new));
	new.br_startoff = left->br_startoff + left->br_blockcount;
5596
	return xfs_rmap_map_extent(tp, ip, whichfork, &new);
5597 5598
}

5599 5600
static int
xfs_bmap_shift_update_extent(
5601
	struct xfs_trans	*tp,
5602 5603
	struct xfs_inode	*ip,
	int			whichfork,
5604
	struct xfs_iext_cursor	*icur,
5605 5606 5607 5608
	struct xfs_bmbt_irec	*got,
	struct xfs_btree_cur	*cur,
	int			*logflags,
	xfs_fileoff_t		startoff)
5609
{
5610
	struct xfs_mount	*mp = ip->i_mount;
5611
	struct xfs_bmbt_irec	prev = *got;
5612
	int			error, i;
5613

5614
	*logflags |= XFS_ILOG_CORE;
5615

5616
	got->br_startoff = startoff;
5617 5618

	if (cur) {
5619
		error = xfs_bmbt_lookup_eq(cur, &prev, &i);
5620 5621 5622 5623
		if (error)
			return error;
		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

5624
		error = xfs_bmbt_update(cur, got);
5625 5626 5627
		if (error)
			return error;
	} else {
5628 5629 5630
		*logflags |= XFS_ILOG_DEXT;
	}

5631 5632
	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
			got);
5633 5634

	/* update reverse mapping */
5635
	error = xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
5636 5637
	if (error)
		return error;
5638
	return xfs_rmap_map_extent(tp, ip, whichfork, got);
5639 5640
}

5641
int
5642
xfs_bmap_collapse_extents(
5643 5644
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
5645
	xfs_fileoff_t		*next_fsb,
5646
	xfs_fileoff_t		offset_shift_fsb,
5647
	bool			*done)
5648
{
5649 5650 5651 5652
	int			whichfork = XFS_DATA_FORK;
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_btree_cur	*cur = NULL;
5653
	struct xfs_bmbt_irec	got, prev;
5654
	struct xfs_iext_cursor	icur;
5655
	xfs_fileoff_t		new_startoff;
5656 5657
	int			error = 0;
	int			logflags = 0;
5658 5659 5660 5661

	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
5662
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
5663
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
5664
		return -EFSCORRUPTED;
5665 5666 5667
	}

	if (XFS_FORCED_SHUTDOWN(mp))
5668
		return -EIO;
5669

5670
	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
5671 5672 5673 5674 5675 5676 5677

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
	}

5678 5679 5680 5681 5682
	if (ifp->if_flags & XFS_IFBROOT) {
		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
		cur->bc_private.b.flags = 0;
	}

5683
	if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5684 5685 5686
		*done = true;
		goto del_cursor;
	}
5687 5688
	XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock),
				del_cursor);
5689

5690
	new_startoff = got.br_startoff - offset_shift_fsb;
5691
	if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) {
5692 5693 5694 5695 5696 5697
		if (new_startoff < prev.br_startoff + prev.br_blockcount) {
			error = -EINVAL;
			goto del_cursor;
		}

		if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) {
5698 5699 5700
			error = xfs_bmse_merge(tp, ip, whichfork,
					offset_shift_fsb, &icur, &got, &prev,
					cur, &logflags);
5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711
			if (error)
				goto del_cursor;
			goto done;
		}
	} else {
		if (got.br_startoff < offset_shift_fsb) {
			error = -EINVAL;
			goto del_cursor;
		}
	}

5712 5713
	error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
			cur, &logflags, new_startoff);
5714 5715
	if (error)
		goto del_cursor;
5716

5717
done:
5718 5719 5720
	if (!xfs_iext_next_extent(ifp, &icur, &got)) {
		*done = true;
		goto del_cursor;
5721 5722
	}

5723
	*next_fsb = got.br_startoff;
5724 5725
del_cursor:
	if (cur)
5726
		xfs_btree_del_cursor(cur, error);
5727 5728 5729 5730 5731
	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
	return error;
}

5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757
/* Make sure we won't be right-shifting an extent past the maximum bound. */
int
xfs_bmap_can_insert_extents(
	struct xfs_inode	*ip,
	xfs_fileoff_t		off,
	xfs_fileoff_t		shift)
{
	struct xfs_bmbt_irec	got;
	int			is_empty;
	int			error = 0;

	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));

	if (XFS_FORCED_SHUTDOWN(ip->i_mount))
		return -EIO;

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty);
	if (!error && !is_empty && got.br_startoff >= off &&
	    ((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff)
		error = -EINVAL;
	xfs_iunlock(ip, XFS_ILOCK_EXCL);

	return error;
}

5758 5759 5760 5761 5762 5763 5764
int
xfs_bmap_insert_extents(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	xfs_fileoff_t		*next_fsb,
	xfs_fileoff_t		offset_shift_fsb,
	bool			*done,
5765
	xfs_fileoff_t		stop_fsb)
5766 5767 5768 5769 5770
{
	int			whichfork = XFS_DATA_FORK;
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
	struct xfs_btree_cur	*cur = NULL;
5771
	struct xfs_bmbt_irec	got, next;
5772
	struct xfs_iext_cursor	icur;
5773
	xfs_fileoff_t		new_startoff;
5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800
	int			error = 0;
	int			logflags = 0;

	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
		return -EFSCORRUPTED;
	}

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));

	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
	}

	if (ifp->if_flags & XFS_IFBROOT) {
		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
		cur->bc_private.b.flags = 0;
	}

5801
	if (*next_fsb == NULLFSBLOCK) {
5802 5803
		xfs_iext_last(ifp, &icur);
		if (!xfs_iext_get_extent(ifp, &icur, &got) ||
5804
		    stop_fsb > got.br_startoff) {
5805
			*done = true;
5806 5807
			goto del_cursor;
		}
5808
	} else {
5809
		if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5810
			*done = true;
5811 5812
			goto del_cursor;
		}
5813
	}
5814 5815
	XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock),
				del_cursor);
5816

5817
	if (stop_fsb >= got.br_startoff + got.br_blockcount) {
5818 5819
		error = -EIO;
		goto del_cursor;
5820 5821
	}

5822
	new_startoff = got.br_startoff + offset_shift_fsb;
5823
	if (xfs_iext_peek_next_extent(ifp, &icur, &next)) {
5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838
		if (new_startoff + got.br_blockcount > next.br_startoff) {
			error = -EINVAL;
			goto del_cursor;
		}

		/*
		 * Unlike a left shift (which involves a hole punch), a right
		 * shift does not modify extent neighbors in any way.  We should
		 * never find mergeable extents in this scenario.  Check anyways
		 * and warn if we encounter two extents that could be one.
		 */
		if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb))
			WARN_ON_ONCE(1);
	}

5839 5840
	error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
			cur, &logflags, new_startoff);
5841 5842
	if (error)
		goto del_cursor;
5843

5844
	if (!xfs_iext_prev_extent(ifp, &icur, &got) ||
5845
	    stop_fsb >= got.br_startoff + got.br_blockcount) {
5846
		*done = true;
5847
		goto del_cursor;
5848 5849
	}

5850
	*next_fsb = got.br_startoff;
5851 5852
del_cursor:
	if (cur)
5853
		xfs_btree_del_cursor(cur, error);
5854 5855
	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
5856 5857
	return error;
}
5858 5859

/*
5860 5861 5862 5863
 * Splits an extent into two extents at split_fsb block such that it is the
 * first block of the current_ext. @ext is a target extent to be split.
 * @split_fsb is a block where the extents is split.  If split_fsb lies in a
 * hole or the first block of extents, just return 0.
5864 5865 5866 5867 5868
 */
STATIC int
xfs_bmap_split_extent_at(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
5869
	xfs_fileoff_t		split_fsb)
5870 5871 5872 5873 5874 5875 5876 5877
{
	int				whichfork = XFS_DATA_FORK;
	struct xfs_btree_cur		*cur = NULL;
	struct xfs_bmbt_irec		got;
	struct xfs_bmbt_irec		new; /* split extent */
	struct xfs_mount		*mp = ip->i_mount;
	struct xfs_ifork		*ifp;
	xfs_fsblock_t			gotblkcnt; /* new block count for got */
5878
	struct xfs_iext_cursor		icur;
5879 5880 5881 5882 5883 5884 5885
	int				error = 0;
	int				logflags = 0;
	int				i = 0;

	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
5886
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903
		XFS_ERROR_REPORT("xfs_bmap_split_extent_at",
				 XFS_ERRLEVEL_LOW, mp);
		return -EFSCORRUPTED;
	}

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

	ifp = XFS_IFORK_PTR(ip, whichfork);
	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		/* Read in all the extents */
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
			return error;
	}

	/*
5904
	 * If there are not extents, or split_fsb lies in a hole we are done.
5905
	 */
5906
	if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) ||
5907
	    got.br_startoff >= split_fsb)
5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918
		return 0;

	gotblkcnt = split_fsb - got.br_startoff;
	new.br_startoff = split_fsb;
	new.br_startblock = got.br_startblock + gotblkcnt;
	new.br_blockcount = got.br_blockcount - gotblkcnt;
	new.br_state = got.br_state;

	if (ifp->if_flags & XFS_IFBROOT) {
		cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
		cur->bc_private.b.flags = 0;
5919
		error = xfs_bmbt_lookup_eq(cur, &got, &i);
5920 5921 5922 5923 5924 5925
		if (error)
			goto del_cursor;
		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor);
	}

	got.br_blockcount = gotblkcnt;
5926 5927
	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur,
			&got);
5928 5929 5930

	logflags = XFS_ILOG_CORE;
	if (cur) {
5931
		error = xfs_bmbt_update(cur, &got);
5932 5933 5934 5935 5936 5937
		if (error)
			goto del_cursor;
	} else
		logflags |= XFS_ILOG_DEXT;

	/* Add new extent */
5938
	xfs_iext_next(ifp, &icur);
5939
	xfs_iext_insert(ip, &icur, &new, 0);
5940 5941 5942 5943
	XFS_IFORK_NEXT_SET(ip, whichfork,
			   XFS_IFORK_NEXTENTS(ip, whichfork) + 1);

	if (cur) {
5944
		error = xfs_bmbt_lookup_eq(cur, &new, &i);
5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960
		if (error)
			goto del_cursor;
		XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor);
		error = xfs_btree_insert(cur, &i);
		if (error)
			goto del_cursor;
		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor);
	}

	/*
	 * Convert to a btree if necessary.
	 */
	if (xfs_bmap_needs_btree(ip, whichfork)) {
		int tmp_logflags; /* partial log flag return val */

		ASSERT(cur == NULL);
5961 5962
		error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
				&tmp_logflags, whichfork);
5963 5964 5965 5966 5967 5968
		logflags |= tmp_logflags;
	}

del_cursor:
	if (cur) {
		cur->bc_private.b.allocated = 0;
5969
		xfs_btree_del_cursor(cur, error);
5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985
	}

	if (logflags)
		xfs_trans_log_inode(tp, ip, logflags);
	return error;
}

int
xfs_bmap_split_extent(
	struct xfs_inode        *ip,
	xfs_fileoff_t           split_fsb)
{
	struct xfs_mount        *mp = ip->i_mount;
	struct xfs_trans        *tp;
	int                     error;

5986 5987 5988
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
			XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
	if (error)
5989 5990 5991 5992 5993
		return error;

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

5994
	error = xfs_bmap_split_extent_at(tp, ip, split_fsb);
5995 5996 5997
	if (error)
		goto out;

5998
	return xfs_trans_commit(tp);
5999 6000

out:
6001
	xfs_trans_cancel(tp);
6002 6003
	return error;
}
6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016

/* Deferred mapping is only for real extents in the data fork. */
static bool
xfs_bmap_is_update_needed(
	struct xfs_bmbt_irec	*bmap)
{
	return  bmap->br_startblock != HOLESTARTBLOCK &&
		bmap->br_startblock != DELAYSTARTBLOCK;
}

/* Record a bmap intent. */
static int
__xfs_bmap_add(
6017
	struct xfs_trans		*tp,
6018 6019 6020 6021 6022 6023 6024
	enum xfs_bmap_intent_type	type,
	struct xfs_inode		*ip,
	int				whichfork,
	struct xfs_bmbt_irec		*bmap)
{
	struct xfs_bmap_intent		*bi;

6025 6026
	trace_xfs_bmap_defer(tp->t_mountp,
			XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),
6027
			type,
6028
			XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),
6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040
			ip->i_ino, whichfork,
			bmap->br_startoff,
			bmap->br_blockcount,
			bmap->br_state);

	bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS);
	INIT_LIST_HEAD(&bi->bi_list);
	bi->bi_type = type;
	bi->bi_owner = ip;
	bi->bi_whichfork = whichfork;
	bi->bi_bmap = *bmap;

6041
	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list);
6042 6043 6044 6045 6046 6047
	return 0;
}

/* Map an extent into a file. */
int
xfs_bmap_map_extent(
6048
	struct xfs_trans	*tp,
6049 6050 6051 6052 6053 6054
	struct xfs_inode	*ip,
	struct xfs_bmbt_irec	*PREV)
{
	if (!xfs_bmap_is_update_needed(PREV))
		return 0;

6055
	return __xfs_bmap_add(tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV);
6056 6057 6058 6059 6060
}

/* Unmap an extent out of a file. */
int
xfs_bmap_unmap_extent(
6061
	struct xfs_trans	*tp,
6062 6063 6064 6065 6066 6067
	struct xfs_inode	*ip,
	struct xfs_bmbt_irec	*PREV)
{
	if (!xfs_bmap_is_update_needed(PREV))
		return 0;

6068
	return __xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV);
6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082
}

/*
 * Process one of the deferred bmap operations.  We pass back the
 * btree cursor to maintain our lock on the bmapbt between calls.
 */
int
xfs_bmap_finish_one(
	struct xfs_trans		*tp,
	struct xfs_inode		*ip,
	enum xfs_bmap_intent_type	type,
	int				whichfork,
	xfs_fileoff_t			startoff,
	xfs_fsblock_t			startblock,
6083
	xfs_filblks_t			*blockcount,
6084 6085
	xfs_exntst_t			state)
{
6086
	int				error = 0;
6087

6088
	ASSERT(tp->t_firstblock == NULLFSBLOCK);
6089

6090 6091 6092
	trace_xfs_bmap_deferred(tp->t_mountp,
			XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type,
			XFS_FSB_TO_AGBNO(tp->t_mountp, startblock),
6093
			ip->i_ino, whichfork, startoff, *blockcount, state);
6094

6095
	if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK))
6096 6097 6098
		return -EFSCORRUPTED;

	if (XFS_TEST_ERROR(false, tp->t_mountp,
6099
			XFS_ERRTAG_BMAP_FINISH_ONE))
6100 6101 6102 6103
		return -EIO;

	switch (type) {
	case XFS_BMAP_MAP:
6104
		error = xfs_bmapi_remap(tp, ip, startoff, *blockcount,
6105
				startblock, 0);
6106
		*blockcount = 0;
6107 6108
		break;
	case XFS_BMAP_UNMAP:
6109
		error = __xfs_bunmapi(tp, ip, startoff, blockcount,
6110
				XFS_BMAPI_REMAP, 1);
6111 6112 6113 6114 6115 6116 6117 6118
		break;
	default:
		ASSERT(0);
		error = -EFSCORRUPTED;
	}

	return error;
}
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154

/* Check that an inode's extent does not have invalid flags or bad ranges. */
xfs_failaddr_t
xfs_bmap_validate_extent(
	struct xfs_inode	*ip,
	int			whichfork,
	struct xfs_bmbt_irec	*irec)
{
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fsblock_t		endfsb;
	bool			isrt;

	isrt = XFS_IS_REALTIME_INODE(ip);
	endfsb = irec->br_startblock + irec->br_blockcount - 1;
	if (isrt) {
		if (!xfs_verify_rtbno(mp, irec->br_startblock))
			return __this_address;
		if (!xfs_verify_rtbno(mp, endfsb))
			return __this_address;
	} else {
		if (!xfs_verify_fsbno(mp, irec->br_startblock))
			return __this_address;
		if (!xfs_verify_fsbno(mp, endfsb))
			return __this_address;
		if (XFS_FSB_TO_AGNO(mp, irec->br_startblock) !=
		    XFS_FSB_TO_AGNO(mp, endfsb))
			return __this_address;
	}
	if (irec->br_state != XFS_EXT_NORM) {
		if (whichfork != XFS_DATA_FORK)
			return __this_address;
		if (!xfs_sb_version_hasextflgbit(&mp->m_sb))
			return __this_address;
	}
	return NULL;
}