xfs_iomap.c 34.8 KB
Newer Older
D
Dave Chinner 已提交
1
// SPDX-License-Identifier: GPL-2.0
L
Linus Torvalds 已提交
2
/*
3
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4
 * Copyright (c) 2016-2018 Christoph Hellwig.
5
 * All Rights Reserved.
L
Linus Torvalds 已提交
6 7 8
 */
#include "xfs.h"
#include "xfs_fs.h"
9
#include "xfs_shared.h"
10 11 12
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
13 14
#include "xfs_mount.h"
#include "xfs_inode.h"
15
#include "xfs_btree.h"
16
#include "xfs_bmap_btree.h"
L
Linus Torvalds 已提交
17
#include "xfs_bmap.h"
D
Dave Chinner 已提交
18
#include "xfs_bmap_util.h"
19
#include "xfs_errortag.h"
L
Linus Torvalds 已提交
20
#include "xfs_error.h"
21
#include "xfs_trans.h"
L
Linus Torvalds 已提交
22
#include "xfs_trans_space.h"
23
#include "xfs_inode_item.h"
L
Linus Torvalds 已提交
24
#include "xfs_iomap.h"
C
Christoph Hellwig 已提交
25
#include "xfs_trace.h"
26
#include "xfs_quota.h"
27 28
#include "xfs_dquot_item.h"
#include "xfs_dquot.h"
29
#include "xfs_reflink.h"
L
Linus Torvalds 已提交
30 31 32 33 34


#define XFS_WRITEIO_ALIGN(mp,off)	(((off) >> mp->m_writeio_log) \
						<< mp->m_writeio_log)

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
static int
xfs_alert_fsblock_zero(
	xfs_inode_t	*ip,
	xfs_bmbt_irec_t	*imap)
{
	xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
			"Access to block zero in inode %llu "
			"start_block: %llx start_off: %llx "
			"blkcnt: %llx extent-state: %x",
		(unsigned long long)ip->i_ino,
		(unsigned long long)imap->br_startblock,
		(unsigned long long)imap->br_startoff,
		(unsigned long long)imap->br_blockcount,
		imap->br_state);
	return -EFSCORRUPTED;
}

int
53 54 55
xfs_bmbt_to_iomap(
	struct xfs_inode	*ip,
	struct iomap		*iomap,
56 57
	struct xfs_bmbt_irec	*imap,
	bool			shared)
58 59 60
{
	struct xfs_mount	*mp = ip->i_mount;

61
	if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock)))
62 63
		return xfs_alert_fsblock_zero(ip, imap);

64
	if (imap->br_startblock == HOLESTARTBLOCK) {
65
		iomap->addr = IOMAP_NULL_ADDR;
66
		iomap->type = IOMAP_HOLE;
67 68
	} else if (imap->br_startblock == DELAYSTARTBLOCK ||
		   isnullstartblock(imap->br_startblock)) {
69
		iomap->addr = IOMAP_NULL_ADDR;
70 71
		iomap->type = IOMAP_DELALLOC;
	} else {
72
		iomap->addr = BBTOB(xfs_fsb_to_db(ip, imap->br_startblock));
73 74 75 76 77 78 79 80
		if (imap->br_state == XFS_EXT_UNWRITTEN)
			iomap->type = IOMAP_UNWRITTEN;
		else
			iomap->type = IOMAP_MAPPED;
	}
	iomap->offset = XFS_FSB_TO_B(mp, imap->br_startoff);
	iomap->length = XFS_FSB_TO_B(mp, imap->br_blockcount);
	iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
81
	iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
82 83 84 85 86 87 88

	if (xfs_ipincount(ip) &&
	    (ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
		iomap->flags |= IOMAP_F_DIRTY;
	if (shared)
		iomap->flags |= IOMAP_F_SHARED;
	return 0;
89 90
}

91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
static void
xfs_hole_to_iomap(
	struct xfs_inode	*ip,
	struct iomap		*iomap,
	xfs_fileoff_t		offset_fsb,
	xfs_fileoff_t		end_fsb)
{
	iomap->addr = IOMAP_NULL_ADDR;
	iomap->type = IOMAP_HOLE;
	iomap->offset = XFS_FSB_TO_B(ip->i_mount, offset_fsb);
	iomap->length = XFS_FSB_TO_B(ip->i_mount, end_fsb - offset_fsb);
	iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
	iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
}

106
xfs_extlen_t
107 108 109
xfs_eof_alignment(
	struct xfs_inode	*ip,
	xfs_extlen_t		extsize)
110
{
111 112
	struct xfs_mount	*mp = ip->i_mount;
	xfs_extlen_t		align = 0;
113

114 115 116 117 118 119 120 121 122 123 124 125 126 127
	if (!XFS_IS_REALTIME_INODE(ip)) {
		/*
		 * Round up the allocation request to a stripe unit
		 * (m_dalign) boundary if the file size is >= stripe unit
		 * size, and we are allocating past the allocation eof.
		 *
		 * If mounted with the "-o swalloc" option the alignment is
		 * increased from the strip unit size to the stripe width.
		 */
		if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC))
			align = mp->m_swidth;
		else if (mp->m_dalign)
			align = mp->m_dalign;

128 129
		if (align && XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, align))
			align = 0;
130
	}
131 132 133 134 135 136

	/*
	 * Always round up the allocation request to an extent boundary
	 * (when file on a real-time subvolume or has di_extsize hint).
	 */
	if (extsize) {
137 138
		if (align)
			align = roundup_64(align, extsize);
139 140 141 142
		else
			align = extsize;
	}

143 144 145 146 147 148 149 150 151 152 153
	return align;
}

