Linux Audio

Check our new training course

Loading...
v6.9.4
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include <linux/iversion.h>
   7
   8#include "xfs.h"
   9#include "xfs_fs.h"
  10#include "xfs_shared.h"
  11#include "xfs_format.h"
  12#include "xfs_log_format.h"
  13#include "xfs_trans_resv.h"
  14#include "xfs_mount.h"
  15#include "xfs_defer.h"
  16#include "xfs_inode.h"
  17#include "xfs_dir2.h"
  18#include "xfs_attr.h"
 
  19#include "xfs_trans_space.h"
  20#include "xfs_trans.h"
  21#include "xfs_buf_item.h"
  22#include "xfs_inode_item.h"
  23#include "xfs_iunlink_item.h"
  24#include "xfs_ialloc.h"
  25#include "xfs_bmap.h"
  26#include "xfs_bmap_util.h"
  27#include "xfs_errortag.h"
  28#include "xfs_error.h"
  29#include "xfs_quota.h"
  30#include "xfs_filestream.h"
  31#include "xfs_trace.h"
  32#include "xfs_icache.h"
  33#include "xfs_symlink.h"
  34#include "xfs_trans_priv.h"
  35#include "xfs_log.h"
  36#include "xfs_bmap_btree.h"
  37#include "xfs_reflink.h"
  38#include "xfs_ag.h"
  39#include "xfs_log_priv.h"
  40#include "xfs_health.h"
 
 
 
 
 
  41
  42struct kmem_cache *xfs_inode_cache;
  43
  44STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
  45STATIC int xfs_iunlink_remove(struct xfs_trans *tp, struct xfs_perag *pag,
  46	struct xfs_inode *);
  47
  48/*
  49 * helper function to extract extent size hint from inode
  50 */
  51xfs_extlen_t
  52xfs_get_extsz_hint(
  53	struct xfs_inode	*ip)
  54{
  55	/*
  56	 * No point in aligning allocations if we need to COW to actually
  57	 * write to them.
  58	 */
  59	if (xfs_is_always_cow_inode(ip))
  60		return 0;
  61	if ((ip->i_diflags & XFS_DIFLAG_EXTSIZE) && ip->i_extsize)
  62		return ip->i_extsize;
  63	if (XFS_IS_REALTIME_INODE(ip))
  64		return ip->i_mount->m_sb.sb_rextsize;
  65	return 0;
  66}
  67
  68/*
  69 * Helper function to extract CoW extent size hint from inode.
  70 * Between the extent size hint and the CoW extent size hint, we
  71 * return the greater of the two.  If the value is zero (automatic),
  72 * use the default size.
  73 */
  74xfs_extlen_t
  75xfs_get_cowextsz_hint(
  76	struct xfs_inode	*ip)
  77{
  78	xfs_extlen_t		a, b;
  79
  80	a = 0;
  81	if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
  82		a = ip->i_cowextsize;
  83	b = xfs_get_extsz_hint(ip);
  84
  85	a = max(a, b);
  86	if (a == 0)
  87		return XFS_DEFAULT_COWEXTSZ_HINT;
  88	return a;
  89}
  90
  91/*
  92 * These two are wrapper routines around the xfs_ilock() routine used to
  93 * centralize some grungy code.  They are used in places that wish to lock the
  94 * inode solely for reading the extents.  The reason these places can't just
  95 * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
  96 * bringing in of the extents from disk for a file in b-tree format.  If the
  97 * inode is in b-tree format, then we need to lock the inode exclusively until
  98 * the extents are read in.  Locking it exclusively all the time would limit
  99 * our parallelism unnecessarily, though.  What we do instead is check to see
 100 * if the extents have been read in yet, and only lock the inode exclusively
 101 * if they have not.
 102 *
 103 * The functions return a value which should be given to the corresponding
 104 * xfs_iunlock() call.
 105 */
 106uint
 107xfs_ilock_data_map_shared(
 108	struct xfs_inode	*ip)
 109{
 110	uint			lock_mode = XFS_ILOCK_SHARED;
 111
 112	if (xfs_need_iread_extents(&ip->i_df))
 113		lock_mode = XFS_ILOCK_EXCL;
 114	xfs_ilock(ip, lock_mode);
 115	return lock_mode;
 116}
 117
 118uint
 119xfs_ilock_attr_map_shared(
 120	struct xfs_inode	*ip)
 121{
 122	uint			lock_mode = XFS_ILOCK_SHARED;
 123
 124	if (xfs_inode_has_attr_fork(ip) && xfs_need_iread_extents(&ip->i_af))
 125		lock_mode = XFS_ILOCK_EXCL;
 126	xfs_ilock(ip, lock_mode);
 127	return lock_mode;
 128}
 129
 130/*
 131 * You can't set both SHARED and EXCL for the same lock,
 132 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_MMAPLOCK_SHARED,
 133 * XFS_MMAPLOCK_EXCL, XFS_ILOCK_SHARED, XFS_ILOCK_EXCL are valid values
 134 * to set in lock_flags.
 135 */
 136static inline void
 137xfs_lock_flags_assert(
 138	uint		lock_flags)
 139{
 140	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 141		(XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 142	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
 143		(XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
 144	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 145		(XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 146	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
 147	ASSERT(lock_flags != 0);
 148}
 149
 150/*
 151 * In addition to i_rwsem in the VFS inode, the xfs inode contains 2
 152 * multi-reader locks: invalidate_lock and the i_lock.  This routine allows
 153 * various combinations of the locks to be obtained.
 154 *
 155 * The 3 locks should always be ordered so that the IO lock is obtained first,
 156 * the mmap lock second and the ilock last in order to prevent deadlock.
 157 *
 158 * Basic locking order:
 159 *
 160 * i_rwsem -> invalidate_lock -> page_lock -> i_ilock
 161 *
 162 * mmap_lock locking order:
 163 *
 164 * i_rwsem -> page lock -> mmap_lock
 165 * mmap_lock -> invalidate_lock -> page_lock
 166 *
 167 * The difference in mmap_lock locking order mean that we cannot hold the
 168 * invalidate_lock over syscall based read(2)/write(2) based IO. These IO paths
 169 * can fault in pages during copy in/out (for buffered IO) or require the
 170 * mmap_lock in get_user_pages() to map the user pages into the kernel address
 171 * space for direct IO. Similarly the i_rwsem cannot be taken inside a page
 172 * fault because page faults already hold the mmap_lock.
 173 *
 174 * Hence to serialise fully against both syscall and mmap based IO, we need to
 175 * take both the i_rwsem and the invalidate_lock. These locks should *only* be
 176 * both taken in places where we need to invalidate the page cache in a race
 177 * free manner (e.g. truncate, hole punch and other extent manipulation
 178 * functions).
 179 */
 180void
 181xfs_ilock(
 182	xfs_inode_t		*ip,
 183	uint			lock_flags)
 184{
 185	trace_xfs_ilock(ip, lock_flags, _RET_IP_);
 186
 187	xfs_lock_flags_assert(lock_flags);
 188
 189	if (lock_flags & XFS_IOLOCK_EXCL) {
 190		down_write_nested(&VFS_I(ip)->i_rwsem,
 191				  XFS_IOLOCK_DEP(lock_flags));
 192	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 193		down_read_nested(&VFS_I(ip)->i_rwsem,
 194				 XFS_IOLOCK_DEP(lock_flags));
 195	}
 196
 197	if (lock_flags & XFS_MMAPLOCK_EXCL) {
 198		down_write_nested(&VFS_I(ip)->i_mapping->invalidate_lock,
 199				  XFS_MMAPLOCK_DEP(lock_flags));
 200	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
 201		down_read_nested(&VFS_I(ip)->i_mapping->invalidate_lock,
 202				 XFS_MMAPLOCK_DEP(lock_flags));
 203	}
 204
 205	if (lock_flags & XFS_ILOCK_EXCL)
 206		down_write_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 207	else if (lock_flags & XFS_ILOCK_SHARED)
 208		down_read_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 209}
 210
 211/*
 212 * This is just like xfs_ilock(), except that the caller
 213 * is guaranteed not to sleep.  It returns 1 if it gets
 214 * the requested locks and 0 otherwise.  If the IO lock is
 215 * obtained but the inode lock cannot be, then the IO lock
 216 * is dropped before returning.
 217 *
 218 * ip -- the inode being locked
 219 * lock_flags -- this parameter indicates the inode's locks to be
 220 *       to be locked.  See the comment for xfs_ilock() for a list
 221 *	 of valid values.
 222 */
 223int
 224xfs_ilock_nowait(
 225	xfs_inode_t		*ip,
 226	uint			lock_flags)
 227{
 228	trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
 229
 230	xfs_lock_flags_assert(lock_flags);
 231
 232	if (lock_flags & XFS_IOLOCK_EXCL) {
 233		if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
 234			goto out;
 235	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 236		if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
 237			goto out;
 238	}
 239
 240	if (lock_flags & XFS_MMAPLOCK_EXCL) {
 241		if (!down_write_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))
 242			goto out_undo_iolock;
 243	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
 244		if (!down_read_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))
 245			goto out_undo_iolock;
 246	}
 247
 248	if (lock_flags & XFS_ILOCK_EXCL) {
 249		if (!down_write_trylock(&ip->i_lock))
 250			goto out_undo_mmaplock;
 251	} else if (lock_flags & XFS_ILOCK_SHARED) {
 252		if (!down_read_trylock(&ip->i_lock))
 253			goto out_undo_mmaplock;
 254	}
 255	return 1;
 256
 257out_undo_mmaplock:
 258	if (lock_flags & XFS_MMAPLOCK_EXCL)
 259		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 260	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 261		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);
 262out_undo_iolock:
 263	if (lock_flags & XFS_IOLOCK_EXCL)
 264		up_write(&VFS_I(ip)->i_rwsem);
 265	else if (lock_flags & XFS_IOLOCK_SHARED)
 266		up_read(&VFS_I(ip)->i_rwsem);
 267out:
 268	return 0;
 269}
 270
 271/*
 272 * xfs_iunlock() is used to drop the inode locks acquired with
 273 * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
 274 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
 275 * that we know which locks to drop.
 276 *
 277 * ip -- the inode being unlocked
 278 * lock_flags -- this parameter indicates the inode's locks to be
 279 *       to be unlocked.  See the comment for xfs_ilock() for a list
 280 *	 of valid values for this parameter.
 281 *
 282 */
 283void
 284xfs_iunlock(
 285	xfs_inode_t		*ip,
 286	uint			lock_flags)
 287{
 288	xfs_lock_flags_assert(lock_flags);
 289
 290	if (lock_flags & XFS_IOLOCK_EXCL)
 291		up_write(&VFS_I(ip)->i_rwsem);
 292	else if (lock_flags & XFS_IOLOCK_SHARED)
 293		up_read(&VFS_I(ip)->i_rwsem);
 294
 295	if (lock_flags & XFS_MMAPLOCK_EXCL)
 296		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 297	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 298		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);
 299
 300	if (lock_flags & XFS_ILOCK_EXCL)
 301		up_write(&ip->i_lock);
 302	else if (lock_flags & XFS_ILOCK_SHARED)
 303		up_read(&ip->i_lock);
 304
 305	trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
 306}
 307
 308/*
 309 * give up write locks.  the i/o lock cannot be held nested
 310 * if it is being demoted.
 311 */
 312void
 313xfs_ilock_demote(
 314	xfs_inode_t		*ip,
 315	uint			lock_flags)
 316{
 317	ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
 318	ASSERT((lock_flags &
 319		~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
 320
 321	if (lock_flags & XFS_ILOCK_EXCL)
 322		downgrade_write(&ip->i_lock);
 323	if (lock_flags & XFS_MMAPLOCK_EXCL)
 324		downgrade_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 325	if (lock_flags & XFS_IOLOCK_EXCL)
 326		downgrade_write(&VFS_I(ip)->i_rwsem);
 327
 328	trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
 329}
 330
 331void
 332xfs_assert_ilocked(
 333	struct xfs_inode	*ip,
 334	uint			lock_flags)
 335{
 336	/*
 337	 * Sometimes we assert the ILOCK is held exclusively, but we're in
 338	 * a workqueue, so lockdep doesn't know we're the owner.
 339	 */
 340	if (lock_flags & XFS_ILOCK_SHARED)
 341		rwsem_assert_held(&ip->i_lock);
 342	else if (lock_flags & XFS_ILOCK_EXCL)
 343		rwsem_assert_held_write_nolockdep(&ip->i_lock);
 344
 345	if (lock_flags & XFS_MMAPLOCK_SHARED)
 346		rwsem_assert_held(&VFS_I(ip)->i_mapping->invalidate_lock);
 347	else if (lock_flags & XFS_MMAPLOCK_EXCL)
 348		rwsem_assert_held_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 349
 350	if (lock_flags & XFS_IOLOCK_SHARED)
 351		rwsem_assert_held(&VFS_I(ip)->i_rwsem);
 352	else if (lock_flags & XFS_IOLOCK_EXCL)
 353		rwsem_assert_held_write(&VFS_I(ip)->i_rwsem);
 354}
 355
 356/*
 357 * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
 358 * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
 359 * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
 360 * errors and warnings.
 361 */
 362#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
 363static bool
 364xfs_lockdep_subclass_ok(
 365	int subclass)
 366{
 367	return subclass < MAX_LOCKDEP_SUBCLASSES;
 368}
 369#else
 370#define xfs_lockdep_subclass_ok(subclass)	(true)
 371#endif
 372
 373/*
 374 * Bump the subclass so xfs_lock_inodes() acquires each lock with a different
 375 * value. This can be called for any type of inode lock combination, including
 376 * parent locking. Care must be taken to ensure we don't overrun the subclass
 377 * storage fields in the class mask we build.
 378 */
 379static inline uint
 380xfs_lock_inumorder(
 381	uint	lock_mode,
 382	uint	subclass)
 383{
 384	uint	class = 0;
 385
 386	ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
 387			      XFS_ILOCK_RTSUM)));
 388	ASSERT(xfs_lockdep_subclass_ok(subclass));
 389
 390	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
 391		ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
 392		class += subclass << XFS_IOLOCK_SHIFT;
 393	}
 394
 395	if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
 396		ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
 397		class += subclass << XFS_MMAPLOCK_SHIFT;
 398	}
 399
 400	if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
 401		ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
 402		class += subclass << XFS_ILOCK_SHIFT;
 403	}
 404
 405	return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
 406}
 407
 408/*
 409 * The following routine will lock n inodes in exclusive mode.  We assume the
 410 * caller calls us with the inodes in i_ino order.
 411 *
 412 * We need to detect deadlock where an inode that we lock is in the AIL and we
 413 * start waiting for another inode that is locked by a thread in a long running
 414 * transaction (such as truncate). This can result in deadlock since the long
 415 * running trans might need to wait for the inode we just locked in order to
 416 * push the tail and free space in the log.
 417 *
 418 * xfs_lock_inodes() can only be used to lock one type of lock at a time -
 419 * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
 420 * lock more than one at a time, lockdep will report false positives saying we
 421 * have violated locking orders.
 422 */
 423static void
 424xfs_lock_inodes(
 425	struct xfs_inode	**ips,
 426	int			inodes,
 427	uint			lock_mode)
 428{
 429	int			attempts = 0;
 430	uint			i;
 431	int			j;
 432	bool			try_lock;
 433	struct xfs_log_item	*lp;
 434
 435	/*
 436	 * Currently supports between 2 and 5 inodes with exclusive locking.  We
 437	 * support an arbitrary depth of locking here, but absolute limits on
 438	 * inodes depend on the type of locking and the limits placed by
 439	 * lockdep annotations in xfs_lock_inumorder.  These are all checked by
 440	 * the asserts.
 441	 */
 442	ASSERT(ips && inodes >= 2 && inodes <= 5);
 443	ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
 444			    XFS_ILOCK_EXCL));
 445	ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
 446			      XFS_ILOCK_SHARED)));
 447	ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
 448		inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
 449	ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
 450		inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
 451
 452	if (lock_mode & XFS_IOLOCK_EXCL) {
 453		ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
 454	} else if (lock_mode & XFS_MMAPLOCK_EXCL)
 455		ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
 456
 457again:
 458	try_lock = false;
 459	i = 0;
 460	for (; i < inodes; i++) {
 461		ASSERT(ips[i]);
 462
 463		if (i && (ips[i] == ips[i - 1]))	/* Already locked */
 464			continue;
 465
 466		/*
 467		 * If try_lock is not set yet, make sure all locked inodes are
 468		 * not in the AIL.  If any are, set try_lock to be used later.
 469		 */
 470		if (!try_lock) {
 471			for (j = (i - 1); j >= 0 && !try_lock; j--) {
 472				lp = &ips[j]->i_itemp->ili_item;
 473				if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))
 474					try_lock = true;
 475			}
 476		}
 477
 478		/*
 479		 * If any of the previous locks we have locked is in the AIL,
 480		 * we must TRY to get the second and subsequent locks. If
 481		 * we can't get any, we must release all we have
 482		 * and try again.
 483		 */
 484		if (!try_lock) {
 485			xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
 486			continue;
 487		}
 488
 489		/* try_lock means we have an inode locked that is in the AIL. */
 490		ASSERT(i != 0);
 491		if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
 492			continue;
 493
 494		/*
 495		 * Unlock all previous guys and try again.  xfs_iunlock will try
 496		 * to push the tail if the inode is in the AIL.
 497		 */
 498		attempts++;
 499		for (j = i - 1; j >= 0; j--) {
 500			/*
 501			 * Check to see if we've already unlocked this one.  Not
 502			 * the first one going back, and the inode ptr is the
 503			 * same.
 504			 */
 505			if (j != (i - 1) && ips[j] == ips[j + 1])
 506				continue;
 507
 508			xfs_iunlock(ips[j], lock_mode);
 509		}
 510
 511		if ((attempts % 5) == 0) {
 512			delay(1); /* Don't just spin the CPU */
 513		}
 514		goto again;
 515	}
 516}
 517
 518/*
 519 * xfs_lock_two_inodes() can only be used to lock ilock. The iolock and
 520 * mmaplock must be double-locked separately since we use i_rwsem and
 521 * invalidate_lock for that. We now support taking one lock EXCL and the
 522 * other SHARED.
 523 */
 524void
 525xfs_lock_two_inodes(
 526	struct xfs_inode	*ip0,
 527	uint			ip0_mode,
 528	struct xfs_inode	*ip1,
 529	uint			ip1_mode)
 530{
 531	int			attempts = 0;
 532	struct xfs_log_item	*lp;
 533
 534	ASSERT(hweight32(ip0_mode) == 1);
 535	ASSERT(hweight32(ip1_mode) == 1);
 536	ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 537	ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 538	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)));
 539	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)));
 540	ASSERT(ip0->i_ino != ip1->i_ino);
 541
 542	if (ip0->i_ino > ip1->i_ino) {
 543		swap(ip0, ip1);
 544		swap(ip0_mode, ip1_mode);
 545	}
 546
 547 again:
 548	xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
 549
 550	/*
 551	 * If the first lock we have locked is in the AIL, we must TRY to get
 552	 * the second lock. If we can't get it, we must release the first one
 553	 * and try again.
 554	 */
 555	lp = &ip0->i_itemp->ili_item;
 556	if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {
 557		if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
 558			xfs_iunlock(ip0, ip0_mode);
 559			if ((++attempts % 5) == 0)
 560				delay(1); /* Don't just spin the CPU */
 561			goto again;
 562		}
 563	} else {
 564		xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
 565	}
 566}
 567
 568uint
 569xfs_ip2xflags(
 570	struct xfs_inode	*ip)
 571{
 572	uint			flags = 0;
 573
 574	if (ip->i_diflags & XFS_DIFLAG_ANY) {
 575		if (ip->i_diflags & XFS_DIFLAG_REALTIME)
 576			flags |= FS_XFLAG_REALTIME;
 577		if (ip->i_diflags & XFS_DIFLAG_PREALLOC)
 578			flags |= FS_XFLAG_PREALLOC;
 579		if (ip->i_diflags & XFS_DIFLAG_IMMUTABLE)
 580			flags |= FS_XFLAG_IMMUTABLE;
 581		if (ip->i_diflags & XFS_DIFLAG_APPEND)
 582			flags |= FS_XFLAG_APPEND;
 583		if (ip->i_diflags & XFS_DIFLAG_SYNC)
 584			flags |= FS_XFLAG_SYNC;
 585		if (ip->i_diflags & XFS_DIFLAG_NOATIME)
 586			flags |= FS_XFLAG_NOATIME;
 587		if (ip->i_diflags & XFS_DIFLAG_NODUMP)
 588			flags |= FS_XFLAG_NODUMP;
 589		if (ip->i_diflags & XFS_DIFLAG_RTINHERIT)
 590			flags |= FS_XFLAG_RTINHERIT;
 591		if (ip->i_diflags & XFS_DIFLAG_PROJINHERIT)
 592			flags |= FS_XFLAG_PROJINHERIT;
 593		if (ip->i_diflags & XFS_DIFLAG_NOSYMLINKS)
 594			flags |= FS_XFLAG_NOSYMLINKS;
 595		if (ip->i_diflags & XFS_DIFLAG_EXTSIZE)
 596			flags |= FS_XFLAG_EXTSIZE;
 597		if (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT)
 598			flags |= FS_XFLAG_EXTSZINHERIT;
 599		if (ip->i_diflags & XFS_DIFLAG_NODEFRAG)
 600			flags |= FS_XFLAG_NODEFRAG;
 601		if (ip->i_diflags & XFS_DIFLAG_FILESTREAM)
 602			flags |= FS_XFLAG_FILESTREAM;
 603	}
 604
 605	if (ip->i_diflags2 & XFS_DIFLAG2_ANY) {
 606		if (ip->i_diflags2 & XFS_DIFLAG2_DAX)
 607			flags |= FS_XFLAG_DAX;
 608		if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 609			flags |= FS_XFLAG_COWEXTSIZE;
 610	}
 611
 612	if (xfs_inode_has_attr_fork(ip))
 613		flags |= FS_XFLAG_HASATTR;
 614	return flags;
 615}
 616
 617/*
 618 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
 619 * is allowed, otherwise it has to be an exact match. If a CI match is found,
 620 * ci_name->name will point to a the actual name (caller must free) or
 621 * will be set to NULL if an exact match is found.
 622 */
 623int
 624xfs_lookup(
 625	struct xfs_inode	*dp,
 626	const struct xfs_name	*name,
 627	struct xfs_inode	**ipp,
 628	struct xfs_name		*ci_name)
 629{
 630	xfs_ino_t		inum;
 631	int			error;
 632
 633	trace_xfs_lookup(dp, name);
 634
 635	if (xfs_is_shutdown(dp->i_mount))
 636		return -EIO;
 637	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
 638		return -EIO;
 639
 640	error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
 641	if (error)
 642		goto out_unlock;
 643
 644	error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
 645	if (error)
 646		goto out_free_name;
 647
 
 
 
 
 
 
 
 
 
 
 648	return 0;
 649
 
 
 650out_free_name:
 651	if (ci_name)
 652		kfree(ci_name->name);
 653out_unlock:
 654	*ipp = NULL;
 655	return error;
 656}
 657
 658/* Propagate di_flags from a parent inode to a child inode. */
 659static void
 660xfs_inode_inherit_flags(
 661	struct xfs_inode	*ip,
 662	const struct xfs_inode	*pip)
 663{
 664	unsigned int		di_flags = 0;
 665	xfs_failaddr_t		failaddr;
 666	umode_t			mode = VFS_I(ip)->i_mode;
 667
 668	if (S_ISDIR(mode)) {
 669		if (pip->i_diflags & XFS_DIFLAG_RTINHERIT)
 670			di_flags |= XFS_DIFLAG_RTINHERIT;
 671		if (pip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
 672			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 673			ip->i_extsize = pip->i_extsize;
 674		}
 675		if (pip->i_diflags & XFS_DIFLAG_PROJINHERIT)
 676			di_flags |= XFS_DIFLAG_PROJINHERIT;
 677	} else if (S_ISREG(mode)) {
 678		if ((pip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
 679		    xfs_has_realtime(ip->i_mount))
 680			di_flags |= XFS_DIFLAG_REALTIME;
 681		if (pip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
 682			di_flags |= XFS_DIFLAG_EXTSIZE;
 683			ip->i_extsize = pip->i_extsize;
 684		}
 685	}
 686	if ((pip->i_diflags & XFS_DIFLAG_NOATIME) &&
 687	    xfs_inherit_noatime)
 688		di_flags |= XFS_DIFLAG_NOATIME;
 689	if ((pip->i_diflags & XFS_DIFLAG_NODUMP) &&
 690	    xfs_inherit_nodump)
 691		di_flags |= XFS_DIFLAG_NODUMP;
 692	if ((pip->i_diflags & XFS_DIFLAG_SYNC) &&
 693	    xfs_inherit_sync)
 694		di_flags |= XFS_DIFLAG_SYNC;
 695	if ((pip->i_diflags & XFS_DIFLAG_NOSYMLINKS) &&
 696	    xfs_inherit_nosymlinks)
 697		di_flags |= XFS_DIFLAG_NOSYMLINKS;
 698	if ((pip->i_diflags & XFS_DIFLAG_NODEFRAG) &&
 699	    xfs_inherit_nodefrag)
 700		di_flags |= XFS_DIFLAG_NODEFRAG;
 701	if (pip->i_diflags & XFS_DIFLAG_FILESTREAM)
 702		di_flags |= XFS_DIFLAG_FILESTREAM;
 703
 704	ip->i_diflags |= di_flags;
 705
 706	/*
 707	 * Inode verifiers on older kernels only check that the extent size
 708	 * hint is an integer multiple of the rt extent size on realtime files.
 709	 * They did not check the hint alignment on a directory with both
 710	 * rtinherit and extszinherit flags set.  If the misaligned hint is
 711	 * propagated from a directory into a new realtime file, new file
 712	 * allocations will fail due to math errors in the rt allocator and/or
 713	 * trip the verifiers.  Validate the hint settings in the new file so
 714	 * that we don't let broken hints propagate.
 715	 */
 716	failaddr = xfs_inode_validate_extsize(ip->i_mount, ip->i_extsize,
 717			VFS_I(ip)->i_mode, ip->i_diflags);
 718	if (failaddr) {
 719		ip->i_diflags &= ~(XFS_DIFLAG_EXTSIZE |
 720				   XFS_DIFLAG_EXTSZINHERIT);
 721		ip->i_extsize = 0;
 722	}
 723}
 724
 725/* Propagate di_flags2 from a parent inode to a child inode. */
 726static void
 727xfs_inode_inherit_flags2(
 728	struct xfs_inode	*ip,
 729	const struct xfs_inode	*pip)
 730{
 731	xfs_failaddr_t		failaddr;
 732
 733	if (pip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE) {
 734		ip->i_diflags2 |= XFS_DIFLAG2_COWEXTSIZE;
 735		ip->i_cowextsize = pip->i_cowextsize;
 736	}
 737	if (pip->i_diflags2 & XFS_DIFLAG2_DAX)
 738		ip->i_diflags2 |= XFS_DIFLAG2_DAX;
 739
 740	/* Don't let invalid cowextsize hints propagate. */
 741	failaddr = xfs_inode_validate_cowextsize(ip->i_mount, ip->i_cowextsize,
 742			VFS_I(ip)->i_mode, ip->i_diflags, ip->i_diflags2);
 743	if (failaddr) {
 744		ip->i_diflags2 &= ~XFS_DIFLAG2_COWEXTSIZE;
 745		ip->i_cowextsize = 0;
 746	}
 747}
 748
 749/*
 750 * Initialise a newly allocated inode and return the in-core inode to the
 751 * caller locked exclusively.
 
 
 752 */
 753int
 754xfs_init_new_inode(
 755	struct mnt_idmap	*idmap,
 756	struct xfs_trans	*tp,
 757	struct xfs_inode	*pip,
 758	xfs_ino_t		ino,
 759	umode_t			mode,
 760	xfs_nlink_t		nlink,
 761	dev_t			rdev,
 762	prid_t			prid,
 763	bool			init_xattrs,
 764	struct xfs_inode	**ipp)
 765{
 766	struct inode		*dir = pip ? VFS_I(pip) : NULL;
 767	struct xfs_mount	*mp = tp->t_mountp;
 768	struct xfs_inode	*ip;
 769	unsigned int		flags;
 770	int			error;
 771	struct timespec64	tv;
 772	struct inode		*inode;
 773
 774	/*
 775	 * Protect against obviously corrupt allocation btree records. Later
 776	 * xfs_iget checks will catch re-allocation of other active in-memory
 777	 * and on-disk inodes. If we don't catch reallocating the parent inode
 778	 * here we will deadlock in xfs_iget() so we have to do these checks
 779	 * first.
 780	 */
 781	if ((pip && ino == pip->i_ino) || !xfs_verify_dir_ino(mp, ino)) {
 782		xfs_alert(mp, "Allocated a known in-use inode 0x%llx!", ino);
 783		xfs_agno_mark_sick(mp, XFS_INO_TO_AGNO(mp, ino),
 784				XFS_SICK_AG_INOBT);
 785		return -EFSCORRUPTED;
 786	}
 787
 788	/*
 789	 * Get the in-core inode with the lock held exclusively to prevent
 790	 * others from looking at until we're done.
 791	 */
 792	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
 793	if (error)
 794		return error;
 795
 796	ASSERT(ip != NULL);
 797	inode = VFS_I(ip);
 798	set_nlink(inode, nlink);
 799	inode->i_rdev = rdev;
 800	ip->i_projid = prid;
 801
 802	if (dir && !(dir->i_mode & S_ISGID) && xfs_has_grpid(mp)) {
 803		inode_fsuid_set(inode, idmap);
 804		inode->i_gid = dir->i_gid;
 805		inode->i_mode = mode;
 806	} else {
 807		inode_init_owner(idmap, inode, dir, mode);
 808	}
 809
 810	/*
 811	 * If the group ID of the new file does not match the effective group
 812	 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
 813	 * (and only if the irix_sgid_inherit compatibility variable is set).
 814	 */
 815	if (irix_sgid_inherit && (inode->i_mode & S_ISGID) &&
 816	    !vfsgid_in_group_p(i_gid_into_vfsgid(idmap, inode)))
 817		inode->i_mode &= ~S_ISGID;
 818
 819	ip->i_disk_size = 0;
 820	ip->i_df.if_nextents = 0;
 821	ASSERT(ip->i_nblocks == 0);
 822
 823	tv = inode_set_ctime_current(inode);
 824	inode_set_mtime_to_ts(inode, tv);
 825	inode_set_atime_to_ts(inode, tv);
 826
 827	ip->i_extsize = 0;
 828	ip->i_diflags = 0;
 829
 830	if (xfs_has_v3inodes(mp)) {
 831		inode_set_iversion(inode, 1);
 832		ip->i_cowextsize = 0;
 833		ip->i_crtime = tv;
 834	}
 835
 836	flags = XFS_ILOG_CORE;
 837	switch (mode & S_IFMT) {
 838	case S_IFIFO:
 839	case S_IFCHR:
 840	case S_IFBLK:
 841	case S_IFSOCK:
 842		ip->i_df.if_format = XFS_DINODE_FMT_DEV;
 843		flags |= XFS_ILOG_DEV;
 844		break;
 845	case S_IFREG:
 846	case S_IFDIR:
 847		if (pip && (pip->i_diflags & XFS_DIFLAG_ANY))
 848			xfs_inode_inherit_flags(ip, pip);
 849		if (pip && (pip->i_diflags2 & XFS_DIFLAG2_ANY))
 850			xfs_inode_inherit_flags2(ip, pip);
 851		fallthrough;
 852	case S_IFLNK:
 853		ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
 854		ip->i_df.if_bytes = 0;
 855		ip->i_df.if_data = NULL;
 856		break;
 857	default:
 858		ASSERT(0);
 859	}
 860
 861	/*
 862	 * If we need to create attributes immediately after allocating the
 863	 * inode, initialise an empty attribute fork right now. We use the
 864	 * default fork offset for attributes here as we don't know exactly what
 865	 * size or how many attributes we might be adding. We can do this
 866	 * safely here because we know the data fork is completely empty and
 867	 * this saves us from needing to run a separate transaction to set the
 868	 * fork offset in the immediate future.
 869	 */
 870	if (init_xattrs && xfs_has_attr(mp)) {
 871		ip->i_forkoff = xfs_default_attroffset(ip) >> 3;
 872		xfs_ifork_init_attr(ip, XFS_DINODE_FMT_EXTENTS, 0);
 873	}
 874
 875	/*
 876	 * Log the new values stuffed into the inode.
 877	 */
 878	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 879	xfs_trans_log_inode(tp, ip, flags);
 880
 881	/* now that we have an i_mode we can setup the inode structure */
 882	xfs_setup_inode(ip);
 883
 884	*ipp = ip;
 885	return 0;
 886}
 887
 888/*
 889 * Decrement the link count on an inode & log the change.  If this causes the
 890 * link count to go to zero, move the inode to AGI unlinked list so that it can
 891 * be freed when the last active reference goes away via xfs_inactive().
 892 */
 893static int			/* error */
 894xfs_droplink(
 895	xfs_trans_t *tp,
 896	xfs_inode_t *ip)
 897{
 898	if (VFS_I(ip)->i_nlink == 0) {
 899		xfs_alert(ip->i_mount,
 900			  "%s: Attempt to drop inode (%llu) with nlink zero.",
 901			  __func__, ip->i_ino);
 902		return -EFSCORRUPTED;
 903	}
 904
 905	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 906
 907	drop_nlink(VFS_I(ip));
 908	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 909
 910	if (VFS_I(ip)->i_nlink)
 911		return 0;
 912
 913	return xfs_iunlink(tp, ip);
 914}
 915
 916/*
 917 * Increment the link count on an inode & log the change.
 918 */
 919static void
 920xfs_bumplink(
 921	xfs_trans_t *tp,
 922	xfs_inode_t *ip)
 923{
 924	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 925
 926	inc_nlink(VFS_I(ip));
 927	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 928}
 929
 930#ifdef CONFIG_XFS_LIVE_HOOKS
 931/*
 932 * Use a static key here to reduce the overhead of directory live update hooks.
 933 * If the compiler supports jump labels, the static branch will be replaced by
 934 * a nop sled when there are no hook users.  Online fsck is currently the only
 935 * caller, so this is a reasonable tradeoff.
 936 *
 937 * Note: Patching the kernel code requires taking the cpu hotplug lock.  Other
 938 * parts of the kernel allocate memory with that lock held, which means that
 939 * XFS callers cannot hold any locks that might be used by memory reclaim or
 940 * writeback when calling the static_branch_{inc,dec} functions.
 941 */
 942DEFINE_STATIC_XFS_HOOK_SWITCH(xfs_dir_hooks_switch);
 943
 944void
 945xfs_dir_hook_disable(void)
 946{
 947	xfs_hooks_switch_off(&xfs_dir_hooks_switch);
 948}
 949
 950void
 951xfs_dir_hook_enable(void)
 952{
 953	xfs_hooks_switch_on(&xfs_dir_hooks_switch);
 954}
 955
 956/* Call hooks for a directory update relating to a child dirent update. */
 957inline void
 958xfs_dir_update_hook(
 959	struct xfs_inode		*dp,
 960	struct xfs_inode		*ip,
 961	int				delta,
 962	const struct xfs_name		*name)
 963{
 964	if (xfs_hooks_switched_on(&xfs_dir_hooks_switch)) {
 965		struct xfs_dir_update_params	p = {
 966			.dp		= dp,
 967			.ip		= ip,
 968			.delta		= delta,
 969			.name		= name,
 970		};
 971		struct xfs_mount	*mp = ip->i_mount;
 972
 973		xfs_hooks_call(&mp->m_dir_update_hooks, 0, &p);
 974	}
 975}
 976
 977/* Call the specified function during a directory update. */
 978int
 979xfs_dir_hook_add(
 980	struct xfs_mount	*mp,
 981	struct xfs_dir_hook	*hook)
 982{
 983	return xfs_hooks_add(&mp->m_dir_update_hooks, &hook->dirent_hook);
 984}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 985
 986/* Stop calling the specified function during a directory update. */
 987void
 988xfs_dir_hook_del(
 989	struct xfs_mount	*mp,
 990	struct xfs_dir_hook	*hook)
 991{
 992	xfs_hooks_del(&mp->m_dir_update_hooks, &hook->dirent_hook);
 993}
 994
 995/* Configure directory update hook functions. */
 996void
 997xfs_dir_hook_setup(
 998	struct xfs_dir_hook	*hook,
 999	notifier_fn_t		mod_fn)
1000{
1001	xfs_hook_setup(&hook->dirent_hook, mod_fn);
1002}
1003#endif /* CONFIG_XFS_LIVE_HOOKS */
1004
1005int
1006xfs_create(
1007	struct mnt_idmap	*idmap,
1008	xfs_inode_t		*dp,
1009	struct xfs_name		*name,
1010	umode_t			mode,
1011	dev_t			rdev,
1012	bool			init_xattrs,
1013	xfs_inode_t		**ipp)
1014{
1015	int			is_dir = S_ISDIR(mode);
 
 
 
 
1016	struct xfs_mount	*mp = dp->i_mount;
1017	struct xfs_inode	*ip = NULL;
1018	struct xfs_trans	*tp = NULL;
1019	int			error;
1020	bool                    unlock_dp_on_error = false;
1021	prid_t			prid;
1022	struct xfs_dquot	*udqp = NULL;
1023	struct xfs_dquot	*gdqp = NULL;
1024	struct xfs_dquot	*pdqp = NULL;
1025	struct xfs_trans_res	*tres;
1026	uint			resblks;
1027	xfs_ino_t		ino;
 
 
 
 
1028
1029	trace_xfs_create(dp, name);
1030
1031	if (xfs_is_shutdown(mp))
1032		return -EIO;
1033	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
1034		return -EIO;
1035
1036	prid = xfs_get_initial_prid(dp);
1037
1038	/*
1039	 * Make sure that we have allocated dquot(s) on disk.
1040	 */
1041	error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(idmap, &init_user_ns),
1042			mapped_fsgid(idmap, &init_user_ns), prid,
1043			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1044			&udqp, &gdqp, &pdqp);
1045	if (error)
1046		return error;
1047
1048	if (is_dir) {
1049		resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
1050		tres = &M_RES(mp)->tr_mkdir;
1051	} else {
1052		resblks = XFS_CREATE_SPACE_RES(mp, name->len);
1053		tres = &M_RES(mp)->tr_create;
1054	}
1055
 
 
 
 
1056	/*
1057	 * Initially assume that the file does not exist and
1058	 * reserve the resources for that case.  If that is not
1059	 * the case we'll drop the one we have and get a more
1060	 * appropriate transaction later.
1061	 */
1062	error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
1063			&tp);
1064	if (error == -ENOSPC) {
1065		/* flush outstanding delalloc blocks and retry */
1066		xfs_flush_inodes(mp);
1067		error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp,
1068				resblks, &tp);
1069	}
1070	if (error)
1071		goto out_release_dquots;
1072
1073	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1074	unlock_dp_on_error = true;
1075
1076	/*
1077	 * A newly created regular or special file just has one directory
1078	 * entry pointing to them, but a directory also the "." entry
1079	 * pointing to itself.
1080	 */
1081	error = xfs_dialloc(&tp, dp->i_ino, mode, &ino);
1082	if (!error)
1083		error = xfs_init_new_inode(idmap, tp, dp, ino, mode,
1084				is_dir ? 2 : 1, rdev, prid, init_xattrs, &ip);
1085	if (error)
1086		goto out_trans_cancel;
1087
1088	/*
1089	 * Now we join the directory inode to the transaction.  We do not do it
1090	 * earlier because xfs_dialloc might commit the previous transaction
1091	 * (and release all the locks).  An error from here on will result in
1092	 * the transaction cancel unlocking dp so don't do it explicitly in the
1093	 * error path.
1094	 */
1095	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1096	unlock_dp_on_error = false;
1097
1098	error = xfs_dir_createname(tp, dp, name, ip->i_ino,
1099					resblks - XFS_IALLOC_SPACE_RES(mp));
1100	if (error) {
1101		ASSERT(error != -ENOSPC);
1102		goto out_trans_cancel;
1103	}
1104	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1105	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1106
1107	if (is_dir) {
1108		error = xfs_dir_init(tp, ip, dp);
1109		if (error)
1110			goto out_trans_cancel;
1111
1112		xfs_bumplink(tp, dp);
1113	}
1114
1115	/*
1116	 * Create ip with a reference from dp, and add '.' and '..' references
1117	 * if it's a directory.
1118	 */
1119	xfs_dir_update_hook(dp, ip, 1, name);
1120
1121	/*
1122	 * If this is a synchronous mount, make sure that the
1123	 * create transaction goes to disk before returning to
1124	 * the user.
1125	 */
1126	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
1127		xfs_trans_set_sync(tp);
1128
1129	/*
1130	 * Attach the dquot(s) to the inodes and modify them incore.
1131	 * These ids of the inode couldn't have changed since the new
1132	 * inode has been locked ever since it was created.
1133	 */
1134	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1135
1136	error = xfs_trans_commit(tp);
1137	if (error)
1138		goto out_release_inode;
1139
1140	xfs_qm_dqrele(udqp);
1141	xfs_qm_dqrele(gdqp);
1142	xfs_qm_dqrele(pdqp);
1143
1144	*ipp = ip;
 
 
 
