xfs_iomap.c 31.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, temp;
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 206 207 208 209 210 211 212 213 214 215 216 217
	count_fsb = last_fsb - offset_fsb;
	ASSERT(count_fsb > 0);

	resaligned = count_fsb;
	if (unlikely(extsz)) {
		if ((temp = do_mod(offset_fsb, extsz)))
			resaligned += temp;
		if ((temp = do_mod(resaligned, extsz)))
			resaligned += extsz - temp;
	}

	if (unlikely(rt)) {
		resrtextents = qblocks = resaligned;
		resrtextents /= mp->m_sb.sb_rextsize;
218 219 220 221
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
222
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
223 224
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
225

226 227 228 229 230 231 232 233 234
	/*
	 * 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;

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

260 261
	lockmode = XFS_ILOCK_EXCL;
	xfs_ilock(ip, lockmode);
L
Linus Torvalds 已提交
262

C
Christoph Hellwig 已提交
263
	error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
264
	if (error)
265
		goto out_trans_cancel;
L
Linus Torvalds 已提交
266

267
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
268 269

	/*
270 271
	 * From this point onwards we overwrite the imap pointer that the
	 * caller gave to us.
L
Linus Torvalds 已提交
272
	 */
273
	xfs_defer_init(&dfops, &firstfsb);
274
	nimaps = 1;
275
	error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
276
				bmapi_flags, &firstfsb, resblks, imap,
277
				&nimaps, &dfops);
278
	if (error)
279
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
280 281

	/*
282
	 * Complete the transaction
L
Linus Torvalds 已提交
283
	 */
284
	error = xfs_defer_finish(&tp, &dfops, NULL);
285
	if (error)
286
		goto out_bmap_cancel;
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 (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
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_bmap_cancel:
308
	xfs_defer_cancel(&dfops);
309
	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
310
out_trans_cancel:
311
	xfs_trans_cancel(tp);
312
	goto out_unlock;
L
Linus Torvalds 已提交
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 341
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,
342 343
	int *qshift,
	int64_t	*qfreesp)
344 345 346 347 348
{
	int64_t freesp;
	int shift = 0;
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

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

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

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

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

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

450 451 452 453 454 455 456 457 458
	/*
	 * 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);
459

460
	freesp = percpu_counter_read_positive(&mp->m_fdblocks);
461 462 463 464 465 466 467 468 469 470
	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++;
471
	}
472 473

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

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

497 498
	if (shift)
		alloc_blocks >>= shift;
499 500 501 502 503 504 505 506
	/*
	 * 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;
507 508 509 510 511 512 513 514 515 516

	/*
	 * 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:
517 518
	if (alloc_blocks < mp->m_writeio_blocks)
		alloc_blocks = mp->m_writeio_blocks;
519 520
	trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
				      mp->m_writeio_blocks);
521 522 523
	return alloc_blocks;
}

524 525 526 527 528 529 530
static int
xfs_file_iomap_begin_delay(
	struct inode		*inode,
	loff_t			offset,
	loff_t			count,
	unsigned		flags,
	struct iomap		*iomap)
L
Linus Torvalds 已提交
531
{
532 533 534 535 536 537 538 539 540 541 542 543 544 545
	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);
	xfs_fileoff_t		end_fsb, orig_end_fsb;
	int			error = 0, eof = 0;
	struct xfs_bmbt_irec	got;
	struct xfs_bmbt_irec	prev;
	xfs_extnum_t		idx;

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

547
	xfs_ilock(ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
548

549 550 551 552 553 554 555 556
	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;
	}
557

558
	XFS_STATS_INC(mp, xs_blk_mapw);
559

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

566 567 568
	xfs_bmap_search_extents(ip, offset_fsb, XFS_DATA_FORK, &eof, &idx,
			&got, &prev);
	if (!eof && got.br_startoff <= offset_fsb) {
569 570 571 572 573 574 575 576 577 578 579
		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;
		}

580 581
		trace_xfs_iomap_found(ip, offset, count, 0, &got);
		goto done;
L
Linus Torvalds 已提交
582
	}
583

584 585 586 587
	error = xfs_qm_dqattach_locked(ip, 0);
	if (error)
		goto out_unlock;

588
	/*
589 590 591 592 593 594 595
	 * 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.
596
	 */
597 598 599 600 601 602
	count = min_t(loff_t, count, 1024 * PAGE_SIZE);
	end_fsb = orig_end_fsb =
		min(XFS_B_TO_FSB(mp, offset + count), maxbytes_fsb);

	if (eof) {
		xfs_fsblock_t	prealloc_blocks;
603

604 605 606 607 608
		prealloc_blocks =
			xfs_iomap_prealloc_size(ip, offset, count, idx, &prev);
		if (prealloc_blocks) {
			xfs_extlen_t	align;
			xfs_off_t	end_offset;
609

610 611 612 613 614 615 616 617 618 619 620 621 622 623
			end_offset = XFS_WRITEIO_ALIGN(mp, offset + count - 1);
			end_fsb = XFS_B_TO_FSBT(mp, end_offset) +
				prealloc_blocks;

			align = xfs_eof_alignment(ip, 0);
			if (align)
				end_fsb = roundup_64(end_fsb, align);

			end_fsb = min(end_fsb, maxbytes_fsb);
			ASSERT(end_fsb > offset_fsb);
		}
	}

retry:
624
	error = xfs_bmapi_reserve_delalloc(ip, XFS_DATA_FORK, offset_fsb,
625
			end_fsb - offset_fsb, &got, &idx, eof);
626 627
	switch (error) {
	case 0:
628
		break;
D
Dave Chinner 已提交
629 630
	case -ENOSPC:
	case -EDQUOT:
631
		/* retry without any preallocation */
C
Christoph Hellwig 已提交
632
		trace_xfs_delalloc_enospc(ip, offset, count);
633 634
		if (end_fsb != orig_end_fsb) {
			end_fsb = orig_end_fsb;
D
Dave Chinner 已提交
635
			goto retry;
636
		}
637 638 639
		/*FALLTHRU*/
	default:
		goto out_unlock;
L
Linus Torvalds 已提交
640 641
	}

642 643 644 645
	/*
	 * Tag the inode as speculatively preallocated so we can reclaim this
	 * space on demand, if necessary.
	 */
646
	if (end_fsb != orig_end_fsb)
647 648
		xfs_inode_set_eofblocks_tag(ip);

649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
	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 已提交
665 666 667 668 669 670 671 672
}

