xfs_iomap.c 24.5 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 19 20 21 22 23 24 25 26 27
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_alloc.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
28
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
29 30 31
#include "xfs_ialloc_btree.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
32
#include "xfs_inode_item.h"
33
#include "xfs_btree.h"
L
Linus Torvalds 已提交
34 35 36 37 38 39 40 41 42
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_trans_space.h"
#include "xfs_utils.h"
#include "xfs_iomap.h"
C
Christoph Hellwig 已提交
43
#include "xfs_trace.h"
44
#include "xfs_icache.h"
45 46
#include "xfs_dquot_item.h"
#include "xfs_dquot.h"
L
Linus Torvalds 已提交
47 48 49 50 51 52


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

53 54 55
STATIC int
xfs_iomap_eof_align_last_fsb(
	xfs_mount_t	*mp,
56
	xfs_inode_t	*ip,
57 58 59 60
	xfs_extlen_t	extsize,
	xfs_fileoff_t	*last_fsb)
{
	xfs_fileoff_t	new_last_fsb = 0;
61
	xfs_extlen_t	align = 0;
62 63
	int		eof, error;

64 65 66 67 68 69 70 71 72 73 74 75 76 77
	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;

78
		if (align && XFS_ISIZE(ip) >= XFS_FSB_TO_B(mp, align))
79 80
			new_last_fsb = roundup_64(*last_fsb, align);
	}
81 82 83 84 85 86 87 88 89 90 91 92 93 94

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

	if (new_last_fsb) {
95
		error = xfs_bmap_eof(ip, new_last_fsb, XFS_DATA_FORK, &eof);
96 97 98 99 100 101 102 103
		if (error)
			return error;
		if (eof)
			*last_fsb = new_last_fsb;
	}
	return 0;
}

104
STATIC int
105
xfs_alert_fsblock_zero(
106 107 108
	xfs_inode_t	*ip,
	xfs_bmbt_irec_t	*imap)
{
109
	xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
110 111 112 113 114 115 116 117 118 119 120
			"Access to block zero in inode %llu "
			"start_block: %llx start_off: %llx "
			"blkcnt: %llx extent-state: %x\n",
		(unsigned long long)ip->i_ino,
		(unsigned long long)imap->br_startblock,
		(unsigned long long)imap->br_startoff,
		(unsigned long long)imap->br_blockcount,
		imap->br_state);
	return EFSCORRUPTED;
}

C
Christoph Hellwig 已提交
121
int
L
Linus Torvalds 已提交
122 123
xfs_iomap_write_direct(
	xfs_inode_t	*ip,
124
	xfs_off_t	offset,
L
Linus Torvalds 已提交
125
	size_t		count,
126
	xfs_bmbt_irec_t *imap,
127
	int		nmaps)
L
Linus Torvalds 已提交
128 129 130 131
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
132
	xfs_filblks_t	count_fsb, resaligned;
L
Linus Torvalds 已提交
133
	xfs_fsblock_t	firstfsb;
134
	xfs_extlen_t	extsz, temp;
135
	int		nimaps;
L
Linus Torvalds 已提交
136
	int		bmapi_flag;
137
	int		quota_flag;
L
Linus Torvalds 已提交
138 139 140
	int		rt;
	xfs_trans_t	*tp;
	xfs_bmap_free_t free_list;
141
	uint		qblocks, resblks, resrtextents;
L
Linus Torvalds 已提交
142
	int		committed;
143
	int		error;
L
Linus Torvalds 已提交
144

145
	error = xfs_qm_dqattach(ip, 0);
L
Linus Torvalds 已提交
146 147 148
	if (error)
		return XFS_ERROR(error);

149
	rt = XFS_IS_REALTIME_INODE(ip);
150
	extsz = xfs_get_extsz_hint(ip);
L
Linus Torvalds 已提交
151

152 153
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
154
	if ((offset + count) > XFS_ISIZE(ip)) {
155
		error = xfs_iomap_eof_align_last_fsb(mp, ip, extsz, &last_fsb);
156
		if (error)
157
			return XFS_ERROR(error);
L
Linus Torvalds 已提交
158
	} else {
159
		if (nmaps && (imap->br_startblock == HOLESTARTBLOCK))
160
			last_fsb = MIN(last_fsb, (xfs_fileoff_t)
161 162
					imap->br_blockcount +
					imap->br_startoff);
L
Linus Torvalds 已提交
163
	}