1145	return 0;
1146
1147 out_trans_cancel:
1148	xfs_trans_cancel(tp);
1149 out_release_inode:
1150	/*
1151	 * Wait until after the current transaction is aborted to finish the
1152	 * setup of the inode and release the inode.  This prevents recursive
1153	 * transactions and deadlocks from xfs_inactive.
1154	 */
1155	if (ip) {
1156		xfs_finish_inode_setup(ip);
1157		xfs_irele(ip);
 
1158	}
 
 
1159 out_release_dquots:
1160	xfs_qm_dqrele(udqp);
1161	xfs_qm_dqrele(gdqp);
1162	xfs_qm_dqrele(pdqp);
1163
1164	if (unlock_dp_on_error)
1165		xfs_iunlock(dp, XFS_ILOCK_EXCL);
1166	return error;
1167}
1168
1169int
1170xfs_create_tmpfile(
1171	struct mnt_idmap	*idmap,
1172	struct xfs_inode	*dp,
1173	umode_t			mode,
1174	struct xfs_inode	**ipp)
1175{
 
1176	struct xfs_mount	*mp = dp->i_mount;
1177	struct xfs_inode	*ip = NULL;
1178	struct xfs_trans	*tp = NULL;
1179	int			error;
1180	prid_t                  prid;
1181	struct xfs_dquot	*udqp = NULL;
1182	struct xfs_dquot	*gdqp = NULL;
1183	struct xfs_dquot	*pdqp = NULL;
1184	struct xfs_trans_res	*tres;
1185	uint			resblks;
1186	xfs_ino_t		ino;
 
 
 
 
1187
1188	if (xfs_is_shutdown(mp))
1189		return -EIO;
1190
1191	prid = xfs_get_initial_prid(dp);
1192
1193	/*
1194	 * Make sure that we have allocated dquot(s) on disk.
1195	 */
1196	error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(idmap, &init_user_ns),
1197			mapped_fsgid(idmap, &init_user_ns), prid,
1198			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1199			&udqp, &gdqp, &pdqp);
1200	if (error)
1201		return error;
1202
1203	resblks = XFS_IALLOC_SPACE_RES(mp);
1204	tres = &M_RES(mp)->tr_create_tmpfile;
1205
1206	error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
1207			&tp);
1208	if (error)
1209		goto out_release_dquots;
1210
1211	error = xfs_dialloc(&tp, dp->i_ino, mode, &ino);
1212	if (!error)
1213		error = xfs_init_new_inode(idmap, tp, dp, ino, mode,
1214				0, 0, prid, false, &ip);
1215	if (error)
1216		goto out_trans_cancel;
1217
1218	if (xfs_has_wsync(mp))
1219		xfs_trans_set_sync(tp);
1220
1221	/*
1222	 * Attach the dquot(s) to the inodes and modify them incore.
1223	 * These ids of the inode couldn't have changed since the new
1224	 * inode has been locked ever since it was created.
1225	 */
1226	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1227
1228	error = xfs_iunlink(tp, ip);
1229	if (error)
1230		goto out_trans_cancel;
1231
1232	error = xfs_trans_commit(tp);
1233	if (error)
1234		goto out_release_inode;
1235
1236	xfs_qm_dqrele(udqp);
1237	xfs_qm_dqrele(gdqp);
1238	xfs_qm_dqrele(pdqp);
1239
1240	*ipp = ip;
 
