xfs_iomap.c 30.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * 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 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * 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 已提交
13
 *
14 15 16
 * 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 已提交
17
 */
18
#include <linux/iomap.h>
L
Linus Torvalds 已提交
19 20
#include "xfs.h"
#include "xfs_fs.h"
21
#include "xfs_shared.h"
22 23 24
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
25
#include "xfs_mount.h"
26
#include "xfs_defer.h"
L
Linus Torvalds 已提交
27
#include "xfs_inode.h"
28
#include "xfs_btree.h"
29
#include "xfs_bmap_btree.h"
L
Linus Torvalds 已提交
30
#include "xfs_bmap.h"
D
Dave Chinner 已提交
31
#include "xfs_bmap_util.h"
L
Linus Torvalds 已提交
32
#include "xfs_error.h"
33
#include "xfs_trans.h"
L
Linus Torvalds 已提交
34 35
#include "xfs_trans_space.h"
#include "xfs_iomap.h"
C
Christoph Hellwig 已提交
36
#include "xfs_trace.h"
37
#include "xfs_icache.h"
38
#include "xfs_quota.h"
39 40
#include "xfs_dquot_item.h"
#include "xfs_dquot.h"
L
Linus Torvalds 已提交
41 42 43 44 45 46


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

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

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

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

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

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

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

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

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

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

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

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

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

182 183
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
184
	if ((offset + count) > XFS_ISIZE(ip)) {
185 186 187 188 189 190 191 192 193
		/*
		 * 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);
194
		error = xfs_iomap_eof_align_last_fsb(ip, extsz, &last_fsb);
195
		if (error)
196
			goto out_unlock;
L
Linus Torvalds 已提交
197
	} else {
198
		if (nmaps && (imap->br_startblock == HOLESTARTBLOCK))
199
			last_fsb = MIN(last_fsb, (xfs_fileoff_t)
200 201
					imap->br_blockcount +
					imap->br_startoff);
L
Linus Torvalds 已提交
202
	}
203 204 205 206 207 208 209 210 211 212 213 214 215 216
	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;
217 218 219 220
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
221
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
222 223
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
224

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

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

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

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

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

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

	/*
281
	 * Complete the transaction
L
Linus Torvalds 已提交
282
	 */
283
	error = xfs_defer_finish(&tp, &dfops, NULL);
284
	if (error)
285
		goto out_bmap_cancel;
286

287
	error = xfs_trans_commit(tp);
288
	if (error)
289
		goto out_unlock;
L
Linus Torvalds 已提交
290

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

299
	if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
300
		error = xfs_alert_fsblock_zero(ip, imap);
L
Linus Torvalds 已提交
301

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

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

314
/*
D
Dave Chinner 已提交
315 316 317
 * If the caller is doing a write at the end of the file, then extend the
 * allocation out to the file system's write iosize.  We clean up any extra
 * space left over when the file is closed in xfs_inactive().
318 319 320
 *
 * If we find we already have delalloc preallocation beyond EOF, don't do more
 * preallocation as it it not needed.
321 322 323 324
 */
STATIC int
xfs_iomap_eof_want_preallocate(
	xfs_mount_t	*mp,
325
	xfs_inode_t	*ip,
326 327 328 329 330 331 332 333 334
	xfs_off_t	offset,
	size_t		count,
	xfs_bmbt_irec_t *imap,
	int		nimaps,
	int		*prealloc)
{
	xfs_fileoff_t   start_fsb;
	xfs_filblks_t   count_fsb;
	int		n, error, imaps;
335
	int		found_delalloc = 0;
336 337

	*prealloc = 0;
338
	if (offset + count <= XFS_ISIZE(ip))
339 340
		return 0;

341 342 343 344 345 346 347 348 349
	/*
	 * If the file is smaller than the minimum prealloc and we are using
	 * dynamic preallocation, don't do any preallocation at all as it is
	 * likely this is the only write to the file that is going to be done.
	 */
	if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE) &&
	    XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_writeio_blocks))
		return 0;

350 351 352 353 354
	/*
	 * If there are any real blocks past eof, then don't
	 * do any speculative allocation.
	 */
	start_fsb = XFS_B_TO_FSBT(mp, ((xfs_ufsize_t)(offset + count - 1)));
355
	count_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