STATIC int
xfs_iomap_eof_align_last_fsb(
	struct xfs_inode	*ip,
	xfs_extlen_t		extsize,
	xfs_fileoff_t		*last_fsb)
{
	xfs_extlen_t		align = xfs_eof_alignment(ip, extsize);

154 155
	if (align) {
		xfs_fileoff_t	new_last_fsb = roundup_64(*last_fsb, align);
156 157
		int		eof, error;

158
		error = xfs_bmap_eof(ip, new_last_fsb, XFS_DATA_FORK, &eof);
159 160 161 162 163 164 165 166
		if (error)
			return error;
		if (eof)
			*last_fsb = new_last_fsb;
	}
	return 0;
}

C
Christoph Hellwig 已提交
167
int
L
Linus Torvalds 已提交
168 169
xfs_iomap_write_direct(
	xfs_inode_t	*ip,
170
	xfs_off_t	offset,
L
Linus Torvalds 已提交
171
	size_t		count,
172
	xfs_bmbt_irec_t *imap,
173
	int		nmaps)
L
Linus Torvalds 已提交
174 175 176 177
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
178
	xfs_filblks_t	count_fsb, resaligned;
179
	xfs_extlen_t	extsz;
180
	int		nimaps;
181
	int		quota_flag;
L
Linus Torvalds 已提交
182 183
	int		rt;
	xfs_trans_t	*tp;
184 185
	uint		qblocks, resblks, resrtextents;
	int		error;
186
	int		lockmode;
187
	int		bmapi_flags = XFS_BMAPI_PREALLOC;
188
	uint		tflags = 0;
L
Linus Torvalds 已提交
189

190
	rt = XFS_IS_REALTIME_INODE(ip);
191
	extsz = xfs_get_extsz_hint(ip);
192 193 194
	lockmode = XFS_ILOCK_SHARED;	/* locked by caller */

	ASSERT(xfs_isilocked(ip, lockmode));
L
Linus Torvalds 已提交
195

196 197
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
198
	if ((offset + count) > XFS_ISIZE(ip)) {
199 200 201 202 203 204 205 206 207
		/*
		 * Assert that the in-core extent list is present since this can
		 * call xfs_iread_extents() and we only have the ilock shared.
		 * This should be safe because the lock was held around a bmapi
		 * call in the caller and we only need it to access the in-core
		 * list.
		 */
		ASSERT(XFS_IFORK_PTR(ip, XFS_DATA_FORK)->if_flags &
								XFS_IFEXTENTS);
208
		error = xfs_iomap_eof_align_last_fsb(ip, extsz, &last_fsb);
209
		if (error)
210
			goto out_unlock;
L
Linus Torvalds 已提交
211
	} else {
212
		if (nmaps && (imap->br_startblock == HOLESTARTBLOCK))
D
Dave Chinner 已提交
213
			last_fsb = min(last_fsb, (xfs_fileoff_t)
214 215
					imap->br_blockcount +
					imap->br_startoff);
L
Linus Torvalds 已提交
216
	}
217 218
	count_fsb = last_fsb - offset_fsb;
	ASSERT(count_fsb > 0);
219
	resaligned = xfs_aligned_fsb_count(offset_fsb, count_fsb, extsz);
220 221 222 223

	if (unlikely(rt)) {
		resrtextents = qblocks = resaligned;
		resrtextents /= mp->m_sb.sb_rextsize;
224 225 226 227
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
228
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
229 230
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
231

232 233 234 235 236
	/*
	 * Drop the shared lock acquired by the caller, attach the dquot if
	 * necessary and move on to transaction setup.
	 */
	xfs_iunlock(ip, lockmode);
237
	error = xfs_qm_dqattach(ip);
238 239 240
	if (error)
		return error;

241 242 243 244 245 246
	/*
	 * For DAX, we do not allocate unwritten extents, but instead we zero
	 * the block before we commit the transaction.  Ideally we'd like to do
	 * this outside the transaction context, but if we commit and then crash
	 * we may not have zeroed the blocks and this will be exposed on
	 * recovery of the allocation. Hence we must zero before commit.
247
	 *
248 249 250
	 * Further, if we are mapping unwritten extents here, we need to zero
	 * and convert them to written so that we don't need an unwritten extent
	 * callback for DAX. This also means that we need to be able to dip into
251 252
	 * the reserve block pool for bmbt block allocation if there is no space
	 * left but we need to do unwritten extent conversion.
253 254 255
	 */
	if (IS_DAX(VFS_I(ip))) {
		bmapi_flags = XFS_BMAPI_CONVERT | XFS_BMAPI_ZERO;
256
		if (imap->br_state == XFS_EXT_UNWRITTEN) {
257
			tflags |= XFS_TRANS_RESERVE;
258 259
			resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
		}
260
	}
261 262 263
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, resrtextents,
			tflags, &tp);
	if (error)
E
Eric Sandeen 已提交
264
		return error;
265

266 267
	lockmode = XFS_ILOCK_EXCL;
	xfs_ilock(ip, lockmode);
L
Linus Torvalds 已提交
268

C
Christoph Hellwig 已提交
269
	error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
270
	if (error)
271
		goto out_trans_cancel;
L
Linus Torvalds 已提交
272

273
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
274 275

	/*
276 277
	 * From this point onwards we overwrite the imap pointer that the
	 * caller gave to us.
L
Linus Torvalds 已提交
278
	 */
279
	nimaps = 1;
280
	error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
281
				bmapi_flags, resblks, imap, &nimaps);
282
	if (error)
283
		goto out_res_cancel;
L
Linus Torvalds 已提交
284 285

	/*
286
	 * Complete the transaction
L
Linus Torvalds 已提交
287
	 */
288
	error = xfs_trans_commit(tp);
289
	if (error)
290
		goto out_unlock;
L
Linus Torvalds 已提交
291

292 293 294
	/*
	 * Copy any maps to caller's array and return any error.
	 */
L
Linus Torvalds 已提交
295
	if (nimaps == 0) {
D
Dave Chinner 已提交
296
		error = -ENOSPC;
297
		goto out_unlock;
298 299
	}

300
	if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock)))
301
		error = xfs_alert_fsblock_zero(ip, imap);
L
Linus Torvalds 已提交
302