1241	return 0;
1242
1243 out_trans_cancel:
1244	xfs_trans_cancel(tp);
1245 out_release_inode:
1246	/*
1247	 * Wait until after the current transaction is aborted to finish the
1248	 * setup of the inode and release the inode.  This prevents recursive
1249	 * transactions and deadlocks from xfs_inactive.
1250	 */
1251	if (ip) {
 
1252		xfs_finish_inode_setup(ip);
1253		xfs_irele(ip);
1254	}
1255 out_release_dquots:
1256	xfs_qm_dqrele(udqp);
1257	xfs_qm_dqrele(gdqp);
1258	xfs_qm_dqrele(pdqp);
1259
1260	return error;
1261}
1262
1263int
1264xfs_link(
1265	xfs_inode_t		*tdp,
1266	xfs_inode_t		*sip,
1267	struct xfs_name		*target_name)
1268{
1269	xfs_mount_t		*mp = tdp->i_mount;
1270	xfs_trans_t		*tp;
 
 
 
 
 
1271	int			error, nospace_error = 0;
1272	int			resblks;
1273
1274	trace_xfs_link(tdp, target_name);
1275
1276	ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
1277
1278	if (xfs_is_shutdown(mp))
1279		return -EIO;
1280	if (xfs_ifork_zapped(tdp, XFS_DATA_FORK))
1281		return -EIO;
1282
1283	error = xfs_qm_dqattach(sip);
1284	if (error)
1285		goto std_return;
1286
1287	error = xfs_qm_dqattach(tdp);
1288	if (error)
1289		goto std_return;
1290
1291	resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
 
 
 
 
1292	error = xfs_trans_alloc_dir(tdp, &M_RES(mp)->tr_link, sip, &resblks,
1293			&tp, &nospace_error);
1294	if (error)
1295		goto std_return;
 
 
 
 
 
 
 
 
 
 
1296
1297	/*
1298	 * If we are using project inheritance, we only allow hard link
1299	 * creation in our tree when the project IDs are the same; else
1300	 * the tree quota mechanism could be circumvented.
1301	 */
1302	if (unlikely((tdp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
1303		     tdp->i_projid != sip->i_projid)) {
1304		/*
1305		 * Project quota setup skips special files which can
1306		 * leave inodes in a PROJINHERIT directory without a
1307		 * project ID set. We need to allow links to be made
1308		 * to these "project-less" inodes because userspace
1309		 * expects them to succeed after project ID setup,
1310		 * but everything else should be rejected.
1311		 */
1312		if (!special_file(VFS_I(sip)->i_mode) ||
1313		    sip->i_projid != 0) {
1314			error = -EXDEV;
1315			goto error_return;
1316		}
1317	}
1318
1319	if (!resblks) {
1320		error = xfs_dir_canenter(tp, tdp, target_name);
1321		if (error)
1322			goto error_return;
1323	}
1324
1325	/*
1326	 * Handle initial link state of O_TMPFILE inode
1327	 */
1328	if (VFS_I(sip)->i_nlink == 0) {
1329		struct xfs_perag	*pag;
1330
1331		pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, sip->i_ino));
1332		error = xfs_iunlink_remove(tp, pag, sip);
1333		xfs_perag_put(pag);
1334		if (error)
1335			goto error_return;
1336	}
1337
1338	error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1339				   resblks);
1340	if (error)
1341		goto error_return;
1342	xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1343	xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1344
1345	xfs_bumplink(tp, sip);
1346	xfs_dir_update_hook(tdp, sip, 1, target_name);
1347
1348	/*
1349	 * If this is a synchronous mount, make sure that the
1350	 * link transaction goes to disk before returning to
1351	 * the user.
1352	 */
1353	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
1354		xfs_trans_set_sync(tp);
1355
1356	return xfs_trans_commit(tp);
 
 
 
 
1357
1358 error_return:
1359	xfs_trans_cancel(tp);
 
 
 
 
1360 std_return:
1361	if (error == -ENOSPC && nospace_error)
1362		error = nospace_error;
1363	return error;
1364}
1365
1366/* Clear the reflink flag and the cowblocks tag if possible. */
1367static void
1368xfs_itruncate_clear_reflink_flags(
1369	struct xfs_inode	*ip)
1370{
1371	struct xfs_ifork	*dfork;
1372	struct xfs_ifork	*cfork;
1373
1374	if (!xfs_is_reflink_inode(ip))
1375		return;
1376	dfork = xfs_ifork_ptr(ip, XFS_DATA_FORK);
1377	cfork = xfs_ifork_ptr(ip, XFS_COW_FORK);
1378	if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
1379		ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1380	if (cfork->if_bytes == 0)
1381		xfs_inode_clear_cowblocks_tag(ip);
1382}
1383
1384/*
1385 * Free up the underlying blocks past new_size.  The new size must be smaller
1386 * than the current size.  This routine can be used both for the attribute and
1387 * data fork, and does not modify the inode size, which is left to the caller.
1388 *
1389 * The transaction passed to this routine must have made a permanent log
1390 * reservation of at least XFS_ITRUNCATE_LOG_RES.  This routine may commit the
1391 * given transaction and start new ones, so make sure everything involved in
1392 * the transaction is tidy before calling here.  Some transaction will be
1393 * returned to the caller to be committed.  The incoming transaction must
1394 * already include the inode, and both inode locks must be held exclusively.
1395 * The inode must also be "held" within the transaction.  On return the inode
1396 * will be "held" within the returned transaction.  This routine does NOT
1397 * require any disk space to be reserved for it within the transaction.
1398 *
1399 * If we get an error, we must return with the inode locked and linked into the
1400 * current transaction. This keeps things simple for the higher level code,
1401 * because it always knows that the inode is locked and held in the transaction
1402 * that returns to it whether errors occur or not.  We don't mark the inode
1403 * dirty on error so that transactions can be easily aborted if possible.
1404 */
1405int
1406xfs_itruncate_extents_flags(
1407	struct xfs_trans	**tpp,
1408	struct xfs_inode	*ip,
1409	int			whichfork,
1410	xfs_fsize_t		new_size,
1411	int			flags)
1412{
1413	struct xfs_mount	*mp = ip->i_mount;
1414	struct xfs_trans	*tp = *tpp;
1415	xfs_fileoff_t		first_unmap_block;
1416	int			error = 0;
1417
1418	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1419	if (atomic_read(&VFS_I(ip)->i_count))
1420		xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
1421	ASSERT(new_size <= XFS_ISIZE(ip));
1422	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1423	ASSERT(ip->i_itemp != NULL);
1424	ASSERT(ip->i_itemp->ili_lock_flags == 0);
1425	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1426
1427	trace_xfs_itruncate_extents_start(ip, new_size);
1428
1429	flags |= xfs_bmapi_aflag(whichfork);
1430
1431	/*
1432	 * Since it is possible for space to become allocated beyond
1433	 * the end of the file (in a crash where the space is allocated
1434	 * but the inode size is not yet updated), simply remove any
1435	 * blocks which show up between the new EOF and the maximum
1436	 * possible file size.
1437	 *
1438	 * We have to free all the blocks to the bmbt maximum offset, even if
1439	 * the page cache can't scale that far.
1440	 */
1441	first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1442	if (!xfs_verify_fileoff(mp, first_unmap_block)) {
1443		WARN_ON_ONCE(first_unmap_block > XFS_MAX_FILEOFF);
1444		return 0;
1445	}
1446
1447	error = xfs_bunmapi_range(&tp, ip, flags, first_unmap_block,
1448			XFS_MAX_FILEOFF);
1449	if (error)
1450		goto out;
1451
1452	if (whichfork == XFS_DATA_FORK) {
1453		/* Remove all pending CoW reservations. */
1454		error = xfs_reflink_cancel_cow_blocks(ip, &tp,
1455				first_unmap_block, XFS_MAX_FILEOFF, true);
1456		if (error)
1457			goto out;
1458
1459		xfs_itruncate_clear_reflink_flags(ip);
1460	}
1461
1462	/*
1463	 * Always re-log the inode so that our permanent transaction can keep
1464	 * on rolling it forward in the log.
1465	 */
1466	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1467
1468	trace_xfs_itruncate_extents_end(ip, new_size);
1469
1470out:
1471	*tpp = tp;
1472	return error;
1473}
1474
1475int
1476xfs_release(
1477	xfs_inode_t	*ip)
 
 
 
 
 
 
1478{
1479	xfs_mount_t	*mp = ip->i_mount;
1480	int		error = 0;
1481
1482	if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
1483		return 0;
1484
1485	/* If this is a read-only mount, don't do this (would generate I/O) */
1486	if (xfs_is_readonly(mp))
1487		return 0;
1488
1489	if (!xfs_is_shutdown(mp)) {
1490		int truncated;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1491
1492		/*
1493		 * If we previously truncated this file and removed old data
1494		 * in the process, we want to initiate "early" writeout on
1495		 * the last close.  This is an attempt to combat the notorious
1496		 * NULL files problem which is particularly noticeable from a
1497		 * truncate down, buffered (re-)write (delalloc), followed by
1498		 * a crash.  What we are effectively doing here is
1499		 * significantly reducing the time window where we'd otherwise
1500		 * be exposed to that problem.
1501		 */
1502		truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
1503		if (truncated) {
1504			xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
1505			if (ip->i_delayed_blks > 0) {
1506				error = filemap_flush(VFS_I(ip)->i_mapping);
1507				if (error)
1508					return error;
1509			}
1510		}
1511	}
1512
1513	if (VFS_I(ip)->i_nlink == 0)
1514		return 0;
1515
1516	/*
1517	 * If we can't get the iolock just skip truncating the blocks past EOF
1518	 * because we could deadlock with the mmap_lock otherwise. We'll get
1519	 * another chance to drop them once the last reference to the inode is
1520	 * dropped, so we'll never leak blocks permanently.
1521	 */
1522	if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL))
1523		return 0;
1524
1525	if (xfs_can_free_eofblocks(ip, false)) {
1526		/*
1527		 * Check if the inode is being opened, written and closed
1528		 * frequently and we have delayed allocation blocks outstanding
1529		 * (e.g. streaming writes from the NFS server), truncating the
1530		 * blocks past EOF will cause fragmentation to occur.
1531		 *
1532		 * In this case don't do the truncation, but we have to be
1533		 * careful how we detect this case. Blocks beyond EOF show up as
1534		 * i_delayed_blks even when the inode is clean, so we need to
1535		 * truncate them away first before checking for a dirty release.
1536		 * Hence on the first dirty close we will still remove the
1537		 * speculative allocation, but after that we will leave it in
1538		 * place.
1539		 */
1540		if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
1541			goto out_unlock;
1542
1543		error = xfs_free_eofblocks(ip);
1544		if (error)
1545			goto out_unlock;
1546
1547		/* delalloc blocks after truncation means it really is dirty */
1548		if (ip->i_delayed_blks)
1549			xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
1550	}
1551
1552out_unlock:
1553	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1554	return error;
1555}
1556
1557/*
1558 * xfs_inactive_truncate
1559 *
1560 * Called to perform a truncate when an inode becomes unlinked.
1561 */
1562STATIC int
1563xfs_inactive_truncate(
1564	struct xfs_inode *ip)
1565{
1566	struct xfs_mount	*mp = ip->i_mount;
1567	struct xfs_trans	*tp;
1568	int			error;
1569
1570	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
1571	if (error) {
1572		ASSERT(xfs_is_shutdown(mp));
1573		return error;
1574	}
1575	xfs_ilock(ip, XFS_ILOCK_EXCL);
1576	xfs_trans_ijoin(tp, ip, 0);
1577
1578	/*
1579	 * Log the inode size first to prevent stale data exposure in the event
1580	 * of a system crash before the truncate completes. See the related
1581	 * comment in xfs_vn_setattr_size() for details.
1582	 */
1583	ip->i_disk_size = 0;
1584	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1585
1586	error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1587	if (error)
1588		goto error_trans_cancel;
1589
1590	ASSERT(ip->i_df.if_nextents == 0);
1591
1592	error = xfs_trans_commit(tp);
1593	if (error)
1594		goto error_unlock;
1595
1596	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1597	return 0;
1598
1599error_trans_cancel:
1600	xfs_trans_cancel(tp);
1601error_unlock:
1602	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1603	return error;
1604}
1605
1606/*
1607 * xfs_inactive_ifree()
1608 *
1609 * Perform the inode free when an inode is unlinked.
1610 */
1611STATIC int
1612xfs_inactive_ifree(
1613	struct xfs_inode *ip)
1614{
1615	struct xfs_mount	*mp = ip->i_mount;
1616	struct xfs_trans	*tp;
1617	int			error;
1618
1619	/*
1620	 * We try to use a per-AG reservation for any block needed by the finobt
1621	 * tree, but as the finobt feature predates the per-AG reservation
1622	 * support a degraded file system might not have enough space for the
1623	 * reservation at mount time.  In that case try to dip into the reserved
1624	 * pool and pray.
1625	 *
1626	 * Send a warning if the reservation does happen to fail, as the inode
1627	 * now remains allocated and sits on the unlinked list until the fs is
1628	 * repaired.
1629	 */
1630	if (unlikely(mp->m_finobt_nores)) {
1631		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1632				XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
1633				&tp);
1634	} else {
1635		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
1636	}
1637	if (error) {
1638		if (error == -ENOSPC) {
1639			xfs_warn_ratelimited(mp,
1640			"Failed to remove inode(s) from unlinked list. "
1641			"Please free space, unmount and run xfs_repair.");
1642		} else {
1643			ASSERT(xfs_is_shutdown(mp));
1644		}
1645		return error;
1646	}
1647
1648	/*
1649	 * We do not hold the inode locked across the entire rolling transaction
1650	 * here. We only need to hold it for the first transaction that
1651	 * xfs_ifree() builds, which may mark the inode XFS_ISTALE if the
1652	 * underlying cluster buffer is freed. Relogging an XFS_ISTALE inode
1653	 * here breaks the relationship between cluster buffer invalidation and
1654	 * stale inode invalidation on cluster buffer item journal commit
1655	 * completion, and can result in leaving dirty stale inodes hanging
1656	 * around in memory.
1657	 *
1658	 * We have no need for serialising this inode operation against other
1659	 * operations - we freed the inode and hence reallocation is required
1660	 * and that will serialise on reallocating the space the deferops need
1661	 * to free. Hence we can unlock the inode on the first commit of
1662	 * the transaction rather than roll it right through the deferops. This
1663	 * avoids relogging the XFS_ISTALE inode.
1664	 *
1665	 * We check that xfs_ifree() hasn't grown an internal transaction roll
1666	 * by asserting that the inode is still locked when it returns.
1667	 */
1668	xfs_ilock(ip, XFS_ILOCK_EXCL);
1669	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1670
1671	error = xfs_ifree(tp, ip);
1672	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1673	if (error) {
1674		/*
1675		 * If we fail to free the inode, shut down.  The cancel
1676		 * might do that, we need to make sure.  Otherwise the
1677		 * inode might be lost for a long time or forever.
1678		 */
1679		if (!xfs_is_shutdown(mp)) {
1680			xfs_notice(mp, "%s: xfs_ifree returned error %d",
1681				__func__, error);
1682			xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1683		}
1684		xfs_trans_cancel(tp);
1685		return error;
1686	}
1687
1688	/*
1689	 * Credit the quota account(s). The inode is gone.
1690	 */
1691	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1692
1693	return xfs_trans_commit(tp);
1694}
1695
1696/*
1697 * Returns true if we need to update the on-disk metadata before we can free
1698 * the memory used by this inode.  Updates include freeing post-eof
1699 * preallocations; freeing COW staging extents; and marking the inode free in
1700 * the inobt if it is on the unlinked list.
1701 */
1702bool
1703xfs_inode_needs_inactive(
1704	struct xfs_inode	*ip)
1705{
1706	struct xfs_mount	*mp = ip->i_mount;
1707	struct xfs_ifork	*cow_ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
1708
1709	/*
1710	 * If the inode is already free, then there can be nothing
1711	 * to clean up here.
1712	 */
1713	if (VFS_I(ip)->i_mode == 0)
1714		return false;
1715
1716	/*
1717	 * If this is a read-only mount, don't do this (would generate I/O)
1718	 * unless we're in log recovery and cleaning the iunlinked list.
1719	 */
1720	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1721		return false;
1722
1723	/* If the log isn't running, push inodes straight to reclaim. */
1724	if (xfs_is_shutdown(mp) || xfs_has_norecovery(mp))
1725		return false;
1726
1727	/* Metadata inodes require explicit resource cleanup. */
1728	if (xfs_is_metadata_inode(ip))
1729		return false;
1730
1731	/* Want to clean out the cow blocks if there are any. */
1732	if (cow_ifp && cow_ifp->if_bytes > 0)
1733		return true;
1734
1735	/* Unlinked files must be freed. */
1736	if (VFS_I(ip)->i_nlink == 0)
1737		return true;
1738
1739	/*
1740	 * This file isn't being freed, so check if there are post-eof blocks
1741	 * to free.  @force is true because we are evicting an inode from the
1742	 * cache.  Post-eof blocks must be freed, lest we end up with broken
1743	 * free space accounting.
1744	 *
1745	 * Note: don't bother with iolock here since lockdep complains about
1746	 * acquiring it in reclaim context. We have the only reference to the
1747	 * inode at this point anyways.
1748	 */
1749	return xfs_can_free_eofblocks(ip, true);
1750}
1751
1752/*
1753 * Save health status somewhere, if we're dumping an inode with uncorrected
1754 * errors and online repair isn't running.
1755 */
1756static inline void
1757xfs_inactive_health(
1758	struct xfs_inode	*ip)
1759{
1760	struct xfs_mount	*mp = ip->i_mount;
1761	struct xfs_perag	*pag;
1762	unsigned int		sick;
1763	unsigned int		checked;
1764
1765	xfs_inode_measure_sickness(ip, &sick, &checked);
1766	if (!sick)
1767		return;
1768
1769	trace_xfs_inode_unfixed_corruption(ip, sick);
1770
1771	if (sick & XFS_SICK_INO_FORGET)
1772		return;
1773
1774	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1775	if (!pag) {
1776		/* There had better still be a perag structure! */
1777		ASSERT(0);
1778		return;
1779	}
1780
1781	xfs_ag_mark_sick(pag, XFS_SICK_AG_INODES);
1782	xfs_perag_put(pag);
1783}
1784
1785/*
1786 * xfs_inactive
1787 *
1788 * This is called when the vnode reference count for the vnode
1789 * goes to zero.  If the file has been unlinked, then it must
1790 * now be truncated.  Also, we clear all of the read-ahead state
1791 * kept for the inode here since the file is now closed.
1792 */
1793int
1794xfs_inactive(
1795	xfs_inode_t	*ip)
1796{
1797	struct xfs_mount	*mp;
1798	int			error = 0;
1799	int			truncate = 0;
1800
1801	/*
1802	 * If the inode is already free, then there can be nothing
1803	 * to clean up here.
1804	 */
1805	if (VFS_I(ip)->i_mode == 0) {
1806		ASSERT(ip->i_df.if_broot_bytes == 0);
1807		goto out;
1808	}
1809
1810	mp = ip->i_mount;
1811	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1812
1813	xfs_inactive_health(ip);
1814
1815	/*
1816	 * If this is a read-only mount, don't do this (would generate I/O)
1817	 * unless we're in log recovery and cleaning the iunlinked list.
1818	 */
1819	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1820		goto out;
1821
1822	/* Metadata inodes require explicit resource cleanup. */
1823	if (xfs_is_metadata_inode(ip))
1824		goto out;
1825
1826	/* Try to clean out the cow blocks if there are any. */
1827	if (xfs_inode_has_cow_data(ip))
1828		xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
 
 
 
1829
1830	if (VFS_I(ip)->i_nlink != 0) {
1831		/*
1832		 * force is true because we are evicting an inode from the
1833		 * cache. Post-eof blocks must be freed, lest we end up with
1834		 * broken free space accounting.
1835		 *
1836		 * Note: don't bother with iolock here since lockdep complains
1837		 * about acquiring it in reclaim context. We have the only
1838		 * reference to the inode at this point anyways.
1839		 */
1840		if (xfs_can_free_eofblocks(ip, true))
1841			error = xfs_free_eofblocks(ip);
1842
1843		goto out;
1844	}
1845
1846	if (S_ISREG(VFS_I(ip)->i_mode) &&
1847	    (ip->i_disk_size != 0 || XFS_ISIZE(ip) != 0 ||
1848	     ip->i_df.if_nextents > 0 || ip->i_delayed_blks > 0))
1849		truncate = 1;
1850
1851	if (xfs_iflags_test(ip, XFS_IQUOTAUNCHECKED)) {
1852		/*
1853		 * If this inode is being inactivated during a quotacheck and
1854		 * has not yet been scanned by quotacheck, we /must/ remove
1855		 * the dquots from the inode before inactivation changes the
1856		 * block and inode counts.  Most probably this is a result of
1857		 * reloading the incore iunlinked list to purge unrecovered
1858		 * unlinked inodes.
1859		 */
1860		xfs_qm_dqdetach(ip);
1861	} else {
1862		error = xfs_qm_dqattach(ip);
1863		if (error)
1864			goto out;
1865	}
1866
 
 
 
 
 
1867	if (S_ISLNK(VFS_I(ip)->i_mode))
1868		error = xfs_inactive_symlink(ip);
1869	else if (truncate)
1870		error = xfs_inactive_truncate(ip);
1871	if (error)
1872		goto out;
1873
1874	/*
1875	 * If there are attributes associated with the file then blow them away
1876	 * now.  The code calls a routine that recursively deconstructs the
1877	 * attribute fork. If also blows away the in-core attribute fork.
1878	 */
1879	if (xfs_inode_has_attr_fork(ip)) {
1880		error = xfs_attr_inactive(ip);
1881		if (error)
1882			goto out;
1883	}
1884
1885	ASSERT(ip->i_forkoff == 0);
1886
1887	/*
1888	 * Free the inode.
1889	 */
1890	error = xfs_inactive_ifree(ip);
1891
1892out:
1893	/*
1894	 * We're done making metadata updates for this inode, so we can release
1895	 * the attached dquots.
1896	 */
1897	xfs_qm_dqdetach(ip);
1898	return error;
1899}
1900
1901/*
1902 * In-Core Unlinked List Lookups
1903 * =============================
1904 *
1905 * Every inode is supposed to be reachable from some other piece of metadata
1906 * with the exception of the root directory.  Inodes with a connection to a
1907 * file descriptor but not linked from anywhere in the on-disk directory tree
1908 * are collectively known as unlinked inodes, though the filesystem itself
1909 * maintains links to these inodes so that on-disk metadata are consistent.
1910 *
1911 * XFS implements a per-AG on-disk hash table of unlinked inodes.  The AGI
1912 * header contains a number of buckets that point to an inode, and each inode
1913 * record has a pointer to the next inode in the hash chain.  This
1914 * singly-linked list causes scaling problems in the iunlink remove function
1915 * because we must walk that list to find the inode that points to the inode
1916 * being removed from the unlinked hash bucket list.
1917 *
1918 * Hence we keep an in-memory double linked list to link each inode on an
1919 * unlinked list. Because there are 64 unlinked lists per AGI, keeping pointer
1920 * based lists would require having 64 list heads in the perag, one for each
1921 * list. This is expensive in terms of memory (think millions of AGs) and cache
1922 * misses on lookups. Instead, use the fact that inodes on the unlinked list
1923 * must be referenced at the VFS level to keep them on the list and hence we
1924 * have an existence guarantee for inodes on the unlinked list.
1925 *
1926 * Given we have an existence guarantee, we can use lockless inode cache lookups
1927 * to resolve aginos to xfs inodes. This means we only need 8 bytes per inode
1928 * for the double linked unlinked list, and we don't need any extra locking to
1929 * keep the list safe as all manipulations are done under the AGI buffer lock.
1930 * Keeping the list up to date does not require memory allocation, just finding
1931 * the XFS inode and updating the next/prev unlinked list aginos.
1932 */
1933
1934/*
1935 * Find an inode on the unlinked list. This does not take references to the
1936 * inode as we have existence guarantees by holding the AGI buffer lock and that
1937 * only unlinked, referenced inodes can be on the unlinked inode list.  If we
1938 * don't find the inode in cache, then let the caller handle the situation.
1939 */
1940static struct xfs_inode *
1941xfs_iunlink_lookup(
1942	struct xfs_perag	*pag,
1943	xfs_agino_t		agino)
1944{
1945	struct xfs_inode	*ip;
1946
1947	rcu_read_lock();
1948	ip = radix_tree_lookup(&pag->pag_ici_root, agino);
1949	if (!ip) {
1950		/* Caller can handle inode not being in memory. */
1951		rcu_read_unlock();
1952		return NULL;
1953	}
1954
1955	/*
1956	 * Inode in RCU freeing limbo should not happen.  Warn about this and
1957	 * let the caller handle the failure.
1958	 */
1959	if (WARN_ON_ONCE(!ip->i_ino)) {
1960		rcu_read_unlock();
1961		return NULL;
1962	}
1963	ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE | XFS_IRECLAIM));
1964	rcu_read_unlock();
1965	return ip;
1966}
1967
1968/*
1969 * Update the prev pointer of the next agino.  Returns -ENOLINK if the inode
1970 * is not in cache.
1971 */
1972static int
1973xfs_iunlink_update_backref(
1974	struct xfs_perag	*pag,
1975	xfs_agino_t		prev_agino,
1976	xfs_agino_t		next_agino)
1977{
1978	struct xfs_inode	*ip;
1979
1980	/* No update necessary if we are at the end of the list. */
1981	if (next_agino == NULLAGINO)
1982		return 0;
1983
1984	ip = xfs_iunlink_lookup(pag, next_agino);
1985	if (!ip)
1986		return -ENOLINK;
1987
1988	ip->i_prev_unlinked = prev_agino;
1989	return 0;
1990}
1991
1992/*
1993 * Point the AGI unlinked bucket at an inode and log the results.  The caller
1994 * is responsible for validating the old value.
1995 */
1996STATIC int
1997xfs_iunlink_update_bucket(
1998	struct xfs_trans	*tp,
1999	struct xfs_perag	*pag,
2000	struct xfs_buf		*agibp,
2001	unsigned int		bucket_index,
2002	xfs_agino_t		new_agino)
2003{
2004	struct xfs_agi		*agi = agibp->b_addr;
2005	xfs_agino_t		old_value;
2006	int			offset;
2007
2008	ASSERT(xfs_verify_agino_or_null(pag, new_agino));
2009
2010	old_value = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2011	trace_xfs_iunlink_update_bucket(tp->t_mountp, pag->pag_agno, bucket_index,
2012			old_value, new_agino);
2013
2014	/*
2015	 * We should never find the head of the list already set to the value
2016	 * passed in because either we're adding or removing ourselves from the
2017	 * head of the list.
2018	 */
2019	if (old_value == new_agino) {
2020		xfs_buf_mark_corrupt(agibp);
2021		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
2022		return -EFSCORRUPTED;
2023	}
2024
2025	agi->agi_unlinked[bucket_index] = cpu_to_be32(new_agino);
2026	offset = offsetof(struct xfs_agi, agi_unlinked) +
2027			(sizeof(xfs_agino_t) * bucket_index);
2028	xfs_trans_log_buf(tp, agibp, offset, offset + sizeof(xfs_agino_t) - 1);
2029	return 0;
2030}
2031
2032/*
2033 * Load the inode @next_agino into the cache and set its prev_unlinked pointer
2034 * to @prev_agino.  Caller must hold the AGI to synchronize with other changes
2035 * to the unlinked list.
2036 */
2037STATIC int
2038xfs_iunlink_reload_next(
2039	struct xfs_trans	*tp,
2040	struct xfs_buf		*agibp,
2041	xfs_agino_t		prev_agino,
2042	xfs_agino_t		next_agino)
2043{
2044	struct xfs_perag	*pag = agibp->b_pag;
2045	struct xfs_mount	*mp = pag->pag_mount;
2046	struct xfs_inode	*next_ip = NULL;
2047	xfs_ino_t		ino;
2048	int			error;
2049
2050	ASSERT(next_agino != NULLAGINO);
2051
2052#ifdef DEBUG
2053	rcu_read_lock();
2054	next_ip = radix_tree_lookup(&pag->pag_ici_root, next_agino);
2055	ASSERT(next_ip == NULL);
2056	rcu_read_unlock();
2057#endif
2058
2059	xfs_info_ratelimited(mp,
2060 "Found unrecovered unlinked inode 0x%x in AG 0x%x.  Initiating recovery.",
2061			next_agino, pag->pag_agno);
2062
2063	/*
2064	 * Use an untrusted lookup just to be cautious in case the AGI has been
2065	 * corrupted and now points at a free inode.  That shouldn't happen,
2066	 * but we'd rather shut down now since we're already running in a weird
2067	 * situation.
2068	 */
2069	ino = XFS_AGINO_TO_INO(mp, pag->pag_agno, next_agino);
2070	error = xfs_iget(mp, tp, ino, XFS_IGET_UNTRUSTED, 0, &next_ip);
2071	if (error) {
2072		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
2073		return error;
2074	}
2075
2076	/* If this is not an unlinked inode, something is very wrong. */
2077	if (VFS_I(next_ip)->i_nlink != 0) {
2078		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
2079		error = -EFSCORRUPTED;
2080		goto rele;
2081	}
2082
2083	next_ip->i_prev_unlinked = prev_agino;
2084	trace_xfs_iunlink_reload_next(next_ip);
2085rele:
2086	ASSERT(!(VFS_I(next_ip)->i_state & I_DONTCACHE));
2087	if (xfs_is_quotacheck_running(mp) && next_ip)
2088		xfs_iflags_set(next_ip, XFS_IQUOTAUNCHECKED);
2089	xfs_irele(next_ip);
2090	return error;
2091}
2092
2093static int
2094xfs_iunlink_insert_inode(
2095	struct xfs_trans	*tp,
2096	struct xfs_perag	*pag,
2097	struct xfs_buf		*agibp,
2098	struct xfs_inode	*ip)
2099{
2100	struct xfs_mount	*mp = tp->t_mountp;
2101	struct xfs_agi		*agi = agibp->b_addr;
2102	xfs_agino_t		next_agino;
2103	xfs_agino_t		agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2104	short			bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2105	int			error;
2106
2107	/*
2108	 * Get the index into the agi hash table for the list this inode will
2109	 * go on.  Make sure the pointer isn't garbage and that this inode
2110	 * isn't already on the list.
2111	 */
2112	next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2113	if (next_agino == agino ||
2114	    !xfs_verify_agino_or_null(pag, next_agino)) {
2115		xfs_buf_mark_corrupt(agibp);
2116		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
2117		return -EFSCORRUPTED;
2118	}
2119
2120	/*
2121	 * Update the prev pointer in the next inode to point back to this
2122	 * inode.
2123	 */
2124	error = xfs_iunlink_update_backref(pag, agino, next_agino);
2125	if (error == -ENOLINK)
2126		error = xfs_iunlink_reload_next(tp, agibp, agino, next_agino);
2127	if (error)
2128		return error;
2129
2130	if (next_agino != NULLAGINO) {
2131		/*
2132		 * There is already another inode in the bucket, so point this
2133		 * inode to the current head of the list.
2134		 */
2135		error = xfs_iunlink_log_inode(tp, ip, pag, next_agino);
2136		if (error)
2137			return error;
2138		ip->i_next_unlinked = next_agino;
2139	}
2140
2141	/* Point the head of the list to point to this inode. */
2142	ip->i_prev_unlinked = NULLAGINO;
2143	return xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index, agino);
2144}
2145
2146/*
2147 * This is called when the inode's link count has gone to 0 or we are creating
2148 * a tmpfile via O_TMPFILE.  The inode @ip must have nlink == 0.
2149 *
2150 * We place the on-disk inode on a list in the AGI.  It will be pulled from this
2151 * list when the inode is freed.
2152 */
2153STATIC int
2154xfs_iunlink(
2155	struct xfs_trans	*tp,
2156	struct xfs_inode	*ip)
2157{
2158	struct xfs_mount	*mp = tp->t_mountp;
2159	struct xfs_perag	*pag;
2160	struct xfs_buf		*agibp;
2161	int			error;
2162
2163	ASSERT(VFS_I(ip)->i_nlink == 0);
2164	ASSERT(VFS_I(ip)->i_mode != 0);
2165	trace_xfs_iunlink(ip);
2166
2167	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
2168
2169	/* Get the agi buffer first.  It ensures lock ordering on the list. */
2170	error = xfs_read_agi(pag, tp, &agibp);
2171	if (error)
2172		goto out;
2173
2174	error = xfs_iunlink_insert_inode(tp, pag, agibp, ip);
2175out:
2176	xfs_perag_put(pag);
2177	return error;
2178}
2179
2180static int
2181xfs_iunlink_remove_inode(
2182	struct xfs_trans	*tp,
2183	struct xfs_perag	*pag,
2184	struct xfs_buf		*agibp,
2185	struct xfs_inode	*ip)
2186{
2187	struct xfs_mount	*mp = tp->t_mountp;
2188	struct xfs_agi		*agi = agibp->b_addr;
2189	xfs_agino_t		agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2190	xfs_agino_t		head_agino;
2191	short			bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2192	int			error;
2193
2194	trace_xfs_iunlink_remove(ip);
2195
2196	/*
2197	 * Get the index into the agi hash table for the list this inode will
2198	 * go on.  Make sure the head pointer isn't garbage.
2199	 */
2200	head_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2201	if (!xfs_verify_agino(pag, head_agino)) {
2202		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
2203				agi, sizeof(*agi));
2204		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
2205		return -EFSCORRUPTED;
2206	}
2207
2208	/*
2209	 * Set our inode's next_unlinked pointer to NULL and then return
2210	 * the old pointer value so that we can update whatever was previous
2211	 * to us in the list to point to whatever was next in the list.
2212	 */
2213	error = xfs_iunlink_log_inode(tp, ip, pag, NULLAGINO);
2214	if (error)
2215		return error;
2216
2217	/*
2218	 * Update the prev pointer in the next inode to point back to previous
2219	 * inode in the chain.
2220	 */
2221	error = xfs_iunlink_update_backref(pag, ip->i_prev_unlinked,
2222			ip->i_next_unlinked);
2223	if (error == -ENOLINK)
2224		error = xfs_iunlink_reload_next(tp, agibp, ip->i_prev_unlinked,
2225				ip->i_next_unlinked);
2226	if (error)
2227		return error;
2228
2229	if (head_agino != agino) {
2230		struct xfs_inode	*prev_ip;
2231
2232		prev_ip = xfs_iunlink_lookup(pag, ip->i_prev_unlinked);
2233		if (!prev_ip) {
2234			xfs_inode_mark_sick(ip, XFS_SICK_INO_CORE);
2235			return -EFSCORRUPTED;
2236		}
2237
2238		error = xfs_iunlink_log_inode(tp, prev_ip, pag,
2239				ip->i_next_unlinked);
2240		prev_ip->i_next_unlinked = ip->i_next_unlinked;
2241	} else {
2242		/* Point the head of the list to the next unlinked inode. */
2243		error = xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index,
2244				ip->i_next_unlinked);
2245	}
2246
2247	ip->i_next_unlinked = NULLAGINO;
2248	ip->i_prev_unlinked = 0;
2249	return error;
2250}
2251
2252/*
2253 * Pull the on-disk inode from the AGI unlinked list.
2254 */
2255STATIC int
2256xfs_iunlink_remove(
2257	struct xfs_trans	*tp,
2258	struct xfs_perag	*pag,
2259	struct xfs_inode	*ip)
2260{
2261	struct xfs_buf		*agibp;
2262	int			error;
2263
2264	trace_xfs_iunlink_remove(ip);
2265
2266	/* Get the agi buffer first.  It ensures lock ordering on the list. */
2267	error = xfs_read_agi(pag, tp, &agibp);
2268	if (error)
2269		return error;
2270
2271	return xfs_iunlink_remove_inode(tp, pag, agibp, ip);
2272}
2273
2274/*
2275 * Look up the inode number specified and if it is not already marked XFS_ISTALE
2276 * mark it stale. We should only find clean inodes in this lookup that aren't
2277 * already stale.
2278 */
2279static void
2280xfs_ifree_mark_inode_stale(
2281	struct xfs_perag	*pag,
2282	struct xfs_inode	*free_ip,
2283	xfs_ino_t		inum)
2284{
2285	struct xfs_mount	*mp = pag->pag_mount;
2286	struct xfs_inode_log_item *iip;
2287	struct xfs_inode	*ip;
2288
2289retry:
2290	rcu_read_lock();
2291	ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, inum));
2292
2293	/* Inode not in memory, nothing to do */
2294	if (!ip) {
2295		rcu_read_unlock();
2296		return;
2297	}
2298
2299	/*
2300	 * because this is an RCU protected lookup, we could find a recently
2301	 * freed or even reallocated inode during the lookup. We need to check
2302	 * under the i_flags_lock for a valid inode here. Skip it if it is not
2303	 * valid, the wrong inode or stale.
2304	 */
2305	spin_lock(&ip->i_flags_lock);
2306	if (ip->i_ino != inum || __xfs_iflags_test(ip, XFS_ISTALE))
2307		goto out_iflags_unlock;
2308
2309	/*
2310	 * Don't try to lock/unlock the current inode, but we _cannot_ skip the
2311	 * other inodes that we did not find in the list attached to the buffer
2312	 * and are not already marked stale. If we can't lock it, back off and
2313	 * retry.
2314	 */
2315	if (ip != free_ip) {
2316		if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2317			spin_unlock(&ip->i_flags_lock);
2318			rcu_read_unlock();
2319			delay(1);
2320			goto retry;
2321		}
2322	}
2323	ip->i_flags |= XFS_ISTALE;
2324
2325	/*
2326	 * If the inode is flushing, it is already attached to the buffer.  All
2327	 * we needed to do here is mark the inode stale so buffer IO completion
2328	 * will remove it from the AIL.
2329	 */
2330	iip = ip->i_itemp;
2331	if (__xfs_iflags_test(ip, XFS_IFLUSHING)) {
2332		ASSERT(!list_empty(&iip->ili_item.li_bio_list));
2333		ASSERT(iip->ili_last_fields);
2334		goto out_iunlock;
2335	}
2336
2337	/*
2338	 * Inodes not attached to the buffer can be released immediately.
2339	 * Everything else has to go through xfs_iflush_abort() on journal
2340	 * commit as the flock synchronises removal of the inode from the
2341	 * cluster buffer against inode reclaim.
2342	 */
2343	if (!iip || list_empty(&iip->ili_item.li_bio_list))
2344		goto out_iunlock;
2345
2346	__xfs_iflags_set(ip, XFS_IFLUSHING);
2347	spin_unlock(&ip->i_flags_lock);
2348	rcu_read_unlock();
2349
2350	/* we have a dirty inode in memory that has not yet been flushed. */
2351	spin_lock(&iip->ili_lock);
2352	iip->ili_last_fields = iip->ili_fields;
2353	iip->ili_fields = 0;
2354	iip->ili_fsync_fields = 0;
2355	spin_unlock(&iip->ili_lock);
2356	ASSERT(iip->ili_last_fields);
2357
2358	if (ip != free_ip)
2359		xfs_iunlock(ip, XFS_ILOCK_EXCL);
2360	return;
2361
2362out_iunlock:
2363	if (ip != free_ip)
2364		xfs_iunlock(ip, XFS_ILOCK_EXCL);
2365out_iflags_unlock:
2366	spin_unlock(&ip->i_flags_lock);
2367	rcu_read_unlock();
2368}
2369
2370/*
2371 * A big issue when freeing the inode cluster is that we _cannot_ skip any
2372 * inodes that are in memory - they all must be marked stale and attached to
2373 * the cluster buffer.
2374 */
2375static int
2376xfs_ifree_cluster(
2377	struct xfs_trans	*tp,
2378	struct xfs_perag	*pag,
2379	struct xfs_inode	*free_ip,
2380	struct xfs_icluster	*xic)
2381{
2382	struct xfs_mount	*mp = free_ip->i_mount;
2383	struct xfs_ino_geometry	*igeo = M_IGEO(mp);
2384	struct xfs_buf		*bp;
2385	xfs_daddr_t		blkno;
2386	xfs_ino_t		inum = xic->first_ino;
2387	int			nbufs;
2388	int			i, j;
2389	int			ioffset;
2390	int			error;
2391
2392	nbufs = igeo->ialloc_blks / igeo->blocks_per_cluster;
2393
2394	for (j = 0; j < nbufs; j++, inum += igeo->inodes_per_cluster) {
2395		/*
2396		 * The allocation bitmap tells us which inodes of the chunk were
2397		 * physically allocated. Skip the cluster if an inode falls into
2398		 * a sparse region.
2399		 */
2400		ioffset = inum - xic->first_ino;
2401		if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
2402			ASSERT(ioffset % igeo->inodes_per_cluster == 0);
2403			continue;
2404		}
2405
2406		blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2407					 XFS_INO_TO_AGBNO(mp, inum));
2408
2409		/*
2410		 * We obtain and lock the backing buffer first in the process
2411		 * here to ensure dirty inodes attached to the buffer remain in
2412		 * the flushing state while we mark them stale.
2413		 *
2414		 * If we scan the in-memory inodes first, then buffer IO can
2415		 * complete before we get a lock on it, and hence we may fail
2416		 * to mark all the active inodes on the buffer stale.
2417		 */
2418		error = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
2419				mp->m_bsize * igeo->blocks_per_cluster,
2420				XBF_UNMAPPED, &bp);
2421		if (error)
2422			return error;
2423
2424		/*
2425		 * This buffer may not have been correctly initialised as we
2426		 * didn't read it from disk. That's not important because we are
2427		 * only using to mark the buffer as stale in the log, and to
2428		 * attach stale cached inodes on it. That means it will never be
2429		 * dispatched for IO. If it is, we want to know about it, and we
2430		 * want it to fail. We can acheive this by adding a write
2431		 * verifier to the buffer.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2432		 */
 
2433		bp->b_ops = &xfs_inode_buf_ops;
2434
2435		/*
2436		 * Now we need to set all the cached clean inodes as XFS_ISTALE,
2437		 * too. This requires lookups, and will skip inodes that we've
2438		 * already marked XFS_ISTALE.
2439		 */
2440		for (i = 0; i < igeo->inodes_per_cluster; i++)
2441			xfs_ifree_mark_inode_stale(pag, free_ip, inum + i);
2442
2443		xfs_trans_stale_inode_buf(tp, bp);
2444		xfs_trans_binval(tp, bp);
2445	}
2446	return 0;
2447}
2448
2449/*
2450 * This is called to return an inode to the inode free list.  The inode should
2451 * already be truncated to 0 length and have no pages associated with it.  This
2452 * routine also assumes that the inode is already a part of the transaction.
2453 *
2454 * The on-disk copy of the inode will have been added to the list of unlinked
2455 * inodes in the AGI. We need to remove the inode from that list atomically with
2456 * respect to freeing it here.
2457 */
2458int
2459xfs_ifree(
2460	struct xfs_trans	*tp,
2461	struct xfs_inode	*ip)
2462{
2463	struct xfs_mount	*mp = ip->i_mount;
2464	struct xfs_perag	*pag;
2465	struct xfs_icluster	xic = { 0 };
2466	struct xfs_inode_log_item *iip = ip->i_itemp;
2467	int			error;
2468
2469	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
2470	ASSERT(VFS_I(ip)->i_nlink == 0);
2471	ASSERT(ip->i_df.if_nextents == 0);
2472	ASSERT(ip->i_disk_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
2473	ASSERT(ip->i_nblocks == 0);
2474
2475	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
2476
2477	/*
2478	 * Free the inode first so that we guarantee that the AGI lock is going
2479	 * to be taken before we remove the inode from the unlinked list. This
2480	 * makes the AGI lock -> unlinked list modification order the same as
2481	 * used in O_TMPFILE creation.
2482	 */
2483	error = xfs_difree(tp, pag, ip->i_ino, &xic);
2484	if (error)
2485		goto out;
2486
2487	error = xfs_iunlink_remove(tp, pag, ip);
2488	if (error)
2489		goto out;
2490
2491	/*
2492	 * Free any local-format data sitting around before we reset the
2493	 * data fork to extents format.  Note that the attr fork data has
2494	 * already been freed by xfs_attr_inactive.
2495	 */
2496	if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
2497		kfree(ip->i_df.if_data);
2498		ip->i_df.if_data = NULL;
2499		ip->i_df.if_bytes = 0;
2500	}
2501
2502	VFS_I(ip)->i_mode = 0;		/* mark incore inode as free */
2503	ip->i_diflags = 0;
2504	ip->i_diflags2 = mp->m_ino_geo.new_diflags2;
2505	ip->i_forkoff = 0;		/* mark the attr fork not in use */
2506	ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
2507	if (xfs_iflags_test(ip, XFS_IPRESERVE_DM_FIELDS))
2508		xfs_iflags_clear(ip, XFS_IPRESERVE_DM_FIELDS);
2509
2510	/* Don't attempt to replay owner changes for a deleted inode */
2511	spin_lock(&iip->ili_lock);
2512	iip->ili_fields &= ~(XFS_ILOG_AOWNER | XFS_ILOG_DOWNER);
2513	spin_unlock(&iip->ili_lock);
2514
2515	/*
2516	 * Bump the generation count so no one will be confused
2517	 * by reincarnations of this inode.
2518	 */
2519	VFS_I(ip)->i_generation++;
2520	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2521
2522	if (xic.deleted)
2523		error = xfs_ifree_cluster(tp, pag, ip, &xic);
2524out:
2525	xfs_perag_put(pag);
2526	return error;
2527}
2528
2529/*
2530 * This is called to unpin an inode.  The caller must have the inode locked
2531 * in at least shared mode so that the buffer cannot be subsequently pinned
2532 * once someone is waiting for it to be unpinned.
2533 */
2534static void
2535xfs_iunpin(
2536	struct xfs_inode	*ip)
2537{
2538	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
2539
2540	trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
2541
2542	/* Give the log a push to start the unpinning I/O */
2543	xfs_log_force_seq(ip->i_mount, ip->i_itemp->ili_commit_seq, 0, NULL);
2544
2545}
2546
2547static void
2548__xfs_iunpin_wait(
2549	struct xfs_inode	*ip)
2550{
2551	wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
2552	DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
2553
2554	xfs_iunpin(ip);
2555
2556	do {
2557		prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
2558		if (xfs_ipincount(ip))
2559			io_schedule();
2560	} while (xfs_ipincount(ip));
2561	finish_wait(wq, &wait.wq_entry);
2562}
2563
2564void
2565xfs_iunpin_wait(
2566	struct xfs_inode	*ip)
2567{
2568	if (xfs_ipincount(ip))
2569		__xfs_iunpin_wait(ip);
2570}
2571
2572/*
2573 * Removing an inode from the namespace involves removing the directory entry
2574 * and dropping the link count on the inode. Removing the directory entry can
2575 * result in locking an AGF (directory blocks were freed) and removing a link
2576 * count can result in placing the inode on an unlinked list which results in
2577 * locking an AGI.
2578 *
2579 * The big problem here is that we have an ordering constraint on AGF and AGI
2580 * locking - inode allocation locks the AGI, then can allocate a new extent for
2581 * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
2582 * removes the inode from the unlinked list, requiring that we lock the AGI
2583 * first, and then freeing the inode can result in an inode chunk being freed
2584 * and hence freeing disk space requiring that we lock an AGF.
2585 *
2586 * Hence the ordering that is imposed by other parts of the code is AGI before
2587 * AGF. This means we cannot remove the directory entry before we drop the inode
2588 * reference count and put it on the unlinked list as this results in a lock
2589 * order of AGF then AGI, and this can deadlock against inode allocation and
2590 * freeing. Therefore we must drop the link counts before we remove the
2591 * directory entry.
2592 *
2593 * This is still safe from a transactional point of view - it is not until we
2594 * get to xfs_defer_finish() that we have the possibility of multiple
2595 * transactions in this operation. Hence as long as we remove the directory
2596 * entry and drop the link count in the first transaction of the remove
2597 * operation, there are no transactional constraints on the ordering here.
2598 */
2599int
2600xfs_remove(
2601	xfs_inode_t             *dp,
2602	struct xfs_name		*name,
2603	xfs_inode_t		*ip)
2604{
2605	xfs_mount_t		*mp = dp->i_mount;
2606	xfs_trans_t             *tp = NULL;
 
 
 
 
 
2607	int			is_dir = S_ISDIR(VFS_I(ip)->i_mode);
2608	int			dontcare;
2609	int                     error = 0;
2610	uint			resblks;
2611
2612	trace_xfs_remove(dp, name);
2613
2614	if (xfs_is_shutdown(mp))
2615		return -EIO;
2616	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
2617		return -EIO;
2618
2619	error = xfs_qm_dqattach(dp);
2620	if (error)
2621		goto std_return;
2622
2623	error = xfs_qm_dqattach(ip);
2624	if (error)
2625		goto std_return;
2626
 
 
 
 
2627	/*
2628	 * We try to get the real space reservation first, allowing for
2629	 * directory btree deletion(s) implying possible bmap insert(s).  If we
2630	 * can't get the space reservation then we use 0 instead, and avoid the
2631	 * bmap btree insert(s) in the directory code by, if the bmap insert
2632	 * tries to happen, instead trimming the LAST block from the directory.
2633	 *
2634	 * Ignore EDQUOT and ENOSPC being returned via nospace_error because
2635	 * the directory code can handle a reservationless update and we don't
2636	 * want to prevent a user from trying to free space by deleting things.
2637	 */
2638	resblks = XFS_REMOVE_SPACE_RES(mp);
2639	error = xfs_trans_alloc_dir(dp, &M_RES(mp)->tr_remove, ip, &resblks,
2640			&tp, &dontcare);
2641	if (error) {
2642		ASSERT(error != -ENOSPC);
2643		goto std_return;
2644	}
2645
2646	/*
2647	 * If we're removing a directory perform some additional validation.
2648	 */
2649	if (is_dir) {
2650		ASSERT(VFS_I(ip)->i_nlink >= 2);
2651		if (VFS_I(ip)->i_nlink != 2) {
2652			error = -ENOTEMPTY;
2653			goto out_trans_cancel;
2654		}
2655		if (!xfs_dir_isempty(ip)) {
2656			error = -ENOTEMPTY;
2657			goto out_trans_cancel;
2658		}
2659
2660		/* Drop the link from ip's "..".  */
2661		error = xfs_droplink(tp, dp);
2662		if (error)
2663			goto out_trans_cancel;
2664
2665		/* Drop the "." link from ip to self.  */
2666		error = xfs_droplink(tp, ip);
2667		if (error)
2668			goto out_trans_cancel;
2669
2670		/*
2671		 * Point the unlinked child directory's ".." entry to the root
2672		 * directory to eliminate back-references to inodes that may
2673		 * get freed before the child directory is closed.  If the fs
2674		 * gets shrunk, this can lead to dirent inode validation errors.
2675		 */
2676		if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) {
2677			error = xfs_dir_replace(tp, ip, &xfs_name_dotdot,
2678					tp->t_mountp->m_sb.sb_rootino, 0);
2679			if (error)
2680				goto out_trans_cancel;
2681		}
2682	} else {
2683		/*
2684		 * When removing a non-directory we need to log the parent
2685		 * inode here.  For a directory this is done implicitly
2686		 * by the xfs_droplink call for the ".." entry.
2687		 */
2688		xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2689	}
2690	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2691
2692	/* Drop the link from dp to ip. */
2693	error = xfs_droplink(tp, ip);
2694	if (error)
2695		goto out_trans_cancel;
2696
2697	error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks);
2698	if (error) {
2699		ASSERT(error != -ENOENT);
2700		goto out_trans_cancel;
2701	}
2702
2703	/*
2704	 * Drop the link from dp to ip, and if ip was a directory, remove the
2705	 * '.' and '..' references since we freed the directory.
2706	 */
2707	xfs_dir_update_hook(dp, ip, -1, name);
2708
2709	/*
2710	 * If this is a synchronous mount, make sure that the
2711	 * remove transaction goes to disk before returning to
2712	 * the user.
2713	 */
2714	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
2715		xfs_trans_set_sync(tp);
2716
2717	error = xfs_trans_commit(tp);
2718	if (error)
2719		goto std_return;
2720
2721	if (is_dir && xfs_inode_is_filestream(ip))
2722		xfs_filestream_deassociate(ip);
2723
 
 
 
