xfs_iomap.c 24.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 19
 */
#include "xfs.h"
#include "xfs_fs.h"
20
#include "xfs_bit.h"
L
Linus Torvalds 已提交
21
#include "xfs_log.h"
22
#include "xfs_inum.h"
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
32
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
33 34
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
35
#include "xfs_attr_sf.h"
L
Linus Torvalds 已提交
36 37
#include "xfs_dinode.h"
#include "xfs_inode.h"
38 39
#include "xfs_ialloc.h"
#include "xfs_btree.h"
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_rw.h"
#include "xfs_acl.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_trans_space.h"
#include "xfs_utils.h"
#include "xfs_iomap.h"

#if defined(XFS_RW_TRACE)
void
xfs_iomap_enter_trace(
	int		tag,
56
	xfs_inode_t	*ip,
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70
	xfs_off_t	offset,
	ssize_t		count)
{
	if (!ip->i_rwtrace)
		return;

	ktrace_enter(ip->i_rwtrace,
		(void *)((unsigned long)tag),
		(void *)ip,
		(void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
		(void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
		(void *)((unsigned long)((offset >> 32) & 0xffffffff)),
		(void *)((unsigned long)(offset & 0xffffffff)),
		(void *)((unsigned long)count),
C
Christoph Hellwig 已提交
71 72
		(void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
		(void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
73
		(void *)((unsigned long)current_pid()),
L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81 82 83 84
		(void *)NULL,
		(void *)NULL,
		(void *)NULL,
		(void *)NULL,
		(void *)NULL,
		(void *)NULL);
}

void
xfs_iomap_map_trace(
	int		tag,
85
	xfs_inode_t	*ip,
L
Linus Torvalds 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
	xfs_off_t	offset,
	ssize_t		count,
	xfs_iomap_t	*iomapp,
	xfs_bmbt_irec_t	*imapp,
	int		flags)
{
	if (!ip->i_rwtrace)
		return;

	ktrace_enter(ip->i_rwtrace,
		(void *)((unsigned long)tag),
		(void *)ip,
		(void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
		(void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
		(void *)((unsigned long)((offset >> 32) & 0xffffffff)),
		(void *)((unsigned long)(offset & 0xffffffff)),
		(void *)((unsigned long)count),
		(void *)((unsigned long)flags),
		(void *)((unsigned long)((iomapp->iomap_offset >> 32) & 0xffffffff)),
		(void *)((unsigned long)(iomapp->iomap_offset & 0xffffffff)),
		(void *)((unsigned long)(iomapp->iomap_delta)),
		(void *)((unsigned long)(iomapp->iomap_bsize)),
		(void *)((unsigned long)(iomapp->iomap_bn)),
		(void *)(__psint_t)(imapp->br_startoff),
		(void *)((unsigned long)(imapp->br_blockcount)),
		(void *)(__psint_t)(imapp->br_startblock));
}
#else
#define xfs_iomap_enter_trace(tag, io, offset, count)
#define xfs_iomap_map_trace(tag, io, offset, count, iomapp, imapp, flags)
#endif

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

STATIC int
xfs_imap_to_bmap(
125
	xfs_inode_t	*ip,
L
Linus Torvalds 已提交
126 127 128 129 130 131 132
	xfs_off_t	offset,
	xfs_bmbt_irec_t *imap,
	xfs_iomap_t	*iomapp,
	int		imaps,			/* Number of imap entries */
	int		iomaps,			/* Number of iomap entries */
	int		flags)
{
133
	xfs_mount_t	*mp = ip->i_mount;
L
Linus Torvalds 已提交
134 135 136 137 138 139 140 141 142 143
	int		pbm;
	xfs_fsblock_t	start_block;


	for (pbm = 0; imaps && pbm < iomaps; imaps--, iomapp++, imap++, pbm++) {
		iomapp->iomap_offset = XFS_FSB_TO_B(mp, imap->br_startoff);
		iomapp->iomap_delta = offset - iomapp->iomap_offset;
		iomapp->iomap_bsize = XFS_FSB_TO_B(mp, imap->br_blockcount);
		iomapp->iomap_flags = flags;

144
		if (XFS_IS_REALTIME_INODE(ip)) {
L
Linus Torvalds 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157
			iomapp->iomap_flags |= IOMAP_REALTIME;
			iomapp->iomap_target = mp->m_rtdev_targp;
		} else {
			iomapp->iomap_target = mp->m_ddev_targp;
		}
		start_block = imap->br_startblock;
		if (start_block == HOLESTARTBLOCK) {
			iomapp->iomap_bn = IOMAP_DADDR_NULL;
			iomapp->iomap_flags |= IOMAP_HOLE;
		} else if (start_block == DELAYSTARTBLOCK) {
			iomapp->iomap_bn = IOMAP_DADDR_NULL;
			iomapp->iomap_flags |= IOMAP_DELAY;
		} else {
158
			iomapp->iomap_bn = XFS_FSB_TO_DB(ip, start_block);
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169
			if (ISUNWRITTEN(imap))
				iomapp->iomap_flags |= IOMAP_UNWRITTEN;
		}

		offset += iomapp->iomap_bsize - iomapp->iomap_delta;
	}
	return pbm;	/* Return the number filled */
}

int
xfs_iomap(
170
	xfs_inode_t	*ip,
L
Linus Torvalds 已提交
171 172 173 174 175 176
	xfs_off_t	offset,
	ssize_t		count,
	int		flags,
	xfs_iomap_t	*iomapp,
	int		*niomaps)
{
177
	xfs_mount_t	*mp = ip->i_mount;
L
Linus Torvalds 已提交
178 179 180 181 182 183 184 185
	xfs_fileoff_t	offset_fsb, end_fsb;
	int		error = 0;
	int		lockmode = 0;
	xfs_bmbt_irec_t	imap;
	int		nimaps = 1;
	int		bmapi_flags = 0;
	int		iomap_flags = 0;

186 187
	ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);

L
Linus Torvalds 已提交
188 189 190
	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

C
Christoph Hellwig 已提交
191
	switch (flags & (BMAPI_READ | BMAPI_WRITE | BMAPI_ALLOCATE)) {
L
Linus Torvalds 已提交
192
	case BMAPI_READ:
193 194
		xfs_iomap_enter_trace(XFS_IOMAP_READ_ENTER, ip, offset, count);
		lockmode = xfs_ilock_map_shared(ip);
L
Linus Torvalds 已提交
195 196 197
		bmapi_flags = XFS_BMAPI_ENTIRE;
		break;
	case BMAPI_WRITE:
198
		xfs_iomap_enter_trace(XFS_IOMAP_WRITE_ENTER, ip, offset, count);
C
Christoph Hellwig 已提交
199
		lockmode = XFS_ILOCK_EXCL;
200 201
		if (flags & BMAPI_IGNSTATE)
			bmapi_flags |= XFS_BMAPI_IGSTATE|XFS_BMAPI_ENTIRE;
202
		xfs_ilock(ip, lockmode);
L
Linus Torvalds 已提交
203 204
		break;
	case BMAPI_ALLOCATE:
205
		xfs_iomap_enter_trace(XFS_IOMAP_ALLOC_ENTER, ip, offset, count);
C
Christoph Hellwig 已提交
206
		lockmode = XFS_ILOCK_SHARED;
L
Linus Torvalds 已提交
207
		bmapi_flags = XFS_BMAPI_ENTIRE;
208

L
Linus Torvalds 已提交
209 210
		/* Attempt non-blocking lock */
		if (flags & BMAPI_TRYLOCK) {
211
			if (!xfs_ilock_nowait(ip, lockmode))
L
Linus Torvalds 已提交
212 213
				return XFS_ERROR(EAGAIN);
		} else {
214
			xfs_ilock(ip, lockmode);
L
Linus Torvalds 已提交
215 216 217 218 219 220 221 222 223 224 225 226
		}
		break;
	default:
		BUG();
	}

	ASSERT(offset <= mp->m_maxioffset);
	if ((xfs_fsize_t)offset + count > mp->m_maxioffset)
		count = mp->m_maxioffset - offset;
	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
	offset_fsb = XFS_B_TO_FSBT(mp, offset);

227
	error = xfs_bmapi(NULL, ip, offset_fsb,
L
Linus Torvalds 已提交
228 229
			(xfs_filblks_t)(end_fsb - offset_fsb),
			bmapi_flags,  NULL, 0, &imap,
230
			&nimaps, NULL, NULL);
L
Linus Torvalds 已提交
231 232 233 234

	if (error)
		goto out;

C
Christoph Hellwig 已提交
235
	switch (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)) {
L
Linus Torvalds 已提交
236 237
	case BMAPI_WRITE:
		/* If we found an extent, return it */
238
		if (nimaps &&
239
		    (imap.br_startblock != HOLESTARTBLOCK) &&
240
		    (imap.br_startblock != DELAYSTARTBLOCK)) {
241
			xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP, ip,
L
Linus Torvalds 已提交
242 243 244 245 246
					offset, count, iomapp, &imap, flags);
			break;
		}

		if (flags & (BMAPI_DIRECT|BMAPI_MMAP)) {
247 248
			error = xfs_iomap_write_direct(ip, offset, count, flags,
						       &imap, &nimaps, nimaps);
L
Linus Torvalds 已提交
249
		} else {
250 251
			error = xfs_iomap_write_delay(ip, offset, count, flags,
						      &imap, &nimaps);
L
Linus Torvalds 已提交
252 253
		}
		if (!error) {
254
			xfs_iomap_map_trace(XFS_IOMAP_ALLOC_MAP, ip,
L
Linus Torvalds 已提交
255 256 257 258 259 260
					offset, count, iomapp, &imap, flags);
		}
		iomap_flags = IOMAP_NEW;
		break;
	case BMAPI_ALLOCATE:
		/* If we found an extent, return it */
261
		xfs_iunlock(ip, lockmode);
L
Linus Torvalds 已提交
262 263 264
		lockmode = 0;

		if (nimaps && !ISNULLSTARTBLOCK(imap.br_startblock)) {
265
			xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP, ip,
L
Linus Torvalds 已提交
266 267 268 269
					offset, count, iomapp, &imap, flags);
			break;
		}

270
		error = xfs_iomap_write_allocate(ip, offset, count,
271
						 &imap, &nimaps);
L
Linus Torvalds 已提交
272 273 274 275
		break;
	}

	if (nimaps) {
276
		*niomaps = xfs_imap_to_bmap(ip, offset, &imap,
L
Linus Torvalds 已提交
277 278 279 280 281 282 283
					    iomapp, nimaps, *niomaps, iomap_flags);
	} else if (niomaps) {
		*niomaps = 0;
	}

out:
	if (lockmode)
284
		xfs_iunlock(ip, lockmode);
L
Linus Torvalds 已提交
285 286 287
	return XFS_ERROR(error);
}

288

289 290 291
STATIC int
xfs_iomap_eof_align_last_fsb(
	xfs_mount_t	*mp,
292
	xfs_inode_t	*ip,
293 294 295 296 297 298 299 300
	xfs_fsize_t	isize,
	xfs_extlen_t	extsize,
	xfs_fileoff_t	*last_fsb)
{
	xfs_fileoff_t	new_last_fsb = 0;
	xfs_extlen_t	align;
	int		eof, error;

301
	if (XFS_IS_REALTIME_INODE(ip))
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
		;
	/*
	 * If mounted with the "-o swalloc" option, roundup the allocation
	 * request to a stripe width boundary if the file size is >=
	 * stripe width and we are allocating past the allocation eof.
	 */
	else if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC) &&
	        (isize >= XFS_FSB_TO_B(mp, mp->m_swidth)))
		new_last_fsb = roundup_64(*last_fsb, mp->m_swidth);
	/*
	 * Roundup 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.
	 */
	else if (mp->m_dalign && (isize >= XFS_FSB_TO_B(mp, mp->m_dalign)))
		new_last_fsb = roundup_64(*last_fsb, mp->m_dalign);

	/*
	 * 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) {
332
		error = xfs_bmap_eof(ip, new_last_fsb, XFS_DATA_FORK, &eof);
333 334 335 336 337 338 339 340
		if (error)
			return error;
		if (eof)
			*last_fsb = new_last_fsb;
	}
	return 0;
}

L
Linus Torvalds 已提交
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 367 368 369 370 371 372
STATIC int
xfs_flush_space(
	xfs_inode_t	*ip,
	int		*fsynced,
	int		*ioflags)
{
	switch (*fsynced) {
	case 0:
		if (ip->i_delayed_blks) {
			xfs_iunlock(ip, XFS_ILOCK_EXCL);
			xfs_flush_inode(ip);
			xfs_ilock(ip, XFS_ILOCK_EXCL);
			*fsynced = 1;
		} else {
			*ioflags |= BMAPI_SYNC;
			*fsynced = 2;
		}
		return 0;
	case 1:
		*fsynced = 2;
		*ioflags |= BMAPI_SYNC;
		return 0;
	case 2:
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		xfs_flush_device(ip);
		xfs_ilock(ip, XFS_ILOCK_EXCL);
		*fsynced = 3;
		return 0;
	}
	return 1;
}

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
STATIC int
xfs_cmn_err_fsblock_zero(
	xfs_inode_t	*ip,
	xfs_bmbt_irec_t	*imap)
{
	xfs_cmn_err(XFS_PTAG_FSBLOCK_ZERO, CE_ALERT, ip->i_mount,
			"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;
}

L
Linus Torvalds 已提交
390 391 392
int
xfs_iomap_write_direct(
	xfs_inode_t	*ip,
393
	xfs_off_t	offset,
L
Linus Torvalds 已提交
394 395 396 397 398 399 400 401 402
	size_t		count,
	int		flags,
	xfs_bmbt_irec_t *ret_imap,
	int		*nmaps,
	int		found)
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
403
	xfs_filblks_t	count_fsb, resaligned;
L
Linus Torvalds 已提交
404
	xfs_fsblock_t	firstfsb;
405 406
	xfs_extlen_t	extsz, temp;
	xfs_fsize_t	isize;
407
	int		nimaps;
L
Linus Torvalds 已提交
408
	int		bmapi_flag;
409
	int		quota_flag;
L
Linus Torvalds 已提交
410 411
	int		rt;
	xfs_trans_t	*tp;
412
	xfs_bmbt_irec_t imap;
L
Linus Torvalds 已提交
413
	xfs_bmap_free_t free_list;
414
	uint		qblocks, resblks, resrtextents;
L
Linus Torvalds 已提交
415
	int		committed;
416
	int		error;
L
Linus Torvalds 已提交
417 418 419 420 421 422 423 424 425

	/*
	 * Make sure that the dquots are there. This doesn't hold
	 * the ilock across a disk read.
	 */
	error = XFS_QM_DQATTACH(ip->i_mount, ip, XFS_QMOPT_ILOCKED);
	if (error)
		return XFS_ERROR(error);

426
	rt = XFS_IS_REALTIME_INODE(ip);
427
	extsz = xfs_get_extsz_hint(ip);
L
Linus Torvalds 已提交
428

429
	isize = ip->i_size;
C
Christoph Hellwig 已提交
430 431
	if (ip->i_new_size > isize)
		isize = ip->i_new_size;
L
Linus Torvalds 已提交
432

433 434
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
435
	if ((offset + count) > isize) {
436
		error = xfs_iomap_eof_align_last_fsb(mp, ip, isize, extsz,
437 438 439
							&last_fsb);
		if (error)
			goto error_out;
L
Linus Torvalds 已提交
440
	} else {
441 442 443 444
		if (found && (ret_imap->br_startblock == HOLESTARTBLOCK))
			last_fsb = MIN(last_fsb, (xfs_fileoff_t)
					ret_imap->br_blockcount +
					ret_imap->br_startoff);
L
Linus Torvalds 已提交
445
	}
446 447 448 449 450 451 452 453 454 455 456 457 458 459
	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;
460 461 462 463
		resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
		quota_flag = XFS_QMOPT_RES_RTBLKS;
	} else {
		resrtextents = 0;
464
		resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
465 466
		quota_flag = XFS_QMOPT_RES_REGBLKS;
	}
