xfs_iomap.c 32.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3
 * Copyright (c) 2016 Christoph Hellwig.
4
 * All Rights Reserved.
L
Linus Torvalds 已提交
5
 *
6 7
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
8 9
 * published by the Free Software Foundation.
 *
10 11 12 13
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
14
 *
15 16 17
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
18
 */
19
#include <linux/iomap.h>
L
Linus Torvalds 已提交
20 21
#include "xfs.h"
#include "xfs_fs.h"
22
#include "xfs_shared.h"
23 24 25
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
26
#include "xfs_mount.h"
27
#include "xfs_defer.h"
L
Linus Torvalds 已提交
28
#include "xfs_inode.h"
29
#include "xfs_btree.h"
30
#include "xfs_bmap_btree.h"
L
Linus Torvalds 已提交
31
#include "xfs_bmap.h"
D
Dave Chinner 已提交
32
#include "xfs_bmap_util.h"
L
Linus Torvalds 已提交
33
#include "xfs_error.h"
34
#include "xfs_trans.h"
L
Linus Torvalds 已提交
35 36
#include "xfs_trans_space.h"
#include "xfs_iomap.h"
C
Christoph Hellwig 已提交
37
#include "xfs_trace.h"
38
#include "xfs_icache.h"
39
#include "xfs_quota.h"
40 41
#include "xfs_dquot_item.h"
#include "xfs_dquot.h"
42
#include "xfs_reflink.h"
L
Linus Torvalds 已提交
43 44 45 46 47


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

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
void
xfs_bmbt_to_iomap(
	struct xfs_inode	*ip,
	struct iomap		*iomap,
	struct xfs_bmbt_irec	*imap)
{
	struct xfs_mount	*mp = ip->i_mount;

	if (imap->br_startblock == HOLESTARTBLOCK) {
		iomap->blkno = IOMAP_NULL_BLOCK;
		iomap->type = IOMAP_HOLE;
	} else if (imap->br_startblock == DELAYSTARTBLOCK) {
		iomap->blkno = IOMAP_NULL_BLOCK;
		iomap->type = IOMAP_DELALLOC;
	} else {
		iomap->blkno = xfs_fsb_to_db(ip, imap->br_startblock);
		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));
}

74
xfs_extlen_t
75 76 77
xfs_eof_alignment(
	struct xfs_inode	*ip,
	xfs_extlen_t		extsize)
78
{
79 80
	struct xfs_mount	*mp = ip->i_mount;
	xfs_extlen_t		align = 0;
81

82 83 84 85 86 87 88 89 90 91 92 93 94 95
	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;

96 97
		if (align && XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, align))
			align = 0;
98
	}
99 100 101 102 103 104

	/*
	 * Always round up the allocation request to an extent boundary
	 * (when file on a real-time subvolume or has di_extsize hint).
	 */
	if (extsize) {
105 106
		if (align)
			align = roundup_64(align, extsize);
107 108 109 110
		else
			align = extsize;
	}

111 112 113 114 115 116 117 118 119 120 121
	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);

122 123
	if (align) {
		xfs_fileoff_t	new_last_fsb = roundup_64(*last_fsb, align);
124 125
		int		eof, error;

126
		error = xfs_bmap_eof(ip, new_last_fsb, XFS_DATA_FORK, &eof);
127 128 129 130 131 132 133 134
		if (error)
			return error;
		if (eof)
			*last_fsb = new_last_fsb;
	}
	return 0;
}

135
STATIC int
136
xfs_alert_fsblock_zero(
137 138 139
	xfs_inode_t	*ip,
	xfs_bmbt_irec_t	*imap)
{
140
	xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
141 142
			"Access to block zero in inode %llu "
			"start_block: %llx start_off: %llx "
143
			"blkcnt: %llx extent-state: %x",
144 145 146 147 148
		(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);
D
Dave Chinner 已提交
149
	return -EFSCORRUPTED;
150 151
}