303
out_unlock:
304
	xfs_iunlock(ip, lockmode);
305
	return error;
L
Linus Torvalds 已提交
306

307
out_res_cancel:
308
	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
309
out_trans_cancel:
310
	xfs_trans_cancel(tp);
311
	goto out_unlock;
L
Linus Torvalds 已提交
312 313
}

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
STATIC bool
xfs_quota_need_throttle(
	struct xfs_inode *ip,
	int type,
	xfs_fsblock_t alloc_blocks)
{
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

	if (!dq || !xfs_this_quota_on(ip->i_mount, type))
		return false;

	/* no hi watermark, no throttle */
	if (!dq->q_prealloc_hi_wmark)
		return false;

	/* under the lo watermark, no throttle */
	if (dq->q_res_bcount + alloc_blocks < dq->q_prealloc_lo_wmark)
		return false;

	return true;
}

STATIC void
xfs_quota_calc_throttle(
	struct xfs_inode *ip,
	int type,
	xfs_fsblock_t *qblocks,
341 342
	int *qshift,
	int64_t	*qfreesp)
343 344 345 346 347
{
	int64_t freesp;
	int shift = 0;
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

348 349
	/* no dq, or over hi wmark, squash the prealloc completely */
	if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
350
		*qblocks = 0;
351
		*qfreesp = 0;
352 353 354 355 356 357 358 359 360 361 362 363
		return;
	}

	freesp = dq->q_prealloc_hi_wmark - dq->q_res_bcount;
	if (freesp < dq->q_low_space[XFS_QLOWSP_5_PCNT]) {
		shift = 2;
		if (freesp < dq->q_low_space[XFS_QLOWSP_3_PCNT])
			shift += 2;
		if (freesp < dq->q_low_space[XFS_QLOWSP_1_PCNT])
			shift += 2;
	}

364 365 366
	if (freesp < *qfreesp)
		*qfreesp = freesp;

367 368 369 370 371 372 373
	/* only overwrite the throttle values if we are more aggressive */
	if ((freesp >> shift) < (*qblocks >> *qshift)) {
		*qblocks = freesp;
		*qshift = shift;
	}
}

374
/*
375 376 377 378
 * If we are doing a write at the end of the file and there are no allocations
 * past this one, then extend the allocation out to the file system's write
 * iosize.
 *
379
 * If we don't have a user specified preallocation size, dynamically increase
380
 * the preallocation size as the size of the file grows.  Cap the maximum size
381 382
 * at a single extent or less if the filesystem is near full. The closer the
 * filesystem is to full, the smaller the maximum prealocation.
383 384 385 386 387 388 389 390
 *
 * As an exception we don't do any preallocation at all if the file is smaller
 * than the minimum preallocation and we are using the default dynamic
 * preallocation scheme, as it is likely this is the only write to the file that
 * is going to be done.
 *
 * We clean up any extra space left over when the file is closed in
 * xfs_inactive().
391 392 393
 */
STATIC xfs_fsblock_t
xfs_iomap_prealloc_size(
394
	struct xfs_inode	*ip,
395
	int			whichfork,
396 397
	loff_t			offset,
	loff_t			count,
398
	struct xfs_iext_cursor	*icur)
399
{
400
	struct xfs_mount	*mp = ip->i_mount;
401
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
402
	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
403
	struct xfs_bmbt_irec	prev;
404 405
	int			shift = 0;
	int64_t			freesp;
406 407
	xfs_fsblock_t		qblocks;
	int			qshift = 0;
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	xfs_fsblock_t		alloc_blocks = 0;

	if (offset + count <= XFS_ISIZE(ip))
		return 0;

	if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE) &&
	    (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_writeio_blocks)))
		return 0;

	/*
	 * If an explicit allocsize is set, the file is small, or we
	 * are writing behind a hole, then use the minimum prealloc:
	 */
	if ((mp->m_flags & XFS_MOUNT_DFLT_IOSIZE) ||
	    XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||
423
	    !xfs_iext_peek_prev_extent(ifp, icur, &prev) ||
424
	    prev.br_startoff + prev.br_blockcount < offset_fsb)
425
		return mp->m_writeio_blocks;
426

427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
	/*
	 * Determine the initial size of the preallocation. We are beyond the
	 * current EOF here, but we need to take into account whether this is
	 * a sparse write or an extending write when determining the
	 * preallocation size.  Hence we need to look up the extent that ends
	 * at the current write offset and use the result to determine the
	 * preallocation size.
	 *
	 * If the extent is a hole, then preallocation is essentially disabled.
	 * Otherwise we take the size of the preceding data extent as the basis
	 * for the preallocation size. If the size of the extent is greater than
	 * half the maximum extent length, then use the current offset as the
	 * basis. This ensures that for large files the preallocation size
	 * always extends to MAXEXTLEN rather than falling short due to things
	 * like stripe unit/width alignment of real extents.
	 */
443 444
	if (prev.br_blockcount <= (MAXEXTLEN >> 1))
		alloc_blocks = prev.br_blockcount << 1;
445 446
	else
		alloc_blocks = XFS_B_TO_FSB(mp, offset);
447 448
	if (!alloc_blocks)
		goto check_writeio;
449
	qblocks = alloc_blocks;
450

451 452 453 454 455 456 457 458 459
	/*
	 * MAXEXTLEN is not a power of two value but we round the prealloc down
	 * to the nearest power of two value after throttling. To prevent the
	 * round down from unconditionally reducing the maximum supported prealloc
	 * size, we round up first, apply appropriate throttling, round down and
	 * cap the value to MAXEXTLEN.
	 */
	alloc_blocks = XFS_FILEOFF_MIN(roundup_pow_of_two(MAXEXTLEN),
				       alloc_blocks);
460

461
	freesp = percpu_counter_read_positive(&mp->m_fdblocks);
