xfs_vnodeops.c 55.2 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

L
Linus Torvalds 已提交
19
#include "xfs.h"
20
#include "xfs_fs.h"
L
Linus Torvalds 已提交
21
#include "xfs_types.h"
22
#include "xfs_bit.h"
L
Linus Torvalds 已提交
23 24 25 26 27 28
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir2.h"
#include "xfs_mount.h"
29
#include "xfs_da_btree.h"
L
Linus Torvalds 已提交
30 31 32 33
#include "xfs_bmap_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
34 35 36 37
#include "xfs_inode_item.h"
#include "xfs_itable.h"
#include "xfs_ialloc.h"
#include "xfs_alloc.h"
L
Linus Torvalds 已提交
38
#include "xfs_bmap.h"
39
#include "xfs_acl.h"
L
Linus Torvalds 已提交
40 41 42 43
#include "xfs_attr.h"
#include "xfs_error.h"
#include "xfs_quota.h"
#include "xfs_utils.h"
44
#include "xfs_rtalloc.h"
L
Linus Torvalds 已提交
45 46
#include "xfs_trans_space.h"
#include "xfs_log_priv.h"
47
#include "xfs_filestream.h"
48
#include "xfs_vnodeops.h"
C
Christoph Hellwig 已提交
49
#include "xfs_trace.h"
D
Dave Chinner 已提交
50
#include "xfs_icache.h"
L
Linus Torvalds 已提交
51

52 53 54 55 56 57 58
/*
 * The maximum pathlen is 1024 bytes. Since the minimum file system
 * blocksize is 512 bytes, we can get a max of 2 extents back from
 * bmapi.
 */
#define SYMLINK_MAPS 2

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
STATIC int
xfs_readlink_bmap(
	xfs_inode_t	*ip,
	char		*link)
{
	xfs_mount_t	*mp = ip->i_mount;
	int		pathlen = ip->i_d.di_size;
	int             nmaps = SYMLINK_MAPS;
	xfs_bmbt_irec_t mval[SYMLINK_MAPS];
	xfs_daddr_t	d;
	int		byte_cnt;
	int		n;
	xfs_buf_t	*bp;
	int		error = 0;

D
Dave Chinner 已提交
74 75
	error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, pathlen), mval, &nmaps,
			       0);
76 77 78 79 80 81 82
	if (error)
		goto out;

	for (n = 0; n < nmaps; n++) {
		d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
		byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);

83
		bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0);
84 85
		if (!bp)
			return XFS_ERROR(ENOMEM);
86
		error = bp->b_error;
87
		if (error) {
88
			xfs_buf_ioerror_alert(bp, __func__);
89 90 91 92 93 94 95
			xfs_buf_relse(bp);
			goto out;
		}
		if (pathlen < byte_cnt)
			byte_cnt = pathlen;
		pathlen -= byte_cnt;

96
		memcpy(link, bp->b_addr, byte_cnt);
97 98 99 100 101 102 103 104 105 106
		xfs_buf_relse(bp);
	}

	link[ip->i_d.di_size] = '\0';
	error = 0;

 out:
	return error;
}

107
int
L
Linus Torvalds 已提交
108
xfs_readlink(
109
	xfs_inode_t     *ip,
110
	char		*link)
L
Linus Torvalds 已提交
111
{
112
	xfs_mount_t	*mp = ip->i_mount;
113
	xfs_fsize_t	pathlen;
L
Linus Torvalds 已提交
114 115
	int		error = 0;

C
Christoph Hellwig 已提交
116
	trace_xfs_readlink(ip);
L
Linus Torvalds 已提交
117 118 119 120 121 122

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

	xfs_ilock(ip, XFS_ILOCK_SHARED);

123 124 125
	pathlen = ip->i_d.di_size;
	if (!pathlen)
		goto out;
L
Linus Torvalds 已提交
126

127 128 129 130 131
	if (pathlen < 0 || pathlen > MAXPATHLEN) {
		xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
			 __func__, (unsigned long long) ip->i_ino,
			 (long long) pathlen);
		ASSERT(0);
132 133
		error = XFS_ERROR(EFSCORRUPTED);
		goto out;
134 135 136
	}


L
Linus Torvalds 已提交
137
	if (ip->i_df.if_flags & XFS_IFINLINE) {
138 139 140 141
		memcpy(link, ip->i_df.if_u1.if_data, pathlen);
		link[pathlen] = '\0';
	} else {
		error = xfs_readlink_bmap(ip, link);
L
Linus Torvalds 已提交
142 143
	}

144
 out:
L
Linus Torvalds 已提交
145 146 147 148 149
	xfs_iunlock(ip, XFS_ILOCK_SHARED);
	return error;
}

/*
150 151 152
 * This is called by xfs_inactive to free any blocks beyond eof
 * when the link count isn't zero and by xfs_dm_punch_hole() when
 * punching a hole to EOF.
L
Linus Torvalds 已提交
153
 */
154
int
155
xfs_free_eofblocks(
L
Linus Torvalds 已提交
156
	xfs_mount_t	*mp,
157
	xfs_inode_t	*ip,
158
	bool		need_iolock)
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171
{
	xfs_trans_t	*tp;
	int		error;
	xfs_fileoff_t	end_fsb;
	xfs_fileoff_t	last_fsb;
	xfs_filblks_t	map_len;
	int		nimaps;
	xfs_bmbt_irec_t	imap;

	/*
	 * Figure out if there are any blocks beyond the end
	 * of the file.  If not, then there is nothing to do.
	 */
172
	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
173
	last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
174
	if (last_fsb <= end_fsb)
175
		return 0;
176
	map_len = last_fsb - end_fsb;
L
Linus Torvalds 已提交
177 178 179

	nimaps = 1;
	xfs_ilock(ip, XFS_ILOCK_SHARED);
D
Dave Chinner 已提交
180
	error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
L
Linus Torvalds 已提交
181 182 183
	xfs_iunlock(ip, XFS_ILOCK_SHARED);

	if (!error && (nimaps != 0) &&
184 185
	    (imap.br_startblock != HOLESTARTBLOCK ||
	     ip->i_delayed_blks)) {
L
Linus Torvalds 已提交
186 187 188
		/*
		 * Attach the dquots to the inode up front.
		 */
C
Christoph Hellwig 已提交
189 190
		error = xfs_qm_dqattach(ip, 0);
		if (error)
191
			return error;
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199

		/*
		 * There are blocks after the end of file.
		 * Free them up now by truncating the file to
		 * its current size.
		 */
		tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);

200
		if (need_iolock) {
201 202
			if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
				xfs_trans_cancel(tp, 0);
203
				return EAGAIN;
204 205
			}
		}
L
Linus Torvalds 已提交
206 207 208 209 210 211 212 213

		error = xfs_trans_reserve(tp, 0,
					  XFS_ITRUNCATE_LOG_RES(mp),
					  0, XFS_TRANS_PERM_LOG_RES,
					  XFS_ITRUNCATE_LOG_COUNT);
		if (error) {
			ASSERT(XFS_FORCED_SHUTDOWN(mp));
			xfs_trans_cancel(tp, 0);
214 215
			if (need_iolock)
				xfs_iunlock(ip, XFS_IOLOCK_EXCL);
216
			return error;
L
Linus Torvalds 已提交
217 218 219
		}

		xfs_ilock(ip, XFS_ILOCK_EXCL);
220
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
221

222 223 224 225 226 227 228
		/*
		 * Do not update the on-disk file size.  If we update the
		 * on-disk file size and then the system crashes before the
		 * contents of the file are flushed to disk then the files
		 * may be full of holes (ie NULL files bug).
		 */
		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
229
					      XFS_ISIZE(ip));
L
Linus Torvalds 已提交
230
		if (error) {
231 232 233 234
			/*
			 * If we get an error at this point we simply don't
			 * bother truncating the file.
			 */
L
Linus Torvalds 已提交
235 236 237 238 239
			xfs_trans_cancel(tp,
					 (XFS_TRANS_RELEASE_LOG_RES |
					  XFS_TRANS_ABORT));
		} else {
			error = xfs_trans_commit(tp,
240
						XFS_TRANS_RELEASE_LOG_RES);
241 242
			if (!error)
				xfs_inode_clear_eofblocks_tag(ip);
L
Linus Torvalds 已提交
243
		}
244 245 246 247

		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (need_iolock)
			xfs_iunlock(ip, XFS_IOLOCK_EXCL);
L
Linus Torvalds 已提交
248
	}
249
	return error;
L
Linus Torvalds 已提交
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
}

/*
 * Free a symlink that has blocks associated with it.
 */
STATIC int
xfs_inactive_symlink_rmt(
	xfs_inode_t	*ip,
	xfs_trans_t	**tpp)
{
	xfs_buf_t	*bp;
	int		committed;
	int		done;
	int		error;
	xfs_fsblock_t	first_block;
	xfs_bmap_free_t	free_list;
	int		i;
	xfs_mount_t	*mp;
	xfs_bmbt_irec_t	mval[SYMLINK_MAPS];
	int		nmaps;
	xfs_trans_t	*ntp;
	int		size;
	xfs_trans_t	*tp;

	tp = *tpp;
	mp = ip->i_mount;
	ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
	/*
	 * We're freeing a symlink that has some
	 * blocks allocated to it.  Free the
	 * blocks here.  We know that we've got
	 * either 1 or 2 extents and that we can
	 * free them all in one bunmapi call.
	 */
	ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
C
Christoph Hellwig 已提交
285

L
Linus Torvalds 已提交
286 287 288 289 290 291 292 293 294 295 296 297 298
	/*
	 * Lock the inode, fix the size, and join it to the transaction.
	 * Hold it so in the normal path, we still have it locked for
	 * the second transaction.  In the error paths we need it
	 * held so the cancel won't rele it, see below.
	 */
	size = (int)ip->i_d.di_size;
	ip->i_d.di_size = 0;
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	/*
	 * Find the block(s) so we can inval and unmap them.
	 */
	done = 0;
299
	xfs_bmap_init(&free_list, &first_block);
300
	nmaps = ARRAY_SIZE(mval);
D
Dave Chinner 已提交
301 302 303
	error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, size),
				mval, &nmaps, 0);
	if (error)
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311
		goto error0;
	/*
	 * Invalidate the block(s).
	 */
	for (i = 0; i < nmaps; i++) {
		bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
			XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
			XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
312 313 314 315
		if (!bp) {
			error = ENOMEM;
			goto error1;
		}
L
Linus Torvalds 已提交
316 317 318 319 320 321
		xfs_trans_binval(tp, bp);
	}
	/*
	 * Unmap the dead block(s) to the free_list.
	 */
	if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