164 165 166 167 168 169 170 171 172 173 174 175 176 177
	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;
178 179 180 181
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
182
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
183 184
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
185 186

	/*
187
	 * Allocate and setup the transaction
L
Linus Torvalds 已提交
188 189 190
	 */
	tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
	error = xfs_trans_reserve(tp, resblks,
191
			XFS_WRITE_LOG_RES(mp), resrtextents,
L
Linus Torvalds 已提交
192 193 194
			XFS_TRANS_PERM_LOG_RES,
			XFS_WRITE_LOG_COUNT);
	/*
195
	 * Check for running out of space, note: need lock to return
L
Linus Torvalds 已提交
196
	 */
197
	if (error) {
L
Linus Torvalds 已提交
198
		xfs_trans_cancel(tp, 0);
199 200 201
		return XFS_ERROR(error);
	}

L
Linus Torvalds 已提交
202 203
	xfs_ilock(ip, XFS_ILOCK_EXCL);

C
Christoph Hellwig 已提交
204
	error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
205
	if (error)
206
		goto out_trans_cancel;
L
Linus Torvalds 已提交
207

208
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
209

210
	bmapi_flag = 0;
211
	if (offset < XFS_ISIZE(ip) || extsz)
L
Linus Torvalds 已提交
212 213 214
		bmapi_flag |= XFS_BMAPI_PREALLOC;

	/*
215 216
	 * From this point onwards we overwrite the imap pointer that the
	 * caller gave to us.
L
Linus Torvalds 已提交
217
	 */
218
	xfs_bmap_init(&free_list, &firstfsb);
219
	nimaps = 1;
220 221
	error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb, bmapi_flag,
				&firstfsb, 0, imap, &nimaps, &free_list);
222
	if (error)
223
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
224 225

	/*
226
	 * Complete the transaction
L
Linus Torvalds 已提交
227
	 */
228
	error = xfs_bmap_finish(&tp, &free_list, &committed);
229
	if (error)
230
		goto out_bmap_cancel;
231
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
232
	if (error)
233
		goto out_unlock;
L
Linus Torvalds 已提交
234

235 236 237
	/*
	 * Copy any maps to caller's array and return any error.
	 */
L
Linus Torvalds 已提交
238
	if (nimaps == 0) {
239 240
		error = XFS_ERROR(ENOSPC);
		goto out_unlock;
241 242
	}

243
	if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
244
		error = xfs_alert_fsblock_zero(ip, imap);
L
Linus Torvalds 已提交
245

246 247 248
out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return error;
L
Linus Torvalds 已提交
249

250
out_bmap_cancel:
L
Linus Torvalds 已提交
251
	xfs_bmap_cancel(&free_list);
252
	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
253
out_trans_cancel:
L
Linus Torvalds 已提交
254
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
255
	goto out_unlock;
L
Linus Torvalds 已提交
256 257
}

258
/*
D
Dave Chinner 已提交
259 260 261
 * 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().
262 263 264
 *
 * If we find we already have delalloc preallocation beyond EOF, don't do more
 * preallocation as it it not needed.
265 266 267 268
 */
STATIC int
xfs_iomap_eof_want_preallocate(
	xfs_mount_t	*mp,
269
	xfs_inode_t	*ip,
270 271 272 273 274 275 276 277 278 279
	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;
	xfs_fsblock_t	firstblock;
	int		n, error, imaps;
280
	int		found_delalloc = 0;
281 282

	*prealloc = 0;
283
	if (offset + count <= XFS_ISIZE(ip))
284 285 286 287 288 289 290
		return 0;

	/*
	 * 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)));
291
	count_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
292 293
	while (count_fsb > 0) {
		imaps = nimaps;
294
		firstblock = NULLFSBLOCK;
D
Dave Chinner 已提交
295 296
		error = xfs_bmapi_read(ip, start_fsb, count_fsb, imap, &imaps,
				       0);
297 298 299 300 301 302 303 304
		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;
305 306 307

			if (imap[n].br_startblock == DELAYSTARTBLOCK)
				found_delalloc = 1;
308 309
		}
	}
310 311
	if (!found_delalloc)
		*prealloc = 1;
312 313 314
	return 0;
}

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
/*
 * 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.
 */
330
STATIC xfs_fsblock_t
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
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;

	/*
	 * 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))
367
		return imap[0].br_blockcount << 1;
368 369 370
	return XFS_B_TO_FSB(mp, offset);
}

371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
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,
	int *qshift)
{
	int64_t freesp;
	int shift = 0;
	struct xfs_dquot *dq = xfs_inode_dquot(ip, type);

	/* over hi wmark, squash the prealloc completely */
	if (dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
		*qblocks = 0;
		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;
	}

	/* only overwrite the throttle values if we are more aggressive */
	if ((freesp >> shift) < (*qblocks >> *qshift)) {
		*qblocks = freesp;
		*qshift = shift;
	}
}