462 463 464 465 466 467 468 469 470 471
	if (freesp < mp->m_low_space[XFS_LOWSP_5_PCNT]) {
		shift = 2;
		if (freesp < mp->m_low_space[XFS_LOWSP_4_PCNT])
			shift++;
		if (freesp < mp->m_low_space[XFS_LOWSP_3_PCNT])
			shift++;
		if (freesp < mp->m_low_space[XFS_LOWSP_2_PCNT])
			shift++;
		if (freesp < mp->m_low_space[XFS_LOWSP_1_PCNT])
			shift++;
472
	}
473 474

	/*
475 476
	 * Check each quota to cap the prealloc size, provide a shift value to
	 * throttle with and adjust amount of available space.
477 478
	 */
	if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
479 480
		xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
					&freesp);
481
	if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
482 483
		xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
					&freesp);
484
	if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
485 486
		xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
					&freesp);
487 488 489 490 491 492 493 494

	/*
	 * The final prealloc size is set to the minimum of free space available
	 * in each of the quotas and the overall filesystem.
	 *
	 * The shift throttle value is set to the maximum value as determined by
	 * the global low free space values and per-quota low free space values.
	 */
D
Dave Chinner 已提交
495 496
	alloc_blocks = min(alloc_blocks, qblocks);
	shift = max(shift, qshift);
497

498 499
	if (shift)
		alloc_blocks >>= shift;
500 501 502 503 504 505 506 507
	/*
	 * rounddown_pow_of_two() returns an undefined result if we pass in
	 * alloc_blocks = 0.
	 */
	if (alloc_blocks)
		alloc_blocks = rounddown_pow_of_two(alloc_blocks);
	if (alloc_blocks > MAXEXTLEN)
		alloc_blocks = MAXEXTLEN;
508 509 510 511 512 513 514 515 516 517

	/*
	 * If we are still trying to allocate more space than is
	 * available, squash the prealloc hard. This can happen if we
	 * have a large file on a small filesystem and the above
	 * lowspace thresholds are smaller than MAXEXTLEN.
	 */
	while (alloc_blocks && alloc_blocks >= freesp)
		alloc_blocks >>= 4;
check_writeio:
518 519
	if (alloc_blocks < mp->m_writeio_blocks)
		alloc_blocks = mp->m_writeio_blocks;
520 521
	trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
				      mp->m_writeio_blocks);
522 523 524
	return alloc_blocks;
}

525 526 527 528 529
static int
xfs_file_iomap_begin_delay(
	struct inode		*inode,
	loff_t			offset,
	loff_t			count,
530
	unsigned		flags,
531
	struct iomap		*iomap)
L
Linus Torvalds 已提交
532
{
533 534 535 536 537
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
	xfs_fileoff_t		maxbytes_fsb =
		XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
538
	xfs_fileoff_t		end_fsb;
539 540
	struct xfs_bmbt_irec	imap, cmap;
	struct xfs_iext_cursor	icur, ccur;
541
	xfs_fsblock_t		prealloc_blocks = 0;
542
	bool			eof = false, cow_eof = false, shared = false;
543 544
	int			whichfork = XFS_DATA_FORK;
	int			error = 0;
545 546 547

	ASSERT(!XFS_IS_REALTIME_INODE(ip));
	ASSERT(!xfs_get_extsz_hint(ip));
548

549
	xfs_ilock(ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
550

551 552 553
	if (unlikely(XFS_TEST_ERROR(
	    (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS &&
	     XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE),
554
	     mp, XFS_ERRTAG_BMAPIFORMAT))) {
555 556 557 558
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
		error = -EFSCORRUPTED;
		goto out_unlock;
	}
559

560
	XFS_STATS_INC(mp, xs_blk_mapw);
561

562
	if (!(ip->i_df.if_flags & XFS_IFEXTENTS)) {
563 564 565
		error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
		if (error)
			goto out_unlock;
L
Linus Torvalds 已提交
566 567
	}

568 569
	end_fsb = min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);

570 571 572 573 574 575 576
	/*
	 * Search the data fork fork first to look up our source mapping.  We
	 * always need the data fork map, as we have to return it to the
	 * iomap code so that the higher level write code can read data in to
	 * perform read-modify-write cycles for unaligned writes.
	 */
	eof = !xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap);
577
	if (eof)
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
		imap.br_startoff = end_fsb; /* fake hole until the end */

	/* We never need to allocate blocks for zeroing a hole. */
	if ((flags & IOMAP_ZERO) && imap.br_startoff > offset_fsb) {
		xfs_hole_to_iomap(ip, iomap, offset_fsb, imap.br_startoff);
		goto out_unlock;
	}

	/*
	 * Search the COW fork extent list even if we did not find a data fork
	 * extent.  This serves two purposes: first this implements the
	 * speculative preallocation using cowextsize, so that we also unshare
	 * block adjacent to shared blocks instead of just the shared blocks
	 * themselves.  Second the lookup in the extent list is generally faster
	 * than going out to the shared extent tree.
	 */
594 595 596 597 598
	if (xfs_is_cow_inode(ip)) {
		if (!ip->i_cowfp) {
			ASSERT(!xfs_is_reflink_inode(ip));
			xfs_ifork_init_cow(ip);
		}
599 600 601 602 603 604 605 606
		cow_eof = !xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb,
				&ccur, &cmap);
		if (!cow_eof && cmap.br_startoff <= offset_fsb) {
			trace_xfs_reflink_cow_found(ip, &cmap);
			whichfork = XFS_COW_FORK;
			goto done;
		}
	}
607