322
			&first_block, &free_list, &done)))
L
Linus Torvalds 已提交
323 324 325 326 327
		goto error1;
	ASSERT(done);
	/*
	 * Commit the first transaction.  This logs the EFI and the inode.
	 */
328
	if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
L
Linus Torvalds 已提交
329 330 331 332 333 334 335 336 337 338 339 340
		goto error1;
	/*
	 * The transaction must have been committed, since there were
	 * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
	 * The new tp has the extent freeing and EFDs.
	 */
	ASSERT(committed);
	/*
	 * The first xact was committed, so add the inode to the new one.
	 * Mark it dirty so it will be logged and moved forward in the log as
	 * part of every commit.
	 */
341
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
342 343 344 345 346 347
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	/*
	 * Get a new, empty transaction to return to our caller.
	 */
	ntp = xfs_trans_dup(tp);
	/*
348
	 * Commit the transaction containing extent freeing and EFDs.
L
Linus Torvalds 已提交
349 350 351 352
	 * If we get an error on the commit here or on the reserve below,
	 * we need to unlock the inode since the new transaction doesn't
	 * have the inode attached.
	 */
353
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
354 355 356 357 358
	tp = ntp;
	if (error) {
		ASSERT(XFS_FORCED_SHUTDOWN(mp));
		goto error0;
	}
359 360 361 362 363 364
	/*
	 * transaction commit worked ok so we can drop the extra ticket
	 * reference that we gained in xfs_trans_dup()
	 */
	xfs_log_ticket_put(tp->t_ticket);

L
Linus Torvalds 已提交
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
	/*
	 * Remove the memory for extent descriptions (just bookkeeping).
	 */
	if (ip->i_df.if_bytes)
		xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
	ASSERT(ip->i_df.if_bytes == 0);
	/*
	 * Put an itruncate log reservation in the new transaction
	 * for our caller.
	 */
	if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
			XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
		ASSERT(XFS_FORCED_SHUTDOWN(mp));
		goto error0;
	}
C
Christoph Hellwig 已提交
380 381

	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
382 383 384 385 386 387 388 389 390
	*tpp = tp;
	return 0;

 error1:
	xfs_bmap_cancel(&free_list);
 error0:
	return error;
}

391
int
L
Linus Torvalds 已提交
392
xfs_release(
393
	xfs_inode_t	*ip)
L
Linus Torvalds 已提交
394
{
395
	xfs_mount_t	*mp = ip->i_mount;
L
Linus Torvalds 已提交
396 397
	int		error;

398
	if (!S_ISREG(ip->i_d.di_mode) || (ip->i_d.di_mode == 0))
L
Linus Torvalds 已提交
399 400 401
		return 0;

	/* If this is a read-only mount, don't do this (would generate I/O) */
402
	if (mp->m_flags & XFS_MOUNT_RDONLY)
L
Linus Torvalds 已提交
403 404
		return 0;

405
	if (!XFS_FORCED_SHUTDOWN(mp)) {
406 407
		int truncated;

408 409 410 411 412 413 414 415 416 417
		/*
		 * If we are using filestreams, and we have an unlinked
		 * file that we are processing the last close on, then nothing
		 * will be able to reopen and write to this file. Purge this
		 * inode from the filestreams cache so that it doesn't delay
		 * teardown of the inode.
		 */
		if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
			xfs_filestream_deassociate(ip);

418 419 420 421
		/*
		 * If we previously truncated this file and removed old data
		 * in the process, we want to initiate "early" writeout on
		 * the last close.  This is an attempt to combat the notorious
L
Lucas De Marchi 已提交
422
		 * NULL files problem which is particularly noticeable from a
423 424 425 426 427
		 * truncate down, buffered (re-)write (delalloc), followed by
		 * a crash.  What we are effectively doing here is
		 * significantly reducing the time window where we'd otherwise
		 * be exposed to that problem.
		 */
428
		truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
429 430 431 432 433
		if (truncated) {
			xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
			if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
				xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
		}
434 435
	}

436 437
	if (ip->i_d.di_nlink == 0)
		return 0;
438

439
	if (xfs_can_free_eofblocks(ip, false)) {
440 441 442 443 444 445 446 447 448 449

		/*
		 * If we can't get the iolock just skip truncating the blocks
		 * past EOF because we could deadlock with the mmap_sem
		 * otherwise.  We'll get another chance to drop them once the
		 * last reference to the inode is dropped, so we'll never leak
		 * blocks permanently.
		 *
		 * Further, check if the inode is being opened, written and
		 * closed frequently and we have delayed allocation blocks
L
Lucas De Marchi 已提交
450
		 * outstanding (e.g. streaming writes from the NFS server),
451 452 453 454 455 456 457 458 459 460 461 462 463
		 * truncating the blocks past EOF will cause fragmentation to
		 * occur.
		 *
		 * In this case don't do the truncation, either, but we have to
		 * be careful how we detect this case. Blocks beyond EOF show
		 * up as i_delayed_blks even when the inode is clean, so we
		 * need to truncate them away first before checking for a dirty
		 * release. Hence on the first dirty close we will still remove
		 * the speculative allocation, but after that we will leave it
		 * in place.
		 */
		if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
			return 0;
L
Linus Torvalds 已提交
464

465
		error = xfs_free_eofblocks(mp, ip, true);
466
		if (error && error != EAGAIN)
467 468 469 470 471 472
			return error;

		/* delalloc blocks after truncation means it really is dirty */
		if (ip->i_delayed_blks)
			xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
	}
L
Linus Torvalds 已提交
473 474 475 476 477 478 479 480 481 482 483
	return 0;
}

/*
 * xfs_inactive
 *
 * This is called when the vnode reference count for the vnode
 * goes to zero.  If the file has been unlinked, then it must
 * now be truncated.  Also, we clear all of the read-ahead state
 * kept for the inode here since the file is now closed.
 */
484
int
L
Linus Torvalds 已提交
485
xfs_inactive(
486
	xfs_inode_t	*ip)
L
Linus Torvalds 已提交
487
{
488
	xfs_bmap_free_t	free_list;
L
Linus Torvalds 已提交
489 490 491 492 493
	xfs_fsblock_t	first_block;
	int		committed;
	xfs_trans_t	*tp;
	xfs_mount_t	*mp;
	int		error;
C
Christoph Hellwig 已提交
494
	int		truncate = 0;
L
Linus Torvalds 已提交
495 496 497 498 499

	/*
	 * If the inode is already free, then there can be nothing
	 * to clean up here.
	 */
C
Christoph Hellwig 已提交
500
	if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
L
Linus Torvalds 已提交
501 502 503 504 505 506 507 508 509 510
		ASSERT(ip->i_df.if_real_bytes == 0);
		ASSERT(ip->i_df.if_broot_bytes == 0);
		return VN_INACTIVE_CACHE;
	}

	mp = ip->i_mount;

	error = 0;

	/* If this is a read-only mount, don't do this (would generate I/O) */
511
	if (mp->m_flags & XFS_MOUNT_RDONLY)
L
Linus Torvalds 已提交
512 513 514
		goto out;

	if (ip->i_d.di_nlink != 0) {
515 516 517 518 519 520
		/*
		 * force is true because we are evicting an inode from the
		 * cache. Post-eof blocks must be freed, lest we end up with
		 * broken free space accounting.
		 */
		if (xfs_can_free_eofblocks(ip, true)) {
521
			error = xfs_free_eofblocks(mp, ip, false);
522
			if (error)
523
				return VN_INACTIVE_CACHE;
L
Linus Torvalds 已提交
524 525 526 527
		}
		goto out;
	}

