2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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.
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.
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
20 #include "xfs_types.h"
24 #include "xfs_trans.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 #include "xfs_trans_priv.h"
42 #include "xfs_inode_item.h"
44 #include "xfs_btree_trace.h"
45 #include "xfs_dir2_trace.h"
49 * Allocate and initialise an xfs_inode.
51 STATIC struct xfs_inode *
59 * if this didn't occur in transactions, we could use
60 * KM_MAYFAIL and return NULL here on ENOMEM. Set the
61 * code up to do this anyway.
63 ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
67 ASSERT(atomic_read(&ip->i_iocount) == 0);
68 ASSERT(atomic_read(&ip->i_pincount) == 0);
69 ASSERT(!spin_is_locked(&ip->i_flags_lock));
70 ASSERT(completion_done(&ip->i_flush));
72 /* initialise the xfs inode */
75 memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
77 memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
79 ip->i_update_core = 0;
80 ip->i_update_size = 0;
81 ip->i_delayed_blks = 0;
82 memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
87 * Initialize inode's trace buffers.
89 #ifdef XFS_INODE_TRACE
90 ip->i_trace = ktrace_alloc(INODE_TRACE_SIZE, KM_NOFS);
93 ip->i_xtrace = ktrace_alloc(XFS_BMAP_KTRACE_SIZE, KM_NOFS);
95 #ifdef XFS_BTREE_TRACE
96 ip->i_btrace = ktrace_alloc(XFS_BMBT_KTRACE_SIZE, KM_NOFS);
99 ip->i_rwtrace = ktrace_alloc(XFS_RW_KTRACE_SIZE, KM_NOFS);
101 #ifdef XFS_ILOCK_TRACE
102 ip->i_lock_trace = ktrace_alloc(XFS_ILOCK_KTRACE_SIZE, KM_NOFS);
104 #ifdef XFS_DIR2_TRACE
105 ip->i_dir_trace = ktrace_alloc(XFS_DIR2_KTRACE_SIZE, KM_NOFS);
108 * Now initialise the VFS inode. We do this after the xfs_inode
109 * initialisation as internal failures will result in ->destroy_inode
110 * being called and that will pass down through the reclaim path and
111 * free the XFS inode. This path requires the XFS inode to already be
112 * initialised. Hence if this call fails, the xfs_inode has already
113 * been freed and we should not reference it at all in the error
116 if (!inode_init_always(mp->m_super, VFS_I(ip)))
119 /* prevent anyone from using this yet */
120 VFS_I(ip)->i_state = I_NEW|I_LOCK;
126 * Check the validity of the inode we just found it the cache
130 struct xfs_perag *pag,
131 struct xfs_inode *ip,
133 int lock_flags) __releases(pag->pag_ici_lock)
135 struct xfs_mount *mp = ip->i_mount;
139 * If INEW is set this inode is being set up
140 * If IRECLAIM is set this inode is being torn down
141 * Pause and try again.
143 if (xfs_iflags_test(ip, (XFS_INEW|XFS_IRECLAIM))) {
144 XFS_STATS_INC(xs_ig_frecycle);
148 /* If IRECLAIMABLE is set, we've torn down the vfs inode part */
149 if (xfs_iflags_test(ip, XFS_IRECLAIMABLE)) {
152 * If lookup is racing with unlink, then we should return an
153 * error immediately so we don't remove it from the reclaim
154 * list and potentially leak the inode.
156 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
161 xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
164 * We need to re-initialise the VFS inode as it has been
165 * 'freed' by the VFS. Do this here so we can deal with
166 * errors cleanly, then tag it so it can be set up correctly
169 if (!inode_init_always(mp->m_super, VFS_I(ip))) {
175 * We must set the XFS_INEW flag before clearing the
176 * XFS_IRECLAIMABLE flag so that if a racing lookup does
177 * not find the XFS_IRECLAIMABLE above but has the igrab()
178 * below succeed we can safely check XFS_INEW to detect
179 * that this inode is still being initialised.
181 xfs_iflags_set(ip, XFS_INEW);
182 xfs_iflags_clear(ip, XFS_IRECLAIMABLE);
184 /* clear the radix tree reclaim flag as well. */
185 __xfs_inode_clear_reclaim_tag(mp, pag, ip);
186 } else if (!igrab(VFS_I(ip))) {
187 /* If the VFS inode is being torn down, pause and try again. */
188 XFS_STATS_INC(xs_ig_frecycle);
190 } else if (xfs_iflags_test(ip, XFS_INEW)) {
192 * We are racing with another cache hit that is
193 * currently recycling this inode out of the XFS_IRECLAIMABLE
194 * state. Wait for the initialisation to complete before
197 wait_on_inode(VFS_I(ip));
200 if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
206 /* We've got a live one. */
207 read_unlock(&pag->pag_ici_lock);
210 xfs_ilock(ip, lock_flags);
212 xfs_iflags_clear(ip, XFS_ISTALE);
213 xfs_itrace_exit_tag(ip, "xfs_iget.found");
214 XFS_STATS_INC(xs_ig_found);
218 read_unlock(&pag->pag_ici_lock);
225 struct xfs_mount *mp,
226 struct xfs_perag *pag,
229 struct xfs_inode **ipp,
232 int lock_flags) __releases(pag->pag_ici_lock)
234 struct xfs_inode *ip;
236 unsigned long first_index, mask;
237 xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
239 ip = xfs_inode_alloc(mp, ino);
243 error = xfs_iread(mp, tp, ip, bno, flags);
247 xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
249 if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
255 * Preload the radix tree so we can insert safely under the
256 * write spinlock. Note that we cannot sleep inside the preload
259 if (radix_tree_preload(GFP_KERNEL)) {
265 * Because the inode hasn't been added to the radix-tree yet it can't
266 * be found by another thread, so we can do the non-sleeping lock here.
269 if (!xfs_ilock_nowait(ip, lock_flags))
273 mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
274 first_index = agino & mask;
275 write_lock(&pag->pag_ici_lock);
277 /* insert the new inode */
278 error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
279 if (unlikely(error)) {
280 WARN_ON(error != -EEXIST);
281 XFS_STATS_INC(xs_ig_dup);
283 goto out_preload_end;
286 /* These values _must_ be set before releasing the radix tree lock! */
287 ip->i_udquot = ip->i_gdquot = NULL;
288 xfs_iflags_set(ip, XFS_INEW);
290 write_unlock(&pag->pag_ici_lock);
291 radix_tree_preload_end();
296 write_unlock(&pag->pag_ici_lock);
297 radix_tree_preload_end();
299 xfs_iunlock(ip, lock_flags);
301 xfs_destroy_inode(ip);
306 * Look up an inode by number in the given file system.
307 * The inode is looked up in the cache held in each AG.
308 * If the inode is found in the cache, initialise the vfs inode
311 * If it is not in core, read it in from the file system's device,
312 * add it to the cache and initialise the vfs inode.
314 * The inode is locked according to the value of the lock_flags parameter.
315 * This flag parameter indicates how and if the inode's IO lock and inode lock
318 * mp -- the mount point structure for the current file system. It points
319 * to the inode hash table.
320 * tp -- a pointer to the current transaction if there is one. This is
321 * simply passed through to the xfs_iread() call.
322 * ino -- the number of the inode desired. This is the unique identifier
323 * within the file system for the inode being requested.
324 * lock_flags -- flags indicating how to lock the inode. See the comment
325 * for xfs_ilock() for a list of valid values.
326 * bno -- the block number starting the buffer containing the inode,
327 * if known (as by bulkstat), else 0.
344 /* the radix tree exists only in inode capable AGs */
345 if (XFS_INO_TO_AGNO(mp, ino) >= mp->m_maxagi)
348 /* get the perag structure and ensure that it's inode capable */
349 pag = xfs_get_perag(mp, ino);
350 if (!pag->pagi_inodeok)
352 ASSERT(pag->pag_ici_init);
353 agino = XFS_INO_TO_AGINO(mp, ino);
357 read_lock(&pag->pag_ici_lock);
358 ip = radix_tree_lookup(&pag->pag_ici_root, agino);
361 error = xfs_iget_cache_hit(pag, ip, flags, lock_flags);
363 goto out_error_or_again;
365 read_unlock(&pag->pag_ici_lock);
366 XFS_STATS_INC(xs_ig_missed);
368 error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip, bno,
371 goto out_error_or_again;
373 xfs_put_perag(mp, pag);
377 ASSERT(ip->i_df.if_ext_max ==
378 XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));
380 * If we have a real type for an on-disk inode, we can set ops(&unlock)
381 * now. If it's a new inode being created, xfs_ialloc will handle it.
383 if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
388 if (error == EAGAIN) {
392 xfs_put_perag(mp, pag);
398 * Look for the inode corresponding to the given ino in the hash table.
399 * If it is there and its i_transp pointer matches tp, return it.
400 * Otherwise, return NULL.
403 xfs_inode_incore(xfs_mount_t *mp,
410 pag = xfs_get_perag(mp, ino);
411 read_lock(&pag->pag_ici_lock);
412 ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ino));
413 read_unlock(&pag->pag_ici_lock);
414 xfs_put_perag(mp, pag);
416 /* the returned inode must match the transaction */
417 if (ip && (ip->i_transp != tp))
423 * Decrement reference count of an inode structure and unlock it.
425 * ip -- the inode being released
426 * lock_flags -- this parameter indicates the inode's locks to be
427 * to be released. See the comment on xfs_iunlock() for a list
431 xfs_iput(xfs_inode_t *ip,
434 xfs_itrace_entry(ip);
435 xfs_iunlock(ip, lock_flags);
440 * Special iput for brand-new inodes that are still locked
447 struct inode *inode = VFS_I(ip);
449 xfs_itrace_entry(ip);
451 if ((ip->i_d.di_mode == 0)) {
452 ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
453 make_bad_inode(inode);
455 if (inode->i_state & I_NEW)
456 unlock_new_inode(inode);
458 xfs_iunlock(ip, lock_flags);
463 * This is called free all the memory associated with an inode.
464 * It must free the inode itself and any buffers allocated for
465 * if_extents/if_data and if_broot. It must also free the lock
466 * associated with the inode.
468 * Note: because we don't initialise everything on reallocation out
469 * of the zone, we must ensure we nullify everything correctly before
470 * freeing the structure.
474 struct xfs_inode *ip)
476 struct xfs_mount *mp = ip->i_mount;
477 struct xfs_perag *pag;
479 XFS_STATS_INC(xs_ig_reclaims);
482 * Remove the inode from the per-AG radix tree. It doesn't matter
483 * if it was never added to it because radix_tree_delete can deal
484 * with that case just fine.
486 pag = xfs_get_perag(mp, ip->i_ino);
487 write_lock(&pag->pag_ici_lock);
488 radix_tree_delete(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ip->i_ino));
489 write_unlock(&pag->pag_ici_lock);
490 xfs_put_perag(mp, pag);
493 * Here we do an (almost) spurious inode lock in order to coordinate
494 * with inode cache radix tree lookups. This is because the lookup
495 * can reference the inodes in the cache without taking references.
497 * We make that OK here by ensuring that we wait until the inode is
498 * unlocked after the lookup before we go ahead and free it. We get
499 * both the ilock and the iolock because the code may need to drop the
500 * ilock one but will still hold the iolock.
502 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
504 xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
506 switch (ip->i_d.di_mode & S_IFMT) {
510 xfs_idestroy_fork(ip, XFS_DATA_FORK);
515 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
517 #ifdef XFS_INODE_TRACE
518 ktrace_free(ip->i_trace);
520 #ifdef XFS_BMAP_TRACE
521 ktrace_free(ip->i_xtrace);
523 #ifdef XFS_BTREE_TRACE
524 ktrace_free(ip->i_btrace);
527 ktrace_free(ip->i_rwtrace);
529 #ifdef XFS_ILOCK_TRACE
530 ktrace_free(ip->i_lock_trace);
532 #ifdef XFS_DIR2_TRACE
533 ktrace_free(ip->i_dir_trace);
537 * Only if we are shutting down the fs will we see an
538 * inode still in the AIL. If it is there, we should remove
539 * it to prevent a use-after-free from occurring.
541 xfs_log_item_t *lip = &ip->i_itemp->ili_item;
542 struct xfs_ail *ailp = lip->li_ailp;
544 ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) ||
545 XFS_FORCED_SHUTDOWN(ip->i_mount));
546 if (lip->li_flags & XFS_LI_IN_AIL) {
547 spin_lock(&ailp->xa_lock);
548 if (lip->li_flags & XFS_LI_IN_AIL)
549 xfs_trans_ail_delete(ailp, lip);
551 spin_unlock(&ailp->xa_lock);
553 xfs_inode_item_destroy(ip);
556 /* asserts to verify all state is correct here */
557 ASSERT(atomic_read(&ip->i_iocount) == 0);
558 ASSERT(atomic_read(&ip->i_pincount) == 0);
559 ASSERT(!spin_is_locked(&ip->i_flags_lock));
560 ASSERT(completion_done(&ip->i_flush));
561 kmem_zone_free(xfs_inode_zone, ip);
565 * This is a wrapper routine around the xfs_ilock() routine
566 * used to centralize some grungy code. It is used in places
567 * that wish to lock the inode solely for reading the extents.
568 * The reason these places can't just call xfs_ilock(SHARED)
569 * is that the inode lock also guards to bringing in of the
570 * extents from disk for a file in b-tree format. If the inode
571 * is in b-tree format, then we need to lock the inode exclusively
572 * until the extents are read in. Locking it exclusively all
573 * the time would limit our parallelism unnecessarily, though.
574 * What we do instead is check to see if the extents have been
575 * read in yet, and only lock the inode exclusively if they
578 * The function returns a value which should be given to the
579 * corresponding xfs_iunlock_map_shared(). This value is
580 * the mode in which the lock was actually taken.
583 xfs_ilock_map_shared(
588 if ((ip->i_d.di_format == XFS_DINODE_FMT_BTREE) &&
589 ((ip->i_df.if_flags & XFS_IFEXTENTS) == 0)) {
590 lock_mode = XFS_ILOCK_EXCL;
592 lock_mode = XFS_ILOCK_SHARED;
595 xfs_ilock(ip, lock_mode);
601 * This is simply the unlock routine to go with xfs_ilock_map_shared().
602 * All it does is call xfs_iunlock() with the given lock_mode.
605 xfs_iunlock_map_shared(
607 unsigned int lock_mode)
609 xfs_iunlock(ip, lock_mode);
613 * The xfs inode contains 2 locks: a multi-reader lock called the
614 * i_iolock and a multi-reader lock called the i_lock. This routine
615 * allows either or both of the locks to be obtained.
617 * The 2 locks should always be ordered so that the IO lock is
618 * obtained first in order to prevent deadlock.
620 * ip -- the inode being locked
621 * lock_flags -- this parameter indicates the inode's locks
622 * to be locked. It can be:
627 * XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED,
628 * XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL,
629 * XFS_IOLOCK_EXCL | XFS_ILOCK_SHARED,
630 * XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL
638 * You can't set both SHARED and EXCL for the same lock,
639 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
640 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
642 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
643 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
644 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
645 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
646 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
648 if (lock_flags & XFS_IOLOCK_EXCL)
649 mrupdate_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
650 else if (lock_flags & XFS_IOLOCK_SHARED)
651 mraccess_nested(&ip->i_iolock, XFS_IOLOCK_DEP(lock_flags));
653 if (lock_flags & XFS_ILOCK_EXCL)
654 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
655 else if (lock_flags & XFS_ILOCK_SHARED)
656 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
658 xfs_ilock_trace(ip, 1, lock_flags, (inst_t *)__return_address);
662 * This is just like xfs_ilock(), except that the caller
663 * is guaranteed not to sleep. It returns 1 if it gets
664 * the requested locks and 0 otherwise. If the IO lock is
665 * obtained but the inode lock cannot be, then the IO lock
666 * is dropped before returning.
668 * ip -- the inode being locked
669 * lock_flags -- this parameter indicates the inode's locks to be
670 * to be locked. See the comment for xfs_ilock() for a list
679 * You can't set both SHARED and EXCL for the same lock,
680 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
681 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
683 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
684 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
685 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
686 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
687 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_DEP_MASK)) == 0);
689 if (lock_flags & XFS_IOLOCK_EXCL) {
690 if (!mrtryupdate(&ip->i_iolock))
692 } else if (lock_flags & XFS_IOLOCK_SHARED) {
693 if (!mrtryaccess(&ip->i_iolock))
696 if (lock_flags & XFS_ILOCK_EXCL) {
697 if (!mrtryupdate(&ip->i_lock))
698 goto out_undo_iolock;
699 } else if (lock_flags & XFS_ILOCK_SHARED) {
700 if (!mrtryaccess(&ip->i_lock))
701 goto out_undo_iolock;
703 xfs_ilock_trace(ip, 2, lock_flags, (inst_t *)__return_address);
707 if (lock_flags & XFS_IOLOCK_EXCL)
708 mrunlock_excl(&ip->i_iolock);
709 else if (lock_flags & XFS_IOLOCK_SHARED)
710 mrunlock_shared(&ip->i_iolock);
716 * xfs_iunlock() is used to drop the inode locks acquired with
717 * xfs_ilock() and xfs_ilock_nowait(). The caller must pass
718 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
719 * that we know which locks to drop.
721 * ip -- the inode being unlocked
722 * lock_flags -- this parameter indicates the inode's locks to be
723 * to be unlocked. See the comment for xfs_ilock() for a list
724 * of valid values for this parameter.
733 * You can't set both SHARED and EXCL for the same lock,
734 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
735 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
737 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
738 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
739 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
740 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
741 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_IUNLOCK_NONOTIFY |
742 XFS_LOCK_DEP_MASK)) == 0);
743 ASSERT(lock_flags != 0);
745 if (lock_flags & XFS_IOLOCK_EXCL)
746 mrunlock_excl(&ip->i_iolock);
747 else if (lock_flags & XFS_IOLOCK_SHARED)
748 mrunlock_shared(&ip->i_iolock);
750 if (lock_flags & XFS_ILOCK_EXCL)
751 mrunlock_excl(&ip->i_lock);
752 else if (lock_flags & XFS_ILOCK_SHARED)
753 mrunlock_shared(&ip->i_lock);
755 if ((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) &&
756 !(lock_flags & XFS_IUNLOCK_NONOTIFY) && ip->i_itemp) {
758 * Let the AIL know that this item has been unlocked in case
759 * it is in the AIL and anyone is waiting on it. Don't do
760 * this if the caller has asked us not to.
762 xfs_trans_unlocked_item(ip->i_itemp->ili_item.li_ailp,
763 (xfs_log_item_t*)(ip->i_itemp));
765 xfs_ilock_trace(ip, 3, lock_flags, (inst_t *)__return_address);
769 * give up write locks. the i/o lock cannot be held nested
770 * if it is being demoted.
777 ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL));
778 ASSERT((lock_flags & ~(XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
780 if (lock_flags & XFS_ILOCK_EXCL)
781 mrdemote(&ip->i_lock);
782 if (lock_flags & XFS_IOLOCK_EXCL)
783 mrdemote(&ip->i_iolock);
788 * Debug-only routine, without additional rw_semaphore APIs, we can
789 * now only answer requests regarding whether we hold the lock for write
790 * (reader state is outside our visibility, we only track writer state).
792 * Note: this means !xfs_isilocked would give false positives, so don't do that.
799 if ((lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) ==
801 if (!ip->i_lock.mr_writer)
805 if ((lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) ==
807 if (!ip->i_iolock.mr_writer)
815 #ifdef XFS_INODE_TRACE
817 #define KTRACE_ENTER(ip, vk, s, line, ra) \
818 ktrace_enter((ip)->i_trace, \
819 /* 0 */ (void *)(__psint_t)(vk), \
820 /* 1 */ (void *)(s), \
821 /* 2 */ (void *)(__psint_t) line, \
822 /* 3 */ (void *)(__psint_t)atomic_read(&VFS_I(ip)->i_count), \
823 /* 4 */ (void *)(ra), \
825 /* 6 */ (void *)(__psint_t)current_cpu(), \
826 /* 7 */ (void *)(__psint_t)current_pid(), \
827 /* 8 */ (void *)__return_address, \
828 /* 9 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL)
831 * Vnode tracing code.
834 _xfs_itrace_entry(xfs_inode_t *ip, const char *func, inst_t *ra)
836 KTRACE_ENTER(ip, INODE_KTRACE_ENTRY, func, 0, ra);
840 _xfs_itrace_exit(xfs_inode_t *ip, const char *func, inst_t *ra)
842 KTRACE_ENTER(ip, INODE_KTRACE_EXIT, func, 0, ra);
846 xfs_itrace_hold(xfs_inode_t *ip, char *file, int line, inst_t *ra)
848 KTRACE_ENTER(ip, INODE_KTRACE_HOLD, file, line, ra);
852 _xfs_itrace_ref(xfs_inode_t *ip, char *file, int line, inst_t *ra)
854 KTRACE_ENTER(ip, INODE_KTRACE_REF, file, line, ra);
858 xfs_itrace_rele(xfs_inode_t *ip, char *file, int line, inst_t *ra)
860 KTRACE_ENTER(ip, INODE_KTRACE_RELE, file, line, ra);
862 #endif /* XFS_INODE_TRACE */