356 357
	while (count_fsb > 0) {
		imaps = nimaps;
D
Dave Chinner 已提交
358 359
		error = xfs_bmapi_read(ip, start_fsb, count_fsb, imap, &imaps,
				       0);
360 361 362 363 364 365 366 367
		if (error)
			return error;
		for (n = 0; n < imaps; n++) {
			if ((imap[n].br_startblock != HOLESTARTBLOCK) &&
			    (imap[n].br_startblock != DELAYSTARTBLOCK))
				return 0;
			start_fsb += imap[n].br_blockcount;
			count_fsb -= imap[n].br_blockcount;
368 369 370

			if (imap[n].br_startblock == DELAYSTARTBLOCK)
				found_delalloc = 1;
371 372
		}
	}
373 374
	if (!found_delalloc)
		*prealloc = 1;
375 376 377
	return 0;
}

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
/*
 * 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 preceeding 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.
 */
393
STATIC xfs_fsblock_t
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
xfs_iomap_eof_prealloc_initial_size(
	struct xfs_mount	*mp,
	struct xfs_inode	*ip,
	xfs_off_t		offset,
	xfs_bmbt_irec_t		*imap,
	int			nimaps)
{
	xfs_fileoff_t   start_fsb;
	int		imaps = 1;
	int		error;

	ASSERT(nimaps >= imaps);

	/* if we are using a specific prealloc size, return now */
	if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
		return 0;

411 412 413 414
	/* If the file is small, then use the minimum prealloc */
	if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign))
		return 0;

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
	/*
	 * As we write multiple pages, the offset will always align to the
	 * start of a page and hence point to a hole at EOF. i.e. if the size is
	 * 4096 bytes, we only have one block at FSB 0, but XFS_B_TO_FSB(4096)
	 * will return FSB 1. Hence if there are blocks in the file, we want to
	 * point to the block prior to the EOF block and not the hole that maps
	 * directly at @offset.
	 */
	start_fsb = XFS_B_TO_FSB(mp, offset);
	if (start_fsb)
		start_fsb--;
	error = xfs_bmapi_read(ip, start_fsb, 1, imap, &imaps, XFS_BMAPI_ENTIRE);
	if (error)
		return 0;

	ASSERT(imaps == 1);
	if (imap[0].br_startblock == HOLESTARTBLOCK)
		return 0;
	if (imap[0].br_blockcount <= (MAXEXTLEN >> 1))
434
		return imap[0].br_blockcount << 1;
435 436 437
	return XFS_B_TO_FSB(mp, offset);
}

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
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,
465 466
	int *qshift,
	int64_t	*qfreesp)
467 468 469 470 471
{
	int64_t freesp;
	int shift = 0;
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

472 473
	/* no dq, or over hi wmark, squash the prealloc completely */
	if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
474
		*qblocks = 0;
475
		*qfreesp = 0;
476 477 478 479 480 481 482 483 484 485 486 487
		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;
	}

488 489 490
	if (freesp < *qfreesp)
		*qfreesp = freesp;

491 492 493 494 495 496 497
	/* only overwrite the throttle values if we are more aggressive */
	if ((freesp >> shift) < (*qblocks >> *qshift)) {
		*qblocks = freesp;
		*qshift = shift;
	}
}

498 499 500 501 502 503 504 505 506
/*
 * If we don't have a user specified preallocation size, dynamically increase
 * the preallocation size as the size of the file grows. Cap the maximum size
 * at a single extent or less if the filesystem is near full. The closer the
 * filesystem is to full, the smaller the maximum prealocation.
 */
STATIC xfs_fsblock_t
xfs_iomap_prealloc_size(
	struct xfs_mount	*mp,
507 508 509 510
	struct xfs_inode	*ip,
	xfs_off_t		offset,
	struct xfs_bmbt_irec	*imap,
	int			nimaps)
511 512
{
	xfs_fsblock_t		alloc_blocks = 0;
513 514
	int			shift = 0;
	int64_t			freesp;
515 516
	xfs_fsblock_t		qblocks;
	int			qshift = 0;
517

518 519
	alloc_blocks = xfs_iomap_eof_prealloc_initial_size(mp, ip, offset,
							   imap, nimaps);
520 521
	if (!alloc_blocks)
		goto check_writeio;
522
	qblocks = alloc_blocks;
523

524 525 526 527 528 529 530 531 532
	/*
	 * 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);
533

534
	freesp = percpu_counter_read_positive(&mp->m_fdblocks);
535 536 537 538 539 540 541 542 543 544
	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++;
545
	}
546 547

	/*
548 549
	 * Check each quota to cap the prealloc size, provide a shift value to
	 * throttle with and adjust amount of available space.
550 551
	 */
	if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
552 553
		xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
					&freesp);
