// SPDX-License-Identifier: GPL-2.0

  /*

   * Copyright (c) 2000-2006 Silicon Graphics, Inc.

   * All Rights Reserved.

   */

  #include <linux/iversion.h>

  #include "xfs.h"

  #include "xfs_fs.h"

  #include "xfs_shared.h"

  #include "xfs_format.h"
  #include "xfs_log_format.h"
  #include "xfs_trans_resv.h"

  #include "xfs_sb.h"

  #include "xfs_mount.h"

  #include "xfs_defer.h"

  #include "xfs_inode.h"

  #include "xfs_dir2.h"

  #include "xfs_attr.h"

  #include "xfs_trans_space.h"
  #include "xfs_trans.h"

  #include "xfs_buf_item.h"

  #include "xfs_inode_item.h"

  #include "xfs_ialloc.h"
  #include "xfs_bmap.h"

  #include "xfs_bmap_util.h"

  #include "xfs_errortag.h"

  #include "xfs_error.h"

  #include "xfs_quota.h"

  #include "xfs_filestream.h"

  #include "xfs_trace.h"

  #include "xfs_icache.h"

  #include "xfs_symlink.h"

  #include "xfs_trans_priv.h"
  #include "xfs_log.h"

  #include "xfs_bmap_btree.h"

  #include "xfs_reflink.h"

  kmem_zone_t *xfs_inode_zone;

  
  /*

   * Used in xfs_itruncate_extents().  This is the maximum number of extents

   * freed from a file in a single transaction.
   */
  #define	XFS_ITRUNC_MAX_EXTENTS	2

  STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
  STATIC int xfs_iunlink_remove(struct xfs_trans *, struct xfs_inode *);

  /*
   * helper function to extract extent size hint from inode
   */
  xfs_extlen_t
  xfs_get_extsz_hint(
  	struct xfs_inode	*ip)
  {

  	/*
  	 * No point in aligning allocations if we need to COW to actually
  	 * write to them.
  	 */
  	if (xfs_is_always_cow_inode(ip))
  		return 0;

  	if ((ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) && ip->i_d.di_extsize)
  		return ip->i_d.di_extsize;
  	if (XFS_IS_REALTIME_INODE(ip))
  		return ip->i_mount->m_sb.sb_rextsize;
  	return 0;
  }

  /*

   * Helper function to extract CoW extent size hint from inode.
   * Between the extent size hint and the CoW extent size hint, we

   * return the greater of the two.  If the value is zero (automatic),
   * use the default size.

   */
  xfs_extlen_t
  xfs_get_cowextsz_hint(
  	struct xfs_inode	*ip)
  {
  	xfs_extlen_t		a, b;
  
  	a = 0;
  	if (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
  		a = ip->i_d.di_cowextsize;
  	b = xfs_get_extsz_hint(ip);

  	a = max(a, b);
  	if (a == 0)
  		return XFS_DEFAULT_COWEXTSZ_HINT;
  	return a;

  }
  
  /*

   * These two are wrapper routines around the xfs_ilock() routine used to
   * centralize some grungy code.  They are used in places that wish to lock the
   * inode solely for reading the extents.  The reason these places can't just
   * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
   * bringing in of the extents from disk for a file in b-tree format.  If the
   * inode is in b-tree format, then we need to lock the inode exclusively until
   * the extents are read in.  Locking it exclusively all the time would limit
   * our parallelism unnecessarily, though.  What we do instead is check to see
   * if the extents have been read in yet, and only lock the inode exclusively
   * if they have not.

   *

   * The functions return a value which should be given to the corresponding

   * xfs_iunlock() call.

   */
  uint

  xfs_ilock_data_map_shared(
  	struct xfs_inode	*ip)

  {

  	uint			lock_mode = XFS_ILOCK_SHARED;

  	if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE &&

  	    (ip->i_df.if_flags & XFS_IFEXTENTS) == 0)

  		lock_mode = XFS_ILOCK_EXCL;

  	xfs_ilock(ip, lock_mode);

  	return lock_mode;
  }

  uint
  xfs_ilock_attr_map_shared(
  	struct xfs_inode	*ip)

  {

  	uint			lock_mode = XFS_ILOCK_SHARED;

  	if (ip->i_afp &&
  	    ip->i_afp->if_format == XFS_DINODE_FMT_BTREE &&

  	    (ip->i_afp->if_flags & XFS_IFEXTENTS) == 0)
  		lock_mode = XFS_ILOCK_EXCL;
  	xfs_ilock(ip, lock_mode);
  	return lock_mode;

  }
  
  /*

   * In addition to i_rwsem in the VFS inode, the xfs inode contains 2
   * multi-reader locks: i_mmap_lock and the i_lock.  This routine allows
   * various combinations of the locks to be obtained.

   *

   * The 3 locks should always be ordered so that the IO lock is obtained first,
   * the mmap lock second and the ilock last in order to prevent deadlock.

   *

   * Basic locking order:
   *

   * i_rwsem -> i_mmap_lock -> page_lock -> i_ilock

   *

   * mmap_lock locking order:

   *

   * i_rwsem -> page lock -> mmap_lock
   * mmap_lock -> i_mmap_lock -> page_lock

   *

   * The difference in mmap_lock locking order mean that we cannot hold the

   * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can

   * fault in pages during copy in/out (for buffered IO) or require the mmap_lock

   * in get_user_pages() to map the user pages into the kernel address space for

   * direct IO. Similarly the i_rwsem cannot be taken inside a page fault because

   * page faults already hold the mmap_lock.

   *
   * Hence to serialise fully against both syscall and mmap based IO, we need to

   * take both the i_rwsem and the i_mmap_lock. These locks should *only* be both

   * taken in places where we need to invalidate the page cache in a race
   * free manner (e.g. truncate, hole punch and other extent manipulation
   * functions).

   */
  void
  xfs_ilock(
  	xfs_inode_t		*ip,
  	uint			lock_flags)
  {
  	trace_xfs_ilock(ip, lock_flags, _RET_IP_);
  
  	/*
  	 * You can't set both SHARED and EXCL for the same lock,
  	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
  	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
  	 */
  	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
  	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
  	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
  	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));

  	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);

  	if (lock_flags & XFS_IOLOCK_EXCL) {
  		down_write_nested(&VFS_I(ip)->i_rwsem,
  				  XFS_IOLOCK_DEP(lock_flags));
  	} else if (lock_flags & XFS_IOLOCK_SHARED) {
  		down_read_nested(&VFS_I(ip)->i_rwsem,
  				 XFS_IOLOCK_DEP(lock_flags));
  	}

  	if (lock_flags & XFS_MMAPLOCK_EXCL)
  		mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
  	else if (lock_flags & XFS_MMAPLOCK_SHARED)
  		mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));

  	if (lock_flags & XFS_ILOCK_EXCL)
  		mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
  	else if (lock_flags & XFS_ILOCK_SHARED)
  		mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
  }
  
  /*
   * This is just like xfs_ilock(), except that the caller
   * is guaranteed not to sleep.  It returns 1 if it gets
   * the requested locks and 0 otherwise.  If the IO lock is
   * obtained but the inode lock cannot be, then the IO lock
   * is dropped before returning.
   *
   * ip -- the inode being locked
   * lock_flags -- this parameter indicates the inode's locks to be
   *       to be locked.  See the comment for xfs_ilock() for a list
   *	 of valid values.
   */
  int
  xfs_ilock_nowait(
  	xfs_inode_t		*ip,
  	uint			lock_flags)
  {
  	trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
  
  	/*
  	 * You can't set both SHARED and EXCL for the same lock,
  	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
  	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
  	 */
  	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
  	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
  	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
  	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));

  	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);

  
  	if (lock_flags & XFS_IOLOCK_EXCL) {

  		if (!down_write_trylock(&VFS_I(ip)->i_rwsem))

  			goto out;
  	} else if (lock_flags & XFS_IOLOCK_SHARED) {

  		if (!down_read_trylock(&VFS_I(ip)->i_rwsem))

  			goto out;
  	}

  
  	if (lock_flags & XFS_MMAPLOCK_EXCL) {
  		if (!mrtryupdate(&ip->i_mmaplock))
  			goto out_undo_iolock;
  	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
  		if (!mrtryaccess(&ip->i_mmaplock))
  			goto out_undo_iolock;
  	}

  	if (lock_flags & XFS_ILOCK_EXCL) {
  		if (!mrtryupdate(&ip->i_lock))

  			goto out_undo_mmaplock;

  	} else if (lock_flags & XFS_ILOCK_SHARED) {
  		if (!mrtryaccess(&ip->i_lock))

  			goto out_undo_mmaplock;

  	}
  	return 1;

  out_undo_mmaplock:
  	if (lock_flags & XFS_MMAPLOCK_EXCL)
  		mrunlock_excl(&ip->i_mmaplock);
  	else if (lock_flags & XFS_MMAPLOCK_SHARED)
  		mrunlock_shared(&ip->i_mmaplock);
  out_undo_iolock:

  	if (lock_flags & XFS_IOLOCK_EXCL)

  		up_write(&VFS_I(ip)->i_rwsem);

  	else if (lock_flags & XFS_IOLOCK_SHARED)

  		up_read(&VFS_I(ip)->i_rwsem);

  out:

  	return 0;
  }
  
  /*
   * xfs_iunlock() is used to drop the inode locks acquired with
   * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
   * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
   * that we know which locks to drop.
   *
   * ip -- the inode being unlocked
   * lock_flags -- this parameter indicates the inode's locks to be
   *       to be unlocked.  See the comment for xfs_ilock() for a list
   *	 of valid values for this parameter.
   *
   */
  void
  xfs_iunlock(
  	xfs_inode_t		*ip,
  	uint			lock_flags)
  {
  	/*
  	 * You can't set both SHARED and EXCL for the same lock,
  	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
  	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
  	 */
  	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
  	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
  	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));

  	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
  	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));

  	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);

  	ASSERT(lock_flags != 0);
  
  	if (lock_flags & XFS_IOLOCK_EXCL)

  		up_write(&VFS_I(ip)->i_rwsem);

  	else if (lock_flags & XFS_IOLOCK_SHARED)

  		up_read(&VFS_I(ip)->i_rwsem);

  	if (lock_flags & XFS_MMAPLOCK_EXCL)
  		mrunlock_excl(&ip->i_mmaplock);
  	else if (lock_flags & XFS_MMAPLOCK_SHARED)
  		mrunlock_shared(&ip->i_mmaplock);

  	if (lock_flags & XFS_ILOCK_EXCL)
  		mrunlock_excl(&ip->i_lock);
  	else if (lock_flags & XFS_ILOCK_SHARED)
  		mrunlock_shared(&ip->i_lock);
  
  	trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
  }
  
  /*
   * give up write locks.  the i/o lock cannot be held nested
   * if it is being demoted.
   */
  void
  xfs_ilock_demote(
  	xfs_inode_t		*ip,
  	uint			lock_flags)
  {

  	ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
  	ASSERT((lock_flags &
  		~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);

  
  	if (lock_flags & XFS_ILOCK_EXCL)
  		mrdemote(&ip->i_lock);

  	if (lock_flags & XFS_MMAPLOCK_EXCL)
  		mrdemote(&ip->i_mmaplock);

  	if (lock_flags & XFS_IOLOCK_EXCL)

  		downgrade_write(&VFS_I(ip)->i_rwsem);

  
  	trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
  }

  #if defined(DEBUG) || defined(XFS_WARN)

  int
  xfs_isilocked(
  	xfs_inode_t		*ip,
  	uint			lock_flags)
  {
  	if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
  		if (!(lock_flags & XFS_ILOCK_SHARED))
  			return !!ip->i_lock.mr_writer;
  		return rwsem_is_locked(&ip->i_lock.mr_lock);
  	}

  	if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
  		if (!(lock_flags & XFS_MMAPLOCK_SHARED))
  			return !!ip->i_mmaplock.mr_writer;
  		return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
  	}

  	if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
  		if (!(lock_flags & XFS_IOLOCK_SHARED))

  			return !debug_locks ||
  				lockdep_is_held_type(&VFS_I(ip)->i_rwsem, 0);
  		return rwsem_is_locked(&VFS_I(ip)->i_rwsem);

  	}
  
  	ASSERT(0);
  	return 0;
  }
  #endif

  /*
   * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
   * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
   * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
   * errors and warnings.
   */
  #if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)

  static bool
  xfs_lockdep_subclass_ok(
  	int subclass)
  {
  	return subclass < MAX_LOCKDEP_SUBCLASSES;
  }
  #else
  #define xfs_lockdep_subclass_ok(subclass)	(true)
  #endif

  /*

   * Bump the subclass so xfs_lock_inodes() acquires each lock with a different

   * value. This can be called for any type of inode lock combination, including
   * parent locking. Care must be taken to ensure we don't overrun the subclass
   * storage fields in the class mask we build.

   */
  static inline int
  xfs_lock_inumorder(int lock_mode, int subclass)
  {

  	int	class = 0;
  
  	ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
  			      XFS_ILOCK_RTSUM)));

  	ASSERT(xfs_lockdep_subclass_ok(subclass));

  	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {

  		ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);

  		class += subclass << XFS_IOLOCK_SHIFT;

  	}
  
  	if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {

  		ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
  		class += subclass << XFS_MMAPLOCK_SHIFT;

  	}

  	if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
  		ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
  		class += subclass << XFS_ILOCK_SHIFT;
  	}

  	return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;

  }
  
  /*

   * The following routine will lock n inodes in exclusive mode.  We assume the
   * caller calls us with the inodes in i_ino order.

   *

   * We need to detect deadlock where an inode that we lock is in the AIL and we
   * start waiting for another inode that is locked by a thread in a long running
   * transaction (such as truncate). This can result in deadlock since the long
   * running trans might need to wait for the inode we just locked in order to
   * push the tail and free space in the log.

   *
   * xfs_lock_inodes() can only be used to lock one type of lock at a time -
   * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
   * lock more than one at a time, lockdep will report false positives saying we
   * have violated locking orders.

   */

  static void

  xfs_lock_inodes(

  	struct xfs_inode	**ips,
  	int			inodes,
  	uint			lock_mode)

  {

  	int			attempts = 0, i, j, try_lock;
  	struct xfs_log_item	*lp;

  	/*
  	 * Currently supports between 2 and 5 inodes with exclusive locking.  We
  	 * support an arbitrary depth of locking here, but absolute limits on

  	 * inodes depend on the type of locking and the limits placed by

  	 * lockdep annotations in xfs_lock_inumorder.  These are all checked by
  	 * the asserts.
  	 */

  	ASSERT(ips && inodes >= 2 && inodes <= 5);

  	ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
  			    XFS_ILOCK_EXCL));
  	ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
  			      XFS_ILOCK_SHARED)));

  	ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
  		inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
  	ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
  		inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
  
  	if (lock_mode & XFS_IOLOCK_EXCL) {
  		ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
  	} else if (lock_mode & XFS_MMAPLOCK_EXCL)
  		ASSERT(!(lock_mode & XFS_ILOCK_EXCL));

  
  	try_lock = 0;
  	i = 0;

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

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

  			continue;
  
  		/*

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

  		 */

  		if (!try_lock) {
  			for (j = (i - 1); j >= 0 && !try_lock; j--) {

  				lp = &ips[j]->i_itemp->ili_item;

  				if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))

  					try_lock++;

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

  		if (!try_lock) {
  			xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
  			continue;
  		}
  
  		/* try_lock means we have an inode locked that is in the AIL. */
  		ASSERT(i != 0);
  		if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
  			continue;

  		/*
  		 * Unlock all previous guys and try again.  xfs_iunlock will try
  		 * to push the tail if the inode is in the AIL.
  		 */
  		attempts++;
  		for (j = i - 1; j >= 0; j--) {

  			/*

  			 * Check to see if we've already unlocked this one.  Not
  			 * the first one going back, and the inode ptr is the
  			 * same.

  			 */

  			if (j != (i - 1) && ips[j] == ips[j + 1])
  				continue;

  			xfs_iunlock(ips[j], lock_mode);
  		}

  		if ((attempts % 5) == 0) {
  			delay(1); /* Don't just spin the CPU */

  		}

  		i = 0;
  		try_lock = 0;
  		goto again;

  	}

  }
  
  /*

   * xfs_lock_two_inodes() can only be used to lock one type of lock at a time -

   * the mmaplock or the ilock, but not more than one type at a time. If we lock
   * more than one at a time, lockdep will report false positives saying we have
   * violated locking orders.  The iolock must be double-locked separately since
   * we use i_rwsem for that.  We now support taking one lock EXCL and the other
   * SHARED.

   */
  void
  xfs_lock_two_inodes(

  	struct xfs_inode	*ip0,
  	uint			ip0_mode,
  	struct xfs_inode	*ip1,
  	uint			ip1_mode)

  {

  	struct xfs_inode	*temp;
  	uint			mode_temp;

  	int			attempts = 0;

  	struct xfs_log_item	*lp;

  	ASSERT(hweight32(ip0_mode) == 1);
  	ASSERT(hweight32(ip1_mode) == 1);
  	ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
  	ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
  	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
  	       !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
  	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
  	       !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
  	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
  	       !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
  	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
  	       !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));

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

  		mode_temp = ip0_mode;
  		ip0_mode = ip1_mode;
  		ip1_mode = mode_temp;

  	}
  
   again:

  	xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));

  
  	/*
  	 * If the first lock we have locked is in the AIL, we must TRY to get
  	 * the second lock. If we can't get it, we must release the first one
  	 * and try again.
  	 */

  	lp = &ip0->i_itemp->ili_item;

  	if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {

  		if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
  			xfs_iunlock(ip0, ip0_mode);

  			if ((++attempts % 5) == 0)
  				delay(1); /* Don't just spin the CPU */
  			goto again;
  		}
  	} else {

  		xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));

  	}
  }

  STATIC uint
  _xfs_dic2xflags(

  	uint16_t		di_flags,

  	uint64_t		di_flags2,
  	bool			has_attr)

  {
  	uint			flags = 0;
  
  	if (di_flags & XFS_DIFLAG_ANY) {
  		if (di_flags & XFS_DIFLAG_REALTIME)

  			flags |= FS_XFLAG_REALTIME;

  		if (di_flags & XFS_DIFLAG_PREALLOC)

  			flags |= FS_XFLAG_PREALLOC;

  		if (di_flags & XFS_DIFLAG_IMMUTABLE)

  			flags |= FS_XFLAG_IMMUTABLE;

  		if (di_flags & XFS_DIFLAG_APPEND)

  			flags |= FS_XFLAG_APPEND;

  		if (di_flags & XFS_DIFLAG_SYNC)

  			flags |= FS_XFLAG_SYNC;

  		if (di_flags & XFS_DIFLAG_NOATIME)

  			flags |= FS_XFLAG_NOATIME;

  		if (di_flags & XFS_DIFLAG_NODUMP)

  			flags |= FS_XFLAG_NODUMP;

  		if (di_flags & XFS_DIFLAG_RTINHERIT)

  			flags |= FS_XFLAG_RTINHERIT;

  		if (di_flags & XFS_DIFLAG_PROJINHERIT)

  			flags |= FS_XFLAG_PROJINHERIT;

  		if (di_flags & XFS_DIFLAG_NOSYMLINKS)

  			flags |= FS_XFLAG_NOSYMLINKS;

  		if (di_flags & XFS_DIFLAG_EXTSIZE)

  			flags |= FS_XFLAG_EXTSIZE;

  		if (di_flags & XFS_DIFLAG_EXTSZINHERIT)

  			flags |= FS_XFLAG_EXTSZINHERIT;

  		if (di_flags & XFS_DIFLAG_NODEFRAG)

  			flags |= FS_XFLAG_NODEFRAG;

  		if (di_flags & XFS_DIFLAG_FILESTREAM)

  			flags |= FS_XFLAG_FILESTREAM;

  	}

  	if (di_flags2 & XFS_DIFLAG2_ANY) {
  		if (di_flags2 & XFS_DIFLAG2_DAX)
  			flags |= FS_XFLAG_DAX;

  		if (di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
  			flags |= FS_XFLAG_COWEXTSIZE;

  	}
  
  	if (has_attr)
  		flags |= FS_XFLAG_HASATTR;

  	return flags;
  }
  
  uint
  xfs_ip2xflags(

  	struct xfs_inode	*ip)

  {

  	struct xfs_icdinode	*dic = &ip->i_d;

  	return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip));

  }

  /*

   * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
   * is allowed, otherwise it has to be an exact match. If a CI match is found,
   * ci_name->name will point to a the actual name (caller must free) or
   * will be set to NULL if an exact match is found.
   */
  int
  xfs_lookup(
  	xfs_inode_t		*dp,
  	struct xfs_name		*name,
  	xfs_inode_t		**ipp,
  	struct xfs_name		*ci_name)
  {
  	xfs_ino_t		inum;
  	int			error;

  
  	trace_xfs_lookup(dp, name);
  
  	if (XFS_FORCED_SHUTDOWN(dp->i_mount))

  		return -EIO;

  	error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);

  	if (error)

  		goto out_unlock;

  
  	error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
  	if (error)
  		goto out_free_name;
  
  	return 0;
  
  out_free_name:
  	if (ci_name)
  		kmem_free(ci_name->name);

  out_unlock:

  	*ipp = NULL;
  	return error;
  }

  /* Propagate di_flags from a parent inode to a child inode. */
  static void
  xfs_inode_inherit_flags(
  	struct xfs_inode	*ip,
  	const struct xfs_inode	*pip)
  {
  	unsigned int		di_flags = 0;
  	umode_t			mode = VFS_I(ip)->i_mode;
  
  	if (S_ISDIR(mode)) {
  		if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
  			di_flags |= XFS_DIFLAG_RTINHERIT;
  		if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
  			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
  			ip->i_d.di_extsize = pip->i_d.di_extsize;
  		}
  		if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
  			di_flags |= XFS_DIFLAG_PROJINHERIT;
  	} else if (S_ISREG(mode)) {

  		if ((pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) &&
  		    xfs_sb_version_hasrealtime(&ip->i_mount->m_sb))

  			di_flags |= XFS_DIFLAG_REALTIME;
  		if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
  			di_flags |= XFS_DIFLAG_EXTSIZE;
  			ip->i_d.di_extsize = pip->i_d.di_extsize;
  		}
  	}
  	if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
  	    xfs_inherit_noatime)
  		di_flags |= XFS_DIFLAG_NOATIME;
  	if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
  	    xfs_inherit_nodump)
  		di_flags |= XFS_DIFLAG_NODUMP;
  	if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
  	    xfs_inherit_sync)
  		di_flags |= XFS_DIFLAG_SYNC;
  	if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
  	    xfs_inherit_nosymlinks)
  		di_flags |= XFS_DIFLAG_NOSYMLINKS;
  	if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
  	    xfs_inherit_nodefrag)
  		di_flags |= XFS_DIFLAG_NODEFRAG;
  	if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
  		di_flags |= XFS_DIFLAG_FILESTREAM;
  
  	ip->i_d.di_flags |= di_flags;
  }
  
  /* Propagate di_flags2 from a parent inode to a child inode. */
  static void
  xfs_inode_inherit_flags2(
  	struct xfs_inode	*ip,
  	const struct xfs_inode	*pip)
  {
  	if (pip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) {
  		ip->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
  		ip->i_d.di_cowextsize = pip->i_d.di_cowextsize;
  	}
  	if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
  		ip->i_d.di_flags2 |= XFS_DIFLAG2_DAX;
  }

  /*

   * Allocate an inode on disk and return a copy of its in-core version.
   * The in-core inode is locked exclusively.  Set mode, nlink, and rdev
   * appropriately within the inode.  The uid and gid for the inode are
   * set according to the contents of the given cred structure.
   *
   * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()

   * has a free inode available, call xfs_iget() to obtain the in-core
   * version of the allocated inode.  Finally, fill in the inode and
   * log its initial contents.  In this case, ialloc_context would be
   * set to NULL.

   *

   * If xfs_dialloc() does not have an available inode, it will replenish
   * its supply by doing an allocation. Since we can only do one
   * allocation within a transaction without deadlocks, we must commit
   * the current transaction before returning the inode itself.
   * In this case, therefore, we will set ialloc_context and return.

   * The caller should then commit the current transaction, start a new
   * transaction, and call xfs_ialloc() again to actually get the inode.
   *
   * To ensure that some other process does not grab the inode that
   * was allocated during the first call to xfs_ialloc(), this routine
   * also returns the [locked] bp pointing to the head of the freelist
   * as ialloc_context.  The caller should hold this buffer across
   * the commit and pass it back into this routine on the second call.

   *
   * If we are allocating quota inodes, we do not have a parent inode
   * to attach to or associate with (i.e. pip == NULL) because they
   * are not linked into the directory structure - they are attached
   * directly to the superblock - and so have no parent.

   */

  static int

  xfs_ialloc(
  	xfs_trans_t	*tp,
  	xfs_inode_t	*pip,

  	umode_t		mode,

  	xfs_nlink_t	nlink,

  	dev_t		rdev,

  	prid_t		prid,

  	xfs_buf_t	**ialloc_context,

  	xfs_inode_t	**ipp)
  {

  	struct xfs_mount *mp = tp->t_mountp;

  	xfs_ino_t	ino;
  	xfs_inode_t	*ip;

  	uint		flags;
  	int		error;

  	struct timespec64 tv;

  	struct inode	*inode;

  
  	/*
  	 * Call the space management code to pick
  	 * the on-disk inode to be allocated.
  	 */

  	error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode,

  			    ialloc_context, &ino);

  	if (error)

  		return error;

  	if (*ialloc_context || ino == NULLFSINO) {

  		*ipp = NULL;
  		return 0;
  	}
  	ASSERT(*ialloc_context == NULL);
  
  	/*

  	 * Protect against obviously corrupt allocation btree records. Later
  	 * xfs_iget checks will catch re-allocation of other active in-memory
  	 * and on-disk inodes. If we don't catch reallocating the parent inode
  	 * here we will deadlock in xfs_iget() so we have to do these checks
  	 * first.
  	 */
  	if ((pip && ino == pip->i_ino) || !xfs_verify_dir_ino(mp, ino)) {
  		xfs_alert(mp, "Allocated a known in-use inode 0x%llx!", ino);
  		return -EFSCORRUPTED;
  	}
  
  	/*

  	 * Get the in-core inode with the lock held exclusively.
  	 * This is because we're setting fields here we need
  	 * to prevent others from looking at until we're done.
  	 */

  	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,

  			 XFS_ILOCK_EXCL, &ip);

  	if (error)

  		return error;

  	ASSERT(ip != NULL);

  	inode = VFS_I(ip);

  	inode->i_mode = mode;

  	set_nlink(inode, nlink);

  	inode->i_uid = current_fsuid();

  	inode->i_rdev = rdev;

  	ip->i_d.di_projid = prid;

  	if (pip && XFS_INHERIT_GID(pip)) {

  		inode->i_gid = VFS_I(pip)->i_gid;

  		if ((VFS_I(pip)->i_mode & S_ISGID) && S_ISDIR(mode))
  			inode->i_mode |= S_ISGID;

  	} else {
  		inode->i_gid = current_fsgid();

  	}
  
  	/*
  	 * If the group ID of the new file does not match the effective group
  	 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
  	 * (and only if the irix_sgid_inherit compatibility variable is set).
  	 */

  	if (irix_sgid_inherit &&
  	    (inode->i_mode & S_ISGID) && !in_group_p(inode->i_gid))

  		inode->i_mode &= ~S_ISGID;

  
  	ip->i_d.di_size = 0;

  	ip->i_df.if_nextents = 0;

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

  	tv = current_time(inode);

  	inode->i_mtime = tv;
  	inode->i_atime = tv;
  	inode->i_ctime = tv;

  	ip->i_d.di_extsize = 0;
  	ip->i_d.di_dmevmask = 0;
  	ip->i_d.di_dmstate = 0;
  	ip->i_d.di_flags = 0;

  	if (xfs_sb_version_has_v3inode(&mp->m_sb)) {

  		inode_set_iversion(inode, 1);

  		ip->i_d.di_flags2 = mp->m_ino_geo.new_diflags2;

  		ip->i_d.di_cowextsize = 0;

  		ip->i_d.di_crtime = tv;

  	}

  	flags = XFS_ILOG_CORE;
  	switch (mode & S_IFMT) {
  	case S_IFIFO:
  	case S_IFCHR:
  	case S_IFBLK:
  	case S_IFSOCK:

  		ip->i_df.if_format = XFS_DINODE_FMT_DEV;

  		ip->i_df.if_flags = 0;
  		flags |= XFS_ILOG_DEV;
  		break;
  	case S_IFREG:
  	case S_IFDIR:

  		if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY))
  			xfs_inode_inherit_flags(ip, pip);
  		if (pip && (pip->i_d.di_flags2 & XFS_DIFLAG2_ANY))
  			xfs_inode_inherit_flags2(ip, pip);

  		/* FALLTHROUGH */
  	case S_IFLNK:

  		ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;

  		ip->i_df.if_flags = XFS_IFEXTENTS;

  		ip->i_df.if_bytes = 0;

  		ip->i_df.if_u1.if_root = NULL;

  		break;
  	default:
  		ASSERT(0);
  	}

  
  	/*
  	 * Log the new values stuffed into the inode.
  	 */

  	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

  	xfs_trans_log_inode(tp, ip, flags);

  	/* now that we have an i_mode we can setup the inode structure */

  	xfs_setup_inode(ip);

  
  	*ipp = ip;
  	return 0;
  }

  /*
   * Allocates a new inode from disk and return a pointer to the
   * incore copy. This routine will internally commit the current
   * transaction and allocate a new one if the Space Manager needed
   * to do an allocation to replenish the inode free-list.
   *
   * This routine is designed to be called from xfs_create and
   * xfs_create_dir.
   *
   */
  int
  xfs_dir_ialloc(
  	xfs_trans_t	**tpp,		/* input: current transaction;
  					   output: may be a new transaction. */
  	xfs_inode_t	*dp,		/* directory within whose allocate
  					   the inode. */
  	umode_t		mode,
  	xfs_nlink_t	nlink,

  	dev_t		rdev,

  	prid_t		prid,		/* project id */

  	xfs_inode_t	**ipp)		/* pointer to inode; it will be

  					   locked. */

  {
  	xfs_trans_t	*tp;

  	xfs_inode_t	*ip;
  	xfs_buf_t	*ialloc_context = NULL;
  	int		code;

  	void		*dqinfo;
  	uint		tflags;
  
  	tp = *tpp;
  	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
  
  	/*
  	 * xfs_ialloc will return a pointer to an incore inode if
  	 * the Space Manager has an available inode on the free
  	 * list. Otherwise, it will do an allocation and replenish
  	 * the freelist.  Since we can only do one allocation per
  	 * transaction without deadlocks, we will need to commit the
  	 * current transaction and start a new one.  We will then
  	 * need to call xfs_ialloc again to get the inode.
  	 *
  	 * If xfs_ialloc did an allocation to replenish the freelist,
  	 * it returns the bp containing the head of the freelist as
  	 * ialloc_context. We will hold a lock on it across the
  	 * transaction commit so that no other process can steal
  	 * the inode(s) that we've just allocated.
  	 */

  	code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, &ialloc_context,
  			&ip);

  
  	/*
  	 * Return an error if we were unable to allocate a new inode.
  	 * This should only happen if we run out of space on disk or
  	 * encounter a disk error.
  	 */
  	if (code) {
  		*ipp = NULL;
  		return code;
  	}
  	if (!ialloc_context && !ip) {
  		*ipp = NULL;

  		return -ENOSPC;

  	}
  
  	/*
  	 * If the AGI buffer is non-NULL, then we were unable to get an
  	 * inode in one operation.  We need to commit the current
  	 * transaction and call xfs_ialloc() again.  It is guaranteed
  	 * to succeed the second time.
  	 */
  	if (ialloc_context) {
  		/*
  		 * Normally, xfs_trans_commit releases all the locks.
  		 * We call bhold to hang on to the ialloc_context across
  		 * the commit.  Holding this buffer prevents any other
  		 * processes from doing any allocations in this
  		 * allocation group.
  		 */
  		xfs_trans_bhold(tp, ialloc_context);

  
  		/*
  		 * We want the quota changes to be associated with the next
  		 * transaction, NOT this one. So, detach the dqinfo from this
  		 * and attach it to the next transaction.
  		 */
  		dqinfo = NULL;
  		tflags = 0;
  		if (tp->t_dqinfo) {
  			dqinfo = (void *)tp->t_dqinfo;
  			tp->t_dqinfo = NULL;
  			tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
  			tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
  		}

  		code = xfs_trans_roll(&tp);

  		/*
  		 * Re-attach the quota info that we detached from prev trx.
  		 */
  		if (dqinfo) {
  			tp->t_dqinfo = dqinfo;
  			tp->t_flags |= tflags;
  		}
  
  		if (code) {
  			xfs_buf_relse(ialloc_context);

  			*tpp = tp;

  			*ipp = NULL;
  			return code;
  		}
  		xfs_trans_bjoin(tp, ialloc_context);
  
  		/*
  		 * Call ialloc again. Since we've locked out all
  		 * other allocations in this allocation group,
  		 * this call should always succeed.
  		 */
  		code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,

  				  &ialloc_context, &ip);

  
  		/*
  		 * If we get an error at this point, return to the caller
  		 * so that the current transaction can be aborted.
  		 */
  		if (code) {
  			*tpp = tp;
  			*ipp = NULL;
  			return code;
  		}
  		ASSERT(!ialloc_context && ip);

  	}
  
  	*ipp = ip;
  	*tpp = tp;
  
  	return 0;
  }
  
  /*

   * Decrement the link count on an inode & log the change.  If this causes the
   * link count to go to zero, move the inode to AGI unlinked list so that it can
   * be freed when the last active reference goes away via xfs_inactive().

   */

  static int			/* error */

  xfs_droplink(
  	xfs_trans_t *tp,
  	xfs_inode_t *ip)
  {

  	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);

  	drop_nlink(VFS_I(ip));
  	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

  	if (VFS_I(ip)->i_nlink)
  		return 0;
  
  	return xfs_iunlink(tp, ip);

  }
  
  /*

   * Increment the link count on an inode & log the change.
   */

  static void

  xfs_bumplink(
  	xfs_trans_t *tp,
  	xfs_inode_t *ip)
  {
  	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);

  	inc_nlink(VFS_I(ip));

  	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

  }

  int
  xfs_create(
  	xfs_inode_t		*dp,
  	struct xfs_name		*name,
  	umode_t			mode,

  	dev_t			rdev,

  	xfs_inode_t		**ipp)
  {
  	int			is_dir = S_ISDIR(mode);
  	struct xfs_mount	*mp = dp->i_mount;
  	struct xfs_inode	*ip = NULL;
  	struct xfs_trans	*tp = NULL;
  	int			error;

  	bool                    unlock_dp_on_error = false;

  	prid_t			prid;
  	struct xfs_dquot	*udqp = NULL;
  	struct xfs_dquot	*gdqp = NULL;
  	struct xfs_dquot	*pdqp = NULL;

  	struct xfs_trans_res	*tres;

  	uint			resblks;

  
  	trace_xfs_create(dp, name);
  
  	if (XFS_FORCED_SHUTDOWN(mp))

  		return -EIO;

  	prid = xfs_get_initial_prid(dp);

  
  	/*
  	 * Make sure that we have allocated dquot(s) on disk.
  	 */

  	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,

  					XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
  					&udqp, &gdqp, &pdqp);
  	if (error)
  		return error;
  
  	if (is_dir) {

  		resblks = XFS_MKDIR_SPACE_RES(mp, name->len);

  		tres = &M_RES(mp)->tr_mkdir;

  	} else {
  		resblks = XFS_CREATE_SPACE_RES(mp, name->len);

  		tres = &M_RES(mp)->tr_create;

  	}

  	/*
  	 * Initially assume that the file does not exist and
  	 * reserve the resources for that case.  If that is not
  	 * the case we'll drop the one we have and get a more
  	 * appropriate transaction later.
  	 */

  	error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);

  	if (error == -ENOSPC) {

  		/* flush outstanding delalloc blocks and retry */
  		xfs_flush_inodes(mp);

  		error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);

  	}

  	if (error)

  		goto out_release_inode;

  	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);

  	unlock_dp_on_error = true;

  	/*
  	 * Reserve disk quota and the inode.
  	 */
  	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
  						pdqp, resblks, 1, 0);
  	if (error)
  		goto out_trans_cancel;

  	/*
  	 * A newly created regular or special file just has one directory
  	 * entry pointing to them, but a directory also the "." entry
  	 * pointing to itself.
  	 */

  	error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, prid, &ip);

  	if (error)

  		goto out_trans_cancel;

  
  	/*
  	 * Now we join the directory inode to the transaction.  We do not do it
  	 * earlier because xfs_dir_ialloc might commit the previous transaction
  	 * (and release all the locks).  An error from here on will result in
  	 * the transaction cancel unlocking dp so don't do it explicitly in the
  	 * error path.
  	 */

  	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);

  	unlock_dp_on_error = false;

  	error = xfs_dir_createname(tp, dp, name, ip->i_ino,

  					resblks - XFS_IALLOC_SPACE_RES(mp));

  	if (error) {

  		ASSERT(error != -ENOSPC);

  		goto out_trans_cancel;

  	}
  	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
  
  	if (is_dir) {
  		error = xfs_dir_init(tp, ip, dp);
  		if (error)

  			goto out_trans_cancel;

  		xfs_bumplink(tp, dp);

  	}
  
  	/*
  	 * If this is a synchronous mount, make sure that the
  	 * create transaction goes to disk before returning to
  	 * the user.
  	 */
  	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
  		xfs_trans_set_sync(tp);
  
  	/*
  	 * Attach the dquot(s) to the inodes and modify them incore.
  	 * These ids of the inode couldn't have changed since the new
  	 * inode has been locked ever since it was created.
  	 */
  	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);

  	error = xfs_trans_commit(tp);

  	if (error)
  		goto out_release_inode;
  
  	xfs_qm_dqrele(udqp);
  	xfs_qm_dqrele(gdqp);
  	xfs_qm_dqrele(pdqp);
  
  	*ipp = ip;
  	return 0;

   out_trans_cancel:

  	xfs_trans_cancel(tp);

   out_release_inode:
  	/*

  	 * Wait until after the current transaction is aborted to finish the
  	 * setup of the inode and release the inode.  This prevents recursive
  	 * transactions and deadlocks from xfs_inactive.

  	 */

  	if (ip) {
  		xfs_finish_inode_setup(ip);

  		xfs_irele(ip);

  	}

  
  	xfs_qm_dqrele(udqp);
  	xfs_qm_dqrele(gdqp);
  	xfs_qm_dqrele(pdqp);
  
  	if (unlock_dp_on_error)

  		xfs_iunlock(dp, XFS_ILOCK_EXCL);

  	return error;
  }
  
  int

  xfs_create_tmpfile(
  	struct xfs_inode	*dp,

  	umode_t			mode,
  	struct xfs_inode	**ipp)

  {
  	struct xfs_mount	*mp = dp->i_mount;
  	struct xfs_inode	*ip = NULL;
  	struct xfs_trans	*tp = NULL;
  	int			error;

  	prid_t                  prid;
  	struct xfs_dquot	*udqp = NULL;
  	struct xfs_dquot	*gdqp = NULL;
  	struct xfs_dquot	*pdqp = NULL;
  	struct xfs_trans_res	*tres;
  	uint			resblks;
  
  	if (XFS_FORCED_SHUTDOWN(mp))

  		return -EIO;

  
  	prid = xfs_get_initial_prid(dp);
  
  	/*
  	 * Make sure that we have allocated dquot(s) on disk.
  	 */

  	error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,

  				XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
  				&udqp, &gdqp, &pdqp);
  	if (error)
  		return error;
  
  	resblks = XFS_IALLOC_SPACE_RES(mp);

  	tres = &M_RES(mp)->tr_create_tmpfile;

  
  	error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);

  	if (error)

  		goto out_release_inode;

  
  	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
  						pdqp, resblks, 1, 0);
  	if (error)
  		goto out_trans_cancel;

  	error = xfs_dir_ialloc(&tp, dp, mode, 0, 0, prid, &ip);

  	if (error)

  		goto out_trans_cancel;

  
  	if (mp->m_flags & XFS_MOUNT_WSYNC)
  		xfs_trans_set_sync(tp);
  
  	/*
  	 * Attach the dquot(s) to the inodes and modify them incore.
  	 * These ids of the inode couldn't have changed since the new
  	 * inode has been locked ever since it was created.
  	 */
  	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);

  	error = xfs_iunlink(tp, ip);
  	if (error)

  		goto out_trans_cancel;

  	error = xfs_trans_commit(tp);

  	if (error)
  		goto out_release_inode;
  
  	xfs_qm_dqrele(udqp);
  	xfs_qm_dqrele(gdqp);
  	xfs_qm_dqrele(pdqp);

  	*ipp = ip;

  	return 0;

   out_trans_cancel:

  	xfs_trans_cancel(tp);

   out_release_inode:
  	/*

  	 * Wait until after the current transaction is aborted to finish the
  	 * setup of the inode and release the inode.  This prevents recursive
  	 * transactions and deadlocks from xfs_inactive.

  	 */

  	if (ip) {
  		xfs_finish_inode_setup(ip);

  		xfs_irele(ip);

  	}

  
  	xfs_qm_dqrele(udqp);
  	xfs_qm_dqrele(gdqp);
  	xfs_qm_dqrele(pdqp);
  
  	return error;
  }
  
  int

  xfs_link(
  	xfs_inode_t		*tdp,
  	xfs_inode_t		*sip,
  	struct xfs_name		*target_name)
  {
  	xfs_mount_t		*mp = tdp->i_mount;
  	xfs_trans_t		*tp;
  	int			error;

  	int			resblks;
  
  	trace_xfs_link(tdp, target_name);

  	ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));

  
  	if (XFS_FORCED_SHUTDOWN(mp))

  		return -EIO;

  	error = xfs_qm_dqattach(sip);

  	if (error)
  		goto std_return;

  	error = xfs_qm_dqattach(tdp);

  	if (error)
  		goto std_return;

  	resblks = XFS_LINK_SPACE_RES(mp, target_name->len);

  	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);

  	if (error == -ENOSPC) {

  		resblks = 0;

  		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);

  	}

  	if (error)

  		goto std_return;

  	xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);

  
  	xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);

  	xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);

  
  	/*
  	 * If we are using project inheritance, we only allow hard link
  	 * creation in our tree when the project IDs are the same; else
  	 * the tree quota mechanism could be circumvented.
  	 */
  	if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&

  		     tdp->i_d.di_projid != sip->i_d.di_projid)) {

  		error = -EXDEV;

  		goto error_return;
  	}

  	if (!resblks) {
  		error = xfs_dir_canenter(tp, tdp, target_name);
  		if (error)
  			goto error_return;
  	}

  	/*
  	 * Handle initial link state of O_TMPFILE inode
  	 */
  	if (VFS_I(sip)->i_nlink == 0) {

  		error = xfs_iunlink_remove(tp, sip);
  		if (error)

  			goto error_return;

  	}

  	error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,

  				   resblks);

  	if (error)

  		goto error_return;

  	xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  	xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);

  	xfs_bumplink(tp, sip);

  
  	/*
  	 * If this is a synchronous mount, make sure that the
  	 * link transaction goes to disk before returning to
  	 * the user.
  	 */

  	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))

  		xfs_trans_set_sync(tp);

  	return xfs_trans_commit(tp);

   error_return:

  	xfs_trans_cancel(tp);

   std_return:
  	return error;
  }

  /* Clear the reflink flag and the cowblocks tag if possible. */
  static void
  xfs_itruncate_clear_reflink_flags(
  	struct xfs_inode	*ip)
  {
  	struct xfs_ifork	*dfork;
  	struct xfs_ifork	*cfork;
  
  	if (!xfs_is_reflink_inode(ip))
  		return;
  	dfork = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
  	cfork = XFS_IFORK_PTR(ip, XFS_COW_FORK);
  	if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
  		ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
  	if (cfork->if_bytes == 0)
  		xfs_inode_clear_cowblocks_tag(ip);
  }

  /*

   * Free up the underlying blocks past new_size.  The new size must be smaller
   * than the current size.  This routine can be used both for the attribute and
   * data fork, and does not modify the inode size, which is left to the caller.

   *

   * The transaction passed to this routine must have made a permanent log
   * reservation of at least XFS_ITRUNCATE_LOG_RES.  This routine may commit the
   * given transaction and start new ones, so make sure everything involved in
   * the transaction is tidy before calling here.  Some transaction will be
   * returned to the caller to be committed.  The incoming transaction must
   * already include the inode, and both inode locks must be held exclusively.
   * The inode must also be "held" within the transaction.  On return the inode
   * will be "held" within the returned transaction.  This routine does NOT
   * require any disk space to be reserved for it within the transaction.

   *

   * If we get an error, we must return with the inode locked and linked into the
   * current transaction. This keeps things simple for the higher level code,
   * because it always knows that the inode is locked and held in the transaction
   * that returns to it whether errors occur or not.  We don't mark the inode
   * dirty on error so that transactions can be easily aborted if possible.

   */
  int

  xfs_itruncate_extents_flags(

  	struct xfs_trans	**tpp,
  	struct xfs_inode	*ip,
  	int			whichfork,

  	xfs_fsize_t		new_size,

  	int			flags)

  {

  	struct xfs_mount	*mp = ip->i_mount;
  	struct xfs_trans	*tp = *tpp;

  	xfs_fileoff_t		first_unmap_block;

  	xfs_filblks_t		unmap_len;

  	int			error = 0;

  	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
  	ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
  	       xfs_isilocked(ip, XFS_IOLOCK_EXCL));

  	ASSERT(new_size <= XFS_ISIZE(ip));

  	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);

  	ASSERT(ip->i_itemp != NULL);

  	ASSERT(ip->i_itemp->ili_lock_flags == 0);

  	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));

  	trace_xfs_itruncate_extents_start(ip, new_size);

  	flags |= xfs_bmapi_aflag(whichfork);

  	/*
  	 * Since it is possible for space to become allocated beyond
  	 * the end of the file (in a crash where the space is allocated
  	 * but the inode size is not yet updated), simply remove any
  	 * blocks which show up between the new EOF and the maximum

  	 * possible file size.
  	 *
  	 * We have to free all the blocks to the bmbt maximum offset, even if
  	 * the page cache can't scale that far.

  	 */

  	first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);

  	if (first_unmap_block >= XFS_MAX_FILEOFF) {
  		WARN_ON_ONCE(first_unmap_block > XFS_MAX_FILEOFF);

  		return 0;

  	}

  	unmap_len = XFS_MAX_FILEOFF - first_unmap_block + 1;
  	while (unmap_len > 0) {

  		ASSERT(tp->t_firstblock == NULLFSBLOCK);

  		error = __xfs_bunmapi(tp, ip, first_unmap_block, &unmap_len,
  				flags, XFS_ITRUNC_MAX_EXTENTS);

  		if (error)

  			goto out;

  		/* free the just unmapped extents */

  		error = xfs_defer_finish(&tp);

  		if (error)

  			goto out;

  	}

  	if (whichfork == XFS_DATA_FORK) {
  		/* Remove all pending CoW reservations. */
  		error = xfs_reflink_cancel_cow_blocks(ip, &tp,

  				first_unmap_block, XFS_MAX_FILEOFF, true);

  		if (error)
  			goto out;

  		xfs_itruncate_clear_reflink_flags(ip);
  	}

  	/*
  	 * Always re-log the inode so that our permanent transaction can keep
  	 * on rolling it forward in the log.
  	 */
  	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  
  	trace_xfs_itruncate_extents_end(ip, new_size);

  out:
  	*tpp = tp;
  	return error;

  }

  int
  xfs_release(
  	xfs_inode_t	*ip)
  {
  	xfs_mount_t	*mp = ip->i_mount;
  	int		error;

  	if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))

  		return 0;
  
  	/* If this is a read-only mount, don't do this (would generate I/O) */
  	if (mp->m_flags & XFS_MOUNT_RDONLY)
  		return 0;
  
  	if (!XFS_FORCED_SHUTDOWN(mp)) {
  		int truncated;
  
  		/*

  		 * If we previously truncated this file and removed old data
  		 * in the process, we want to initiate "early" writeout on
  		 * the last close.  This is an attempt to combat the notorious
  		 * NULL files problem which is particularly noticeable from a
  		 * truncate down, buffered (re-)write (delalloc), followed by
  		 * a crash.  What we are effectively doing here is
  		 * significantly reducing the time window where we'd otherwise
  		 * be exposed to that problem.
  		 */
  		truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
  		if (truncated) {
  			xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);

  			if (ip->i_delayed_blks > 0) {

  				error = filemap_flush(VFS_I(ip)->i_mapping);

  				if (error)
  					return error;
  			}
  		}
  	}

  	if (VFS_I(ip)->i_nlink == 0)

  		return 0;
  
  	if (xfs_can_free_eofblocks(ip, false)) {
  
  		/*

  		 * Check if the inode is being opened, written and closed
  		 * frequently and we have delayed allocation blocks outstanding
  		 * (e.g. streaming writes from the NFS server), truncating the
  		 * blocks past EOF will cause fragmentation to occur.
  		 *
  		 * In this case don't do the truncation, but we have to be
  		 * careful how we detect this case. Blocks beyond EOF show up as
  		 * i_delayed_blks even when the inode is clean, so we need to
  		 * truncate them away first before checking for a dirty release.
  		 * Hence on the first dirty close we will still remove the
  		 * speculative allocation, but after that we will leave it in
  		 * place.
  		 */
  		if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
  			return 0;
  		/*

  		 * If we can't get the iolock just skip truncating the blocks

  		 * past EOF because we could deadlock with the mmap_lock

  		 * otherwise. We'll get another chance to drop them once the

  		 * last reference to the inode is dropped, so we'll never leak
  		 * blocks permanently.

  		 */

  		if (xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
  			error = xfs_free_eofblocks(ip);
  			xfs_iunlock(ip, XFS_IOLOCK_EXCL);
  			if (error)
  				return error;
  		}

  
  		/* delalloc blocks after truncation means it really is dirty */
  		if (ip->i_delayed_blks)
  			xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
  	}
  	return 0;
  }
  
  /*

   * xfs_inactive_truncate
   *
   * Called to perform a truncate when an inode becomes unlinked.
   */
  STATIC int
  xfs_inactive_truncate(
  	struct xfs_inode *ip)
  {
  	struct xfs_mount	*mp = ip->i_mount;
  	struct xfs_trans	*tp;
  	int			error;

  	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);

  	if (error) {
  		ASSERT(XFS_FORCED_SHUTDOWN(mp));

  		return error;
  	}

  	xfs_ilock(ip, XFS_ILOCK_EXCL);
  	xfs_trans_ijoin(tp, ip, 0);
  
  	/*
  	 * Log the inode size first to prevent stale data exposure in the event
  	 * of a system crash before the truncate completes. See the related

  	 * comment in xfs_vn_setattr_size() for details.

  	 */
  	ip->i_d.di_size = 0;
  	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  
  	error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
  	if (error)
  		goto error_trans_cancel;

  	ASSERT(ip->i_df.if_nextents == 0);

  	error = xfs_trans_commit(tp);

  	if (error)
  		goto error_unlock;
  
  	xfs_iunlock(ip, XFS_ILOCK_EXCL);
  	return 0;
  
  error_trans_cancel:

  	xfs_trans_cancel(tp);

  error_unlock:
  	xfs_iunlock(ip, XFS_ILOCK_EXCL);
  	return error;
  }
  
  /*

   * xfs_inactive_ifree()
   *
   * Perform the inode free when an inode is unlinked.
   */
  STATIC int
  xfs_inactive_ifree(
  	struct xfs_inode *ip)
  {

  	struct xfs_mount	*mp = ip->i_mount;
  	struct xfs_trans	*tp;
  	int			error;

  	/*

  	 * We try to use a per-AG reservation for any block needed by the finobt
  	 * tree, but as the finobt feature predates the per-AG reservation
  	 * support a degraded file system might not have enough space for the
  	 * reservation at mount time.  In that case try to dip into the reserved
  	 * pool and pray.

  	 *
  	 * Send a warning if the reservation does happen to fail, as the inode
  	 * now remains allocated and sits on the unlinked list until the fs is
  	 * repaired.
  	 */

  	if (unlikely(mp->m_finobt_nores)) {

  		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
  				XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
  				&tp);
  	} else {
  		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
  	}

  	if (error) {

  		if (error == -ENOSPC) {

  			xfs_warn_ratelimited(mp,
  			"Failed to remove inode(s) from unlinked list. "
  			"Please free space, unmount and run xfs_repair.");
  		} else {
  			ASSERT(XFS_FORCED_SHUTDOWN(mp));
  		}

  		return error;
  	}

  	/*
  	 * We do not hold the inode locked across the entire rolling transaction
  	 * here. We only need to hold it for the first transaction that
  	 * xfs_ifree() builds, which may mark the inode XFS_ISTALE if the
  	 * underlying cluster buffer is freed. Relogging an XFS_ISTALE inode
  	 * here breaks the relationship between cluster buffer invalidation and
  	 * stale inode invalidation on cluster buffer item journal commit
  	 * completion, and can result in leaving dirty stale inodes hanging
  	 * around in memory.
  	 *
  	 * We have no need for serialising this inode operation against other
  	 * operations - we freed the inode and hence reallocation is required
  	 * and that will serialise on reallocating the space the deferops need
  	 * to free. Hence we can unlock the inode on the first commit of
  	 * the transaction rather than roll it right through the deferops. This
  	 * avoids relogging the XFS_ISTALE inode.
  	 *
  	 * We check that xfs_ifree() hasn't grown an internal transaction roll
  	 * by asserting that the inode is still locked when it returns.
  	 */

  	xfs_ilock(ip, XFS_ILOCK_EXCL);

  	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

  	error = xfs_ifree(tp, ip);

  	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));

  	if (error) {
  		/*
  		 * If we fail to free the inode, shut down.  The cancel
  		 * might do that, we need to make sure.  Otherwise the
  		 * inode might be lost for a long time or forever.
  		 */
  		if (!XFS_FORCED_SHUTDOWN(mp)) {
  			xfs_notice(mp, "%s: xfs_ifree returned error %d",
  				__func__, error);
  			xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
  		}

  		xfs_trans_cancel(tp);

  		return error;
  	}
  
  	/*
  	 * Credit the quota account(s). The inode is gone.
  	 */
  	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
  
  	/*

  	 * Just ignore errors at this point.  There is nothing we can do except
  	 * to try to keep going. Make sure it's not a silent error.

  	 */

  	error = xfs_trans_commit(tp);

  	if (error)
  		xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
  			__func__, error);

  	return 0;
  }
  
  /*

   * xfs_inactive
   *
   * This is called when the vnode reference count for the vnode
   * goes to zero.  If the file has been unlinked, then it must
   * now be truncated.  Also, we clear all of the read-ahead state
   * kept for the inode here since the file is now closed.
   */

  void

  xfs_inactive(
  	xfs_inode_t	*ip)
  {

  	struct xfs_mount	*mp;

  	int			error;
  	int			truncate = 0;

  
  	/*
  	 * If the inode is already free, then there can be nothing
  	 * to clean up here.
  	 */

  	if (VFS_I(ip)->i_mode == 0) {

  		ASSERT(ip->i_df.if_broot_bytes == 0);

  		return;

  	}
  
  	mp = ip->i_mount;

  	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));

  	/* If this is a read-only mount, don't do this (would generate I/O) */
  	if (mp->m_flags & XFS_MOUNT_RDONLY)

  		return;