Linux Audio

Check our new training course

Loading...
v4.17
 
   1/*
   2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   3 * All Rights Reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it would be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write the Free Software Foundation,
  16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18#include <linux/log2.h>
  19#include <linux/iversion.h>
  20
  21#include "xfs.h"
  22#include "xfs_fs.h"
  23#include "xfs_shared.h"
  24#include "xfs_format.h"
  25#include "xfs_log_format.h"
  26#include "xfs_trans_resv.h"
  27#include "xfs_sb.h"
  28#include "xfs_mount.h"
  29#include "xfs_defer.h"
  30#include "xfs_inode.h"
  31#include "xfs_da_format.h"
  32#include "xfs_da_btree.h"
  33#include "xfs_dir2.h"
  34#include "xfs_attr_sf.h"
  35#include "xfs_attr.h"
 
  36#include "xfs_trans_space.h"
  37#include "xfs_trans.h"
  38#include "xfs_buf_item.h"
  39#include "xfs_inode_item.h"
 
  40#include "xfs_ialloc.h"
  41#include "xfs_bmap.h"
  42#include "xfs_bmap_util.h"
  43#include "xfs_errortag.h"
  44#include "xfs_error.h"
  45#include "xfs_quota.h"
  46#include "xfs_filestream.h"
  47#include "xfs_cksum.h"
  48#include "xfs_trace.h"
  49#include "xfs_icache.h"
  50#include "xfs_symlink.h"
  51#include "xfs_trans_priv.h"
  52#include "xfs_log.h"
  53#include "xfs_bmap_btree.h"
  54#include "xfs_reflink.h"
  55#include "xfs_dir2_priv.h"
  56
  57kmem_zone_t *xfs_inode_zone;
  58
  59/*
  60 * Used in xfs_itruncate_extents().  This is the maximum number of extents
  61 * freed from a file in a single transaction.
  62 */
  63#define	XFS_ITRUNC_MAX_EXTENTS	2
  64
  65STATIC int xfs_iflush_int(struct xfs_inode *, struct xfs_buf *);
  66STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
  67STATIC int xfs_iunlink_remove(struct xfs_trans *, struct xfs_inode *);
  68
  69/*
  70 * helper function to extract extent size hint from inode
  71 */
  72xfs_extlen_t
  73xfs_get_extsz_hint(
  74	struct xfs_inode	*ip)
  75{
  76	if ((ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) && ip->i_d.di_extsize)
  77		return ip->i_d.di_extsize;
  78	if (XFS_IS_REALTIME_INODE(ip))
  79		return ip->i_mount->m_sb.sb_rextsize;
  80	return 0;
  81}
  82
  83/*
  84 * Helper function to extract CoW extent size hint from inode.
  85 * Between the extent size hint and the CoW extent size hint, we
  86 * return the greater of the two.  If the value is zero (automatic),
  87 * use the default size.
  88 */
  89xfs_extlen_t
  90xfs_get_cowextsz_hint(
  91	struct xfs_inode	*ip)
  92{
  93	xfs_extlen_t		a, b;
  94
  95	a = 0;
  96	if (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
  97		a = ip->i_d.di_cowextsize;
  98	b = xfs_get_extsz_hint(ip);
  99
 100	a = max(a, b);
 101	if (a == 0)
 102		return XFS_DEFAULT_COWEXTSZ_HINT;
 103	return a;
 104}
 105
 106/*
 107 * These two are wrapper routines around the xfs_ilock() routine used to
 108 * centralize some grungy code.  They are used in places that wish to lock the
 109 * inode solely for reading the extents.  The reason these places can't just
 110 * call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
 111 * bringing in of the extents from disk for a file in b-tree format.  If the
 112 * inode is in b-tree format, then we need to lock the inode exclusively until
 113 * the extents are read in.  Locking it exclusively all the time would limit
 114 * our parallelism unnecessarily, though.  What we do instead is check to see
 115 * if the extents have been read in yet, and only lock the inode exclusively
 116 * if they have not.
 117 *
 118 * The functions return a value which should be given to the corresponding
 119 * xfs_iunlock() call.
 120 */
 121uint
 122xfs_ilock_data_map_shared(
 123	struct xfs_inode	*ip)
 124{
 125	uint			lock_mode = XFS_ILOCK_SHARED;
 126
 127	if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
 128	    (ip->i_df.if_flags & XFS_IFEXTENTS) == 0)
 129		lock_mode = XFS_ILOCK_EXCL;
 130	xfs_ilock(ip, lock_mode);
 131	return lock_mode;
 132}
 133
 134uint
 135xfs_ilock_attr_map_shared(
 136	struct xfs_inode	*ip)
 137{
 138	uint			lock_mode = XFS_ILOCK_SHARED;
 139
 140	if (ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE &&
 141	    (ip->i_afp->if_flags & XFS_IFEXTENTS) == 0)
 142		lock_mode = XFS_ILOCK_EXCL;
 143	xfs_ilock(ip, lock_mode);
 144	return lock_mode;
 145}
 146
 147/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 148 * In addition to i_rwsem in the VFS inode, the xfs inode contains 2
 149 * multi-reader locks: i_mmap_lock and the i_lock.  This routine allows
 150 * various combinations of the locks to be obtained.
 151 *
 152 * The 3 locks should always be ordered so that the IO lock is obtained first,
 153 * the mmap lock second and the ilock last in order to prevent deadlock.
 154 *
 155 * Basic locking order:
 156 *
 157 * i_rwsem -> i_mmap_lock -> page_lock -> i_ilock
 158 *
 159 * mmap_sem locking order:
 160 *
 161 * i_rwsem -> page lock -> mmap_sem
 162 * mmap_sem -> i_mmap_lock -> page_lock
 163 *
 164 * The difference in mmap_sem locking order mean that we cannot hold the
 165 * i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can
 166 * fault in pages during copy in/out (for buffered IO) or require the mmap_sem
 167 * in get_user_pages() to map the user pages into the kernel address space for
 168 * direct IO. Similarly the i_rwsem cannot be taken inside a page fault because
 169 * page faults already hold the mmap_sem.
 170 *
 171 * Hence to serialise fully against both syscall and mmap based IO, we need to
 172 * take both the i_rwsem and the i_mmap_lock. These locks should *only* be both
 173 * taken in places where we need to invalidate the page cache in a race
 174 * free manner (e.g. truncate, hole punch and other extent manipulation
 175 * functions).
 176 */
 177void
 178xfs_ilock(
 179	xfs_inode_t		*ip,
 180	uint			lock_flags)
 181{
 182	trace_xfs_ilock(ip, lock_flags, _RET_IP_);
 183
 184	/*
 185	 * You can't set both SHARED and EXCL for the same lock,
 186	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 187	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 188	 */
 189	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 190	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 191	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
 192	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
 193	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 194	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 195	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
 196
 197	if (lock_flags & XFS_IOLOCK_EXCL) {
 198		down_write_nested(&VFS_I(ip)->i_rwsem,
 199				  XFS_IOLOCK_DEP(lock_flags));
 200	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 201		down_read_nested(&VFS_I(ip)->i_rwsem,
 202				 XFS_IOLOCK_DEP(lock_flags));
 203	}
 204
 205	if (lock_flags & XFS_MMAPLOCK_EXCL)
 206		mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
 207	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 208		mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
 
 
 
 209
 210	if (lock_flags & XFS_ILOCK_EXCL)
 211		mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 212	else if (lock_flags & XFS_ILOCK_SHARED)
 213		mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 214}
 215
 216/*
 217 * This is just like xfs_ilock(), except that the caller
 218 * is guaranteed not to sleep.  It returns 1 if it gets
 219 * the requested locks and 0 otherwise.  If the IO lock is
 220 * obtained but the inode lock cannot be, then the IO lock
 221 * is dropped before returning.
 222 *
 223 * ip -- the inode being locked
 224 * lock_flags -- this parameter indicates the inode's locks to be
 225 *       to be locked.  See the comment for xfs_ilock() for a list
 226 *	 of valid values.
 227 */
 228int
 229xfs_ilock_nowait(
 230	xfs_inode_t		*ip,
 231	uint			lock_flags)
 232{
 233	trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
 234
 235	/*
 236	 * You can't set both SHARED and EXCL for the same lock,
 237	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 238	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 239	 */
 240	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 241	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 242	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
 243	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
 244	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 245	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 246	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
 247
 248	if (lock_flags & XFS_IOLOCK_EXCL) {
 249		if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
 250			goto out;
 251	} else if (lock_flags & XFS_IOLOCK_SHARED) {
 252		if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
 253			goto out;
 254	}
 255
 256	if (lock_flags & XFS_MMAPLOCK_EXCL) {
 257		if (!mrtryupdate(&ip->i_mmaplock))
 258			goto out_undo_iolock;
 259	} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
 260		if (!mrtryaccess(&ip->i_mmaplock))
 261			goto out_undo_iolock;
 262	}
 263
 264	if (lock_flags & XFS_ILOCK_EXCL) {
 265		if (!mrtryupdate(&ip->i_lock))
 266			goto out_undo_mmaplock;
 267	} else if (lock_flags & XFS_ILOCK_SHARED) {
 268		if (!mrtryaccess(&ip->i_lock))
 269			goto out_undo_mmaplock;
 270	}
 271	return 1;
 272
 273out_undo_mmaplock:
 274	if (lock_flags & XFS_MMAPLOCK_EXCL)
 275		mrunlock_excl(&ip->i_mmaplock);
 276	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 277		mrunlock_shared(&ip->i_mmaplock);
 278out_undo_iolock:
 279	if (lock_flags & XFS_IOLOCK_EXCL)
 280		up_write(&VFS_I(ip)->i_rwsem);
 281	else if (lock_flags & XFS_IOLOCK_SHARED)
 282		up_read(&VFS_I(ip)->i_rwsem);
 283out:
 284	return 0;
 285}
 286
 287/*
 288 * xfs_iunlock() is used to drop the inode locks acquired with
 289 * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
 290 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
 291 * that we know which locks to drop.
 292 *
 293 * ip -- the inode being unlocked
 294 * lock_flags -- this parameter indicates the inode's locks to be
 295 *       to be unlocked.  See the comment for xfs_ilock() for a list
 296 *	 of valid values for this parameter.
 297 *
 298 */
 299void
 300xfs_iunlock(
 301	xfs_inode_t		*ip,
 302	uint			lock_flags)
 303{
 304	/*
 305	 * You can't set both SHARED and EXCL for the same lock,
 306	 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 307	 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 308	 */
 309	ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 310	       (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 311	ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
 312	       (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
 313	ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 314	       (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 315	ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
 316	ASSERT(lock_flags != 0);
 317
 318	if (lock_flags & XFS_IOLOCK_EXCL)
 319		up_write(&VFS_I(ip)->i_rwsem);
 320	else if (lock_flags & XFS_IOLOCK_SHARED)
 321		up_read(&VFS_I(ip)->i_rwsem);
 322
 323	if (lock_flags & XFS_MMAPLOCK_EXCL)
 324		mrunlock_excl(&ip->i_mmaplock);
 325	else if (lock_flags & XFS_MMAPLOCK_SHARED)
 326		mrunlock_shared(&ip->i_mmaplock);
 327
 328	if (lock_flags & XFS_ILOCK_EXCL)
 329		mrunlock_excl(&ip->i_lock);
 330	else if (lock_flags & XFS_ILOCK_SHARED)
 331		mrunlock_shared(&ip->i_lock);
 332
 333	trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
 334}
 335
 336/*
 337 * give up write locks.  the i/o lock cannot be held nested
 338 * if it is being demoted.
 339 */
 340void
 341xfs_ilock_demote(
 342	xfs_inode_t		*ip,
 343	uint			lock_flags)
 344{
 345	ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
 346	ASSERT((lock_flags &
 347		~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
 348
 349	if (lock_flags & XFS_ILOCK_EXCL)
 350		mrdemote(&ip->i_lock);
 351	if (lock_flags & XFS_MMAPLOCK_EXCL)
 352		mrdemote(&ip->i_mmaplock);
 353	if (lock_flags & XFS_IOLOCK_EXCL)
 354		downgrade_write(&VFS_I(ip)->i_rwsem);
 355
 356	trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
 357}
 358
 359#if defined(DEBUG) || defined(XFS_WARN)
 360int
 361xfs_isilocked(
 362	xfs_inode_t		*ip,
 363	uint			lock_flags)
 364{
 365	if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
 366		if (!(lock_flags & XFS_ILOCK_SHARED))
 367			return !!ip->i_lock.mr_writer;
 368		return rwsem_is_locked(&ip->i_lock.mr_lock);
 369	}
 370
 371	if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
 372		if (!(lock_flags & XFS_MMAPLOCK_SHARED))
 373			return !!ip->i_mmaplock.mr_writer;
 374		return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
 375	}
 376
 377	if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
 378		if (!(lock_flags & XFS_IOLOCK_SHARED))
 379			return !debug_locks ||
 380				lockdep_is_held_type(&VFS_I(ip)->i_rwsem, 0);
 381		return rwsem_is_locked(&VFS_I(ip)->i_rwsem);
 382	}
 383
 384	ASSERT(0);
 385	return 0;
 386}
 387#endif
 388
 389/*
 390 * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
 391 * DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
 392 * when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
 393 * errors and warnings.
 394 */
 395#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
 396static bool
 397xfs_lockdep_subclass_ok(
 398	int subclass)
 399{
 400	return subclass < MAX_LOCKDEP_SUBCLASSES;
 401}
 402#else
 403#define xfs_lockdep_subclass_ok(subclass)	(true)
 404#endif
 405
 406/*
 407 * Bump the subclass so xfs_lock_inodes() acquires each lock with a different
 408 * value. This can be called for any type of inode lock combination, including
 409 * parent locking. Care must be taken to ensure we don't overrun the subclass
 410 * storage fields in the class mask we build.
 411 */
 412static inline int
 413xfs_lock_inumorder(int lock_mode, int subclass)
 
 
 414{
 415	int	class = 0;
 416
 417	ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
 418			      XFS_ILOCK_RTSUM)));
 419	ASSERT(xfs_lockdep_subclass_ok(subclass));
 420
 421	if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
 422		ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
 423		class += subclass << XFS_IOLOCK_SHIFT;
 424	}
 425
 426	if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
 427		ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
 428		class += subclass << XFS_MMAPLOCK_SHIFT;
 429	}
 430
 431	if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
 432		ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
 433		class += subclass << XFS_ILOCK_SHIFT;
 434	}
 435
 436	return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
 437}
 438
 439/*
 440 * The following routine will lock n inodes in exclusive mode.  We assume the
 441 * caller calls us with the inodes in i_ino order.
 442 *
 443 * We need to detect deadlock where an inode that we lock is in the AIL and we
 444 * start waiting for another inode that is locked by a thread in a long running
 445 * transaction (such as truncate). This can result in deadlock since the long
 446 * running trans might need to wait for the inode we just locked in order to
 447 * push the tail and free space in the log.
 448 *
 449 * xfs_lock_inodes() can only be used to lock one type of lock at a time -
 450 * the iolock, the mmaplock or the ilock, but not more than one at a time. If we
 451 * lock more than one at a time, lockdep will report false positives saying we
 452 * have violated locking orders.
 453 */
 454static void
 455xfs_lock_inodes(
 456	xfs_inode_t	**ips,
 457	int		inodes,
 458	uint		lock_mode)
 459{
 460	int		attempts = 0, i, j, try_lock;
 461	xfs_log_item_t	*lp;
 
 
 
 462
 463	/*
 464	 * Currently supports between 2 and 5 inodes with exclusive locking.  We
 465	 * support an arbitrary depth of locking here, but absolute limits on
 466	 * inodes depend on the the type of locking and the limits placed by
 467	 * lockdep annotations in xfs_lock_inumorder.  These are all checked by
 468	 * the asserts.
 469	 */
 470	ASSERT(ips && inodes >= 2 && inodes <= 5);
 471	ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
 472			    XFS_ILOCK_EXCL));
 473	ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
 474			      XFS_ILOCK_SHARED)));
 475	ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
 476		inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
 477	ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
 478		inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
 479
 480	if (lock_mode & XFS_IOLOCK_EXCL) {
 481		ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
 482	} else if (lock_mode & XFS_MMAPLOCK_EXCL)
 483		ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
 484
 485	try_lock = 0;
 486	i = 0;
 487again:
 
 
 488	for (; i < inodes; i++) {
 489		ASSERT(ips[i]);
 490
 491		if (i && (ips[i] == ips[i - 1]))	/* Already locked */
 492			continue;
 493
 494		/*
 495		 * If try_lock is not set yet, make sure all locked inodes are
 496		 * not in the AIL.  If any are, set try_lock to be used later.
 497		 */
 498		if (!try_lock) {
 499			for (j = (i - 1); j >= 0 && !try_lock; j--) {
 500				lp = (xfs_log_item_t *)ips[j]->i_itemp;
 501				if (lp && (lp->li_flags & XFS_LI_IN_AIL))
 502					try_lock++;
 503			}
 504		}
 505
 506		/*
 507		 * If any of the previous locks we have locked is in the AIL,
 508		 * we must TRY to get the second and subsequent locks. If
 509		 * we can't get any, we must release all we have
 510		 * and try again.
 511		 */
 512		if (!try_lock) {
 513			xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
 514			continue;
 515		}
 516
 517		/* try_lock means we have an inode locked that is in the AIL. */
 518		ASSERT(i != 0);
 519		if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
 520			continue;
 521
 522		/*
 523		 * Unlock all previous guys and try again.  xfs_iunlock will try
 524		 * to push the tail if the inode is in the AIL.
 525		 */
 526		attempts++;
 527		for (j = i - 1; j >= 0; j--) {
 528			/*
 529			 * Check to see if we've already unlocked this one.  Not
 530			 * the first one going back, and the inode ptr is the
 531			 * same.
 532			 */
 533			if (j != (i - 1) && ips[j] == ips[j + 1])
 534				continue;
 535
 536			xfs_iunlock(ips[j], lock_mode);
 537		}
 538
 539		if ((attempts % 5) == 0) {
 540			delay(1); /* Don't just spin the CPU */
 541		}
 542		i = 0;
 543		try_lock = 0;
 544		goto again;
 545	}
 546}
 547
 548/*
 549 * xfs_lock_two_inodes() can only be used to lock one type of lock at a time -
 550 * the mmaplock or the ilock, but not more than one type at a time. If we lock
 551 * more than one at a time, lockdep will report false positives saying we have
 552 * violated locking orders.  The iolock must be double-locked separately since
 553 * we use i_rwsem for that.  We now support taking one lock EXCL and the other
 554 * SHARED.
 555 */
 556void
 557xfs_lock_two_inodes(
 558	struct xfs_inode	*ip0,
 559	uint			ip0_mode,
 560	struct xfs_inode	*ip1,
 561	uint			ip1_mode)
 562{
 563	struct xfs_inode	*temp;
 564	uint			mode_temp;
 565	int			attempts = 0;
 566	xfs_log_item_t		*lp;
 567
 568	ASSERT(hweight32(ip0_mode) == 1);
 569	ASSERT(hweight32(ip1_mode) == 1);
 570	ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 571	ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
 572	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
 573	       !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
 574	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
 575	       !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
 576	ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
 577	       !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
 578	ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
 579	       !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
 580
 581	ASSERT(ip0->i_ino != ip1->i_ino);
 582
 583	if (ip0->i_ino > ip1->i_ino) {
 584		temp = ip0;
 585		ip0 = ip1;
 586		ip1 = temp;
 587		mode_temp = ip0_mode;
 588		ip0_mode = ip1_mode;
 589		ip1_mode = mode_temp;
 590	}
 591
 592 again:
 593	xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
 594
 595	/*
 596	 * If the first lock we have locked is in the AIL, we must TRY to get
 597	 * the second lock. If we can't get it, we must release the first one
 598	 * and try again.
 599	 */
 600	lp = (xfs_log_item_t *)ip0->i_itemp;
 601	if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
 602		if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
 603			xfs_iunlock(ip0, ip0_mode);
 604			if ((++attempts % 5) == 0)
 605				delay(1); /* Don't just spin the CPU */
 606			goto again;
 607		}
 608	} else {
 609		xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
 610	}
 611}
 612
 613void
 614__xfs_iflock(
 615	struct xfs_inode	*ip)
 616{
 617	wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IFLOCK_BIT);
 618	DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IFLOCK_BIT);
 619
 620	do {
 621		prepare_to_wait_exclusive(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
 622		if (xfs_isiflocked(ip))
 623			io_schedule();
 624	} while (!xfs_iflock_nowait(ip));
 625
 626	finish_wait(wq, &wait.wq_entry);
 627}
 628
 629STATIC uint
 630_xfs_dic2xflags(
 631	uint16_t		di_flags,
 632	uint64_t		di_flags2,
 633	bool			has_attr)
 634{
 635	uint			flags = 0;
 636
 637	if (di_flags & XFS_DIFLAG_ANY) {
 638		if (di_flags & XFS_DIFLAG_REALTIME)
 639			flags |= FS_XFLAG_REALTIME;
 640		if (di_flags & XFS_DIFLAG_PREALLOC)
 641			flags |= FS_XFLAG_PREALLOC;
 642		if (di_flags & XFS_DIFLAG_IMMUTABLE)
 643			flags |= FS_XFLAG_IMMUTABLE;
 644		if (di_flags & XFS_DIFLAG_APPEND)
 645			flags |= FS_XFLAG_APPEND;
 646		if (di_flags & XFS_DIFLAG_SYNC)
 647			flags |= FS_XFLAG_SYNC;
 648		if (di_flags & XFS_DIFLAG_NOATIME)
 649			flags |= FS_XFLAG_NOATIME;
 650		if (di_flags & XFS_DIFLAG_NODUMP)
 651			flags |= FS_XFLAG_NODUMP;
 652		if (di_flags & XFS_DIFLAG_RTINHERIT)
 653			flags |= FS_XFLAG_RTINHERIT;
 654		if (di_flags & XFS_DIFLAG_PROJINHERIT)
 655			flags |= FS_XFLAG_PROJINHERIT;
 656		if (di_flags & XFS_DIFLAG_NOSYMLINKS)
 657			flags |= FS_XFLAG_NOSYMLINKS;
 658		if (di_flags & XFS_DIFLAG_EXTSIZE)
 659			flags |= FS_XFLAG_EXTSIZE;
 660		if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
 661			flags |= FS_XFLAG_EXTSZINHERIT;
 662		if (di_flags & XFS_DIFLAG_NODEFRAG)
 663			flags |= FS_XFLAG_NODEFRAG;
 664		if (di_flags & XFS_DIFLAG_FILESTREAM)
 665			flags |= FS_XFLAG_FILESTREAM;
 666	}
 667
 668	if (di_flags2 & XFS_DIFLAG2_ANY) {
 669		if (di_flags2 & XFS_DIFLAG2_DAX)
 670			flags |= FS_XFLAG_DAX;
 671		if (di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
 672			flags |= FS_XFLAG_COWEXTSIZE;
 673	}
 674
 675	if (has_attr)
 676		flags |= FS_XFLAG_HASATTR;
 677
 678	return flags;
 679}
 680
 681uint
 682xfs_ip2xflags(
 683	struct xfs_inode	*ip)
 684{
 685	struct xfs_icdinode	*dic = &ip->i_d;
 686
 687	return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip));
 688}
 689
 690/*
 691 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
 692 * is allowed, otherwise it has to be an exact match. If a CI match is found,
 693 * ci_name->name will point to a the actual name (caller must free) or
 694 * will be set to NULL if an exact match is found.
 695 */
 696int
 697xfs_lookup(
 698	xfs_inode_t		*dp,
 699	struct xfs_name		*name,
 700	xfs_inode_t		**ipp,
 701	struct xfs_name		*ci_name)
 702{
 703	xfs_ino_t		inum;
 704	int			error;
 705
 706	trace_xfs_lookup(dp, name);
 707
 708	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 
 
 709		return -EIO;
 710
 711	error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
 712	if (error)
 713		goto out_unlock;
 714
 715	error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
 716	if (error)
 717		goto out_free_name;
 718
 
 
 
 
 
 
 
 
 
 
 719	return 0;
 720
 
 
 721out_free_name:
 722	if (ci_name)
 723		kmem_free(ci_name->name);
 724out_unlock:
 725	*ipp = NULL;
 726	return error;
 727}
 728
 729/*
 730 * Allocate an inode on disk and return a copy of its in-core version.
 731 * The in-core inode is locked exclusively.  Set mode, nlink, and rdev
 732 * appropriately within the inode.  The uid and gid for the inode are
 733 * set according to the contents of the given cred structure.
 734 *
 735 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
 736 * has a free inode available, call xfs_iget() to obtain the in-core
 737 * version of the allocated inode.  Finally, fill in the inode and
 738 * log its initial contents.  In this case, ialloc_context would be
 739 * set to NULL.
 740 *
 741 * If xfs_dialloc() does not have an available inode, it will replenish
 742 * its supply by doing an allocation. Since we can only do one
 743 * allocation within a transaction without deadlocks, we must commit
 744 * the current transaction before returning the inode itself.
 745 * In this case, therefore, we will set ialloc_context and return.
 746 * The caller should then commit the current transaction, start a new
 747 * transaction, and call xfs_ialloc() again to actually get the inode.
 748 *
 749 * To ensure that some other process does not grab the inode that
 750 * was allocated during the first call to xfs_ialloc(), this routine
 751 * also returns the [locked] bp pointing to the head of the freelist
 752 * as ialloc_context.  The caller should hold this buffer across
 753 * the commit and pass it back into this routine on the second call.
 754 *
 755 * If we are allocating quota inodes, we do not have a parent inode
 756 * to attach to or associate with (i.e. pip == NULL) because they
 757 * are not linked into the directory structure - they are attached
 758 * directly to the superblock - and so have no parent.
 759 */
 760static int
 761xfs_ialloc(
 762	xfs_trans_t	*tp,
 763	xfs_inode_t	*pip,
 764	umode_t		mode,
 765	xfs_nlink_t	nlink,
 766	dev_t		rdev,
 767	prid_t		prid,
 768	xfs_buf_t	**ialloc_context,
 769	xfs_inode_t	**ipp)
 770{
 771	struct xfs_mount *mp = tp->t_mountp;
 772	xfs_ino_t	ino;
 773	xfs_inode_t	*ip;
 774	uint		flags;
 775	int		error;
 776	struct timespec	tv;
 777	struct inode	*inode;
 778
 779	/*
 780	 * Call the space management code to pick
 781	 * the on-disk inode to be allocated.
 782	 */
 783	error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode,
 784			    ialloc_context, &ino);
 785	if (error)
 786		return error;
 787	if (*ialloc_context || ino == NULLFSINO) {
 788		*ipp = NULL;
 789		return 0;
 790	}
 791	ASSERT(*ialloc_context == NULL);
 792
 793	/*
 794	 * Get the in-core inode with the lock held exclusively.
 795	 * This is because we're setting fields here we need
 796	 * to prevent others from looking at until we're done.
 797	 */
 798	error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,
 799			 XFS_ILOCK_EXCL, &ip);
 800	if (error)
 801		return error;
 802	ASSERT(ip != NULL);
 803	inode = VFS_I(ip);
 804
 805	/*
 806	 * We always convert v1 inodes to v2 now - we only support filesystems
 807	 * with >= v2 inode capability, so there is no reason for ever leaving
 808	 * an inode in v1 format.
 809	 */
 810	if (ip->i_d.di_version == 1)
 811		ip->i_d.di_version = 2;
 812
 813	inode->i_mode = mode;
 814	set_nlink(inode, nlink);
 815	ip->i_d.di_uid = xfs_kuid_to_uid(current_fsuid());
 816	ip->i_d.di_gid = xfs_kgid_to_gid(current_fsgid());
 817	inode->i_rdev = rdev;
 818	xfs_set_projid(ip, prid);
 819
 820	if (pip && XFS_INHERIT_GID(pip)) {
 821		ip->i_d.di_gid = pip->i_d.di_gid;
 822		if ((VFS_I(pip)->i_mode & S_ISGID) && S_ISDIR(mode))
 823			inode->i_mode |= S_ISGID;
 824	}
 825
 826	/*
 827	 * If the group ID of the new file does not match the effective group
 828	 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
 829	 * (and only if the irix_sgid_inherit compatibility variable is set).
 830	 */
 831	if ((irix_sgid_inherit) &&
 832	    (inode->i_mode & S_ISGID) &&
 833	    (!in_group_p(xfs_gid_to_kgid(ip->i_d.di_gid))))
 834		inode->i_mode &= ~S_ISGID;
 835
 836	ip->i_d.di_size = 0;
 837	ip->i_d.di_nextents = 0;
 838	ASSERT(ip->i_d.di_nblocks == 0);
 839
 840	tv = current_time(inode);
 841	inode->i_mtime = tv;
 842	inode->i_atime = tv;
 843	inode->i_ctime = tv;
 844
 845	ip->i_d.di_extsize = 0;
 846	ip->i_d.di_dmevmask = 0;
 847	ip->i_d.di_dmstate = 0;
 848	ip->i_d.di_flags = 0;
 849
 850	if (ip->i_d.di_version == 3) {
 851		inode_set_iversion(inode, 1);
 852		ip->i_d.di_flags2 = 0;
 853		ip->i_d.di_cowextsize = 0;
 854		ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec;
 855		ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec;
 856	}
 857
 858
 859	flags = XFS_ILOG_CORE;
 860	switch (mode & S_IFMT) {
 861	case S_IFIFO:
 862	case S_IFCHR:
 863	case S_IFBLK:
 864	case S_IFSOCK:
 865		ip->i_d.di_format = XFS_DINODE_FMT_DEV;
 866		ip->i_df.if_flags = 0;
 867		flags |= XFS_ILOG_DEV;
 868		break;
 869	case S_IFREG:
 870	case S_IFDIR:
 871		if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
 872			uint		di_flags = 0;
 873
 874			if (S_ISDIR(mode)) {
 875				if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
 876					di_flags |= XFS_DIFLAG_RTINHERIT;
 877				if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
 878					di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 879					ip->i_d.di_extsize = pip->i_d.di_extsize;
 880				}
 881				if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
 882					di_flags |= XFS_DIFLAG_PROJINHERIT;
 883			} else if (S_ISREG(mode)) {
 884				if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
 885					di_flags |= XFS_DIFLAG_REALTIME;
 886				if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
 887					di_flags |= XFS_DIFLAG_EXTSIZE;
 888					ip->i_d.di_extsize = pip->i_d.di_extsize;
 889				}
 890			}
 891			if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
 892			    xfs_inherit_noatime)
 893				di_flags |= XFS_DIFLAG_NOATIME;
 894			if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
 895			    xfs_inherit_nodump)
 896				di_flags |= XFS_DIFLAG_NODUMP;
 897			if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
 898			    xfs_inherit_sync)
 899				di_flags |= XFS_DIFLAG_SYNC;
 900			if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
 901			    xfs_inherit_nosymlinks)
 902				di_flags |= XFS_DIFLAG_NOSYMLINKS;
 903			if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
 904			    xfs_inherit_nodefrag)
 905				di_flags |= XFS_DIFLAG_NODEFRAG;
 906			if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
 907				di_flags |= XFS_DIFLAG_FILESTREAM;
 908
 909			ip->i_d.di_flags |= di_flags;
 910		}
 911		if (pip &&
 912		    (pip->i_d.di_flags2 & XFS_DIFLAG2_ANY) &&
 913		    pip->i_d.di_version == 3 &&
 914		    ip->i_d.di_version == 3) {
 915			uint64_t	di_flags2 = 0;
 916
 917			if (pip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) {
 918				di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
 919				ip->i_d.di_cowextsize = pip->i_d.di_cowextsize;
 920			}
 921			if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
 922				di_flags2 |= XFS_DIFLAG2_DAX;
 923
 924			ip->i_d.di_flags2 |= di_flags2;
 925		}
 926		/* FALLTHROUGH */
 927	case S_IFLNK:
 928		ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
 929		ip->i_df.if_flags = XFS_IFEXTENTS;
 930		ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
 931		ip->i_df.if_u1.if_root = NULL;
 932		break;
 933	default:
 934		ASSERT(0);
 935	}
 936	/*
 937	 * Attribute fork settings for new inode.
 938	 */
 939	ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
 940	ip->i_d.di_anextents = 0;
 941
 942	/*
 943	 * Log the new values stuffed into the inode.
 944	 */
 945	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 946	xfs_trans_log_inode(tp, ip, flags);
 947
 948	/* now that we have an i_mode we can setup the inode structure */
 949	xfs_setup_inode(ip);
 950
 951	*ipp = ip;
 952	return 0;
 953}
 954
 955/*
 956 * Allocates a new inode from disk and return a pointer to the
 957 * incore copy. This routine will internally commit the current
 958 * transaction and allocate a new one if the Space Manager needed
 959 * to do an allocation to replenish the inode free-list.
 960 *
 961 * This routine is designed to be called from xfs_create and
 962 * xfs_create_dir.
 963 *
 964 */
 965int
 966xfs_dir_ialloc(
 967	xfs_trans_t	**tpp,		/* input: current transaction;
 968					   output: may be a new transaction. */
 969	xfs_inode_t	*dp,		/* directory within whose allocate
 970					   the inode. */
 971	umode_t		mode,
 972	xfs_nlink_t	nlink,
 973	dev_t		rdev,
 974	prid_t		prid,		/* project id */
 975	xfs_inode_t	**ipp)		/* pointer to inode; it will be
 976					   locked. */
 977{
 978	xfs_trans_t	*tp;
 979	xfs_inode_t	*ip;
 980	xfs_buf_t	*ialloc_context = NULL;
 981	int		code;
 982	void		*dqinfo;
 983	uint		tflags;
 984
 985	tp = *tpp;
 986	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
 987
 988	/*
 989	 * xfs_ialloc will return a pointer to an incore inode if
 990	 * the Space Manager has an available inode on the free
 991	 * list. Otherwise, it will do an allocation and replenish
 992	 * the freelist.  Since we can only do one allocation per
 993	 * transaction without deadlocks, we will need to commit the
 994	 * current transaction and start a new one.  We will then
 995	 * need to call xfs_ialloc again to get the inode.
 996	 *
 997	 * If xfs_ialloc did an allocation to replenish the freelist,
 998	 * it returns the bp containing the head of the freelist as
 999	 * ialloc_context. We will hold a lock on it across the
1000	 * transaction commit so that no other process can steal
1001	 * the inode(s) that we've just allocated.
1002	 */
1003	code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, &ialloc_context,
1004			&ip);
1005
1006	/*
1007	 * Return an error if we were unable to allocate a new inode.
1008	 * This should only happen if we run out of space on disk or
1009	 * encounter a disk error.
1010	 */
1011	if (code) {
1012		*ipp = NULL;
1013		return code;
1014	}
1015	if (!ialloc_context && !ip) {
1016		*ipp = NULL;
1017		return -ENOSPC;
1018	}
1019
1020	/*
1021	 * If the AGI buffer is non-NULL, then we were unable to get an
1022	 * inode in one operation.  We need to commit the current
1023	 * transaction and call xfs_ialloc() again.  It is guaranteed
1024	 * to succeed the second time.
1025	 */
1026	if (ialloc_context) {
1027		/*
1028		 * Normally, xfs_trans_commit releases all the locks.
1029		 * We call bhold to hang on to the ialloc_context across
1030		 * the commit.  Holding this buffer prevents any other
1031		 * processes from doing any allocations in this
1032		 * allocation group.
1033		 */
1034		xfs_trans_bhold(tp, ialloc_context);
1035
1036		/*
1037		 * We want the quota changes to be associated with the next
1038		 * transaction, NOT this one. So, detach the dqinfo from this
1039		 * and attach it to the next transaction.
1040		 */
1041		dqinfo = NULL;
1042		tflags = 0;
1043		if (tp->t_dqinfo) {
1044			dqinfo = (void *)tp->t_dqinfo;
1045			tp->t_dqinfo = NULL;
1046			tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
1047			tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
1048		}
1049
1050		code = xfs_trans_roll(&tp);
1051
1052		/*
1053		 * Re-attach the quota info that we detached from prev trx.
1054		 */
1055		if (dqinfo) {
1056			tp->t_dqinfo = dqinfo;
1057			tp->t_flags |= tflags;
1058		}
1059
1060		if (code) {
1061			xfs_buf_relse(ialloc_context);
1062			*tpp = tp;
1063			*ipp = NULL;
1064			return code;
1065		}
1066		xfs_trans_bjoin(tp, ialloc_context);
1067
1068		/*
1069		 * Call ialloc again. Since we've locked out all
1070		 * other allocations in this allocation group,
1071		 * this call should always succeed.
1072		 */
1073		code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,
1074				  &ialloc_context, &ip);
1075
1076		/*
1077		 * If we get an error at this point, return to the caller
1078		 * so that the current transaction can be aborted.
1079		 */
1080		if (code) {
1081			*tpp = tp;
1082			*ipp = NULL;
1083			return code;
1084		}
1085		ASSERT(!ialloc_context && ip);
1086
1087	}
1088
1089	*ipp = ip;
1090	*tpp = tp;
1091
1092	return 0;
1093}
1094
1095/*
1096 * Decrement the link count on an inode & log the change.  If this causes the
1097 * link count to go to zero, move the inode to AGI unlinked list so that it can
1098 * be freed when the last active reference goes away via xfs_inactive().
1099 */
1100static int			/* error */
1101xfs_droplink(
1102	xfs_trans_t *tp,
1103	xfs_inode_t *ip)
1104{
1105	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1106
1107	drop_nlink(VFS_I(ip));
1108	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1109
1110	if (VFS_I(ip)->i_nlink)
1111		return 0;
1112
1113	return xfs_iunlink(tp, ip);
1114}
1115
1116/*
1117 * Increment the link count on an inode & log the change.
1118 */
1119static int
1120xfs_bumplink(
1121	xfs_trans_t *tp,
1122	xfs_inode_t *ip)
1123{
1124	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1125
1126	ASSERT(ip->i_d.di_version > 1);
1127	inc_nlink(VFS_I(ip));
1128	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1129	return 0;
1130}
1131
1132int
1133xfs_create(
1134	xfs_inode_t		*dp,
1135	struct xfs_name		*name,
1136	umode_t			mode,
1137	dev_t			rdev,
1138	xfs_inode_t		**ipp)
1139{
1140	int			is_dir = S_ISDIR(mode);
 
 
 
 
1141	struct xfs_mount	*mp = dp->i_mount;
1142	struct xfs_inode	*ip = NULL;
1143	struct xfs_trans	*tp = NULL;
1144	int			error;
1145	struct xfs_defer_ops	dfops;
1146	xfs_fsblock_t		first_block;
1147	bool                    unlock_dp_on_error = false;
1148	prid_t			prid;
1149	struct xfs_dquot	*udqp = NULL;
1150	struct xfs_dquot	*gdqp = NULL;
1151	struct xfs_dquot	*pdqp = NULL;
1152	struct xfs_trans_res	*tres;
 
 
 
1153	uint			resblks;
 
1154
1155	trace_xfs_create(dp, name);
1156
1157	if (XFS_FORCED_SHUTDOWN(mp))
 
 
1158		return -EIO;
1159
1160	prid = xfs_get_initial_prid(dp);
1161
1162	/*
1163	 * Make sure that we have allocated dquot(s) on disk.
1164	 */
1165	error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1166					xfs_kgid_to_gid(current_fsgid()), prid,
1167					XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1168					&udqp, &gdqp, &pdqp);
1169	if (error)
1170		return error;
1171
1172	if (is_dir) {
1173		resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
1174		tres = &M_RES(mp)->tr_mkdir;
1175	} else {
1176		resblks = XFS_CREATE_SPACE_RES(mp, name->len);
1177		tres = &M_RES(mp)->tr_create;
1178	}
1179
 
 
 
 
1180	/*
1181	 * Initially assume that the file does not exist and
1182	 * reserve the resources for that case.  If that is not
1183	 * the case we'll drop the one we have and get a more
1184	 * appropriate transaction later.
1185	 */
1186	error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
 
