fs/xfs/xfs_inode.c

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