L
Linus Torvalds 已提交
467 468

	/*
469
	 * Allocate and setup the transaction
L
Linus Torvalds 已提交
470 471 472 473
	 */
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
	tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
	error = xfs_trans_reserve(tp, resblks,
474
			XFS_WRITE_LOG_RES(mp), resrtextents,
L
Linus Torvalds 已提交
475 476 477
			XFS_TRANS_PERM_LOG_RES,
			XFS_WRITE_LOG_COUNT);
	/*
478
	 * Check for running out of space, note: need lock to return
L
Linus Torvalds 已提交
479 480 481 482 483
	 */
	if (error)
		xfs_trans_cancel(tp, 0);
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	if (error)
484
		goto error_out;
L
Linus Torvalds 已提交
485

486 487 488
	error = XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip,
					      qblocks, 0, quota_flag);
	if (error)
L
Linus Torvalds 已提交
489 490 491 492 493
		goto error1;

	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	xfs_trans_ihold(tp, ip);

494
	bmapi_flag = XFS_BMAPI_WRITE;
495
	if ((flags & BMAPI_DIRECT) && (offset < ip->i_size || extsz))
L
Linus Torvalds 已提交
496 497 498
		bmapi_flag |= XFS_BMAPI_PREALLOC;

	/*
499
	 * Issue the xfs_bmapi() call to allocate the blocks
L
Linus Torvalds 已提交
500 501
	 */
	XFS_BMAP_INIT(&free_list, &firstfsb);