1187	if (error == -ENOSPC) {
1188		/* flush outstanding delalloc blocks and retry */
1189		xfs_flush_inodes(mp);
1190		error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
 
1191	}
1192	if (error)
1193		goto out_release_inode;
1194
1195	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1196	unlock_dp_on_error = true;
1197
1198	xfs_defer_init(&dfops, &first_block);
1199
1200	/*
1201	 * Reserve disk quota and the inode.
1202	 */
1203	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1204						pdqp, resblks, 1, 0);
1205	if (error)
1206		goto out_trans_cancel;
1207
1208	/*
1209	 * A newly created regular or special file just has one directory
1210	 * entry pointing to them, but a directory also the "." entry
1211	 * pointing to itself.
1212	 */
1213	error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, prid, &ip);
 
 
1214	if (error)
1215		goto out_trans_cancel;
1216
1217	/*
1218	 * Now we join the directory inode to the transaction.  We do not do it
1219	 * earlier because xfs_dir_ialloc might commit the previous transaction
1220	 * (and release all the locks).  An error from here on will result in
1221	 * the transaction cancel unlocking dp so don't do it explicitly in the
1222	 * error path.
1223	 */
1224	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1225	unlock_dp_on_error = false;
1226
1227	error = xfs_dir_createname(tp, dp, name, ip->i_ino,
1228					&first_block, &dfops, resblks ?
1229					resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1230	if (error) {
1231		ASSERT(error != -ENOSPC);
1232		goto out_trans_cancel;
1233	}
1234	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1235	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1236
1237	if (is_dir) {
1238		error = xfs_dir_init(tp, ip, dp);
1239		if (error)
1240			goto out_bmap_cancel;
1241
1242		error = xfs_bumplink(tp, dp);
1243		if (error)
1244			goto out_bmap_cancel;
1245	}
1246
1247	/*
1248	 * If this is a synchronous mount, make sure that the
1249	 * create transaction goes to disk before returning to
1250	 * the user.
1251	 */
1252	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1253		xfs_trans_set_sync(tp);
1254
1255	/*
1256	 * Attach the dquot(s) to the inodes and modify them incore.
1257	 * These ids of the inode couldn't have changed since the new
1258	 * inode has been locked ever since it was created.
1259	 */
1260	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1261
1262	error = xfs_defer_finish(&tp, &dfops);
1263	if (error)
1264		goto out_bmap_cancel;
1265
1266	error = xfs_trans_commit(tp);
1267	if (error)
1268		goto out_release_inode;
1269
1270	xfs_qm_dqrele(udqp);
1271	xfs_qm_dqrele(gdqp);
1272	xfs_qm_dqrele(pdqp);
1273
1274	*ipp = ip;
 
 
 
1275	return 0;
1276
1277 out_bmap_cancel:
1278	xfs_defer_cancel(&dfops);
1279 out_trans_cancel:
1280	xfs_trans_cancel(tp);
1281 out_release_inode:
1282	/*
1283	 * Wait until after the current transaction is aborted to finish the
1284	 * setup of the inode and release the inode.  This prevents recursive
1285	 * transactions and deadlocks from xfs_inactive.
1286	 */
1287	if (ip) {
1288		xfs_finish_inode_setup(ip);
1289		IRELE(ip);
1290	}
1291
 
 
 
1292	xfs_qm_dqrele(udqp);
1293	xfs_qm_dqrele(gdqp);
1294	xfs_qm_dqrele(pdqp);
1295
1296	if (unlock_dp_on_error)
1297		xfs_iunlock(dp, XFS_ILOCK_EXCL);
1298	return error;
1299}
1300
1301int
1302xfs_create_tmpfile(
1303	struct xfs_inode	*dp,
1304	umode_t			mode,
1305	struct xfs_inode	**ipp)
1306{
 
1307	struct xfs_mount	*mp = dp->i_mount;
1308	struct xfs_inode	*ip = NULL;
1309	struct xfs_trans	*tp = NULL;
1310	int			error;
1311	prid_t                  prid;
1312	struct xfs_dquot	*udqp = NULL;
1313	struct xfs_dquot	*gdqp = NULL;
1314	struct xfs_dquot	*pdqp = NULL;
1315	struct xfs_trans_res	*tres;
 
1316	uint			resblks;
 
1317
1318	if (XFS_FORCED_SHUTDOWN(mp))
1319		return -EIO;
1320
1321	prid = xfs_get_initial_prid(dp);
 
1322
1323	/*
1324	 * Make sure that we have allocated dquot(s) on disk.
1325	 */
1326	error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1327				xfs_kgid_to_gid(current_fsgid()), prid,
1328				XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1329				&udqp, &gdqp, &pdqp);
1330	if (error)
1331		return error;
1332
1333	resblks = XFS_IALLOC_SPACE_RES(mp);
1334	tres = &M_RES(mp)->tr_create_tmpfile;
1335
1336	error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
 