608
	if (imap.br_startoff <= offset_fsb) {
609 610 611 612 613
		/*
		 * For reflink files we may need a delalloc reservation when
		 * overwriting shared extents.   This includes zeroing of
		 * existing extents that contain data.
		 */
614
		if (!xfs_is_cow_inode(ip) ||
615 616 617 618
		    ((flags & IOMAP_ZERO) && imap.br_state != XFS_EXT_NORM)) {
			trace_xfs_iomap_found(ip, offset, count, XFS_DATA_FORK,
					&imap);
			goto done;
619 620
		}

621
		xfs_trim_extent(&imap, offset_fsb, end_fsb - offset_fsb);
622

623
		/* Trim the mapping to the nearest shared extent boundary. */
624
		error = xfs_inode_need_cow(ip, &imap, &shared);
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
		if (error)
			goto out_unlock;

		/* Not shared?  Just report the (potentially capped) extent. */
		if (!shared) {
			trace_xfs_iomap_found(ip, offset, count, XFS_DATA_FORK,
					&imap);
			goto done;
		}

		/*
		 * Fork all the shared blocks from our write offset until the
		 * end of the extent.
		 */
		whichfork = XFS_COW_FORK;
		end_fsb = imap.br_startoff + imap.br_blockcount;
	} else {
		/*
		 * We cap the maximum length we map here to MAX_WRITEBACK_PAGES
		 * pages to keep the chunks of work done where somewhat
		 * symmetric with the work writeback does.  This is a completely
		 * arbitrary number pulled out of thin air.
		 *
		 * Note that the values needs to be less than 32-bits wide until
		 * the lower level functions are updated.
		 */
		count = min_t(loff_t, count, 1024 * PAGE_SIZE);
		end_fsb = min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);
653 654 655

		if (xfs_is_always_cow_inode(ip))
			whichfork = XFS_COW_FORK;
656 657
	}

658
	error = xfs_qm_dqattach_locked(ip, false);
659 660 661
	if (error)
		goto out_unlock;

662 663 664
	if (eof) {
		prealloc_blocks = xfs_iomap_prealloc_size(ip, whichfork, offset,
				count, &icur);
665 666 667
		if (prealloc_blocks) {
			xfs_extlen_t	align;
			xfs_off_t	end_offset;
668
			xfs_fileoff_t	p_end_fsb;
669

670
			end_offset = XFS_WRITEIO_ALIGN(mp, offset + count - 1);
671 672
			p_end_fsb = XFS_B_TO_FSBT(mp, end_offset) +
					prealloc_blocks;
673 674 675

			align = xfs_eof_alignment(ip, 0);
			if (align)
676
				p_end_fsb = roundup_64(p_end_fsb, align);
677

678 679 680
			p_end_fsb = min(p_end_fsb, maxbytes_fsb);
			ASSERT(p_end_fsb > offset_fsb);
			prealloc_blocks = p_end_fsb - end_fsb;
681 682 683 684
		}
	}

retry:
685 686 687 688 689
	error = xfs_bmapi_reserve_delalloc(ip, whichfork, offset_fsb,
			end_fsb - offset_fsb, prealloc_blocks,
			whichfork == XFS_DATA_FORK ? &imap : &cmap,
			whichfork == XFS_DATA_FORK ? &icur : &ccur,
			whichfork == XFS_DATA_FORK ? eof : cow_eof);
690 691
	switch (error) {
	case 0:
692
		break;
D
Dave Chinner 已提交
693 694
	case -ENOSPC:
	case -EDQUOT:
695
		/* retry without any preallocation */
C
Christoph Hellwig 已提交
696
		trace_xfs_delalloc_enospc(ip, offset, count);
697 698
		if (prealloc_blocks) {
			prealloc_blocks = 0;
D
Dave Chinner 已提交
699
			goto retry;
700
		}
701 702 703
		/*FALLTHRU*/
	default:
		goto out_unlock;
L
Linus Torvalds 已提交
704 705
	}

706 707 708 709
	/*
	 * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
	 * them out if the write happens to fail.
	 */
710
	iomap->flags |= IOMAP_F_NEW;
711 712
	trace_xfs_iomap_alloc(ip, offset, count, whichfork,
			whichfork == XFS_DATA_FORK ? &imap : &cmap);
713
done:
714 715 716 717
	if (whichfork == XFS_COW_FORK) {
		if (imap.br_startoff > offset_fsb) {
			xfs_trim_extent(&cmap, offset_fsb,
					imap.br_startoff - offset_fsb);
718
			error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
719 720 721 722
			goto out_unlock;
		}
		/* ensure we only report blocks we have a reservation for */
		xfs_trim_extent(&imap, cmap.br_startoff, cmap.br_blockcount);
723
		shared = true;
724
	}
725
	error = xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
726 727 728
out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return error;
L
Linus Torvalds 已提交
729 730 731 732 733
}

int
xfs_iomap_write_unwritten(
	xfs_inode_t	*ip,
734
	xfs_off_t	offset,
735 736
	xfs_off_t	count,
	bool		update_isize)
L
Linus Torvalds 已提交
737 738 739 740 741
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_filblks_t	count_fsb;
	xfs_filblks_t	numblks_fsb;
742 743 744
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
745
	struct inode	*inode = VFS_I(ip);
746
	xfs_fsize_t	i_size;
747
	uint		resblks;
L
Linus Torvalds 已提交
748 749
	int		error;

C
Christoph Hellwig 已提交
750
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
751 752 753 754 755

	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	count_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
	count_fsb = (xfs_filblks_t)(count_fsb - offset_fsb);

756 757 758 759 760 761 762 763 764 765
	/*
	 * Reserve enough blocks in this transaction for two complete extent
	 * btree splits.  We may be converting the middle part of an unwritten
	 * extent and in this case we will insert two new extents in the btree
	 * each of which could cause a full split.
	 *
	 * This reservation amount will be used in the first call to
	 * xfs_bmbt_split() to select an AG with enough space to satisfy the
	 * rest of the operation.
	 */
766
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
767

768
	do {
L
Linus Torvalds 已提交
769
		/*
770
		 * Set up a transaction to convert the range of extents
L
Linus Torvalds 已提交
771 772
		 * from unwritten to real. Do allocations in a loop until
		 * we have covered the range passed in.
773
		 *
774 775 776
		 * Note that we can't risk to recursing back into the filesystem
		 * here as we might be asked to write out the same inode that we
		 * complete here and might deadlock on the iolock.
L
Linus Torvalds 已提交
777
		 */
778
		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
C
Christoph Hellwig 已提交
779
				XFS_TRANS_RESERVE, &tp);