502
	nimaps = 1;
503
	error = xfs_bmapi(tp, ip, offset_fsb, count_fsb, bmapi_flag,
504
		&firstfsb, 0, &imap, &nimaps, &free_list, NULL);
505
	if (error)
L
Linus Torvalds 已提交
506 507 508
		goto error0;

	/*
509
	 * Complete the transaction
L
Linus Torvalds 已提交
510
	 */
511
	error = xfs_bmap_finish(&tp, &free_list, &committed);
512
	if (error)
L
Linus Torvalds 已提交
513
		goto error0;
514
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
515
	if (error)
L
Linus Torvalds 已提交
516 517
		goto error_out;

518 519 520
	/*
	 * Copy any maps to caller's array and return any error.
	 */
L
Linus Torvalds 已提交
521
	if (nimaps == 0) {
522 523 524 525
		error = ENOSPC;
		goto error_out;
	}

526
	if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip))) {
527
		error = xfs_cmn_err_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
528 529 530
		goto error_out;
	}

531
	*ret_imap = imap;
L
Linus Torvalds 已提交
532 533 534
	*nmaps = 1;
	return 0;

535
error0:	/* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
L
Linus Torvalds 已提交
536
	xfs_bmap_cancel(&free_list);
537
	XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp, tp, ip, qblocks, 0, quota_flag);
L
Linus Torvalds 已提交
538

539
error1:	/* Just cancel transaction */
L
Linus Torvalds 已提交
540 541 542 543 544 545 546
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
	*nmaps = 0;	/* nothing set-up here */