C
Christoph Hellwig 已提交
152
int
L
Linus Torvalds 已提交
153 154
xfs_iomap_write_direct(
	xfs_inode_t	*ip,
155
	xfs_off_t	offset,
L
Linus Torvalds 已提交
156
	size_t		count,
157
	xfs_bmbt_irec_t *imap,
158
	int		nmaps)
L
Linus Torvalds 已提交
159 160 161 162
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
163
	xfs_filblks_t	count_fsb, resaligned;
L
Linus Torvalds 已提交
164
	xfs_fsblock_t	firstfsb;
165
	xfs_extlen_t	extsz;
166
	int		nimaps;
167
	int		quota_flag;
L
Linus Torvalds 已提交
168 169
	int		rt;
	xfs_trans_t	*tp;
170
	struct xfs_defer_ops dfops;
171 172
	uint		qblocks, resblks, resrtextents;
	int		error;
173
	int		lockmode;
174
	int		bmapi_flags = XFS_BMAPI_PREALLOC;
175
	uint		tflags = 0;
L
Linus Torvalds 已提交
176

177
	rt = XFS_IS_REALTIME_INODE(ip);
178
	extsz = xfs_get_extsz_hint(ip);
179 180 181
	lockmode = XFS_ILOCK_SHARED;	/* locked by caller */

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

183 184
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
185
	if ((offset + count) > XFS_ISIZE(ip)) {
186 187 188 189 190 191 192 193 194
		/*
		 * 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);
195
		error = xfs_iomap_eof_align_last_fsb(ip, extsz, &last_fsb);
196
		if (error)
197
			goto out_unlock;
L
Linus Torvalds 已提交
198
	} else {
199
		if (nmaps && (imap->br_startblock == HOLESTARTBLOCK))
200
			last_fsb = MIN(last_fsb, (xfs_fileoff_t)
201 202
					imap->br_blockcount +
					imap->br_startoff);
L
Linus Torvalds 已提交
203
	}
204 205
	count_fsb = last_fsb - offset_fsb;
	ASSERT(count_fsb > 0);
206
	resaligned = xfs_aligned_fsb_count(offset_fsb, count_fsb, extsz);
207 208 209 210

	if (unlikely(rt)) {
		resrtextents = qblocks = resaligned;
		resrtextents /= mp->m_sb.sb_rextsize;
211 212 213 214
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
215
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
216 217
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
218

219 220 221 222 223 224 225 226 227
	/*
	 * Drop the shared lock acquired by the caller, attach the dquot if
	 * necessary and move on to transaction setup.
	 */
	xfs_iunlock(ip, lockmode);
	error = xfs_qm_dqattach(ip, 0);
	if (error)
		return error;

228 229 230 231 232 233
	/*
	 * 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.
234
	 *
235 236 237
	 * 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
238 239
	 * the reserve block pool for bmbt block allocation if there is no space
	 * left but we need to do unwritten extent conversion.
240 241 242
	 */
	if (IS_DAX(VFS_I(ip))) {
		bmapi_flags = XFS_BMAPI_CONVERT | XFS_BMAPI_ZERO;
243
		if (ISUNWRITTEN(imap)) {
244
			tflags |= XFS_TRANS_RESERVE;
245 246
			resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
		}
247
	}
248 249 250
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, resrtextents,
			tflags, &tp);
	if (error)
E
Eric Sandeen 已提交
251
		return error;
252

253 254
	lockmode = XFS_ILOCK_EXCL;
	xfs_ilock(ip, lockmode);
L
Linus Torvalds 已提交
255

C
Christoph Hellwig 已提交
256
	error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
257
	if (error)
258
		goto out_trans_cancel;
L
Linus Torvalds 已提交
259

260
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
261 262

	/*
263 264
	 * From this point onwards we overwrite the imap pointer that the
	 * caller gave to us.
L
Linus Torvalds 已提交
265
	 */
266
	xfs_defer_init(&dfops, &firstfsb);
267
	nimaps = 1;
268
	error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