C
Christoph Hellwig 已提交
528 529 530 531
	if (S_ISREG(ip->i_d.di_mode) &&
	    (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
	     ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
		truncate = 1;
L
Linus Torvalds 已提交
532

C
Christoph Hellwig 已提交
533 534
	error = xfs_qm_dqattach(ip, 0);
	if (error)
535
		return VN_INACTIVE_CACHE;
L
Linus Torvalds 已提交
536 537

	tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
C
Christoph Hellwig 已提交
538 539 540 541 542 543 544 545 546 547 548 549
	error = xfs_trans_reserve(tp, 0,
			(truncate || S_ISLNK(ip->i_d.di_mode)) ?
				XFS_ITRUNCATE_LOG_RES(mp) :
				XFS_IFREE_LOG_RES(mp),
			0,
			XFS_TRANS_PERM_LOG_RES,
			XFS_ITRUNCATE_LOG_COUNT);
	if (error) {
		ASSERT(XFS_FORCED_SHUTDOWN(mp));
		xfs_trans_cancel(tp, 0);
		return VN_INACTIVE_CACHE;
	}
L
Linus Torvalds 已提交
550

551
	xfs_ilock(ip, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
552
	xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
553

C
Christoph Hellwig 已提交
554 555 556 557 558 559 560 561 562 563 564 565 566 567
	if (S_ISLNK(ip->i_d.di_mode)) {
		/*
		 * Zero length symlinks _can_ exist.
		 */
		if (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) {
			error = xfs_inactive_symlink_rmt(ip, &tp);
			if (error)
				goto out_cancel;
		} else if (ip->i_df.if_bytes > 0) {
			xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
					  XFS_DATA_FORK);
			ASSERT(ip->i_df.if_bytes == 0);
		}
	} else if (truncate) {
568 569 570 571
		ip->i_d.di_size = 0;
		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
C
Christoph Hellwig 已提交
572 573
		if (error)
			goto out_cancel;
574 575

		ASSERT(ip->i_d.di_nextents == 0);
L
Linus Torvalds 已提交
576 577 578
	}

	/*
579 580 581
	 * If there are attributes associated with the file then blow them away
	 * now.  The code calls a routine that recursively deconstructs the
	 * attribute fork.  We need to just commit the current transaction
L
Linus Torvalds 已提交
582 583 584
	 * because we can't use it for xfs_attr_inactive().
	 */
	if (ip->i_d.di_anextents > 0) {
585 586 587 588
		ASSERT(ip->i_d.di_forkoff != 0);

		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
		if (error)
589 590 591
			goto out_unlock;

		xfs_iunlock(ip, XFS_ILOCK_EXCL);
592 593 594

		error = xfs_attr_inactive(ip);
		if (error)
595
			goto out;
596 597 598 599 600 601

		tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
		error = xfs_trans_reserve(tp, 0,
					  XFS_IFREE_LOG_RES(mp),
					  0, XFS_TRANS_PERM_LOG_RES,
					  XFS_INACTIVE_LOG_COUNT);
602 603 604 605
		if (error) {
			xfs_trans_cancel(tp, 0);
			goto out;
		}
606 607 608

		xfs_ilock(ip, XFS_ILOCK_EXCL);
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
609 610
	}

611 612 613 614 615
	if (ip->i_afp)
		xfs_idestroy_fork(ip, XFS_ATTR_FORK);

	ASSERT(ip->i_d.di_anextents == 0);

L
Linus Torvalds 已提交
616 617 618
	/*
	 * Free the inode.
	 */
619
	xfs_bmap_init(&free_list, &first_block);
L
Linus Torvalds 已提交
620 621 622 623 624 625 626 627
	error = xfs_ifree(tp, ip, &free_list);
	if (error) {
		/*
		 * If we fail to free the inode, shut down.  The cancel
		 * might do that, we need to make sure.  Otherwise the
		 * inode might be lost for a long time or forever.
		 */
		if (!XFS_FORCED_SHUTDOWN(mp)) {
628 629
			xfs_notice(mp, "%s: xfs_ifree returned error %d",
				__func__, error);
630
			xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
L
Linus Torvalds 已提交
631 632 633 634 635 636
		}
		xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
	} else {
		/*
		 * Credit the quota account(s). The inode is gone.
		 */
C
Christoph Hellwig 已提交
637
		xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
L
Linus Torvalds 已提交
638 639

		/*
640 641 642
		 * Just ignore errors at this point.  There is nothing we can
		 * do except to try to keep going. Make sure it's not a silent
		 * error.
L
Linus Torvalds 已提交
643
		 */
644 645
		error = xfs_bmap_finish(&tp,  &free_list, &committed);
		if (error)
646 647
			xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
				__func__, error);
648 649
		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
		if (error)
650 651
			xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
				__func__, error);
L
Linus Torvalds 已提交
652
	}
C
Christoph Hellwig 已提交
653

L
Linus Torvalds 已提交
654 655 656
	/*
	 * Release the dquots held by inode, if any.
	 */
C
Christoph Hellwig 已提交
657
	xfs_qm_dqdetach(ip);
658 659
out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
660 661 662 663
out:
	return VN_INACTIVE_CACHE;
out_cancel:
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
664
	goto out_unlock;
L
Linus Torvalds 已提交
665 666
}

667 668 669 670 671 672
/*
 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
 * is allowed, otherwise it has to be an exact match. If a CI match is found,
 * ci_name->name will point to a the actual name (caller must free) or
 * will be set to NULL if an exact match is found.
 */
673
int
L
Linus Torvalds 已提交
674
xfs_lookup(
675
	xfs_inode_t		*dp,
676
	struct xfs_name		*name,
677 678
	xfs_inode_t		**ipp,
	struct xfs_name		*ci_name)
L
Linus Torvalds 已提交
679
{
C
Christoph Hellwig 已提交
680
	xfs_ino_t		inum;
L
Linus Torvalds 已提交
681 682 683
	int			error;
	uint			lock_mode;

C
Christoph Hellwig 已提交
684
	trace_xfs_lookup(dp, name);
L
Linus Torvalds 已提交
685 686 687 688 689

	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
		return XFS_ERROR(EIO);

	lock_mode = xfs_ilock_map_shared(dp);
690
	error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
L
Linus Torvalds 已提交
691
	xfs_iunlock_map_shared(dp, lock_mode);
C
Christoph Hellwig 已提交
692 693 694 695

	if (error)
		goto out;

696
	error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
C
Christoph Hellwig 已提交
697
	if (error)
698
		goto out_free_name;
C
Christoph Hellwig 已提交
699 700 701

	return 0;

702 703 704 705
out_free_name:
	if (ci_name)
		kmem_free(ci_name->name);
out:
C
Christoph Hellwig 已提交
706
	*ipp = NULL;
L
Linus Torvalds 已提交
707 708 709
	return error;
}

710
int
L
Linus Torvalds 已提交
711
xfs_create(
712
	xfs_inode_t		*dp,
713
	struct xfs_name		*name,
A
Al Viro 已提交
714
	umode_t			mode,
715
	xfs_dev_t		rdev,
C
Christoph Hellwig 已提交
716
	xfs_inode_t		**ipp)
L
Linus Torvalds 已提交
717
{
718 719 720 721
	int			is_dir = S_ISDIR(mode);
	struct xfs_mount	*mp = dp->i_mount;
	struct xfs_inode	*ip = NULL;
	struct xfs_trans	*tp = NULL;
722
	int			error;
L
Linus Torvalds 已提交
723 724
	xfs_bmap_free_t		free_list;
	xfs_fsblock_t		first_block;
725
	boolean_t		unlock_dp_on_error = B_FALSE;
L
Linus Torvalds 已提交
726 727
	uint			cancel_flags;
	int			committed;
728
	prid_t			prid;
729 730
	struct xfs_dquot	*udqp = NULL;
	struct xfs_dquot	*gdqp = NULL;
L
Linus Torvalds 已提交
731
	uint			resblks;
732 733
	uint			log_res;
	uint			log_count;
L
Linus Torvalds 已提交
734

C
Christoph Hellwig 已提交
735
	trace_xfs_create(dp, name);
L
Linus Torvalds 已提交
736

737 738 739
	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

740
	if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
741
		prid = xfs_get_projid(dp);
L
Linus Torvalds 已提交
742
	else
743
		prid = XFS_PROJID_DEFAULT;
L
Linus Torvalds 已提交
744 745 746 747

	/*
	 * Make sure that we have allocated dquot(s) on disk.
	 */
C
Christoph Hellwig 已提交
748
	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
749
			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
L
Linus Torvalds 已提交
750
	if (error)
751
		return error;
L
Linus Torvalds 已提交
752

753 754 755 756 757 758 759 760 761 762 763 764
	if (is_dir) {
		rdev = 0;
		resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
		log_res = XFS_MKDIR_LOG_RES(mp);
		log_count = XFS_MKDIR_LOG_COUNT;
		tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
	} else {
		resblks = XFS_CREATE_SPACE_RES(mp, name->len);
		log_res = XFS_CREATE_LOG_RES(mp);
		log_count = XFS_CREATE_LOG_COUNT;
		tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
	}
L
Linus Torvalds 已提交
765 766

	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
767

L
Linus Torvalds 已提交
768 769 770 771 772 773
	/*
	 * Initially assume that the file does not exist and
	 * reserve the resources for that case.  If that is not
	 * the case we'll drop the one we have and get a more
	 * appropriate transaction later.
	 */
774 775
	error = xfs_trans_reserve(tp, resblks, log_res, 0,
			XFS_TRANS_PERM_LOG_RES, log_count);
L
Linus Torvalds 已提交
776
	if (error == ENOSPC) {
777
		/* flush outstanding delalloc blocks and retry */
D
Dave Chinner 已提交
778
		xfs_flush_inodes(mp);
779 780
		error = xfs_trans_reserve(tp, resblks, log_res, 0,
				XFS_TRANS_PERM_LOG_RES, log_count);
781 782 783
	}
	if (error == ENOSPC) {
		/* No space at all so try a "no-allocation" reservation */
L
Linus Torvalds 已提交
784
		resblks = 0;
785 786
		error = xfs_trans_reserve(tp, 0, log_res, 0,
				XFS_TRANS_PERM_LOG_RES, log_count);
L
Linus Torvalds 已提交
787 788 789
	}
	if (error) {
		cancel_flags = 0;
790
		goto out_trans_cancel;
L
Linus Torvalds 已提交
791 792
	}

793
	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
794
	unlock_dp_on_error = B_TRUE;
L
Linus Torvalds 已提交
795

796
	xfs_bmap_init(&free_list, &first_block);
L
Linus Torvalds 已提交
797 798 799 800

	/*
	 * Reserve disk quota and the inode.
	 */
C
Christoph Hellwig 已提交
801
	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
L
Linus Torvalds 已提交
802
	if (error)
803
		goto out_trans_cancel;
L
Linus Torvalds 已提交
804

805 806
	error = xfs_dir_canenter(tp, dp, name, resblks);
	if (error)
807 808 809 810 811 812 813
		goto out_trans_cancel;

	/*
	 * A newly created regular or special file just has one directory
	 * entry pointing to them, but a directory also the "." entry
	 * pointing to itself.
	 */
C
Christoph Hellwig 已提交
814
	error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
815
			       prid, resblks > 0, &ip, &committed);
L
Linus Torvalds 已提交
816 817
	if (error) {
		if (error == ENOSPC)
818 819
			goto out_trans_cancel;
		goto out_trans_abort;
L
Linus Torvalds 已提交
820 821 822
	}

	/*
823 824 825 826 827
	 * Now we join the directory inode to the transaction.  We do not do it
	 * earlier because xfs_dir_ialloc might commit the previous transaction
	 * (and release all the locks).  An error from here on will result in
	 * the transaction cancel unlocking dp so don't do it explicitly in the
	 * error path.
L
Linus Torvalds 已提交
828
	 */