1337	if (error)
1338		goto out_release_inode;
1339
1340	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1341						pdqp, resblks, 1, 0);
 
1342	if (error)
1343		goto out_trans_cancel;
1344
1345	error = xfs_dir_ialloc(&tp, dp, mode, 1, 0, prid, &ip);
1346	if (error)
1347		goto out_trans_cancel;
1348
1349	if (mp->m_flags & XFS_MOUNT_WSYNC)
1350		xfs_trans_set_sync(tp);
1351
1352	/*
1353	 * Attach the dquot(s) to the inodes and modify them incore.
1354	 * These ids of the inode couldn't have changed since the new
1355	 * inode has been locked ever since it was created.
1356	 */
1357	xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1358
1359	error = xfs_iunlink(tp, ip);
1360	if (error)
1361		goto out_trans_cancel;
1362
1363	error = xfs_trans_commit(tp);
1364	if (error)
1365		goto out_release_inode;
1366
1367	xfs_qm_dqrele(udqp);
1368	xfs_qm_dqrele(gdqp);
1369	xfs_qm_dqrele(pdqp);
1370
1371	*ipp = ip;
 
1372	return 0;
1373
1374 out_trans_cancel:
1375	xfs_trans_cancel(tp);
1376 out_release_inode:
1377	/*
1378	 * Wait until after the current transaction is aborted to finish the
1379	 * setup of the inode and release the inode.  This prevents recursive
1380	 * transactions and deadlocks from xfs_inactive.
1381	 */
1382	if (ip) {
 
1383		xfs_finish_inode_setup(ip);
1384		IRELE(ip);
1385	}
1386
1387	xfs_qm_dqrele(udqp);
1388	xfs_qm_dqrele(gdqp);
1389	xfs_qm_dqrele(pdqp);
1390
1391	return error;
1392}
1393
1394int
1395xfs_link(
1396	xfs_inode_t		*tdp,
1397	xfs_inode_t		*sip,
1398	struct xfs_name		*target_name)
1399{
1400	xfs_mount_t		*mp = tdp->i_mount;
1401	xfs_trans_t		*tp;
1402	int			error;
1403	struct xfs_defer_ops	dfops;
1404	xfs_fsblock_t           first_block;
 
 
 
1405	int			resblks;
1406
1407	trace_xfs_link(tdp, target_name);
1408
1409	ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
1410
1411	if (XFS_FORCED_SHUTDOWN(mp))
 
 
1412		return -EIO;
1413
1414	error = xfs_qm_dqattach(sip, 0);
1415	if (error)
1416		goto std_return;
1417
1418	error = xfs_qm_dqattach(tdp, 0);
1419	if (error)
1420		goto std_return;
1421
1422	resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
1423	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);
1424	if (error == -ENOSPC) {
1425		resblks = 0;
1426		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);
1427	}
1428	if (error)
1429		goto std_return;
1430
1431	xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);
1432
1433	xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1434	xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
 