269
				bmapi_flags, &firstfsb, resblks, imap,
270
				&nimaps, &dfops);
271
	if (error)
272
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
273 274

	/*
275
	 * Complete the transaction
L
Linus Torvalds 已提交
276
	 */
277
	error = xfs_defer_finish(&tp, &dfops, NULL);
278
	if (error)
279
		goto out_bmap_cancel;
280

281
	error = xfs_trans_commit(tp);
282
	if (error)
283
		goto out_unlock;
L
Linus Torvalds 已提交
284

285 286 287
	/*
	 * Copy any maps to caller's array and return any error.
	 */
L
Linus Torvalds 已提交
288
	if (nimaps == 0) {
D
Dave Chinner 已提交
289
		error = -ENOSPC;
290
		goto out_unlock;
291 292
	}

293
	if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
294
		error = xfs_alert_fsblock_zero(ip, imap);
L
Linus Torvalds 已提交
295

296
out_unlock:
297
	xfs_iunlock(ip, lockmode);
298
	return error;
L
Linus Torvalds 已提交
299

300
out_bmap_cancel:
301
	xfs_defer_cancel(&dfops);
302
	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
303
out_trans_cancel:
304
	xfs_trans_cancel(tp);
305
	goto out_unlock;
L
Linus Torvalds 已提交
306 307
}

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
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,
335 336
	int *qshift,
	int64_t	*qfreesp)
337 338 339 340 341
{
	int64_t freesp;
	int shift = 0;
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

342 343
	/* no dq, or over hi wmark, squash the prealloc completely */
	if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
344
		*qblocks = 0;
345
		*qfreesp = 0;
346 347 348 349 350 351 352 353 354 355 356 357
		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;
	}

358 359 360
	if (freesp < *qfreesp)
		*qfreesp = freesp;

361 362 363 364 365 366 367
	/* only overwrite the throttle values if we are more aggressive */
	if ((freesp >> shift) < (*qblocks >> *qshift)) {
		*qblocks = freesp;
		*qshift = shift;
	}
}

368
/*
369 370 371 372
 * 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.
 *
373
 * If we don't have a user specified preallocation size, dynamically increase
374
 * the preallocation size as the size of the file grows.  Cap the maximum size
375 376
 * at a single extent or less if the filesystem is near full. The closer the
 * filesystem is to full, the smaller the maximum prealocation.
377 378 379 380 381 382 383 384
 *
 * 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().
385 386 387
 */
STATIC xfs_fsblock_t
xfs_iomap_prealloc_size(
388
	struct xfs_inode	*ip,
389 390
	loff_t			offset,
	loff_t			count,
391
	xfs_extnum_t		idx)
392
{
393
	struct xfs_mount	*mp = ip->i_mount;
394
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
395
	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
396
	struct xfs_bmbt_irec	prev;
397 398
	int			shift = 0;
	int64_t			freesp;
399 400
	xfs_fsblock_t		qblocks;
	int			qshift = 0;
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
	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) ||
416 417
	    !xfs_iext_get_extent(ifp, idx - 1, &prev) ||
	    prev.br_startoff + prev.br_blockcount < offset_fsb)
418
		return mp->m_writeio_blocks;
419

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
	/*
	 * 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.
	 */
436 437
	if (prev.br_blockcount <= (MAXEXTLEN >> 1))
		alloc_blocks = prev.br_blockcount << 1;
438 439
	else
		alloc_blocks = XFS_B_TO_FSB(mp, offset);
440 441
	if (!alloc_blocks)
		goto check_writeio;
442
	qblocks = alloc_blocks;
443

444 445 446 447 448 449 450 451 452
	/*
	 * 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);
453

454
	freesp = percpu_counter_read_positive(&mp->m_fdblocks);
455 456 457 458 459 460 461 462 463 464
	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++;
465
	}
466 467

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

	/*
	 * 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.
	 */
	alloc_blocks = MIN(alloc_blocks, qblocks);
	shift = MAX(shift, qshift);

