xfs_iomap.c 32.4 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 (imap->br_state == XFS_EXT_UNWRITTEN) {
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
	/*
	 * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
	 * them out if the write happens to fail.
	 */
	iomap->flags = IOMAP_F_NEW;
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
	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 已提交
654 655 656 657 658 659 660 661
}

/*
 * 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.
662 663 664
 *
 * 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 已提交
665
 */
C
Christoph Hellwig 已提交
666
int
L
Linus Torvalds 已提交
667 668
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
669
	int		whichfork,
670
	xfs_off_t	offset,
671
	xfs_bmbt_irec_t *imap)
L
Linus Torvalds 已提交
672 673 674 675 676
{
	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;
677
	struct xfs_defer_ops	dfops;
L
Linus Torvalds 已提交
678 679
	xfs_filblks_t	count_fsb;
	xfs_trans_t	*tp;
680
	int		nimaps;
L
Linus Torvalds 已提交
681
	int		error = 0;
C
Christoph Hellwig 已提交
682
	int		flags = XFS_BMAPI_DELALLOC;
L
Linus Torvalds 已提交
683 684
	int		nres;

685
	if (whichfork == XFS_COW_FORK)
686
		flags |= XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC;
687

L
Linus Torvalds 已提交
688 689 690
	/*
	 * Make sure that the dquots are there.
	 */
C
Christoph Hellwig 已提交
691 692
	error = xfs_qm_dqattach(ip, 0);
	if (error)
E
Eric Sandeen 已提交
693
		return error;
L
Linus Torvalds 已提交
694

695
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
696 697
	count_fsb = imap->br_blockcount;
	map_start_fsb = imap->br_startoff;
L
Linus Torvalds 已提交
698

699
	XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
L
Linus Torvalds 已提交
700 701 702 703 704 705 706 707 708 709 710 711 712

	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);
713 714 715 716 717 718 719
			/*
			 * 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,
720 721
					0, XFS_TRANS_RESERVE, &tp);
			if (error)
E
Eric Sandeen 已提交
722
				return error;
723

L
Linus Torvalds 已提交
724
			xfs_ilock(ip, XFS_ILOCK_EXCL);
725
			xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
726

727
			xfs_defer_init(&dfops, &first_block);
L
Linus Torvalds 已提交
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 754 755 756 757 758
			 * 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 已提交
759
			 */
760
			nimaps = 1;
761
			end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
762
			error = xfs_bmap_last_offset(ip, &last_block,
763 764 765 766
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
767 768 769 770
			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 已提交
771
					error = -EAGAIN;
L
Linus Torvalds 已提交
772 773 774 775
					goto trans_cancel;
				}
			}

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

787
			error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
788 789 790
			if (error)
				goto trans_cancel;

791
			error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
792 793 794 795 796 797 798 799 800 801
			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
		 */
802
		if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
803
			return xfs_alert_fsblock_zero(ip, imap);
804

805 806 807
		if ((offset_fsb >= imap->br_startoff) &&
		    (offset_fsb < (imap->br_startoff +
				   imap->br_blockcount))) {
808
			XFS_STATS_INC(mp, xs_xstrat_quick);
809
			return 0;
L
Linus Torvalds 已提交
810 811
		}

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

trans_cancel:
821
	xfs_defer_cancel(&dfops);
822
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
823 824
error0:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
825
	return error;
L
Linus Torvalds 已提交
826 827 828 829 830
}

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

C
Christoph Hellwig 已提交
847
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
848 849 850 851 852

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

853 854 855 856 857 858 859 860 861 862
	/*
	 * 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.
	 */
863
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
864

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

		xfs_ilock(ip, XFS_ILOCK_EXCL);
881
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
882 883 884 885

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

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
		/*
		 * 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);
		}

909
		error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
910 911 912
		if (error)
			goto error_on_bmapi_transaction;

913
		error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
914 915
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
E
Eric Sandeen 已提交
916
			return error;
917

918
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
919
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935

		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:
936
	xfs_defer_cancel(&dfops);
937
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
938
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
939
	return error;
L
Linus Torvalds 已提交
940
}
941

942 943
static inline bool imap_needs_alloc(struct inode *inode,
		struct xfs_bmbt_irec *imap, int nimaps)
944 945 946
{
	return !nimaps ||
		imap->br_startblock == HOLESTARTBLOCK ||
947
		imap->br_startblock == DELAYSTARTBLOCK ||
948
		(IS_DAX(inode) && imap->br_state == XFS_EXT_UNWRITTEN);
949 950
}

C
Christoph Hellwig 已提交
951 952 953 954 955 956 957 958 959 960 961 962 963
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;
}

964 965 966 967 968 969 970 971 972 973 974 975 976
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;
977
	bool			shared = false, trimmed = false;
978
	unsigned		lockmode;
979 980 981 982

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

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

C
Christoph Hellwig 已提交
990
	if (need_excl_ilock(ip, flags)) {
991 992 993 994 995
		lockmode = XFS_ILOCK_EXCL;
		xfs_ilock(ip, XFS_ILOCK_EXCL);
	} else {
		lockmode = xfs_ilock_data_map_shared(ip);
	}
996 997 998 999 1000 1001 1002 1003

	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,
1004
			       &nimaps, 0);
1005 1006
	if (error)
		goto out_unlock;
1007

1008
	if (flags & IOMAP_REPORT) {
1009 1010 1011
		/* Trim the mapping to the nearest shared extent boundary. */
		error = xfs_reflink_trim_around_shared(ip, &imap, &shared,
				&trimmed);
1012 1013 1014 1015 1016
		if (error)
			goto out_unlock;
	}

	if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && xfs_is_reflink_inode(ip)) {
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
		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;
		}
1028 1029 1030

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

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

C
Christoph Hellwig 已提交
1056
		iomap->flags = IOMAP_F_NEW;
1057 1058
		trace_xfs_iomap_alloc(ip, offset, length, 0, &imap);
	} else {
1059 1060
		ASSERT(nimaps);

1061
		xfs_iunlock(ip, lockmode);
1062
		trace_xfs_iomap_found(ip, offset, length, 0, &imap);
1063 1064
	}

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

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

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

1096 1097 1098 1099 1100 1101 1102 1103 1104
	/*
	 * 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);
1105 1106 1107
	end_fsb = XFS_B_TO_FSB(mp, offset + length);

	/*
1108 1109
	 * Trim delalloc blocks if they were allocated by this write and we
	 * didn't manage to write the whole range.
1110 1111 1112 1113 1114
	 *
	 * 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.
	 */
1115
	if ((iomap->flags & IOMAP_F_NEW) && start_fsb < end_fsb) {
1116 1117 1118
		truncate_pagecache_range(VFS_I(ip), XFS_FSB_TO_B(mp, start_fsb),
					 XFS_FSB_TO_B(mp, end_fsb) - 1);

1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
		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,
1145
				length, written, iomap);
1146 1147 1148
	return 0;
}

1149
const struct iomap_ops xfs_iomap_ops = {
1150 1151 1152
	.iomap_begin		= xfs_file_iomap_begin,
	.iomap_end		= xfs_file_iomap_end,
};
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

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

1195
const struct iomap_ops xfs_xattr_iomap_ops = {
1196 1197
	.iomap_begin		= xfs_xattr_iomap_begin,
};