1435
1436	/*
1437	 * If we are using project inheritance, we only allow hard link
1438	 * creation in our tree when the project IDs are the same; else
1439	 * the tree quota mechanism could be circumvented.
1440	 */
1441	if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1442		     (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1443		error = -EXDEV;
1444		goto error_return;
1445	}
1446
1447	if (!resblks) {
1448		error = xfs_dir_canenter(tp, tdp, target_name);
1449		if (error)
1450			goto error_return;
1451	}
1452
1453	xfs_defer_init(&dfops, &first_block);
1454
1455	/*
1456	 * Handle initial link state of O_TMPFILE inode
 
 
1457	 */
1458	if (VFS_I(sip)->i_nlink == 0) {
1459		error = xfs_iunlink_remove(tp, sip);
1460		if (error)
 
 
 
 
 
 
 
 
 
 
1461			goto error_return;
 
1462	}
1463
1464	error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1465					&first_block, &dfops, resblks);
1466	if (error)
1467		goto error_return;
1468	xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1469	xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1470
1471	error = xfs_bumplink(tp, sip);
1472	if (error)
1473		goto error_return;
1474
1475	/*
1476	 * If this is a synchronous mount, make sure that the
1477	 * link transaction goes to disk before returning to
1478	 * the user.
1479	 */
1480	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1481		xfs_trans_set_sync(tp);
1482
1483	error = xfs_defer_finish(&tp, &dfops);
1484	if (error) {
1485		xfs_defer_cancel(&dfops);
1486		goto error_return;
1487	}
1488
1489	return xfs_trans_commit(tp);
1490
1491 error_return:
1492	xfs_trans_cancel(tp);
 
 
 
 
1493 std_return:
 
 
1494	return error;
1495}
1496
1497/* Clear the reflink flag and the cowblocks tag if possible. */
1498static void
1499xfs_itruncate_clear_reflink_flags(
1500	struct xfs_inode	*ip)
1501{
1502	struct xfs_ifork	*dfork;
1503	struct xfs_ifork	*cfork;
1504
1505	if (!xfs_is_reflink_inode(ip))
1506		return;
1507	dfork = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1508	cfork = XFS_IFORK_PTR(ip, XFS_COW_FORK);
1509	if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
1510		ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1511	if (cfork->if_bytes == 0)
1512		xfs_inode_clear_cowblocks_tag(ip);
1513}
1514
1515/*
1516 * Free up the underlying blocks past new_size.  The new size must be smaller
1517 * than the current size.  This routine can be used both for the attribute and
1518 * data fork, and does not modify the inode size, which is left to the caller.
1519 *
1520 * The transaction passed to this routine must have made a permanent log
1521 * reservation of at least XFS_ITRUNCATE_LOG_RES.  This routine may commit the
1522 * given transaction and start new ones, so make sure everything involved in
1523 * the transaction is tidy before calling here.  Some transaction will be
1524 * returned to the caller to be committed.  The incoming transaction must
1525 * already include the inode, and both inode locks must be held exclusively.
1526 * The inode must also be "held" within the transaction.  On return the inode
1527 * will be "held" within the returned transaction.  This routine does NOT
1528 * require any disk space to be reserved for it within the transaction.
1529 *
1530 * If we get an error, we must return with the inode locked and linked into the
1531 * current transaction. This keeps things simple for the higher level code,
1532 * because it always knows that the inode is locked and held in the transaction
1533 * that returns to it whether errors occur or not.  We don't mark the inode
1534 * dirty on error so that transactions can be easily aborted if possible.
1535 */
1536int
1537xfs_itruncate_extents(
1538	struct xfs_trans	**tpp,
1539	struct xfs_inode	*ip,
1540	int			whichfork,
1541	xfs_fsize_t		new_size)
 