2724	return 0;
2725
2726 out_trans_cancel:
2727	xfs_trans_cancel(tp);
 
 
 
 
 
2728 std_return:
2729	return error;
2730}
2731
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2732/*
2733 * Enter all inodes for a rename transaction into a sorted array.
2734 */
2735#define __XFS_SORT_INODES	5
2736STATIC void
2737xfs_sort_for_rename(
2738	struct xfs_inode	*dp1,	/* in: old (source) directory inode */
2739	struct xfs_inode	*dp2,	/* in: new (target) directory inode */
2740	struct xfs_inode	*ip1,	/* in: inode of old entry */
2741	struct xfs_inode	*ip2,	/* in: inode of new entry */
2742	struct xfs_inode	*wip,	/* in: whiteout inode */
2743	struct xfs_inode	**i_tab,/* out: sorted array of inodes */
2744	int			*num_inodes)  /* in/out: inodes in array */
2745{
2746	int			i, j;
2747
2748	ASSERT(*num_inodes == __XFS_SORT_INODES);
2749	memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2750
2751	/*
2752	 * i_tab contains a list of pointers to inodes.  We initialize
2753	 * the table here & we'll sort it.  We will then use it to
2754	 * order the acquisition of the inode locks.
2755	 *
2756	 * Note that the table may contain duplicates.  e.g., dp1 == dp2.
2757	 */
2758	i = 0;
2759	i_tab[i++] = dp1;
2760	i_tab[i++] = dp2;
2761	i_tab[i++] = ip1;
2762	if (ip2)
2763		i_tab[i++] = ip2;
2764	if (wip)
2765		i_tab[i++] = wip;
2766	*num_inodes = i;
2767
2768	/*
2769	 * Sort the elements via bubble sort.  (Remember, there are at
2770	 * most 5 elements to sort, so this is adequate.)
2771	 */
2772	for (i = 0; i < *num_inodes; i++) {
2773		for (j = 1; j < *num_inodes; j++) {
2774			if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
2775				struct xfs_inode *temp = i_tab[j];
2776				i_tab[j] = i_tab[j-1];
2777				i_tab[j-1] = temp;
2778			}
2779		}
2780	}
2781}
2782
2783static int
2784xfs_finish_rename(
2785	struct xfs_trans	*tp)
2786{
2787	/*
2788	 * If this is a synchronous mount, make sure that the rename transaction
2789	 * goes to disk before returning to the user.
2790	 */
2791	if (xfs_has_wsync(tp->t_mountp) || xfs_has_dirsync(tp->t_mountp))
2792		xfs_trans_set_sync(tp);
2793
2794	return xfs_trans_commit(tp);
2795}
2796
2797/*
2798 * xfs_cross_rename()
2799 *
2800 * responsible for handling RENAME_EXCHANGE flag in renameat2() syscall
2801 */
2802STATIC int
2803xfs_cross_rename(
2804	struct xfs_trans	*tp,
2805	struct xfs_inode	*dp1,
2806	struct xfs_name		*name1,
2807	struct xfs_inode	*ip1,
2808	struct xfs_inode	*dp2,
2809	struct xfs_name		*name2,
2810	struct xfs_inode	*ip2,
2811	int			spaceres)
2812{
2813	int		error = 0;
2814	int		ip1_flags = 0;
2815	int		ip2_flags = 0;
2816	int		dp2_flags = 0;
2817
2818	/* Swap inode number for dirent in first parent */
2819	error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, spaceres);
2820	if (error)
2821		goto out_trans_abort;
2822
2823	/* Swap inode number for dirent in second parent */
2824	error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres);
2825	if (error)
2826		goto out_trans_abort;
2827
2828	/*
2829	 * If we're renaming one or more directories across different parents,
2830	 * update the respective ".." entries (and link counts) to match the new
2831	 * parents.
2832	 */
2833	if (dp1 != dp2) {
2834		dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2835
2836		if (S_ISDIR(VFS_I(ip2)->i_mode)) {
2837			error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
2838						dp1->i_ino, spaceres);
2839			if (error)
2840				goto out_trans_abort;
2841
2842			/* transfer ip2 ".." reference to dp1 */
2843			if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
2844				error = xfs_droplink(tp, dp2);
2845				if (error)
2846					goto out_trans_abort;
2847				xfs_bumplink(tp, dp1);
2848			}
2849
2850			/*
2851			 * Although ip1 isn't changed here, userspace needs
2852			 * to be warned about the change, so that applications
2853			 * relying on it (like backup ones), will properly
2854			 * notify the change
2855			 */
2856			ip1_flags |= XFS_ICHGTIME_CHG;
2857			ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2858		}
2859
2860		if (S_ISDIR(VFS_I(ip1)->i_mode)) {
2861			error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
2862						dp2->i_ino, spaceres);
2863			if (error)
2864				goto out_trans_abort;
2865
2866			/* transfer ip1 ".." reference to dp2 */
2867			if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
2868				error = xfs_droplink(tp, dp1);
2869				if (error)
2870					goto out_trans_abort;
2871				xfs_bumplink(tp, dp2);
2872			}
2873
2874			/*
2875			 * Although ip2 isn't changed here, userspace needs
2876			 * to be warned about the change, so that applications
2877			 * relying on it (like backup ones), will properly
2878			 * notify the change
2879			 */
2880			ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2881			ip2_flags |= XFS_ICHGTIME_CHG;
2882		}
2883	}
2884
2885	if (ip1_flags) {
2886		xfs_trans_ichgtime(tp, ip1, ip1_flags);
2887		xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
2888	}
2889	if (ip2_flags) {
2890		xfs_trans_ichgtime(tp, ip2, ip2_flags);
2891		xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
2892	}
2893	if (dp2_flags) {
2894		xfs_trans_ichgtime(tp, dp2, dp2_flags);
2895		xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
2896	}
2897	xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2898	xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
2899
2900	/*
2901	 * Inform our hook clients that we've finished an exchange operation as
2902	 * follows: removed the source and target files from their directories;
2903	 * added the target to the source directory; and added the source to
2904	 * the target directory.  All inodes are locked, so it's ok to model a
2905	 * rename this way so long as we say we deleted entries before we add
2906	 * new ones.
2907	 */
2908	xfs_dir_update_hook(dp1, ip1, -1, name1);
2909	xfs_dir_update_hook(dp2, ip2, -1, name2);
2910	xfs_dir_update_hook(dp1, ip2, 1, name1);
2911	xfs_dir_update_hook(dp2, ip1, 1, name2);
2912
2913	return xfs_finish_rename(tp);
2914
2915out_trans_abort:
2916	xfs_trans_cancel(tp);
2917	return error;
2918}
2919
2920/*
2921 * xfs_rename_alloc_whiteout()
2922 *
2923 * Return a referenced, unlinked, unlocked inode that can be used as a
2924 * whiteout in a rename transaction. We use a tmpfile inode here so that if we
2925 * crash between allocating the inode and linking it into the rename transaction
2926 * recovery will free the inode and we won't leak it.
2927 */
2928static int
2929xfs_rename_alloc_whiteout(
2930	struct mnt_idmap	*idmap,
2931	struct xfs_name		*src_name,
2932	struct xfs_inode	*dp,
2933	struct xfs_inode	**wip)
2934{
 
 
 
 
 
 
2935	struct xfs_inode	*tmpfile;
2936	struct qstr		name;
2937	int			error;
2938
2939	error = xfs_create_tmpfile(idmap, dp, S_IFCHR | WHITEOUT_MODE,
2940				   &tmpfile);
2941	if (error)
2942		return error;
2943
2944	name.name = src_name->name;
2945	name.len = src_name->len;
2946	error = xfs_inode_init_security(VFS_I(tmpfile), VFS_I(dp), &name);
2947	if (error) {
2948		xfs_finish_inode_setup(tmpfile);
2949		xfs_irele(tmpfile);
2950		return error;
2951	}
2952
2953	/*
2954	 * Prepare the tmpfile inode as if it were created through the VFS.
2955	 * Complete the inode setup and flag it as linkable.  nlink is already
2956	 * zero, so we can skip the drop_nlink.
2957	 */
2958	xfs_setup_iops(tmpfile);
2959	xfs_finish_inode_setup(tmpfile);
2960	VFS_I(tmpfile)->i_state |= I_LINKABLE;
2961
2962	*wip = tmpfile;
2963	return 0;
2964}
2965
2966/*
2967 * xfs_rename
2968 */
2969int
2970xfs_rename(
2971	struct mnt_idmap	*idmap,
2972	struct xfs_inode	*src_dp,
2973	struct xfs_name		*src_name,
2974	struct xfs_inode	*src_ip,
2975	struct xfs_inode	*target_dp,
2976	struct xfs_name		*target_name,
2977	struct xfs_inode	*target_ip,
2978	unsigned int		flags)
2979{
 
 
 
 
 
 
 
 
 
 
 
2980	struct xfs_mount	*mp = src_dp->i_mount;
2981	struct xfs_trans	*tp;
2982	struct xfs_inode	*wip = NULL;		/* whiteout inode */
2983	struct xfs_inode	*inodes[__XFS_SORT_INODES];
2984	int			i;
2985	int			num_inodes = __XFS_SORT_INODES;
2986	bool			new_parent = (src_dp != target_dp);
2987	bool			src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
2988	int			spaceres;
2989	bool			retried = false;
2990	int			error, nospace_error = 0;
2991
2992	trace_xfs_rename(src_dp, target_dp, src_name, target_name);
2993
2994	if ((flags & RENAME_EXCHANGE) && !target_ip)
2995		return -EINVAL;
2996
2997	/*
2998	 * If we are doing a whiteout operation, allocate the whiteout inode
2999	 * we will be placing at the target and ensure the type is set
3000	 * appropriately.
3001	 */
3002	if (flags & RENAME_WHITEOUT) {
3003		error = xfs_rename_alloc_whiteout(idmap, src_name,
3004						  target_dp, &wip);
3005		if (error)
3006			return error;
3007
3008		/* setup target dirent info as whiteout */
3009		src_name->type = XFS_DIR3_FT_CHRDEV;
3010	}
3011
3012	xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
3013				inodes, &num_inodes);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3014
3015retry:
3016	nospace_error = 0;
3017	spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
 
3018	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
3019	if (error == -ENOSPC) {
3020		nospace_error = error;
3021		spaceres = 0;
3022		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
3023				&tp);
3024	}
3025	if (error)
3026		goto out_release_wip;
 
 
 
 
 
 
 
 
 
 
3027
3028	/*
3029	 * Attach the dquots to the inodes
3030	 */
3031	error = xfs_qm_vop_rename_dqattach(inodes);
3032	if (error)
3033		goto out_trans_cancel;
 
 
3034
3035	/*
3036	 * Lock all the participating inodes. Depending upon whether
3037	 * the target_name exists in the target directory, and
3038	 * whether the target directory is the same as the source
3039	 * directory, we can lock from 2 to 5 inodes.
3040	 */
3041	xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
3042
3043	/*
3044	 * Join all the inodes to the transaction. From this point on,
3045	 * we can rely on either trans_commit or trans_cancel to unlock
3046	 * them.
3047	 */
3048	xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
3049	if (new_parent)
3050		xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
3051	xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
3052	if (target_ip)
3053		xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
3054	if (wip)
3055		xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
3056
3057	/*
3058	 * If we are using project inheritance, we only allow renames
3059	 * into our tree when the project IDs are the same; else the
3060	 * tree quota mechanism would be circumvented.
3061	 */
3062	if (unlikely((target_dp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
3063		     target_dp->i_projid != src_ip->i_projid)) {
3064		error = -EXDEV;
3065		goto out_trans_cancel;
3066	}
3067
3068	/* RENAME_EXCHANGE is unique from here on. */
3069	if (flags & RENAME_EXCHANGE)
3070		return xfs_cross_rename(tp, src_dp, src_name, src_ip,
3071					target_dp, target_name, target_ip,
3072					spaceres);
 
 
 
3073
3074	/*
3075	 * Try to reserve quota to handle an expansion of the target directory.
3076	 * We'll allow the rename to continue in reservationless mode if we hit
3077	 * a space usage constraint.  If we trigger reservationless mode, save
3078	 * the errno if there isn't any free space in the target directory.
3079	 */
3080	if (spaceres != 0) {
3081		error = xfs_trans_reserve_quota_nblks(tp, target_dp, spaceres,
3082				0, false);
3083		if (error == -EDQUOT || error == -ENOSPC) {
3084			if (!retried) {
3085				xfs_trans_cancel(tp);
 
3086				xfs_blockgc_free_quota(target_dp, 0);
3087				retried = true;
3088				goto retry;
3089			}
3090
3091			nospace_error = error;
3092			spaceres = 0;
3093			error = 0;
3094		}
3095		if (error)
3096			goto out_trans_cancel;
3097	}
3098
3099	/*
3100	 * Check for expected errors before we dirty the transaction
3101	 * so we can return an error without a transaction abort.
3102	 */
3103	if (target_ip == NULL) {
3104		/*
3105		 * If there's no space reservation, check the entry will
3106		 * fit before actually inserting it.
3107		 */
3108		if (!spaceres) {
3109			error = xfs_dir_canenter(tp, target_dp, target_name);
3110			if (error)
3111				goto out_trans_cancel;
3112		}
3113	} else {
3114		/*
3115		 * If target exists and it's a directory, check that whether
3116		 * it can be destroyed.
3117		 */
3118		if (S_ISDIR(VFS_I(target_ip)->i_mode) &&
3119		    (!xfs_dir_isempty(target_ip) ||
3120		     (VFS_I(target_ip)->i_nlink > 2))) {
3121			error = -EEXIST;
3122			goto out_trans_cancel;
3123		}
3124	}
3125
3126	/*
3127	 * Lock the AGI buffers we need to handle bumping the nlink of the
3128	 * whiteout inode off the unlinked list and to handle dropping the
3129	 * nlink of the target inode.  Per locking order rules, do this in
3130	 * increasing AG order and before directory block allocation tries to
3131	 * grab AGFs because we grab AGIs before AGFs.
3132	 *
3133	 * The (vfs) caller must ensure that if src is a directory then
3134	 * target_ip is either null or an empty directory.
3135	 */
3136	for (i = 0; i < num_inodes && inodes[i] != NULL; i++) {
3137		if (inodes[i] == wip ||
3138		    (inodes[i] == target_ip &&
3139		     (VFS_I(target_ip)->i_nlink == 1 || src_is_directory))) {
3140			struct xfs_perag	*pag;
3141			struct xfs_buf		*bp;
3142
3143			pag = xfs_perag_get(mp,
3144					XFS_INO_TO_AGNO(mp, inodes[i]->i_ino));
3145			error = xfs_read_agi(pag, tp, &bp);
3146			xfs_perag_put(pag);
3147			if (error)
3148				goto out_trans_cancel;
3149		}
3150	}
3151
3152	/*
3153	 * Directory entry creation below may acquire the AGF. Remove
3154	 * the whiteout from the unlinked list first to preserve correct
3155	 * AGI/AGF locking order. This dirties the transaction so failures
3156	 * after this point will abort and log recovery will clean up the
3157	 * mess.
3158	 *
3159	 * For whiteouts, we need to bump the link count on the whiteout
3160	 * inode. After this point, we have a real link, clear the tmpfile
3161	 * state flag from the inode so it doesn't accidentally get misused
3162	 * in future.
3163	 */
3164	if (wip) {
3165		struct xfs_perag	*pag;
3166
3167		ASSERT(VFS_I(wip)->i_nlink == 0);
3168
3169		pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, wip->i_ino));
3170		error = xfs_iunlink_remove(tp, pag, wip);
3171		xfs_perag_put(pag);
3172		if (error)
3173			goto out_trans_cancel;
3174
3175		xfs_bumplink(tp, wip);
3176		VFS_I(wip)->i_state &= ~I_LINKABLE;
3177	}
3178
3179	/*
3180	 * Set up the target.
3181	 */
3182	if (target_ip == NULL) {
3183		/*
3184		 * If target does not exist and the rename crosses
3185		 * directories, adjust the target directory link count
3186		 * to account for the ".." reference from the new entry.
3187		 */
3188		error = xfs_dir_createname(tp, target_dp, target_name,
3189					   src_ip->i_ino, spaceres);
3190		if (error)
3191			goto out_trans_cancel;
3192
3193		xfs_trans_ichgtime(tp, target_dp,
3194					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3195
3196		if (new_parent && src_is_directory) {
3197			xfs_bumplink(tp, target_dp);
3198		}
3199	} else { /* target_ip != NULL */
3200		/*
3201		 * Link the source inode under the target name.
3202		 * If the source inode is a directory and we are moving
3203		 * it across directories, its ".." entry will be
3204		 * inconsistent until we replace that down below.
3205		 *
3206		 * In case there is already an entry with the same
3207		 * name at the destination directory, remove it first.
3208		 */
3209		error = xfs_dir_replace(tp, target_dp, target_name,
3210					src_ip->i_ino, spaceres);
3211		if (error)
3212			goto out_trans_cancel;
3213
3214		xfs_trans_ichgtime(tp, target_dp,
3215					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3216
3217		/*
3218		 * Decrement the link count on the target since the target
3219		 * dir no longer points to it.
3220		 */
3221		error = xfs_droplink(tp, target_ip);
3222		if (error)
3223			goto out_trans_cancel;
3224
3225		if (src_is_directory) {
3226			/*
3227			 * Drop the link from the old "." entry.
3228			 */
3229			error = xfs_droplink(tp, target_ip);
3230			if (error)
3231				goto out_trans_cancel;
3232		}
3233	} /* target_ip != NULL */
3234
3235	/*
3236	 * Remove the source.
3237	 */
3238	if (new_parent && src_is_directory) {
3239		/*
3240		 * Rewrite the ".." entry to point to the new
3241		 * directory.
3242		 */
3243		error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
3244					target_dp->i_ino, spaceres);
3245		ASSERT(error != -EEXIST);
3246		if (error)
3247			goto out_trans_cancel;
3248	}
3249
3250	/*
3251	 * We always want to hit the ctime on the source inode.
3252	 *
3253	 * This isn't strictly required by the standards since the source
3254	 * inode isn't really being changed, but old unix file systems did
3255	 * it and some incremental backup programs won't work without it.
3256	 */
3257	xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
3258	xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
3259
3260	/*
3261	 * Adjust the link count on src_dp.  This is necessary when
3262	 * renaming a directory, either within one parent when
3263	 * the target existed, or across two parent directories.
3264	 */
3265	if (src_is_directory && (new_parent || target_ip != NULL)) {
3266
 
3267		/*
3268		 * Decrement link count on src_directory since the
3269		 * entry that's moved no longer points to it.
 
3270		 */
3271		error = xfs_droplink(tp, src_dp);
3272		if (error)
3273			goto out_trans_cancel;
3274	}
3275
 
3276	/*
3277	 * For whiteouts, we only need to update the source dirent with the
3278	 * inode number of the whiteout inode rather than removing it
3279	 * altogether.
3280	 */
3281	if (wip)
3282		error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
3283					spaceres);
3284	else
3285		error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
3286					   spaceres);
3287
3288	if (error)
3289		goto out_trans_cancel;
3290
3291	xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3292	xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
3293	if (new_parent)
3294		xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
3295
3296	/*
3297	 * Inform our hook clients that we've finished a rename operation as
3298	 * follows: removed the source and target files from their directories;
3299	 * that we've added the source to the target directory; and finally
3300	 * that we've added the whiteout, if there was one.  All inodes are
3301	 * locked, so it's ok to model a rename this way so long as we say we
3302	 * deleted entries before we add new ones.
3303	 */
3304	if (target_ip)
3305		xfs_dir_update_hook(target_dp, target_ip, -1, target_name);
3306	xfs_dir_update_hook(src_dp, src_ip, -1, src_name);
3307	xfs_dir_update_hook(target_dp, src_ip, 1, target_name);
3308	if (wip)
3309		xfs_dir_update_hook(src_dp, wip, 1, src_name);
3310
3311	error = xfs_finish_rename(tp);
3312	if (wip)
3313		xfs_irele(wip);
3314	return error;
3315
3316out_trans_cancel:
3317	xfs_trans_cancel(tp);
 
 
 
 
 
 
 
 
3318out_release_wip:
3319	if (wip)
3320		xfs_irele(wip);
3321	if (error == -ENOSPC && nospace_error)
3322		error = nospace_error;
3323	return error;
3324}
3325
3326static int
3327xfs_iflush(
3328	struct xfs_inode	*ip,
3329	struct xfs_buf		*bp)
3330{
3331	struct xfs_inode_log_item *iip = ip->i_itemp;
3332	struct xfs_dinode	*dip;
3333	struct xfs_mount	*mp = ip->i_mount;
3334	int			error;
3335
3336	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
3337	ASSERT(xfs_iflags_test(ip, XFS_IFLUSHING));
3338	ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_BTREE ||
3339	       ip->i_df.if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3340	ASSERT(iip->ili_item.li_buf == bp);
3341
3342	dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
3343
3344	/*
3345	 * We don't flush the inode if any of the following checks fail, but we
3346	 * do still update the log item and attach to the backing buffer as if
3347	 * the flush happened. This is a formality to facilitate predictable
3348	 * error handling as the caller will shutdown and fail the buffer.
3349	 */
3350	error = -EFSCORRUPTED;
3351	if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
3352			       mp, XFS_ERRTAG_IFLUSH_1)) {
3353		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3354			"%s: Bad inode %llu magic number 0x%x, ptr "PTR_FMT,
3355			__func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
3356		goto flush_out;
3357	}
3358	if (S_ISREG(VFS_I(ip)->i_mode)) {
3359		if (XFS_TEST_ERROR(
3360		    ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
3361		    ip->i_df.if_format != XFS_DINODE_FMT_BTREE,
3362		    mp, XFS_ERRTAG_IFLUSH_3)) {
3363			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3364				"%s: Bad regular inode %llu, ptr "PTR_FMT,
3365				__func__, ip->i_ino, ip);
3366			goto flush_out;
3367		}
3368	} else if (S_ISDIR(VFS_I(ip)->i_mode)) {
3369		if (XFS_TEST_ERROR(
3370		    ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
3371		    ip->i_df.if_format != XFS_DINODE_FMT_BTREE &&
3372		    ip->i_df.if_format != XFS_DINODE_FMT_LOCAL,
3373		    mp, XFS_ERRTAG_IFLUSH_4)) {
3374			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3375				"%s: Bad directory inode %llu, ptr "PTR_FMT,
3376				__func__, ip->i_ino, ip);
3377			goto flush_out;
3378		}
3379	}
3380	if (XFS_TEST_ERROR(ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af) >
3381				ip->i_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
3382		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3383			"%s: detected corrupt incore inode %llu, "
3384			"total extents = %llu nblocks = %lld, ptr "PTR_FMT,
3385			__func__, ip->i_ino,
3386			ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af),
3387			ip->i_nblocks, ip);
3388		goto flush_out;
3389	}
3390	if (XFS_TEST_ERROR(ip->i_forkoff > mp->m_sb.sb_inodesize,
3391				mp, XFS_ERRTAG_IFLUSH_6)) {
3392		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3393			"%s: bad inode %llu, forkoff 0x%x, ptr "PTR_FMT,
3394			__func__, ip->i_ino, ip->i_forkoff, ip);
3395		goto flush_out;
3396	}
3397
3398	/*
3399	 * Inode item log recovery for v2 inodes are dependent on the flushiter
3400	 * count for correct sequencing.  We bump the flush iteration count so
3401	 * we can detect flushes which postdate a log record during recovery.
3402	 * This is redundant as we now log every change and hence this can't
3403	 * happen but we need to still do it to ensure backwards compatibility
3404	 * with old kernels that predate logging all inode changes.
3405	 */
3406	if (!xfs_has_v3inodes(mp))
3407		ip->i_flushiter++;
3408
3409	/*
3410	 * If there are inline format data / attr forks attached to this inode,
3411	 * make sure they are not corrupt.
3412	 */
3413	if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL &&
3414	    xfs_ifork_verify_local_data(ip))
3415		goto flush_out;
3416	if (xfs_inode_has_attr_fork(ip) &&
3417	    ip->i_af.if_format == XFS_DINODE_FMT_LOCAL &&
3418	    xfs_ifork_verify_local_attr(ip))
3419		goto flush_out;
3420
3421	/*
3422	 * Copy the dirty parts of the inode into the on-disk inode.  We always
3423	 * copy out the core of the inode, because if the inode is dirty at all
3424	 * the core must be.
3425	 */
3426	xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
3427
3428	/* Wrap, we never let the log put out DI_MAX_FLUSH */
3429	if (!xfs_has_v3inodes(mp)) {
3430		if (ip->i_flushiter == DI_MAX_FLUSH)
3431			ip->i_flushiter = 0;
3432	}
3433
3434	xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
3435	if (xfs_inode_has_attr_fork(ip))
3436		xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
3437
3438	/*
3439	 * We've recorded everything logged in the inode, so we'd like to clear
3440	 * the ili_fields bits so we don't log and flush things unnecessarily.
3441	 * However, we can't stop logging all this information until the data
3442	 * we've copied into the disk buffer is written to disk.  If we did we
3443	 * might overwrite the copy of the inode in the log with all the data
3444	 * after re-logging only part of it, and in the face of a crash we
3445	 * wouldn't have all the data we need to recover.
3446	 *
3447	 * What we do is move the bits to the ili_last_fields field.  When
3448	 * logging the inode, these bits are moved back to the ili_fields field.
3449	 * In the xfs_buf_inode_iodone() routine we clear ili_last_fields, since
3450	 * we know that the information those bits represent is permanently on
3451	 * disk.  As long as the flush completes before the inode is logged
3452	 * again, then both ili_fields and ili_last_fields will be cleared.
3453	 */
3454	error = 0;
3455flush_out:
3456	spin_lock(&iip->ili_lock);
3457	iip->ili_last_fields = iip->ili_fields;
3458	iip->ili_fields = 0;
3459	iip->ili_fsync_fields = 0;
 