554
	if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
555 556
		xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
					&freesp);
557
	if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
558 559
		xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
					&freesp);
560 561 562 563 564 565 566 567 568 569 570

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

571 572
	if (shift)
		alloc_blocks >>= shift;
573 574 575 576 577 578 579 580
	/*
	 * 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;
581 582 583 584 585 586 587 588 589

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

591
check_writeio:
592 593 594
	if (alloc_blocks < mp->m_writeio_blocks)
		alloc_blocks = mp->m_writeio_blocks;

595 596 597
	trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
				      mp->m_writeio_blocks);

598 599 600
	return alloc_blocks;
}

C
Christoph Hellwig 已提交
601
int
L
Linus Torvalds 已提交
602 603
xfs_iomap_write_delay(
	xfs_inode_t	*ip,
604
	xfs_off_t	offset,
L
Linus Torvalds 已提交
605
	size_t		count,
606
	xfs_bmbt_irec_t *ret_imap)
L
Linus Torvalds 已提交
607 608 609 610
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
611 612 613
	xfs_off_t	aligned_offset;
	xfs_fileoff_t	ioalign;
	xfs_extlen_t	extsz;
L
Linus Torvalds 已提交
614 615
	int		nimaps;
	xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS];
D
Dave Chinner 已提交
616
	int		prealloc;
617
	int		error;
L
Linus Torvalds 已提交
618

C
Christoph Hellwig 已提交
619
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
620 621 622 623 624

	/*
	 * Make sure that the dquots are there. This doesn't hold
	 * the ilock across a disk read.
	 */
C
Christoph Hellwig 已提交
625
	error = xfs_qm_dqattach_locked(ip, 0);
L
Linus Torvalds 已提交
626
	if (error)
E
Eric Sandeen 已提交
627
		return error;
L
Linus Torvalds 已提交
628

629
	extsz = xfs_get_extsz_hint(ip);
630 631
	offset_fsb = XFS_B_TO_FSBT(mp, offset);

632
	error = xfs_iomap_eof_want_preallocate(mp, ip, offset, count,
633
				imap, XFS_WRITE_IMAPS, &prealloc);
634 635
	if (error)
		return error;
L
Linus Torvalds 已提交
636

D
Dave Chinner 已提交
637
retry:
638
	if (prealloc) {
639 640 641 642
		xfs_fsblock_t	alloc_blocks;

		alloc_blocks = xfs_iomap_prealloc_size(mp, ip, offset, imap,
						       XFS_WRITE_IMAPS);
643

L
Linus Torvalds 已提交
644 645
		aligned_offset = XFS_WRITEIO_ALIGN(mp, (offset + count - 1));
		ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
646
		last_fsb = ioalign + alloc_blocks;
647 648
	} else {
		last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
L
Linus Torvalds 已提交
649 650
	}

651
	if (prealloc || extsz) {
652
		error = xfs_iomap_eof_align_last_fsb(ip, extsz, &last_fsb);
653
		if (error)
L
Linus Torvalds 已提交
654 655
			return error;
	}
656

657 658 659 660
	/*
	 * Make sure preallocation does not create extents beyond the range we
	 * actually support in this filesystem.
	 */
D
Dave Chinner 已提交
661 662
	if (last_fsb > XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes))
		last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
663 664 665

	ASSERT(last_fsb > offset_fsb);

666
	nimaps = XFS_WRITE_IMAPS;
667 668
	error = xfs_bmapi_delay(ip, offset_fsb, last_fsb - offset_fsb,
				imap, &nimaps, XFS_BMAPI_ENTIRE);
669 670
	switch (error) {
	case 0:
D
Dave Chinner 已提交
671 672
	case -ENOSPC:
	case -EDQUOT:
673 674
		break;
	default:
E
Eric Sandeen 已提交
675
		return error;
676
	}
677