426 427 428 429 430 431 432 433 434
/*
 * 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,
435 436 437 438
	struct xfs_inode	*ip,
	xfs_off_t		offset,
	struct xfs_bmbt_irec	*imap,
	int			nimaps)
439 440
{
	xfs_fsblock_t		alloc_blocks = 0;
441 442
	int			shift = 0;
	int64_t			freesp;
443 444
	xfs_fsblock_t		qblocks;
	int			qshift = 0;
445

446 447
	alloc_blocks = xfs_iomap_eof_prealloc_initial_size(mp, ip, offset,
							   imap, nimaps);
448 449
	if (!alloc_blocks)
		goto check_writeio;
450
	qblocks = alloc_blocks;
451

452 453 454 455 456 457 458 459 460
	/*
	 * 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);
461 462 463 464 465 466 467 468 469 470 471 472 473

	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
	freesp = mp->m_sb.sb_fdblocks;
	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++;
474
	}
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496

	/*
	 * Check each quota to cap the prealloc size and provide a shift
	 * value to throttle with.
	 */
	if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
		xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift);
	if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
		xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift);
	if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
		xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift);

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

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

517
check_writeio:
518 519 520 521 522 523
	if (alloc_blocks < mp->m_writeio_blocks)
		alloc_blocks = mp->m_writeio_blocks;

	return alloc_blocks;
}

C
Christoph Hellwig 已提交
524
int
L
Linus Torvalds 已提交
525 526
xfs_iomap_write_delay(
	xfs_inode_t	*ip,
527
	xfs_off_t	offset,
L
Linus Torvalds 已提交
528
	size_t		count,
529
	xfs_bmbt_irec_t *ret_imap)
L
Linus Torvalds 已提交
530 531 532 533
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
534 535 536
	xfs_off_t	aligned_offset;
	xfs_fileoff_t	ioalign;
	xfs_extlen_t	extsz;
L
Linus Torvalds 已提交
537 538
	int		nimaps;
	xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS];
D
Dave Chinner 已提交
539
	int		prealloc;
540
	int		error;
L
Linus Torvalds 已提交
541

C
Christoph Hellwig 已提交
542
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
543 544 545 546 547

	/*
	 * Make sure that the dquots are there. This doesn't hold
	 * the ilock across a disk read.
	 */
C
Christoph Hellwig 已提交
548
	error = xfs_qm_dqattach_locked(ip, 0);
L
Linus Torvalds 已提交
549 550 551
	if (error)
		return XFS_ERROR(error);

552
	extsz = xfs_get_extsz_hint(ip);
553 554
	offset_fsb = XFS_B_TO_FSBT(mp, offset);

555
	error = xfs_iomap_eof_want_preallocate(mp, ip, offset, count,
556
				imap, XFS_WRITE_IMAPS, &prealloc);
557 558
	if (error)
		return error;
L
Linus Torvalds 已提交
559

D
Dave Chinner 已提交
560
retry:
561
	if (prealloc) {
562 563 564 565
		xfs_fsblock_t	alloc_blocks;

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

L
Linus Torvalds 已提交
567 568
		aligned_offset = XFS_WRITEIO_ALIGN(mp, (offset + count - 1));
		ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
569
		last_fsb = ioalign + alloc_blocks;
570 571
	} else {
		last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
L
Linus Torvalds 已提交
572 573
	}