/*
 * 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.
673 674 675
 *
 * 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 已提交
676
 */
C
Christoph Hellwig 已提交
677
int
L
Linus Torvalds 已提交
678 679
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
680
	int		whichfork,
681
	xfs_off_t	offset,
682
	xfs_bmbt_irec_t *imap)
L
Linus Torvalds 已提交
683 684 685 686 687
{
	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;
688
	struct xfs_defer_ops	dfops;
L
Linus Torvalds 已提交
689 690
	xfs_filblks_t	count_fsb;
	xfs_trans_t	*tp;
691
	int		nimaps;
L
Linus Torvalds 已提交
692
	int		error = 0;
693
	int		flags = 0;
L
Linus Torvalds 已提交
694 695
	int		nres;

696 697 698
	if (whichfork == XFS_COW_FORK)
		flags |= XFS_BMAPI_COWFORK;

L
Linus Torvalds 已提交
699 700 701
	/*
	 * Make sure that the dquots are there.
	 */
C
Christoph Hellwig 已提交
702 703
	error = xfs_qm_dqattach(ip, 0);
	if (error)
E
Eric Sandeen 已提交
704
		return error;
L
Linus Torvalds 已提交
705

706
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
707 708
	count_fsb = imap->br_blockcount;
	map_start_fsb = imap->br_startoff;
L
Linus Torvalds 已提交
709

710
	XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718 719 720 721 722 723

	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);
724 725 726 727 728 729 730
			/*
			 * 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,
731 732
					0, XFS_TRANS_RESERVE, &tp);
			if (error)
E
Eric Sandeen 已提交
733
				return error;
734

L
Linus Torvalds 已提交
735
			xfs_ilock(ip, XFS_ILOCK_EXCL);
736
			xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
737

738
			xfs_defer_init(&dfops, &first_block);
L
Linus Torvalds 已提交
739 740

			/*
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
			 * 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 已提交
770
			 */
771
			nimaps = 1;
772
			end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
773
			error = xfs_bmap_last_offset(ip, &last_block,
774 775 776 777
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
778 779 780 781
			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 已提交
782
					error = -EAGAIN;
L
Linus Torvalds 已提交
783 784 785 786
					goto trans_cancel;
				}
			}

787 788 789 790
			/*
			 * From this point onwards we overwrite the imap
			 * pointer that the caller gave to us.
			 */
791
			error = xfs_bmapi_write(tp, ip, map_start_fsb,
792
						count_fsb, flags, &first_block,
793
						nres, imap, &nimaps,
794
						&dfops);
L
Linus Torvalds 已提交
795 796 797
			if (error)
				goto trans_cancel;

798
			error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
799 800 801
			if (error)
				goto trans_cancel;

802
			error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
803 804 805 806 807 808 809 810 811 812
			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
		 */
813
		if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
814
			return xfs_alert_fsblock_zero(ip, imap);
815

816 817 818
		if ((offset_fsb >= imap->br_startoff) &&
		    (offset_fsb < (imap->br_startoff +
				   imap->br_blockcount))) {
819
			XFS_STATS_INC(mp, xs_xstrat_quick);
820
			return 0;
L
Linus Torvalds 已提交
821 822
		}

823 824
		/*
		 * So far we have not mapped the requested part of the
L
Linus Torvalds 已提交
825 826
		 * file, just surrounding data, try again.
		 */
827 828
		count_fsb -= imap->br_blockcount;
		map_start_fsb = imap->br_startoff + imap->br_blockcount;