829
	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
830
	unlock_dp_on_error = B_FALSE;
L
Linus Torvalds 已提交
831

832
	error = xfs_dir_createname(tp, dp, name, ip->i_ino,
833 834
					&first_block, &free_list, resblks ?
					resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
L
Linus Torvalds 已提交
835 836
	if (error) {
		ASSERT(error != ENOSPC);
837
		goto out_trans_abort;
L
Linus Torvalds 已提交
838
	}
839
	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
L
Linus Torvalds 已提交
840 841
	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);

842 843 844 845 846 847 848 849 850 851
	if (is_dir) {
		error = xfs_dir_init(tp, ip, dp);
		if (error)
			goto out_bmap_cancel;

		error = xfs_bumplink(tp, dp);
		if (error)
			goto out_bmap_cancel;
	}

L
Linus Torvalds 已提交
852 853 854 855 856
	/*
	 * If this is a synchronous mount, make sure that the
	 * create transaction goes to disk before returning to
	 * the user.
	 */
857
	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
L
Linus Torvalds 已提交
858 859 860 861 862 863 864
		xfs_trans_set_sync(tp);

	/*
	 * Attach the dquot(s) to the inodes and modify them incore.
	 * These ids of the inode couldn't have changed since the new
	 * inode has been locked ever since it was created.
	 */
C
Christoph Hellwig 已提交
865
	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
L
Linus Torvalds 已提交
866

867
	error = xfs_bmap_finish(&tp, &free_list, &committed);
868
	if (error)
869
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
870

871
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
872 873
	if (error)
		goto out_release_inode;
L
Linus Torvalds 已提交
874

C
Christoph Hellwig 已提交
875 876
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);
L
Linus Torvalds 已提交
877

878
	*ipp = ip;
C
Christoph Hellwig 已提交
879
	return 0;
L
Linus Torvalds 已提交
880

881 882 883
 out_bmap_cancel:
	xfs_bmap_cancel(&free_list);
 out_trans_abort:
L
Linus Torvalds 已提交
884
	cancel_flags |= XFS_TRANS_ABORT;
885 886
 out_trans_cancel:
	xfs_trans_cancel(tp, cancel_flags);
887 888 889 890 891 892 893 894 895
 out_release_inode:
	/*
	 * Wait until after the current transaction is aborted to
	 * release the inode.  This prevents recursive transactions
	 * and deadlocks from xfs_inactive.
	 */
	if (ip)
		IRELE(ip);

C
Christoph Hellwig 已提交
896 897
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);
L
Linus Torvalds 已提交
898

899 900
	if (unlock_dp_on_error)
		xfs_iunlock(dp, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
901
	return error;
L
Linus Torvalds 已提交
902 903 904 905 906 907 908 909 910 911
}

#ifdef DEBUG
int xfs_locked_n;
int xfs_small_retries;
int xfs_middle_retries;
int xfs_lots_retries;
int xfs_lock_delays;
#endif

912 913 914 915 916 917 918 919
/*
 * Bump the subclass so xfs_lock_inodes() acquires each lock with
 * a different value
 */
static inline int
xfs_lock_inumorder(int lock_mode, int subclass)
{
	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
920
		lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
921
	if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
922
		lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
923 924 925 926

	return lock_mode;
}

L
Linus Torvalds 已提交
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
/*
 * The following routine will lock n inodes in exclusive mode.
 * We assume the caller calls us with the inodes in i_ino order.
 *
 * We need to detect deadlock where an inode that we lock
 * is in the AIL and we start waiting for another inode that is locked
 * by a thread in a long running transaction (such as truncate). This can
 * result in deadlock since the long running trans might need to wait
 * for the inode we just locked in order to push the tail and free space
 * in the log.
 */
void
xfs_lock_inodes(
	xfs_inode_t	**ips,
	int		inodes,
	uint		lock_mode)
{
	int		attempts = 0, i, j, try_lock;
	xfs_log_item_t	*lp;

	ASSERT(ips && (inodes >= 2)); /* we need at least two */

949 950
	try_lock = 0;
	i = 0;
L
Linus Torvalds 已提交
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987

again:
	for (; i < inodes; i++) {
		ASSERT(ips[i]);

		if (i && (ips[i] == ips[i-1]))	/* Already locked */
			continue;

		/*
		 * If try_lock is not set yet, make sure all locked inodes
		 * are not in the AIL.
		 * If any are, set try_lock to be used later.
		 */

		if (!try_lock) {
			for (j = (i - 1); j >= 0 && !try_lock; j--) {
				lp = (xfs_log_item_t *)ips[j]->i_itemp;
				if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
					try_lock++;
				}
			}
		}

		/*
		 * If any of the previous locks we have locked is in the AIL,
		 * we must TRY to get the second and subsequent locks. If
		 * we can't get any, we must release all we have
		 * and try again.
		 */

		if (try_lock) {
			/* try_lock must be 0 if i is 0. */
			/*
			 * try_lock means we have an inode locked
			 * that is in the AIL.
			 */
			ASSERT(i != 0);
988
			if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
L
Linus Torvalds 已提交
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
				attempts++;

				/*
				 * Unlock all previous guys and try again.
				 * xfs_iunlock will try to push the tail
				 * if the inode is in the AIL.
				 */

				for(j = i - 1; j >= 0; j--) {

					/*
					 * Check to see if we've already
					 * unlocked this one.
					 * Not the first one going back,
					 * and the inode ptr is the same.
					 */
					if ((j != (i - 1)) && ips[j] ==
								ips[j+1])
						continue;

					xfs_iunlock(ips[j], lock_mode);
				}

				if ((attempts % 5) == 0) {
					delay(1); /* Don't just spin the CPU */
#ifdef DEBUG
					xfs_lock_delays++;
#endif
				}
				i = 0;
				try_lock = 0;
				goto again;
			}
		} else {
1023
			xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
		}
	}

#ifdef DEBUG
	if (attempts) {
		if (attempts < 5) xfs_small_retries++;
		else if (attempts < 100) xfs_middle_retries++;
		else xfs_lots_retries++;
	} else {
		xfs_locked_n++;
	}
#endif
}

1038 1039 1040 1041 1042 1043
/*
 * xfs_lock_two_inodes() can only be used to lock one type of lock
 * at a time - the iolock or the ilock, but not both at once. If
 * we lock both at once, lockdep will report false positives saying
 * we have violated locking orders.
 */
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
void
xfs_lock_two_inodes(
	xfs_inode_t		*ip0,
	xfs_inode_t		*ip1,
	uint			lock_mode)
{
	xfs_inode_t		*temp;
	int			attempts = 0;
	xfs_log_item_t		*lp;

1054 1055
	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
		ASSERT((lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) == 0);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
	ASSERT(ip0->i_ino != ip1->i_ino);

	if (ip0->i_ino > ip1->i_ino) {
		temp = ip0;
		ip0 = ip1;
		ip1 = temp;
	}

 again:
	xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));

	/*
	 * If the first lock we have locked is in the AIL, we must TRY to get
	 * the second lock. If we can't get it, we must release the first one
	 * and try again.
	 */
	lp = (xfs_log_item_t *)ip0->i_itemp;
	if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
		if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
			xfs_iunlock(ip0, lock_mode);
			if ((++attempts % 5) == 0)
				delay(1); /* Don't just spin the CPU */
			goto again;
		}
	} else {
		xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
	}
}

1085
int
L
Linus Torvalds 已提交
1086
xfs_remove(
1087
	xfs_inode_t             *dp,
1088 1089
	struct xfs_name		*name,
	xfs_inode_t		*ip)
L
Linus Torvalds 已提交
1090
{
1091
	xfs_mount_t		*mp = dp->i_mount;
L
Linus Torvalds 已提交
1092
	xfs_trans_t             *tp = NULL;
1093
	int			is_dir = S_ISDIR(ip->i_d.di_mode);
L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100
	int                     error = 0;
	xfs_bmap_free_t         free_list;
	xfs_fsblock_t           first_block;
	int			cancel_flags;
	int			committed;
	int			link_zero;
	uint			resblks;
1101
	uint			log_count;
L
Linus Torvalds 已提交
1102

C
Christoph Hellwig 已提交
1103
	trace_xfs_remove(dp, name);
L
Linus Torvalds 已提交
1104 1105 1106 1107

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

C
Christoph Hellwig 已提交
1108
	error = xfs_qm_dqattach(dp, 0);
1109 1110 1111
	if (error)
		goto std_return;

C
Christoph Hellwig 已提交
1112
	error = xfs_qm_dqattach(ip, 0);
1113
	if (error)
L
Linus Torvalds 已提交
1114 1115
		goto std_return;

1116 1117 1118 1119 1120 1121 1122
	if (is_dir) {
		tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
		log_count = XFS_DEFAULT_LOG_COUNT;
	} else {
		tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
		log_count = XFS_REMOVE_LOG_COUNT;
	}
L
Linus Torvalds 已提交
1123
	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1124

L
Linus Torvalds 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
	/*
	 * We try to get the real space reservation first,
	 * allowing for directory btree deletion(s) implying
	 * possible bmap insert(s).  If we can't get the space
	 * reservation then we use 0 instead, and avoid the bmap
	 * btree insert(s) in the directory code by, if the bmap
	 * insert tries to happen, instead trimming the LAST
	 * block from the directory.
	 */
	resblks = XFS_REMOVE_SPACE_RES(mp);
	error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
1136
				  XFS_TRANS_PERM_LOG_RES, log_count);
L
Linus Torvalds 已提交
1137 1138 1139
	if (error == ENOSPC) {
		resblks = 0;
		error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
1140
					  XFS_TRANS_PERM_LOG_RES, log_count);
L
Linus Torvalds 已提交
1141 1142 1143
	}
	if (error) {
		ASSERT(error != ENOSPC);
1144 1145
		cancel_flags = 0;
		goto out_trans_cancel;
L
Linus Torvalds 已提交
1146 1147
	}

1148
	xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
1149

1150 1151
	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
1152