3460	spin_unlock(&iip->ili_lock);
3461
3462	/*
3463	 * Store the current LSN of the inode so that we can tell whether the
3464	 * item has moved in the AIL from xfs_buf_inode_iodone().
3465	 */
3466	xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
3467				&iip->ili_item.li_lsn);
3468
3469	/* generate the checksum. */
3470	xfs_dinode_calc_crc(mp, dip);
3471	if (error)
3472		xfs_inode_mark_sick(ip, XFS_SICK_INO_CORE);
3473	return error;
3474}
3475
3476/*
3477 * Non-blocking flush of dirty inode metadata into the backing buffer.
3478 *
3479 * The caller must have a reference to the inode and hold the cluster buffer
3480 * locked. The function will walk across all the inodes on the cluster buffer it
3481 * can find and lock without blocking, and flush them to the cluster buffer.
3482 *
3483 * On successful flushing of at least one inode, the caller must write out the
3484 * buffer and release it. If no inodes are flushed, -EAGAIN will be returned and
3485 * the caller needs to release the buffer. On failure, the filesystem will be
3486 * shut down, the buffer will have been unlocked and released, and EFSCORRUPTED
3487 * will be returned.
3488 */
3489int
3490xfs_iflush_cluster(
3491	struct xfs_buf		*bp)
3492{
3493	struct xfs_mount	*mp = bp->b_mount;
3494	struct xfs_log_item	*lip, *n;
3495	struct xfs_inode	*ip;
3496	struct xfs_inode_log_item *iip;
3497	int			clcount = 0;
3498	int			error = 0;
3499
3500	/*
3501	 * We must use the safe variant here as on shutdown xfs_iflush_abort()
3502	 * will remove itself from the list.
3503	 */
3504	list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
3505		iip = (struct xfs_inode_log_item *)lip;
3506		ip = iip->ili_inode;
3507
3508		/*
3509		 * Quick and dirty check to avoid locks if possible.
3510		 */
3511		if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING))
3512			continue;
3513		if (xfs_ipincount(ip))
3514			continue;
3515
3516		/*
3517		 * The inode is still attached to the buffer, which means it is
3518		 * dirty but reclaim might try to grab it. Check carefully for
3519		 * that, and grab the ilock while still holding the i_flags_lock
3520		 * to guarantee reclaim will not be able to reclaim this inode
3521		 * once we drop the i_flags_lock.
3522		 */
3523		spin_lock(&ip->i_flags_lock);
3524		ASSERT(!__xfs_iflags_test(ip, XFS_ISTALE));
3525		if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING)) {
3526			spin_unlock(&ip->i_flags_lock);
3527			continue;
3528		}
3529
3530		/*
3531		 * ILOCK will pin the inode against reclaim and prevent
3532		 * concurrent transactions modifying the inode while we are
3533		 * flushing the inode. If we get the lock, set the flushing
3534		 * state before we drop the i_flags_lock.
3535		 */
3536		if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
3537			spin_unlock(&ip->i_flags_lock);
3538			continue;
3539		}
3540		__xfs_iflags_set(ip, XFS_IFLUSHING);
3541		spin_unlock(&ip->i_flags_lock);
3542
3543		/*
3544		 * Abort flushing this inode if we are shut down because the
3545		 * inode may not currently be in the AIL. This can occur when
3546		 * log I/O failure unpins the inode without inserting into the
3547		 * AIL, leaving a dirty/unpinned inode attached to the buffer
3548		 * that otherwise looks like it should be flushed.
3549		 */
3550		if (xlog_is_shutdown(mp->m_log)) {
3551			xfs_iunpin_wait(ip);
3552			xfs_iflush_abort(ip);
3553			xfs_iunlock(ip, XFS_ILOCK_SHARED);
3554			error = -EIO;
3555			continue;
3556		}
3557
3558		/* don't block waiting on a log force to unpin dirty inodes */
3559		if (xfs_ipincount(ip)) {
3560			xfs_iflags_clear(ip, XFS_IFLUSHING);
3561			xfs_iunlock(ip, XFS_ILOCK_SHARED);
3562			continue;
3563		}
3564
3565		if (!xfs_inode_clean(ip))
3566			error = xfs_iflush(ip, bp);
3567		else
3568			xfs_iflags_clear(ip, XFS_IFLUSHING);
3569		xfs_iunlock(ip, XFS_ILOCK_SHARED);
3570		if (error)
3571			break;
3572		clcount++;
3573	}
3574
3575	if (error) {
3576		/*
3577		 * Shutdown first so we kill the log before we release this
3578		 * buffer. If it is an INODE_ALLOC buffer and pins the tail
3579		 * of the log, failing it before the _log_ is shut down can
3580		 * result in the log tail being moved forward in the journal
3581		 * on disk because log writes can still be taking place. Hence
3582		 * unpinning the tail will allow the ICREATE intent to be
3583		 * removed from the log an recovery will fail with uninitialised
3584		 * inode cluster buffers.
3585		 */
3586		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3587		bp->b_flags |= XBF_ASYNC;
3588		xfs_buf_ioend_fail(bp);
3589		return error;
3590	}
3591
3592	if (!clcount)
3593		return -EAGAIN;
3594
3595	XFS_STATS_INC(mp, xs_icluster_flushcnt);
3596	XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
3597	return 0;
3598
3599}
3600
3601/* Release an inode. */
3602void
3603xfs_irele(
3604	struct xfs_inode	*ip)
3605{
3606	trace_xfs_irele(ip, _RET_IP_);
3607	iput(VFS_I(ip));
3608}
3609
3610/*
3611 * Ensure all commited transactions touching the inode are written to the log.
3612 */
3613int
3614xfs_log_force_inode(
3615	struct xfs_inode	*ip)
3616{
3617	xfs_csn_t		seq = 0;
3618
3619	xfs_ilock(ip, XFS_ILOCK_SHARED);
3620	if (xfs_ipincount(ip))
3621		seq = ip->i_itemp->ili_commit_seq;
3622	xfs_iunlock(ip, XFS_ILOCK_SHARED);
3623
3624	if (!seq)
3625		return 0;
3626	return xfs_log_force_seq(ip->i_mount, seq, XFS_LOG_SYNC, NULL);
3627}
3628
3629/*
3630 * Grab the exclusive iolock for a data copy from src to dest, making sure to
3631 * abide vfs locking order (lowest pointer value goes first) and breaking the
3632 * layout leases before proceeding.  The loop is needed because we cannot call
3633 * the blocking break_layout() with the iolocks held, and therefore have to
3634 * back out both locks.
3635 */
3636static int
3637xfs_iolock_two_inodes_and_break_layout(
3638	struct inode		*src,
3639	struct inode		*dest)
3640{
3641	int			error;
3642
3643	if (src > dest)
3644		swap(src, dest);
3645
3646retry:
3647	/* Wait to break both inodes' layouts before we start locking. */
3648	error = break_layout(src, true);
3649	if (error)
3650		return error;
3651	if (src != dest) {
3652		error = break_layout(dest, true);
3653		if (error)
3654			return error;
3655	}
3656
3657	/* Lock one inode and make sure nobody got in and leased it. */
3658	inode_lock(src);
3659	error = break_layout(src, false);
3660	if (error) {
3661		inode_unlock(src);
3662		if (error == -EWOULDBLOCK)
3663			goto retry;
3664		return error;
3665	}
3666
3667	if (src == dest)
3668		return 0;
3669
3670	/* Lock the other inode and make sure nobody got in and leased it. */
3671	inode_lock_nested(dest, I_MUTEX_NONDIR2);
3672	error = break_layout(dest, false);
3673	if (error) {
3674		inode_unlock(src);
3675		inode_unlock(dest);
3676		if (error == -EWOULDBLOCK)
3677			goto retry;
3678		return error;
3679	}
3680
3681	return 0;
3682}
3683
3684static int
3685xfs_mmaplock_two_inodes_and_break_dax_layout(
3686	struct xfs_inode	*ip1,
3687	struct xfs_inode	*ip2)
3688{
3689	int			error;
3690	bool			retry;
3691	struct page		*page;
3692
3693	if (ip1->i_ino > ip2->i_ino)
3694		swap(ip1, ip2);
3695
3696again:
3697	retry = false;
3698	/* Lock the first inode */
3699	xfs_ilock(ip1, XFS_MMAPLOCK_EXCL);
3700	error = xfs_break_dax_layouts(VFS_I(ip1), &retry);
3701	if (error || retry) {
3702		xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
3703		if (error == 0 && retry)
3704			goto again;
3705		return error;
3706	}
3707
3708	if (ip1 == ip2)
3709		return 0;
3710
3711	/* Nested lock the second inode */
3712	xfs_ilock(ip2, xfs_lock_inumorder(XFS_MMAPLOCK_EXCL, 1));
3713	/*
3714	 * We cannot use xfs_break_dax_layouts() directly here because it may
3715	 * need to unlock & lock the XFS_MMAPLOCK_EXCL which is not suitable
3716	 * for this nested lock case.
3717	 */
3718	page = dax_layout_busy_page(VFS_I(ip2)->i_mapping);
3719	if (page && page_ref_count(page) != 1) {
3720		xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
3721		xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
3722		goto again;
3723	}
3724
3725	return 0;
3726}
3727
3728/*
3729 * Lock two inodes so that userspace cannot initiate I/O via file syscalls or
3730 * mmap activity.
3731 */
3732int
3733xfs_ilock2_io_mmap(
3734	struct xfs_inode	*ip1,
3735	struct xfs_inode	*ip2)
3736{
3737	int			ret;
3738
3739	ret = xfs_iolock_two_inodes_and_break_layout(VFS_I(ip1), VFS_I(ip2));
3740	if (ret)
3741		return ret;
3742
3743	if (IS_DAX(VFS_I(ip1)) && IS_DAX(VFS_I(ip2))) {
3744		ret = xfs_mmaplock_two_inodes_and_break_dax_layout(ip1, ip2);
3745		if (ret) {
3746			inode_unlock(VFS_I(ip2));
3747			if (ip1 != ip2)
3748				inode_unlock(VFS_I(ip1));
3749			return ret;
3750		}
3751	} else
3752		filemap_invalidate_lock_two(VFS_I(ip1)->i_mapping,
3753					    VFS_I(ip2)->i_mapping);
3754
3755	return 0;
3756}
3757
3758/* Unlock both inodes to allow IO and mmap activity. */
3759void
3760xfs_iunlock2_io_mmap(
3761	struct xfs_inode	*ip1,
3762	struct xfs_inode	*ip2)
3763{
3764	if (IS_DAX(VFS_I(ip1)) && IS_DAX(VFS_I(ip2))) {
3765		xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
3766		if (ip1 != ip2)
3767			xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
3768	} else
3769		filemap_invalidate_unlock_two(VFS_I(ip1)->i_mapping,
3770					      VFS_I(ip2)->i_mapping);
3771
3772	inode_unlock(VFS_I(ip2));
3773	if (ip1 != ip2)
3774		inode_unlock(VFS_I(ip1));
3775}
3776
3777/* Drop the MMAPLOCK and the IOLOCK after a remap completes. */
3778void
3779xfs_iunlock2_remapping(
3780	struct xfs_inode	*ip1,
3781	struct xfs_inode	*ip2)
3782{
3783	xfs_iflags_clear(ip1, XFS_IREMAPPING);
3784
3785	if (ip1 != ip2)
3786		xfs_iunlock(ip1, XFS_MMAPLOCK_SHARED);
3787	xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
3788
3789	if (ip1 != ip2)
3790		inode_unlock_shared(VFS_I(ip1));
3791	inode_unlock(VFS_I(ip2));
3792}
3793
3794/*
3795 * Reload the incore inode list for this inode.  Caller should ensure that
3796 * the link count cannot change, either by taking ILOCK_SHARED or otherwise
3797 * preventing other threads from executing.
3798 */
3799int
3800xfs_inode_reload_unlinked_bucket(
3801	struct xfs_trans	*tp,
3802	struct xfs_inode	*ip)
3803{
3804	struct xfs_mount	*mp = tp->t_mountp;
3805	struct xfs_buf		*agibp;
3806	struct xfs_agi		*agi;
3807	struct xfs_perag	*pag;
3808	xfs_agnumber_t		agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
3809	xfs_agino_t		agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
3810	xfs_agino_t		prev_agino, next_agino;
3811	unsigned int		bucket;
3812	bool			foundit = false;
3813	int			error;
3814
3815	/* Grab the first inode in the list */
3816	pag = xfs_perag_get(mp, agno);
3817	error = xfs_ialloc_read_agi(pag, tp, &agibp);
3818	xfs_perag_put(pag);
3819	if (error)
3820		return error;
3821
3822	/*
3823	 * We've taken ILOCK_SHARED and the AGI buffer lock to stabilize the
3824	 * incore unlinked list pointers for this inode.  Check once more to
3825	 * see if we raced with anyone else to reload the unlinked list.
3826	 */
3827	if (!xfs_inode_unlinked_incomplete(ip)) {
3828		foundit = true;
3829		goto out_agibp;
3830	}
3831
3832	bucket = agino % XFS_AGI_UNLINKED_BUCKETS;
3833	agi = agibp->b_addr;
3834
3835	trace_xfs_inode_reload_unlinked_bucket(ip);
3836
3837	xfs_info_ratelimited(mp,
3838 "Found unrecovered unlinked inode 0x%x in AG 0x%x.  Initiating list recovery.",
3839			agino, agno);
3840
3841	prev_agino = NULLAGINO;
3842	next_agino = be32_to_cpu(agi->agi_unlinked[bucket]);
3843	while (next_agino != NULLAGINO) {
3844		struct xfs_inode	*next_ip = NULL;
3845
3846		/* Found this caller's inode, set its backlink. */
3847		if (next_agino == agino) {
3848			next_ip = ip;
3849			next_ip->i_prev_unlinked = prev_agino;
3850			foundit = true;
3851			goto next_inode;
3852		}
3853
3854		/* Try in-memory lookup first. */
3855		next_ip = xfs_iunlink_lookup(pag, next_agino);
3856		if (next_ip)
3857			goto next_inode;
3858
3859		/* Inode not in memory, try reloading it. */
3860		error = xfs_iunlink_reload_next(tp, agibp, prev_agino,
3861				next_agino);
3862		if (error)
3863			break;
3864
3865		/* Grab the reloaded inode. */
3866		next_ip = xfs_iunlink_lookup(pag, next_agino);
3867		if (!next_ip) {
3868			/* No incore inode at all?  We reloaded it... */
3869			ASSERT(next_ip != NULL);
3870			error = -EFSCORRUPTED;
3871			break;
3872		}
3873
3874next_inode:
3875		prev_agino = next_agino;
3876		next_agino = next_ip->i_next_unlinked;
3877	}
3878
3879out_agibp:
3880	xfs_trans_brelse(tp, agibp);
3881	/* Should have found this inode somewhere in the iunlinked bucket. */
3882	if (!error && !foundit)
3883		error = -EFSCORRUPTED;
3884	return error;
3885}
3886
3887/* Decide if this inode is missing its unlinked list and reload it. */
3888int
3889xfs_inode_reload_unlinked(
3890	struct xfs_inode	*ip)
3891{
3892	struct xfs_trans	*tp;
3893	int			error;
3894
3895	error = xfs_trans_alloc_empty(ip->i_mount, &tp);
3896	if (error)
3897		return error;
3898
3899	xfs_ilock(ip, XFS_ILOCK_SHARED);
3900	if (xfs_inode_unlinked_incomplete(ip))
3901		error = xfs_inode_reload_unlinked_bucket(tp, ip);
3902	xfs_iunlock(ip, XFS_ILOCK_SHARED);
3903	xfs_trans_cancel(tp);
3904
3905	return error;
3906}
3907
3908/* Has this inode fork been zapped by repair? */
3909bool
3910xfs_ifork_zapped(
3911	const struct xfs_inode	*ip,
3912	int			whichfork)
3913{
3914	unsigned int		datamask = 0;
3915
3916	switch (whichfork) {
3917	case XFS_DATA_FORK:
3918		switch (ip->i_vnode.i_mode & S_IFMT) {
3919		case S_IFDIR:
3920			datamask = XFS_SICK_INO_DIR_ZAPPED;
3921			break;
3922		case S_IFLNK:
3923			datamask = XFS_SICK_INO_SYMLINK_ZAPPED;
3924			break;
3925		}
3926		return ip->i_sick & (XFS_SICK_INO_BMBTD_ZAPPED | datamask);
3927	case XFS_ATTR_FORK:
3928		return ip->i_sick & XFS_SICK_INO_BMBTA_ZAPPED;
3929	default:
3930		return false;
3931	}
3932}
3933
3934/* Compute the number of data and realtime blocks used by a file. */
3935void
3936xfs_inode_count_blocks(
3937	struct xfs_trans	*tp,
3938	struct xfs_inode	*ip,
3939	xfs_filblks_t		*dblocks,
3940	xfs_filblks_t		*rblocks)
3941{
3942	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, XFS_DATA_FORK);
3943
3944	*rblocks = 0;
3945	if (XFS_IS_REALTIME_INODE(ip))
3946		xfs_bmap_count_leaves(ifp, rblocks);
3947	*dblocks = ip->i_nblocks - *rblocks;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3948}
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include <linux/iversion.h>
   7
   8#include "xfs.h"
   9#include "xfs_fs.h"
  10#include "xfs_shared.h"
  11#include "xfs_format.h"
  12#include "xfs_log_format.h"
  13#include "xfs_trans_resv.h"
  14#include "xfs_mount.h"
  15#include "xfs_defer.h"
  16#include "xfs_inode.h"
  17#include "xfs_dir2.h"
  18#include "xfs_attr.h"
  19#include "xfs_bit.h"
  20#include "xfs_trans_space.h"
  21#include "xfs_trans.h"
  22#include "xfs_buf_item.h"
  23#include "xfs_inode_item.h"
  24#include "xfs_iunlink_item.h"
  25#include "xfs_ialloc.h"
  26#include "xfs_bmap.h"
  27#include "xfs_bmap_util.h"
  28#include "xfs_errortag.h"
  29#include "xfs_error.h"
  30#include "xfs_quota.h"
  31#include "xfs_filestream.h"
  32#include "xfs_trace.h"
  33#include "xfs_icache.h"
  34#include "xfs_symlink.h"
  35#include "xfs_trans_priv.h"
  36#include "xfs_log.h"
  37#include "xfs_bmap_btree.h"
  38#include "xfs_reflink.h"
  39#include "xfs_ag.h"
  40#include "xfs_log_priv.h"
  41#include "xfs_health.h"
  42#include "xfs_pnfs.h"
  43#include "xfs_parent.h"
  44#include "xfs_xattr.h"
  45#include "xfs_inode_util.h"
  46#include "xfs_metafile.h"
  47
  48struct kmem_cache *xfs_inode_cache;
  49
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  50/*
  51 * These two are wrapper routines around the xfs_ilock() routine used to
  52 * centralize some grungy code.  They are used in places that wish to lock the
  53 * inode solely for reading the extents.  The reason these places can't just
  54 * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
  55 * bringing in of the extents from disk for a file in b-tree format.  If the
  56 * inode is in b-tree format, then we need to lock the inode exclusively until
  57 * the extents are read in.  Locking it exclusively all the time would limit
  58 * our parallelism unnecessarily, though.  What we do instead is check to see
  59 * if the extents have been read in yet, and only lock the inode exclusively
  60 * if they have not.
  61 *
  62 * The functions return a value which should be given to the corresponding
  63 * xfs_iunlock() call.
  64 */
  65uint
  66xfs_ilock_data_map_shared(
  67	struct xfs_inode	*ip)
  68{
  69	uint			lock_mode = XFS_ILOCK_SHARED;
  70
  71	if (xfs_need_iread_extents(&ip->i_df))
  72		lock_mode = XFS_ILOCK_EXCL;
  73	xfs_ilock(ip, lock_mode);
  74	return lock_mode;
  75}
  76
  77uint
  78xfs_ilock_attr_map_shared(
  79	struct xfs_inode	*ip)
  80{
  81	uint			lock_mode = XFS_ILOCK_SHARED;
  82
  83	if (xfs_inode_has_attr_fork(ip) && xfs_need_iread_extents(&ip->i_af))
  84		lock_mode = XFS_ILOCK_EXCL;
  85	xfs_ilock(ip, lock_mode);
  86	return lock_mode;
  87}
  88
  89/*
  90 * You can't set both SHARED and EXCL for the same lock,
  91 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_MMAPLOCK_SHARED,
  92 * XFS_MMAPLOCK_EXCL, XFS_ILOCK_SHARED, XFS_ILOCK_EXCL are valid values
  93 * to set in lock_flags.
  94 */
  95static inline void
  96xfs_lock_flags_assert(
  97	uint		lock_flags)
  98{
  99	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 100		(XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 101	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
 102		(XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
 103	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 104		(XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 105	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
 106	ASSERT(lock_flags != 0);
 107}
 108
 109/*
 110 * In addition to i_rwsem in the VFS inode, the xfs inode contains 2
 111 * multi-reader locks: invalidate_lock and the i_lock.  This routine allows
 112 * various combinations of the locks to be obtained.
 113 *
 114 * The 3 locks should always be ordered so that the IO lock is obtained first,
 115 * the mmap lock second and the ilock last in order to prevent deadlock.
 116 *
 117 * Basic locking order:
 118 *
 119 * i_rwsem -> invalidate_lock -> page_lock -> i_ilock
 120 *
 121 * mmap_lock locking order:
 122 *
 123 * i_rwsem -> page lock -> mmap_lock
 124 * mmap_lock -> invalidate_lock -> page_lock
 125 *
 126 * The difference in mmap_lock locking order mean that we cannot hold the
 127 * invalidate_lock over syscall based read(2)/write(2) based IO. These IO paths
 128 * can fault in pages during copy in/out (for buffered IO) or require the
 129 * mmap_lock in get_user_pages() to map the user pages into the kernel address
 130 * space for direct IO. Similarly the i_rwsem cannot be taken inside a page
 131 * fault because page faults already hold the mmap_lock.
 132 *
 133 * Hence to serialise fully against both syscall and mmap based IO, we need to
 134 * take both the i_rwsem and the invalidate_lock. These locks should *only* be
 135 * both taken in places where we need to invalidate the page cache in a race
 136 * free manner (e.g. truncate, hole punch and other extent manipulation
 137 * functions).
 138 */
 139void
 140xfs_ilock(
 141	xfs_inode_t		*ip,
 142	uint			lock_flags)
 143{
 144	trace_xfs_ilock(ip, lock_flags, _RET_IP_);
 145
 146	xfs_lock_flags_assert(lock_flags);
 147
 148	if (lock_flags & XFS_IOLOCK_EXCL) {
 149		down_write_nested(&VFS_I(ip)->i_rwsem,
 150				  XFS_IOLOCK_DEP(lock_flags));
 151	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 152		down_read_nested(&VFS_I(ip)->i_rwsem,
 153				 XFS_IOLOCK_DEP(lock_flags));
 154	}
 155
 156	if (lock_flags & XFS_MMAPLOCK_EXCL) {
 157		down_write_nested(&VFS_I(ip)->i_mapping->invalidate_lock,
 158				  XFS_MMAPLOCK_DEP(lock_flags));
 159	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
 160		down_read_nested(&VFS_I(ip)->i_mapping->invalidate_lock,
 161				 XFS_MMAPLOCK_DEP(lock_flags));
 162	}
 163
 164	if (lock_flags & XFS_ILOCK_EXCL)
 165		down_write_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 166	else if (lock_flags & XFS_ILOCK_SHARED)
 167		down_read_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 168}
 169
 170/*
 171 * This is just like xfs_ilock(), except that the caller
 172 * is guaranteed not to sleep.  It returns 1 if it gets
 173 * the requested locks and 0 otherwise.  If the IO lock is
 174 * obtained but the inode lock cannot be, then the IO lock
 175 * is dropped before returning.
 176 *
 177 * ip -- the inode being locked
 178 * lock_flags -- this parameter indicates the inode's locks to be
 179 *       to be locked.  See the comment for xfs_ilock() for a list
 180 *	 of valid values.
 181 */
 182int
 183xfs_ilock_nowait(
 184	xfs_inode_t		*ip,
 185	uint			lock_flags)
 186{
 187	trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
 188
 189	xfs_lock_flags_assert(lock_flags);
 190
 191	if (lock_flags & XFS_IOLOCK_EXCL) {
 192		if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
 193			goto out;
 194	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 195		if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
 196			goto out;
 197	}
 198
 199	if (lock_flags & XFS_MMAPLOCK_EXCL) {
 200		if (!down_write_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))
 201			goto out_undo_iolock;
 202	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
 203		if (!down_read_trylock(&VFS_I(ip)->i_mapping->invalidate_lock))
 204			goto out_undo_iolock;
 205	}
 206
 207	if (lock_flags & XFS_ILOCK_EXCL) {
 208		if (!down_write_trylock(&ip->i_lock))
 209			goto out_undo_mmaplock;
 210	} else if (lock_flags & XFS_ILOCK_SHARED) {
 211		if (!down_read_trylock(&ip->i_lock))
 212			goto out_undo_mmaplock;
 213	}
 214	return 1;
 215
 216out_undo_mmaplock:
 217	if (lock_flags & XFS_MMAPLOCK_EXCL)
 218		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 219	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 220		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);
 221out_undo_iolock:
 222	if (lock_flags & XFS_IOLOCK_EXCL)
 223		up_write(&VFS_I(ip)->i_rwsem);
 224	else if (lock_flags & XFS_IOLOCK_SHARED)
 225		up_read(&VFS_I(ip)->i_rwsem);
 226out:
 227	return 0;
 228}
 229
 230/*
 231 * xfs_iunlock() is used to drop the inode locks acquired with
 232 * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
 233 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
 234 * that we know which locks to drop.
 235 *
 236 * ip -- the inode being unlocked
 237 * lock_flags -- this parameter indicates the inode's locks to be
 238 *       to be unlocked.  See the comment for xfs_ilock() for a list
 239 *	 of valid values for this parameter.
 240 *
 241 */
 242void
 243xfs_iunlock(
 244	xfs_inode_t		*ip,
 245	uint			lock_flags)
 246{
 247	xfs_lock_flags_assert(lock_flags);
 248
 249	if (lock_flags & XFS_IOLOCK_EXCL)
 250		up_write(&VFS_I(ip)->i_rwsem);
 251	else if (lock_flags & XFS_IOLOCK_SHARED)
 252		up_read(&VFS_I(ip)->i_rwsem);
 253
 254	if (lock_flags & XFS_MMAPLOCK_EXCL)
 255		up_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 256	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 257		up_read(&VFS_I(ip)->i_mapping->invalidate_lock);
 258
 259	if (lock_flags & XFS_ILOCK_EXCL)
 260		up_write(&ip->i_lock);
 261	else if (lock_flags & XFS_ILOCK_SHARED)
 262		up_read(&ip->i_lock);
 263
 264	trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
 265}
 266
 267/*
 268 * give up write locks.  the i/o lock cannot be held nested
 269 * if it is being demoted.
 270 */
 271void
 272xfs_ilock_demote(
 273	xfs_inode_t		*ip,
 274	uint			lock_flags)
 275{
 276	ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
 277	ASSERT((lock_flags &
 278		~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
 279
 280	if (lock_flags & XFS_ILOCK_EXCL)
 281		downgrade_write(&ip->i_lock);
 282	if (lock_flags & XFS_MMAPLOCK_EXCL)
 283		downgrade_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 284	if (lock_flags & XFS_IOLOCK_EXCL)
 285		downgrade_write(&VFS_I(ip)->i_rwsem);
 286
 287	trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
 288}
 289
 290void
 291xfs_assert_ilocked(
 292	struct xfs_inode	*ip,
 293	uint			lock_flags)
 294{
 295	/*
 296	 * Sometimes we assert the ILOCK is held exclusively, but we're in
 297	 * a workqueue, so lockdep doesn't know we're the owner.
 298	 */
 299	if (lock_flags & XFS_ILOCK_SHARED)
 300		rwsem_assert_held(&ip->i_lock);
 301	else if (lock_flags & XFS_ILOCK_EXCL)
 302		rwsem_assert_held_write_nolockdep(&ip->i_lock);
 303
 304	if (lock_flags & XFS_MMAPLOCK_SHARED)
 305		rwsem_assert_held(&VFS_I(ip)->i_mapping->invalidate_lock);
 306	else if (lock_flags & XFS_MMAPLOCK_EXCL)
 307		rwsem_assert_held_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 308
 309	if (lock_flags & XFS_IOLOCK_SHARED)
 310		rwsem_assert_held(&VFS_I(ip)->i_rwsem);
 311	else if (lock_flags & XFS_IOLOCK_EXCL)
 312		rwsem_assert_held_write(&VFS_I(ip)->i_rwsem);
 313}
 314
 315/*
 316 * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
 317 * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
 318 * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
 319 * errors and warnings.
 320 */
 321#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
 322static bool
 323xfs_lockdep_subclass_ok(
 324	int subclass)
 325{
 326	return subclass < MAX_LOCKDEP_SUBCLASSES;
 327}
 328#else
 329#define xfs_lockdep_subclass_ok(subclass)	(true)
 330#endif
 331
 332/*
 333 * Bump the subclass so xfs_lock_inodes() acquires each lock with a different
 334 * value. This can be called for any type of inode lock combination, including
 335 * parent locking. Care must be taken to ensure we don't overrun the subclass
 336 * storage fields in the class mask we build.
 337 */
 338static inline uint
 339xfs_lock_inumorder(
 340	uint	lock_mode,
 341	uint	subclass)
 342{
 343	uint	class = 0;
 344
 345	ASSERT(!(lock_mode & XFS_ILOCK_PARENT));
 
 346	ASSERT(xfs_lockdep_subclass_ok(subclass));
 347
 348	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
 349		ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
 350		class += subclass << XFS_IOLOCK_SHIFT;
 351	}
 352
 353	if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
 354		ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
 355		class += subclass << XFS_MMAPLOCK_SHIFT;
 356	}
 357
 358	if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
 359		ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
 360		class += subclass << XFS_ILOCK_SHIFT;
 361	}
 362
 363	return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
 364}
 365
 366/*
 367 * The following routine will lock n inodes in exclusive mode.  We assume the
 368 * caller calls us with the inodes in i_ino order.
 369 *
 370 * We need to detect deadlock where an inode that we lock is in the AIL and we
 371 * start waiting for another inode that is locked by a thread in a long running
 372 * transaction (such as truncate). This can result in deadlock since the long
 373 * running trans might need to wait for the inode we just locked in order to
 374 * push the tail and free space in the log.
 375 *
 376 * xfs_lock_inodes() can only be used to lock one type of lock at a time -
 377 * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
 378 * lock more than one at a time, lockdep will report false positives saying we
 379 * have violated locking orders.
 380 */
 381void
 382xfs_lock_inodes(
 383	struct xfs_inode	**ips,
 384	int			inodes,
 385	uint			lock_mode)
 386{
 387	int			attempts = 0;
 388	uint			i;
 389	int			j;
 390	bool			try_lock;
 391	struct xfs_log_item	*lp;
 392
 393	/*
 394	 * Currently supports between 2 and 5 inodes with exclusive locking.  We
 395	 * support an arbitrary depth of locking here, but absolute limits on
 396	 * inodes depend on the type of locking and the limits placed by
 397	 * lockdep annotations in xfs_lock_inumorder.  These are all checked by
 398	 * the asserts.
 399	 */
 400	ASSERT(ips && inodes >= 2 && inodes <= 5);
 401	ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
 402			    XFS_ILOCK_EXCL));
 403	ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
 404			      XFS_ILOCK_SHARED)));
 405	ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
 406		inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
 407	ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
 408		inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
 409
 410	if (lock_mode & XFS_IOLOCK_EXCL) {
 411		ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
 412	} else if (lock_mode & XFS_MMAPLOCK_EXCL)
 413		ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
 414
 415again:
 416	try_lock = false;
 417	i = 0;
 418	for (; i < inodes; i++) {
 419		ASSERT(ips[i]);
 420
 421		if (i && (ips[i] == ips[i - 1]))	/* Already locked */
 422			continue;
 423
 424		/*
 425		 * If try_lock is not set yet, make sure all locked inodes are
 426		 * not in the AIL.  If any are, set try_lock to be used later.
 427		 */
 428		if (!try_lock) {
 429			for (j = (i - 1); j >= 0 && !try_lock; j--) {
 430				lp = &ips[j]->i_itemp->ili_item;
 431				if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))
 432					try_lock = true;
 433			}
 434		}
 435
 436		/*
 437		 * If any of the previous locks we have locked is in the AIL,
 438		 * we must TRY to get the second and subsequent locks. If
 439		 * we can't get any, we must release all we have
 440		 * and try again.
 441		 */
 442		if (!try_lock) {
 443			xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
 444			continue;
 445		}
 446
 447		/* try_lock means we have an inode locked that is in the AIL. */
 448		ASSERT(i != 0);
 449		if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
 450			continue;
 451
 452		/*
 453		 * Unlock all previous guys and try again.  xfs_iunlock will try
 454		 * to push the tail if the inode is in the AIL.
 455		 */
 456		attempts++;
 457		for (j = i - 1; j >= 0; j--) {
 458			/*
 459			 * Check to see if we've already unlocked this one.  Not
 460			 * the first one going back, and the inode ptr is the
 461			 * same.
 462			 */
 463			if (j != (i - 1) && ips[j] == ips[j + 1])
 464				continue;
 465
 466			xfs_iunlock(ips[j], lock_mode);
 467		}
 468
 469		if ((attempts % 5) == 0) {
 470			delay(1); /* Don't just spin the CPU */
 471		}
 472		goto again;
 473	}
 474}
 475
 476/*
 477 * xfs_lock_two_inodes() can only be used to lock ilock. The iolock and
 478 * mmaplock must be double-locked separately since we use i_rwsem and
 479 * invalidate_lock for that. We now support taking one lock EXCL and the
 480 * other SHARED.
 481 */
 482void
 483xfs_lock_two_inodes(
 484	struct xfs_inode	*ip0,
 485	uint			ip0_mode,
 486	struct xfs_inode	*ip1,
 487	uint			ip1_mode)
 488{
 489	int			attempts = 0;
 490	struct xfs_log_item	*lp;
 491
 492	ASSERT(hweight32(ip0_mode) == 1);
 493	ASSERT(hweight32(ip1_mode) == 1);
 494	ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 495	ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 496	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)));
 497	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)));
 498	ASSERT(ip0->i_ino != ip1->i_ino);
 499
 500	if (ip0->i_ino > ip1->i_ino) {
 501		swap(ip0, ip1);
 502		swap(ip0_mode, ip1_mode);
 503	}
 504
 505 again:
 506	xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
 507
 508	/*
 509	 * If the first lock we have locked is in the AIL, we must TRY to get
 510	 * the second lock. If we can't get it, we must release the first one
 511	 * and try again.
 512	 */
 513	lp = &ip0->i_itemp->ili_item;
 514	if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {
 515		if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
 516			xfs_iunlock(ip0, ip0_mode);
 517			if ((++attempts % 5) == 0)
 518				delay(1); /* Don't just spin the CPU */
 519			goto again;
 520		}
 521	} else {
 522		xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
 523	}
 524}
 525
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 526/*
 527 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
 528 * is allowed, otherwise it has to be an exact match. If a CI match is found,
 529 * ci_name->name will point to a the actual name (caller must free) or
 530 * will be set to NULL if an exact match is found.
 531 */
 532int
 533xfs_lookup(
 534	struct xfs_inode	*dp,
 535	const struct xfs_name	*name,
 536	struct xfs_inode	**ipp,
 537	struct xfs_name		*ci_name)
 538{
 539	xfs_ino_t		inum;
 540	int			error;
 541
 542	trace_xfs_lookup(dp, name);
 543
 544	if (xfs_is_shutdown(dp->i_mount))
 545		return -EIO;
 546	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
 547		return -EIO;
 548
 549	error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
 550	if (error)
 551		goto out_unlock;
 552
 553	error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
 554	if (error)
 555		goto out_free_name;
 556
 557	/*
 558	 * Fail if a directory entry in the regular directory tree points to
 559	 * a metadata file.
 560	 */
 561	if (XFS_IS_CORRUPT(dp->i_mount, xfs_is_metadir_inode(*ipp))) {
 562		xfs_fs_mark_sick(dp->i_mount, XFS_SICK_FS_METADIR);
 563		error = -EFSCORRUPTED;
 564		goto out_irele;
 565	}
 566
 567	return 0;
 568
 569out_irele:
 570	xfs_irele(*ipp);
 571out_free_name:
 572	if (ci_name)
 573		kfree(ci_name->name);
 574out_unlock:
 575	*ipp = NULL;
 576	return error;
 577}
 578
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 579/*
 580 * Initialise a newly allocated inode and return the in-core inode to the
 581 * caller locked exclusively.
 582 *
 583 * Caller is responsible for unlocking the inode manually upon return
 584 */
 585int
 586xfs_icreate(
 
 587	struct xfs_trans	*tp,
 
 588	xfs_ino_t		ino,
 589	const struct xfs_icreate_args *args,
 
 
 
 
 590	struct xfs_inode	**ipp)
 591{
 
 592	struct xfs_mount	*mp = tp->t_mountp;
 593	struct xfs_inode	*ip = NULL;
 
 594	int			error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 595
 596	/*
 597	 * Get the in-core inode with the lock held exclusively to prevent
 598	 * others from looking at until we're done.
 599	 */
 600	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
 601	if (error)
 602		return error;
 603
 604	ASSERT(ip != NULL);
 605	xfs_trans_ijoin(tp, ip, 0);
 606	xfs_inode_init(tp, args, ip);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 607
 608	/* now that we have an i_mode we can setup the inode structure */
 609	xfs_setup_inode(ip);
 610
 611	*ipp = ip;
 612	return 0;
 613}
 614
 615/* Return dquots for the ids that will be assigned to a new file. */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 616int
 617xfs_icreate_dqalloc(
 618	const struct xfs_icreate_args	*args,
 619	struct xfs_dquot		**udqpp,
 620	struct xfs_dquot		**gdqpp,
 621	struct xfs_dquot		**pdqpp)
 622{
 623	struct inode			*dir = VFS_I(args->pip);
 624	kuid_t				uid = GLOBAL_ROOT_UID;
 625	kgid_t				gid = GLOBAL_ROOT_GID;
 626	prid_t				prid = 0;
 627	unsigned int			flags = XFS_QMOPT_QUOTALL;
 628
 629	if (args->idmap) {
 630		/*
 631		 * The uid/gid computation code must match what the VFS uses to
 632		 * assign i_[ug]id.  INHERIT adjusts the gid computation for
 633		 * setgid/grpid systems.
 634		 */
 635		uid = mapped_fsuid(args->idmap, i_user_ns(dir));
 636		gid = mapped_fsgid(args->idmap, i_user_ns(dir));
 637		prid = xfs_get_initial_prid(args->pip);
 638		flags |= XFS_QMOPT_INHERIT;
 639	}
 640
 641	*udqpp = *gdqpp = *pdqpp = NULL;
 
 
 
 
 
 
 
 642
 643	return xfs_qm_vop_dqalloc(args->pip, uid, gid, prid, flags, udqpp,
 644			gdqpp, pdqpp);
 
 
 
 
 
 645}
 
 646
 647int
 648xfs_create(
 649	const struct xfs_icreate_args *args,
 
 650	struct xfs_name		*name,
 651	struct xfs_inode	**ipp)
 
 
 
 652{
 653	struct xfs_inode	*dp = args->pip;
 654	struct xfs_dir_update	du = {
 655		.dp		= dp,
 656		.name		= name,
 657	};
 658	struct xfs_mount	*mp = dp->i_mount;
 
 659	struct xfs_trans	*tp = NULL;
 660	struct xfs_dquot	*udqp;
 661	struct xfs_dquot	*gdqp;
 662	struct xfs_dquot	*pdqp;
 
 
 
 663	struct xfs_trans_res	*tres;
 
 664	xfs_ino_t		ino;
 665	bool			unlock_dp_on_error = false;
 666	bool			is_dir = S_ISDIR(args->mode);
 667	uint			resblks;
 668	int			error;
 669
 670	trace_xfs_create(dp, name);
 671
 672	if (xfs_is_shutdown(mp))
 673		return -EIO;
 674	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
 675		return -EIO;
 676
 677	/* Make sure that we have allocated dquot(s) on disk. */
 678	error = xfs_icreate_dqalloc(args, &udqp, &gdqp, &pdqp);
 
 
 
 
 
 
 
 679	if (error)
 680		return error;
 681
 682	if (is_dir) {
 683		resblks = xfs_mkdir_space_res(mp, name->len);
 684		tres = &M_RES(mp)->tr_mkdir;
 685	} else {
 686		resblks = xfs_create_space_res(mp, name->len);
 687		tres = &M_RES(mp)->tr_create;
 688	}
 689
 690	error = xfs_parent_start(mp, &du.ppargs);
 691	if (error)
 692		goto out_release_dquots;
 693
 694	/*
 695	 * Initially assume that the file does not exist and
 696	 * reserve the resources for that case.  If that is not
 697	 * the case we'll drop the one we have and get a more
 698	 * appropriate transaction later.
 699	 */
 700	error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
 701			&tp);
 702	if (error == -ENOSPC) {
 703		/* flush outstanding delalloc blocks and retry */
 704		xfs_flush_inodes(mp);
 705		error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp,
 706				resblks, &tp);
 707	}
 708	if (error)
 709		goto out_parent;
 710
 711	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
 712	unlock_dp_on_error = true;
 713
 714	/*
 715	 * A newly created regular or special file just has one directory
 716	 * entry pointing to them, but a directory also the "." entry
 717	 * pointing to itself.
 718	 */
 719	error = xfs_dialloc(&tp, args, &ino);
 720	if (!error)
 721		error = xfs_icreate(tp, ino, args, &du.ip);
 
 722	if (error)
 723		goto out_trans_cancel;
 724
 725	/*
 726	 * Now we join the directory inode to the transaction.  We do not do it
 727	 * earlier because xfs_dialloc might commit the previous transaction
 728	 * (and release all the locks).  An error from here on will result in
 729	 * the transaction cancel unlocking dp so don't do it explicitly in the
 730	 * error path.
 731	 */
 732	xfs_trans_ijoin(tp, dp, 0);
 
 733
 734	error = xfs_dir_create_child(tp, resblks, &du);
 735	if (error)
 
 
 736		goto out_trans_cancel;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 737
 738	/*
 739	 * If this is a synchronous mount, make sure that the
 740	 * create transaction goes to disk before returning to
 741	 * the user.
 742	 */
 743	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
 744		xfs_trans_set_sync(tp);
 745
 746	/*
 747	 * Attach the dquot(s) to the inodes and modify them incore.
 748	 * These ids of the inode couldn't have changed since the new
 749	 * inode has been locked ever since it was created.
 750	 */
 751	xfs_qm_vop_create_dqattach(tp, du.ip, udqp, gdqp, pdqp);
 752
 753	error = xfs_trans_commit(tp);
 754	if (error)
 755		goto out_release_inode;
 756
 757	xfs_qm_dqrele(udqp);
 758	xfs_qm_dqrele(gdqp);
 759	xfs_qm_dqrele(pdqp);
 760
 761	*ipp = du.ip;
 762	xfs_iunlock(du.ip, XFS_ILOCK_EXCL);
 763	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 764	xfs_parent_finish(mp, du.ppargs);
 765	return 0;
 766
 767 out_trans_cancel:
 768	xfs_trans_cancel(tp);
 769 out_release_inode:
 770	/*
 771	 * Wait until after the current transaction is aborted to finish the
 772	 * setup of the inode and release the inode.  This prevents recursive
 773	 * transactions and deadlocks from xfs_inactive.
 774	 */
 775	if (du.ip) {
 776		xfs_iunlock(du.ip, XFS_ILOCK_EXCL);
 777		xfs_finish_inode_setup(du.ip);
 778		xfs_irele(du.ip);
 779	}
 780 out_parent:
 781	xfs_parent_finish(mp, du.ppargs);
 782 out_release_dquots:
 783	xfs_qm_dqrele(udqp);
 784	xfs_qm_dqrele(gdqp);
 785	xfs_qm_dqrele(pdqp);
 786
 787	if (unlock_dp_on_error)
 788		xfs_iunlock(dp, XFS_ILOCK_EXCL);
 789	return error;
 790}
 791
 792int
 793xfs_create_tmpfile(
 794	const struct xfs_icreate_args *args,
 
 
 795	struct xfs_inode	**ipp)
 796{
 797	struct xfs_inode	*dp = args->pip;
 798	struct xfs_mount	*mp = dp->i_mount;
 799	struct xfs_inode	*ip = NULL;
 800	struct xfs_trans	*tp = NULL;
 801	struct xfs_dquot	*udqp;
 802	struct xfs_dquot	*gdqp;
 803	struct xfs_dquot	*pdqp;
 
 
 804	struct xfs_trans_res	*tres;
 
 805	xfs_ino_t		ino;
 806	uint			resblks;
 807	int			error;
 808
 809	ASSERT(args->flags & XFS_ICREATE_TMPFILE);
 810
 811	if (xfs_is_shutdown(mp))
 812		return -EIO;
 813
 814	/* Make sure that we have allocated dquot(s) on disk. */
 815	error = xfs_icreate_dqalloc(args, &udqp, &gdqp, &pdqp);
 
 
 
 
 
 
 
 816	if (error)
 817		return error;
 818
 819	resblks = XFS_IALLOC_SPACE_RES(mp);
 820	tres = &M_RES(mp)->tr_create_tmpfile;
 821
 822	error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
 823			&tp);
 824	if (error)
 825		goto out_release_dquots;
 826
 827	error = xfs_dialloc(&tp, args, &ino);
 828	if (!error)
 829		error = xfs_icreate(tp, ino, args, &ip);
 
 830	if (error)
 831		goto out_trans_cancel;
 832
 833	if (xfs_has_wsync(mp))
 834		xfs_trans_set_sync(tp);
 835
 836	/*
 837	 * Attach the dquot(s) to the inodes and modify them incore.
 838	 * These ids of the inode couldn't have changed since the new
 839	 * inode has been locked ever since it was created.
 840	 */
 841	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
 842
 843	error = xfs_iunlink(tp, ip);
 844	if (error)
 845		goto out_trans_cancel;
 846
 847	error = xfs_trans_commit(tp);
 848	if (error)
 849		goto out_release_inode;
 850
 851	xfs_qm_dqrele(udqp);
 852	xfs_qm_dqrele(gdqp);
 853	xfs_qm_dqrele(pdqp);
 854
 855	*ipp = ip;
 856	xfs_iunlock(ip, XFS_ILOCK_EXCL);
 857	return 0;
 858
 859 out_trans_cancel:
 860	xfs_trans_cancel(tp);
 861 out_release_inode:
 862	/*
 863	 * Wait until after the current transaction is aborted to finish the
 864	 * setup of the inode and release the inode.  This prevents recursive
 865	 * transactions and deadlocks from xfs_inactive.
 866	 */
 867	if (ip) {
 868		xfs_iunlock(ip, XFS_ILOCK_EXCL);
 869		xfs_finish_inode_setup(ip);
 870		xfs_irele(ip);
 871	}
 872 out_release_dquots:
 873	xfs_qm_dqrele(udqp);
 874	xfs_qm_dqrele(gdqp);
 875	xfs_qm_dqrele(pdqp);
 876
 877	return error;
 878}
 879
 880int
 881xfs_link(
 882	struct xfs_inode	*tdp,
 883	struct xfs_inode	*sip,
 884	struct xfs_name		*target_name)
 885{
 886	struct xfs_dir_update	du = {
 887		.dp		= tdp,
 888		.name		= target_name,
 889		.ip		= sip,
 890	};
 891	struct xfs_mount	*mp = tdp->i_mount;
 892	struct xfs_trans	*tp;
 893	int			error, nospace_error = 0;
 894	int			resblks;
 895
 896	trace_xfs_link(tdp, target_name);
 897
 898	ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
 899
 900	if (xfs_is_shutdown(mp))
 901		return -EIO;
 902	if (xfs_ifork_zapped(tdp, XFS_DATA_FORK))
 903		return -EIO;
 904
 905	error = xfs_qm_dqattach(sip);
 906	if (error)
 907		goto std_return;
 908
 909	error = xfs_qm_dqattach(tdp);
 910	if (error)
 911		goto std_return;
 912
 913	error = xfs_parent_start(mp, &du.ppargs);
 914	if (error)
 915		goto std_return;
 916
 917	resblks = xfs_link_space_res(mp, target_name->len);
 918	error = xfs_trans_alloc_dir(tdp, &M_RES(mp)->tr_link, sip, &resblks,
 919			&tp, &nospace_error);
 920	if (error)
 921		goto out_parent;
 922
 923	/*
 924	 * We don't allow reservationless or quotaless hardlinking when parent
 925	 * pointers are enabled because we can't back out if the xattrs must
 926	 * grow.
 927	 */
 928	if (du.ppargs && nospace_error) {
 929		error = nospace_error;
 930		goto error_return;
 931	}
 932
 933	/*
 934	 * If we are using project inheritance, we only allow hard link
 935	 * creation in our tree when the project IDs are the same; else
 936	 * the tree quota mechanism could be circumvented.
 937	 */
 938	if (unlikely((tdp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
 939		     tdp->i_projid != sip->i_projid)) {
 940		/*
 941		 * Project quota setup skips special files which can
 942		 * leave inodes in a PROJINHERIT directory without a
 943		 * project ID set. We need to allow links to be made
 944		 * to these "project-less" inodes because userspace
 945		 * expects them to succeed after project ID setup,
 946		 * but everything else should be rejected.
 947		 */
 948		if (!special_file(VFS_I(sip)->i_mode) ||
 949		    sip->i_projid != 0) {
 950			error = -EXDEV;
 951			goto error_return;
 952		}
 953	}
 954
 955	error = xfs_dir_add_child(tp, resblks, &du);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 956	if (error)
 957		goto error_return;
 
 
 
 
 
 958
 959	/*
 960	 * If this is a synchronous mount, make sure that the
 961	 * link transaction goes to disk before returning to
 962	 * the user.
 963	 */
 964	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
 965		xfs_trans_set_sync(tp);
 966
 967	error = xfs_trans_commit(tp);
 968	xfs_iunlock(tdp, XFS_ILOCK_EXCL);
 969	xfs_iunlock(sip, XFS_ILOCK_EXCL);
 970	xfs_parent_finish(mp, du.ppargs);
 971	return error;
 972
 973 error_return:
 974	xfs_trans_cancel(tp);
 975	xfs_iunlock(tdp, XFS_ILOCK_EXCL);
 976	xfs_iunlock(sip, XFS_ILOCK_EXCL);
 977 out_parent:
 978	xfs_parent_finish(mp, du.ppargs);
 979 std_return:
 980	if (error == -ENOSPC && nospace_error)
 981		error = nospace_error;
 982	return error;
 983}
 984
 985/* Clear the reflink flag and the cowblocks tag if possible. */
 986static void
 987xfs_itruncate_clear_reflink_flags(
 988	struct xfs_inode	*ip)
 989{
 990	struct xfs_ifork	*dfork;
 991	struct xfs_ifork	*cfork;
 992
 993	if (!xfs_is_reflink_inode(ip))
 994		return;
 995	dfork = xfs_ifork_ptr(ip, XFS_DATA_FORK);
 996	cfork = xfs_ifork_ptr(ip, XFS_COW_FORK);
 997	if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
 998		ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
 999	if (cfork->if_bytes == 0)
1000		xfs_inode_clear_cowblocks_tag(ip);
1001}
1002
1003/*
1004 * Free up the underlying blocks past new_size.  The new size must be smaller
1005 * than the current size.  This routine can be used both for the attribute and
1006 * data fork, and does not modify the inode size, which is left to the caller.
1007 *
1008 * The transaction passed to this routine must have made a permanent log
1009 * reservation of at least XFS_ITRUNCATE_LOG_RES.  This routine may commit the
1010 * given transaction and start new ones, so make sure everything involved in
1011 * the transaction is tidy before calling here.  Some transaction will be
1012 * returned to the caller to be committed.  The incoming transaction must
1013 * already include the inode, and both inode locks must be held exclusively.
1014 * The inode must also be "held" within the transaction.  On return the inode
1015 * will be "held" within the returned transaction.  This routine does NOT
1016 * require any disk space to be reserved for it within the transaction.
1017 *
1018 * If we get an error, we must return with the inode locked and linked into the
1019 * current transaction. This keeps things simple for the higher level code,
1020 * because it always knows that the inode is locked and held in the transaction
1021 * that returns to it whether errors occur or not.  We don't mark the inode
1022 * dirty on error so that transactions can be easily aborted if possible.
1023 */
1024int
1025xfs_itruncate_extents_flags(
1026	struct xfs_trans	**tpp,
1027	struct xfs_inode	*ip,
1028	int			whichfork,
1029	xfs_fsize_t		new_size,
1030	int			flags)
1031{
1032	struct xfs_mount	*mp = ip->i_mount;
1033	struct xfs_trans	*tp = *tpp;
1034	xfs_fileoff_t		first_unmap_block;
1035	int			error = 0;
1036
1037	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1038	if (atomic_read(&VFS_I(ip)->i_count))
1039		xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
1040	ASSERT(new_size <= XFS_ISIZE(ip));
1041	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1042	ASSERT(ip->i_itemp != NULL);
1043	ASSERT(ip->i_itemp->ili_lock_flags == 0);
1044	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1045
1046	trace_xfs_itruncate_extents_start(ip, new_size);
1047
1048	flags |= xfs_bmapi_aflag(whichfork);
1049
1050	/*
1051	 * Since it is possible for space to become allocated beyond
1052	 * the end of the file (in a crash where the space is allocated
1053	 * but the inode size is not yet updated), simply remove any
1054	 * blocks which show up between the new EOF and the maximum
1055	 * possible file size.
1056	 *
1057	 * We have to free all the blocks to the bmbt maximum offset, even if
1058	 * the page cache can't scale that far.
1059	 */
1060	first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1061	if (!xfs_verify_fileoff(mp, first_unmap_block)) {
1062		WARN_ON_ONCE(first_unmap_block > XFS_MAX_FILEOFF);
1063		return 0;
1064	}
1065
1066	error = xfs_bunmapi_range(&tp, ip, flags, first_unmap_block,
1067			XFS_MAX_FILEOFF);
1068	if (error)
1069		goto out;
1070
1071	if (whichfork == XFS_DATA_FORK) {
1072		/* Remove all pending CoW reservations. */
1073		error = xfs_reflink_cancel_cow_blocks(ip, &tp,
1074				first_unmap_block, XFS_MAX_FILEOFF, true);
1075		if (error)
1076			goto out;
1077
1078		xfs_itruncate_clear_reflink_flags(ip);
1079	}
1080
1081	/*
1082	 * Always re-log the inode so that our permanent transaction can keep
1083	 * on rolling it forward in the log.
1084	 */
1085	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1086
1087	trace_xfs_itruncate_extents_end(ip, new_size);
1088
1089out:
1090	*tpp = tp;
1091	return error;
1092}
1093
1094/*
1095 * Mark all the buffers attached to this directory stale.  In theory we should
1096 * never be freeing a directory with any blocks at all, but this covers the
1097 * case where we've recovered a directory swap with a "temporary" directory
1098 * created by online repair and now need to dump it.
1099 */
1100STATIC void
1101xfs_inactive_dir(
1102	struct xfs_inode	*dp)
1103{
1104	struct xfs_iext_cursor	icur;
1105	struct xfs_bmbt_irec	got;
1106	struct xfs_mount	*mp = dp->i_mount;
1107	struct xfs_da_geometry	*geo = mp->m_dir_geo;
1108	struct xfs_ifork	*ifp = xfs_ifork_ptr(dp, XFS_DATA_FORK);
1109	xfs_fileoff_t		off;
1110
1111	/*
1112	 * Invalidate each directory block.  All directory blocks are of
1113	 * fsbcount length and alignment, so we only need to walk those same
1114	 * offsets.  We hold the only reference to this inode, so we must wait
1115	 * for the buffer locks.
1116	 */
1117	for_each_xfs_iext(ifp, &icur, &got) {
1118		for (off = round_up(got.br_startoff, geo->fsbcount);
1119		     off < got.br_startoff + got.br_blockcount;
1120		     off += geo->fsbcount) {
1121			struct xfs_buf	*bp = NULL;
1122			xfs_fsblock_t	fsbno;
1123			int		error;
1124
1125			fsbno = (off - got.br_startoff) + got.br_startblock;
1126			error = xfs_buf_incore(mp->m_ddev_targp,
1127					XFS_FSB_TO_DADDR(mp, fsbno),
1128					XFS_FSB_TO_BB(mp, geo->fsbcount),
1129					XBF_LIVESCAN, &bp);
1130			if (error)
1131				continue;
1132
1133			xfs_buf_stale(bp);
1134			xfs_buf_relse(bp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1135		}
1136	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1137}
1138
1139/*
1140 * xfs_inactive_truncate
1141 *
1142 * Called to perform a truncate when an inode becomes unlinked.
1143 */
1144STATIC int
1145xfs_inactive_truncate(
1146	struct xfs_inode *ip)
1147{
1148	struct xfs_mount	*mp = ip->i_mount;
1149	struct xfs_trans	*tp;
1150	int			error;
1151
1152	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
1153	if (error) {
1154		ASSERT(xfs_is_shutdown(mp));
1155		return error;
1156	}
1157	xfs_ilock(ip, XFS_ILOCK_EXCL);
1158	xfs_trans_ijoin(tp, ip, 0);
1159
1160	/*
1161	 * Log the inode size first to prevent stale data exposure in the event
1162	 * of a system crash before the truncate completes. See the related
1163	 * comment in xfs_vn_setattr_size() for details.
1164	 */
1165	ip->i_disk_size = 0;
1166	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1167
1168	error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1169	if (error)
1170		goto error_trans_cancel;
1171
1172	ASSERT(ip->i_df.if_nextents == 0);
1173
1174	error = xfs_trans_commit(tp);
1175	if (error)
1176		goto error_unlock;
1177
1178	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1179	return 0;
1180
1181error_trans_cancel:
1182	xfs_trans_cancel(tp);
1183error_unlock:
1184	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1185	return error;
1186}
1187
1188/*
1189 * xfs_inactive_ifree()
1190 *
1191 * Perform the inode free when an inode is unlinked.
1192 */
1193STATIC int
1194xfs_inactive_ifree(
1195	struct xfs_inode *ip)
1196{
1197	struct xfs_mount	*mp = ip->i_mount;
1198	struct xfs_trans	*tp;
1199	int			error;
1200
1201	/*
1202	 * We try to use a per-AG reservation for any block needed by the finobt
1203	 * tree, but as the finobt feature predates the per-AG reservation
1204	 * support a degraded file system might not have enough space for the
1205	 * reservation at mount time.  In that case try to dip into the reserved
1206	 * pool and pray.
1207	 *
1208	 * Send a warning if the reservation does happen to fail, as the inode
1209	 * now remains allocated and sits on the unlinked list until the fs is
1210	 * repaired.
1211	 */
1212	if (unlikely(mp->m_finobt_nores)) {
1213		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1214				XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
1215				&tp);
1216	} else {
1217		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
1218	}
1219	if (error) {
1220		if (error == -ENOSPC) {
1221			xfs_warn_ratelimited(mp,
1222			"Failed to remove inode(s) from unlinked list. "
1223			"Please free space, unmount and run xfs_repair.");
1224		} else {
1225			ASSERT(xfs_is_shutdown(mp));
1226		}
1227		return error;
1228	}
1229
1230	/*
1231	 * We do not hold the inode locked across the entire rolling transaction
1232	 * here. We only need to hold it for the first transaction that
1233	 * xfs_ifree() builds, which may mark the inode XFS_ISTALE if the
1234	 * underlying cluster buffer is freed. Relogging an XFS_ISTALE inode
1235	 * here breaks the relationship between cluster buffer invalidation and
1236	 * stale inode invalidation on cluster buffer item journal commit
1237	 * completion, and can result in leaving dirty stale inodes hanging
1238	 * around in memory.
1239	 *
1240	 * We have no need for serialising this inode operation against other
1241	 * operations - we freed the inode and hence reallocation is required
1242	 * and that will serialise on reallocating the space the deferops need
1243	 * to free. Hence we can unlock the inode on the first commit of
1244	 * the transaction rather than roll it right through the deferops. This
1245	 * avoids relogging the XFS_ISTALE inode.
1246	 *
1247	 * We check that xfs_ifree() hasn't grown an internal transaction roll
1248	 * by asserting that the inode is still locked when it returns.
1249	 */
1250	xfs_ilock(ip, XFS_ILOCK_EXCL);
1251	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1252
1253	error = xfs_ifree(tp, ip);
1254	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1255	if (error) {
1256		/*
1257		 * If we fail to free the inode, shut down.  The cancel
1258		 * might do that, we need to make sure.  Otherwise the
1259		 * inode might be lost for a long time or forever.
1260		 */
1261		if (!xfs_is_shutdown(mp)) {
1262			xfs_notice(mp, "%s: xfs_ifree returned error %d",
1263				__func__, error);
1264			xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1265		}
1266		xfs_trans_cancel(tp);
1267		return error;
1268	}
1269
1270	/*
1271	 * Credit the quota account(s). The inode is gone.
1272	 */
1273	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1274
1275	return xfs_trans_commit(tp);
1276}
1277
1278/*
1279 * Returns true if we need to update the on-disk metadata before we can free
1280 * the memory used by this inode.  Updates include freeing post-eof
1281 * preallocations; freeing COW staging extents; and marking the inode free in
1282 * the inobt if it is on the unlinked list.
1283 */
1284bool
1285xfs_inode_needs_inactive(
1286	struct xfs_inode	*ip)
1287{
1288	struct xfs_mount	*mp = ip->i_mount;
1289	struct xfs_ifork	*cow_ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
1290
1291	/*
1292	 * If the inode is already free, then there can be nothing
1293	 * to clean up here.
1294	 */
1295	if (VFS_I(ip)->i_mode == 0)
1296		return false;
1297
1298	/*
1299	 * If this is a read-only mount, don't do this (would generate I/O)
1300	 * unless we're in log recovery and cleaning the iunlinked list.
1301	 */
1302	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1303		return false;
1304
1305	/* If the log isn't running, push inodes straight to reclaim. */
1306	if (xfs_is_shutdown(mp) || xfs_has_norecovery(mp))
1307		return false;
1308
1309	/* Metadata inodes require explicit resource cleanup. */
1310	if (xfs_is_internal_inode(ip))
1311		return false;
1312
1313	/* Want to clean out the cow blocks if there are any. */
1314	if (cow_ifp && cow_ifp->if_bytes > 0)
1315		return true;
1316
1317	/* Unlinked files must be freed. */
1318	if (VFS_I(ip)->i_nlink == 0)
1319		return true;
1320
1321	/*
1322	 * This file isn't being freed, so check if there are post-eof blocks
1323	 * to free.
 
 
1324	 *
1325	 * Note: don't bother with iolock here since lockdep complains about
1326	 * acquiring it in reclaim context. We have the only reference to the
1327	 * inode at this point anyways.
1328	 */
1329	return xfs_can_free_eofblocks(ip);
1330}
1331
1332/*
1333 * Save health status somewhere, if we're dumping an inode with uncorrected
1334 * errors and online repair isn't running.
1335 */
1336static inline void
1337xfs_inactive_health(
1338	struct xfs_inode	*ip)
1339{
1340	struct xfs_mount	*mp = ip->i_mount;
1341	struct xfs_perag	*pag;
1342	unsigned int		sick;
1343	unsigned int		checked;
1344
1345	xfs_inode_measure_sickness(ip, &sick, &checked);
1346	if (!sick)
1347		return;
1348
1349	trace_xfs_inode_unfixed_corruption(ip, sick);
1350
1351	if (sick & XFS_SICK_INO_FORGET)
1352		return;
1353
1354	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1355	if (!pag) {
1356		/* There had better still be a perag structure! */
1357		ASSERT(0);
1358		return;
1359	}
1360
1361	xfs_ag_mark_sick(pag, XFS_SICK_AG_INODES);
1362	xfs_perag_put(pag);
1363}
1364
1365/*
1366 * xfs_inactive
1367 *
1368 * This is called when the vnode reference count for the vnode
1369 * goes to zero.  If the file has been unlinked, then it must
1370 * now be truncated.  Also, we clear all of the read-ahead state
1371 * kept for the inode here since the file is now closed.
1372 */
1373int
1374xfs_inactive(
1375	xfs_inode_t	*ip)
1376{
1377	struct xfs_mount	*mp;
1378	int			error = 0;
1379	int			truncate = 0;
1380
1381	/*
1382	 * If the inode is already free, then there can be nothing
1383	 * to clean up here.
1384	 */
1385	if (VFS_I(ip)->i_mode == 0) {
1386		ASSERT(ip->i_df.if_broot_bytes == 0);
1387		goto out;
1388	}
1389
1390	mp = ip->i_mount;
1391	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1392
1393	xfs_inactive_health(ip);
1394
1395	/*
1396	 * If this is a read-only mount, don't do this (would generate I/O)
1397	 * unless we're in log recovery and cleaning the iunlinked list.
1398	 */
1399	if (xfs_is_readonly(mp) && !xlog_recovery_needed(mp->m_log))
1400		goto out;
1401
1402	/* Metadata inodes require explicit resource cleanup. */
1403	if (xfs_is_internal_inode(ip))
1404		goto out;
1405
1406	/* Try to clean out the cow blocks if there are any. */
1407	if (xfs_inode_has_cow_data(ip)) {
1408		error = xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
1409		if (error)
1410			goto out;
1411	}
1412
1413	if (VFS_I(ip)->i_nlink != 0) {
1414		/*
 
 
 
 
1415		 * Note: don't bother with iolock here since lockdep complains
1416		 * about acquiring it in reclaim context. We have the only
1417		 * reference to the inode at this point anyways.
1418		 */
1419		if (xfs_can_free_eofblocks(ip))
1420			error = xfs_free_eofblocks(ip);
1421
1422		goto out;
1423	}
1424
1425	if (S_ISREG(VFS_I(ip)->i_mode) &&
1426	    (ip->i_disk_size != 0 || XFS_ISIZE(ip) != 0 ||
1427	     xfs_inode_has_filedata(ip)))
1428		truncate = 1;
1429
1430	if (xfs_iflags_test(ip, XFS_IQUOTAUNCHECKED)) {
1431		/*
1432		 * If this inode is being inactivated during a quotacheck and
1433		 * has not yet been scanned by quotacheck, we /must/ remove
1434		 * the dquots from the inode before inactivation changes the
1435		 * block and inode counts.  Most probably this is a result of
1436		 * reloading the incore iunlinked list to purge unrecovered
1437		 * unlinked inodes.
1438		 */
1439		xfs_qm_dqdetach(ip);
1440	} else {
1441		error = xfs_qm_dqattach(ip);
1442		if (error)
1443			goto out;
1444	}
1445
1446	if (S_ISDIR(VFS_I(ip)->i_mode) && ip->i_df.if_nextents > 0) {
1447		xfs_inactive_dir(ip);
1448		truncate = 1;
1449	}
1450
1451	if (S_ISLNK(VFS_I(ip)->i_mode))
1452		error = xfs_inactive_symlink(ip);
1453	else if (truncate)
1454		error = xfs_inactive_truncate(ip);
1455	if (error)
1456		goto out;
1457
1458	/*
1459	 * If there are attributes associated with the file then blow them away
1460	 * now.  The code calls a routine that recursively deconstructs the
1461	 * attribute fork. If also blows away the in-core attribute fork.
1462	 */
1463	if (xfs_inode_has_attr_fork(ip)) {
1464		error = xfs_attr_inactive(ip);
1465		if (error)
1466			goto out;
1467	}
1468
1469	ASSERT(ip->i_forkoff == 0);
1470
1471	/*
1472	 * Free the inode.
1473	 */
1474	error = xfs_inactive_ifree(ip);
1475
1476out:
1477	/*
1478	 * We're done making metadata updates for this inode, so we can release
1479	 * the attached dquots.
1480	 */
1481	xfs_qm_dqdetach(ip);
1482	return error;
1483}
1484
1485/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1486 * Find an inode on the unlinked list. This does not take references to the
1487 * inode as we have existence guarantees by holding the AGI buffer lock and that
1488 * only unlinked, referenced inodes can be on the unlinked inode list.  If we
1489 * don't find the inode in cache, then let the caller handle the situation.
1490 */
1491struct xfs_inode *
1492xfs_iunlink_lookup(
1493	struct xfs_perag	*pag,
1494	xfs_agino_t		agino)
1495{
1496	struct xfs_inode	*ip;
1497
1498	rcu_read_lock();
1499	ip = radix_tree_lookup(&pag->pag_ici_root, agino);
1500	if (!ip) {
1501		/* Caller can handle inode not being in memory. */
1502		rcu_read_unlock();
1503		return NULL;
1504	}
1505
1506	/*
1507	 * Inode in RCU freeing limbo should not happen.  Warn about this and
1508	 * let the caller handle the failure.
1509	 */
1510	if (WARN_ON_ONCE(!ip->i_ino)) {
1511		rcu_read_unlock();
1512		return NULL;
1513	}
1514	ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE | XFS_IRECLAIM));
1515	rcu_read_unlock();
1516	return ip;
1517}
1518
1519/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1520 * Load the inode @next_agino into the cache and set its prev_unlinked pointer
1521 * to @prev_agino.  Caller must hold the AGI to synchronize with other changes
1522 * to the unlinked list.
1523 */
1524int
1525xfs_iunlink_reload_next(
1526	struct xfs_trans	*tp,
1527	struct xfs_buf		*agibp,
1528	xfs_agino_t		prev_agino,
1529	xfs_agino_t		next_agino)
1530{
1531	struct xfs_perag	*pag = agibp->b_pag;
1532	struct xfs_mount	*mp = pag_mount(pag);
1533	struct xfs_inode	*next_ip = NULL;
 
1534	int			error;
1535
1536	ASSERT(next_agino != NULLAGINO);
1537
1538#ifdef DEBUG
1539	rcu_read_lock();
1540	next_ip = radix_tree_lookup(&pag->pag_ici_root, next_agino);
1541	ASSERT(next_ip == NULL);
1542	rcu_read_unlock();
1543#endif
1544
1545	xfs_info_ratelimited(mp,
1546 "Found unrecovered unlinked inode 0x%x in AG 0x%x.  Initiating recovery.",
1547			next_agino, pag_agno(pag));
1548
1549	/*
1550	 * Use an untrusted lookup just to be cautious in case the AGI has been
1551	 * corrupted and now points at a free inode.  That shouldn't happen,
1552	 * but we'd rather shut down now since we're already running in a weird
1553	 * situation.
1554	 */
1555	error = xfs_iget(mp, tp, xfs_agino_to_ino(pag, next_agino),
1556			XFS_IGET_UNTRUSTED, 0, &next_ip);
1557	if (error) {
1558		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
1559		return error;
1560	}
1561
1562	/* If this is not an unlinked inode, something is very wrong. */
1563	if (VFS_I(next_ip)->i_nlink != 0) {
1564		xfs_ag_mark_sick(pag, XFS_SICK_AG_AGI);
1565		error = -EFSCORRUPTED;
1566		goto rele;
1567	}
1568
1569	next_ip->i_prev_unlinked = prev_agino;
1570	trace_xfs_iunlink_reload_next(next_ip);
1571rele:
1572	ASSERT(!(VFS_I(next_ip)->i_state & I_DONTCACHE));
1573	if (xfs_is_quotacheck_running(mp) && next_ip)
1574		xfs_iflags_set(next_ip, XFS_IQUOTAUNCHECKED);
1575	xfs_irele(next_ip);
1576	return error;
1577}
1578
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1579/*
1580 * Look up the inode number specified and if it is not already marked XFS_ISTALE
1581 * mark it stale. We should only find clean inodes in this lookup that aren't
1582 * already stale.
1583 */
1584static void
1585xfs_ifree_mark_inode_stale(
1586	struct xfs_perag	*pag,
1587	struct xfs_inode	*free_ip,
1588	xfs_ino_t		inum)
1589{
1590	struct xfs_mount	*mp = pag_mount(pag);
1591	struct xfs_inode_log_item *iip;
1592	struct xfs_inode	*ip;
1593
1594retry:
1595	rcu_read_lock();
1596	ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, inum));
1597
1598	/* Inode not in memory, nothing to do */
1599	if (!ip) {
1600		rcu_read_unlock();
1601		return;
1602	}
1603
1604	/*
1605	 * because this is an RCU protected lookup, we could find a recently
1606	 * freed or even reallocated inode during the lookup. We need to check
1607	 * under the i_flags_lock for a valid inode here. Skip it if it is not
1608	 * valid, the wrong inode or stale.
1609	 */
1610	spin_lock(&ip->i_flags_lock);
1611	if (ip->i_ino != inum || __xfs_iflags_test(ip, XFS_ISTALE))
1612		goto out_iflags_unlock;
1613
1614	/*
1615	 * Don't try to lock/unlock the current inode, but we _cannot_ skip the
1616	 * other inodes that we did not find in the list attached to the buffer
1617	 * and are not already marked stale. If we can't lock it, back off and
1618	 * retry.
1619	 */
1620	if (ip != free_ip) {
1621		if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
1622			spin_unlock(&ip->i_flags_lock);
1623			rcu_read_unlock();
1624			delay(1);
1625			goto retry;
1626		}
1627	}
1628	ip->i_flags |= XFS_ISTALE;
1629
1630	/*
1631	 * If the inode is flushing, it is already attached to the buffer.  All
1632	 * we needed to do here is mark the inode stale so buffer IO completion
1633	 * will remove it from the AIL.
1634	 */
1635	iip = ip->i_itemp;
1636	if (__xfs_iflags_test(ip, XFS_IFLUSHING)) {
1637		ASSERT(!list_empty(&iip->ili_item.li_bio_list));
1638		ASSERT(iip->ili_last_fields);
1639		goto out_iunlock;
1640	}
1641
1642	/*
1643	 * Inodes not attached to the buffer can be released immediately.
1644	 * Everything else has to go through xfs_iflush_abort() on journal
1645	 * commit as the flock synchronises removal of the inode from the
1646	 * cluster buffer against inode reclaim.
1647	 */
1648	if (!iip || list_empty(&iip->ili_item.li_bio_list))
1649		goto out_iunlock;
1650
1651	__xfs_iflags_set(ip, XFS_IFLUSHING);
1652	spin_unlock(&ip->i_flags_lock);
1653	rcu_read_unlock();
1654
1655	/* we have a dirty inode in memory that has not yet been flushed. */
1656	spin_lock(&iip->ili_lock);
1657	iip->ili_last_fields = iip->ili_fields;
1658	iip->ili_fields = 0;
1659	iip->ili_fsync_fields = 0;
1660	spin_unlock(&iip->ili_lock);
1661	ASSERT(iip->ili_last_fields);
1662
1663	if (ip != free_ip)
1664		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1665	return;
1666
1667out_iunlock:
1668	if (ip != free_ip)
1669		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1670out_iflags_unlock:
1671	spin_unlock(&ip->i_flags_lock);
1672	rcu_read_unlock();
1673}
1674
1675/*
1676 * A big issue when freeing the inode cluster is that we _cannot_ skip any
1677 * inodes that are in memory - they all must be marked stale and attached to
1678 * the cluster buffer.
1679 */
1680static int
1681xfs_ifree_cluster(
1682	struct xfs_trans	*tp,
1683	struct xfs_perag	*pag,
1684	struct xfs_inode	*free_ip,
1685	struct xfs_icluster	*xic)
1686{
1687	struct xfs_mount	*mp = free_ip->i_mount;
1688	struct xfs_ino_geometry	*igeo = M_IGEO(mp);
1689	struct xfs_buf		*bp;
1690	xfs_daddr_t		blkno;
1691	xfs_ino_t		inum = xic->first_ino;
1692	int			nbufs;
1693	int			i, j;
1694	int			ioffset;
1695	int			error;
1696
1697	nbufs = igeo->ialloc_blks / igeo->blocks_per_cluster;
1698
1699	for (j = 0; j < nbufs; j++, inum += igeo->inodes_per_cluster) {
1700		/*
1701		 * The allocation bitmap tells us which inodes of the chunk were
1702		 * physically allocated. Skip the cluster if an inode falls into
1703		 * a sparse region.
1704		 */
1705		ioffset = inum - xic->first_ino;
1706		if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
1707			ASSERT(ioffset % igeo->inodes_per_cluster == 0);
1708			continue;
1709		}
1710
1711		blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
1712					 XFS_INO_TO_AGBNO(mp, inum));
1713
1714		/*
1715		 * We obtain and lock the backing buffer first in the process
1716		 * here to ensure dirty inodes attached to the buffer remain in
1717		 * the flushing state while we mark them stale.
1718		 *
1719		 * If we scan the in-memory inodes first, then buffer IO can
1720		 * complete before we get a lock on it, and hence we may fail
1721		 * to mark all the active inodes on the buffer stale.
1722		 */
1723		error = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
1724				mp->m_bsize * igeo->blocks_per_cluster,
1725				XBF_UNMAPPED, &bp);
1726		if (error)
1727			return error;
1728
1729		/*
1730		 * This buffer may not have been correctly initialised as we
1731		 * didn't read it from disk. That's not important because we are
1732		 * only using to mark the buffer as stale in the log, and to
1733		 * attach stale cached inodes on it.
1734		 *
1735		 * For the inode that triggered the cluster freeing, this
1736		 * attachment may occur in xfs_inode_item_precommit() after we
1737		 * have marked this buffer stale.  If this buffer was not in
1738		 * memory before xfs_ifree_cluster() started, it will not be
1739		 * marked XBF_DONE and this will cause problems later in
1740		 * xfs_inode_item_precommit() when we trip over a (stale, !done)
1741		 * buffer to attached to the transaction.
1742		 *
1743		 * Hence we have to mark the buffer as XFS_DONE here. This is
1744		 * safe because we are also marking the buffer as XBF_STALE and
1745		 * XFS_BLI_STALE. That means it will never be dispatched for
1746		 * IO and it won't be unlocked until the cluster freeing has
1747		 * been committed to the journal and the buffer unpinned. If it
1748		 * is written, we want to know about it, and we want it to
1749		 * fail. We can acheive this by adding a write verifier to the
1750		 * buffer.
1751		 */
1752		bp->b_flags |= XBF_DONE;
1753		bp->b_ops = &xfs_inode_buf_ops;
1754
1755		/*
1756		 * Now we need to set all the cached clean inodes as XFS_ISTALE,
1757		 * too. This requires lookups, and will skip inodes that we've
1758		 * already marked XFS_ISTALE.
1759		 */
1760		for (i = 0; i < igeo->inodes_per_cluster; i++)
1761			xfs_ifree_mark_inode_stale(pag, free_ip, inum + i);
1762
1763		xfs_trans_stale_inode_buf(tp, bp);
1764		xfs_trans_binval(tp, bp);
1765	}
1766	return 0;
1767}
1768
1769/*
1770 * This is called to return an inode to the inode free list.  The inode should
1771 * already be truncated to 0 length and have no pages associated with it.  This
1772 * routine also assumes that the inode is already a part of the transaction.
1773 *
1774 * The on-disk copy of the inode will have been added to the list of unlinked
1775 * inodes in the AGI. We need to remove the inode from that list atomically with
1776 * respect to freeing it here.
1777 */
1778int
1779xfs_ifree(
1780	struct xfs_trans	*tp,
1781	struct xfs_inode	*ip)
1782{
1783	struct xfs_mount	*mp = ip->i_mount;
1784	struct xfs_perag	*pag;
1785	struct xfs_icluster	xic = { 0 };
1786	struct xfs_inode_log_item *iip = ip->i_itemp;
1787	int			error;
1788
1789	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1790	ASSERT(VFS_I(ip)->i_nlink == 0);
1791	ASSERT(ip->i_df.if_nextents == 0);
1792	ASSERT(ip->i_disk_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
1793	ASSERT(ip->i_nblocks == 0);
1794
1795	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
1796
1797	error = xfs_inode_uninit(tp, pag, ip, &xic);
 
 
 
 
 
 
 
 
 
 
1798	if (error)
1799		goto out;
1800
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1801	if (xfs_iflags_test(ip, XFS_IPRESERVE_DM_FIELDS))
1802		xfs_iflags_clear(ip, XFS_IPRESERVE_DM_FIELDS);
1803
1804	/* Don't attempt to replay owner changes for a deleted inode */
1805	spin_lock(&iip->ili_lock);
1806	iip->ili_fields &= ~(XFS_ILOG_AOWNER | XFS_ILOG_DOWNER);
1807	spin_unlock(&iip->ili_lock);
1808
 
 
 
 
 
 
 
1809	if (xic.deleted)
1810		error = xfs_ifree_cluster(tp, pag, ip, &xic);
1811out:
1812	xfs_perag_put(pag);
1813	return error;
1814}
1815
1816/*
1817 * This is called to unpin an inode.  The caller must have the inode locked
1818 * in at least shared mode so that the buffer cannot be subsequently pinned
1819 * once someone is waiting for it to be unpinned.
1820 */
1821static void
1822xfs_iunpin(
1823	struct xfs_inode	*ip)
1824{
1825	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
1826
1827	trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
1828
1829	/* Give the log a push to start the unpinning I/O */
1830	xfs_log_force_seq(ip->i_mount, ip->i_itemp->ili_commit_seq, 0, NULL);
1831
1832}
1833
1834static void
1835__xfs_iunpin_wait(
1836	struct xfs_inode	*ip)
1837{
1838	wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
1839	DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
1840
1841	xfs_iunpin(ip);
1842
1843	do {
1844		prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
1845		if (xfs_ipincount(ip))
1846			io_schedule();
1847	} while (xfs_ipincount(ip));
1848	finish_wait(wq, &wait.wq_entry);
1849}
1850
1851void
1852xfs_iunpin_wait(
1853	struct xfs_inode	*ip)
1854{
1855	if (xfs_ipincount(ip))
1856		__xfs_iunpin_wait(ip);
1857}
1858
1859/*
1860 * Removing an inode from the namespace involves removing the directory entry
1861 * and dropping the link count on the inode. Removing the directory entry can
1862 * result in locking an AGF (directory blocks were freed) and removing a link
1863 * count can result in placing the inode on an unlinked list which results in
1864 * locking an AGI.
1865 *
1866 * The big problem here is that we have an ordering constraint on AGF and AGI
1867 * locking - inode allocation locks the AGI, then can allocate a new extent for
1868 * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
1869 * removes the inode from the unlinked list, requiring that we lock the AGI
1870 * first, and then freeing the inode can result in an inode chunk being freed
1871 * and hence freeing disk space requiring that we lock an AGF.
1872 *
1873 * Hence the ordering that is imposed by other parts of the code is AGI before
1874 * AGF. This means we cannot remove the directory entry before we drop the inode
1875 * reference count and put it on the unlinked list as this results in a lock
1876 * order of AGF then AGI, and this can deadlock against inode allocation and
1877 * freeing. Therefore we must drop the link counts before we remove the
1878 * directory entry.
1879 *
1880 * This is still safe from a transactional point of view - it is not until we
1881 * get to xfs_defer_finish() that we have the possibility of multiple
1882 * transactions in this operation. Hence as long as we remove the directory
1883 * entry and drop the link count in the first transaction of the remove
1884 * operation, there are no transactional constraints on the ordering here.
1885 */
1886int
1887xfs_remove(
1888	struct xfs_inode	*dp,
1889	struct xfs_name		*name,
1890	struct xfs_inode	*ip)
1891{
1892	struct xfs_dir_update	du = {
1893		.dp		= dp,
1894		.name		= name,
1895		.ip		= ip,
1896	};
1897	struct xfs_mount	*mp = dp->i_mount;
1898	struct xfs_trans	*tp = NULL;
1899	int			is_dir = S_ISDIR(VFS_I(ip)->i_mode);
1900	int			dontcare;
1901	int                     error = 0;
1902	uint			resblks;
1903
1904	trace_xfs_remove(dp, name);
1905
1906	if (xfs_is_shutdown(mp))
1907		return -EIO;
1908	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
1909		return -EIO;
1910
1911	error = xfs_qm_dqattach(dp);
1912	if (error)
1913		goto std_return;
1914
1915	error = xfs_qm_dqattach(ip);
1916	if (error)
1917		goto std_return;
1918
1919	error = xfs_parent_start(mp, &du.ppargs);
1920	if (error)
1921		goto std_return;
1922
1923	/*
1924	 * We try to get the real space reservation first, allowing for
1925	 * directory btree deletion(s) implying possible bmap insert(s).  If we
1926	 * can't get the space reservation then we use 0 instead, and avoid the
1927	 * bmap btree insert(s) in the directory code by, if the bmap insert
1928	 * tries to happen, instead trimming the LAST block from the directory.
1929	 *
1930	 * Ignore EDQUOT and ENOSPC being returned via nospace_error because
1931	 * the directory code can handle a reservationless update and we don't
1932	 * want to prevent a user from trying to free space by deleting things.
1933	 */
1934	resblks = xfs_remove_space_res(mp, name->len);
1935	error = xfs_trans_alloc_dir(dp, &M_RES(mp)->tr_remove, ip, &resblks,
1936			&tp, &dontcare);
1937	if (error) {
1938		ASSERT(error != -ENOSPC);
1939		goto out_parent;
1940	}
1941
1942	error = xfs_dir_remove_child(tp, resblks, &du);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1943	if (error)
1944		goto out_trans_cancel;
1945
 
 
 
 
 
 
 
 
 
 
 
 
1946	/*
1947	 * If this is a synchronous mount, make sure that the
1948	 * remove transaction goes to disk before returning to
1949	 * the user.
1950	 */
1951	if (xfs_has_wsync(mp) || xfs_has_dirsync(mp))
1952		xfs_trans_set_sync(tp);
1953
1954	error = xfs_trans_commit(tp);
1955	if (error)
1956		goto out_unlock;
1957
1958	if (is_dir && xfs_inode_is_filestream(ip))
1959		xfs_filestream_deassociate(ip);
1960
1961	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1962	xfs_iunlock(dp, XFS_ILOCK_EXCL);
1963	xfs_parent_finish(mp, du.ppargs);
1964	return 0;
1965
1966 out_trans_cancel:
1967	xfs_trans_cancel(tp);
1968 out_unlock:
1969	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1970	xfs_iunlock(dp, XFS_ILOCK_EXCL);
1971 out_parent:
1972	xfs_parent_finish(mp, du.ppargs);
1973 std_return:
1974	return error;
1975}
1976
1977static inline void
1978xfs_iunlock_rename(
1979	struct xfs_inode	**i_tab,
1980	int			num_inodes)
1981{
1982	int			i;
1983
1984	for (i = num_inodes - 1; i >= 0; i--) {
1985		/* Skip duplicate inodes if src and target dps are the same */
1986		if (!i_tab[i] || (i > 0 && i_tab[i] == i_tab[i - 1]))
1987			continue;
1988		xfs_iunlock(i_tab[i], XFS_ILOCK_EXCL);
1989	}
1990}
1991
1992/*
1993 * Enter all inodes for a rename transaction into a sorted array.
1994 */
1995#define __XFS_SORT_INODES	5
1996STATIC void
1997xfs_sort_for_rename(
1998	struct xfs_inode	*dp1,	/* in: old (source) directory inode */
1999	struct xfs_inode	*dp2,	/* in: new (target) directory inode */
2000	struct xfs_inode	*ip1,	/* in: inode of old entry */
2001	struct xfs_inode	*ip2,	/* in: inode of new entry */
2002	struct xfs_inode	*wip,	/* in: whiteout inode */
2003	struct xfs_inode	**i_tab,/* out: sorted array of inodes */
2004	int			*num_inodes)  /* in/out: inodes in array */
2005{
2006	int			i;
2007
2008	ASSERT(*num_inodes == __XFS_SORT_INODES);
2009	memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2010
2011	/*
2012	 * i_tab contains a list of pointers to inodes.  We initialize
2013	 * the table here & we'll sort it.  We will then use it to
2014	 * order the acquisition of the inode locks.
2015	 *
2016	 * Note that the table may contain duplicates.  e.g., dp1 == dp2.
2017	 */
2018	i = 0;
2019	i_tab[i++] = dp1;
2020	i_tab[i++] = dp2;
2021	i_tab[i++] = ip1;
2022	if (ip2)
2023		i_tab[i++] = ip2;
2024	if (wip)
2025		i_tab[i++] = wip;
2026	*num_inodes = i;
2027
2028	xfs_sort_inodes(i_tab, *num_inodes);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2029}
2030
2031void
2032xfs_sort_inodes(
2033	struct xfs_inode	**i_tab,
2034	unsigned int		num_inodes)
 
 
 
 
 
 
 
 
 
 
 
2035{
2036	int			i, j;
 
 
 
 
 
 
 
 
2037
2038	ASSERT(num_inodes <= __XFS_SORT_INODES);
 
 
 
2039
2040	/*
2041	 * Sort the elements via bubble sort.  (Remember, there are at
2042	 * most 5 elements to sort, so this is adequate.)
 
2043	 */
2044	for (i = 0; i < num_inodes; i++) {
2045		for (j = 1; j < num_inodes; j++) {
2046			if (i_tab[j]->i_ino < i_tab[j-1]->i_ino)
2047				swap(i_tab[j], i_tab[j - 1]);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2048		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2049	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2050}
2051
2052/*
2053 * xfs_rename_alloc_whiteout()
2054 *
2055 * Return a referenced, unlinked, unlocked inode that can be used as a
2056 * whiteout in a rename transaction. We use a tmpfile inode here so that if we
2057 * crash between allocating the inode and linking it into the rename transaction
2058 * recovery will free the inode and we won't leak it.
2059 */
2060static int
2061xfs_rename_alloc_whiteout(
2062	struct mnt_idmap	*idmap,
2063	struct xfs_name		*src_name,
2064	struct xfs_inode	*dp,
2065	struct xfs_inode	**wip)
2066{
2067	struct xfs_icreate_args	args = {
2068		.idmap		= idmap,
2069		.pip		= dp,
2070		.mode		= S_IFCHR | WHITEOUT_MODE,
2071		.flags		= XFS_ICREATE_TMPFILE,
2072	};
2073	struct xfs_inode	*tmpfile;
2074	struct qstr		name;
2075	int			error;
2076
2077	error = xfs_create_tmpfile(&args, &tmpfile);
 
2078	if (error)
2079		return error;
2080
2081	name.name = src_name->name;
2082	name.len = src_name->len;
2083	error = xfs_inode_init_security(VFS_I(tmpfile), VFS_I(dp), &name);
2084	if (error) {
2085		xfs_finish_inode_setup(tmpfile);
2086		xfs_irele(tmpfile);
2087		return error;
2088	}
2089
2090	/*
2091	 * Prepare the tmpfile inode as if it were created through the VFS.
2092	 * Complete the inode setup and flag it as linkable.  nlink is already
2093	 * zero, so we can skip the drop_nlink.
2094	 */
2095	xfs_setup_iops(tmpfile);
2096	xfs_finish_inode_setup(tmpfile);
2097	VFS_I(tmpfile)->i_state |= I_LINKABLE;
2098
2099	*wip = tmpfile;
2100	return 0;
2101}
2102
2103/*
2104 * xfs_rename
2105 */
2106int
2107xfs_rename(
2108	struct mnt_idmap	*idmap,
2109	struct xfs_inode	*src_dp,
2110	struct xfs_name		*src_name,
2111	struct xfs_inode	*src_ip,
2112	struct xfs_inode	*target_dp,
2113	struct xfs_name		*target_name,
2114	struct xfs_inode	*target_ip,
2115	unsigned int		flags)
2116{
2117	struct xfs_dir_update	du_src = {
2118		.dp		= src_dp,
2119		.name		= src_name,
2120		.ip		= src_ip,
2121	};
2122	struct xfs_dir_update	du_tgt = {
2123		.dp		= target_dp,
2124		.name		= target_name,
2125		.ip		= target_ip,
2126	};
2127	struct xfs_dir_update	du_wip = { };
2128	struct xfs_mount	*mp = src_dp->i_mount;
2129	struct xfs_trans	*tp;
 
2130	struct xfs_inode	*inodes[__XFS_SORT_INODES];
2131	int			i;
2132	int			num_inodes = __XFS_SORT_INODES;
2133	bool			new_parent = (src_dp != target_dp);
2134	bool			src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
2135	int			spaceres;
2136	bool			retried = false;
2137	int			error, nospace_error = 0;
2138
2139	trace_xfs_rename(src_dp, target_dp, src_name, target_name);
2140
2141	if ((flags & RENAME_EXCHANGE) && !target_ip)
2142		return -EINVAL;
2143
2144	/*
2145	 * If we are doing a whiteout operation, allocate the whiteout inode
2146	 * we will be placing at the target and ensure the type is set
2147	 * appropriately.
2148	 */
2149	if (flags & RENAME_WHITEOUT) {
2150		error = xfs_rename_alloc_whiteout(idmap, src_name, target_dp,
2151				&du_wip.ip);
2152		if (error)
2153			return error;
2154
2155		/* setup target dirent info as whiteout */
2156		src_name->type = XFS_DIR3_FT_CHRDEV;
2157	}
2158
2159	xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, du_wip.ip,
2160			inodes, &num_inodes);
2161
2162	error = xfs_parent_start(mp, &du_src.ppargs);
2163	if (error)
2164		goto out_release_wip;
2165
2166	if (du_wip.ip) {
2167		error = xfs_parent_start(mp, &du_wip.ppargs);
2168		if (error)
2169			goto out_src_ppargs;
2170	}
2171
2172	if (target_ip) {
2173		error = xfs_parent_start(mp, &du_tgt.ppargs);
2174		if (error)
2175			goto out_wip_ppargs;
2176	}
2177
2178retry:
2179	nospace_error = 0;
2180	spaceres = xfs_rename_space_res(mp, src_name->len, target_ip != NULL,
2181			target_name->len, du_wip.ip != NULL);
2182	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
2183	if (error == -ENOSPC) {
2184		nospace_error = error;
2185		spaceres = 0;
2186		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
2187				&tp);
2188	}
2189	if (error)
2190		goto out_tgt_ppargs;
2191
2192	/*
2193	 * We don't allow reservationless renaming when parent pointers are
2194	 * enabled because we can't back out if the xattrs must grow.
2195	 */
2196	if (du_src.ppargs && nospace_error) {
2197		error = nospace_error;
2198		xfs_trans_cancel(tp);
2199		goto out_tgt_ppargs;
2200	}
2201
2202	/*
2203	 * Attach the dquots to the inodes
2204	 */
2205	error = xfs_qm_vop_rename_dqattach(inodes);
2206	if (error) {
2207		xfs_trans_cancel(tp);
2208		goto out_tgt_ppargs;
2209	}
2210
2211	/*
2212	 * Lock all the participating inodes. Depending upon whether
2213	 * the target_name exists in the target directory, and
2214	 * whether the target directory is the same as the source
2215	 * directory, we can lock from 2 to 5 inodes.
2216	 */
2217	xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
2218
2219	/*
2220	 * Join all the inodes to the transaction.
 
 
2221	 */
2222	xfs_trans_ijoin(tp, src_dp, 0);
2223	if (new_parent)
2224		xfs_trans_ijoin(tp, target_dp, 0);
2225	xfs_trans_ijoin(tp, src_ip, 0);
2226	if (target_ip)
2227		xfs_trans_ijoin(tp, target_ip, 0);
2228	if (du_wip.ip)
2229		xfs_trans_ijoin(tp, du_wip.ip, 0);
2230
2231	/*
2232	 * If we are using project inheritance, we only allow renames
2233	 * into our tree when the project IDs are the same; else the
2234	 * tree quota mechanism would be circumvented.
2235	 */
2236	if (unlikely((target_dp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
2237		     target_dp->i_projid != src_ip->i_projid)) {
2238		error = -EXDEV;
2239		goto out_trans_cancel;
2240	}
2241
2242	/* RENAME_EXCHANGE is unique from here on. */
2243	if (flags & RENAME_EXCHANGE) {
2244		error = xfs_dir_exchange_children(tp, &du_src, &du_tgt,
2245				spaceres);
2246		if (error)
2247			goto out_trans_cancel;
2248		goto out_commit;
2249	}
2250
2251	/*
2252	 * Try to reserve quota to handle an expansion of the target directory.
2253	 * We'll allow the rename to continue in reservationless mode if we hit
2254	 * a space usage constraint.  If we trigger reservationless mode, save
2255	 * the errno if there isn't any free space in the target directory.
2256	 */
2257	if (spaceres != 0) {
2258		error = xfs_trans_reserve_quota_nblks(tp, target_dp, spaceres,
2259				0, false);
2260		if (error == -EDQUOT || error == -ENOSPC) {
2261			if (!retried) {
2262				xfs_trans_cancel(tp);
2263				xfs_iunlock_rename(inodes, num_inodes);
2264				xfs_blockgc_free_quota(target_dp, 0);
2265				retried = true;
2266				goto retry;
2267			}
2268
2269			nospace_error = error;
2270			spaceres = 0;
2271			error = 0;
2272		}
2273		if (error)
2274			goto out_trans_cancel;
2275	}
2276
2277	/*
2278	 * We don't allow quotaless renaming when parent pointers are enabled
2279	 * because we can't back out if the xattrs must grow.
2280	 */
2281	if (du_src.ppargs && nospace_error) {
2282		error = nospace_error;
2283		goto out_trans_cancel;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2284	}
2285
2286	/*
2287	 * Lock the AGI buffers we need to handle bumping the nlink of the
2288	 * whiteout inode off the unlinked list and to handle dropping the
2289	 * nlink of the target inode.  Per locking order rules, do this in
2290	 * increasing AG order and before directory block allocation tries to
2291	 * grab AGFs because we grab AGIs before AGFs.
2292	 *
2293	 * The (vfs) caller must ensure that if src is a directory then
2294	 * target_ip is either null or an empty directory.
2295	 */
2296	for (i = 0; i < num_inodes && inodes[i] != NULL; i++) {
2297		if (inodes[i] == du_wip.ip ||
2298		    (inodes[i] == target_ip &&
2299		     (VFS_I(target_ip)->i_nlink == 1 || src_is_directory))) {
2300			struct xfs_perag	*pag;
2301			struct xfs_buf		*bp;
2302
2303			pag = xfs_perag_get(mp,
2304					XFS_INO_TO_AGNO(mp, inodes[i]->i_ino));
2305			error = xfs_read_agi(pag, tp, 0, &bp);
2306			xfs_perag_put(pag);
2307			if (error)
2308				goto out_trans_cancel;
2309		}
2310	}
2311
2312	error = xfs_dir_rename_children(tp, &du_src, &du_tgt, spaceres,
2313			&du_wip);
2314	if (error)
2315		goto out_trans_cancel;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2316
2317	if (du_wip.ip) {
2318		/*
2319		 * Now we have a real link, clear the "I'm a tmpfile" state
2320		 * flag from the inode so it doesn't accidentally get misused in
2321		 * future.
2322		 */
2323		VFS_I(du_wip.ip)->i_state &= ~I_LINKABLE;
 
 
2324	}
2325
2326out_commit:
2327	/*
2328	 * If this is a synchronous mount, make sure that the rename
2329	 * transaction goes to disk before returning to the user.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2330	 */
2331	if (xfs_has_wsync(tp->t_mountp) || xfs_has_dirsync(tp->t_mountp))
2332		xfs_trans_set_sync(tp);
 
 
 
 
2333
2334	error = xfs_trans_commit(tp);
2335	nospace_error = 0;
2336	goto out_unlock;
 
2337
2338out_trans_cancel:
2339	xfs_trans_cancel(tp);
2340out_unlock:
2341	xfs_iunlock_rename(inodes, num_inodes);
2342out_tgt_ppargs:
2343	xfs_parent_finish(mp, du_tgt.ppargs);
2344out_wip_ppargs:
2345	xfs_parent_finish(mp, du_wip.ppargs);
2346out_src_ppargs:
2347	xfs_parent_finish(mp, du_src.ppargs);
2348out_release_wip:
2349	if (du_wip.ip)
2350		xfs_irele(du_wip.ip);
2351	if (error == -ENOSPC && nospace_error)
2352		error = nospace_error;
2353	return error;
2354}
2355
2356static int
2357xfs_iflush(
2358	struct xfs_inode	*ip,
2359	struct xfs_buf		*bp)
2360{
2361	struct xfs_inode_log_item *iip = ip->i_itemp;
2362	struct xfs_dinode	*dip;
2363	struct xfs_mount	*mp = ip->i_mount;
2364	int			error;
2365
2366	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
2367	ASSERT(xfs_iflags_test(ip, XFS_IFLUSHING));
2368	ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_BTREE ||
2369	       ip->i_df.if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
2370	ASSERT(iip->ili_item.li_buf == bp);
2371
2372	dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
2373
2374	/*
2375	 * We don't flush the inode if any of the following checks fail, but we
2376	 * do still update the log item and attach to the backing buffer as if
2377	 * the flush happened. This is a formality to facilitate predictable
2378	 * error handling as the caller will shutdown and fail the buffer.
2379	 */
2380	error = -EFSCORRUPTED;
2381	if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
2382			       mp, XFS_ERRTAG_IFLUSH_1)) {
2383		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
2384			"%s: Bad inode %llu magic number 0x%x, ptr "PTR_FMT,
2385			__func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
2386		goto flush_out;
2387	}
2388	if (S_ISREG(VFS_I(ip)->i_mode)) {
2389		if (XFS_TEST_ERROR(
2390		    ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
2391		    ip->i_df.if_format != XFS_DINODE_FMT_BTREE,
2392		    mp, XFS_ERRTAG_IFLUSH_3)) {
2393			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
2394				"%s: Bad regular inode %llu, ptr "PTR_FMT,
2395				__func__, ip->i_ino, ip);
2396			goto flush_out;
2397		}
2398	} else if (S_ISDIR(VFS_I(ip)->i_mode)) {
2399		if (XFS_TEST_ERROR(
2400		    ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
2401		    ip->i_df.if_format != XFS_DINODE_FMT_BTREE &&
2402		    ip->i_df.if_format != XFS_DINODE_FMT_LOCAL,
2403		    mp, XFS_ERRTAG_IFLUSH_4)) {
2404			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
2405				"%s: Bad directory inode %llu, ptr "PTR_FMT,
2406				__func__, ip->i_ino, ip);
2407			goto flush_out;
2408		}
2409	}
2410	if (XFS_TEST_ERROR(ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af) >
2411				ip->i_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
2412		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
2413			"%s: detected corrupt incore inode %llu, "
2414			"total extents = %llu nblocks = %lld, ptr "PTR_FMT,
2415			__func__, ip->i_ino,
2416			ip->i_df.if_nextents + xfs_ifork_nextents(&ip->i_af),
2417			ip->i_nblocks, ip);
2418		goto flush_out;
2419	}
2420	if (XFS_TEST_ERROR(ip->i_forkoff > mp->m_sb.sb_inodesize,
2421				mp, XFS_ERRTAG_IFLUSH_6)) {
2422		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
2423			"%s: bad inode %llu, forkoff 0x%x, ptr "PTR_FMT,
2424			__func__, ip->i_ino, ip->i_forkoff, ip);
2425		goto flush_out;
2426	}
2427
2428	/*
2429	 * Inode item log recovery for v2 inodes are dependent on the flushiter
2430	 * count for correct sequencing.  We bump the flush iteration count so
2431	 * we can detect flushes which postdate a log record during recovery.
2432	 * This is redundant as we now log every change and hence this can't
2433	 * happen but we need to still do it to ensure backwards compatibility
2434	 * with old kernels that predate logging all inode changes.
2435	 */
2436	if (!xfs_has_v3inodes(mp))
2437		ip->i_flushiter++;
2438
2439	/*
2440	 * If there are inline format data / attr forks attached to this inode,
2441	 * make sure they are not corrupt.
2442	 */
2443	if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL &&
2444	    xfs_ifork_verify_local_data(ip))
2445		goto flush_out;
2446	if (xfs_inode_has_attr_fork(ip) &&
2447	    ip->i_af.if_format == XFS_DINODE_FMT_LOCAL &&
2448	    xfs_ifork_verify_local_attr(ip))
2449		goto flush_out;
2450
2451	/*
2452	 * Copy the dirty parts of the inode into the on-disk inode.  We always
2453	 * copy out the core of the inode, because if the inode is dirty at all
2454	 * the core must be.
2455	 */
2456	xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
2457
2458	/* Wrap, we never let the log put out DI_MAX_FLUSH */
2459	if (!xfs_has_v3inodes(mp)) {
2460		if (ip->i_flushiter == DI_MAX_FLUSH)
2461			ip->i_flushiter = 0;
2462	}
2463
2464	xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
2465	if (xfs_inode_has_attr_fork(ip))
2466		xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
2467
2468	/*
2469	 * We've recorded everything logged in the inode, so we'd like to clear
2470	 * the ili_fields bits so we don't log and flush things unnecessarily.
2471	 * However, we can't stop logging all this information until the data
2472	 * we've copied into the disk buffer is written to disk.  If we did we
2473	 * might overwrite the copy of the inode in the log with all the data
2474	 * after re-logging only part of it, and in the face of a crash we
2475	 * wouldn't have all the data we need to recover.
2476	 *
2477	 * What we do is move the bits to the ili_last_fields field.  When
2478	 * logging the inode, these bits are moved back to the ili_fields field.
2479	 * In the xfs_buf_inode_iodone() routine we clear ili_last_fields, since
2480	 * we know that the information those bits represent is permanently on
2481	 * disk.  As long as the flush completes before the inode is logged
2482	 * again, then both ili_fields and ili_last_fields will be cleared.
2483	 */
2484	error = 0;
2485flush_out:
2486	spin_lock(&iip->ili_lock);
2487	iip->ili_last_fields = iip->ili_fields;
2488	iip->ili_fields = 0;
2489	iip->ili_fsync_fields = 0;
2490	set_bit(XFS_LI_FLUSHING, &iip->ili_item.li_flags);
2491	spin_unlock(&iip->ili_lock);
2492
2493	/*
2494	 * Store the current LSN of the inode so that we can tell whether the
2495	 * item has moved in the AIL from xfs_buf_inode_iodone().
2496	 */
2497	xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
2498				&iip->ili_item.li_lsn);
2499
2500	/* generate the checksum. */
2501	xfs_dinode_calc_crc(mp, dip);
2502	if (error)
2503		xfs_inode_mark_sick(ip, XFS_SICK_INO_CORE);
2504	return error;
2505}
2506
2507/*
2508 * Non-blocking flush of dirty inode metadata into the backing buffer.
2509 *
2510 * The caller must have a reference to the inode and hold the cluster buffer
2511 * locked. The function will walk across all the inodes on the cluster buffer it
2512 * can find and lock without blocking, and flush them to the cluster buffer.
2513 *
2514 * On successful flushing of at least one inode, the caller must write out the
2515 * buffer and release it. If no inodes are flushed, -EAGAIN will be returned and
2516 * the caller needs to release the buffer. On failure, the filesystem will be
2517 * shut down, the buffer will have been unlocked and released, and EFSCORRUPTED
2518 * will be returned.
2519 */
2520int
2521xfs_iflush_cluster(
2522	struct xfs_buf		*bp)
2523{
2524	struct xfs_mount	*mp = bp->b_mount;
2525	struct xfs_log_item	*lip, *n;
2526	struct xfs_inode	*ip;
2527	struct xfs_inode_log_item *iip;
2528	int			clcount = 0;
2529	int			error = 0;
2530
2531	/*
2532	 * We must use the safe variant here as on shutdown xfs_iflush_abort()
2533	 * will remove itself from the list.
2534	 */
2535	list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
2536		iip = (struct xfs_inode_log_item *)lip;
2537		ip = iip->ili_inode;
2538
2539		/*
2540		 * Quick and dirty check to avoid locks if possible.
2541		 */
2542		if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING))
2543			continue;
2544		if (xfs_ipincount(ip))
2545			continue;
2546
2547		/*
2548		 * The inode is still attached to the buffer, which means it is
2549		 * dirty but reclaim might try to grab it. Check carefully for
2550		 * that, and grab the ilock while still holding the i_flags_lock
2551		 * to guarantee reclaim will not be able to reclaim this inode
2552		 * once we drop the i_flags_lock.
2553		 */
2554		spin_lock(&ip->i_flags_lock);
2555		ASSERT(!__xfs_iflags_test(ip, XFS_ISTALE));
2556		if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING)) {
2557			spin_unlock(&ip->i_flags_lock);
2558			continue;
2559		}
2560
2561		/*
2562		 * ILOCK will pin the inode against reclaim and prevent
2563		 * concurrent transactions modifying the inode while we are
2564		 * flushing the inode. If we get the lock, set the flushing
2565		 * state before we drop the i_flags_lock.
2566		 */
2567		if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
2568			spin_unlock(&ip->i_flags_lock);
2569			continue;
2570		}
2571		__xfs_iflags_set(ip, XFS_IFLUSHING);
2572		spin_unlock(&ip->i_flags_lock);
2573
2574		/*
2575		 * Abort flushing this inode if we are shut down because the
2576		 * inode may not currently be in the AIL. This can occur when
2577		 * log I/O failure unpins the inode without inserting into the
2578		 * AIL, leaving a dirty/unpinned inode attached to the buffer
2579		 * that otherwise looks like it should be flushed.
2580		 */
2581		if (xlog_is_shutdown(mp->m_log)) {
2582			xfs_iunpin_wait(ip);
2583			xfs_iflush_abort(ip);
2584			xfs_iunlock(ip, XFS_ILOCK_SHARED);
2585			error = -EIO;
2586			continue;
2587		}
2588
2589		/* don't block waiting on a log force to unpin dirty inodes */
2590		if (xfs_ipincount(ip)) {
2591			xfs_iflags_clear(ip, XFS_IFLUSHING);
2592			xfs_iunlock(ip, XFS_ILOCK_SHARED);
2593			continue;
2594		}
2595
2596		if (!xfs_inode_clean(ip))
2597			error = xfs_iflush(ip, bp);
2598		else
2599			xfs_iflags_clear(ip, XFS_IFLUSHING);
2600		xfs_iunlock(ip, XFS_ILOCK_SHARED);
2601		if (error)
2602			break;
2603		clcount++;
2604	}
2605
2606	if (error) {
2607		/*
2608		 * Shutdown first so we kill the log before we release this
2609		 * buffer. If it is an INODE_ALLOC buffer and pins the tail
2610		 * of the log, failing it before the _log_ is shut down can
2611		 * result in the log tail being moved forward in the journal
2612		 * on disk because log writes can still be taking place. Hence
2613		 * unpinning the tail will allow the ICREATE intent to be
2614		 * removed from the log an recovery will fail with uninitialised
2615		 * inode cluster buffers.
2616		 */
2617		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
2618		bp->b_flags |= XBF_ASYNC;
2619		xfs_buf_ioend_fail(bp);
2620		return error;
2621	}
2622
2623	if (!clcount)
2624		return -EAGAIN;
2625
2626	XFS_STATS_INC(mp, xs_icluster_flushcnt);
2627	XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
2628	return 0;
2629
2630}
2631
2632/* Release an inode. */
2633void
2634xfs_irele(
2635	struct xfs_inode	*ip)
2636{
2637	trace_xfs_irele(ip, _RET_IP_);
2638	iput(VFS_I(ip));
2639}
2640
2641/*
2642 * Ensure all commited transactions touching the inode are written to the log.
2643 */
2644int
2645xfs_log_force_inode(
2646	struct xfs_inode	*ip)
2647{
2648	xfs_csn_t		seq = 0;
2649
2650	xfs_ilock(ip, XFS_ILOCK_SHARED);
2651	if (xfs_ipincount(ip))
2652		seq = ip->i_itemp->ili_commit_seq;
2653	xfs_iunlock(ip, XFS_ILOCK_SHARED);
2654
2655	if (!seq)
2656		return 0;
2657	return xfs_log_force_seq(ip->i_mount, seq, XFS_LOG_SYNC, NULL);
2658}
2659
2660/*
2661 * Grab the exclusive iolock for a data copy from src to dest, making sure to
2662 * abide vfs locking order (lowest pointer value goes first) and breaking the
2663 * layout leases before proceeding.  The loop is needed because we cannot call
2664 * the blocking break_layout() with the iolocks held, and therefore have to
2665 * back out both locks.
2666 */
2667static int
2668xfs_iolock_two_inodes_and_break_layout(
2669	struct inode		*src,
2670	struct inode		*dest)
2671{
2672	int			error;
2673
2674	if (src > dest)
2675		swap(src, dest);
2676
2677retry:
2678	/* Wait to break both inodes' layouts before we start locking. */
2679	error = break_layout(src, true);
2680	if (error)
2681		return error;
2682	if (src != dest) {
2683		error = break_layout(dest, true);
2684		if (error)
2685			return error;
2686	}
2687
2688	/* Lock one inode and make sure nobody got in and leased it. */
2689	inode_lock(src);
2690	error = break_layout(src, false);
2691	if (error) {
2692		inode_unlock(src);
2693		if (error == -EWOULDBLOCK)
2694			goto retry;
2695		return error;
2696	}
2697
2698	if (src == dest)
2699		return 0;
2700
2701	/* Lock the other inode and make sure nobody got in and leased it. */
2702	inode_lock_nested(dest, I_MUTEX_NONDIR2);
2703	error = break_layout(dest, false);
2704	if (error) {
2705		inode_unlock(src);
2706		inode_unlock(dest);
2707		if (error == -EWOULDBLOCK)
2708			goto retry;
2709		return error;
2710	}
2711
2712	return 0;
2713}
2714
2715static int
2716xfs_mmaplock_two_inodes_and_break_dax_layout(
2717	struct xfs_inode	*ip1,
2718	struct xfs_inode	*ip2)
2719{
2720	int			error;
2721	bool			retry;
2722	struct page		*page;
2723
2724	if (ip1->i_ino > ip2->i_ino)
2725		swap(ip1, ip2);
2726
2727again:
2728	retry = false;
2729	/* Lock the first inode */
2730	xfs_ilock(ip1, XFS_MMAPLOCK_EXCL);
2731	error = xfs_break_dax_layouts(VFS_I(ip1), &retry);
2732	if (error || retry) {
2733		xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
2734		if (error == 0 && retry)
2735			goto again;
2736		return error;
2737	}
2738
2739	if (ip1 == ip2)
2740		return 0;
2741
2742	/* Nested lock the second inode */
2743	xfs_ilock(ip2, xfs_lock_inumorder(XFS_MMAPLOCK_EXCL, 1));
2744	/*
2745	 * We cannot use xfs_break_dax_layouts() directly here because it may
2746	 * need to unlock & lock the XFS_MMAPLOCK_EXCL which is not suitable
2747	 * for this nested lock case.
2748	 */
2749	page = dax_layout_busy_page(VFS_I(ip2)->i_mapping);
2750	if (page && page_ref_count(page) != 1) {
2751		xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
2752		xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
2753		goto again;
2754	}
2755
2756	return 0;
2757}
2758
2759/*
2760 * Lock two inodes so that userspace cannot initiate I/O via file syscalls or
2761 * mmap activity.
2762 */
2763int
2764xfs_ilock2_io_mmap(
2765	struct xfs_inode	*ip1,
2766	struct xfs_inode	*ip2)
2767{
2768	int			ret;
2769
2770	ret = xfs_iolock_two_inodes_and_break_layout(VFS_I(ip1), VFS_I(ip2));
2771	if (ret)
2772		return ret;
2773
2774	if (IS_DAX(VFS_I(ip1)) && IS_DAX(VFS_I(ip2))) {
2775		ret = xfs_mmaplock_two_inodes_and_break_dax_layout(ip1, ip2);
2776		if (ret) {
2777			inode_unlock(VFS_I(ip2));
2778			if (ip1 != ip2)
2779				inode_unlock(VFS_I(ip1));
2780			return ret;
2781		}
2782	} else
2783		filemap_invalidate_lock_two(VFS_I(ip1)->i_mapping,
2784					    VFS_I(ip2)->i_mapping);
2785
2786	return 0;
2787}
2788
2789/* Unlock both inodes to allow IO and mmap activity. */
2790void
2791xfs_iunlock2_io_mmap(
2792	struct xfs_inode	*ip1,
2793	struct xfs_inode	*ip2)
2794{
2795	if (IS_DAX(VFS_I(ip1)) && IS_DAX(VFS_I(ip2))) {
2796		xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
2797		if (ip1 != ip2)
2798			xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
2799	} else
2800		filemap_invalidate_unlock_two(VFS_I(ip1)->i_mapping,
2801					      VFS_I(ip2)->i_mapping);
2802
2803	inode_unlock(VFS_I(ip2));
2804	if (ip1 != ip2)
2805		inode_unlock(VFS_I(ip1));
2806}
2807
2808/* Drop the MMAPLOCK and the IOLOCK after a remap completes. */
2809void
2810xfs_iunlock2_remapping(
2811	struct xfs_inode	*ip1,
2812	struct xfs_inode	*ip2)
2813{
2814	xfs_iflags_clear(ip1, XFS_IREMAPPING);
2815
2816	if (ip1 != ip2)
2817		xfs_iunlock(ip1, XFS_MMAPLOCK_SHARED);
2818	xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
2819
2820	if (ip1 != ip2)
2821		inode_unlock_shared(VFS_I(ip1));
2822	inode_unlock(VFS_I(ip2));
2823}
2824
2825/*
2826 * Reload the incore inode list for this inode.  Caller should ensure that
2827 * the link count cannot change, either by taking ILOCK_SHARED or otherwise
2828 * preventing other threads from executing.
2829 */
2830int
2831xfs_inode_reload_unlinked_bucket(
2832	struct xfs_trans	*tp,
2833	struct xfs_inode	*ip)
2834{
2835	struct xfs_mount	*mp = tp->t_mountp;
2836	struct xfs_buf		*agibp;
2837	struct xfs_agi		*agi;
2838	struct xfs_perag	*pag;
2839	xfs_agnumber_t		agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
2840	xfs_agino_t		agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2841	xfs_agino_t		prev_agino, next_agino;
2842	unsigned int		bucket;
2843	bool			foundit = false;
2844	int			error;
2845
2846	/* Grab the first inode in the list */
2847	pag = xfs_perag_get(mp, agno);
2848	error = xfs_ialloc_read_agi(pag, tp, 0, &agibp);
2849	xfs_perag_put(pag);
2850	if (error)
2851		return error;
2852
2853	/*
2854	 * We've taken ILOCK_SHARED and the AGI buffer lock to stabilize the
2855	 * incore unlinked list pointers for this inode.  Check once more to
2856	 * see if we raced with anyone else to reload the unlinked list.
2857	 */
2858	if (!xfs_inode_unlinked_incomplete(ip)) {
2859		foundit = true;
2860		goto out_agibp;
2861	}
2862
2863	bucket = agino % XFS_AGI_UNLINKED_BUCKETS;
2864	agi = agibp->b_addr;
2865
2866	trace_xfs_inode_reload_unlinked_bucket(ip);
2867
2868	xfs_info_ratelimited(mp,
2869 "Found unrecovered unlinked inode 0x%x in AG 0x%x.  Initiating list recovery.",
2870			agino, agno);
2871
2872	prev_agino = NULLAGINO;
2873	next_agino = be32_to_cpu(agi->agi_unlinked[bucket]);
2874	while (next_agino != NULLAGINO) {
2875		struct xfs_inode	*next_ip = NULL;
2876
2877		/* Found this caller's inode, set its backlink. */
2878		if (next_agino == agino) {
2879			next_ip = ip;
2880			next_ip->i_prev_unlinked = prev_agino;
2881			foundit = true;
2882			goto next_inode;
2883		}
2884
2885		/* Try in-memory lookup first. */
2886		next_ip = xfs_iunlink_lookup(pag, next_agino);
2887		if (next_ip)
2888			goto next_inode;
2889
2890		/* Inode not in memory, try reloading it. */
2891		error = xfs_iunlink_reload_next(tp, agibp, prev_agino,
2892				next_agino);
2893		if (error)
2894			break;
2895
2896		/* Grab the reloaded inode. */
2897		next_ip = xfs_iunlink_lookup(pag, next_agino);
2898		if (!next_ip) {
2899			/* No incore inode at all?  We reloaded it... */
2900			ASSERT(next_ip != NULL);
2901			error = -EFSCORRUPTED;
2902			break;
2903		}
2904
2905next_inode:
2906		prev_agino = next_agino;
2907		next_agino = next_ip->i_next_unlinked;
2908	}
2909
2910out_agibp:
2911	xfs_trans_brelse(tp, agibp);
2912	/* Should have found this inode somewhere in the iunlinked bucket. */
2913	if (!error && !foundit)
2914		error = -EFSCORRUPTED;
2915	return error;
2916}
2917
2918/* Decide if this inode is missing its unlinked list and reload it. */
2919int
2920xfs_inode_reload_unlinked(
2921	struct xfs_inode	*ip)
2922{
2923	struct xfs_trans	*tp;
2924	int			error;
2925
2926	error = xfs_trans_alloc_empty(ip->i_mount, &tp);
2927	if (error)
2928		return error;
2929
2930	xfs_ilock(ip, XFS_ILOCK_SHARED);
2931	if (xfs_inode_unlinked_incomplete(ip))
2932		error = xfs_inode_reload_unlinked_bucket(tp, ip);
2933	xfs_iunlock(ip, XFS_ILOCK_SHARED);
2934	xfs_trans_cancel(tp);
2935
2936	return error;
2937}
2938
2939/* Has this inode fork been zapped by repair? */
2940bool
2941xfs_ifork_zapped(
2942	const struct xfs_inode	*ip,
2943	int			whichfork)
2944{
2945	unsigned int		datamask = 0;
2946
2947	switch (whichfork) {
2948	case XFS_DATA_FORK:
2949		switch (ip->i_vnode.i_mode & S_IFMT) {
2950		case S_IFDIR:
2951			datamask = XFS_SICK_INO_DIR_ZAPPED;
2952			break;
2953		case S_IFLNK:
2954			datamask = XFS_SICK_INO_SYMLINK_ZAPPED;
2955			break;
2956		}
2957		return ip->i_sick & (XFS_SICK_INO_BMBTD_ZAPPED | datamask);
2958	case XFS_ATTR_FORK:
2959		return ip->i_sick & XFS_SICK_INO_BMBTA_ZAPPED;
2960	default:
2961		return false;
2962	}
2963}
2964
2965/* Compute the number of data and realtime blocks used by a file. */
2966void
2967xfs_inode_count_blocks(
2968	struct xfs_trans	*tp,
2969	struct xfs_inode	*ip,
2970	xfs_filblks_t		*dblocks,
2971	xfs_filblks_t		*rblocks)
2972{
2973	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, XFS_DATA_FORK);
2974
2975	*rblocks = 0;
2976	if (XFS_IS_REALTIME_INODE(ip))
2977		xfs_bmap_count_leaves(ifp, rblocks);
2978	*dblocks = ip->i_nblocks - *rblocks;
2979}
2980
2981static void
2982xfs_wait_dax_page(
2983	struct inode		*inode)
2984{
2985	struct xfs_inode        *ip = XFS_I(inode);
2986
2987	xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
2988	schedule();
2989	xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
2990}
2991
2992int
2993xfs_break_dax_layouts(
2994	struct inode		*inode,
2995	bool			*retry)
2996{
2997	struct page		*page;
2998
2999	xfs_assert_ilocked(XFS_I(inode), XFS_MMAPLOCK_EXCL);
3000
3001	page = dax_layout_busy_page(inode->i_mapping);
3002	if (!page)
3003		return 0;
3004
3005	*retry = true;
3006	return ___wait_var_event(&page->_refcount,
3007			atomic_read(&page->_refcount) == 1, TASK_INTERRUPTIBLE,
3008			0, 0, xfs_wait_dax_page(inode));
3009}
3010
3011int
3012xfs_break_layouts(
3013	struct inode		*inode,
3014	uint			*iolock,
3015	enum layout_break_reason reason)
3016{
3017	bool			retry;
3018	int			error;
3019
3020	xfs_assert_ilocked(XFS_I(inode), XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL);
3021
3022	do {
3023		retry = false;
3024		switch (reason) {
3025		case BREAK_UNMAP:
3026			error = xfs_break_dax_layouts(inode, &retry);
3027			if (error || retry)
3028				break;
3029			fallthrough;
3030		case BREAK_WRITE:
3031			error = xfs_break_leased_layouts(inode, iolock, &retry);
3032			break;
3033		default:
3034			WARN_ON_ONCE(1);
3035			error = -EINVAL;
3036		}
3037	} while (error == 0 && retry);
3038
3039	return error;
3040}
3041
3042/* Returns the size of fundamental allocation unit for a file, in bytes. */
3043unsigned int
3044xfs_inode_alloc_unitsize(
3045	struct xfs_inode	*ip)
3046{
3047	unsigned int		blocks = 1;
3048
3049	if (XFS_IS_REALTIME_INODE(ip))
3050		blocks = ip->i_mount->m_sb.sb_rextsize;
3051
3052	return XFS_FSB_TO_B(ip->i_mount, blocks);
3053}
3054
3055/* Should we always be using copy on write for file writes? */
3056bool
3057xfs_is_always_cow_inode(
3058	const struct xfs_inode	*ip)
3059{
3060	return ip->i_mount->m_always_cow && xfs_has_reflink(ip->i_mount);
3061}