491 492
	if (shift)
		alloc_blocks >>= shift;
493 494 495 496 497 498 499 500
	/*
	 * 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;
501 502 503 504 505 506 507 508 509 510

	/*
	 * 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:
511 512
	if (alloc_blocks < mp->m_writeio_blocks)
		alloc_blocks = mp->m_writeio_blocks;
513 514
	trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
				      mp->m_writeio_blocks);
515 516 517
	return alloc_blocks;
}

518 519 520 521 522 523 524
static int
xfs_file_iomap_begin_delay(
	struct inode		*inode,
	loff_t			offset,
	loff_t			count,
	unsigned		flags,
	struct iomap		*iomap)
L
Linus Torvalds 已提交
525
{
526 527 528 529 530 531
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
	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);
532
	xfs_fileoff_t		end_fsb;
533 534 535
	int			error = 0, eof = 0;
	struct xfs_bmbt_irec	got;
	xfs_extnum_t		idx;
536
	xfs_fsblock_t		prealloc_blocks = 0;
537 538 539

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

541
	xfs_ilock(ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
542

543 544 545 546 547 548 549 550
	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),
	     mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
		error = -EFSCORRUPTED;
		goto out_unlock;
	}
551

552
	XFS_STATS_INC(mp, xs_blk_mapw);
553

554 555 556 557
	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
		if (error)
			goto out_unlock;
L
Linus Torvalds 已提交
558 559
	}

560
	eof = !xfs_iext_lookup_extent(ip, ifp, offset_fsb, &idx, &got);
561
	if (!eof && got.br_startoff <= offset_fsb) {
562 563 564 565 566 567 568 569 570 571 572
		if (xfs_is_reflink_inode(ip)) {
			bool		shared;

			end_fsb = min(XFS_B_TO_FSB(mp, offset + count),
					maxbytes_fsb);
			xfs_trim_extent(&got, offset_fsb, end_fsb - offset_fsb);
			error = xfs_reflink_reserve_cow(ip, &got, &shared);
			if (error)
				goto out_unlock;
		}

573 574
		trace_xfs_iomap_found(ip, offset, count, 0, &got);
		goto done;
L
Linus Torvalds 已提交
575
	}
576

577 578 579 580
	error = xfs_qm_dqattach_locked(ip, 0);
	if (error)
		goto out_unlock;

581
	/*
582 583 584 585 586 587 588
	 * 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 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.
589
	 */
590
	count = min_t(loff_t, count, 1024 * PAGE_SIZE);
591
	end_fsb = min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);
592 593

	if (eof) {
594
		prealloc_blocks = xfs_iomap_prealloc_size(ip, offset, count, idx);
595 596 597
		if (prealloc_blocks) {
			xfs_extlen_t	align;
			xfs_off_t	end_offset;
598
			xfs_fileoff_t	p_end_fsb;
599

600
			end_offset = XFS_WRITEIO_ALIGN(mp, offset + count - 1);
601 602
			p_end_fsb = XFS_B_TO_FSBT(mp, end_offset) +
					prealloc_blocks;
603 604 605

			align = xfs_eof_alignment(ip, 0);
			if (align)
606
				p_end_fsb = roundup_64(p_end_fsb, align);
607

608 609 610
			p_end_fsb = min(p_end_fsb, maxbytes_fsb);
			ASSERT(p_end_fsb > offset_fsb);
			prealloc_blocks = p_end_fsb - end_fsb;
611 612 613 614
		}
	}

retry:
615
	error = xfs_bmapi_reserve_delalloc(ip, XFS_DATA_FORK, offset_fsb,
616
			end_fsb - offset_fsb, prealloc_blocks, &got, &idx, eof);