L
Linus Torvalds 已提交
678
	/*
D
Dave Chinner 已提交
679
	 * If bmapi returned us nothing, we got either ENOSPC or EDQUOT. Retry
680
	 * without EOF preallocation.
L
Linus Torvalds 已提交
681 682
	 */
	if (nimaps == 0) {
C
Christoph Hellwig 已提交
683
		trace_xfs_delalloc_enospc(ip, offset, count);
D
Dave Chinner 已提交
684 685 686 687
		if (prealloc) {
			prealloc = 0;
			error = 0;
			goto retry;
688
		}
D
Dave Chinner 已提交
689
		return error ? error : -ENOSPC;
L
Linus Torvalds 已提交
690 691
	}

692
	if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
693
		return xfs_alert_fsblock_zero(ip, &imap[0]);
694

695 696 697 698 699 700 701
	/*
	 * Tag the inode as speculatively preallocated so we can reclaim this
	 * space on demand, if necessary.
	 */
	if (prealloc)
		xfs_inode_set_eofblocks_tag(ip);

702
	*ret_imap = imap[0];
L
Linus Torvalds 已提交
703 704 705 706 707 708 709 710 711
	return 0;
}

/*
 * 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.
712 713 714
 *
 * 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 已提交
715
 */
C
Christoph Hellwig 已提交
716
int
L
Linus Torvalds 已提交
717 718
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
719
	xfs_off_t	offset,
720
	xfs_bmbt_irec_t *imap)
L
Linus Torvalds 已提交
721 722 723 724 725
{
	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;
726
	struct xfs_defer_ops	dfops;
L
Linus Torvalds 已提交
727 728
	xfs_filblks_t	count_fsb;
	xfs_trans_t	*tp;
729
	int		nimaps;
L
Linus Torvalds 已提交
730 731 732 733 734 735
	int		error = 0;
	int		nres;

	/*
	 * Make sure that the dquots are there.
	 */
C
Christoph Hellwig 已提交
736 737
	error = xfs_qm_dqattach(ip, 0);
	if (error)
E
Eric Sandeen 已提交
738
		return error;
L
Linus Torvalds 已提交
739

740
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
741 742
	count_fsb = imap->br_blockcount;
	map_start_fsb = imap->br_startoff;
L
Linus Torvalds 已提交
743

744
	XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
L
Linus Torvalds 已提交
745 746 747 748 749 750 751 752 753 754 755 756 757

	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);
758 759 760 761 762 763 764
			/*
			 * 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,
765 766
					0, XFS_TRANS_RESERVE, &tp);
			if (error)
E
Eric Sandeen 已提交
767
				return error;
768

L
Linus Torvalds 已提交
769
			xfs_ilock(ip, XFS_ILOCK_EXCL);
770
			xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
771

772
			xfs_defer_init(&dfops, &first_block);
L
Linus Torvalds 已提交
773 774

			/*
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
			 * 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 已提交
804
			 */
805
			nimaps = 1;
806
			end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
807
			error = xfs_bmap_last_offset(ip, &last_block,
808 809 810 811
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
812 813 814 815
			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 已提交
816
					error = -EAGAIN;
L
Linus Torvalds 已提交
817 818 819 820
					goto trans_cancel;
				}
			}

821 822 823 824
			/*
			 * From this point onwards we overwrite the imap
			 * pointer that the caller gave to us.
			 */
825
			error = xfs_bmapi_write(tp, ip, map_start_fsb,
826 827
						count_fsb, 0, &first_block,
						nres, imap, &nimaps,
828
						&dfops);
L
Linus Torvalds 已提交
829 830 831
			if (error)
				goto trans_cancel;

832
			error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
833 834 835
			if (error)
				goto trans_cancel;

836
			error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
837 838 839 840 841 842 843 844 845 846
			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
		 */
847
		if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
848
			return xfs_alert_fsblock_zero(ip, imap);
849

850 851 852
		if ((offset_fsb >= imap->br_startoff) &&
		    (offset_fsb < (imap->br_startoff +
				   imap->br_blockcount))) {
853
			XFS_STATS_INC(mp, xs_xstrat_quick);
854
			return 0;
L
Linus Torvalds 已提交
855 856
		}

857 858
		/*
		 * So far we have not mapped the requested part of the
L
Linus Torvalds 已提交
859 860
		 * file, just surrounding data, try again.
		 */