1542{
1543	struct xfs_mount	*mp = ip->i_mount;
1544	struct xfs_trans	*tp = *tpp;
1545	struct xfs_defer_ops	dfops;
1546	xfs_fsblock_t		first_block;
1547	xfs_fileoff_t		first_unmap_block;
1548	xfs_fileoff_t		last_block;
1549	xfs_filblks_t		unmap_len;
1550	int			error = 0;
1551	int			done = 0;
1552
1553	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1554	ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
1555	       xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1556	ASSERT(new_size <= XFS_ISIZE(ip));
1557	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1558	ASSERT(ip->i_itemp != NULL);
1559	ASSERT(ip->i_itemp->ili_lock_flags == 0);
1560	ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1561
1562	trace_xfs_itruncate_extents_start(ip, new_size);
1563
 
 
1564	/*
1565	 * Since it is possible for space to become allocated beyond
1566	 * the end of the file (in a crash where the space is allocated
1567	 * but the inode size is not yet updated), simply remove any
1568	 * blocks which show up between the new EOF and the maximum
1569	 * possible file size.  If the first block to be removed is
1570	 * beyond the maximum file size (ie it is the same as last_block),
1571	 * then there is nothing to do.
 
1572	 */
1573	first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1574	last_block = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
1575	if (first_unmap_block == last_block)
1576		return 0;
1577
1578	ASSERT(first_unmap_block < last_block);
1579	unmap_len = last_block - first_unmap_block + 1;
1580	while (!done) {
1581		xfs_defer_init(&dfops, &first_block);
1582		error = xfs_bunmapi(tp, ip,
1583				    first_unmap_block, unmap_len,
1584				    xfs_bmapi_aflag(whichfork),
1585				    XFS_ITRUNC_MAX_EXTENTS,
1586				    &first_block, &dfops,
1587				    &done);
1588		if (error)
1589			goto out_bmap_cancel;
1590
1591		/*
1592		 * Duplicate the transaction that has the permanent
1593		 * reservation and commit the old transaction.
1594		 */
1595		xfs_defer_ijoin(&dfops, ip);
1596		error = xfs_defer_finish(&tp, &dfops);
1597		if (error)
1598			goto out_bmap_cancel;
1599
1600		error = xfs_trans_roll_inode(&tp, ip);
1601		if (error)
1602			goto out;
1603	}
1604
 
 
 
 
 
1605	if (whichfork == XFS_DATA_FORK) {
1606		/* Remove all pending CoW reservations. */
1607		error = xfs_reflink_cancel_cow_blocks(ip, &tp,
1608				first_unmap_block, last_block, true);
1609		if (error)
1610			goto out;
1611
1612		xfs_itruncate_clear_reflink_flags(ip);
1613	}
1614
1615	/*
1616	 * Always re-log the inode so that our permanent transaction can keep
1617	 * on rolling it forward in the log.
1618	 */
1619	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1620
1621	trace_xfs_itruncate_extents_end(ip, new_size);
1622
1623out:
1624	*tpp = tp;
1625	return error;
1626out_bmap_cancel:
1627	/*
1628	 * If the bunmapi call encounters an error, return to the caller where
1629	 * the transaction can be properly aborted.  We just need to make sure
1630	 * we're not holding any resources that we were not when we came in.
1631	 */
1632	xfs_defer_cancel(&dfops);
1633	goto out;
1634}
1635
1636int
1637xfs_release(
1638	xfs_inode_t	*ip)
 
 
 
 
 
 
1639{
1640	xfs_mount_t	*mp = ip->i_mount;
1641	int		error;
1642
1643	if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
1644		return 0;
1645
1646	/* If this is a read-only mount, don't do this (would generate I/O) */
1647	if (mp->m_flags & XFS_MOUNT_RDONLY)
1648		return 0;
1649
1650	if (!XFS_FORCED_SHUTDOWN(mp)) {
1651		int truncated;
1652
1653		/*
1654		 * If we previously truncated this file and removed old data
1655		 * in the process, we want to initiate "early" writeout on
1656		 * the last close.  This is an attempt to combat the notorious
1657		 * NULL files problem which is particularly noticeable from a
1658		 * truncate down, buffered (re-)write (delalloc), followed by
1659		 * a crash.  What we are effectively doing here is
1660		 * significantly reducing the time window where we'd otherwise
1661		 * be exposed to that problem.
1662		 */
1663		truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
1664		if (truncated) {
1665			xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
1666			if (ip->i_delayed_blks > 0) {
1667				error = filemap_flush(VFS_I(ip)->i_mapping);
1668				if (error)
1669					return error;
1670			}
1671		}
1672	}
1673
1674	if (VFS_I(ip)->i_nlink == 0)
1675		return 0;
1676
1677	if (xfs_can_free_eofblocks(ip, false)) {
1678
1679		/*
1680		 * Check if the inode is being opened, written and closed
1681		 * frequently and we have delayed allocation blocks outstanding
1682		 * (e.g. streaming writes from the NFS server), truncating the
1683		 * blocks past EOF will cause fragmentation to occur.
1684		 *
1685		 * In this case don't do the truncation, but we have to be
1686		 * careful how we detect this case. Blocks beyond EOF show up as
1687		 * i_delayed_blks even when the inode is clean, so we need to
1688		 * truncate them away first before checking for a dirty release.
1689		 * Hence on the first dirty close we will still remove the
1690		 * speculative allocation, but after that we will leave it in
1691		 * place.
1692		 */
1693		if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
1694			return 0;
1695		/*
1696		 * If we can't get the iolock just skip truncating the blocks
1697		 * past EOF because we could deadlock with the mmap_sem
1698		 * otherwise. We'll get another chance to drop them once the
1699		 * last reference to the inode is dropped, so we'll never leak
1700		 * blocks permanently.
1701		 */
1702		if (xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
1703			error = xfs_free_eofblocks(ip);
1704			xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1705			if (error)
1706				return error;
1707		}
1708
1709		/* delalloc blocks after truncation means it really is dirty */
1710		if (ip->i_delayed_blks)
1711			xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
1712	}
1713	return 0;
1714}
1715
1716/*
1717 * xfs_inactive_truncate
1718 *
1719 * Called to perform a truncate when an inode becomes unlinked.
1720 */
1721STATIC int
1722xfs_inactive_truncate(
1723	struct xfs_inode *ip)
1724{
1725	struct xfs_mount	*mp = ip->i_mount;
1726	struct xfs_trans	*tp;
1727	int			error;
1728
1729	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
1730	if (error) {
1731		ASSERT(XFS_FORCED_SHUTDOWN(mp));
1732		return error;
1733	}
1734
1735	xfs_ilock(ip, XFS_ILOCK_EXCL);
1736	xfs_trans_ijoin(tp, ip, 0);
1737
1738	/*
1739	 * Log the inode size first to prevent stale data exposure in the event
1740	 * of a system crash before the truncate completes. See the related
1741	 * comment in xfs_vn_setattr_size() for details.
1742	 */
1743	ip->i_d.di_size = 0;
1744	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1745
1746	error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1747	if (error)
1748		goto error_trans_cancel;
1749
1750	ASSERT(ip->i_d.di_nextents == 0);
1751
1752	error = xfs_trans_commit(tp);
1753	if (error)
1754		goto error_unlock;
1755
1756	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1757	return 0;
1758
1759error_trans_cancel:
1760	xfs_trans_cancel(tp);
1761error_unlock:
1762	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1763	return error;
1764}
1765
1766/*
1767 * xfs_inactive_ifree()
1768 *
1769 * Perform the inode free when an inode is unlinked.
1770 */
1771STATIC int
1772xfs_inactive_ifree(
1773	struct xfs_inode *ip)
1774{
1775	struct xfs_defer_ops	dfops;
1776	xfs_fsblock_t		first_block;
1777	struct xfs_mount	*mp = ip->i_mount;
1778	struct xfs_trans	*tp;
1779	int			error;
1780
1781	/*
1782	 * We try to use a per-AG reservation for any block needed by the finobt
1783	 * tree, but as the finobt feature predates the per-AG reservation
1784	 * support a degraded file system might not have enough space for the
1785	 * reservation at mount time.  In that case try to dip into the reserved
1786	 * pool and pray.
1787	 *
1788	 * Send a warning if the reservation does happen to fail, as the inode
1789	 * now remains allocated and sits on the unlinked list until the fs is
1790	 * repaired.
1791	 */
1792	if (unlikely(mp->m_inotbt_nores)) {
1793		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1794				XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
1795				&tp);
1796	} else {
1797		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
1798	}
1799	if (error) {
1800		if (error == -ENOSPC) {
1801			xfs_warn_ratelimited(mp,
1802			"Failed to remove inode(s) from unlinked list. "
1803			"Please free space, unmount and run xfs_repair.");
1804		} else {
1805			ASSERT(XFS_FORCED_SHUTDOWN(mp));
1806		}
1807		return error;
1808	}
1809
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1810	xfs_ilock(ip, XFS_ILOCK_EXCL);
1811	xfs_trans_ijoin(tp, ip, 0);
1812
1813	xfs_defer_init(&dfops, &first_block);
1814	error = xfs_ifree(tp, ip, &dfops);
1815	if (error) {
1816		/*
1817		 * If we fail to free the inode, shut down.  The cancel
1818		 * might do that, we need to make sure.  Otherwise the
1819		 * inode might be lost for a long time or forever.
1820		 */
1821		if (!XFS_FORCED_SHUTDOWN(mp)) {
1822			xfs_notice(mp, "%s: xfs_ifree returned error %d",
1823				__func__, error);
1824			xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1825		}
1826		xfs_trans_cancel(tp);
1827		xfs_iunlock(ip, XFS_ILOCK_EXCL);
1828		return error;
1829	}
1830
1831	/*
1832	 * Credit the quota account(s). The inode is gone.
1833	 */
1834	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1835
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1836	/*
1837	 * Just ignore errors at this point.  There is nothing we can do except
1838	 * to try to keep going. Make sure it's not a silent error.
1839	 */
1840	error = xfs_defer_finish(&tp, &dfops);
1841	if (error) {
1842		xfs_notice(mp, "%s: xfs_defer_finish returned error %d",
1843			__func__, error);
1844		xfs_defer_cancel(&dfops);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1845	}
1846	error = xfs_trans_commit(tp);
1847	if (error)
1848		xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
1849			__func__, error);
1850
1851	xfs_iunlock(ip, XFS_ILOCK_EXCL);
1852	return 0;
1853}
1854
1855/*
1856 * xfs_inactive
1857 *
1858 * This is called when the vnode reference count for the vnode
1859 * goes to zero.  If the file has been unlinked, then it must
1860 * now be truncated.  Also, we clear all of the read-ahead state
1861 * kept for the inode here since the file is now closed.
1862 */
1863void
1864xfs_inactive(
1865	xfs_inode_t	*ip)
1866{
1867	struct xfs_mount	*mp;
1868	struct xfs_ifork	*cow_ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
1869	int			error;
1870	int			truncate = 0;
1871
1872	/*
1873	 * If the inode is already free, then there can be nothing
1874	 * to clean up here.
1875	 */
1876	if (VFS_I(ip)->i_mode == 0) {
1877		ASSERT(ip->i_df.if_real_bytes == 0);
1878		ASSERT(ip->i_df.if_broot_bytes == 0);
1879		return;
1880	}
1881
1882	mp = ip->i_mount;
1883	ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1884
1885	/* If this is a read-only mount, don't do this (would generate I/O) */
1886	if (mp->m_flags & XFS_MOUNT_RDONLY)
1887		return;
 
 
 
 
 
 
 
 
 
1888
1889	/* Try to clean out the cow blocks if there are any. */
1890	if (xfs_is_reflink_inode(ip) && cow_ifp->if_bytes > 0)
1891		xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
 
 
 
1892
1893	if (VFS_I(ip)->i_nlink != 0) {
1894		/*
1895		 * force is true because we are evicting an inode from the
1896		 * cache. Post-eof blocks must be freed, lest we end up with
1897		 * broken free space accounting.
1898		 *
1899		 * Note: don't bother with iolock here since lockdep complains
1900		 * about acquiring it in reclaim context. We have the only
1901		 * reference to the inode at this point anyways.
1902		 */
1903		if (xfs_can_free_eofblocks(ip, true))
1904			xfs_free_eofblocks(ip);
1905
1906		return;
1907	}
1908
1909	if (S_ISREG(VFS_I(ip)->i_mode) &&
1910	    (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
1911	     ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
1912		truncate = 1;
1913
1914	error = xfs_qm_dqattach(ip, 0);
1915	if (error)
1916		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1917
1918	if (S_ISLNK(VFS_I(ip)->i_mode))
1919		error = xfs_inactive_symlink(ip);
1920	else if (truncate)
1921		error = xfs_inactive_truncate(ip);
1922	if (error)
1923		return;
1924
1925	/*
1926	 * If there are attributes associated with the file then blow them away
1927	 * now.  The code calls a routine that recursively deconstructs the
1928	 * attribute fork. If also blows away the in-core attribute fork.
1929	 */
1930	if (XFS_IFORK_Q(ip)) {
1931		error = xfs_attr_inactive(ip);
1932		if (error)
1933			return;
1934	}
1935
1936	ASSERT(!ip->i_afp);
1937	ASSERT(ip->i_d.di_anextents == 0);
1938	ASSERT(ip->i_d.di_forkoff == 0);
1939
1940	/*
1941	 * Free the inode.
1942	 */
1943	error = xfs_inactive_ifree(ip);
1944	if (error)
1945		return;
1946
 
1947	/*
1948	 * Release the dquots held by inode, if any.
 
1949	 */
1950	xfs_qm_dqdetach(ip);
 
1951}
1952
1953/*
1954 * This is called when the inode's link count goes to 0 or we are creating a
1955 * tmpfile via O_TMPFILE. In the case of a tmpfile, @ignore_linkcount will be
1956 * set to true as the link count is dropped to zero by the VFS after we've
1957 * created the file successfully, so we have to add it to the unlinked list
1958 * while the link count is non-zero.
1959 *
1960 * We place the on-disk inode on a list in the AGI.  It will be pulled from this
1961 * list when the inode is freed.
1962 */
1963STATIC int
1964xfs_iunlink(
1965	struct xfs_trans *tp,
1966	struct xfs_inode *ip)
1967{
1968	xfs_mount_t	*mp = tp->t_mountp;
1969	xfs_agi_t	*agi;
1970	xfs_dinode_t	*dip;
1971	xfs_buf_t	*agibp;
1972	xfs_buf_t	*ibp;
1973	xfs_agino_t	agino;
1974	short		bucket_index;
1975	int		offset;
1976	int		error;
1977
1978	ASSERT(VFS_I(ip)->i_mode != 0);
1979
1980	/*
1981	 * Get the agi buffer first.  It ensures lock ordering
1982	 * on the list.
1983	 */
1984	error = xfs_read_agi(mp, tp, XFS_INO_TO_AGNO(mp, ip->i_ino), &agibp);
1985	if (error)
1986		return error;
1987	agi = XFS_BUF_TO_AGI(agibp);
1988
1989	/*
1990	 * Get the index into the agi hash table for the
1991	 * list this inode will go on.
1992	 */
1993	agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
1994	ASSERT(agino != 0);
1995	bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
1996	ASSERT(agi->agi_unlinked[bucket_index]);
1997	ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
 
 
 
1998
1999	if (agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO)) {
2000		/*
2001		 * There is already another inode in the bucket we need
2002		 * to add ourselves to.  Add us at the front of the list.
2003		 * Here we put the head pointer into our next pointer,
2004		 * and then we fall through to point the head at us.
2005		 */
2006		error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2007				       0, 0);
2008		if (error)
2009			return error;
 
 
 
 
 
2010
2011		ASSERT(dip->di_next_unlinked == cpu_to_be32(NULLAGINO));
2012		dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
2013		offset = ip->i_imap.im_boffset +
2014			offsetof(xfs_dinode_t, di_next_unlinked);
2015
2016		/* need to recalc the inode CRC if appropriate */
2017		xfs_dinode_calc_crc(mp, dip);
 
 
 
 
2018
2019		xfs_trans_inode_buf(tp, ibp);
2020		xfs_trans_log_buf(tp, ibp, offset,
2021				  (offset + sizeof(xfs_agino_t) - 1));
2022		xfs_inobp_check(mp, ibp);
2023	}
2024
2025	/*
2026	 * Point the bucket head pointer at the inode being inserted.
 
 
 
2027	 */
2028	ASSERT(agino != 0);
2029	agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
2030	offset = offsetof(xfs_agi_t, agi_unlinked) +
2031		(sizeof(xfs_agino_t) * bucket_index);
2032	xfs_trans_log_buf(tp, agibp, offset,
2033			  (offset + sizeof(xfs_agino_t) - 1));
2034	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2035}
2036
2037/*
2038 * Pull the on-disk inode from the AGI unlinked list.
 
 
2039 */
2040STATIC int
2041xfs_iunlink_remove(
2042	xfs_trans_t	*tp,
2043	xfs_inode_t	*ip)
2044{
2045	xfs_ino_t	next_ino;
2046	xfs_mount_t	*mp;
2047	xfs_agi_t	*agi;
2048	xfs_dinode_t	*dip;
2049	xfs_buf_t	*agibp;
2050	xfs_buf_t	*ibp;
2051	xfs_agnumber_t	agno;
2052	xfs_agino_t	agino;
2053	xfs_agino_t	next_agino;
2054	xfs_buf_t	*last_ibp;
2055	xfs_dinode_t	*last_dip = NULL;
2056	short		bucket_index;
2057	int		offset, last_offset = 0;
2058	int		error;
2059
2060	mp = tp->t_mountp;
2061	agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
 
 
 
 
 
 
 
2062
2063	/*
2064	 * Get the agi buffer first.  It ensures lock ordering
2065	 * on the list.
 
 
 
 
 
 
 
 
 
 
 
 
2066	 */
2067	error = xfs_read_agi(mp, tp, agno, &agibp);
2068	if (error)
2069		return error;
 
 
 
 
 
 
2070
2071	agi = XFS_BUF_TO_AGI(agibp);
 
 
 
 
 
 
 
 
 
 
2072
2073	/*
2074	 * Get the index into the agi hash table for the
2075	 * list this inode will go on.
 
 
2076	 */
2077	agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2078	ASSERT(agino != 0);
2079	bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2080	ASSERT(agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO));
2081	ASSERT(agi->agi_unlinked[bucket_index]);
2082
2083	if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
2084		/*
2085		 * We're at the head of the list.  Get the inode's on-disk
2086		 * buffer to see if there is anyone after us on the list.
2087		 * Only modify our next pointer if it is not already NULLAGINO.
2088		 * This saves us the overhead of dealing with the buffer when
2089		 * there is no need to change it.
2090		 */
2091		error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2092				       0, 0);
2093		if (error) {
2094			xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
2095				__func__, error);
2096			return error;
2097		}
2098		next_agino = be32_to_cpu(dip->di_next_unlinked);
2099		ASSERT(next_agino != 0);
2100		if (next_agino != NULLAGINO) {
2101			dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
2102			offset = ip->i_imap.im_boffset +
2103				offsetof(xfs_dinode_t, di_next_unlinked);
2104
2105			/* need to recalc the inode CRC if appropriate */
2106			xfs_dinode_calc_crc(mp, dip);
2107
2108			xfs_trans_inode_buf(tp, ibp);
2109			xfs_trans_log_buf(tp, ibp, offset,
2110					  (offset + sizeof(xfs_agino_t) - 1));
2111			xfs_inobp_check(mp, ibp);
2112		} else {
2113			xfs_trans_brelse(tp, ibp);
2114		}
2115		/*
2116		 * Point the bucket head pointer at the next inode.
2117		 */
2118		ASSERT(next_agino != 0);
2119		ASSERT(next_agino != agino);
2120		agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
2121		offset = offsetof(xfs_agi_t, agi_unlinked) +
2122			(sizeof(xfs_agino_t) * bucket_index);
2123		xfs_trans_log_buf(tp, agibp, offset,
2124				  (offset + sizeof(xfs_agino_t) - 1));
2125	} else {
2126		/*
2127		 * We need to search the list for the inode being freed.
2128		 */
2129		next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2130		last_ibp = NULL;
2131		while (next_agino != agino) {
2132			struct xfs_imap	imap;
2133
2134			if (last_ibp)
2135				xfs_trans_brelse(tp, last_ibp);
2136
2137			imap.im_blkno = 0;
2138			next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
2139
2140			error = xfs_imap(mp, tp, next_ino, &imap, 0);
2141			if (error) {
2142				xfs_warn(mp,
2143	"%s: xfs_imap returned error %d.",
2144					 __func__, error);
2145				return error;
2146			}
2147
2148			error = xfs_imap_to_bp(mp, tp, &imap, &last_dip,
2149					       &last_ibp, 0, 0);
2150			if (error) {
2151				xfs_warn(mp,
2152	"%s: xfs_imap_to_bp returned error %d.",
2153					__func__, error);
2154				return error;
2155			}
2156
2157			last_offset = imap.im_boffset;
2158			next_agino = be32_to_cpu(last_dip->di_next_unlinked);
2159			ASSERT(next_agino != NULLAGINO);
2160			ASSERT(next_agino != 0);
2161		}
2162
2163		/*
2164		 * Now last_ibp points to the buffer previous to us on the
2165		 * unlinked list.  Pull us from the list.
2166		 */
2167		error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2168				       0, 0);
2169		if (error) {
2170			xfs_warn(mp, "%s: xfs_imap_to_bp(2) returned error %d.",
2171				__func__, error);
2172			return error;
2173		}
2174		next_agino = be32_to_cpu(dip->di_next_unlinked);
2175		ASSERT(next_agino != 0);
2176		ASSERT(next_agino != agino);
2177		if (next_agino != NULLAGINO) {
2178			dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
2179			offset = ip->i_imap.im_boffset +
2180				offsetof(xfs_dinode_t, di_next_unlinked);
2181
2182			/* need to recalc the inode CRC if appropriate */
2183			xfs_dinode_calc_crc(mp, dip);
2184
2185			xfs_trans_inode_buf(tp, ibp);
2186			xfs_trans_log_buf(tp, ibp, offset,
2187					  (offset + sizeof(xfs_agino_t) - 1));
2188			xfs_inobp_check(mp, ibp);
2189		} else {
2190			xfs_trans_brelse(tp, ibp);
2191		}
2192		/*
2193		 * Point the previous inode on the list to the next inode.
2194		 */
2195		last_dip->di_next_unlinked = cpu_to_be32(next_agino);
2196		ASSERT(next_agino != 0);
2197		offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
2198
2199		/* need to recalc the inode CRC if appropriate */
2200		xfs_dinode_calc_crc(mp, last_dip);
2201
2202		xfs_trans_inode_buf(tp, last_ibp);
2203		xfs_trans_log_buf(tp, last_ibp, offset,
2204				  (offset + sizeof(xfs_agino_t) - 1));
2205		xfs_inobp_check(mp, last_ibp);
2206	}
2207	return 0;
2208}
2209
2210/*
2211 * A big issue when freeing the inode cluster is that we _cannot_ skip any
2212 * inodes that are in memory - they all must be marked stale and attached to
2213 * the cluster buffer.
2214 */
2215STATIC int
2216xfs_ifree_cluster(
2217	xfs_inode_t		*free_ip,
2218	xfs_trans_t		*tp,
 
2219	struct xfs_icluster	*xic)
2220{
2221	xfs_mount_t		*mp = free_ip->i_mount;
2222	int			blks_per_cluster;
2223	int			inodes_per_cluster;
 
 
2224	int			nbufs;
2225	int			i, j;
2226	int			ioffset;
2227	xfs_daddr_t		blkno;
2228	xfs_buf_t		*bp;
2229	xfs_inode_t		*ip;
2230	xfs_inode_log_item_t	*iip;
2231	struct xfs_log_item	*lip;
2232	struct xfs_perag	*pag;
2233	xfs_ino_t		inum;
2234
2235	inum = xic->first_ino;
2236	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
2237	blks_per_cluster = xfs_icluster_size_fsb(mp);
2238	inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
2239	nbufs = mp->m_ialloc_blks / blks_per_cluster;
2240
2241	for (j = 0; j < nbufs; j++, inum += inodes_per_cluster) {
2242		/*
2243		 * The allocation bitmap tells us which inodes of the chunk were
2244		 * physically allocated. Skip the cluster if an inode falls into
2245		 * a sparse region.
2246		 */
2247		ioffset = inum - xic->first_ino;
2248		if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
2249			ASSERT(do_mod(ioffset, inodes_per_cluster) == 0);
2250			continue;
2251		}
2252
2253		blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2254					 XFS_INO_TO_AGBNO(mp, inum));
2255
2256		/*
2257		 * We obtain and lock the backing buffer first in the process
2258		 * here, as we have to ensure that any dirty inode that we
2259		 * can't get the flush lock on is attached to the buffer.
 
2260		 * If we scan the in-memory inodes first, then buffer IO can
2261		 * complete before we get a lock on it, and hence we may fail
2262		 * to mark all the active inodes on the buffer stale.
2263		 */
2264		bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
2265					mp->m_bsize * blks_per_cluster,
2266					XBF_UNMAPPED);
2267
2268		if (!bp)
2269			return -ENOMEM;
2270
2271		/*
2272		 * This buffer may not have been correctly initialised as we
2273		 * didn't read it from disk. That's not important because we are
2274		 * only using to mark the buffer as stale in the log, and to
2275		 * attach stale cached inodes on it. That means it will never be
2276		 * dispatched for IO. If it is, we want to know about it, and we
2277		 * want it to fail. We can acheive this by adding a write
2278		 * verifier to the buffer.
2279		 */
2280		 bp->b_ops = &xfs_inode_buf_ops;
2281
2282		/*
2283		 * Walk the inodes already attached to the buffer and mark them
2284		 * stale. These will all have the flush locks held, so an
2285		 * in-memory inode walk can't lock them. By marking them all
2286		 * stale first, we will not attempt to lock them in the loop
2287		 * below as the XFS_ISTALE flag will be set.
2288		 */
2289		list_for_each_entry(lip, &bp->b_li_list, li_bio_list) {
2290			if (lip->li_type == XFS_LI_INODE) {
2291				iip = (xfs_inode_log_item_t *)lip;
2292				ASSERT(iip->ili_logged == 1);
2293				lip->li_cb = xfs_istale_done;
2294				xfs_trans_ail_copy_lsn(mp->m_ail,
2295							&iip->ili_flush_lsn,
2296							&iip->ili_item.li_lsn);
2297				xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
2298			}
2299		}
2300
2301
2302		/*
2303		 * For each inode in memory attempt to add it to the inode
2304		 * buffer and set it up for being staled on buffer IO
2305		 * completion.  This is safe as we've locked out tail pushing
2306		 * and flushing by locking the buffer.
2307		 *
2308		 * We have already marked every inode that was part of a
2309		 * transaction stale above, which means there is no point in
2310		 * even trying to lock them.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2311		 */
2312		for (i = 0; i < inodes_per_cluster; i++) {
2313retry:
2314			rcu_read_lock();
2315			ip = radix_tree_lookup(&pag->pag_ici_root,
2316					XFS_INO_TO_AGINO(mp, (inum + i)));
2317
2318			/* Inode not in memory, nothing to do */
2319			if (!ip) {
2320				rcu_read_unlock();
2321				continue;
2322			}
2323
2324			/*
2325			 * because this is an RCU protected lookup, we could
2326			 * find a recently freed or even reallocated inode
2327			 * during the lookup. We need to check under the
2328			 * i_flags_lock for a valid inode here. Skip it if it
2329			 * is not valid, the wrong inode or stale.
2330			 */
2331			spin_lock(&ip->i_flags_lock);
2332			if (ip->i_ino != inum + i ||
2333			    __xfs_iflags_test(ip, XFS_ISTALE)) {
2334				spin_unlock(&ip->i_flags_lock);
2335				rcu_read_unlock();
2336				continue;
2337			}
2338			spin_unlock(&ip->i_flags_lock);
2339
2340			/*
2341			 * Don't try to lock/unlock the current inode, but we
2342			 * _cannot_ skip the other inodes that we did not find
2343			 * in the list attached to the buffer and are not
2344			 * already marked stale. If we can't lock it, back off
2345			 * and retry.
2346			 */
2347			if (ip != free_ip) {
2348				if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2349					rcu_read_unlock();
2350					delay(1);
2351					goto retry;
2352				}
2353
2354				/*
2355				 * Check the inode number again in case we're
2356				 * racing with freeing in xfs_reclaim_inode().
2357				 * See the comments in that function for more
2358				 * information as to why the initial check is
2359				 * not sufficient.
2360				 */
2361				if (ip->i_ino != inum + i) {
2362					xfs_iunlock(ip, XFS_ILOCK_EXCL);
2363					rcu_read_unlock();
2364					continue;
2365				}
2366			}
2367			rcu_read_unlock();
2368
2369			xfs_iflock(ip);
2370			xfs_iflags_set(ip, XFS_ISTALE);
2371
2372			/*
2373			 * we don't need to attach clean inodes or those only
2374			 * with unlogged changes (which we throw away, anyway).
2375			 */
2376			iip = ip->i_itemp;
2377			if (!iip || xfs_inode_clean(ip)) {
2378				ASSERT(ip != free_ip);
2379				xfs_ifunlock(ip);
2380				xfs_iunlock(ip, XFS_ILOCK_EXCL);
2381				continue;
2382			}
2383
2384			iip->ili_last_fields = iip->ili_fields;
2385			iip->ili_fields = 0;
2386			iip->ili_fsync_fields = 0;
2387			iip->ili_logged = 1;
2388			xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
2389						&iip->ili_item.li_lsn);
2390
2391			xfs_buf_attach_iodone(bp, xfs_istale_done,
2392						  &iip->ili_item);
2393
2394			if (ip != free_ip)
2395				xfs_iunlock(ip, XFS_ILOCK_EXCL);
2396		}
2397
2398		xfs_trans_stale_inode_buf(tp, bp);
2399		xfs_trans_binval(tp, bp);
2400	}
2401
2402	xfs_perag_put(pag);
2403	return 0;
2404}
2405
2406/*
2407 * Free any local-format buffers sitting around before we reset to
2408 * extents format.
2409 */
2410static inline void
2411xfs_ifree_local_data(
2412	struct xfs_inode	*ip,
2413	int			whichfork)
2414{
2415	struct xfs_ifork	*ifp;
2416
2417	if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
2418		return;
2419
2420	ifp = XFS_IFORK_PTR(ip, whichfork);
2421	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
2422}
2423
2424/*
2425 * This is called to return an inode to the inode free list.
2426 * The inode should already be truncated to 0 length and have
2427 * no pages associated with it.  This routine also assumes that
2428 * the inode is already a part of the transaction.
2429 *
2430 * The on-disk copy of the inode will have been added to the list
2431 * of unlinked inodes in the AGI. We need to remove the inode from
2432 * that list atomically with respect to freeing it here.
2433 */
2434int
2435xfs_ifree(
2436	xfs_trans_t	*tp,
2437	xfs_inode_t	*ip,
2438	struct xfs_defer_ops	*dfops)
2439{
2440	int			error;
 
2441	struct xfs_icluster	xic = { 0 };
 
 
2442
2443	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2444	ASSERT(VFS_I(ip)->i_nlink == 0);
2445	ASSERT(ip->i_d.di_nextents == 0);
2446	ASSERT(ip->i_d.di_anextents == 0);
2447	ASSERT(ip->i_d.di_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
2448	ASSERT(ip->i_d.di_nblocks == 0);
2449
2450	/*
2451	 * Pull the on-disk inode from the AGI unlinked list.
2452	 */
2453	error = xfs_iunlink_remove(tp, ip);
2454	if (error)
2455		return error;
2456
2457	error = xfs_difree(tp, ip->i_ino, dfops, &xic);
2458	if (error)
2459		return error;
2460
2461	xfs_ifree_local_data(ip, XFS_DATA_FORK);
2462	xfs_ifree_local_data(ip, XFS_ATTR_FORK);
2463
2464	VFS_I(ip)->i_mode = 0;		/* mark incore inode as free */
2465	ip->i_d.di_flags = 0;
2466	ip->i_d.di_flags2 = 0;
2467	ip->i_d.di_dmevmask = 0;
2468	ip->i_d.di_forkoff = 0;		/* mark the attr fork not in use */
2469	ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2470	ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2471
2472	/* Don't attempt to replay owner changes for a deleted inode */
2473	ip->i_itemp->ili_fields &= ~(XFS_ILOG_AOWNER|XFS_ILOG_DOWNER);
2474
2475	/*
2476	 * Bump the generation count so no one will be confused
2477	 * by reincarnations of this inode.
2478	 */
2479	VFS_I(ip)->i_generation++;
2480	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2481
2482	if (xic.deleted)
2483		error = xfs_ifree_cluster(ip, tp, &xic);
2484
 
2485	return error;
2486}
2487
2488/*
2489 * This is called to unpin an inode.  The caller must have the inode locked
2490 * in at least shared mode so that the buffer cannot be subsequently pinned
2491 * once someone is waiting for it to be unpinned.
2492 */
2493static void
2494xfs_iunpin(
2495	struct xfs_inode	*ip)
2496{
2497	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2498
2499	trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
2500
2501	/* Give the log a push to start the unpinning I/O */
2502	xfs_log_force_lsn(ip->i_mount, ip->i_itemp->ili_last_lsn, 0, NULL);
2503
2504}
2505
2506static void
2507__xfs_iunpin_wait(
2508	struct xfs_inode	*ip)
2509{
2510	wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
2511	DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
2512
2513	xfs_iunpin(ip);
2514
2515	do {
2516		prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
2517		if (xfs_ipincount(ip))
2518			io_schedule();
2519	} while (xfs_ipincount(ip));
2520	finish_wait(wq, &wait.wq_entry);
2521}
2522
2523void
2524xfs_iunpin_wait(
2525	struct xfs_inode	*ip)
2526{
2527	if (xfs_ipincount(ip))
2528		__xfs_iunpin_wait(ip);
2529}
2530
2531/*
2532 * Removing an inode from the namespace involves removing the directory entry
2533 * and dropping the link count on the inode. Removing the directory entry can
2534 * result in locking an AGF (directory blocks were freed) and removing a link
2535 * count can result in placing the inode on an unlinked list which results in
2536 * locking an AGI.
2537 *
2538 * The big problem here is that we have an ordering constraint on AGF and AGI
2539 * locking - inode allocation locks the AGI, then can allocate a new extent for
2540 * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
2541 * removes the inode from the unlinked list, requiring that we lock the AGI
2542 * first, and then freeing the inode can result in an inode chunk being freed
2543 * and hence freeing disk space requiring that we lock an AGF.
2544 *
2545 * Hence the ordering that is imposed by other parts of the code is AGI before
2546 * AGF. This means we cannot remove the directory entry before we drop the inode
2547 * reference count and put it on the unlinked list as this results in a lock
2548 * order of AGF then AGI, and this can deadlock against inode allocation and
2549 * freeing. Therefore we must drop the link counts before we remove the
2550 * directory entry.
2551 *
2552 * This is still safe from a transactional point of view - it is not until we
2553 * get to xfs_defer_finish() that we have the possibility of multiple
2554 * transactions in this operation. Hence as long as we remove the directory
2555 * entry and drop the link count in the first transaction of the remove
2556 * operation, there are no transactional constraints on the ordering here.
2557 */
2558int
2559xfs_remove(
2560	xfs_inode_t             *dp,
2561	struct xfs_name		*name,
2562	xfs_inode_t		*ip)
2563{
2564	xfs_mount_t		*mp = dp->i_mount;
2565	xfs_trans_t             *tp = NULL;
 
 
 
 
 
2566	int			is_dir = S_ISDIR(VFS_I(ip)->i_mode);
 
2567	int                     error = 0;
2568	struct xfs_defer_ops	dfops;
2569	xfs_fsblock_t           first_block;
2570	uint			resblks;
2571
2572	trace_xfs_remove(dp, name);
2573
2574	if (XFS_FORCED_SHUTDOWN(mp))
 
 
2575		return -EIO;
2576
2577	error = xfs_qm_dqattach(dp, 0);
2578	if (error)
2579		goto std_return;
2580
2581	error = xfs_qm_dqattach(ip, 0);
2582	if (error)
2583		goto std_return;
2584
2585	/*
2586	 * We try to get the real space reservation first,
2587	 * allowing for directory btree deletion(s) implying
2588	 * possible bmap insert(s).  If we can't get the space
2589	 * reservation then we use 0 instead, and avoid the bmap
2590	 * btree insert(s) in the directory code by, if the bmap
2591	 * insert tries to happen, instead trimming the LAST
2592	 * block from the directory.
2593	 */
2594	resblks = XFS_REMOVE_SPACE_RES(mp);
2595	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, resblks, 0, 0, &tp);
2596	if (error == -ENOSPC) {
2597		resblks = 0;
2598		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0,
2599				&tp);
2600	}
2601	if (error) {
2602		ASSERT(error != -ENOSPC);
2603		goto std_return;
2604	}
2605
2606	xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
2607
2608	xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2609	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2610
2611	/*
2612	 * If we're removing a directory perform some additional validation.
2613	 */
2614	if (is_dir) {
2615		ASSERT(VFS_I(ip)->i_nlink >= 2);
2616		if (VFS_I(ip)->i_nlink != 2) {
2617			error = -ENOTEMPTY;
2618			goto out_trans_cancel;
2619		}
2620		if (!xfs_dir_isempty(ip)) {
2621			error = -ENOTEMPTY;
2622			goto out_trans_cancel;
2623		}
2624
2625		/* Drop the link from ip's "..".  */
2626		error = xfs_droplink(tp, dp);
2627		if (error)
2628			goto out_trans_cancel;
2629
2630		/* Drop the "." link from ip to self.  */
2631		error = xfs_droplink(tp, ip);
2632		if (error)
2633			goto out_trans_cancel;
2634	} else {
2635		/*
2636		 * When removing a non-directory we need to log the parent
2637		 * inode here.  For a directory this is done implicitly
2638		 * by the xfs_droplink call for the ".." entry.
2639		 */
2640		xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2641	}
2642	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2643
2644	/* Drop the link from dp to ip. */
2645	error = xfs_droplink(tp, ip);
2646	if (error)
2647		goto out_trans_cancel;
2648
2649	xfs_defer_init(&dfops, &first_block);
2650	error = xfs_dir_removename(tp, dp, name, ip->i_ino,
2651					&first_block, &dfops, resblks);
2652	if (error) {
2653		ASSERT(error != -ENOENT);
2654		goto out_bmap_cancel;
2655	}
2656
2657	/*
2658	 * If this is a synchronous mount, make sure that the
2659	 * remove transaction goes to disk before returning to
2660	 * the user.
2661	 */
2662	if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2663		xfs_trans_set_sync(tp);
2664
2665	error = xfs_defer_finish(&tp, &dfops);
2666	if (error)
2667		goto out_bmap_cancel;
2668
2669	error = xfs_trans_commit(tp);
2670	if (error)
2671		goto std_return;
2672
2673	if (is_dir && xfs_inode_is_filestream(ip))
2674		xfs_filestream_deassociate(ip);
2675
 
 
 