error_out:
	return XFS_ERROR(error);
}

547 548 549 550 551 552 553 554 555 556 557 558 559 560
/*
 * 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().
 *
 * For sync writes, we are flushing delayed allocate space to
 * try to make additional space available for allocation near
 * the filesystem full boundary - preallocation hurts in that
 * situation, of course.
 */
STATIC int
xfs_iomap_eof_want_preallocate(
	xfs_mount_t	*mp,
561
	xfs_inode_t	*ip,
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
	xfs_fsize_t	isize,
	xfs_off_t	offset,
	size_t		count,
	int		ioflag,
	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;

	*prealloc = 0;
	if ((ioflag & BMAPI_SYNC) || (offset + count) <= isize)
		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)));
	count_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
	while (count_fsb > 0) {
		imaps = nimaps;
587
		firstblock = NULLFSBLOCK;
588
		error = xfs_bmapi(NULL, ip, start_fsb, count_fsb, 0,
589
				  &firstblock, 0, imap, &imaps, NULL, NULL);
590 591 592 593 594 595 596 597 598 599 600 601 602 603
		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;
		}
	}
	*prealloc = 1;
	return 0;
}

L
Linus Torvalds 已提交
604 605 606
int
xfs_iomap_write_delay(
	xfs_inode_t	*ip,
607
	xfs_off_t	offset,
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615
	size_t		count,
	int		ioflag,
	xfs_bmbt_irec_t *ret_imap,
	int		*nmaps)
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_fileoff_t	offset_fsb;
	xfs_fileoff_t	last_fsb;