780
		if (error)
E
Eric Sandeen 已提交
781
			return error;
L
Linus Torvalds 已提交
782 783

		xfs_ilock(ip, XFS_ILOCK_EXCL);
784
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
785 786 787 788 789

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
		nimaps = 1;
790
		error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
791 792
					XFS_BMAPI_CONVERT, resblks, &imap,
					&nimaps);
L
Linus Torvalds 已提交
793 794 795
		if (error)
			goto error_on_bmapi_transaction;

796 797 798 799 800 801 802 803
		/*
		 * Log the updated inode size as we go.  We have to be careful
		 * to only log it up to the actual write offset if it is
		 * halfway into a block.
		 */
		i_size = XFS_FSB_TO_B(mp, offset_fsb + count_fsb);
		if (i_size > offset + count)
			i_size = offset + count;
804 805
		if (update_isize && i_size > i_size_read(inode))
			i_size_write(inode, i_size);
806 807 808 809 810 811
		i_size = xfs_new_eof(ip, i_size);
		if (i_size) {
			ip->i_d.di_size = i_size;
			xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
		}

812
		error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
813 814
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
E
Eric Sandeen 已提交
815
			return error;
816

817
		if (unlikely(!xfs_valid_startblock(ip, imap.br_startblock)))
818
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834

		if ((numblks_fsb = imap.br_blockcount) == 0) {
			/*
			 * The numblks_fsb value should always get
			 * smaller, otherwise the loop is stuck.
			 */
			ASSERT(imap.br_blockcount);
			break;
		}
		offset_fsb += numblks_fsb;
		count_fsb -= numblks_fsb;
	} while (count_fsb > 0);

	return 0;

error_on_bmapi_transaction:
835
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
836
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
837
	return error;
L
Linus Torvalds 已提交
838
}
839

840 841 842 843 844
static inline bool
imap_needs_alloc(
	struct inode		*inode,
	struct xfs_bmbt_irec	*imap,
	int			nimaps)
845 846 847
{
	return !nimaps ||
		imap->br_startblock == HOLESTARTBLOCK ||
848
		imap->br_startblock == DELAYSTARTBLOCK ||
849
		(IS_DAX(inode) && imap->br_state == XFS_EXT_UNWRITTEN);
850 851
}

852 853 854 855
static inline bool
needs_cow_for_zeroing(
	struct xfs_bmbt_irec	*imap,
	int			nimaps)
856 857 858 859 860 861
{
	return nimaps &&
		imap->br_startblock != HOLESTARTBLOCK &&
		imap->br_state != XFS_EXT_UNWRITTEN;
}

862 863 864 865 866
static int
xfs_ilock_for_iomap(
	struct xfs_inode	*ip,
	unsigned		flags,
	unsigned		*lockmode)
C
Christoph Hellwig 已提交
867
{
868
	unsigned		mode = XFS_ILOCK_SHARED;
869
	bool			is_write = flags & (IOMAP_WRITE | IOMAP_ZERO);
870

C
Christoph Hellwig 已提交
871
	/*
872 873
	 * COW writes may allocate delalloc space or convert unwritten COW
	 * extents, so we need to make sure to take the lock exclusively here.
C
Christoph Hellwig 已提交
874
	 */
875
	if (xfs_is_cow_inode(ip) && is_write) {
876 877 878 879 880 881 882 883
		/*
		 * FIXME: It could still overwrite on unshared extents and not
		 * need allocation.
		 */
		if (flags & IOMAP_NOWAIT)
			return -EAGAIN;
		mode = XFS_ILOCK_EXCL;
	}
884 885

	/*
886 887
	 * Extents not yet cached requires exclusive access, don't block.  This
	 * is an opencoded xfs_ilock_data_map_shared() call but with
888 889
	 * non-blocking behaviour.
	 */
890 891 892 893 894 895
	if (!(ip->i_df.if_flags & XFS_IFEXTENTS)) {
		if (flags & IOMAP_NOWAIT)
			return -EAGAIN;
		mode = XFS_ILOCK_EXCL;
	}

896
relock:
897 898 899 900 901 902 903
	if (flags & IOMAP_NOWAIT) {
		if (!xfs_ilock_nowait(ip, mode))
			return -EAGAIN;
	} else {
		xfs_ilock(ip, mode);
	}

904 905 906 907 908
	/*
	 * The reflink iflag could have changed since the earlier unlocked
	 * check, so if we got ILOCK_SHARED for a write and but we're now a
	 * reflink inode we have to switch to ILOCK_EXCL and relock.
	 */
909
	if (mode == XFS_ILOCK_SHARED && is_write && xfs_is_cow_inode(ip)) {
910 911 912 913 914
		xfs_iunlock(ip, mode);
		mode = XFS_ILOCK_EXCL;
		goto relock;
	}

915 916
	*lockmode = mode;
	return 0;
C
Christoph Hellwig 已提交
917 918
}

919 920 921 922 923 924 925 926 927 928 929 930 931
static int
xfs_file_iomap_begin(
	struct inode		*inode,
	loff_t			offset,
	loff_t			length,
	unsigned		flags,
	struct iomap		*iomap)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_bmbt_irec	imap;
	xfs_fileoff_t		offset_fsb, end_fsb;
	int			nimaps = 1, error = 0;
932
	bool			shared = false;
933
	unsigned		lockmode;
934 935 936 937

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

938
	if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && !(flags & IOMAP_DIRECT) &&
C
Christoph Hellwig 已提交
939
			!IS_DAX(inode) && !xfs_get_extsz_hint(ip)) {
940
		/* Reserve delalloc blocks for regular writeback. */
941 942
		return xfs_file_iomap_begin_delay(inode, offset, length, flags,
				iomap);
943 944
	}