617 618
	switch (error) {
	case 0:
619
		break;
D
Dave Chinner 已提交
620 621
	case -ENOSPC:
	case -EDQUOT:
622
		/* retry without any preallocation */
C
Christoph Hellwig 已提交
623
		trace_xfs_delalloc_enospc(ip, offset, count);
624 625
		if (prealloc_blocks) {
			prealloc_blocks = 0;
D
Dave Chinner 已提交
626
			goto retry;
627
		}
628 629 630
		/*FALLTHRU*/
	default:
		goto out_unlock;
L
Linus Torvalds 已提交
631 632
	}

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
	trace_xfs_iomap_alloc(ip, offset, count, 0, &got);
done:
	if (isnullstartblock(got.br_startblock))
		got.br_startblock = DELAYSTARTBLOCK;

	if (!got.br_startblock) {
		error = xfs_alert_fsblock_zero(ip, &got);
		if (error)
			goto out_unlock;
	}

	xfs_bmbt_to_iomap(ip, iomap, &got);

out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return error;
L
Linus Torvalds 已提交
649 650 651 652 653 654 655 656
}

/*
 * Pass in a delayed allocate extent, convert it to real extents;
 * return to the caller the extent we create which maps on top of
 * the originating callers request.
 *
 * Called without a lock on the inode.
657 658 659
 *
 * We no longer bother to look at the incoming map - all we have to
 * guarantee is that whatever we allocate fills the required range.
L
Linus Torvalds 已提交
660
 */
C
Christoph Hellwig 已提交
661
int
L
Linus Torvalds 已提交
662 663
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
664
	int		whichfork,
665
	xfs_off_t	offset,
666
	xfs_bmbt_irec_t *imap)
L
Linus Torvalds 已提交
667 668 669 670 671
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb, last_block;
	xfs_fileoff_t	end_fsb, map_start_fsb;
	xfs_fsblock_t	first_block;
672
	struct xfs_defer_ops	dfops;
L
Linus Torvalds 已提交
673 674
	xfs_filblks_t	count_fsb;
	xfs_trans_t	*tp;
675
	int		nimaps;
L
Linus Torvalds 已提交
676
	int		error = 0;
C
Christoph Hellwig 已提交
677
	int		flags = XFS_BMAPI_DELALLOC;
L
Linus Torvalds 已提交
678 679
	int		nres;

680
	if (whichfork == XFS_COW_FORK)
681
		flags |= XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC;
682

L
Linus Torvalds 已提交
683 684 685
	/*
	 * Make sure that the dquots are there.
	 */
C
Christoph Hellwig 已提交
686 687
	error = xfs_qm_dqattach(ip, 0);
	if (error)
E
Eric Sandeen 已提交
688
		return error;
L
Linus Torvalds 已提交
689

690
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
691 692
	count_fsb = imap->br_blockcount;
	map_start_fsb = imap->br_startoff;
L
Linus Torvalds 已提交
693

694
	XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