1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
	/*
	 * If we're removing a directory perform some additional validation.
	 */
	if (is_dir) {
		ASSERT(ip->i_d.di_nlink >= 2);
		if (ip->i_d.di_nlink != 2) {
			error = XFS_ERROR(ENOTEMPTY);
			goto out_trans_cancel;
		}
		if (!xfs_dir_isempty(ip)) {
			error = XFS_ERROR(ENOTEMPTY);
			goto out_trans_cancel;
		}
	}

1168
	xfs_bmap_init(&free_list, &first_block);
1169
	error = xfs_dir_removename(tp, dp, name, ip->i_ino,
1170
					&first_block, &free_list, resblks);
L
Linus Torvalds 已提交
1171 1172
	if (error) {
		ASSERT(error != ENOENT);
1173
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
1174
	}
1175
	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
L
Linus Torvalds 已提交
1176

1177 1178 1179 1180 1181 1182 1183 1184 1185
	if (is_dir) {
		/*
		 * Drop the link from ip's "..".
		 */
		error = xfs_droplink(tp, dp);
		if (error)
			goto out_bmap_cancel;

		/*
1186
		 * Drop the "." link from ip to self.
1187 1188 1189 1190 1191 1192 1193
		 */
		error = xfs_droplink(tp, ip);
		if (error)
			goto out_bmap_cancel;
	} else {
		/*
		 * When removing a non-directory we need to log the parent
1194 1195
		 * inode here.  For a directory this is done implicitly
		 * by the xfs_droplink call for the ".." entry.
1196 1197
		 */
		xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
L
Linus Torvalds 已提交
1198 1199
	}

1200
	/*
1201
	 * Drop the link from dp to ip.
1202 1203 1204 1205 1206 1207 1208
	 */
	error = xfs_droplink(tp, ip);
	if (error)
		goto out_bmap_cancel;

	/*
	 * Determine if this is the last link while
L
Linus Torvalds 已提交
1209 1210
	 * we are in the transaction.
	 */
1211
	link_zero = (ip->i_d.di_nlink == 0);
L
Linus Torvalds 已提交
1212 1213 1214 1215 1216 1217

	/*
	 * If this is a synchronous mount, make sure that the
	 * remove transaction goes to disk before returning to
	 * the user.
	 */
1218
	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
L
Linus Torvalds 已提交
1219 1220
		xfs_trans_set_sync(tp);

1221
	error = xfs_bmap_finish(&tp, &free_list, &committed);
1222 1223
	if (error)
		goto out_bmap_cancel;
L
Linus Torvalds 已提交
1224

1225
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1226
	if (error)
L
Linus Torvalds 已提交
1227 1228
		goto std_return;

1229 1230 1231 1232 1233 1234
	/*
	 * If we are using filestreams, kill the stream association.
	 * If the file is still open it may get a new one but that
	 * will get killed on last close in xfs_close() so we don't
	 * have to worry about that.
	 */
1235
	if (!is_dir && link_zero && xfs_inode_is_filestream(ip))
1236 1237
		xfs_filestream_deassociate(ip);

C
Christoph Hellwig 已提交
1238
	return 0;
L
Linus Torvalds 已提交
1239

1240
 out_bmap_cancel:
L
Linus Torvalds 已提交
1241 1242
	xfs_bmap_cancel(&free_list);
	cancel_flags |= XFS_TRANS_ABORT;
1243
 out_trans_cancel:
L
Linus Torvalds 已提交
1244
	xfs_trans_cancel(tp, cancel_flags);
C
Christoph Hellwig 已提交
1245 1246
 std_return:
	return error;
L
Linus Torvalds 已提交
1247 1248
}

1249
int
L
Linus Torvalds 已提交
1250
xfs_link(
1251
	xfs_inode_t		*tdp,
1252
	xfs_inode_t		*sip,
1253
	struct xfs_name		*target_name)
L
Linus Torvalds 已提交
1254
{
1255
	xfs_mount_t		*mp = tdp->i_mount;
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261 1262 1263
	xfs_trans_t		*tp;
	int			error;
	xfs_bmap_free_t         free_list;
	xfs_fsblock_t           first_block;
	int			cancel_flags;
	int			committed;
	int			resblks;

C
Christoph Hellwig 已提交
1264
	trace_xfs_link(tdp, target_name);
L
Linus Torvalds 已提交
1265

1266
	ASSERT(!S_ISDIR(sip->i_d.di_mode));
L
Linus Torvalds 已提交
1267 1268 1269 1270

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

C
Christoph Hellwig 已提交
1271
	error = xfs_qm_dqattach(sip, 0);
1272 1273 1274
	if (error)
		goto std_return;

C
Christoph Hellwig 已提交
1275
	error = xfs_qm_dqattach(tdp, 0);
L
Linus Torvalds 已提交
1276 1277 1278 1279 1280
	if (error)
		goto std_return;

	tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1281
	resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
			XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
	if (error == ENOSPC) {
		resblks = 0;
		error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
				XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
	}
	if (error) {
		cancel_flags = 0;
		goto error_return;
	}

1294
	xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
1295

1296 1297
	xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
1298

1299 1300 1301 1302 1303 1304
	/*
	 * If we are using project inheritance, we only allow hard link
	 * creation in our tree when the project IDs are the same; else
	 * the tree quota mechanism could be circumvented.
	 */
	if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1305
		     (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1306
		error = XFS_ERROR(EXDEV);
1307 1308 1309
		goto error_return;
	}

1310 1311
	error = xfs_dir_canenter(tp, tdp, target_name, resblks);
	if (error)
L
Linus Torvalds 已提交
1312 1313
		goto error_return;

1314
	xfs_bmap_init(&free_list, &first_block);
L
Linus Torvalds 已提交
1315

1316 1317
	error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
					&first_block, &free_list, resblks);
L
Linus Torvalds 已提交
1318 1319
	if (error)
		goto abort_return;
1320
	xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
L
Linus Torvalds 已提交
1321 1322 1323
	xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);

	error = xfs_bumplink(tp, sip);
1324
	if (error)
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
		goto abort_return;

	/*
	 * If this is a synchronous mount, make sure that the
	 * link transaction goes to disk before returning to
	 * the user.
	 */
	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
		xfs_trans_set_sync(tp);
	}

1336
	error = xfs_bmap_finish (&tp, &free_list, &committed);
L
Linus Torvalds 已提交
1337 1338 1339 1340 1341
	if (error) {
		xfs_bmap_cancel(&free_list);
		goto abort_return;
	}

C
Christoph Hellwig 已提交
1342
	return xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
1343 1344 1345 1346 1347

 abort_return:
	cancel_flags |= XFS_TRANS_ABORT;
 error_return:
	xfs_trans_cancel(tp, cancel_flags);
C
Christoph Hellwig 已提交
1348 1349
 std_return:
	return error;
L
Linus Torvalds 已提交
1350
}
1351

1352
int
L
Linus Torvalds 已提交
1353
xfs_symlink(
1354
	xfs_inode_t		*dp,
1355 1356
	struct xfs_name		*link_name,
	const char		*target_path,
A
Al Viro 已提交
1357
	umode_t			mode,
C
Christoph Hellwig 已提交
1358
	xfs_inode_t		**ipp)
L
Linus Torvalds 已提交
1359
{
1360
	xfs_mount_t		*mp = dp->i_mount;
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366
	xfs_trans_t		*tp;
	xfs_inode_t		*ip;
	int			error;
	int			pathlen;
	xfs_bmap_free_t		free_list;
	xfs_fsblock_t		first_block;
1367
	boolean_t		unlock_dp_on_error = B_FALSE;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374
	uint			cancel_flags;
	int			committed;
	xfs_fileoff_t		first_fsb;
	xfs_filblks_t		fs_blocks;
	int			nmaps;
	xfs_bmbt_irec_t		mval[SYMLINK_MAPS];
	xfs_daddr_t		d;
1375
	const char		*cur_chunk;
L
Linus Torvalds 已提交
1376 1377 1378
	int			byte_cnt;
	int			n;
	xfs_buf_t		*bp;
1379
	prid_t			prid;
L
Linus Torvalds 已提交
1380 1381 1382
	struct xfs_dquot	*udqp, *gdqp;
	uint			resblks;

1383
	*ipp = NULL;
L
Linus Torvalds 已提交
1384 1385 1386 1387
	error = 0;
	ip = NULL;
	tp = NULL;

C
Christoph Hellwig 已提交
1388
	trace_xfs_symlink(dp, link_name);
L
Linus Torvalds 已提交
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

	/*
	 * Check component lengths of the target path name.
	 */
	pathlen = strlen(target_path);
	if (pathlen >= MAXPATHLEN)      /* total string too long */
		return XFS_ERROR(ENAMETOOLONG);

	udqp = gdqp = NULL;
1401
	if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1402
		prid = xfs_get_projid(dp);
L
Linus Torvalds 已提交
1403
	else
1404
		prid = XFS_PROJID_DEFAULT;
L
Linus Torvalds 已提交
1405 1406 1407 1408

	/*
	 * Make sure that we have allocated dquot(s) on disk.
	 */
C
Christoph Hellwig 已提交
1409
	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
L
Linus Torvalds 已提交
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
	if (error)
		goto std_return;

	tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
	/*
	 * The symlink will fit into the inode data fork?
	 * There can't be any attributes so we get the whole variable part.
	 */
	if (pathlen <= XFS_LITINO(mp))
		fs_blocks = 0;
	else
		fs_blocks = XFS_B_TO_FSB(mp, pathlen);
1424
	resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
	error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
			XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
	if (error == ENOSPC && fs_blocks == 0) {
		resblks = 0;
		error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
				XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
	}
	if (error) {
		cancel_flags = 0;
		goto error_return;
	}

1437
	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1438
	unlock_dp_on_error = B_TRUE;
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450

	/*
	 * Check whether the directory allows new symlinks or not.
	 */
	if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
		error = XFS_ERROR(EPERM);
		goto error_return;
	}

	/*
	 * Reserve disk quota : blocks and inode.
	 */
C
Christoph Hellwig 已提交
1451
	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