616 617
	xfs_off_t	aligned_offset;
	xfs_fileoff_t	ioalign;
L
Linus Torvalds 已提交
618
	xfs_fsblock_t	firstblock;
619 620
	xfs_extlen_t	extsz;
	xfs_fsize_t	isize;
L
Linus Torvalds 已提交
621 622
	int		nimaps;
	xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS];
623 624
	int		prealloc, fsynced = 0;
	int		error;
L
Linus Torvalds 已提交
625

C
Christoph Hellwig 已提交
626
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
627 628 629 630 631 632 633 634 635

	/*
	 * Make sure that the dquots are there. This doesn't hold
	 * the ilock across a disk read.
	 */
	error = XFS_QM_DQATTACH(mp, ip, XFS_QMOPT_ILOCKED);
	if (error)
		return XFS_ERROR(error);

636
	extsz = xfs_get_extsz_hint(ip);
637 638
	offset_fsb = XFS_B_TO_FSBT(mp, offset);

L
Linus Torvalds 已提交
639
retry:
640
	isize = ip->i_size;
C
Christoph Hellwig 已提交
641 642
	if (ip->i_new_size > isize)
		isize = ip->i_new_size;
L
Linus Torvalds 已提交
643

644
	error = xfs_iomap_eof_want_preallocate(mp, ip, isize, offset, count,
645 646 647
				ioflag, imap, XFS_WRITE_IMAPS, &prealloc);
	if (error)
		return error;
