bcachefs: kill bch2_fs_usage_read()

With bch2_ioctl_fs_usage(), this is now dead code.

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

diff --git a/fs/bcachefs/bcachefs.h b/fs/bcachefs/bcachefs.h
index 8ffb683c368ab384dbbd5ada93100d7ec2506257..89ffe38b6bfea47dd791f0a767b83c91b29c71ed 100644 (file)
--- a/fs/bcachefs/bcachefs.h
+++ b/fs/bcachefs/bcachefs.h
@@ -896,10 +896,6 @@ struct bch_fs {
        struct bch_fs_usage __percpu    *usage_gc;
        u64 __percpu            *online_reserved;
 
-       /* single element mempool: */
-       struct mutex            usage_scratch_lock;
-       struct bch_fs_usage_online *usage_scratch;
-
        struct io_clock         io_clock[2];
 
        /* JOURNAL SEQ BLACKLIST */

diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index 2fd7a55f6373be277813af00d27415f122f0bfff..07cdb429991820ba09e78d729dd0131fbfe124f4 100644 (file)
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -64,40 +64,6 @@ u64 bch2_fs_usage_read_one(struct bch_fs *c, u64 *v)
        return ret;
 }
 
-struct bch_fs_usage_online *bch2_fs_usage_read(struct bch_fs *c)
-{
-       struct bch_fs_usage_online *ret;
-       unsigned nr_replicas = READ_ONCE(c->replicas.nr);
-       unsigned seq, i;
-retry:
-       ret = kmalloc(__fs_usage_online_u64s(nr_replicas) * sizeof(u64), GFP_KERNEL);
-       if (unlikely(!ret))
-               return NULL;
-
-       percpu_down_read(&c->mark_lock);
-
-       if (nr_replicas != c->replicas.nr) {
-               nr_replicas = c->replicas.nr;
-               percpu_up_read(&c->mark_lock);
-               kfree(ret);
-               goto retry;
-       }
-
-       ret->online_reserved = percpu_u64_get(c->online_reserved);
-
-       do {
-               seq = read_seqcount_begin(&c->usage_lock);
-               unsafe_memcpy(&ret->u, c->usage_base,
-                             __fs_usage_u64s(nr_replicas) * sizeof(u64),
-                             "embedded variable length struct");
-               for (i = 0; i < ARRAY_SIZE(c->usage); i++)
-                       acc_u64s_percpu((u64 *) &ret->u, (u64 __percpu *) c->usage[i],
-                                       __fs_usage_u64s(nr_replicas));
-       } while (read_seqcount_retry(&c->usage_lock, seq));
-
-       return ret;
-}
-
 void bch2_fs_usage_acc_to_base(struct bch_fs *c, unsigned idx)
 {
        unsigned u64s = fs_usage_u64s(c);

diff --git a/fs/bcachefs/buckets.h b/fs/bcachefs/buckets.h
index dc99df654ac91f354c4de028adfa1efa86827da2..df73a47a41232f3e8dcaf5b5c950850ad6e4086c 100644 (file)
--- a/fs/bcachefs/buckets.h
+++ b/fs/bcachefs/buckets.h
@@ -300,8 +300,6 @@ static inline unsigned dev_usage_u64s(void)
 
 u64 bch2_fs_usage_read_one(struct bch_fs *, u64 *);
 
-struct bch_fs_usage_online *bch2_fs_usage_read(struct bch_fs *);
-
 void bch2_fs_usage_acc_to_base(struct bch_fs *, unsigned);
 
 void bch2_fs_usage_to_text(struct printbuf *,

diff --git a/fs/bcachefs/chardev.c b/fs/bcachefs/chardev.c
index 57bb02996f8ee7f197e0c8908898c6e69fc305a9..0e76e06ab84426a760d14684ea6de6d927a804b7 100644 (file)
--- a/fs/bcachefs/chardev.c
+++ b/fs/bcachefs/chardev.c
@@ -518,9 +518,7 @@ static long bch2_ioctl_fs_usage(struct bch_fs *c,
                                struct bch_ioctl_fs_usage __user *user_arg)
 {
        struct bch_ioctl_fs_usage arg;
-       struct bch_fs_usage_online *src = NULL;
        darray_char replicas = {};
-       unsigned i;
        u32 replica_entries_bytes;
        int ret = 0;
 
@@ -536,25 +534,26 @@ static long bch2_ioctl_fs_usage(struct bch_fs *c,
        if (ret)
                goto err;
 
+       struct bch_fs_usage_short u = bch2_fs_usage_read_short(c);
        arg.capacity            = c->capacity;
-       arg.used                = bch2_fs_sectors_used(c, src);
-       arg.online_reserved     = src->online_reserved;
+       arg.used                = u.used;
+       arg.online_reserved     = percpu_u64_get(c->online_reserved);
        arg.replica_entries_bytes = replicas.nr;
 
-       src = bch2_fs_usage_read(c);
-       if (!src) {
-               ret = -ENOMEM;
-               goto err;
-       }
+       for (unsigned i = 0; i < BCH_REPLICAS_MAX; i++) {
+               struct disk_accounting_pos k = {
+                       .type = BCH_DISK_ACCOUNTING_persistent_reserved,
+                       .persistent_reserved.nr_replicas = i,
+               };
 
-       for (i = 0; i < BCH_REPLICAS_MAX; i++)
-               arg.persistent_reserved[i] = src->u.persistent_reserved[i];
-       percpu_up_read(&c->mark_lock);
+               bch2_accounting_mem_read(c,
+                                        disk_accounting_pos_to_bpos(&k),
+                                        &arg.persistent_reserved[i], 1);
+       }
 
        ret = copy_to_user_errcode(user_arg, &arg, sizeof(arg));
 err:
        darray_exit(&replicas);
-       kfree(src);
        return ret;
 }
 

diff --git a/fs/bcachefs/disk_accounting.c b/fs/bcachefs/disk_accounting.c
index ccd3f8d878d1122033f0007a98f604baddb7c250..eadf4f6392bf3266977f2e6d01dd89e4f590ed2b 100644 (file)
--- a/fs/bcachefs/disk_accounting.c
+++ b/fs/bcachefs/disk_accounting.c
@@ -38,7 +38,7 @@
  * replay).
  *
  * To do a disk accounting update:
- * - initialize a disk_accounting_key, to specify which counter is being update
+ * - initialize a disk_accounting_pos, to specify which counter is being update
  * - initialize counter deltas, as an array of 1-3 s64s
  * - call bch2_disk_accounting_mod()
  *

diff --git a/fs/bcachefs/replicas.c b/fs/bcachefs/replicas.c
index 9cf1d118f14646a3beb95ef7a8bdef814a39593d..06783f357f8d505edfb4ac80078fffeddfc436e6 100644 (file)
--- a/fs/bcachefs/replicas.c
+++ b/fs/bcachefs/replicas.c
@@ -308,13 +308,10 @@ static int replicas_table_update(struct bch_fs *c,
                                 struct bch_replicas_cpu *new_r)
 {
        struct bch_fs_usage __percpu *new_usage[JOURNAL_BUF_NR];
-       struct bch_fs_usage_online *new_scratch = NULL;
        struct bch_fs_usage __percpu *new_gc = NULL;
        struct bch_fs_usage *new_base = NULL;
        unsigned i, bytes = sizeof(struct bch_fs_usage) +
                sizeof(u64) * new_r->nr;
-       unsigned scratch_bytes = sizeof(struct bch_fs_usage_online) +
-               sizeof(u64) * new_r->nr;
        int ret = 0;
 
        memset(new_usage, 0, sizeof(new_usage));
@@ -325,7 +322,6 @@ static int replicas_table_update(struct bch_fs *c,
                        goto err;
 
        if (!(new_base = kzalloc(bytes, GFP_KERNEL)) ||
-           !(new_scratch  = kmalloc(scratch_bytes, GFP_KERNEL)) ||
            (c->usage_gc &&
             !(new_gc = __alloc_percpu_gfp(bytes, sizeof(u64), GFP_KERNEL))))
                goto err;
@@ -344,12 +340,10 @@ static int replicas_table_update(struct bch_fs *c,
        for (i = 0; i < ARRAY_SIZE(new_usage); i++)
                swap(c->usage[i],       new_usage[i]);
        swap(c->usage_base,     new_base);
-       swap(c->usage_scratch,  new_scratch);
        swap(c->usage_gc,       new_gc);
        swap(c->replicas,       *new_r);
 out:
        free_percpu(new_gc);
-       kfree(new_scratch);
        for (i = 0; i < ARRAY_SIZE(new_usage); i++)
                free_percpu(new_usage[i]);
        kfree(new_base);
@@ -1028,7 +1022,6 @@ void bch2_fs_replicas_exit(struct bch_fs *c)
 {
        unsigned i;
 
-       kfree(c->usage_scratch);
        for (i = 0; i < ARRAY_SIZE(c->usage); i++)
                free_percpu(c->usage[i]);
        kfree(c->usage_base);

diff --git a/fs/bcachefs/super.c b/fs/bcachefs/super.c
index 597addbf2bca2816dc7da80a50cd9df19aa936d6..e7a17179f7410befa33001b7b7a06885c5e5f946 100644 (file)
--- a/fs/bcachefs/super.c
+++ b/fs/bcachefs/super.c
@@ -791,8 +791,6 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts)
 
        INIT_LIST_HEAD(&c->list);
 
-       mutex_init(&c->usage_scratch_lock);
-
        mutex_init(&c->bio_bounce_pages_lock);
        mutex_init(&c->snapshot_table_lock);
        init_rwsem(&c->snapshot_create_lock);