L
Linus Torvalds 已提交
1452 1453 1454 1455 1456 1457
	if (error)
		goto error_return;

	/*
	 * Check for ability to enter directory entry, if no space reserved.
	 */
1458 1459
	error = xfs_dir_canenter(tp, dp, link_name, resblks);
	if (error)
L
Linus Torvalds 已提交
1460 1461 1462 1463 1464
		goto error_return;
	/*
	 * Initialize the bmap freelist prior to calling either
	 * bmapi or the directory create code.
	 */
1465
	xfs_bmap_init(&free_list, &first_block);
L
Linus Torvalds 已提交
1466 1467 1468 1469

	/*
	 * Allocate an inode for the symlink.
	 */
C
Christoph Hellwig 已提交
1470 1471
	error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
			       prid, resblks > 0, &ip, NULL);
L
Linus Torvalds 已提交
1472 1473 1474 1475 1476 1477
	if (error) {
		if (error == ENOSPC)
			goto error_return;
		goto error1;
	}

1478 1479 1480 1481 1482
	/*
	 * An error after we've joined dp to the transaction will result in the
	 * transaction cancel unlocking dp so don't do it explicitly in the
	 * error path.
	 */
1483
	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1484
	unlock_dp_on_error = B_FALSE;
L
Linus Torvalds 已提交
1485 1486 1487 1488

	/*
	 * Also attach the dquot(s) to it, if applicable.
	 */
C
Christoph Hellwig 已提交
1489
	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

	if (resblks)
		resblks -= XFS_IALLOC_SPACE_RES(mp);
	/*
	 * If the symlink will fit into the inode, write it inline.
	 */
	if (pathlen <= XFS_IFORK_DSIZE(ip)) {
		xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
		memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
		ip->i_d.di_size = pathlen;

		/*
		 * The inode was initially created in extent format.
		 */
		ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
		ip->i_df.if_flags |= XFS_IFINLINE;

		ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
		xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);

	} else {
		first_fsb = 0;
		nmaps = SYMLINK_MAPS;

1514 1515 1516
		error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
				  XFS_BMAPI_METADATA, &first_block, resblks,
				  mval, &nmaps, &free_list);
1517 1518
		if (error)
			goto error2;
L
Linus Torvalds 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530

		if (resblks)
			resblks -= fs_blocks;
		ip->i_d.di_size = pathlen;
		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

		cur_chunk = target_path;
		for (n = 0; n < nmaps; n++) {
			d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
			byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
			bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
					       BTOBB(byte_cnt), 0);
1531 1532 1533 1534
			if (!bp) {
				error = ENOMEM;
				goto error2;
			}
L
Linus Torvalds 已提交
1535 1536 1537 1538 1539
			if (pathlen < byte_cnt) {
				byte_cnt = pathlen;
			}
			pathlen -= byte_cnt;

1540
			memcpy(bp->b_addr, cur_chunk, byte_cnt);
L
Linus Torvalds 已提交
1541 1542 1543 1544 1545 1546 1547 1548 1549
			cur_chunk += byte_cnt;

			xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
		}
	}

	/*
	 * Create the directory entry for the symlink.
	 */
1550 1551
	error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
					&first_block, &free_list, resblks);
1552
	if (error)
1553
		goto error2;
1554
	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
L
Linus Torvalds 已提交
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);

	/*
	 * If this is a synchronous mount, make sure that the
	 * symlink transaction goes to disk before returning to
	 * the user.
	 */
	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
		xfs_trans_set_sync(tp);
	}

1566
	error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
1567 1568 1569
	if (error) {
		goto error2;
	}
1570
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
C
Christoph Hellwig 已提交
1571 1572
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);
L
Linus Torvalds 已提交
1573

C
Christoph Hellwig 已提交
1574 1575
	*ipp = ip;
	return 0;
L
Linus Torvalds 已提交
1576 1577 1578 1579 1580 1581 1582 1583

 error2:
	IRELE(ip);
 error1:
	xfs_bmap_cancel(&free_list);
	cancel_flags |= XFS_TRANS_ABORT;
 error_return:
	xfs_trans_cancel(tp, cancel_flags);
C
Christoph Hellwig 已提交
1584 1585
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);
L
Linus Torvalds 已提交
1586

1587
	if (unlock_dp_on_error)
L
Linus Torvalds 已提交
1588
		xfs_iunlock(dp, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
1589 1590
 std_return:
	return error;
L
Linus Torvalds 已提交
1591 1592 1593
}

int
1594 1595
xfs_set_dmattrs(
	xfs_inode_t     *ip,
L
Linus Torvalds 已提交
1596
	u_int		evmask,
1597
	u_int16_t	state)
L
Linus Torvalds 已提交
1598
{
1599
	xfs_mount_t	*mp = ip->i_mount;
L
Linus Torvalds 已提交
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
	xfs_trans_t	*tp;
	int		error;

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

	tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
	error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
	if (error) {
		xfs_trans_cancel(tp, 0);
		return error;
	}
	xfs_ilock(ip, XFS_ILOCK_EXCL);
1616
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
1617

C
Christoph Hellwig 已提交
1618 1619
	ip->i_d.di_dmevmask = evmask;
	ip->i_d.di_dmstate  = state;
L
Linus Torvalds 已提交
1620 1621

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1622
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645

	return error;
}

/*
 * xfs_alloc_file_space()
 *      This routine allocates disk space for the given file.
 *
 *	If alloc_type == 0, this request is for an ALLOCSP type
 *	request which will change the file size.  In this case, no
 *	DMAPI event will be generated by the call.  A TRUNCATE event
 *	will be generated later by xfs_setattr.
 *
 *	If alloc_type != 0, this request is for a RESVSP type
 *	request, and a DMAPI DM_EVENT_WRITE will be generated if the
 *	lower block boundary byte address is less than the file's
 *	length.
 *
 * RETURNS:
 *       0 on success
 *      errno on error
 *
 */
1646
STATIC int
L
Linus Torvalds 已提交
1647 1648 1649 1650 1651 1652 1653
xfs_alloc_file_space(
	xfs_inode_t		*ip,
	xfs_off_t		offset,
	xfs_off_t		len,
	int			alloc_type,
	int			attr_flags)
{
1654 1655
	xfs_mount_t		*mp = ip->i_mount;
	xfs_off_t		count;
L
Linus Torvalds 已提交
1656 1657
	xfs_filblks_t		allocated_fsb;
	xfs_filblks_t		allocatesize_fsb;
1658 1659
	xfs_extlen_t		extsz, temp;
	xfs_fileoff_t		startoffset_fsb;
L
Linus Torvalds 已提交
1660
	xfs_fsblock_t		firstfsb;
1661 1662
	int			nimaps;
	int			quota_flag;
L
Linus Torvalds 已提交
1663 1664
	int			rt;
	xfs_trans_t		*tp;
1665 1666 1667 1668 1669
	xfs_bmbt_irec_t		imaps[1], *imapp;
	xfs_bmap_free_t		free_list;
	uint			qblocks, resblks, resrtextents;
	int			committed;
	int			error;
L
Linus Torvalds 已提交
1670

C
Christoph Hellwig 已提交
1671
	trace_xfs_alloc_file_space(ip);
L
Linus Torvalds 已提交
1672 1673 1674 1675

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

C
Christoph Hellwig 已提交
1676 1677
	error = xfs_qm_dqattach(ip, 0);
	if (error)
L
Linus Torvalds 已提交
1678 1679 1680 1681 1682
		return error;

	if (len <= 0)
		return XFS_ERROR(EINVAL);

1683 1684 1685
	rt = XFS_IS_REALTIME_INODE(ip);
	extsz = xfs_get_extsz_hint(ip);

L
Linus Torvalds 已提交
1686 1687
	count = len;
	imapp = &imaps[0];
1688
	nimaps = 1;
L
Linus Torvalds 已提交
1689 1690 1691 1692
	startoffset_fsb	= XFS_B_TO_FSBT(mp, offset);
	allocatesize_fsb = XFS_B_TO_FSB(mp, count);

	/*
1693
	 * Allocate file space until done or until there is an error
L
Linus Torvalds 已提交
1694 1695
	 */
	while (allocatesize_fsb && !error) {
1696 1697
		xfs_fileoff_t	s, e;

L
Linus Torvalds 已提交
1698
		/*
1699
		 * Determine space reservations for data/realtime.
L
Linus Torvalds 已提交
1700
		 */
1701
		if (unlikely(extsz)) {
L
Linus Torvalds 已提交
1702
			s = startoffset_fsb;
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
			do_div(s, extsz);
			s *= extsz;
			e = startoffset_fsb + allocatesize_fsb;
			if ((temp = do_mod(startoffset_fsb, extsz)))
				e += temp;
			if ((temp = do_mod(e, extsz)))
				e += extsz - temp;
		} else {
			s = 0;
			e = allocatesize_fsb;
		}

1715 1716 1717 1718 1719 1720 1721 1722
		/*
		 * The transaction reservation is limited to a 32-bit block
		 * count, hence we need to limit the number of blocks we are
		 * trying to reserve to avoid an overflow. We can't allocate
		 * more than @nimaps extents, and an extent is limited on disk
		 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
		 */
		resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
1723
		if (unlikely(rt)) {
1724
			resrtextents = qblocks = resblks;
1725 1726 1727
			resrtextents /= mp->m_sb.sb_rextsize;
			resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
			quota_flag = XFS_QMOPT_RES_RTBLKS;
L
Linus Torvalds 已提交
1728
		} else {
1729
			resrtextents = 0;
1730
			resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
1731
			quota_flag = XFS_QMOPT_RES_REGBLKS;
L
Linus Torvalds 已提交
1732 1733 1734
		}

		/*
1735
		 * Allocate and setup the transaction.
L
Linus Torvalds 已提交
1736 1737
		 */
		tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1738 1739
		error = xfs_trans_reserve(tp, resblks,
					  XFS_WRITE_LOG_RES(mp), resrtextents,
L
Linus Torvalds 已提交
1740 1741 1742
					  XFS_TRANS_PERM_LOG_RES,
					  XFS_WRITE_LOG_COUNT);
		/*
1743
		 * Check for running out of space
L
Linus Torvalds 已提交
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
		 */
		if (error) {
			/*
			 * Free the transaction structure.
			 */
			ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
			xfs_trans_cancel(tp, 0);
			break;
		}
		xfs_ilock(ip, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
1754 1755
		error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
						      0, quota_flag);
L
Linus Torvalds 已提交
1756 1757 1758
		if (error)
			goto error1;

1759
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
1760

1761
		xfs_bmap_init(&free_list, &firstfsb);
1762 1763 1764
		error = xfs_bmapi_write(tp, ip, startoffset_fsb,
					allocatesize_fsb, alloc_type, &firstfsb,
					0, imapp, &nimaps, &free_list);
L
Linus Torvalds 已提交
1765 1766 1767 1768 1769
		if (error) {
			goto error0;
		}

		/*
1770
		 * Complete the transaction
L
Linus Torvalds 已提交
1771
		 */
1772
		error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
1773 1774 1775 1776
		if (error) {
			goto error0;
		}

1777
		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
1778 1779 1780 1781 1782 1783 1784
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
		if (error) {
			break;
		}

		allocated_fsb = imapp->br_blockcount;

1785
		if (nimaps == 0) {
L
Linus Torvalds 已提交
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
			error = XFS_ERROR(ENOSPC);
			break;
		}

		startoffset_fsb += allocated_fsb;
		allocatesize_fsb -= allocated_fsb;
	}

	return error;

1796
error0:	/* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
L
Linus Torvalds 已提交
1797
	xfs_bmap_cancel(&free_list);
1798
	xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
1799 1800

error1:	/* Just cancel transaction */
L
Linus Torvalds 已提交
1801 1802
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
1803
	return error;
L
Linus Torvalds 已提交
1804 1805 1806 1807 1808
}