L
Linus Torvalds 已提交
829 830 831
	}

trans_cancel:
832
	xfs_defer_cancel(&dfops);
833
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
834 835
error0:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
836
	return error;
L
Linus Torvalds 已提交
837 838 839 840 841
}

int
xfs_iomap_write_unwritten(
	xfs_inode_t	*ip,
842
	xfs_off_t	offset,
843
	xfs_off_t	count)
L
Linus Torvalds 已提交
844 845 846 847 848
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_filblks_t	count_fsb;
	xfs_filblks_t	numblks_fsb;
849 850 851 852
	xfs_fsblock_t	firstfsb;
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
853
	struct xfs_defer_ops dfops;
854
	xfs_fsize_t	i_size;
855
	uint		resblks;
L
Linus Torvalds 已提交
856 857
	int		error;

C
Christoph Hellwig 已提交
858
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
859 860 861 862 863

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

864 865 866 867 868 869 870 871 872 873
	/*
	 * 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.
	 */
874
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
875

876
	do {
L
Linus Torvalds 已提交
877
		/*
878
		 * Set up a transaction to convert the range of extents
L
Linus Torvalds 已提交
879 880
		 * from unwritten to real. Do allocations in a loop until
		 * we have covered the range passed in.
881
		 *
882 883 884
		 * 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 已提交
885
		 */
886 887 888
		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
				XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
		if (error)
E
Eric Sandeen 已提交
889
			return error;
L
Linus Torvalds 已提交
890 891

		xfs_ilock(ip, XFS_ILOCK_EXCL);
892
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
893 894 895 896

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
897
		xfs_defer_init(&dfops, &firstfsb);
L
Linus Torvalds 已提交
898
		nimaps = 1;
899
		error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
900
					XFS_BMAPI_CONVERT, &firstfsb, resblks,
901
					&imap, &nimaps, &dfops);
L
Linus Torvalds 已提交
902 903 904
		if (error)
			goto error_on_bmapi_transaction;

905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
		/*
		 * 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);
		}

920
		error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
921 922 923
		if (error)
			goto error_on_bmapi_transaction;

924
		error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
925 926
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
E
Eric Sandeen 已提交
927
			return error;
928

929
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
930
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946

		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:
947
	xfs_defer_cancel(&dfops);
948
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
949
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
950
	return error;
L
Linus Torvalds 已提交
951
}
952

953 954
static inline bool imap_needs_alloc(struct inode *inode,
		struct xfs_bmbt_irec *imap, int nimaps)
955 956 957
{
	return !nimaps ||
		imap->br_startblock == HOLESTARTBLOCK ||
958 959
		imap->br_startblock == DELAYSTARTBLOCK ||
		(IS_DAX(inode) && ISUNWRITTEN(imap));
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974
}

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;
975
	bool			shared = false, trimmed = false;
976
	unsigned		lockmode;
977 978 979 980

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

981 982 983
	if ((flags & IOMAP_WRITE) && !IS_DAX(inode) &&
		   !xfs_get_extsz_hint(ip)) {
		/* Reserve delalloc blocks for regular writeback. */
984 985 986 987
		return xfs_file_iomap_begin_delay(inode, offset, length, flags,
				iomap);
	}

988 989 990 991 992 993 994 995 996 997
	/*
	 * COW writes will allocate delalloc space, so we need to make sure
	 * to take the lock exclusively here.
	 */
	if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && xfs_is_reflink_inode(ip)) {
		lockmode = XFS_ILOCK_EXCL;
		xfs_ilock(ip, XFS_ILOCK_EXCL);
	} else {
		lockmode = xfs_ilock_data_map_shared(ip);
	}
998 999 1000 1001 1002 1003 1004 1005

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

1010
	if (flags & IOMAP_REPORT) {
1011 1012 1013
		/* Trim the mapping to the nearest shared extent boundary. */
		error = xfs_reflink_trim_around_shared(ip, &imap, &shared,
				&trimmed);
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
		if (error)
			goto out_unlock;
	}

	if ((flags & (IOMAP_WRITE | IOMAP_ZERO)) && xfs_is_reflink_inode(ip)) {
		error = xfs_reflink_reserve_cow(ip, &imap, &shared);
		if (error)
			goto out_unlock;

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

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

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

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

1059
	xfs_bmbt_to_iomap(ip, iomap, &imap);
1060 1061
	if (shared)
		iomap->flags |= IOMAP_F_SHARED;
1062
	return 0;
1063 1064 1065
out_unlock:
	xfs_iunlock(ip, lockmode);
	return error;
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
}

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;

	start_fsb = XFS_B_TO_FSB(mp, offset + written);
	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) {
		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;
}

struct iomap_ops xfs_iomap_ops = {
	.iomap_begin		= xfs_file_iomap_begin,
	.iomap_end		= xfs_file_iomap_end,
};
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 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

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

struct iomap_ops xfs_xattr_iomap_ops = {
	.iomap_begin		= xfs_xattr_iomap_begin,
};