L
Linus Torvalds 已提交
695 696 697 698 699 700 701 702 703 704 705 706 707

	while (count_fsb != 0) {
		/*
		 * Set up a transaction with which to allocate the
		 * backing store for the file.  Do allocations in a
		 * loop until we get some space in the range we are
		 * interested in.  The other space that might be allocated
		 * is in the delayed allocation extent on which we sit
		 * but before our buffer starts.
		 */
		nimaps = 0;
		while (nimaps == 0) {
			nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
708 709 710 711 712 713 714
			/*
			 * We have already reserved space for the extent and any
			 * indirect blocks when creating the delalloc extent,
			 * there is no need to reserve space in this transaction
			 * again.
			 */
			error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0,
715 716
					0, XFS_TRANS_RESERVE, &tp);
			if (error)
E
Eric Sandeen 已提交
717
				return error;
718

L
Linus Torvalds 已提交
719
			xfs_ilock(ip, XFS_ILOCK_EXCL);
720
			xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
721

722
			xfs_defer_init(&dfops, &first_block);
L
Linus Torvalds 已提交
723 724

			/*
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
			 * it is possible that the extents have changed since
			 * we did the read call as we dropped the ilock for a
			 * while. We have to be careful about truncates or hole
			 * punchs here - we are not allowed to allocate
			 * non-delalloc blocks here.
			 *
			 * The only protection against truncation is the pages
			 * for the range we are being asked to convert are
			 * locked and hence a truncate will block on them
			 * first.
			 *
			 * As a result, if we go beyond the range we really
			 * need and hit an delalloc extent boundary followed by
			 * a hole while we have excess blocks in the map, we
			 * will fill the hole incorrectly and overrun the
			 * transaction reservation.
			 *
			 * Using a single map prevents this as we are forced to
			 * check each map we look for overlap with the desired
			 * range and abort as soon as we find it. Also, given
			 * that we only return a single map, having one beyond
			 * what we can return is probably a bit silly.
			 *
			 * We also need to check that we don't go beyond EOF;
			 * this is a truncate optimisation as a truncate sets
			 * the new file size before block on the pages we
			 * currently have locked under writeback. Because they
			 * are about to be tossed, we don't need to write them
			 * back....
L
Linus Torvalds 已提交
754
			 */
755
			nimaps = 1;
756
			end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
757
			error = xfs_bmap_last_offset(ip, &last_block,
758 759 760 761
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
762 763 764 765
			last_block = XFS_FILEOFF_MAX(last_block, end_fsb);
			if ((map_start_fsb + count_fsb) > last_block) {
				count_fsb = last_block - map_start_fsb;
				if (count_fsb == 0) {
D
Dave Chinner 已提交
766
					error = -EAGAIN;
L
Linus Torvalds 已提交
767 768 769 770
					goto trans_cancel;
				}
			}

771 772 773 774
			/*
			 * From this point onwards we overwrite the imap
			 * pointer that the caller gave to us.
			 */
775
			error = xfs_bmapi_write(tp, ip, map_start_fsb,
776
						count_fsb, flags, &first_block,
777
						nres, imap, &nimaps,
778
						&dfops);
L
Linus Torvalds 已提交
779 780 781
			if (error)
				goto trans_cancel;

782
			error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
783 784 785
			if (error)
				goto trans_cancel;

786
			error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
787 788 789 790 791 792 793 794 795 796
			if (error)
				goto error0;

			xfs_iunlock(ip, XFS_ILOCK_EXCL);
		}

		/*
		 * See if we were able to allocate an extent that
		 * covers at least part of the callers request
		 */
797
		if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
798
			return xfs_alert_fsblock_zero(ip, imap);
799

800 801 802
		if ((offset_fsb >= imap->br_startoff) &&
		    (offset_fsb < (imap->br_startoff +
				   imap->br_blockcount))) {
803
			XFS_STATS_INC(mp, xs_xstrat_quick);
804
			return 0;
L
Linus Torvalds 已提交
805 806
		}

807 808
		/*
		 * So far we have not mapped the requested part of the
L
Linus Torvalds 已提交
809 810
		 * file, just surrounding data, try again.
		 */
811 812
		count_fsb -= imap->br_blockcount;
		map_start_fsb = imap->br_startoff + imap->br_blockcount;
L
Linus Torvalds 已提交
813 814 815
	}

trans_cancel:
816
	xfs_defer_cancel(&dfops);
817
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
818 819
error0:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
820
	return error;
L
Linus Torvalds 已提交
821 822 823 824 825
}

int
xfs_iomap_write_unwritten(
	xfs_inode_t	*ip,
826
	xfs_off_t	offset,
827
	xfs_off_t	count)
L
Linus Torvalds 已提交
828 829 830 831 832
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_filblks_t	count_fsb;
	xfs_filblks_t	numblks_fsb;
833 834 835 836
	xfs_fsblock_t	firstfsb;
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
837
	struct xfs_defer_ops dfops;
838
	xfs_fsize_t	i_size;
839
	uint		resblks;
L
Linus Torvalds 已提交
840 841
	int		error;

C
Christoph Hellwig 已提交
842
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
843 844 845 846 847

	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);

848 849 850 851 852 853 854 855 856 857
	/*
	 * 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.
	 */
858
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
859

