fs: remove inode_lock from iput_final and prune_icache

Now that inode state changes are protected by the inode->i_lock and
the inode LRU manipulations by the inode_lru_lock, we can remove the
inode_lock from prune_icache and the initial part of iput_final().

instead of using the inode_lock to protect the inode during
iput_final, use the inode->i_lock instead. This protects the inode
against new references being taken while we change the inode state
to I_FREEING, as well as preventing prune_icache from grabbing the
inode while we are manipulating it. Hence we no longer need the
inode_lock in iput_final prior to setting I_FREEING on the inode.

For prune_icache, we no longer need the inode_lock to protect the
LRU list, and the inodes themselves are protected against freeing
races by the inode->i_lock. Hence we can lift the inode_lock from
prune_icache as well.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 2e994efe12cbf25905921d5b1d2fbb7f8e3c177a..61b31acb9176b35bc77c914b2b3913abbcc9e78a 100644 (file)
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -128,7 +128,7 @@ alloc_inode:
 destroy_inode:
 dirty_inode:                           (must not sleep)
 write_inode:
-drop_inode:                            !!!inode_lock!!!
+drop_inode:                            !!!inode->i_lock!!!
 evict_inode:
 put_super:             write
 write_super:           read

diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting
index 0c986c9e8519ad32d455b1818436c61aab8434c6..6e29954851a243427d20fe07dd83970569180338 100644 (file)
--- a/Documentation/filesystems/porting
+++ b/Documentation/filesystems/porting
@@ -298,11 +298,14 @@ be used instead.  It gets called whenever the inode is evicted, whether it has
 remaining links or not.  Caller does *not* evict the pagecache or inode-associated
 metadata buffers; getting rid of those is responsibility of method, as it had
 been for ->delete_inode().
-       ->drop_inode() returns int now; it's called on final iput() with inode_lock
-held and it returns true if filesystems wants the inode to be dropped.  As before,
-generic_drop_inode() is still the default and it's been updated appropriately.
-generic_delete_inode() is also alive and it consists simply of return 1.  Note that
-all actual eviction work is done by caller after ->drop_inode() returns.
+
+       ->drop_inode() returns int now; it's called on final iput() with
+inode->i_lock held and it returns true if filesystems wants the inode to be
+dropped.  As before, generic_drop_inode() is still the default and it's been
+updated appropriately.  generic_delete_inode() is also alive and it consists
+simply of return 1.  Note that all actual eviction work is done by caller after
+->drop_inode() returns.
+
        clear_inode() is gone; use end_writeback() instead.  As before, it must
 be called exactly once on each call of ->evict_inode() (as it used to be for
 each call of ->delete_inode()).  Unlike before, if you are using inode-associated
@@ -395,6 +398,9 @@ Currently you can only have FALLOC_FL_PUNCH_HOLE with FALLOC_FL_KEEP_SIZE set,
 so the i_size should not change when hole punching, even when puching the end of
 a file off.
 
+--
+[mandatory]
+
 --
 [mandatory]
        ->get_sb() is gone.  Switch to use of ->mount().  Typically it's just

diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 306f0ae8df094c14cd6825aaf27e5448efa04b24..80815ed654cb499a1b5fc7683c016438bf8886f5 100644 (file)
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -254,7 +254,7 @@ or bottom half).
        should be synchronous or not, not all filesystems check this flag.
 
   drop_inode: called when the last access to the inode is dropped,