945 946 947 948 949 950 951 952 953
	/*
	 * Lock the inode in the manner required for the specified operation and
	 * check for as many conditions that would result in blocking as
	 * possible. This removes most of the non-blocking checks from the
	 * mapping code below.
	 */
	error = xfs_ilock_for_iomap(ip, flags, &lockmode);
	if (error)
		return error;
G
Goldwyn Rodrigues 已提交
954

955
	ASSERT(offset <= mp->m_super->s_maxbytes);
956
	if (offset > mp->m_super->s_maxbytes - length)
957 958 959 960 961
		length = mp->m_super->s_maxbytes - offset;
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	end_fsb = XFS_B_TO_FSB(mp, offset + length);

	error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
962
			       &nimaps, 0);
963 964
	if (error)
		goto out_unlock;
965

966
	if (flags & IOMAP_REPORT) {
967
		/* Trim the mapping to the nearest shared extent boundary. */
968
		error = xfs_reflink_trim_around_shared(ip, &imap, &shared);
969 970 971 972
		if (error)
			goto out_unlock;
	}

973 974 975 976
	/* Non-modifying mapping requested, so we are done */
	if (!(flags & (IOMAP_WRITE | IOMAP_ZERO)))
		goto out_found;

977 978 979 980
	/*
	 * Break shared extents if necessary. Checks for non-blocking IO have
	 * been done up front, so we don't need to do them here.
	 */
981
	if (xfs_is_cow_inode(ip)) {
982
		struct xfs_bmbt_irec	cmap;
983
		bool			directio = (flags & IOMAP_DIRECT);
984

985 986 987 988 989
		/* if zeroing doesn't need COW allocation, then we are done. */
		if ((flags & IOMAP_ZERO) &&
		    !needs_cow_for_zeroing(&imap, nimaps))
			goto out_found;

990
		/* may drop and re-acquire the ilock */
991 992
		cmap = imap;
		error = xfs_reflink_allocate_cow(ip, &cmap, &shared, &lockmode,
993
				directio);
994 995 996 997 998 999
		if (error)
			goto out_unlock;

		/*
		 * For buffered writes we need to report the address of the
		 * previous block (if there was any) so that the higher level
1000 1001 1002
		 * write code can perform read-modify-write operations; we
		 * won't need the CoW fork mapping until writeback.  For direct
		 * I/O, which must be block aligned, we need to report the
1003 1004
		 * newly allocated address.  If the data fork has a hole, copy
		 * the COW fork mapping to avoid allocating to the data fork.
1005
		 */
1006 1007
		if (directio || imap.br_startblock == HOLESTARTBLOCK)
			imap = cmap;
1008 1009 1010

		end_fsb = imap.br_startoff + imap.br_blockcount;
		length = XFS_FSB_TO_B(mp, end_fsb) - offset;
1011 1012
	}

1013 1014 1015
	/* Don't need to allocate over holes when doing zeroing operations. */
	if (flags & IOMAP_ZERO)
		goto out_found;
1016

1017 1018
	if (!imap_needs_alloc(inode, &imap, nimaps))
		goto out_found;
1019

1020 1021 1022 1023
	/* If nowait is set bail since we are going to make allocations. */
	if (flags & IOMAP_NOWAIT) {
		error = -EAGAIN;
		goto out_unlock;
1024 1025
	}

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	/*
	 * We cap the maximum length we map to a sane size  to keep the chunks
	 * of work done where somewhat symmetric with the work writeback does.
	 * This is a completely arbitrary number pulled out of thin air as a
	 * best guess for initial testing.
	 *
	 * Note that the values needs to be less than 32-bits wide until the
	 * lower level functions are updated.
	 */
	length = min_t(loff_t, length, 1024 * PAGE_SIZE);

	/*
	 * xfs_iomap_write_direct() expects the shared lock. It is unlocked on
	 * return.
	 */
	if (lockmode == XFS_ILOCK_EXCL)
		xfs_ilock_demote(ip, lockmode);
	error = xfs_iomap_write_direct(ip, offset, length, &imap,
			nimaps);
	if (error)
		return error;

1048
	iomap->flags |= IOMAP_F_NEW;
1049
	trace_xfs_iomap_alloc(ip, offset, length, XFS_DATA_FORK, &imap);
1050 1051

out_finish:
1052 1053 1054 1055 1056 1057 1058
	/*
	 * Writes that span EOF might trigger an IO size update on completion,
	 * so consider them to be dirty for the purposes of O_DSYNC even if
	 * there is no other metadata changes pending or have been made here.
	 */
	if ((flags & IOMAP_WRITE) && offset + length > i_size_read(inode))
		iomap->flags |= IOMAP_F_DIRTY;
1059
	return xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
1060 1061 1062 1063

out_found:
	ASSERT(nimaps);
	xfs_iunlock(ip, lockmode);
1064
	trace_xfs_iomap_found(ip, offset, length, XFS_DATA_FORK, &imap);
1065 1066
	goto out_finish;

1067 1068 1069
out_unlock:
	xfs_iunlock(ip, lockmode);
	return error;
1070 1071 1072 1073 1074 1075 1076
}

static int
xfs_file_iomap_end_delalloc(
	struct xfs_inode	*ip,
	loff_t			offset,
	loff_t			length,
1077 1078
	ssize_t			written,
	struct iomap		*iomap)
1079 1080 1081 1082 1083 1084
{
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fileoff_t		start_fsb;
	xfs_fileoff_t		end_fsb;
	int			error = 0;

1085 1086 1087 1088
	/*
	 * Behave as if the write failed if drop writes is enabled. Set the NEW
	 * flag to force delalloc cleanup.
	 */
1089
	if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DROP_WRITES)) {
1090
		iomap->flags |= IOMAP_F_NEW;
1091
		written = 0;
1092
	}
1093

