fs/xfs/xfs_iget.c

   1 /*
   2  * Copyright (c) 2000-2005 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 "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_types.h"
  21 #include "xfs_bit.h"
  22 #include "xfs_log.h"
  23 #include "xfs_inum.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_ag.h"
  27 #include "xfs_dir2.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_mount.h"
  30 #include "xfs_bmap_btree.h"
  31 #include "xfs_alloc_btree.h"
  32 #include "xfs_ialloc_btree.h"
  33 #include "xfs_dir2_sf.h"
  34 #include "xfs_attr_sf.h"
  35 #include "xfs_dinode.h"
  36 #include "xfs_inode.h"
  37 #include "xfs_btree.h"
  38 #include "xfs_ialloc.h"
  39 #include "xfs_quota.h"
  40 #include "xfs_utils.h"
  41
  42 /*
  43  * Check the validity of the inode we just found it the cache
  44  */
  45 static int
  46 xfs_iget_cache_hit(
  47         struct xfs_perag        *pag,
  48         struct xfs_inode        *ip,
  49         int                     flags,
  50         int                     lock_flags) __releases(pag->pag_ici_lock)
  51 {
  52         struct xfs_mount        *mp = ip->i_mount;
  53         int                     error = 0;
  54
  55         /*
  56          * If INEW is set this inode is being set up
  57          * If IRECLAIM is set this inode is being torn down
  58          * Pause and try again.
  59          */
  60         if (xfs_iflags_test(ip, (XFS_INEW|XFS_IRECLAIM))) {
  61                 error = EAGAIN;
  62                 XFS_STATS_INC(xs_ig_frecycle);
  63                 goto out_error;
  64         }
  65
  66         /* If IRECLAIMABLE is set, we've torn down the vfs inode part */
  67         if (xfs_iflags_test(ip, XFS_IRECLAIMABLE)) {
  68
  69                 /*
  70                  * If lookup is racing with unlink, then we should return an
  71                  * error immediately so we don't remove it from the reclaim
  72                  * list and potentially leak the inode.
  73                  */
  74
  75                 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
  76                         error = ENOENT;
  77                         goto out_error;
  78                 }
  79
  80                 xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
  81
  82                 /*
  83                  * We need to re-initialise the VFS inode as it has been
  84                  * 'freed' by the VFS. Do this here so we can deal with
  85                  * errors cleanly, then tag it so it can be set up correctly
  86                  * later.
  87                  */
  88                 if (!inode_init_always(mp->m_super, VFS_I(ip))) {
  89                         error = ENOMEM;
  90                         goto out_error;
  91                 }
  92                 xfs_iflags_set(ip, XFS_INEW);
  93                 xfs_iflags_clear(ip, XFS_IRECLAIMABLE);
  94
  95                 /* clear the radix tree reclaim flag as well. */
  96                 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
  97                 read_unlock(&pag->pag_ici_lock);
  98
  99                 XFS_MOUNT_ILOCK(mp);
 100                 list_del_init(&ip->i_reclaim);
 101                 XFS_MOUNT_IUNLOCK(mp);
 102         } else if (!igrab(VFS_I(ip))) {
 103                 /* If the VFS inode is being torn down, pause and try again. */
 104                 error = EAGAIN;
 105                 XFS_STATS_INC(xs_ig_frecycle);
 106                 goto out_error;
 107         } else {
 108                 /* we've got a live one */
 109                 read_unlock(&pag->pag_ici_lock);
 110         }
 111
 112         if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
 113                 error = ENOENT;
 114                 goto out;
 115         }
 116
 117         if (lock_flags != 0)
 118                 xfs_ilock(ip, lock_flags);
 119
 120         xfs_iflags_clear(ip, XFS_ISTALE);
 121         xfs_itrace_exit_tag(ip, "xfs_iget.found");
 122         XFS_STATS_INC(xs_ig_found);
 123         return 0;
 124
 125 out_error:
 126         read_unlock(&pag->pag_ici_lock);
 127 out:
 128         return error;
 129 }
 130
 131
 132 static int
 133 xfs_iget_cache_miss(
 134         struct xfs_mount        *mp,
 135         struct xfs_perag        *pag,
 136         xfs_trans_t             *tp,
 137         xfs_ino_t               ino,
 138         struct xfs_inode        **ipp,
 139         xfs_daddr_t             bno,
 140         int                     flags,
 141         int                     lock_flags) __releases(pag->pag_ici_lock)
 142 {
 143         struct xfs_inode        *ip;
 144         int                     error;
 145         unsigned long           first_index, mask;
 146         xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, ino);
 147
 148         /*
 149          * Read the disk inode attributes into a new inode structure and get
 150          * a new vnode for it. This should also initialize i_ino and i_mount.
 151          */
 152         error = xfs_iread(mp, tp, ino, &ip, bno,
 153                           (flags & XFS_IGET_BULKSTAT) ? XFS_IMAP_BULKSTAT : 0);
 154         if (error)
 155                 return error;
 156
 157         xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
 158
 159         if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
 160                 error = ENOENT;
 161                 goto out_destroy;
 162         }
 163
 164         /*
 165          * Preload the radix tree so we can insert safely under the
 166          * write spinlock.
 167          */
 168         if (radix_tree_preload(GFP_KERNEL)) {
 169                 error = EAGAIN;
 170                 goto out_destroy;
 171         }
 172
 173         if (lock_flags)
 174                 xfs_ilock(ip, lock_flags);
 175
 176         mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
 177         first_index = agino & mask;
 178         write_lock(&pag->pag_ici_lock);
 179
 180         /* insert the new inode */
 181         error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
 182         if (unlikely(error)) {
 183                 WARN_ON(error != -EEXIST);
 184                 XFS_STATS_INC(xs_ig_dup);
 185                 error = EAGAIN;
 186                 goto out_unlock;
 187         }
 188
 189         /* These values _must_ be set before releasing the radix tree lock! */
 190         ip->i_udquot = ip->i_gdquot = NULL;
 191         xfs_iflags_set(ip, XFS_INEW);
 192
 193         write_unlock(&pag->pag_ici_lock);
 194         radix_tree_preload_end();
 195         *ipp = ip;
 196         return 0;
 197
 198 out_unlock:
 199         write_unlock(&pag->pag_ici_lock);
 200         radix_tree_preload_end();
 201 out_destroy:
 202         xfs_idestroy(ip);
 203         return error;
 204 }
 205
 206 /*
 207  * Look up an inode by number in the given file system.
 208  * The inode is looked up in the cache held in each AG.
 209  * If the inode is found in the cache, initialise the vfs inode
 210  * if necessary.
 211  *
 212  * If it is not in core, read it in from the file system's device,
 213  * add it to the cache and initialise the vfs inode.
 214  *
 215  * The inode is locked according to the value of the lock_flags parameter.
 216  * This flag parameter indicates how and if the inode's IO lock and inode lock
 217  * should be taken.
 218  *
 219  * mp -- the mount point structure for the current file system.  It points
 220  *       to the inode hash table.
 221  * tp -- a pointer to the current transaction if there is one.  This is
 222  *       simply passed through to the xfs_iread() call.
 223  * ino -- the number of the inode desired.  This is the unique identifier
 224  *        within the file system for the inode being requested.
 225  * lock_flags -- flags indicating how to lock the inode.  See the comment
 226  *               for xfs_ilock() for a list of valid values.
 227  * bno -- the block number starting the buffer containing the inode,
 228  *        if known (as by bulkstat), else 0.
 229  */
 230 int
 231 xfs_iget(
 232         xfs_mount_t     *mp,
 233         xfs_trans_t     *tp,
 234         xfs_ino_t       ino,
 235         uint            flags,
 236         uint            lock_flags,
 237         xfs_inode_t     **ipp,
 238         xfs_daddr_t     bno)
 239 {
 240         xfs_inode_t     *ip;
 241         int             error;
 242         xfs_perag_t     *pag;
 243         xfs_agino_t     agino;
 244
 245         /* the radix tree exists only in inode capable AGs */
 246         if (XFS_INO_TO_AGNO(mp, ino) >= mp->m_maxagi)
 247                 return EINVAL;
 248
 249         /* get the perag structure and ensure that it's inode capable */
 250         pag = xfs_get_perag(mp, ino);
 251         if (!pag->pagi_inodeok)
 252                 return EINVAL;
 253         ASSERT(pag->pag_ici_init);
 254         agino = XFS_INO_TO_AGINO(mp, ino);
 255
 256 again:
 257         error = 0;
 258         read_lock(&pag->pag_ici_lock);
 259         ip = radix_tree_lookup(&pag->pag_ici_root, agino);
 260
 261         if (ip) {
 262                 error = xfs_iget_cache_hit(pag, ip, flags, lock_flags);
 263                 if (error)
 264                         goto out_error_or_again;
 265         } else {
 266                 read_unlock(&pag->pag_ici_lock);
 267                 XFS_STATS_INC(xs_ig_missed);
 268
 269                 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip, bno,
 270                                                         flags, lock_flags);
 271                 if (error)
 272                         goto out_error_or_again;
 273         }
 274         xfs_put_perag(mp, pag);
 275
 276         xfs_iflags_set(ip, XFS_IMODIFIED);
 277         *ipp = ip;
 278
 279         ASSERT(ip->i_df.if_ext_max ==
 280                XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));
 281         /*
 282          * If we have a real type for an on-disk inode, we can set ops(&unlock)
 283          * now.  If it's a new inode being created, xfs_ialloc will handle it.
 284          */
 285         if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
 286                 xfs_setup_inode(ip);
 287         return 0;
 288
 289 out_error_or_again:
 290         if (error == EAGAIN) {
 291                 delay(1);
 292                 goto again;
 293         }
 294         xfs_put_perag(mp, pag);
 295         return error;
 296 }
 297
 298
 299 /*
 300  * Look for the inode corresponding to the given ino in the hash table.
 301  * If it is there and its i_transp pointer matches tp, return it.
 302  * Otherwise, return NULL.
 303  */
 304 xfs_inode_t *
 305 xfs_inode_incore(xfs_mount_t    *mp,
 306                  xfs_ino_t      ino,
 307                  xfs_trans_t    *tp)
 308 {
 309         xfs_inode_t     *ip;
 310         xfs_perag_t     *pag;
 311
 312         pag = xfs_get_perag(mp, ino);
 313         read_lock(&pag->pag_ici_lock);
 314         ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ino));
 315         read_unlock(&pag->pag_ici_lock);
 316         xfs_put_perag(mp, pag);
 317
 318         /* the returned inode must match the transaction */
 319         if (ip && (ip->i_transp != tp))
 320                 return NULL;
 321         return ip;
 322 }
 323
 324 /*
 325  * Decrement reference count of an inode structure and unlock it.
 326  *
 327  * ip -- the inode being released
 328  * lock_flags -- this parameter indicates the inode's locks to be
 329  *       to be released.  See the comment on xfs_iunlock() for a list
 330  *       of valid values.
 331  */
 332 void
 333 xfs_iput(xfs_inode_t    *ip,
 334          uint           lock_flags)
 335 {
 336         xfs_itrace_entry(ip);
 337         xfs_iunlock(ip, lock_flags);
 338         IRELE(ip);
 339 }
 340
 341 /*
 342  * Special iput for brand-new inodes that are still locked
 343  */
 344 void
 345 xfs_iput_new(
 346         xfs_inode_t     *ip,
 347         uint            lock_flags)
 348 {
 349         struct inode    *inode = VFS_I(ip);
 350
 351         xfs_itrace_entry(ip);
 352
 353         if ((ip->i_d.di_mode == 0)) {
 354                 ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
 355                 make_bad_inode(inode);
 356         }
 357         if (inode->i_state & I_NEW)
 358                 unlock_new_inode(inode);
 359         if (lock_flags)
 360                 xfs_iunlock(ip, lock_flags);
 361         IRELE(ip);
 362 }
 363
 364
 365 /*
 366  * This routine embodies the part of the reclaim code that pulls
 367  * the inode from the inode hash table and the mount structure's
 368  * inode list.
 369  * This should only be called from xfs_reclaim().
 370  */
 371 void
 372 xfs_ireclaim(xfs_inode_t *ip)
 373 {
 374         /*
 375          * Remove from old hash list and mount list.
 376          */
 377         XFS_STATS_INC(xs_ig_reclaims);
 378
 379         xfs_iextract(ip);
 380
 381         /*
 382          * Here we do a spurious inode lock in order to coordinate with inode
 383          * cache radix tree lookups.  This is because the lookup can reference
 384          * the inodes in the cache without taking references.  We make that OK
 385          * here by ensuring that we wait until the inode is unlocked after the
 386          * lookup before we go ahead and free it.  We get both the ilock and
 387          * the iolock because the code may need to drop the ilock one but will
 388          * still hold the iolock.
 389          */
 390         xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
 391
 392         /*
 393          * Release dquots (and their references) if any. An inode may escape
 394          * xfs_inactive and get here via vn_alloc->vn_reclaim path.
 395          */
 396         XFS_QM_DQDETACH(ip->i_mount, ip);
 397
 398         /*
 399          * Free all memory associated with the inode.
 400          */
 401         xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
 402         xfs_idestroy(ip);
 403 }
 404
 405 /*
 406  * This routine removes an about-to-be-destroyed inode from
 407  * all of the lists in which it is located with the exception
 408  * of the behavior chain.
 409  */
 410 void
 411 xfs_iextract(
 412         xfs_inode_t     *ip)
 413 {
 414         xfs_mount_t     *mp = ip->i_mount;
 415         xfs_perag_t     *pag = xfs_get_perag(mp, ip->i_ino);
 416
 417         write_lock(&pag->pag_ici_lock);
 418         radix_tree_delete(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ip->i_ino));
 419         write_unlock(&pag->pag_ici_lock);
 420         xfs_put_perag(mp, pag);
 421
 422         /* Deal with the deleted inodes list */
 423         XFS_MOUNT_ILOCK(mp);
 424         list_del_init(&ip->i_reclaim);
 425         mp->m_ireclaims++;
 426         XFS_MOUNT_IUNLOCK(mp);
 427 }
 428
 429 /*
 430  * This is a wrapper routine around the xfs_ilock() routine
 431  * used to centralize some grungy code.  It is used in places
 432  * that wish to lock the inode solely for reading the extents.
 433  * The reason these places can't just call xfs_ilock(SHARED)
 434  * is that the inode lock also guards to bringing in of the
 435  * extents from disk for a file in b-tree format.  If the inode
 436  * is in b-tree format, then we need to lock the inode exclusively
 437  * until the extents are read in.  Locking it exclusively all
 438  * the time would limit our parallelism unnecessarily, though.
 439  * What we do instead is check to see if the extents have been
 440  * read in yet, and only lock the inode exclusively if they
 441  * have not.
 442  *
 443  * The function returns a value which should be given to the
 444  * corresponding xfs_iunlock_map_shared().  This value is
 445  * the mode in which the lock was actually taken.
 446  */
 447 uint
 448 xfs_ilock_map_shared(
 449         xfs_inode_t     *ip)
 450 {
 451         uint    lock_mode;
 452
 453         if ((ip->i_d.di_format == XFS_DINODE_FMT_BTREE) &&
 454             ((ip->i_df.if_flags & XFS_IFEXTENTS) == 0)) {
 455                 lock_mode = XFS_ILOCK_EXCL;
 456         } else {
 457                 lock_mode = XFS_ILOCK_SHARED;
 458         }
 459
 460         xfs_ilock(ip, lock_mode);
 461
 462         return lock_mode;
 463 }
 464
 465 /*
 466  * This is simply the unlock routine to go with xfs_ilock_map_shared().
 467  * All it does is call xfs_iunlock() with the given lock_mode.
 468  */
 469 void
 470 xfs_iunlock_map_shared(
 471         xfs_inode_t     *ip,
 472         unsigned int    lock_mode)
 473 {
 474         xfs_iunlock(ip, lock_mode);
 475 }
 476
 477 /*
 478  * The xfs inode contains 2 locks: a multi-reader lock called the
 479  * i_iolock and a multi-reader lock called the i_lock.  This routine
 480  * allows either or both of the locks to be obtained.
 481  *
 482  * The 2 locks should always be ordered so that the IO lock is
 483  * obtained first in order to prevent deadlock.
 484  *
 485  * ip -- the inode being locked
 486  * lock_flags -- this parameter indicates the inode's locks
 487  *       to be locked.  It can be:
 488  *              XFS_IOLOCK_SHARED,
 489  *              XFS_IOLOCK_EXCL,
 490  *              XFS_ILOCK_SHARED,
 491  *              XFS_ILOCK_EXCL,
 492  *              XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED,
 493  *              XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL,
 494  *              XFS_IOLOCK_EXCL | XFS_ILOCK_SHARED,
 495  *              XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL
 496  */
 497 void
 498 xfs_ilock(
 499         xfs_inode_t             *ip,
 500         uint                    lock_flags)
 501 {
 502         /*
 503          * You can't set both SHARED and EXCL for the same lock,
 504          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 505          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 506          */
 507         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 508                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 509         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 510                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 511         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
 512
 513         if (lock_flags & XFS_IOLOCK_EXCL)
 514                 mrupdate_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
 515         else if (lock_flags & XFS_IOLOCK_SHARED)
 516                 mraccess_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
 517
 518         if (lock_flags & XFS_ILOCK_EXCL)
 519                 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 520         else if (lock_flags & XFS_ILOCK_SHARED)
 521                 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
 522
 523         xfs_ilock_trace(ip, 1, lock_flags, (inst_t *)__return_address);
 524 }
 525
 526 /*
 527  * This is just like xfs_ilock(), except that the caller
 528  * is guaranteed not to sleep.  It returns 1 if it gets
 529  * the requested locks and 0 otherwise.  If the IO lock is
 530  * obtained but the inode lock cannot be, then the IO lock
 531  * is dropped before returning.
 532  *
 533  * ip -- the inode being locked
 534  * lock_flags -- this parameter indicates the inode's locks to be
 535  *       to be locked.  See the comment for xfs_ilock() for a list
 536  *       of valid values.
 537  */
 538 int
 539 xfs_ilock_nowait(
 540         xfs_inode_t             *ip,
 541         uint                    lock_flags)
 542 {
 543         /*
 544          * You can't set both SHARED and EXCL for the same lock,
 545          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 546          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 547          */
 548         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 549                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 550         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 551                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 552         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
 553
 554         if (lock_flags & XFS_IOLOCK_EXCL) {
 555                 if (!mrtryupdate(&ip->i_iolock))
 556                         goto out;
 557         } else if (lock_flags & XFS_IOLOCK_SHARED) {
 558                 if (!mrtryaccess(&ip->i_iolock))
 559                         goto out;
 560         }
 561         if (lock_flags & XFS_ILOCK_EXCL) {
 562                 if (!mrtryupdate(&ip->i_lock))
 563                         goto out_undo_iolock;
 564         } else if (lock_flags & XFS_ILOCK_SHARED) {
 565                 if (!mrtryaccess(&ip->i_lock))
 566                         goto out_undo_iolock;
 567         }
 568         xfs_ilock_trace(ip, 2, lock_flags, (inst_t *)__return_address);
 569         return 1;
 570
 571  out_undo_iolock:
 572         if (lock_flags & XFS_IOLOCK_EXCL)
 573                 mrunlock_excl(&ip->i_iolock);
 574         else if (lock_flags & XFS_IOLOCK_SHARED)
 575                 mrunlock_shared(&ip->i_iolock);
 576  out:
 577         return 0;
 578 }
 579
 580 /*
 581  * xfs_iunlock() is used to drop the inode locks acquired with
 582  * xfs_ilock() and xfs_ilock_nowait().  The caller must pass
 583  * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
 584  * that we know which locks to drop.
 585  *
 586  * ip -- the inode being unlocked
 587  * lock_flags -- this parameter indicates the inode's locks to be
 588  *       to be unlocked.  See the comment for xfs_ilock() for a list
 589  *       of valid values for this parameter.
 590  *
 591  */
 592 void
 593 xfs_iunlock(
 594         xfs_inode_t             *ip,
 595         uint                    lock_flags)
 596 {
 597         /*
 598          * You can't set both SHARED and EXCL for the same lock,
 599          * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
 600          * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
 601          */
 602         ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
 603                (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
 604         ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
 605                (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
 606         ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_IUNLOCK_NONOTIFY |
 607                         XFS_LOCK_DEP_MASK)) == 0);
 608         ASSERT(lock_flags != 0);
 609
 610         if (lock_flags & XFS_IOLOCK_EXCL)
 611                 mrunlock_excl(&ip->i_iolock);
 612         else if (lock_flags & XFS_IOLOCK_SHARED)
 613                 mrunlock_shared(&ip->i_iolock);
 614
 615         if (lock_flags & XFS_ILOCK_EXCL)
 616                 mrunlock_excl(&ip->i_lock);
 617         else if (lock_flags & XFS_ILOCK_SHARED)
 618                 mrunlock_shared(&ip->i_lock);
 619
 620         if ((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) &&
 621             !(lock_flags & XFS_IUNLOCK_NONOTIFY) && ip->i_itemp) {
 622                 /*
 623                  * Let the AIL know that this item has been unlocked in case
 624                  * it is in the AIL and anyone is waiting on it.  Don't do
 625                  * this if the caller has asked us not to.
 626                  */
 627                 xfs_trans_unlocked_item(ip->i_mount,
 628                                         (xfs_log_item_t*)(ip->i_itemp));
 629         }
 630         xfs_ilock_trace(ip, 3, lock_flags, (inst_t *)__return_address);
 631 }
 632
 633 /*
 634  * give up write locks.  the i/o lock cannot be held nested
 635  * if it is being demoted.
 636  */
 637 void
 638 xfs_ilock_demote(
 639         xfs_inode_t             *ip,
 640         uint                    lock_flags)
 641 {
 642         ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL));
 643         ASSERT((lock_flags & ~(XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
 644
 645         if (lock_flags & XFS_ILOCK_EXCL)
 646                 mrdemote(&ip->i_lock);
 647         if (lock_flags & XFS_IOLOCK_EXCL)
 648                 mrdemote(&ip->i_iolock);
 649 }
 650
 651 #ifdef DEBUG
 652 /*
 653  * Debug-only routine, without additional rw_semaphore APIs, we can
 654  * now only answer requests regarding whether we hold the lock for write
 655  * (reader state is outside our visibility, we only track writer state).
 656  *
 657  * Note: this means !xfs_isilocked would give false positives, so don't do that.
 658  */
 659 int
 660 xfs_isilocked(
 661         xfs_inode_t             *ip,
 662         uint                    lock_flags)
 663 {
 664         if ((lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) ==
 665                         XFS_ILOCK_EXCL) {
 666                 if (!ip->i_lock.mr_writer)
 667                         return 0;
 668         }
 669
 670         if ((lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) ==
 671                         XFS_IOLOCK_EXCL) {
 672                 if (!ip->i_iolock.mr_writer)
 673                         return 0;
 674         }
 675
 676         return 1;
 677 }
 678 #endif
 679