861 862
		count_fsb -= imap->br_blockcount;
		map_start_fsb = imap->br_startoff + imap->br_blockcount;
L
Linus Torvalds 已提交
863 864 865
	}

trans_cancel:
866
	xfs_defer_cancel(&dfops);
867
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
868 869
error0:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
870
	return error;
L
Linus Torvalds 已提交
871 872 873 874 875
}

int
xfs_iomap_write_unwritten(
	xfs_inode_t	*ip,
876
	xfs_off_t	offset,
877
	xfs_off_t	count)
L
Linus Torvalds 已提交
878 879 880 881 882
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_filblks_t	count_fsb;
	xfs_filblks_t	numblks_fsb;
883 884 885 886
	xfs_fsblock_t	firstfsb;
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
887
	struct xfs_defer_ops dfops;
888
	xfs_fsize_t	i_size;
889
	uint		resblks;
L
Linus Torvalds 已提交
890 891
	int		error;

C
Christoph Hellwig 已提交
892
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
893 894 895 896 897

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

898 899 900 901 902 903 904 905 906 907
	/*
	 * 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.
	 */
908
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
909

910
	do {
L
Linus Torvalds 已提交
911
		/*
912
		 * Set up a transaction to convert the range of extents
L
Linus Torvalds 已提交
913 914
		 * from unwritten to real. Do allocations in a loop until
		 * we have covered the range passed in.
915
		 *
916 917 918
		 * 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 已提交
919
		 */
920 921 922
		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
				XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
		if (error)
E
Eric Sandeen 已提交
923
			return error;
L
Linus Torvalds 已提交
924 925

		xfs_ilock(ip, XFS_ILOCK_EXCL);
926
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
927 928 929 930

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
931
		xfs_defer_init(&dfops, &firstfsb);
L
Linus Torvalds 已提交
932
		nimaps = 1;
933
		error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
934
					XFS_BMAPI_CONVERT, &firstfsb, resblks,
935
					&imap, &nimaps, &dfops);
L
Linus Torvalds 已提交
936 937 938
		if (error)
			goto error_on_bmapi_transaction;

939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
		/*
		 * 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);
		}

954
		error = xfs_defer_finish(&tp, &dfops, NULL);
L
Linus Torvalds 已提交
955 956 957
		if (error)
			goto error_on_bmapi_transaction;

958
		error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
959 960
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
E
Eric Sandeen 已提交
961
			return error;
962

963
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
964
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980

		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:
981
	xfs_defer_cancel(&dfops);
982
	xfs_trans_cancel(tp);
L
Linus Torvalds 已提交
983
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
E
Eric Sandeen 已提交
984
	return error;
L
Linus Torvalds 已提交
985
}
986

987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
static inline bool imap_needs_alloc(struct xfs_bmbt_irec *imap, int nimaps)
{
	return !nimaps ||
		imap->br_startblock == HOLESTARTBLOCK ||
		imap->br_startblock == DELAYSTARTBLOCK;
}

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;

	if (XFS_FORCED_SHUTDOWN(mp))
		return -EIO;

	xfs_ilock(ip, XFS_ILOCK_EXCL);

	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,
			       &nimaps, XFS_BMAPI_ENTIRE);
	if (error) {
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		return error;
	}

	if ((flags & IOMAP_WRITE) && imap_needs_alloc(&imap, nimaps)) {
		/*
		 * 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);
		if (xfs_get_extsz_hint(ip)) {
			/*
			 * xfs_iomap_write_direct() expects the shared lock. It
			 * is unlocked on return.
			 */
			xfs_ilock_demote(ip, XFS_ILOCK_EXCL);
			error = xfs_iomap_write_direct(ip, offset, length, &imap,
					nimaps);
		} else {
			error = xfs_iomap_write_delay(ip, offset, length, &imap);
			xfs_iunlock(ip, XFS_ILOCK_EXCL);
		}

		if (error)
			return error;

		trace_xfs_iomap_alloc(ip, offset, length, 0, &imap);
	} else {
1056 1057
		ASSERT(nimaps);

1058
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1059
		trace_xfs_iomap_found(ip, offset, length, 0, &imap);
1060 1061
	}

1062
	xfs_bmbt_to_iomap(ip, iomap, &imap);
1063 1064 1065 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
	return 0;
}

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,
};
1124 1125 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

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