860
	do {
L
Linus Torvalds 已提交
861
		/*
862
		 * Set up a transaction to convert the range of extents
L
Linus Torvalds 已提交
863 864
		 * from unwritten to real. Do allocations in a loop until
		 * we have covered the range passed in.
865
		 *
866 867 868
		 * 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 已提交
869
		 */
870 871 872
		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
				XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
		if (error)
E
Eric Sandeen 已提交
873
			return error;
L
Linus Torvalds 已提交
874 875

		xfs_ilock(ip, XFS_ILOCK_EXCL);
876
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
877 878 879 880

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
881
		xfs_defer_init(&dfops, &firstfsb);
L
Linus Torvalds 已提交
882
		nimaps = 1;
883
		error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
884
					XFS_BMAPI_CONVERT, &firstfsb, resblks,
885
					&imap, &nimaps, &dfops);
L
Linus Torvalds 已提交
886 887 888
		if (error)
			goto error_on_bmapi_transaction;

889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
		/*
		 * 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;

		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);
		}

904
		error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
905 906 907
		if (error)
			goto error_on_bmapi_transaction;

908
		error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
909 910
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
E
Eric Sandeen 已提交
911
			return error;
912

913
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
914
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930

		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:
931
	xfs_defer_cancel(&dfops);
932
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
933
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
934
	return error;
L
Linus Torvalds 已提交
935
}
936

937 938
static inline bool imap_needs_alloc(struct inode *inode,
		struct xfs_bmbt_irec *imap, int nimaps)
939 940 941
{
	return !nimaps ||
		imap->br_startblock == HOLESTARTBLOCK ||
942 943
		imap->br_startblock == DELAYSTARTBLOCK ||
		(IS_DAX(inode) && ISUNWRITTEN(imap));
944 945
}

C
Christoph Hellwig 已提交
946 947 948 949 950 951 952 953 954 955 956 957 958
static inline bool need_excl_ilock(struct xfs_inode *ip, unsigned flags)
{
	/*
	 * COW writes will allocate delalloc space, so we need to make sure
	 * to take the lock exclusively here.
	 */
	if (xfs_is_reflink_inode(ip) && (flags & (IOMAP_WRITE | IOMAP_ZERO)))
		return true;
	if ((flags & IOMAP_DIRECT) && (flags & IOMAP_WRITE))
		return true;
	return false;
}

959 960 961 962 963 964 965 966 967 968 969 970 971
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;
972
	bool			shared = false, trimmed = false;
973
	unsigned		lockmode;
974 975 976 977

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

C
Christoph Hellwig 已提交
978 979
	if (((flags & (IOMAP_WRITE | IOMAP_DIRECT)) == IOMAP_WRITE) &&
			!IS_DAX(inode) && !xfs_get_extsz_hint(ip)) {
980
		/* Reserve delalloc blocks for regular writeback. */
981 982 983 984
		return xfs_file_iomap_begin_delay(inode, offset, length, flags,
				iomap);
	}

C
Christoph Hellwig 已提交
985
	if (need_excl_ilock(ip, flags)) {
986 987 988 989 990
		lockmode = XFS_ILOCK_EXCL;
		xfs_ilock(ip, XFS_ILOCK_EXCL);
	} else {
		lockmode = xfs_ilock_data_map_shared(ip);
	}
991 992 993 994 995 996 997 998

	ASSERT(offset <= mp->m_super->s_maxbytes);
	if ((xfs_fsize_t)offset + length > mp->m_super->s_maxbytes)
		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,
999
			       &nimaps, 0);
1000 1001
	if (error)
		goto out_unlock;
1002