/*
 * Zero file bytes between startoff and endoff inclusive.
 * The iolock is held exclusive and no blocks are buffered.
1809 1810 1811 1812 1813 1814 1815
 *
 * This function is used by xfs_free_file_space() to zero
 * partial blocks when the range to free is not block aligned.
 * When unreserving space with boundaries that are not block
 * aligned we round up the start and round down the end
 * boundaries and then use this function to zero the parts of
 * the blocks that got dropped during the rounding.
L
Linus Torvalds 已提交
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
 */
STATIC int
xfs_zero_remaining_bytes(
	xfs_inode_t		*ip,
	xfs_off_t		startoff,
	xfs_off_t		endoff)
{
	xfs_bmbt_irec_t		imap;
	xfs_fileoff_t		offset_fsb;
	xfs_off_t		lastoffset;
	xfs_off_t		offset;
	xfs_buf_t		*bp;
	xfs_mount_t		*mp = ip->i_mount;
	int			nimap;
	int			error = 0;

1832 1833 1834 1835 1836
	/*
	 * Avoid doing I/O beyond eof - it's not necessary
	 * since nothing can read beyond eof.  The space will
	 * be zeroed when the file is extended anyway.
	 */
1837
	if (startoff >= XFS_ISIZE(ip))
1838 1839
		return 0;

1840 1841
	if (endoff > XFS_ISIZE(ip))
		endoff = XFS_ISIZE(ip);
1842

1843 1844
	bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
					mp->m_rtdev_targp : mp->m_ddev_targp,
D
Dave Chinner 已提交
1845
				  BTOBB(mp->m_sb.sb_blocksize), 0);
1846 1847
	if (!bp)
		return XFS_ERROR(ENOMEM);
L
Linus Torvalds 已提交
1848

1849 1850
	xfs_buf_unlock(bp);

L
Linus Torvalds 已提交
1851 1852 1853
	for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
		offset_fsb = XFS_B_TO_FSBT(mp, offset);
		nimap = 1;
D
Dave Chinner 已提交
1854
		error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
L
Linus Torvalds 已提交
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
		if (error || nimap < 1)
			break;
		ASSERT(imap.br_blockcount >= 1);
		ASSERT(imap.br_startoff == offset_fsb);
		lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
		if (lastoffset > endoff)
			lastoffset = endoff;
		if (imap.br_startblock == HOLESTARTBLOCK)
			continue;
		ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
		if (imap.br_state == XFS_EXT_UNWRITTEN)
			continue;
		XFS_BUF_UNDONE(bp);
		XFS_BUF_UNWRITE(bp);
		XFS_BUF_READ(bp);
1870
		XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
L
Linus Torvalds 已提交
1871
		xfsbdstrat(mp, bp);
C
Christoph Hellwig 已提交
1872
		error = xfs_buf_iowait(bp);
1873
		if (error) {
1874 1875
			xfs_buf_ioerror_alert(bp,
					"xfs_zero_remaining_bytes(read)");
L
Linus Torvalds 已提交
1876 1877
			break;
		}
1878
		memset(bp->b_addr +
L
Linus Torvalds 已提交
1879 1880 1881 1882 1883 1884
			(offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
		      0, lastoffset - offset + 1);
		XFS_BUF_UNDONE(bp);
		XFS_BUF_UNREAD(bp);
		XFS_BUF_WRITE(bp);
		xfsbdstrat(mp, bp);
C
Christoph Hellwig 已提交
1885
		error = xfs_buf_iowait(bp);
1886
		if (error) {
1887 1888
			xfs_buf_ioerror_alert(bp,
					"xfs_zero_remaining_bytes(write)");
L
Linus Torvalds 已提交
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
			break;
		}
	}
	xfs_buf_free(bp);
	return error;
}

/*
 * xfs_free_file_space()
 *      This routine frees disk space for the given file.
 *
 *	This routine is only called by xfs_change_file_space
 *	for an UNRESVSP type call.
 *
 * RETURNS:
 *       0 on success
 *      errno on error
 *
 */
STATIC int
xfs_free_file_space(
	xfs_inode_t		*ip,
	xfs_off_t		offset,
	xfs_off_t		len,
	int			attr_flags)
{
	int			committed;
	int			done;
	xfs_fileoff_t		endoffset_fsb;
	int			error;
	xfs_fsblock_t		firstfsb;
	xfs_bmap_free_t		free_list;
	xfs_bmbt_irec_t		imap;
	xfs_off_t		ioffset;
	xfs_extlen_t		mod=0;
	xfs_mount_t		*mp;
	int			nimap;
	uint			resblks;
1927
	uint			rounding;
L
Linus Torvalds 已提交
1928 1929 1930
	int			rt;
	xfs_fileoff_t		startoffset_fsb;
	xfs_trans_t		*tp;
1931
	int			need_iolock = 1;
L
Linus Torvalds 已提交
1932 1933 1934

	mp = ip->i_mount;

C
Christoph Hellwig 已提交
1935
	trace_xfs_free_file_space(ip);
1936

C
Christoph Hellwig 已提交
1937 1938
	error = xfs_qm_dqattach(ip, 0);
	if (error)
L
Linus Torvalds 已提交
1939 1940 1941 1942 1943
		return error;

	error = 0;
	if (len <= 0)	/* if nothing being freed */
		return error;
1944
	rt = XFS_IS_REALTIME_INODE(ip);
L
Linus Torvalds 已提交
1945
	startoffset_fsb	= XFS_B_TO_FSB(mp, offset);
C
Christoph Hellwig 已提交
1946
	endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
L
Linus Torvalds 已提交
1947

1948
	if (attr_flags & XFS_ATTR_NOLOCK)
1949
		need_iolock = 0;
1950
	if (need_iolock) {
L
Linus Torvalds 已提交
1951
		xfs_ilock(ip, XFS_IOLOCK_EXCL);
1952
		/* wait for the completion of any pending DIOs */
C
Christoph Hellwig 已提交
1953
		inode_dio_wait(VFS_I(ip));
1954
	}
1955

1956
	rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
1957
	ioffset = offset & ~(rounding - 1);
1958

1959
	if (VN_CACHED(VFS_I(ip)) != 0) {
1960
		error = xfs_flushinval_pages(ip, ioffset, -1, FI_REMAPF_LOCKED);
1961 1962
		if (error)
			goto out_unlock_iolock;
1963 1964
	}

L
Linus Torvalds 已提交
1965 1966
	/*
	 * Need to zero the stuff we're not freeing, on disk.
M
Malcolm Parsons 已提交
1967
	 * If it's a realtime file & can't use unwritten extents then we
L
Linus Torvalds 已提交
1968 1969 1970
	 * actually need to zero the extent edges.  Otherwise xfs_bunmapi
	 * will take care of it for us.
	 */
1971
	if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
L
Linus Torvalds 已提交
1972
		nimap = 1;
D
Dave Chinner 已提交
1973 1974
		error = xfs_bmapi_read(ip, startoffset_fsb, 1,
					&imap, &nimap, 0);
L
Linus Torvalds 已提交
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
		if (error)
			goto out_unlock_iolock;
		ASSERT(nimap == 0 || nimap == 1);
		if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
			xfs_daddr_t	block;

			ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
			block = imap.br_startblock;
			mod = do_div(block, mp->m_sb.sb_rextsize);
			if (mod)
				startoffset_fsb += mp->m_sb.sb_rextsize - mod;
		}
		nimap = 1;
D
Dave Chinner 已提交
1988 1989
		error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
					&imap, &nimap, 0);