L
Linus Torvalds 已提交
648

649
	if (prealloc) {
L
Linus Torvalds 已提交
650 651
		aligned_offset = XFS_WRITEIO_ALIGN(mp, (offset + count - 1));
		ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
652 653 654
		last_fsb = ioalign + mp->m_writeio_blocks;
	} else {
		last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
L
Linus Torvalds 已提交
655 656
	}

657
	if (prealloc || extsz) {
658
		error = xfs_iomap_eof_align_last_fsb(mp, ip, isize, extsz,
659 660
							&last_fsb);
		if (error)
L
Linus Torvalds 已提交
661 662
			return error;
	}
663 664 665

	nimaps = XFS_WRITE_IMAPS;
	firstblock = NULLFSBLOCK;
666
	error = xfs_bmapi(NULL, ip, offset_fsb,
L
Linus Torvalds 已提交
667 668 669
			  (xfs_filblks_t)(last_fsb - offset_fsb),
			  XFS_BMAPI_DELAY | XFS_BMAPI_WRITE |
			  XFS_BMAPI_ENTIRE, &firstblock, 1, imap,
670
			  &nimaps, NULL, NULL);
671
	if (error && (error != ENOSPC))
L
Linus Torvalds 已提交
672
		return XFS_ERROR(error);
673

L
Linus Torvalds 已提交
674 675
	/*
	 * If bmapi returned us nothing, and if we didn't get back EDQUOT,
676
	 * then we must have run out of space - flush delalloc, and retry..
L
Linus Torvalds 已提交
677 678 679
	 */
	if (nimaps == 0) {
		xfs_iomap_enter_trace(XFS_IOMAP_WRITE_NOSPACE,
680
					ip, offset, count);
L
Linus Torvalds 已提交
681 682 683 684 685 686 687
		if (xfs_flush_space(ip, &fsynced, &ioflag))
			return XFS_ERROR(ENOSPC);

		error = 0;
		goto retry;
	}

688
	if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
689
		return xfs_cmn_err_fsblock_zero(ip, &imap[0]);
690 691 692 693

	*ret_imap = imap[0];
	*nmaps = 1;

L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702
	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.
703 704 705
 *
 * 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 已提交
706 707 708 709
 */
int
xfs_iomap_write_allocate(
	xfs_inode_t	*ip,
710
	xfs_off_t	offset,
711
	size_t		count,
L
Linus Torvalds 已提交
712 713 714 715 716 717 718 719 720
	xfs_bmbt_irec_t *map,
	int		*retmap)
{
	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;
721
	xfs_bmbt_irec_t	imap;
L
Linus Torvalds 已提交
722
	xfs_trans_t	*tp;
723
	int		nimaps, committed;
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732 733 734
	int		error = 0;
	int		nres;

	*retmap = 0;

	/*
	 * Make sure that the dquots are there.
	 */
	if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
		return XFS_ERROR(error);

735
	offset_fsb = XFS_B_TO_FSBT(mp, offset);
L
Linus Torvalds 已提交
736
	count_fsb = map->br_blockcount;
737
	map_start_fsb = map->br_startoff;
L
Linus Torvalds 已提交
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753

	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);
