new inode method: ->free_inode()

A lot of ->destroy_inode() instances end with call_rcu() of a callback
that does RCU-delayed part of freeing.  Introduce a new method for
doing just that, with saner signature.

Rules:
->destroy_inode		->free_inode
	f			g		immediate call of f(),
						RCU-delayed call of g()
	f			NULL		immediate call of f(),
						no RCU-delayed calls
	NULL			g		RCU-delayed call of g()
	NULL			NULL		RCU-delayed default freeing

IOW, NULL ->free_inode gives the same behaviour as now.

Note that NULL, NULL is equivalent to NULL, free_inode_nonrcu; we could
mandate the latter form, but that would have very little benefit beyond
making rules a bit more symmetric.  It would break backwards compatibility,
require extra boilerplate and expected semantics for (NULL, NULL) pair
would have no use whatsoever...

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 34 insertions, 22 deletions

diff --git a/fs/inode.c b/fs/inode.c
index e9d97add2b36..627e1766503a 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -202,12 +202,28 @@ out:
 }
 EXPORT_SYMBOL(inode_init_always);
 
+void free_inode_nonrcu(struct inode *inode)
+{
+        kmem_cache_free(inode_cachep, inode);
+}
+EXPORT_SYMBOL(free_inode_nonrcu);
+
+static void i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        if (inode->free_inode)
+                inode->free_inode(inode);
+        else
+                free_inode_nonrcu(inode);
+}
+
 static struct inode *alloc_inode(struct super_block *sb)
 {
+        const struct super_operations *ops = sb->s_op;
         struct inode *inode;
 
-        if (sb->s_op->alloc_inode)
-                inode = sb->s_op->alloc_inode(sb);
+        if (ops->alloc_inode)
+                inode = ops->alloc_inode(sb);
         else
                 inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);
 
@@ -215,22 +231,19 @@ static struct inode *alloc_inode(struct super_block *sb)
                 return NULL;
 
         if (unlikely(inode_init_always(sb, inode))) {
-                if (inode->i_sb->s_op->destroy_inode)
-                        inode->i_sb->s_op->destroy_inode(inode);
-                else
-                        kmem_cache_free(inode_cachep, inode);
+                if (ops->destroy_inode) {
+                        ops->destroy_inode(inode);
+                        if (!ops->free_inode)
+                                return NULL;
+                }
+                inode->free_inode = ops->free_inode;
+                i_callback(&inode->i_rcu);
                 return NULL;
         }
 
         return inode;
 }
 
-void free_inode_nonrcu(struct inode *inode)
-{
-        kmem_cache_free(inode_cachep, inode);
-}
-EXPORT_SYMBOL(free_inode_nonrcu);
-
 void __destroy_inode(struct inode *inode)
 {
         BUG_ON(inode_has_buffers(inode));
@@ -253,20 +266,19 @@ void __destroy_inode(struct inode *inode)
 }
 EXPORT_SYMBOL(__destroy_inode);
 
-static void i_callback(struct rcu_head *head)
-{
-        struct inode *inode = container_of(head, struct inode, i_rcu);
-        kmem_cache_free(inode_cachep, inode);
-}
-
 static void destroy_inode(struct inode *inode)
 {
+        const struct super_operations *ops = inode->i_sb->s_op;
+
         BUG_ON(!list_empty(&inode->i_lru));
         __destroy_inode(inode);
-        if (inode->i_sb->s_op->destroy_inode)
-                inode->i_sb->s_op->destroy_inode(inode);
-        else
-                call_rcu(&inode->i_rcu, i_callback);
+        if (ops->destroy_inode) {
+                ops->destroy_inode(inode);
+                if (!ops->free_inode)
+                        return;
+        }
+        inode->free_inode = ops->free_inode;
+        call_rcu(&inode->i_rcu, i_callback);
 }
 
 /**