2676	return 0;
2677
2678 out_bmap_cancel:
2679	xfs_defer_cancel(&dfops);
2680 out_trans_cancel:
2681	xfs_trans_cancel(tp);
 
 
 
 
 
2682 std_return:
2683	return error;
2684}
2685
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2686/*
2687 * Enter all inodes for a rename transaction into a sorted array.
2688 */
2689#define __XFS_SORT_INODES	5
2690STATIC void
2691xfs_sort_for_rename(
2692	struct xfs_inode	*dp1,	/* in: old (source) directory inode */
2693	struct xfs_inode	*dp2,	/* in: new (target) directory inode */
2694	struct xfs_inode	*ip1,	/* in: inode of old entry */
2695	struct xfs_inode	*ip2,	/* in: inode of new entry */
2696	struct xfs_inode	*wip,	/* in: whiteout inode */
2697	struct xfs_inode	**i_tab,/* out: sorted array of inodes */
2698	int			*num_inodes)  /* in/out: inodes in array */
2699{
2700	int			i, j;
2701
2702	ASSERT(*num_inodes == __XFS_SORT_INODES);
2703	memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2704
2705	/*
2706	 * i_tab contains a list of pointers to inodes.  We initialize
2707	 * the table here & we'll sort it.  We will then use it to
2708	 * order the acquisition of the inode locks.
2709	 *
2710	 * Note that the table may contain duplicates.  e.g., dp1 == dp2.
2711	 */
2712	i = 0;
2713	i_tab[i++] = dp1;
2714	i_tab[i++] = dp2;
2715	i_tab[i++] = ip1;
2716	if (ip2)
2717		i_tab[i++] = ip2;
2718	if (wip)
2719		i_tab[i++] = wip;
2720	*num_inodes = i;
2721
2722	/*
2723	 * Sort the elements via bubble sort.  (Remember, there are at
2724	 * most 5 elements to sort, so this is adequate.)
2725	 */
2726	for (i = 0; i < *num_inodes; i++) {
2727		for (j = 1; j < *num_inodes; j++) {
2728			if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
2729				struct xfs_inode *temp = i_tab[j];
2730				i_tab[j] = i_tab[j-1];
2731				i_tab[j-1] = temp;
2732			}
2733		}
2734	}
2735}
2736
2737static int
2738xfs_finish_rename(
2739	struct xfs_trans	*tp,
2740	struct xfs_defer_ops	*dfops)
2741{
2742	int			error;
 
 
2743
2744	/*
2745	 * If this is a synchronous mount, make sure that the rename transaction
2746	 * goes to disk before returning to the user.
2747	 */
2748	if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2749		xfs_trans_set_sync(tp);
2750
2751	error = xfs_defer_finish(&tp, dfops);
2752	if (error) {
2753		xfs_defer_cancel(dfops);
2754		xfs_trans_cancel(tp);
2755		return error;
2756	}
2757
2758	return xfs_trans_commit(tp);
2759}
2760
2761/*
2762 * xfs_cross_rename()
2763 *
2764 * responsible for handling RENAME_EXCHANGE flag in renameat2() sytemcall
2765 */
2766STATIC int
2767xfs_cross_rename(
2768	struct xfs_trans	*tp,
2769	struct xfs_inode	*dp1,
2770	struct xfs_name		*name1,
2771	struct xfs_inode	*ip1,
2772	struct xfs_inode	*dp2,
2773	struct xfs_name		*name2,
2774	struct xfs_inode	*ip2,
2775	struct xfs_defer_ops	*dfops,
2776	xfs_fsblock_t		*first_block,
2777	int			spaceres)
2778{
2779	int		error = 0;
2780	int		ip1_flags = 0;
2781	int		ip2_flags = 0;
2782	int		dp2_flags = 0;
2783
2784	/* Swap inode number for dirent in first parent */
2785	error = xfs_dir_replace(tp, dp1, name1,
2786				ip2->i_ino,
2787				first_block, dfops, spaceres);
2788	if (error)
2789		goto out_trans_abort;
2790
2791	/* Swap inode number for dirent in second parent */
2792	error = xfs_dir_replace(tp, dp2, name2,
2793				ip1->i_ino,
2794				first_block, dfops, spaceres);
2795	if (error)
2796		goto out_trans_abort;
2797
2798	/*
2799	 * If we're renaming one or more directories across different parents,
2800	 * update the respective ".." entries (and link counts) to match the new
2801	 * parents.
2802	 */
2803	if (dp1 != dp2) {
2804		dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2805
2806		if (S_ISDIR(VFS_I(ip2)->i_mode)) {
2807			error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
2808						dp1->i_ino, first_block,
2809						dfops, spaceres);
2810			if (error)
2811				goto out_trans_abort;
2812
2813			/* transfer ip2 ".." reference to dp1 */
2814			if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
2815				error = xfs_droplink(tp, dp2);
2816				if (error)
2817					goto out_trans_abort;
2818				error = xfs_bumplink(tp, dp1);
2819				if (error)
2820					goto out_trans_abort;
2821			}
2822
2823			/*
2824			 * Although ip1 isn't changed here, userspace needs
2825			 * to be warned about the change, so that applications
2826			 * relying on it (like backup ones), will properly
2827			 * notify the change
2828			 */
2829			ip1_flags |= XFS_ICHGTIME_CHG;
2830			ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2831		}
2832
2833		if (S_ISDIR(VFS_I(ip1)->i_mode)) {
2834			error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
2835						dp2->i_ino, first_block,
2836						dfops, spaceres);
2837			if (error)
2838				goto out_trans_abort;
2839
2840			/* transfer ip1 ".." reference to dp2 */
2841			if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
2842				error = xfs_droplink(tp, dp1);
2843				if (error)
2844					goto out_trans_abort;
2845				error = xfs_bumplink(tp, dp2);
2846				if (error)
2847					goto out_trans_abort;
2848			}
2849
2850			/*
2851			 * Although ip2 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_MOD | XFS_ICHGTIME_CHG;
2857			ip2_flags |= XFS_ICHGTIME_CHG;
2858		}
2859	}
2860
2861	if (ip1_flags) {
2862		xfs_trans_ichgtime(tp, ip1, ip1_flags);
2863		xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
2864	}
2865	if (ip2_flags) {
2866		xfs_trans_ichgtime(tp, ip2, ip2_flags);
2867		xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
2868	}
2869	if (dp2_flags) {
2870		xfs_trans_ichgtime(tp, dp2, dp2_flags);
2871		xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
2872	}
2873	xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2874	xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
2875	return xfs_finish_rename(tp, dfops);
2876
2877out_trans_abort:
2878	xfs_defer_cancel(dfops);
2879	xfs_trans_cancel(tp);
2880	return error;
2881}
2882
2883/*
2884 * xfs_rename_alloc_whiteout()
2885 *
2886 * Return a referenced, unlinked, unlocked inode that that can be used as a
2887 * whiteout in a rename transaction. We use a tmpfile inode here so that if we
2888 * crash between allocating the inode and linking it into the rename transaction
2889 * recovery will free the inode and we won't leak it.
2890 */
2891static int
2892xfs_rename_alloc_whiteout(
 
 
2893	struct xfs_inode	*dp,
2894	struct xfs_inode	**wip)
2895{
 
 
 
 
 
 
2896	struct xfs_inode	*tmpfile;
 
2897	int			error;
2898
2899	error = xfs_create_tmpfile(dp, S_IFCHR | WHITEOUT_MODE, &tmpfile);
2900	if (error)
2901		return error;
2902
 
 
 
 
 
 
 
 
 
2903	/*
2904	 * Prepare the tmpfile inode as if it were created through the VFS.
2905	 * Otherwise, the link increment paths will complain about nlink 0->1.
2906	 * Drop the link count as done by d_tmpfile(), complete the inode setup
2907	 * and flag it as linkable.
2908	 */
2909	drop_nlink(VFS_I(tmpfile));
2910	xfs_setup_iops(tmpfile);
2911	xfs_finish_inode_setup(tmpfile);
2912	VFS_I(tmpfile)->i_state |= I_LINKABLE;
2913
2914	*wip = tmpfile;
2915	return 0;
2916}
2917
2918/*
2919 * xfs_rename
2920 */
2921int
2922xfs_rename(
 
2923	struct xfs_inode	*src_dp,
2924	struct xfs_name		*src_name,
2925	struct xfs_inode	*src_ip,
2926	struct xfs_inode	*target_dp,
2927	struct xfs_name		*target_name,
2928	struct xfs_inode	*target_ip,
2929	unsigned int		flags)
2930{
 
 
 
 
 
 
 
 
 
 
 
2931	struct xfs_mount	*mp = src_dp->i_mount;
2932	struct xfs_trans	*tp;
2933	struct xfs_defer_ops	dfops;
2934	xfs_fsblock_t		first_block;
2935	struct xfs_inode	*wip = NULL;		/* whiteout inode */
2936	struct xfs_inode	*inodes[__XFS_SORT_INODES];
 
2937	int			num_inodes = __XFS_SORT_INODES;
2938	bool			new_parent = (src_dp != target_dp);
2939	bool			src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
2940	int			spaceres;
2941	int			error;
 
2942
2943	trace_xfs_rename(src_dp, target_dp, src_name, target_name);
2944
2945	if ((flags & RENAME_EXCHANGE) && !target_ip)
2946		return -EINVAL;
2947
2948	/*
2949	 * If we are doing a whiteout operation, allocate the whiteout inode
2950	 * we will be placing at the target and ensure the type is set
2951	 * appropriately.
2952	 */
2953	if (flags & RENAME_WHITEOUT) {
2954		ASSERT(!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)));
2955		error = xfs_rename_alloc_whiteout(target_dp, &wip);
2956		if (error)
2957			return error;
2958
2959		/* setup target dirent info as whiteout */
2960		src_name->type = XFS_DIR3_FT_CHRDEV;
2961	}
2962
2963	xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
2964				inodes, &num_inodes);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2965
2966	spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
 
 
 
