xfs: Replace xfs_isilocked with xfs_assert_ilocked

To use the new rwsem_assert_held()/rwsem_assert_held_write(), we can't
use the existing ASSERT macro.  Add a new xfs_assert_ilocked() and
convert all the callers.

Fix an apparent bug in xfs_isilocked(): If the caller specifies
XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL, xfs_assert_ilocked() will check both
the IOLOCK and the ILOCK are held for write.  xfs_isilocked() only
checked that the ILOCK was held for write.

xfs_assert_ilocked() is always on, even if DEBUG or XFS_WARN aren't
defined.  It's a cheap check, so I don't think it's worth defining
it away.

Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>

diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 82ab559f1da18212eddbd36ad838d808a86db391..673a4b6d2e8d1e8fb7f1beb6c680dff55d99f3cd 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -224,7 +224,7 @@ int
 xfs_attr_get_ilocked(
        struct xfs_da_args      *args)
 {
-       ASSERT(xfs_isilocked(args->dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(args->dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        if (!xfs_inode_hasattr(args->dp))
                return -ENOATTR;

diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index d440393b40eb8e738856956f55f6bca41ce8e3a5..1c007ebf153ab163a5e8de4e698482482ac78b72 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -545,7 +545,7 @@ xfs_attr_rmtval_stale(
        struct xfs_buf          *bp;
        int                     error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        if (XFS_IS_CORRUPT(mp, map->br_startblock == DELAYSTARTBLOCK) ||
            XFS_IS_CORRUPT(mp, map->br_startblock == HOLESTARTBLOCK))

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index b525524a2da4ef1cf116418f33498d0740093ec1..68ab22a2a4530a73b8f56a396e7a0afad8d359f8 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -1189,7 +1189,7 @@ xfs_iread_extents(
        if (!xfs_need_iread_extents(ifp))
                return 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        ir.loaded = 0;
        xfs_iext_first(ifp, &ir.icur);
@@ -3898,7 +3898,7 @@ xfs_bmapi_read(
 
        ASSERT(*nmap >= 1);
        ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_ENTIRE)));
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        if (WARN_ON_ONCE(!ifp))
                return -EFSCORRUPTED;
@@ -4369,7 +4369,7 @@ xfs_bmapi_write(
        ASSERT(tp != NULL);
        ASSERT(len > 0);
        ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(!(flags & XFS_BMAPI_REMAP));
 
        /* zeroing is for currently only for data extents, not metadata */
@@ -4666,7 +4666,7 @@ xfs_bmapi_remap(
        ifp = xfs_ifork_ptr(ip, whichfork);
        ASSERT(len > 0);
        ASSERT(len <= (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
                           XFS_BMAPI_NORMAP)));
        ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
@@ -5291,7 +5291,7 @@ __xfs_bunmapi(
        if (xfs_is_shutdown(mp))
                return -EIO;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(len > 0);
        ASSERT(nexts >= 0);
 
@@ -5635,8 +5635,7 @@ xfs_bmse_merge(
 
        blockcount = left->br_blockcount + got->br_blockcount;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
        ASSERT(xfs_bmse_can_merge(left, got, shift));
 
        new = *left;
@@ -5764,7 +5763,7 @@ xfs_bmap_collapse_extents(
        if (xfs_is_shutdown(mp))
                return -EIO;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
 
        error = xfs_iread_extents(tp, ip, whichfork);
        if (error)
@@ -5837,7 +5836,7 @@ xfs_bmap_can_insert_extents(
        int                     is_empty;
        int                     error = 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
 
        if (xfs_is_shutdown(ip->i_mount))
                return -EIO;
@@ -5879,7 +5878,7 @@ xfs_bmap_insert_extents(
        if (xfs_is_shutdown(mp))
                return -EIO;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
 
        error = xfs_iread_extents(tp, ip, whichfork);
        if (error)
@@ -6257,7 +6256,7 @@ xfs_bunmapi_range(
        xfs_filblks_t           unmap_len = endoff - startoff + 1;
        int                     error = 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        while (unmap_len > 0) {
                ASSERT((*tpp)->t_highest_agno == NULLAGNUMBER);

diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
index 6ed3a5fda081e0cb89482baa526e2b4c93378607..c13276095cc0e3bfb5c72f3151ad4bf10de0070d 100644 (file)
--- a/fs/xfs/libxfs/xfs_defer.c
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -1006,7 +1006,7 @@ xfs_defer_ops_capture(
         * transaction.
         */
        for (i = 0; i < dfc->dfc_held.dr_inos; i++) {
-               ASSERT(xfs_isilocked(dfc->dfc_held.dr_ip[i], XFS_ILOCK_EXCL));
+               xfs_assert_ilocked(dfc->dfc_held.dr_ip[i], XFS_ILOCK_EXCL);
                ihold(VFS_I(dfc->dfc_held.dr_ip[i]));
        }
 

diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index 136d5d7b9de98c33a31ed7f8258ba536c0398368..60758f75182bd70622eb5bca81010b3fb6083c18 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -565,7 +565,7 @@ xfs_iextents_copy(
        struct xfs_bmbt_irec    rec;
        int64_t                 copied = 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
        ASSERT(ifp->if_bytes > 0);
 
        for_each_xfs_iext(ifp, &icur, &rec) {

diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index e31663cb7b4349e173c2b19ac33eb6b10cd59a33..1f6e05fc359b70c6ebdbeded7f560bc7b77d8c3b 100644 (file)
--- a/fs/xfs/libxfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
@@ -934,7 +934,7 @@ xfs_rtfree_extent(
        struct timespec64       atime;
 
        ASSERT(mp->m_rbmip->i_itemp != NULL);
-       ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(mp->m_rbmip, XFS_ILOCK_EXCL);
 
        error = xfs_rtcheck_alloc_range(&args, start, len);
        if (error)

diff --git a/fs/xfs/libxfs/xfs_trans_inode.c b/fs/xfs/libxfs/xfs_trans_inode.c
index 70e97ea6eee7cd3b3858eea1bc9f373058bb65d7..69fc5b981352b86ad29284918ca9d4b90f8d4855 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_inode.c
+++ b/fs/xfs/libxfs/xfs_trans_inode.c
@@ -31,7 +31,7 @@ xfs_trans_ijoin(
 {
        struct xfs_inode_log_item *iip;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        if (ip->i_itemp == NULL)
                xfs_inode_item_init(ip, ip->i_mount);
        iip = ip->i_itemp;
@@ -60,7 +60,7 @@ xfs_trans_ichgtime(
        struct timespec64       tv;
 
        ASSERT(tp);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        tv = current_time(inode);
 
@@ -90,7 +90,7 @@ xfs_trans_log_inode(
        struct inode            *inode = VFS_I(ip);
 
        ASSERT(iip);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(!xfs_iflags_test(ip, XFS_ISTALE));
 
        tp->t_flags |= XFS_TRANS_DIRTY;

diff --git a/fs/xfs/scrub/readdir.c b/fs/xfs/scrub/readdir.c
index 16462332c897b17a90ecd8167ab3a02708fa0ab0..dfdcb96b6c169b3cb50ba2c388034346112a5e93 100644 (file)
--- a/fs/xfs/scrub/readdir.c
+++ b/fs/xfs/scrub/readdir.c
@@ -281,7 +281,7 @@ xchk_dir_walk(
                return -EIO;
 
        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
-       ASSERT(xfs_isilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL)
                return xchk_dir_walk_sf(sc, dp, dirent_fn, priv);
@@ -332,7 +332,7 @@ xchk_dir_lookup(
                return -EIO;
 
        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
-       ASSERT(xfs_isilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
                error = xfs_dir2_sf_lookup(&args);

diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index 47453510c0ab4a3a893b8e6f67bee5260f61e791..56021403f44774ba4850701310e99f31e9707ea5 100644 (file)
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -504,7 +504,7 @@ xfs_attr_list_ilocked(
 {
        struct xfs_inode                *dp = context->dp;
 
-       ASSERT(xfs_isilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        /*
         * Decide on what work routines to call based on the inode size.

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index cb2a4b940292834272491cacaaf5a8c982f64f82..2fe306fd71fcb46f2b61b05dadcf7b60d97a18ad 100644 (file)
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -508,8 +508,8 @@ xfs_can_free_eofblocks(
         * Caller must either hold the exclusive io lock; or be inactivating
         * the inode, which guarantees there are no other users of the inode.
         */
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL) ||
-              (VFS_I(ip)->i_state & I_FREEING));
+       if (!(VFS_I(ip)->i_state & I_FREEING))
+               xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
 
        /* prealloc/delalloc exists only on regular files */
        if (!S_ISREG(VFS_I(ip)->i_mode))
@@ -965,8 +965,7 @@ xfs_collapse_file_space(
        xfs_fileoff_t           shift_fsb = XFS_B_TO_FSB(mp, len);
        bool                    done = false;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
-       ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
 
        trace_xfs_collapse_file_space(ip);
 
@@ -1035,8 +1034,7 @@ xfs_insert_file_space(
        xfs_fileoff_t           shift_fsb = XFS_B_TO_FSB(mp, len);
        bool                    done = false;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
-       ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
 
        trace_xfs_insert_file_space(ip);
 

diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index cc6dc56f455d0c74ab02ef891469bc4db634d331..e82dd5d65cdee9a7fc488c0ce8ab8ad4537070c6 100644 (file)
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -522,7 +522,7 @@ xfs_readdir(
                return -EIO;
 
        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
-       ASSERT(xfs_isilocked(dp, XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
+       xfs_assert_ilocked(dp, XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL);
        XFS_STATS_INC(dp->i_mount, xs_dir_getdents);
 
        args.dp = dp;

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index e38fe4c8f25b971a8dfcc52d26124c1ccf7abd02..308b5f33b712e5a3a4ca56537a763b6b61ccf249 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -950,7 +950,7 @@ xfs_qm_dqget_inode(
        if (error)
                return error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(xfs_inode_dquot(ip, type) == NULL);
 
        id = xfs_qm_id_for_quotatype(ip, type);
@@ -1007,7 +1007,7 @@ restart:
        }
 
 dqret:
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        trace_xfs_dqget_miss(dqp);
        *O_dqpp = dqp;
        return 0;

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index e33e5e13b95f462ffe33c232739af6c4762758a0..632653e00906fa32e2b5a8c70451522952a8660a 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -879,7 +879,7 @@ xfs_break_dax_layouts(
 {
        struct page             *page;
 
-       ASSERT(xfs_isilocked(XFS_I(inode), XFS_MMAPLOCK_EXCL));
+       xfs_assert_ilocked(XFS_I(inode), XFS_MMAPLOCK_EXCL);
 
        page = dax_layout_busy_page(inode->i_mapping);
        if (!page)
@@ -900,7 +900,7 @@ xfs_break_layouts(
        bool                    retry;
        int                     error;
 
-       ASSERT(xfs_isilocked(XFS_I(inode), XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL));
+       xfs_assert_ilocked(XFS_I(inode), XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL);
 
        do {
                retry = false;

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 37ec247edc133253c9d15a291f0f7e633f20e898..634df4f8484da5242e1021062c30e63576168be9 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -328,52 +328,26 @@ xfs_ilock_demote(
        trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
 }
 
-#if defined(DEBUG) || defined(XFS_WARN)
-static inline bool
-__xfs_rwsem_islocked(
-       struct rw_semaphore     *rwsem,
-       bool                    shared)
-{
-       if (!debug_locks)
-               return rwsem_is_locked(rwsem);
-
-       if (!shared)
-               return lockdep_is_held_type(rwsem, 0);
-
-       /*
-        * We are checking that the lock is held at least in shared
-        * mode but don't care that it might be held exclusively
-        * (i.e. shared | excl). Hence we check if the lock is held
-        * in any mode rather than an explicit shared mode.
-        */
-       return lockdep_is_held_type(rwsem, -1);
-}
-
-bool
-xfs_isilocked(
+void
+xfs_assert_ilocked(
        struct xfs_inode        *ip,
        uint                    lock_flags)
 {
-       if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
-               if (!(lock_flags & XFS_ILOCK_SHARED))
-                       return !!ip->i_lock.mr_writer;
-               return rwsem_is_locked(&ip->i_lock.mr_lock);
-       }
+       if (lock_flags & XFS_ILOCK_SHARED)
+               rwsem_assert_held(&ip->i_lock.mr_lock);
+       else if (lock_flags & XFS_ILOCK_EXCL)
+               ASSERT(ip->i_lock.mr_writer);
 
-       if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
-               return __xfs_rwsem_islocked(&VFS_I(ip)->i_mapping->invalidate_lock,
-                               (lock_flags & XFS_MMAPLOCK_SHARED));
-       }
+       if (lock_flags & XFS_MMAPLOCK_SHARED)
+               rwsem_assert_held(&VFS_I(ip)->i_mapping->invalidate_lock);
+       else if (lock_flags & XFS_MMAPLOCK_EXCL)
+               rwsem_assert_held_write(&VFS_I(ip)->i_mapping->invalidate_lock);
 
-       if (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) {
-               return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem,
-                               (lock_flags & XFS_IOLOCK_SHARED));
-       }
-
-       ASSERT(0);
-       return false;
+       if (lock_flags & XFS_IOLOCK_SHARED)
+               rwsem_assert_held(&VFS_I(ip)->i_rwsem);
+       else if (lock_flags & XFS_IOLOCK_EXCL)
+               rwsem_assert_held_write(&VFS_I(ip)->i_rwsem);
 }
-#endif
 
 /*
  * xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
@@ -1342,9 +1316,9 @@ xfs_itruncate_extents_flags(
        xfs_fileoff_t           first_unmap_block;
        int                     error = 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-       ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
-              xfs_isilocked(ip, XFS_IOLOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
+       if (atomic_read(&VFS_I(ip)->i_count))
+               xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
        ASSERT(new_size <= XFS_ISIZE(ip));
        ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
        ASSERT(ip->i_itemp != NULL);
@@ -1596,7 +1570,7 @@ xfs_inactive_ifree(
        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
        error = xfs_ifree(tp, ip);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        if (error) {
                /*
                 * If we fail to free the inode, shut down.  The cancel
@@ -2350,7 +2324,7 @@ xfs_ifree(
        struct xfs_inode_log_item *iip = ip->i_itemp;
        int                     error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(VFS_I(ip)->i_nlink == 0);
        ASSERT(ip->i_df.if_nextents == 0);
        ASSERT(ip->i_disk_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
@@ -2419,7 +2393,7 @@ static void
 xfs_iunpin(
        struct xfs_inode        *ip)
 {
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
 
        trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
 
@@ -3182,7 +3156,7 @@ xfs_iflush(
        struct xfs_mount        *mp = ip->i_mount;
        int                     error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED);
        ASSERT(xfs_iflags_test(ip, XFS_IFLUSHING));
        ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_BTREE ||
               ip->i_df.if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));

diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 97f63bacd4c2be08c1b5c98535edc914fe2e2fbe..dcc818901a79a09a8834a6402b15cd0975820a99 100644 (file)
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -523,7 +523,7 @@ void                xfs_ilock(xfs_inode_t *, uint);
 int            xfs_ilock_nowait(xfs_inode_t *, uint);
 void           xfs_iunlock(xfs_inode_t *, uint);
 void           xfs_ilock_demote(xfs_inode_t *, uint);
-bool           xfs_isilocked(struct xfs_inode *, uint);
+void           xfs_assert_ilocked(struct xfs_inode *, uint);
 uint           xfs_ilock_data_map_shared(struct xfs_inode *);
 uint           xfs_ilock_attr_map_shared(struct xfs_inode *);
 

diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index bfbeafc8e12063391f85cfe0ff3ca9b103795b2a..f28d653300d1240971af650686ed9066ad43f785 100644 (file)
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -650,7 +650,7 @@ xfs_inode_item_pin(
 {
        struct xfs_inode        *ip = INODE_ITEM(lip)->ili_inode;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(lip->li_buf);
 
        trace_xfs_inode_pin(ip, _RET_IP_);
@@ -756,7 +756,7 @@ xfs_inode_item_release(
        unsigned short          lock_flags;
 
        ASSERT(ip->i_itemp != NULL);
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        lock_flags = iip->ili_lock_flags;
        iip->ili_lock_flags = 0;

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index be102fd49560dc7c121d732122597eb586c56ef6..12510d20813b33633873535e0f0aa473e9c00c08 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -796,8 +796,7 @@ xfs_setattr_size(
        uint                    lock_flags = 0;
        bool                    did_zeroing = false;
 
-       ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
-       ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
        ASSERT(S_ISREG(inode->i_mode));
        ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
                ATTR_MTIME_SET|ATTR_TIMES_SET)) == 0);

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 5bcd67cae16a49b192b1dece5f6f3bee902acab8..b5b555698ae1e6544224d4057c454006adf04c35 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -254,7 +254,7 @@ xfs_qm_dqattach_one(
        struct xfs_dquot        *dqp;
        int                     error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        error = 0;
 
        /*
@@ -322,7 +322,7 @@ xfs_qm_dqattach_locked(
        if (!xfs_qm_need_dqattach(ip))
                return 0;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
                error = xfs_qm_dqattach_one(ip, XFS_DQTYPE_USER,
@@ -353,7 +353,7 @@ done:
         * Don't worry about the dquots that we may have attached before any
         * error - they'll get detached later if it has not already been done.
         */
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        return error;
 }
 
@@ -1811,7 +1811,7 @@ xfs_qm_vop_chown(
                                 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
 
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        ASSERT(XFS_IS_QUOTA_ON(ip->i_mount));
 
        /* old dquot */
@@ -1899,7 +1899,7 @@ xfs_qm_vop_create_dqattach(
        if (!XFS_IS_QUOTA_ON(mp))
                return;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        if (udqp && XFS_IS_UQUOTA_ON(mp)) {
                ASSERT(ip->i_udquot == NULL);

diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index d5ca8bcae65b6c9d38ef487e3c370deff3bd5a7c..e64ef2a293b69beff953337db549fb81ad90fe2e 100644 (file)
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -527,7 +527,7 @@ xfs_reflink_allocate_cow(
        int                     error;
        bool                    found;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
        if (!ip->i_cowfp) {
                ASSERT(!xfs_is_reflink_inode(ip));
                xfs_ifork_init_cow(ip);

diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 2f85567f3d756b3fd824372d8337354176907351..b62b5c34413e7a084bc835e24080be9988fbef5e 100644 (file)
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -1260,7 +1260,7 @@ xfs_rtpick_extent(
        uint64_t                seq;            /* sequence number of file creation */
        struct timespec64       ts;             /* timespec in inode */
 
-       ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(mp->m_rbmip, XFS_ILOCK_EXCL);
 
        ts = inode_get_atime(VFS_I(mp->m_rbmip));
        if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM)) {

diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 92974a4414c832a8e0c358608182129bf59652e2..c2dc8c501bdc53e86296c6d00a5cbedc10be10f5 100644 (file)
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -44,7 +44,7 @@ xfs_readlink_bmap_ilocked(
        int                     fsblocks = 0;
        int                     offset;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
 
        fsblocks = xfs_symlink_blocks(mp, pathlen);
        error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);

diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 12d45e93f07d50369aeb83e20d2cb6b5eb4da007..7350640059cc60dc093d69e23646089cb7a17f98 100644 (file)
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -1273,7 +1273,7 @@ xfs_trans_reserve_more_inode(
        unsigned int            rtx = xfs_extlen_to_rtxlen(mp, rblocks);
        int                     error;
 
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        error = xfs_trans_reserve(tp, &resv, dblocks, rtx);
        if (error)

diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index aa00cf67ad72a909f0cf81901f8719ab8b2367b6..9c159d016ecf544fe0be1b28ba6cb1d4e5d6dbdc 100644 (file)
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -796,7 +796,7 @@ xfs_trans_reserve_quota_nblks(
                return 0;
 
        ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
-       ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
+       xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 
        if (force)
                qflags |= XFS_QMOPT_FORCE_RES;