754
			tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
			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);
			xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
			xfs_trans_ihold(tp, ip);

			XFS_BMAP_INIT(&free_list, &first_block);

			/*
771 772 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
			 * 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 已提交
800
			 */
801
			nimaps = 1;
802
			end_fsb = XFS_B_TO_FSB(mp, ip->i_size);
803 804 805 806 807
			error = xfs_bmap_last_offset(NULL, ip, &last_block,
							XFS_DATA_FORK);
			if (error)
				goto trans_cancel;

L
Linus Torvalds 已提交
808 809 810 811 812 813 814 815 816 817
			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;
				}
			}

			/* Go get the actual blocks */
818
			error = xfs_bmapi(tp, ip, map_start_fsb, count_fsb,
L
Linus Torvalds 已提交
819
					XFS_BMAPI_WRITE, &first_block, 1,
820
					&imap, &nimaps, &free_list, NULL);
L
Linus Torvalds 已提交
821 822 823
			if (error)
				goto trans_cancel;

824
			error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
825 826 827
			if (error)
				goto trans_cancel;

828
			error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836 837 838
			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
		 */
839
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
840
			return xfs_cmn_err_fsblock_zero(ip, &imap);
841

842 843 844 845 846 847 848
		if ((offset_fsb >= imap.br_startoff) &&
		    (offset_fsb < (imap.br_startoff +
				   imap.br_blockcount))) {
			*map = imap;
			*retmap = 1;
			XFS_STATS_INC(xs_xstrat_quick);
			return 0;
L
Linus Torvalds 已提交
849 850
		}

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

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,
870
	xfs_off_t	offset,
L
Linus Torvalds 已提交
871 872 873 874 875 876
	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;
877 878 879 880 881 882
	xfs_fsblock_t	firstfsb;
	int		nimaps;
	xfs_trans_t	*tp;
	xfs_bmbt_irec_t imap;
	xfs_bmap_free_t free_list;
	uint		resblks;
L
Linus Torvalds 已提交
883 884 885
	int		committed;
	int		error;

886
	xfs_iomap_enter_trace(XFS_IOMAP_UNWRITTEN, ip, offset, count);
L
Linus Torvalds 已提交
887 888 889 890 891

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

892 893 894 895 896 897 898 899 900 901
	/*
	 * 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.
	 */
902
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
L
Linus Torvalds 已提交
903

904
	do {
L
Linus Torvalds 已提交
905 906 907 908 909 910
		/*
		 * 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.
		 */
		tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
911
		tp->t_flags |= XFS_TRANS_RESERVE;
912
		error = xfs_trans_reserve(tp, resblks,
L
Linus Torvalds 已提交
913 914 915 916 917
				XFS_WRITE_LOG_RES(mp), 0,
				XFS_TRANS_PERM_LOG_RES,
				XFS_WRITE_LOG_COUNT);
		if (error) {
			xfs_trans_cancel(tp, 0);
918
			return XFS_ERROR(error);
L
Linus Torvalds 已提交
919 920 921 922 923 924 925 926 927 928 929
		}

		xfs_ilock(ip, XFS_ILOCK_EXCL);
		xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
		xfs_trans_ihold(tp, ip);

		/*
		 * Modify the unwritten extent state of the buffer.
		 */
		XFS_BMAP_INIT(&free_list, &firstfsb);
		nimaps = 1;
930
		error = xfs_bmapi(tp, ip, offset_fsb, count_fsb,
931
				  XFS_BMAPI_WRITE|XFS_BMAPI_CONVERT, &firstfsb,
932
				  1, &imap, &nimaps, &free_list, NULL);
L
Linus Torvalds 已提交
933 934 935
		if (error)
			goto error_on_bmapi_transaction;

936
		error = xfs_bmap_finish(&(tp), &(free_list), &committed);
L
Linus Torvalds 已提交
937 938 939
		if (error)
			goto error_on_bmapi_transaction;

940
		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
941 942
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error)
943 944
			return XFS_ERROR(error);

945
		if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
946
			return xfs_cmn_err_fsblock_zero(ip, &imap);
L
Linus Torvalds 已提交
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967

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