-       with the inode_lock spinlock held.
+       with the inode->i_lock spinlock held.
 
        This method should be either NULL (normal UNIX filesystem
        semantics) or "generic_delete_inode" (for filesystems that do not

diff --git a/fs/inode.c b/fs/inode.c
index b19cb6ee6ca31c7dfa23cf223e27aa6ceec2f395..389f5a247599ee36ef633ca4f4afaa9efe5a5d65 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -650,7 +650,6 @@ static void prune_icache(int nr_to_scan)
        unsigned long reap = 0;
 
        down_read(&iprune_sem);
-       spin_lock(&inode_lock);
        spin_lock(&inode_lru_lock);
        for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
                struct inode *inode;
@@ -676,8 +675,8 @@ static void prune_icache(int nr_to_scan)
                 */
                if (atomic_read(&inode->i_count) ||
                    (inode->i_state & ~I_REFERENCED)) {
-                       spin_unlock(&inode->i_lock);
                        list_del_init(&inode->i_lru);
+                       spin_unlock(&inode->i_lock);
                        inodes_stat.nr_unused--;
                        continue;
                }
@@ -685,20 +684,18 @@ static void prune_icache(int nr_to_scan)
                /* recently referenced inodes get one more pass */
                if (inode->i_state & I_REFERENCED) {
                        inode->i_state &= ~I_REFERENCED;
-                       spin_unlock(&inode->i_lock);
                        list_move(&inode->i_lru, &inode_lru);
+                       spin_unlock(&inode->i_lock);
                        continue;
                }
                if (inode_has_buffers(inode) || inode->i_data.nrpages) {
                        __iget(inode);
                        spin_unlock(&inode->i_lock);
                        spin_unlock(&inode_lru_lock);
-                       spin_unlock(&inode_lock);
                        if (remove_inode_buffers(inode))
                                reap += invalidate_mapping_pages(&inode->i_data,
                                                                0, -1);
                        iput(inode);
-                       spin_lock(&inode_lock);
                        spin_lock(&inode_lru_lock);
 
                        if (inode != list_entry(inode_lru.next,
@@ -724,7 +721,6 @@ static void prune_icache(int nr_to_scan)
        else
                __count_vm_events(PGINODESTEAL, reap);
        spin_unlock(&inode_lru_lock);
-       spin_unlock(&inode_lock);
 
        dispose_list(&freeable);
        up_read(&iprune_sem);
@@ -1082,7 +1078,6 @@ EXPORT_SYMBOL(iunique);
 
 struct inode *igrab(struct inode *inode)
 {
-       spin_lock(&inode_lock);
        spin_lock(&inode->i_lock);
        if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
                __iget(inode);
@@ -1096,7 +1091,6 @@ struct inode *igrab(struct inode *inode)
                 */
                inode = NULL;
        }
-       spin_unlock(&inode_lock);
        return inode;
 }
 EXPORT_SYMBOL(igrab);
@@ -1439,7 +1433,6 @@ static void iput_final(struct inode *inode)
        const struct super_operations *op = inode->i_sb->s_op;
        int drop;
 
-       spin_lock(&inode->i_lock);
        WARN_ON(inode->i_state & I_NEW);
 
        if (op && op->drop_inode)
@@ -1452,16 +1445,13 @@ static void iput_final(struct inode *inode)
                if (!(inode->i_state & (I_DIRTY|I_SYNC)))
                        inode_lru_list_add(inode);
                spin_unlock(&inode->i_lock);
-               spin_unlock(&inode_lock);
                return;
        }
 
        if (!drop) {
                inode->i_state |= I_WILL_FREE;
                spin_unlock(&inode->i_lock);
-               spin_unlock(&inode_lock);
                write_inode_now(inode, 1);
-               spin_lock(&inode_lock);
                spin_lock(&inode->i_lock);
                WARN_ON(inode->i_state & I_NEW);
                inode->i_state &= ~I_WILL_FREE;
@@ -1470,7 +1460,6 @@ static void iput_final(struct inode *inode)
        inode->i_state |= I_FREEING;
        inode_lru_list_del(inode);
        spin_unlock(&inode->i_lock);
-       spin_unlock(&inode_lock);
 
        evict(inode);
 }
@@ -1489,7 +1478,7 @@ void iput(struct inode *inode)
        if (inode) {
                BUG_ON(inode->i_state & I_CLEAR);
 
-               if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
+               if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock))
                        iput_final(inode);
        }
 }

diff --git a/fs/logfs/inode.c b/fs/logfs/inode.c
index 03b8c240aeda37ea287b36f8ebaeeae1ee23a479..edfea7a3a747fa2c984a5817d82909fdccc7d0ea 100644 (file)
--- a/fs/logfs/inode.c
+++ b/fs/logfs/inode.c
@@ -293,7 +293,7 @@ static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
        return ret;
 }
 
-/* called with inode_lock held */
+/* called with inode->i_lock held */
 static int logfs_drop_inode(struct inode *inode)
 {
        struct logfs_super *super = logfs_super(inode->i_sb);