574
	if (prealloc || extsz) {
575
		error = xfs_iomap_eof_align_last_fsb(mp, ip, extsz, &last_fsb);
576
		if (error)
L
Linus Torvalds 已提交
577 578
			return error;
	}
579

580 581 582 583
	/*
	 * Make sure preallocation does not create extents beyond the range we
	 * actually support in this filesystem.
	 */
D
Dave Chinner 已提交
584 585
	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);
586 587 588

	ASSERT(last_fsb > offset_fsb);

589
	nimaps = XFS_WRITE_IMAPS;
590 591
	error = xfs_bmapi_delay(ip, offset_fsb, last_fsb - offset_fsb,
				imap, &nimaps, XFS_BMAPI_ENTIRE);
592 593 594 595 596 597
	switch (error) {
	case 0:
	case ENOSPC:
	case EDQUOT:
		break;
	default:
L
Linus Torvalds 已提交
598
		return XFS_ERROR(error);
599
	}
600

L
Linus Torvalds 已提交
601
	/*
D
Dave Chinner 已提交
602
	 * If bmapi returned us nothing, we got either ENOSPC or EDQUOT. Retry
603
	 * without EOF preallocation.
L
Linus Torvalds 已提交
604 605
	 */
	if (nimaps == 0) {
C
Christoph Hellwig 已提交
606
		trace_xfs_delalloc_enospc(ip, offset, count);
D
Dave Chinner 已提交
607 608 609 610
		if (prealloc) {
			prealloc = 0;
			error = 0;
			goto retry;
611
		}
D
Dave Chinner 已提交
612
		return XFS_ERROR(error ? error : ENOSPC);
L
Linus Torvalds 已提交
613 614
	}

615
	if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
616
		return xfs_alert_fsblock_zero(ip, &imap[0]);
617

618 619 620 621 622 623 624
	/*
	 * Tag the inode as speculatively preallocated so we can reclaim this
	 * space on demand, if necessary.
	 */
	if (prealloc)
		xfs_inode_set_eofblocks_tag(ip);

625
	*ret_imap = imap[0];
L
Linus Torvalds 已提交
626 627 628 629 630 631 632 633 634
	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.
635 636 637
 *
 * 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 已提交
638
 */
C
Christoph Hellwig 已提交
639
int
L
Linus Torvalds 已提交
640 641
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
642
	xfs_off_t	offset,
643
	size_t		count,
644
	xfs_bmbt_irec_t *imap)
L
Linus Torvalds 已提交
645 646 647 648 649 650 651 652
{
	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;
	xfs_bmap_free_t	free_list;
	xfs_filblks_t	count_fsb;
	xfs_trans_t	*tp;
653
	int		nimaps, committed;
L
Linus Torvalds 已提交
654 655 656 657 658 659
	int		error = 0;
	int		nres;

	/*
	 * Make sure that the dquots are there.
	 */
C
Christoph Hellwig 已提交
660 661
	error = xfs_qm_dqattach(ip, 0);
	if (error)
L
Linus Torvalds 已提交
662 663
		return XFS_ERROR(error);

664
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
665 666
	count_fsb = imap->br_blockcount;
	map_start_fsb = imap->br_startoff;
L
Linus Torvalds 已提交
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682

	XFS_STATS_ADD(xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));

	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) {
			tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
683
			tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693
			nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
			error = xfs_trans_reserve(tp, nres,
					XFS_WRITE_LOG_RES(mp),
					0, XFS_TRANS_PERM_LOG_RES,
					XFS_WRITE_LOG_COUNT);
			if (error) {
				xfs_trans_cancel(tp, 0);
				return XFS_ERROR(error);
			}
			xfs_ilock(ip, XFS_ILOCK_EXCL);
694
			xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
695

696
			xfs_bmap_init(&free_list, &first_block);
L
Linus Torvalds 已提交
697 698

			/*
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
			 * 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 已提交
728
			 */
729
			nimaps = 1;
730
			end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
731 732 733 734 735
			error = xfs_bmap_last_offset(NULL, ip, &last_block,
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
736 737 738 739 740 741 742 743 744
			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) {
					error = EAGAIN;
					goto trans_cancel;
				}
			}

745 746 747 748
			/*
			 * From this point onwards we overwrite the imap
			 * pointer that the caller gave to us.
			 */