2967	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
2968	if (error == -ENOSPC) {
 
2969		spaceres = 0;
2970		error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
2971				&tp);
2972	}
2973	if (error)
2974		goto out_release_wip;
 
 
 
 
 
 
 
 
 
 
2975
2976	/*
2977	 * Attach the dquots to the inodes
2978	 */
2979	error = xfs_qm_vop_rename_dqattach(inodes);
2980	if (error)
2981		goto out_trans_cancel;
 
 
2982
2983	/*
2984	 * Lock all the participating inodes. Depending upon whether
2985	 * the target_name exists in the target directory, and
2986	 * whether the target directory is the same as the source
2987	 * directory, we can lock from 2 to 4 inodes.
2988	 */
2989	xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
2990
2991	/*
2992	 * Join all the inodes to the transaction. From this point on,
2993	 * we can rely on either trans_commit or trans_cancel to unlock
2994	 * them.
2995	 */
2996	xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
2997	if (new_parent)
2998		xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
2999	xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
3000	if (target_ip)
3001		xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
3002	if (wip)
3003		xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
3004
3005	/*
3006	 * If we are using project inheritance, we only allow renames
3007	 * into our tree when the project IDs are the same; else the
3008	 * tree quota mechanism would be circumvented.
3009	 */
3010	if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
3011		     (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
3012		error = -EXDEV;
3013		goto out_trans_cancel;
3014	}
3015
3016	xfs_defer_init(&dfops, &first_block);
3017
3018	/* RENAME_EXCHANGE is unique from here on. */
3019	if (flags & RENAME_EXCHANGE)
3020		return xfs_cross_rename(tp, src_dp, src_name, src_ip,
3021					target_dp, target_name, target_ip,
3022					&dfops, &first_block, spaceres);
 
 
 
3023
3024	/*
3025	 * Set up the target.
3026	 */
3027	if (target_ip == NULL) {
3028		/*
3029		 * If there's no space reservation, check the entry will
3030		 * fit before actually inserting it.
3031		 */
3032		if (!spaceres) {
3033			error = xfs_dir_canenter(tp, target_dp, target_name);
3034			if (error)
3035				goto out_trans_cancel;
 
 
 
 
 
 
 
 
 
3036		}
3037		/*
3038		 * If target does not exist and the rename crosses
3039		 * directories, adjust the target directory link count
3040		 * to account for the ".." reference from the new entry.
3041		 */
3042		error = xfs_dir_createname(tp, target_dp, target_name,
3043						src_ip->i_ino, &first_block,
3044						&dfops, spaceres);
3045		if (error)
3046			goto out_bmap_cancel;
 
3047
3048		xfs_trans_ichgtime(tp, target_dp,
3049					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 
 
 
 
 
 
3050
3051		if (new_parent && src_is_directory) {
3052			error = xfs_bumplink(tp, target_dp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3053			if (error)
3054				goto out_bmap_cancel;
3055		}
3056	} else { /* target_ip != NULL */
3057		/*
3058		 * If target exists and it's a directory, check that both
3059		 * target and source are directories and that target can be
3060		 * destroyed, or that neither is a directory.
3061		 */
3062		if (S_ISDIR(VFS_I(target_ip)->i_mode)) {
3063			/*
3064			 * Make sure target dir is empty.
3065			 */
3066			if (!(xfs_dir_isempty(target_ip)) ||
3067			    (VFS_I(target_ip)->i_nlink > 2)) {
3068				error = -EEXIST;
3069				goto out_trans_cancel;
3070			}
3071		}
 
3072
 
 
 
 
 
 
3073		/*
3074		 * Link the source inode under the target name.
3075		 * If the source inode is a directory and we are moving
3076		 * it across directories, its ".." entry will be
3077		 * inconsistent until we replace that down below.
3078		 *
3079		 * In case there is already an entry with the same
3080		 * name at the destination directory, remove it first.
3081		 */
3082		error = xfs_dir_replace(tp, target_dp, target_name,
3083					src_ip->i_ino,
3084					&first_block, &dfops, spaceres);
3085		if (error)
3086			goto out_bmap_cancel;
3087
3088		xfs_trans_ichgtime(tp, target_dp,
3089					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 
 
 
 
 
3090
3091		/*
3092		 * Decrement the link count on the target since the target
3093		 * dir no longer points to it.
3094		 */
3095		error = xfs_droplink(tp, target_ip);
3096		if (error)
3097			goto out_bmap_cancel;
3098
3099		if (src_is_directory) {
3100			/*
3101			 * Drop the link from the old "." entry.
3102			 */
3103			error = xfs_droplink(tp, target_ip);
3104			if (error)
3105				goto out_bmap_cancel;
3106		}
3107	} /* target_ip != NULL */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3108
3109	/*
3110	 * Remove the source.
 
 
 
3111	 */
3112	if (new_parent && src_is_directory) {
3113		/*
3114		 * Rewrite the ".." entry to point to the new
3115		 * directory.
3116		 */
3117		error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
3118					target_dp->i_ino,
3119					&first_block, &dfops, spaceres);
3120		ASSERT(error != -EEXIST);
3121		if (error)
3122			goto out_bmap_cancel;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3123	}
3124
3125	/*
3126	 * We always want to hit the ctime on the source inode.
3127	 *
3128	 * This isn't strictly required by the standards since the source
3129	 * inode isn't really being changed, but old unix file systems did
3130	 * it and some incremental backup programs won't work without it.
 
3131	 */
3132	xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
3133	xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
3134
3135	/*
3136	 * Adjust the link count on src_dp.  This is necessary when
3137	 * renaming a directory, either within one parent when
3138	 * the target existed, or across two parent directories.
3139	 */
3140	if (src_is_directory && (new_parent || target_ip != NULL)) {
3141
3142		/*
3143		 * Decrement link count on src_directory since the
3144		 * entry that's moved no longer points to it.
3145		 */
3146		error = xfs_droplink(tp, src_dp);
3147		if (error)
3148			goto out_bmap_cancel;
3149	}
3150
3151	/*
3152	 * For whiteouts, we only need to update the source dirent with the
3153	 * inode number of the whiteout inode rather than removing it
3154	 * altogether.
3155	 */
3156	if (wip) {
3157		error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
3158					&first_block, &dfops, spaceres);
3159	} else
3160		error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
3161					   &first_block, &dfops, spaceres);
3162	if (error)
3163		goto out_bmap_cancel;
3164
3165	/*
3166	 * For whiteouts, we need to bump the link count on the whiteout inode.
3167	 * This means that failures all the way up to this point leave the inode
3168	 * on the unlinked list and so cleanup is a simple matter of dropping
3169	 * the remaining reference to it. If we fail here after bumping the link
3170	 * count, we're shutting down the filesystem so we'll never see the
3171	 * intermediate state on disk.
3172	 */
3173	if (wip) {
3174		ASSERT(VFS_I(wip)->i_nlink == 0);
3175		error = xfs_bumplink(tp, wip);
3176		if (error)
3177			goto out_bmap_cancel;
3178		error = xfs_iunlink_remove(tp, wip);
3179		if (error)
3180			goto out_bmap_cancel;
3181		xfs_trans_log_inode(tp, wip, XFS_ILOG_CORE);
3182
3183		/*
3184		 * Now we have a real link, clear the "I'm a tmpfile" state
3185		 * flag from the inode so it doesn't accidentally get misused in
3186		 * future.
3187		 */
3188		VFS_I(wip)->i_state &= ~I_LINKABLE;
3189	}
3190
3191	xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3192	xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
3193	if (new_parent)
3194		xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
3195
3196	error = xfs_finish_rename(tp, &dfops);
3197	if (wip)
3198		IRELE(wip);
3199	return error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3200
3201out_bmap_cancel:
3202	xfs_defer_cancel(&dfops);
3203out_trans_cancel:
3204	xfs_trans_cancel(tp);
3205out_release_wip:
3206	if (wip)
3207		IRELE(wip);
 
 
 
 
3208	return error;
3209}
3210
3211STATIC int
 
 
 
 
 
 
 
 
 
 
 
 
 