1003
	if (flags & IOMAP_REPORT) {
1004 1005 1006
		/* Trim the mapping to the nearest shared extent boundary. */
		error = xfs_reflink_trim_around_shared(ip, &imap, &shared,
				&trimmed);
1007 1008 1009 1010 1011
		if (error)
			goto out_unlock;
	}

	if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && xfs_is_reflink_inode(ip)) {
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
		if (flags & IOMAP_DIRECT) {
			/* may drop and re-acquire the ilock */
			error = xfs_reflink_allocate_cow(ip, &imap, &shared,
					&lockmode);
			if (error)
				goto out_unlock;
		} else {
			error = xfs_reflink_reserve_cow(ip, &imap, &shared);
			if (error)
				goto out_unlock;
		}
1023 1024 1025

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

1028
	if ((flags & IOMAP_WRITE) && imap_needs_alloc(inode, &imap, nimaps)) {
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
		/*
		 * 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 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);
1040 1041 1042 1043
		/*
		 * xfs_iomap_write_direct() expects the shared lock. It
		 * is unlocked on return.
		 */
1044 1045
		if (lockmode == XFS_ILOCK_EXCL)
			xfs_ilock_demote(ip, lockmode);
1046 1047
		error = xfs_iomap_write_direct(ip, offset, length, &imap,
				nimaps);
1048 1049 1050
		if (error)
			return error;

C
Christoph Hellwig 已提交
1051
		iomap->flags = IOMAP_F_NEW;
1052 1053
		trace_xfs_iomap_alloc(ip, offset, length, 0, &imap);
	} else {
1054 1055
		ASSERT(nimaps);

1056
		xfs_iunlock(ip, lockmode);
1057
		trace_xfs_iomap_found(ip, offset, length, 0, &imap);
1058 1059
	}

1060
	xfs_bmbt_to_iomap(ip, iomap, &imap);
1061 1062
	if (shared)
		iomap->flags |= IOMAP_F_SHARED;
1063
	return 0;
1064 1065 1066
out_unlock:
	xfs_iunlock(ip, lockmode);
	return error;
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
}

static int
xfs_file_iomap_end_delalloc(
	struct xfs_inode	*ip,
	loff_t			offset,
	loff_t			length,
	ssize_t			written)
{
	struct xfs_mount	*mp = ip->i_mount;
	xfs_fileoff_t		start_fsb;
	xfs_fileoff_t		end_fsb;
	int			error = 0;

1081 1082 1083 1084
	/* behave as if the write failed if drop writes is enabled */
	if (xfs_mp_drop_writes(mp))
		written = 0;

1085 1086 1087 1088 1089 1090 1091 1092 1093
	/*
	 * 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);
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
	end_fsb = XFS_B_TO_FSB(mp, offset + length);

	/*
	 * Trim back delalloc blocks if we didn't manage to write the whole
	 * range reserved.
	 *
	 * 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.
	 */
	if (start_fsb < end_fsb) {
1105 1106 1107
		truncate_pagecache_range(VFS_I(ip), XFS_FSB_TO_B(mp, start_fsb),
					 XFS_FSB_TO_B(mp, end_fsb) - 1);

1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
		xfs_ilock(ip, XFS_ILOCK_EXCL);
		error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
					       end_fsb - start_fsb);
		xfs_iunlock(ip, XFS_ILOCK_EXCL);

		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,
				length, written);
	return 0;
}

1138
const struct iomap_ops xfs_iomap_ops = {
1139 1140 1141
	.iomap_begin		= xfs_file_iomap_begin,
	.iomap_end		= xfs_file_iomap_end,
};
1142 1143 1144 1145 1146 1147 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

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;

	lockmode = xfs_ilock_data_map_shared(ip);

	/* if there are no attribute fork or extents, return ENOENT */
	if (XFS_IFORK_Q(ip) || !ip->i_d.di_anextents) {
		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,
			       &nimaps, XFS_BMAPI_ENTIRE | XFS_BMAPI_ATTRFORK);
out_unlock:
	xfs_iunlock(ip, lockmode);

	if (!error) {
		ASSERT(nimaps);
		xfs_bmbt_to_iomap(ip, iomap, &imap);
	}

	return error;
}

1184
const struct iomap_ops xfs_xattr_iomap_ops = {
1185 1186
	.iomap_begin		= xfs_xattr_iomap_begin,
};