bcachefs: rename bch_extent_rebalance fields to match other opts structs

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index 5ec0fec597f77b42e82258e07933566e4c054cd3..ee0e86f0becda346e770861562c3fc5e4f35949b 100644 (file)
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -1161,11 +1161,11 @@ void bch2_bkey_ptrs_to_text(struct printbuf *out, struct bch_fs *c,
 
                        prt_str(out, "rebalance: target ");
                        if (c)
-                               bch2_target_to_text(out, c, r->target);
+                               bch2_target_to_text(out, c, r->background_target);
                        else
-                               prt_printf(out, "%u", r->target);
+                               prt_printf(out, "%u", r->background_target);
                        prt_str(out, " compression ");
-                       bch2_compression_opt_to_text(out, r->compression);
+                       bch2_compression_opt_to_text(out, r->background_compression);
                        break;
                }
                default:
@@ -1453,8 +1453,8 @@ u64 bch2_bkey_sectors_need_rebalance(struct bch_fs *c, struct bkey_s_c k)
        struct extent_ptr_decoded p;
        u64 sectors = 0;
 
-       if (opts->compression) {
-               unsigned compression_type = bch2_compression_opt_to_type(opts->compression);
+       if (opts->background_compression) {
+               unsigned compression_type = bch2_compression_opt_to_type(opts->background_compression);
 
                bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
                        if (p.crc.compression_type == BCH_COMPRESSION_TYPE_incompressible ||
@@ -1468,10 +1468,10 @@ u64 bch2_bkey_sectors_need_rebalance(struct bch_fs *c, struct bkey_s_c k)
                }
        }
 incompressible:
-       if (opts->target &&
-           bch2_target_accepts_data(c, BCH_DATA_user, opts->target)) {
+       if (opts->background_target &&
+           bch2_target_accepts_data(c, BCH_DATA_user, opts->background_target)) {
                bkey_for_each_ptr_decode(k.k, ptrs, p, entry)
-                       if (!p.ptr.cached && !bch2_dev_in_target(c, p.ptr.dev, opts->target))
+                       if (!p.ptr.cached && !bch2_dev_in_target(c, p.ptr.dev, opts->background_target))
                                sectors += p.crc.compressed_size;
        }
 
@@ -1500,14 +1500,14 @@ int bch2_bkey_set_needs_rebalance(struct bch_fs *c, struct bkey_i *_k,
                         * they're referenced by different inodes with different
                         * options:
                         */
-                       if (r->target)
-                               target = r->target;
-                       if (r->compression)
-                               compression = r->compression;
+                       if (r->background_target)
+                               target = r->background_target;
+                       if (r->background_compression)
+                               compression = r->background_compression;
                }
 
-               r->target       = target;
-               r->compression  = compression;
+               r->background_target            = target;
+               r->background_compression       = compression;
        }
 
        needs_rebalance = bch2_bkey_ptrs_need_rebalance(c, k.s_c, target, compression);
@@ -1515,10 +1515,10 @@ int bch2_bkey_set_needs_rebalance(struct bch_fs *c, struct bkey_i *_k,
        if (needs_rebalance && !r) {
                union bch_extent_entry *new = bkey_val_end(k);
 
-               new->rebalance.type             = 1U << BCH_EXTENT_ENTRY_rebalance;
-               new->rebalance.compression      = compression;
-               new->rebalance.target           = target;
-               new->rebalance.unused           = 0;
+               new->rebalance.type                     = 1U << BCH_EXTENT_ENTRY_rebalance;
+               new->rebalance.background_compression   = compression;
+               new->rebalance.background_target        = target;
+               new->rebalance.unused                   = 0;
                k.k->u64s += extent_entry_u64s(new);
        } else if (!needs_rebalance && r && k.k->type != KEY_TYPE_reflink_v) {
                /*

diff --git a/fs/bcachefs/extents_format.h b/fs/bcachefs/extents_format.h
index 3bd2fdbb08174c395d2f80b94fef388e784c2ab0..2cc3e60f3b127233270237c22f405e768da50d43 100644 (file)
--- a/fs/bcachefs/extents_format.h
+++ b/fs/bcachefs/extents_format.h
@@ -205,11 +205,11 @@ struct bch_extent_rebalance {
 #if defined(__LITTLE_ENDIAN_BITFIELD)
        __u64                   type:6,
                                unused:34,
-                               compression:8, /* enum bch_compression_opt */
-                               target:16;
+                               background_compression:8, /* enum bch_compression_opt */
+                               background_target:16;
 #elif defined (__BIG_ENDIAN_BITFIELD)
-       __u64                   target:16,
-                               compression:8,
+       __u64                   background_target:16,
+                               background_compression:8,
                                unused:34,
                                type:6;
 #endif

diff --git a/fs/bcachefs/rebalance.c b/fs/bcachefs/rebalance.c
index 2f93ae8781bb04922820ca71ce0e18417464d0d6..dc70e6feaf79b29d88f074813df3cddac9aca22f 100644 (file)
--- a/fs/bcachefs/rebalance.c
+++ b/fs/bcachefs/rebalance.c
@@ -157,8 +157,8 @@ static struct bkey_s_c next_rebalance_extent(struct btree_trans *trans,
        memset(data_opts, 0, sizeof(*data_opts));
 
        data_opts->rewrite_ptrs         =
-               bch2_bkey_ptrs_need_rebalance(c, k, r->target, r->compression);
-       data_opts->target               = r->target;
+               bch2_bkey_ptrs_need_rebalance(c, k, r->background_target, r->background_compression);
+       data_opts->target               = r->background_target;
        data_opts->write_flags          |= BCH_WRITE_ONLY_SPECIFIED_DEVS;
 
        if (!data_opts->rewrite_ptrs) {
@@ -179,9 +179,9 @@ static struct bkey_s_c next_rebalance_extent(struct btree_trans *trans,
                struct printbuf buf = PRINTBUF;
 
                prt_str(&buf, "target=");
-               bch2_target_to_text(&buf, c, r->target);
+               bch2_target_to_text(&buf, c, r->background_target);
                prt_str(&buf, " compression=");
-               bch2_compression_opt_to_text(&buf, r->compression);
+               bch2_compression_opt_to_text(&buf, r->background_compression);
                prt_str(&buf, " ");
                bch2_bkey_val_to_text(&buf, c, k);
 
@@ -261,8 +261,8 @@ static bool rebalance_pred(struct bch_fs *c, void *arg,
        } else {
                const struct bch_extent_rebalance *r = bch2_bkey_rebalance_opts(k);
 
-               target          = r ? r->target : io_opts->background_target;
-               compression     = r ? r->compression : io_opts->background_compression;
+               target          = r ? r->background_target : io_opts->background_target;
+               compression     = r ? r->background_compression : io_opts->background_compression;
        }
 
        data_opts->rewrite_ptrs         = bch2_bkey_ptrs_need_rebalance(c, k, target, compression);