749
			error = xfs_bmapi_write(tp, ip, map_start_fsb,
750 751 752
						count_fsb,
						XFS_BMAPI_STACK_SWITCH,
						&first_block, 1,
753
						imap, &nimaps, &free_list);
L
Linus Torvalds 已提交
754 755 756
			if (error)
				goto trans_cancel;

757
			error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
758 759 760
			if (error)
				goto trans_cancel;

761
			error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
762 763 764 765 766 767 768 769 770 771
			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
		 */
772
		if (!(imap->br_startblock || XFS_IS_REALTIME_INODE(ip)))
773
			return xfs_alert_fsblock_zero(ip, imap);
774

775 776 777
		if ((offset_fsb >= imap->br_startoff) &&
		    (offset_fsb < (imap->br_startoff +
				   imap->br_blockcount))) {
778 779
			XFS_STATS_INC(xs_xstrat_quick);
			return 0;
L
Linus Torvalds 已提交
780 781
		}

782 783
		/*
		 * So far we have not mapped the requested part of the
L
Linus Torvalds 已提交
784 785
		 * file, just surrounding data, try again.
		 */
786 787
		count_fsb -= imap->br_blockcount;
		map_start_fsb = imap->br_startoff + imap->br_blockcount;
L
Linus Torvalds 已提交
788 789 790 791 792 793 794 795 796 797 798 799 800
	}

trans_cancel:
	xfs_bmap_cancel(&free_list);
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
error0:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return XFS_ERROR(error);
}

int
xfs_iomap_write_unwritten(
	xfs_inode_t	*ip,
801
	xfs_off_t	offset,
L
Linus Torvalds 已提交
802 803 804 805 806 807
	size_t		count)
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_filblks_t	count_fsb;
	xfs_filblks_t	numblks_fsb;
808 809 810 811 812
	xfs_fsblock_t	firstfsb;
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
	xfs_bmap_free_t free_list;
813
	xfs_fsize_t	i_size;
814
	uint		resblks;
L
Linus Torvalds 已提交
815 816 817
	int		committed;
	int		error;

C
Christoph Hellwig 已提交
818
	trace_xfs_unwritten_convert(ip, offset, count);
L
Linus Torvalds 已提交
819 820 821 822 823

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

824 825 826 827 828 829 830 831 832 833
	/*
	 * 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.
	 */
834
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
835

836
	do {
L
Linus Torvalds 已提交
837 838 839 840
		/*
		 * set up a transaction to convert the range of extents
		 * from unwritten to real. Do allocations in a loop until
		 * we have covered the range passed in.
841 842 843 844 845 846
		 *
		 * Note that we open code the transaction allocation here
		 * to pass KM_NOFS--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 已提交
847
		 */
J
Jan Kara 已提交
848
		sb_start_intwrite(mp->m_super);
849
		tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS);
J
Jan Kara 已提交
850
		tp->t_flags |= XFS_TRANS_RESERVE | XFS_TRANS_FREEZE_PROT;
851
		error = xfs_trans_reserve(tp, resblks,
L
Linus Torvalds 已提交
852 853 854 855 856
				XFS_WRITE_LOG_RES(mp), 0,
				XFS_TRANS_PERM_LOG_RES,
				XFS_WRITE_LOG_COUNT);
		if (error) {
			xfs_trans_cancel(tp, 0);
857
			return XFS_ERROR(error);
L
Linus Torvalds 已提交
858 859 860
		}

		xfs_ilock(ip, XFS_ILOCK_EXCL);
861
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
862 863 864 865

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
866
		xfs_bmap_init(&free_list, &firstfsb);
L
Linus Torvalds 已提交
867
		nimaps = 1;
868 869
		error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
				  XFS_BMAPI_CONVERT, &firstfsb,
870
				  1, &imap, &nimaps, &free_list);
L
Linus Torvalds 已提交
871 872 873
		if (error)
			goto error_on_bmapi_transaction;

874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
		/*
		 * 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);
		}

		error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
890 891 892
		if (error)
			goto error_on_bmapi_transaction;

893
		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
894 895
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
896 897
			return XFS_ERROR(error);

898
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
899
			return xfs_alert_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920

		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:
	xfs_bmap_cancel(&free_list);
	xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT));
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	return XFS_ERROR(error);
}