btrfs: Unexport and rename btrfs_invalidate_inodes

This function is no longer used outside of inode.c so just make it
static. At the same time give a more becoming name, since it's not
really invalidating the inodes but just calling d_prune_alias. Last,
but not least - move the function above the sole caller to avoid
introducing yet-another-pointless forward declaration.

Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Reviewed-by: Anand Jain <anand.jain@oracle.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 3d6b2dc86c8fe9f07137b221cbc986dc9d3c289b..bfa96697209a158ea850646d9bf0f5c5b238500b 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3231,7 +3231,6 @@ int btrfs_orphan_cleanup(struct btrfs_root *root);
 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root);
 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
-void btrfs_invalidate_inodes(struct btrfs_root *root);
 void btrfs_add_delayed_iput(struct inode *inode);
 void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
 int btrfs_prealloc_file_range(struct inode *inode, int mode,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 563e63fa2fce78a0646a383bb0e205ec818013df..766bd286869d89b3fa2581c247b984091bc76213 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4379,6 +4379,70 @@ out:
        return ret;
 }
 
+/* Delete all dentries for inodes belonging to the root */
+static void btrfs_prune_dentries(struct btrfs_root *root)
+{
+       struct btrfs_fs_info *fs_info = root->fs_info;
+       struct rb_node *node;
+       struct rb_node *prev;
+       struct btrfs_inode *entry;
+       struct inode *inode;
+       u64 objectid = 0;
+
+       if (!test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
+               WARN_ON(btrfs_root_refs(&root->root_item) != 0);
+
+       spin_lock(&root->inode_lock);
+again:
+       node = root->inode_tree.rb_node;
+       prev = NULL;
+       while (node) {
+               prev = node;
+               entry = rb_entry(node, struct btrfs_inode, rb_node);
+
+               if (objectid < btrfs_ino(BTRFS_I(&entry->vfs_inode)))
+                       node = node->rb_left;
+               else if (objectid > btrfs_ino(BTRFS_I(&entry->vfs_inode)))
+                       node = node->rb_right;
+               else
+                       break;
+       }
+       if (!node) {
+               while (prev) {
+                       entry = rb_entry(prev, struct btrfs_inode, rb_node);
+                       if (objectid <= btrfs_ino(BTRFS_I(&entry->vfs_inode))) {
+                               node = prev;
+                               break;
+                       }
+                       prev = rb_next(prev);
+               }
+       }
+       while (node) {
+               entry = rb_entry(node, struct btrfs_inode, rb_node);
+               objectid = btrfs_ino(BTRFS_I(&entry->vfs_inode)) + 1;
+               inode = igrab(&entry->vfs_inode);
+               if (inode) {
+                       spin_unlock(&root->inode_lock);
+                       if (atomic_read(&inode->i_count) > 1)
+                               d_prune_aliases(inode);
+                       /*
+                        * btrfs_drop_inode will have it removed from the inode
+                        * cache when its usage count hits zero.
+                        */
+                       iput(inode);
+                       cond_resched();
+                       spin_lock(&root->inode_lock);
+                       goto again;
+               }
+
+               if (cond_resched_lock(&root->inode_lock))
+                       goto again;
+
+               node = rb_next(node);
+       }
+       spin_unlock(&root->inode_lock);
+}
+
 int btrfs_delete_subvolume(struct inode *dir, struct dentry *dentry)
 {
        struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
@@ -4505,7 +4569,7 @@ out_up_write:
                spin_unlock(&dest->root_item_lock);
        } else {
                d_invalidate(dentry);
-               btrfs_invalidate_inodes(dest);
+               btrfs_prune_dentries(dest);
                ASSERT(dest->send_in_progress == 0);
 
                /* the last ref */
@@ -5818,69 +5882,6 @@ static void inode_tree_del(struct inode *inode)
        }
 }
 
-void btrfs_invalidate_inodes(struct btrfs_root *root)
-{
-       struct btrfs_fs_info *fs_info = root->fs_info;
-       struct rb_node *node;
-       struct rb_node *prev;
-       struct btrfs_inode *entry;
-       struct inode *inode;
-       u64 objectid = 0;
-
-       if (!test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
-               WARN_ON(btrfs_root_refs(&root->root_item) != 0);
-
-       spin_lock(&root->inode_lock);
-again:
-       node = root->inode_tree.rb_node;
-       prev = NULL;
-       while (node) {
-               prev = node;
-               entry = rb_entry(node, struct btrfs_inode, rb_node);
-
-               if (objectid < btrfs_ino(BTRFS_I(&entry->vfs_inode)))
-                       node = node->rb_left;
-               else if (objectid > btrfs_ino(BTRFS_I(&entry->vfs_inode)))
-                       node = node->rb_right;
-               else
-                       break;
-       }
-       if (!node) {
-               while (prev) {
-                       entry = rb_entry(prev, struct btrfs_inode, rb_node);
-                       if (objectid <= btrfs_ino(BTRFS_I(&entry->vfs_inode))) {
-                               node = prev;
-                               break;
-                       }
-                       prev = rb_next(prev);
-               }
-       }
-       while (node) {
-               entry = rb_entry(node, struct btrfs_inode, rb_node);
-               objectid = btrfs_ino(BTRFS_I(&entry->vfs_inode)) + 1;
-               inode = igrab(&entry->vfs_inode);
-               if (inode) {
-                       spin_unlock(&root->inode_lock);
-                       if (atomic_read(&inode->i_count) > 1)
-                               d_prune_aliases(inode);
-                       /*
-                        * btrfs_drop_inode will have it removed from
-                        * the inode cache when its usage count
-                        * hits zero.
-                        */
-                       iput(inode);
-                       cond_resched();
-                       spin_lock(&root->inode_lock);
-                       goto again;
-               }
-
-               if (cond_resched_lock(&root->inode_lock))
-                       goto again;
-
-               node = rb_next(node);
-       }
-       spin_unlock(&root->inode_lock);
-}
 
 static int btrfs_init_locked_inode(struct inode *inode, void *p)
 {