btrfs: turn the backref sharedness check cache into a context object

[linux-block.git] / fs / btrfs / backref.c

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index efdeb69e8ed6471a8a58f2fbb782c97c7ccc4093..693c99ad4afb315a0f1a4c4a51cf112de3f6ce41 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -1542,13 +1542,13 @@ int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
  * fs_info->commit_root_sem semaphore, so no need to worry about the root's last
  * snapshot field changing while updating or checking the cache.
  */
-static bool lookup_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
+static bool lookup_backref_shared_cache(struct btrfs_backref_share_check_ctx *ctx,
                                        struct btrfs_root *root,
                                        u64 bytenr, int level, bool *is_shared)
 {
        struct btrfs_backref_shared_cache_entry *entry;
 
-       if (!cache->use_cache)
+       if (!ctx->use_path_cache)
                return false;
 
        if (WARN_ON_ONCE(level >= BTRFS_MAX_LEVEL))
@@ -1562,7 +1562,7 @@ static bool lookup_backref_shared_cache(struct btrfs_backref_shared_cache *cache
         */
        ASSERT(level >= 0);
 
-       entry = &cache->entries[level];
+       entry = &ctx->path_cache_entries[level];
 
        /* Unused cache entry or being used for some other extent buffer. */
        if (entry->bytenr != bytenr)
@@ -1595,8 +1595,8 @@ static bool lookup_backref_shared_cache(struct btrfs_backref_shared_cache *cache
         */
        if (*is_shared) {
                for (int i = 0; i < level; i++) {
-                       cache->entries[i].is_shared = true;
-                       cache->entries[i].gen = entry->gen;
+                       ctx->path_cache_entries[i].is_shared = true;
+                       ctx->path_cache_entries[i].gen = entry->gen;
                }
        }
 
@@ -1608,14 +1608,14 @@ static bool lookup_backref_shared_cache(struct btrfs_backref_shared_cache *cache
  * fs_info->commit_root_sem semaphore, so no need to worry about the root's last
  * snapshot field changing while updating or checking the cache.
  */
-static void store_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
+static void store_backref_shared_cache(struct btrfs_backref_share_check_ctx *ctx,
                                       struct btrfs_root *root,
                                       u64 bytenr, int level, bool is_shared)
 {
        struct btrfs_backref_shared_cache_entry *entry;
        u64 gen;
 
-       if (!cache->use_cache)
+       if (!ctx->use_path_cache)
                return;
 
        if (WARN_ON_ONCE(level >= BTRFS_MAX_LEVEL))
@@ -1634,7 +1634,7 @@ static void store_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
        else
                gen = btrfs_root_last_snapshot(&root->root_item);
 
-       entry = &cache->entries[level];
+       entry = &ctx->path_cache_entries[level];
        entry->bytenr = bytenr;
        entry->is_shared = is_shared;
        entry->gen = gen;
@@ -1648,7 +1648,7 @@ static void store_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
         */
        if (is_shared) {
                for (int i = 0; i < level; i++) {
-                       entry = &cache->entries[i];
+                       entry = &ctx->path_cache_entries[i];
                        entry->is_shared = is_shared;
                        entry->gen = gen;
                }
@@ -1664,7 +1664,7 @@ static void store_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
  *               not known.
  * @roots:       List of roots this extent is shared among.
  * @tmp:         Temporary list used for iteration.
- * @cache:       A backref lookup result cache.
+ * @ctx:         A backref sharedness check context.
  *
  * btrfs_is_data_extent_shared uses the backref walking code but will short
  * circuit as soon as it finds a root or inode that doesn't match the
@@ -1680,7 +1680,7 @@ static void store_backref_shared_cache(struct btrfs_backref_shared_cache *cache,
 int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr,
                                u64 extent_gen,
                                struct ulist *roots, struct ulist *tmp,
-                               struct btrfs_backref_shared_cache *cache)
+                               struct btrfs_backref_share_check_ctx *ctx)
 {
        struct btrfs_root *root = inode->root;
        struct btrfs_fs_info *fs_info = root->fs_info;
@@ -1715,7 +1715,7 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr,
        /* -1 means we are in the bytenr of the data extent. */
        level = -1;
        ULIST_ITER_INIT(&uiter);
-       cache->use_cache = true;
+       ctx->use_path_cache = true;
        while (1) {
                bool is_shared;
                bool cached;
@@ -1726,7 +1726,7 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr,
                        /* this is the only condition under which we return 1 */
                        ret = 1;
                        if (level >= 0)
-                               store_backref_shared_cache(cache, root, bytenr,
+                               store_backref_shared_cache(ctx, root, bytenr,
                                                           level, true);
                        break;
                }
@@ -1761,17 +1761,17 @@ int btrfs_is_data_extent_shared(struct btrfs_inode *inode, u64 bytenr,
                 * (which implies multiple paths).
                 */
                if (level == -1 && tmp->nnodes > 1)
-                       cache->use_cache = false;
+                       ctx->use_path_cache = false;
 
                if (level >= 0)
-                       store_backref_shared_cache(cache, root, bytenr,
+                       store_backref_shared_cache(ctx, root, bytenr,
                                                   level, false);
                node = ulist_next(tmp, &uiter);
                if (!node)
                        break;
                bytenr = node->val;
                level++;
-               cached = lookup_backref_shared_cache(cache, root, bytenr, level,
+               cached = lookup_backref_shared_cache(ctx, root, bytenr, level,
                                                     &is_shared);
                if (cached) {
                        ret = (is_shared ? 1 : 0);