L
Linus Torvalds 已提交
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
		if (error)
			goto out_unlock_iolock;
		ASSERT(nimap == 0 || nimap == 1);
		if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
			ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
			mod++;
			if (mod && (mod != mp->m_sb.sb_rextsize))
				endoffset_fsb -= mod;
		}
	}
	if ((done = (endoffset_fsb <= startoffset_fsb)))
		/*
		 * One contiguous piece to clear
		 */
		error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
	else {
		/*
		 * Some full blocks, possibly two pieces to clear
		 */
		if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
			error = xfs_zero_remaining_bytes(ip, offset,
				XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
		if (!error &&
		    XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
			error = xfs_zero_remaining_bytes(ip,
				XFS_FSB_TO_B(mp, endoffset_fsb),
				offset + len - 1);
	}

	/*
	 * free file space until done or until there is an error
	 */
	resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
	while (!error && !done) {

		/*
2026 2027 2028
		 * allocate and setup the transaction. Allow this
		 * transaction to dip into the reserve blocks to ensure
		 * the freeing of the space succeeds at ENOSPC.
L
Linus Torvalds 已提交
2029 2030
		 */
		tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
2031
		tp->t_flags |= XFS_TRANS_RESERVE;
L
Linus Torvalds 已提交
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
		error = xfs_trans_reserve(tp,
					  resblks,
					  XFS_WRITE_LOG_RES(mp),
					  0,
					  XFS_TRANS_PERM_LOG_RES,
					  XFS_WRITE_LOG_COUNT);

		/*
		 * check for running out of space
		 */
		if (error) {
			/*
			 * Free the transaction structure.
			 */
			ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
			xfs_trans_cancel(tp, 0);
			break;
		}
		xfs_ilock(ip, XFS_ILOCK_EXCL);
C
Christoph Hellwig 已提交
2051 2052 2053
		error = xfs_trans_reserve_quota(tp, mp,
				ip->i_udquot, ip->i_gdquot,
				resblks, 0, XFS_QMOPT_RES_REGBLKS);
L
Linus Torvalds 已提交
2054 2055 2056
		if (error)
			goto error1;

2057
		xfs_trans_ijoin(tp, ip, 0);
L
Linus Torvalds 已提交
2058 2059 2060 2061

		/*
		 * issue the bunmapi() call to free the blocks
		 */
2062
		xfs_bmap_init(&free_list, &firstfsb);
2063
		error = xfs_bunmapi(tp, ip, startoffset_fsb,
L
Linus Torvalds 已提交
2064
				  endoffset_fsb - startoffset_fsb,
2065
				  0, 2, &firstfsb, &free_list, &done);
L
Linus Torvalds 已提交
2066 2067 2068 2069 2070 2071 2072
		if (error) {
			goto error0;
		}

		/*
		 * complete the transaction
		 */
2073
		error = xfs_bmap_finish(&tp, &free_list, &committed);
L
Linus Torvalds 已提交
2074 2075 2076 2077
		if (error) {
			goto error0;
		}

2078
		error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
L
Linus Torvalds 已提交
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
		xfs_iunlock(ip, XFS_ILOCK_EXCL);
	}

 out_unlock_iolock:
	if (need_iolock)
		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	return error;

 error0:
	xfs_bmap_cancel(&free_list);
 error1:
	xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
	xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
		    XFS_ILOCK_EXCL);
	return error;
}

/*
 * xfs_change_file_space()
 *      This routine allocates or frees disk space for the given file.
 *      The user specified parameters are checked for alignment and size
 *      limitations.
 *
 * RETURNS:
 *       0 on success
 *      errno on error
 *
 */
int
xfs_change_file_space(
2109
	xfs_inode_t	*ip,
L
Linus Torvalds 已提交
2110 2111 2112 2113 2114
	int		cmd,
	xfs_flock64_t	*bf,
	xfs_off_t	offset,
	int		attr_flags)
{
2115
	xfs_mount_t	*mp = ip->i_mount;
L
Linus Torvalds 已提交
2116 2117 2118 2119 2120
	int		clrprealloc;
	int		error;
	xfs_fsize_t	fsize;
	int		setprealloc;
	xfs_off_t	startoffset;
D
Dave Chinner 已提交
2121
	xfs_off_t	end;
L
Linus Torvalds 已提交
2122
	xfs_trans_t	*tp;
2123
	struct iattr	iattr;
D
Dave Chinner 已提交
2124
	int		prealloc_type;
L
Linus Torvalds 已提交
2125

2126
	if (!S_ISREG(ip->i_d.di_mode))
L
Linus Torvalds 已提交
2127 2128 2129 2130 2131 2132 2133 2134 2135
		return XFS_ERROR(EINVAL);

	switch (bf->l_whence) {
	case 0: /*SEEK_SET*/
		break;
	case 1: /*SEEK_CUR*/
		bf->l_start += offset;
		break;
	case 2: /*SEEK_END*/
2136
		bf->l_start += XFS_ISIZE(ip);
L
Linus Torvalds 已提交
2137 2138 2139 2140 2141
		break;
	default:
		return XFS_ERROR(EINVAL);
	}

D
Dave Chinner 已提交
2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
	/*
	 * length of <= 0 for resv/unresv/zero is invalid.  length for
	 * alloc/free is ignored completely and we have no idea what userspace
	 * might have set it to, so set it to zero to allow range
	 * checks to pass.
	 */
	switch (cmd) {
	case XFS_IOC_ZERO_RANGE:
	case XFS_IOC_RESVSP:
	case XFS_IOC_RESVSP64:
	case XFS_IOC_UNRESVSP:
	case XFS_IOC_UNRESVSP64:
		if (bf->l_len <= 0)
			return XFS_ERROR(EINVAL);
		break;
	default:
		bf->l_len = 0;
		break;
	}
L
Linus Torvalds 已提交
2161

2162 2163
	if (bf->l_start < 0 ||
	    bf->l_start > mp->m_super->s_maxbytes ||
D
Dave Chinner 已提交
2164 2165
	    bf->l_start + bf->l_len < 0 ||
	    bf->l_start + bf->l_len >= mp->m_super->s_maxbytes)
L
Linus Torvalds 已提交
2166 2167 2168 2169 2170
		return XFS_ERROR(EINVAL);

	bf->l_whence = 0;

	startoffset = bf->l_start;
2171
	fsize = XFS_ISIZE(ip);
L
Linus Torvalds 已提交
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184

	/*
	 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
	 * file space.
	 * These calls do NOT zero the data space allocated to the file,
	 * nor do they change the file size.
	 *
	 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
	 * space.
	 * These calls cause the new file data to be zeroed and the file
	 * size to be changed.
	 */
	setprealloc = clrprealloc = 0;
D
Dave Chinner 已提交
2185
	prealloc_type = XFS_BMAPI_PREALLOC;
L
Linus Torvalds 已提交
2186 2187

	switch (cmd) {
D
Dave Chinner 已提交
2188 2189
	case XFS_IOC_ZERO_RANGE:
		prealloc_type |= XFS_BMAPI_CONVERT;
D
Dave Chinner 已提交
2190
		end = round_down(startoffset + bf->l_len, PAGE_SIZE) - 1;
2191
		if (startoffset <= end)
D
Dave Chinner 已提交
2192
			truncate_pagecache_range(VFS_I(ip), startoffset, end);
D
Dave Chinner 已提交
2193
		/* FALLTHRU */
L
Linus Torvalds 已提交
2194 2195 2196
	case XFS_IOC_RESVSP:
	case XFS_IOC_RESVSP64:
		error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
D
Dave Chinner 已提交
2197
						prealloc_type, attr_flags);
L
Linus Torvalds 已提交
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
		if (error)
			return error;
		setprealloc = 1;
		break;

	case XFS_IOC_UNRESVSP:
	case XFS_IOC_UNRESVSP64:
		if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
								attr_flags)))
			return error;
		break;

	case XFS_IOC_ALLOCSP:
	case XFS_IOC_ALLOCSP64:
	case XFS_IOC_FREESP:
	case XFS_IOC_FREESP64:
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
		/*
		 * These operations actually do IO when extending the file, but
		 * the allocation is done seperately to the zeroing that is
		 * done. This set of operations need to be serialised against
		 * other IO operations, such as truncate and buffered IO. We
		 * need to take the IOLOCK here to serialise the allocation and
		 * zeroing IO to prevent other IOLOCK holders (e.g. getbmap,
		 * truncate, direct IO) from racing against the transient
		 * allocated but not written state we can have here.
		 */
		xfs_ilock(ip, XFS_IOLOCK_EXCL);
L
Linus Torvalds 已提交
2225 2226
		if (startoffset > fsize) {
			error = xfs_alloc_file_space(ip, fsize,
2227 2228 2229 2230
					startoffset - fsize, 0,
					attr_flags | XFS_ATTR_NOLOCK);
			if (error) {
				xfs_iunlock(ip, XFS_IOLOCK_EXCL);
L
Linus Torvalds 已提交
2231
				break;
2232
			}
L
Linus Torvalds 已提交
2233 2234
		}

2235 2236
		iattr.ia_valid = ATTR_SIZE;
		iattr.ia_size = startoffset;
L
Linus Torvalds 已提交
2237

2238 2239 2240
		error = xfs_setattr_size(ip, &iattr,
					 attr_flags | XFS_ATTR_NOLOCK);
		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
L
Linus Torvalds 已提交
2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265

		if (error)
			return error;

		clrprealloc = 1;
		break;

	default:
		ASSERT(0);
		return XFS_ERROR(EINVAL);
	}

	/*
	 * update the inode timestamp, mode, and prealloc flag bits
	 */
	tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);

	if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
				      0, 0, 0))) {
		/* ASSERT(0); */
		xfs_trans_cancel(tp, 0);
		return error;
	}

	xfs_ilock(ip, XFS_ILOCK_EXCL);
2266
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
2267

2268
	if ((attr_flags & XFS_ATTR_DMI) == 0) {
L
Linus Torvalds 已提交
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
		ip->i_d.di_mode &= ~S_ISUID;

		/*
		 * Note that we don't have to worry about mandatory
		 * file locking being disabled here because we only
		 * clear the S_ISGID bit if the Group execute bit is
		 * on, but if it was on then mandatory locking wouldn't
		 * have been enabled.
		 */
		if (ip->i_d.di_mode & S_IXGRP)
			ip->i_d.di_mode &= ~S_ISGID;

2281
		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
L
Linus Torvalds 已提交
2282 2283 2284 2285 2286 2287 2288
	}
	if (setprealloc)
		ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
	else if (clrprealloc)
		ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2289 2290
	if (attr_flags & XFS_ATTR_SYNC)
		xfs_trans_set_sync(tp);
2291
	return xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
2292
}