3212xfs_iflush_cluster(
3213	struct xfs_inode	*ip,
3214	struct xfs_buf		*bp)
3215{
3216	struct xfs_mount	*mp = ip->i_mount;
3217	struct xfs_perag	*pag;
3218	unsigned long		first_index, mask;
3219	unsigned long		inodes_per_cluster;
3220	int			cilist_size;
3221	struct xfs_inode	**cilist;
3222	struct xfs_inode	*cip;
3223	int			nr_found;
3224	int			clcount = 0;
3225	int			bufwasdelwri;
3226	int			i;
3227
3228	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
3229
3230	inodes_per_cluster = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
3231	cilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
3232	cilist = kmem_alloc(cilist_size, KM_MAYFAIL|KM_NOFS);
3233	if (!cilist)
3234		goto out_put;
3235
3236	mask = ~(((mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog)) - 1);
3237	first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
3238	rcu_read_lock();
3239	/* really need a gang lookup range call here */
3240	nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)cilist,
3241					first_index, inodes_per_cluster);
3242	if (nr_found == 0)
3243		goto out_free;
3244
3245	for (i = 0; i < nr_found; i++) {
3246		cip = cilist[i];
3247		if (cip == ip)
3248			continue;
3249
3250		/*
3251		 * because this is an RCU protected lookup, we could find a
3252		 * recently freed or even reallocated inode during the lookup.
3253		 * We need to check under the i_flags_lock for a valid inode
3254		 * here. Skip it if it is not valid or the wrong inode.
3255		 */
3256		spin_lock(&cip->i_flags_lock);
3257		if (!cip->i_ino ||
3258		    __xfs_iflags_test(cip, XFS_ISTALE)) {
3259			spin_unlock(&cip->i_flags_lock);
3260			continue;
3261		}
3262
3263		/*
3264		 * Once we fall off the end of the cluster, no point checking
3265		 * any more inodes in the list because they will also all be
3266		 * outside the cluster.
3267		 */
3268		if ((XFS_INO_TO_AGINO(mp, cip->i_ino) & mask) != first_index) {
3269			spin_unlock(&cip->i_flags_lock);
3270			break;
 
 
 
 
3271		}
3272		spin_unlock(&cip->i_flags_lock);
3273
3274		/*
3275		 * Do an un-protected check to see if the inode is dirty and
3276		 * is a candidate for flushing.  These checks will be repeated
3277		 * later after the appropriate locks are acquired.
 
3278		 */
3279		if (xfs_inode_clean(cip) && xfs_ipincount(cip) == 0)
 
3280			continue;
 
 
 
3281
3282		/*
3283		 * Try to get locks.  If any are unavailable or it is pinned,
3284		 * then this inode cannot be flushed and is skipped.
3285		 */
3286
3287		if (!xfs_ilock_nowait(cip, XFS_ILOCK_SHARED))
3288			continue;
3289		if (!xfs_iflock_nowait(cip)) {
3290			xfs_iunlock(cip, XFS_ILOCK_SHARED);
 
 
 
3291			continue;
3292		}
3293		if (xfs_ipincount(cip)) {
3294			xfs_ifunlock(cip);
3295			xfs_iunlock(cip, XFS_ILOCK_SHARED);
3296			continue;
3297		}
3298
3299
3300		/*
3301		 * Check the inode number again, just to be certain we are not
3302		 * racing with freeing in xfs_reclaim_inode(). See the comments
3303		 * in that function for more information as to why the initial
3304		 * check is not sufficient.
3305		 */
3306		if (!cip->i_ino) {
3307			xfs_ifunlock(cip);
3308			xfs_iunlock(cip, XFS_ILOCK_SHARED);
3309			continue;
3310		}
3311
3312		/*
3313		 * arriving here means that this inode can be flushed.  First
3314		 * re-check that it's dirty before flushing.
3315		 */
3316		if (!xfs_inode_clean(cip)) {
3317			int	error;
3318			error = xfs_iflush_int(cip, bp);
3319			if (error) {
3320				xfs_iunlock(cip, XFS_ILOCK_SHARED);
3321				goto cluster_corrupt_out;
3322			}
3323			clcount++;
3324		} else {
3325			xfs_ifunlock(cip);
3326		}
3327		xfs_iunlock(cip, XFS_ILOCK_SHARED);
3328	}
3329
3330	if (clcount) {
3331		XFS_STATS_INC(mp, xs_icluster_flushcnt);
3332		XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
 
 
 
 
 
 
 
 
 
 
 
 
3333	}
3334
3335out_free:
3336	rcu_read_unlock();
3337	kmem_free(cilist);
3338out_put:
3339	xfs_perag_put(pag);
3340	return 0;
3341
 
3342
3343cluster_corrupt_out:
3344	/*
3345	 * Corruption detected in the clustering loop.  Invalidate the
3346	 * inode buffer and shut down the filesystem.
3347	 */
3348	rcu_read_unlock();
3349	/*
3350	 * Clean up the buffer.  If it was delwri, just release it --
3351	 * brelse can handle it with no problems.  If not, shut down the
3352	 * filesystem before releasing the buffer.
3353	 */
3354	bufwasdelwri = (bp->b_flags & _XBF_DELWRI_Q);
3355	if (bufwasdelwri)
3356		xfs_buf_relse(bp);
3357
3358	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 
 
 
 
 
 
 
3359
3360	if (!bufwasdelwri) {
3361		/*
3362		 * Just like incore_relse: if we have b_iodone functions,
3363		 * mark the buffer as an error and call them.  Otherwise
3364		 * mark it as stale and brelse.
3365		 */
3366		if (bp->b_iodone) {
3367			bp->b_flags &= ~XBF_DONE;
3368			xfs_buf_stale(bp);
3369			xfs_buf_ioerror(bp, -EIO);
3370			xfs_buf_ioend(bp);
3371		} else {
3372			xfs_buf_stale(bp);
3373			xfs_buf_relse(bp);
3374		}
3375	}
3376
3377	/*
3378	 * Unlocks the flush lock
3379	 */
3380	xfs_iflush_abort(cip, false);
3381	kmem_free(cilist);
3382	xfs_perag_put(pag);
3383	return -EFSCORRUPTED;
3384}
3385
3386/*
3387 * Flush dirty inode metadata into the backing buffer.
3388 *
3389 * The caller must have the inode lock and the inode flush lock held.  The
3390 * inode lock will still be held upon return to the caller, and the inode
3391 * flush lock will be released after the inode has reached the disk.
3392 *
3393 * The caller must write out the buffer returned in *bpp and release it.
3394 */
3395int
3396xfs_iflush(
3397	struct xfs_inode	*ip,
3398	struct xfs_buf		**bpp)
3399{
3400	struct xfs_mount	*mp = ip->i_mount;
3401	struct xfs_buf		*bp = NULL;
3402	struct xfs_dinode	*dip;
3403	int			error;
3404
3405	XFS_STATS_INC(mp, xs_iflush_count);
3406
3407	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3408	ASSERT(xfs_isiflocked(ip));
3409	ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3410	       ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3411
3412	*bpp = NULL;
 
 
 
 
 
 
 
 
 
3413
3414	xfs_iunpin_wait(ip);
 
 
 
 
 
 
 
 
3415
3416	/*
3417	 * For stale inodes we cannot rely on the backing buffer remaining
3418	 * stale in cache for the remaining life of the stale inode and so
3419	 * xfs_imap_to_bp() below may give us a buffer that no longer contains
3420	 * inodes below. We have to check this after ensuring the inode is
3421	 * unpinned so that it is safe to reclaim the stale inode after the
3422	 * flush call.
3423	 */
3424	if (xfs_iflags_test(ip, XFS_ISTALE)) {
3425		xfs_ifunlock(ip);
3426		return 0;
3427	}
3428
3429	/*
3430	 * This may have been unpinned because the filesystem is shutting
3431	 * down forcibly. If that's the case we must not write this inode
3432	 * to disk, because the log record didn't make it to disk.
3433	 *
3434	 * We also have to remove the log item from the AIL in this case,
3435	 * as we wait for an empty AIL as part of the unmount process.
3436	 */
3437	if (XFS_FORCED_SHUTDOWN(mp)) {
3438		error = -EIO;
3439		goto abort_out;
3440	}
3441
3442	/*
3443	 * Get the buffer containing the on-disk inode. We are doing a try-lock
3444	 * operation here, so we may get  an EAGAIN error. In that case, we
3445	 * simply want to return with the inode still dirty.
3446	 *
3447	 * If we get any other error, we effectively have a corruption situation
3448	 * and we cannot flush the inode, so we treat it the same as failing
3449	 * xfs_iflush_int().
3450	 */
3451	error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &bp, XBF_TRYLOCK,
3452			       0);
3453	if (error == -EAGAIN) {
3454		xfs_ifunlock(ip);
 
 
 
 
 
 
 
 
 
 
 
3455		return error;
3456	}
3457	if (error)
3458		goto corrupt_out;
3459
3460	/*
3461	 * First flush out the inode that xfs_iflush was called with.
3462	 */
3463	error = xfs_iflush_int(ip, bp);
3464	if (error)
3465		goto corrupt_out;
3466
 
 
3467	/*
3468	 * If the buffer is pinned then push on the log now so we won't
3469	 * get stuck waiting in the write for too long.
3470	 */
3471	if (xfs_buf_ispinned(bp))
3472		xfs_log_force(mp, 0);
 
 
 
 
 
3473
3474	/*
3475	 * inode clustering:
3476	 * see if other inodes can be gathered into this write
3477	 */
3478	error = xfs_iflush_cluster(ip, bp);
3479	if (error)
3480		goto cluster_corrupt_out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3481
3482	*bpp = bp;
3483	return 0;
 
3484
3485corrupt_out:
3486	if (bp)
3487		xfs_buf_relse(bp);
3488	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3489cluster_corrupt_out:
3490	error = -EFSCORRUPTED;
3491abort_out:
3492	/*
3493	 * Unlocks the flush lock
3494	 */
3495	xfs_iflush_abort(ip, false);
3496	return error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3497}
3498
3499/*
3500 * If there are inline format data / attr forks attached to this inode,
3501 * make sure they're not corrupt.
 
3502 */
3503bool
3504xfs_inode_verify_forks(
 
3505	struct xfs_inode	*ip)
3506{
3507	struct xfs_ifork	*ifp;
3508	xfs_failaddr_t		fa;
 
 
 
 
 
 
 
 
3509
3510	fa = xfs_ifork_verify_data(ip, &xfs_default_ifork_ops);
3511	if (fa) {
3512		ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
3513		xfs_inode_verifier_error(ip, -EFSCORRUPTED, "data fork",
3514				ifp->if_u1.if_data, ifp->if_bytes, fa);
3515		return false;
 
 
 
 
 
 
 
 
 
3516	}
3517
3518	fa = xfs_ifork_verify_attr(ip, &xfs_default_ifork_ops);
3519	if (fa) {
3520		ifp = XFS_IFORK_PTR(ip, XFS_ATTR_FORK);
3521		xfs_inode_verifier_error(ip, -EFSCORRUPTED, "attr fork",
3522				ifp ? ifp->if_u1.if_data : NULL,
3523				ifp ? ifp->if_bytes : 0, fa);
3524		return false;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3525	}
3526	return true;
 
 
 
 
 
 
3527}
3528
3529STATIC int
3530xfs_iflush_int(
3531	struct xfs_inode	*ip,
3532	struct xfs_buf		*bp)
3533{
3534	struct xfs_inode_log_item *iip = ip->i_itemp;
3535	struct xfs_dinode	*dip;
3536	struct xfs_mount	*mp = ip->i_mount;
3537
3538	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3539	ASSERT(xfs_isiflocked(ip));
3540	ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3541	       ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3542	ASSERT(iip != NULL && iip->ili_fields != 0);
3543	ASSERT(ip->i_d.di_version > 1);
3544
3545	/* set *dip = inode's place in the buffer */
3546	dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
 
 
 
3547
3548	if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
3549			       mp, XFS_ERRTAG_IFLUSH_1)) {
3550		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3551			"%s: Bad inode %Lu magic number 0x%x, ptr "PTR_FMT,
3552			__func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
3553		goto corrupt_out;
3554	}
3555	if (S_ISREG(VFS_I(ip)->i_mode)) {
3556		if (XFS_TEST_ERROR(
3557		    (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3558		    (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3559		    mp, XFS_ERRTAG_IFLUSH_3)) {
3560			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3561				"%s: Bad regular inode %Lu, ptr "PTR_FMT,
3562				__func__, ip->i_ino, ip);
3563			goto corrupt_out;
3564		}
3565	} else if (S_ISDIR(VFS_I(ip)->i_mode)) {
3566		if (XFS_TEST_ERROR(
3567		    (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3568		    (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3569		    (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3570		    mp, XFS_ERRTAG_IFLUSH_4)) {
3571			xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3572				"%s: Bad directory inode %Lu, ptr "PTR_FMT,
3573				__func__, ip->i_ino, ip);
3574			goto corrupt_out;
3575		}
 
 
 
 
 
3576	}
3577	if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3578				ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
3579		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3580			"%s: detected corrupt incore inode %Lu, "
3581			"total extents = %d, nblocks = %Ld, ptr "PTR_FMT,
3582			__func__, ip->i_ino,
3583			ip->i_d.di_nextents + ip->i_d.di_anextents,
3584			ip->i_d.di_nblocks, ip);
3585		goto corrupt_out;
3586	}
3587	if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3588				mp, XFS_ERRTAG_IFLUSH_6)) {
3589		xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3590			"%s: bad inode %Lu, forkoff 0x%x, ptr "PTR_FMT,
3591			__func__, ip->i_ino, ip->i_d.di_forkoff, ip);
3592		goto corrupt_out;
3593	}
3594
3595	/*
3596	 * Inode item log recovery for v2 inodes are dependent on the
3597	 * di_flushiter count for correct sequencing. We bump the flush
3598	 * iteration count so we can detect flushes which postdate a log record
3599	 * during recovery. This is redundant as we now log every change and
3600	 * hence this can't happen but we need to still do it to ensure
3601	 * backwards compatibility with old kernels that predate logging all
3602	 * inode changes.
3603	 */
3604	if (ip->i_d.di_version < 3)
3605		ip->i_d.di_flushiter++;
3606
3607	/* Check the inline fork data before we write out. */
3608	if (!xfs_inode_verify_forks(ip))
3609		goto corrupt_out;
3610
3611	/*
3612	 * Copy the dirty parts of the inode into the on-disk inode.  We always
3613	 * copy out the core of the inode, because if the inode is dirty at all
3614	 * the core must be.
3615	 */
3616	xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
3617
3618	/* Wrap, we never let the log put out DI_MAX_FLUSH */
3619	if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3620		ip->i_d.di_flushiter = 0;
 
 
3621
3622	xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
3623	if (XFS_IFORK_Q(ip))
3624		xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
3625	xfs_inobp_check(mp, bp);
3626
3627	/*
3628	 * We've recorded everything logged in the inode, so we'd like to clear
3629	 * the ili_fields bits so we don't log and flush things unnecessarily.
3630	 * However, we can't stop logging all this information until the data
3631	 * we've copied into the disk buffer is written to disk.  If we did we
3632	 * might overwrite the copy of the inode in the log with all the data
3633	 * after re-logging only part of it, and in the face of a crash we
3634	 * wouldn't have all the data we need to recover.
3635	 *
3636	 * What we do is move the bits to the ili_last_fields field.  When
3637	 * logging the inode, these bits are moved back to the ili_fields field.
3638	 * In the xfs_iflush_done() routine we clear ili_last_fields, since we
3639	 * know that the information those bits represent is permanently on
3640	 * disk.  As long as the flush completes before the inode is logged
3641	 * again, then both ili_fields and ili_last_fields will be cleared.
3642	 *
3643	 * We can play with the ili_fields bits here, because the inode lock
3644	 * must be held exclusively in order to set bits there and the flush
3645	 * lock protects the ili_last_fields bits.  Set ili_logged so the flush
3646	 * done routine can tell whether or not to look in the AIL.  Also, store
3647	 * the current LSN of the inode so that we can tell whether the item has
3648	 * moved in the AIL from xfs_iflush_done().  In order to read the lsn we
3649	 * need the AIL lock, because it is a 64 bit value that cannot be read
3650	 * atomically.
3651	 */
3652	iip->ili_last_fields = iip->ili_fields;
3653	iip->ili_fields = 0;
3654	iip->ili_fsync_fields = 0;
3655	iip->ili_logged = 1;
3656
3657	xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
3658				&iip->ili_item.li_lsn);
3659
3660	/*
3661	 * Attach the function xfs_iflush_done to the inode's
3662	 * buffer.  This will remove the inode from the AIL
3663	 * and unlock the inode's flush lock when the inode is
3664	 * completely written to disk.
3665	 */
3666	xfs_buf_attach_iodone(bp, xfs_iflush_done, &iip->ili_item);
3667
3668	/* generate the checksum. */
3669	xfs_dinode_calc_crc(mp, dip);
 
 
 
3670
3671	ASSERT(!list_empty(&bp->b_li_list));
3672	ASSERT(bp->b_iodone != NULL);
3673	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3674
3675corrupt_out:
3676	return -EFSCORRUPTED;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3677}
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}