1094 1095 1096 1097 1098 1099 1100 1101 1102
	/*
	 * start_fsb refers to the first unused block after a short write. If
	 * nothing was written, round offset down to point at the first block in
	 * the range.
	 */
	if (unlikely(!written))
		start_fsb = XFS_B_TO_FSBT(mp, offset);
	else
		start_fsb = XFS_B_TO_FSB(mp, offset + written);
1103 1104 1105
	end_fsb = XFS_B_TO_FSB(mp, offset + length);

	/*
1106 1107
	 * Trim delalloc blocks if they were allocated by this write and we
	 * didn't manage to write the whole range.
1108 1109 1110 1111 1112
	 *
	 * We don't need to care about racing delalloc as we hold i_mutex
	 * across the reserve/allocate/unreserve calls. If there are delalloc
	 * blocks in the range, they are ours.
	 */
1113
	if ((iomap->flags & IOMAP_F_NEW) && start_fsb < end_fsb) {
1114 1115 1116
		truncate_pagecache_range(VFS_I(ip), XFS_FSB_TO_B(mp, start_fsb),
					 XFS_FSB_TO_B(mp, end_fsb) - 1);

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
		error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
					       end_fsb - start_fsb);
		if (error && !XFS_FORCED_SHUTDOWN(mp)) {
			xfs_alert(mp, "%s: unable to clean up ino %lld",
				__func__, ip->i_ino);
			return error;
		}
	}

	return 0;
}

static int
xfs_file_iomap_end(
	struct inode		*inode,
	loff_t			offset,
	loff_t			length,
	ssize_t			written,
	unsigned		flags,
	struct iomap		*iomap)
{
	if ((flags & IOMAP_WRITE) && iomap->type == IOMAP_DELALLOC)
		return xfs_file_iomap_end_delalloc(XFS_I(inode), offset,
1140
				length, written, iomap);
1141 1142 1143
	return 0;
}

1144
const struct iomap_ops xfs_iomap_ops = {
1145 1146 1147
	.iomap_begin		= xfs_file_iomap_begin,
	.iomap_end		= xfs_file_iomap_end,
};
1148

1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
static int
xfs_seek_iomap_begin(
	struct inode		*inode,
	loff_t			offset,
	loff_t			length,
	unsigned		flags,
	struct iomap		*iomap)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
	xfs_fileoff_t		end_fsb = XFS_B_TO_FSB(mp, offset + length);
	xfs_fileoff_t		cow_fsb = NULLFILEOFF, data_fsb = NULLFILEOFF;
	struct xfs_iext_cursor	icur;
	struct xfs_bmbt_irec	imap, cmap;
	int			error = 0;
	unsigned		lockmode;

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

	lockmode = xfs_ilock_data_map_shared(ip);
	if (!(ip->i_df.if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
		if (error)
			goto out_unlock;
	}

	if (xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap)) {
		/*
		 * If we found a data extent we are done.
		 */
		if (imap.br_startoff <= offset_fsb)
			goto done;
		data_fsb = imap.br_startoff;
	} else {
		/*
		 * Fake a hole until the end of the file.
		 */
		data_fsb = min(XFS_B_TO_FSB(mp, offset + length),
			       XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes));
	}

	/*
	 * If a COW fork extent covers the hole, report it - capped to the next
	 * data fork extent:
	 */
	if (xfs_inode_has_cow_data(ip) &&
	    xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &cmap))
		cow_fsb = cmap.br_startoff;
	if (cow_fsb != NULLFILEOFF && cow_fsb <= offset_fsb) {
		if (data_fsb < cow_fsb + cmap.br_blockcount)
			end_fsb = min(end_fsb, data_fsb);
		xfs_trim_extent(&cmap, offset_fsb, end_fsb);
		error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
		/*
		 * This is a COW extent, so we must probe the page cache
		 * because there could be dirty page cache being backed
		 * by this extent.
		 */
		iomap->type = IOMAP_UNWRITTEN;
		goto out_unlock;
	}

	/*
	 * Else report a hole, capped to the next found data or COW extent.
	 */
	if (cow_fsb != NULLFILEOFF && cow_fsb < data_fsb)
		imap.br_blockcount = cow_fsb - offset_fsb;
	else
		imap.br_blockcount = data_fsb - offset_fsb;
	imap.br_startoff = offset_fsb;
	imap.br_startblock = HOLESTARTBLOCK;
	imap.br_state = XFS_EXT_NORM;
done:
	xfs_trim_extent(&imap, offset_fsb, end_fsb);
	error = xfs_bmbt_to_iomap(ip, iomap, &imap, false);
out_unlock:
	xfs_iunlock(ip, lockmode);
	return error;
}

const struct iomap_ops xfs_seek_iomap_ops = {
	.iomap_begin		= xfs_seek_iomap_begin,
};

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
static int
xfs_xattr_iomap_begin(
	struct inode		*inode,
	loff_t			offset,
	loff_t			length,
	unsigned		flags,
	struct iomap		*iomap)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
	xfs_fileoff_t		end_fsb = XFS_B_TO_FSB(mp, offset + length);
	struct xfs_bmbt_irec	imap;
	int			nimaps = 1, error = 0;
	unsigned		lockmode;

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

1254
	lockmode = xfs_ilock_attr_map_shared(ip);
1255 1256

	/* if there are no attribute fork or extents, return ENOENT */
1257
	if (!XFS_IFORK_Q(ip) || !ip->i_d.di_anextents) {
1258 1259 1260 1261 1262 1263
		error = -ENOENT;
		goto out_unlock;
	}

	ASSERT(ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL);
	error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
1264
			       &nimaps, XFS_BMAPI_ATTRFORK);
1265 1266 1267
out_unlock:
	xfs_iunlock(ip, lockmode);

1268 1269 1270 1271
	if (error)
		return error;
	ASSERT(nimaps);
	return xfs_bmbt_to_iomap(ip, iomap, &imap, false);
1272 1273
}

1274
const struct iomap_ops xfs_xattr_iomap_ops = {
1275 1276
	.iomap_begin		= xfs_xattr_iomap_begin,
};