bcachefs: fix assorted sparse-isms

19 files changed, 59 insertions, 65 deletions

diff --git a/fs/bcachefs/alloc.c b/fs/bcachefs/alloc.c
index 24a22f1b7128..44f9479eecd1 100644
--- a/fs/bcachefs/alloc.c
+++ b/fs/bcachefs/alloc.c
@@ -1889,8 +1889,9 @@ void bch2_dev_allocator_add(struct bch_fs *c, struct bch_dev *ca)
 /* stop allocator thread: */
 void bch2_dev_allocator_stop(struct bch_dev *ca)
 {
-	struct task_struct *p = ca->alloc_thread;
+	struct task_struct *p;
 
+	p = rcu_dereference_protected(ca->alloc_thread, 1);
 	ca->alloc_thread = NULL;
 
 	/*
@@ -1925,7 +1926,7 @@ int bch2_dev_allocator_start(struct bch_dev *ca)
 		return PTR_ERR(p);
 
 	get_task_struct(p);
-	ca->alloc_thread = p;
+	rcu_assign_pointer(ca->alloc_thread, p);
 	wake_up_process(p);
 	return 0;
 }
diff --git a/fs/bcachefs/alloc.h b/fs/bcachefs/alloc.h
index 372cc047e927..00d01f464c68 100644
--- a/fs/bcachefs/alloc.h
+++ b/fs/bcachefs/alloc.h
@@ -103,7 +103,8 @@ static inline void bch2_wake_allocator(struct bch_dev *ca)
 	struct task_struct *p;
 
 	rcu_read_lock();
-	if ((p = READ_ONCE(ca->alloc_thread)))
+	p = rcu_dereference(ca->alloc_thread);
+	if (p)
 		wake_up_process(p);
 	rcu_read_unlock();
 }
diff --git a/fs/bcachefs/bcachefs.h b/fs/bcachefs/bcachefs.h
index 5b6faca1d330..879bde20bca4 100644
--- a/fs/bcachefs/bcachefs.h
+++ b/fs/bcachefs/bcachefs.h
@@ -383,7 +383,7 @@ struct bch_dev {
 	struct bch_dev_usage	usage_cached;
 
 	/* Allocator: */
-	struct task_struct	*alloc_thread;
+	struct task_struct __rcu *alloc_thread;
 
 	/*
 	 * free: Buckets that are ready to be used
@@ -458,7 +458,6 @@ enum {
 	/* shutdown: */
 	BCH_FS_EMERGENCY_RO,
 	BCH_FS_WRITE_DISABLE_COMPLETE,
-	BCH_FS_GC_STOPPING,
 
 	/* errors: */
 	BCH_FS_ERROR,
diff --git a/fs/bcachefs/btree_gc.c b/fs/bcachefs/btree_gc.c
index ffa9c62e3c0d..cd5ebfbe7bda 100644
--- a/fs/bcachefs/btree_gc.c
+++ b/fs/bcachefs/btree_gc.c
@@ -27,6 +27,7 @@
 #include <linux/kthread.h>
 #include <linux/preempt.h>
 #include <linux/rcupdate.h>
+#include <linux/sched/task.h>
 #include <trace/events/bcachefs.h>
 
 struct range_checks {
@@ -814,6 +815,7 @@ static int bch2_coalesce_btree(struct bch_fs *c, enum btree_id btree_id)
 {
 	struct btree_iter iter;
 	struct btree *b;
+	bool kthread = (current->flags & PF_KTHREAD) != 0;
 	unsigned i;
 
 	/* Sliding window of adjacent btree nodes */
@@ -860,7 +862,7 @@ static int bch2_coalesce_btree(struct bch_fs *c, enum btree_id btree_id)
 
 		lock_seq[0] = merge[0]->lock.state.seq;
 
-		if (test_bit(BCH_FS_GC_STOPPING, &c->flags)) {
+		if (kthread && kthread_should_stop()) {
 			bch2_btree_iter_unlock(&iter);
 			return -ESHUTDOWN;
 		}
@@ -959,13 +961,15 @@ static int bch2_gc_thread(void *arg)
 
 void bch2_gc_thread_stop(struct bch_fs *c)
 {
-	set_bit(BCH_FS_GC_STOPPING, &c->flags);
-
-	if (c->gc_thread)
-		kthread_stop(c->gc_thread);
+	struct task_struct *p;
 
+	p = c->gc_thread;
 	c->gc_thread = NULL;
-	clear_bit(BCH_FS_GC_STOPPING, &c->flags);
+
+	if (p) {
+		kthread_stop(p);
+		put_task_struct(p);
+	}
 }
 
 int bch2_gc_thread_start(struct bch_fs *c)
@@ -974,12 +978,13 @@ int bch2_gc_thread_start(struct bch_fs *c)
 
 	BUG_ON(c->gc_thread);
 
-	p = kthread_create(bch2_gc_thread, c, "bcache_gc");
+	p = kthread_create(bch2_gc_thread, c, "bch_gc");
 	if (IS_ERR(p))
 		return PTR_ERR(p);
 
+	get_task_struct(p);
 	c->gc_thread = p;
-	wake_up_process(c->gc_thread);
+	wake_up_process(p);
 	return 0;
 }
 
diff --git a/fs/bcachefs/btree_update_interior.c b/fs/bcachefs/btree_update_interior.c
index 706c78693cae..c3ecc1e96726 100644
--- a/fs/bcachefs/btree_update_interior.c
+++ b/fs/bcachefs/btree_update_interior.c
@@ -1797,8 +1797,8 @@ static int __btree_node_rewrite(struct bch_fs *c, struct btree_iter *iter,
 	bch2_btree_node_write(c, n, SIX_LOCK_intent);
 
 	if (parent) {
-		bch2_btree_insert_node(as, parent, iter,
-				       &keylist_single(&n->key));
+		bch2_keylist_add(&as->parent_keys, &n->key);
+		bch2_btree_insert_node(as, parent, iter, &as->parent_keys);
 	} else {
 		bch2_btree_set_root(as, n, iter);
 	}
diff --git a/fs/bcachefs/buckets.c b/fs/bcachefs/buckets.c
index 1f944cb8a3e5..03918e46b4d2 100644
--- a/fs/bcachefs/buckets.c
+++ b/fs/bcachefs/buckets.c
@@ -957,7 +957,8 @@ void bch2_dev_buckets_free(struct bch_dev *ca)
 	kvpfree(ca->buckets_dirty,
 		BITS_TO_LONGS(ca->mi.nbuckets) * sizeof(unsigned long));
 	kvpfree(ca->oldest_gens, ca->mi.nbuckets * sizeof(u8));
-	kvpfree(ca->buckets,	 sizeof(struct bucket_array) +
+	kvpfree(rcu_dereference_protected(ca->buckets, 1),
+		sizeof(struct bucket_array) +
 		ca->mi.nbuckets * sizeof(struct bucket));
 
 	free_percpu(ca->usage_percpu);
diff --git a/fs/bcachefs/compress.c b/fs/bcachefs/compress.c
index 1af62621da1b..6379905bad7b 100644
--- a/fs/bcachefs/compress.c
+++ b/fs/bcachefs/compress.c
@@ -480,7 +480,7 @@ static const unsigned bch2_compression_opt_to_feature[] = {
 
 #undef BCH_FEATURE_NONE
 
-int __bch2_check_set_has_compressed_data(struct bch_fs *c, u64 f)
+static int __bch2_check_set_has_compressed_data(struct bch_fs *c, u64 f)
 {
 	int ret = 0;
 
@@ -529,26 +529,6 @@ void bch2_fs_compress_exit(struct bch_fs *c)
 	mempool_exit(&c->compression_bounce[READ]);
 }
 
-static void *mempool_kvpmalloc(gfp_t gfp_mask, void *pool_data)
-{
-	size_t size = (size_t)pool_data;
-	return kvpmalloc(size, gfp_mask);
-}
-
-void mempool_kvpfree(void *element, void *pool_data)
-{
-	size_t size = (size_t)pool_data;
-	kvpfree(element, size);
-}
-
-static int mempool_init_kvpmalloc_pool(mempool_t *pool, int min_nr, size_t size)
-{
-	return !mempool_initialized(pool)
-		? mempool_init(pool, min_nr, mempool_kvpmalloc,
-			       mempool_kvpfree, (void *) size)
-		: 0;
-}
-
 static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
 {
 	size_t max_extent = c->sb.encoded_extent_max << 9;
@@ -611,6 +591,9 @@ have_compressed:
 		if (i->decompress_workspace)
 			decompress_workspace_needed = true;
 
+		if (mempool_initialized(&c->compress_workspace[i->type]))
+			continue;
+
 		ret = mempool_init_kvpmalloc_pool(
 				&c->compress_workspace[i->type],
 				1, i->compress_workspace);
diff --git a/fs/bcachefs/disk_groups.c b/fs/bcachefs/disk_groups.c
index b738acc0693e..cd200cbed3e6 100644
--- a/fs/bcachefs/disk_groups.c
+++ b/fs/bcachefs/disk_groups.c
@@ -16,8 +16,8 @@ static int group_cmp(const void *_l, const void *_r)
 		strncmp(l->label, r->label, sizeof(l->label));
 }
 
-const char *bch2_sb_disk_groups_validate(struct bch_sb *sb,
-					 struct bch_sb_field *f)
+static const char *bch2_sb_disk_groups_validate(struct bch_sb *sb,
+						struct bch_sb_field *f)
 {
 	struct bch_sb_field_disk_groups *groups =
 		field_to_type(f, disk_groups);
@@ -162,7 +162,8 @@ int bch2_sb_disk_groups_to_cpu(struct bch_fs *c)
 		}
 	}
 
-	old_g = c->disk_groups;
+	old_g = rcu_dereference_protected(c->disk_groups,
+				lockdep_is_held(&c->sb_lock));
 	rcu_assign_pointer(c->disk_groups, cpu_g);
 	if (old_g)
 		kfree_rcu(old_g, rcu);
diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index e2ae2af2f5c2..035e6f9bd264 100644
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -144,7 +144,7 @@ bch2_extent_has_group(struct bch_fs *c, struct bkey_s_c_extent e, unsigned group
 	const struct bch_extent_ptr *ptr;
 
 	extent_for_each_ptr(e, ptr) {
-		struct bch_dev *ca = c->devs[ptr->dev];
+		struct bch_dev *ca = bch_dev_bkey_exists(c, ptr->dev);
 
 		if (ca->mi.group &&
 		    ca->mi.group - 1 == group)
diff --git a/fs/bcachefs/fs-io.c b/fs/bcachefs/fs-io.c
index 5915a6d5584a..b5e0a8c50eb7 100644
--- a/fs/bcachefs/fs-io.c
+++ b/fs/bcachefs/fs-io.c
@@ -1020,12 +1020,12 @@ static void bchfs_read(struct bch_fs *c, struct btree_iter *iter,
 
 			if (bkey_extent_is_data(k.k)) {
 				struct bkey_s_c_extent e = bkey_s_c_to_extent(k);
-				const struct bch_extent_ptr *ptr;
 				struct bch_extent_crc_unpacked crc;
+				const union bch_extent_entry *i;
 
-				extent_for_each_ptr_crc(e, ptr, crc)
-					want_full_extent |= !!crc.csum_type |
-							     !!crc.compression_type;
+				extent_for_each_crc(e, crc, i)
+					want_full_extent |= ((crc.csum_type != 0) |
+							     (crc.compression_type != 0));
 			}
 
 			readpage_bio_extend(readpages_iter,
diff --git a/fs/bcachefs/journal.h b/fs/bcachefs/journal.h
index 4cec7bb56948..6759810b19ef 100644
--- a/fs/bcachefs/journal.h
+++ b/fs/bcachefs/journal.h
@@ -365,6 +365,8 @@ static inline void bch2_journal_set_replay_done(struct journal *j)
 ssize_t bch2_journal_print_debug(struct journal *, char *);
 ssize_t bch2_journal_print_pins(struct journal *, char *);
 
+int bch2_set_nr_journal_buckets(struct bch_fs *, struct bch_dev *,
+				unsigned nr);
 int bch2_dev_journal_alloc(struct bch_dev *);
 
 void bch2_dev_journal_stop(struct journal *, struct bch_dev *);
diff --git a/fs/bcachefs/journal_io.c b/fs/bcachefs/journal_io.c
index f1b6b5489332..36ba6a4daf84 100644
--- a/fs/bcachefs/journal_io.c
+++ b/fs/bcachefs/journal_io.c
@@ -324,7 +324,7 @@ struct jset_entry_ops {
 			struct jset_entry *, int);
 };
 
-const struct jset_entry_ops bch2_jset_entry_ops[] = {
+static const struct jset_entry_ops bch2_jset_entry_ops[] = {
 #define x(f, nr)						\
 	[BCH_JSET_ENTRY_##f]	= (struct jset_entry_ops) {	\
 		.validate	= journal_entry_validate_##f,	\
diff --git a/fs/bcachefs/keylist.h b/fs/bcachefs/keylist.h
index a8c8883ba071..3106759e35f7 100644
--- a/fs/bcachefs/keylist.h
+++ b/fs/bcachefs/keylist.h
@@ -55,9 +55,6 @@ static inline struct bkey_i *bch2_keylist_front(struct keylist *l)
 	     _k != (_keylist)->top;				\
 	     _k = bkey_next(_k))
 
-#define keylist_single(k)					\
-	((struct keylist) { .keys = k, .top = bkey_next(k) })
-
 static inline u64 keylist_sectors(struct keylist *keys)
 {
 	struct bkey_i *k;
diff --git a/fs/bcachefs/rebalance.c b/fs/bcachefs/rebalance.c
index d0a212990391..4154b1e97acd 100644
--- a/fs/bcachefs/rebalance.c
+++ b/fs/bcachefs/rebalance.c
@@ -304,7 +304,7 @@ void bch2_rebalance_stop(struct bch_fs *c)
 	c->rebalance.pd.rate.rate = UINT_MAX;
 	bch2_ratelimit_reset(&c->rebalance.pd.rate);
 
-	p = c->rebalance.thread;
+	p = rcu_dereference_protected(c->rebalance.thread, 1);
 	c->rebalance.thread = NULL;
 
 	if (p) {
@@ -328,9 +328,8 @@ int bch2_rebalance_start(struct bch_fs *c)
 		return PTR_ERR(p);
 
 	get_task_struct(p);
-
 	rcu_assign_pointer(c->rebalance.thread, p);
-	wake_up_process(c->rebalance.thread);
+	wake_up_process(p);
 	return 0;
 }
 
diff --git a/fs/bcachefs/rebalance_types.h b/fs/bcachefs/rebalance_types.h
index 14963bf551e6..aaf5b9ca133c 100644
--- a/fs/bcachefs/rebalance_types.h
+++ b/fs/bcachefs/rebalance_types.h
@@ -10,7 +10,7 @@ enum rebalance_state {
 };
 
 struct bch_fs_rebalance {
-	struct task_struct	*thread;
+	struct task_struct __rcu *thread;
 	struct bch_pd_controller pd;
 
 	atomic64_t		work_unknown_dev;
diff --git a/fs/bcachefs/super-io.h b/fs/bcachefs/super-io.h
index aa761c44ec5a..995b1c907318 100644
--- a/fs/bcachefs/super-io.h
+++ b/fs/bcachefs/super-io.h
@@ -131,4 +131,7 @@ static inline struct bch_member_cpu bch2_mi_to_cpu(struct bch_member *mi)
 	};
 }
 
+size_t bch2_sb_field_to_text(char *, size_t, struct bch_sb *,
+			     struct bch_sb_field *);
+
 #endif /* _BCACHEFS_SUPER_IO_H */
diff --git a/fs/bcachefs/super.c b/fs/bcachefs/super.c
index 13f19c2dae5b..55da242c994d 100644
--- a/fs/bcachefs/super.c
+++ b/fs/bcachefs/super.c
@@ -644,7 +644,8 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts)
 			BIOSET_NEED_BVECS) ||
 	    !(c->usage_percpu = alloc_percpu(struct bch_fs_usage)) ||
 	    lg_lock_init(&c->usage_lock) ||
-	    mempool_init_vp_pool(&c->btree_bounce_pool, 1, btree_bytes(c)) ||
+	    mempool_init_kvpmalloc_pool(&c->btree_bounce_pool, 1,
+					btree_bytes(c)) ||
 	    bch2_io_clock_init(&c->io_clock[READ]) ||
 	    bch2_io_clock_init(&c->io_clock[WRITE]) ||
 	    bch2_fs_journal_init(&c->journal) ||
diff --git a/fs/bcachefs/util.c b/fs/bcachefs/util.c
index 8cd27d646f9c..60e1f1ff44eb 100644
--- a/fs/bcachefs/util.c
+++ b/fs/bcachefs/util.c
@@ -203,7 +203,7 @@ bool bch2_is_zero(const void *_p, size_t n)
 	return true;
 }
 
-void bch2_quantiles_update(struct quantiles *q, u64 v)
+static void bch2_quantiles_update(struct quantiles *q, u64 v)
 {
 	unsigned i = 0;
 
@@ -788,20 +788,28 @@ void sort_cmp_size(void *base, size_t num, size_t size,
 	}
 }
 
-void mempool_free_vp(void *element, void *pool_data)
+static void mempool_free_vp(void *element, void *pool_data)
 {
 	size_t size = (size_t) pool_data;
 
 	vpfree(element, size);
 }
 
-void *mempool_alloc_vp(gfp_t gfp_mask, void *pool_data)
+static void *mempool_alloc_vp(gfp_t gfp_mask, void *pool_data)
 {
 	size_t size = (size_t) pool_data;
 
 	return vpmalloc(size, gfp_mask);
 }
 
+int mempool_init_kvpmalloc_pool(mempool_t *pool, int min_nr, size_t size)
+{
+	return size < PAGE_SIZE
+		? mempool_init_kmalloc_pool(pool, min_nr, size)
+		: mempool_init(pool, min_nr, mempool_alloc_vp,
+			       mempool_free_vp, (void *) size);
+}
+
 #if 0
 void eytzinger1_test(void)
 {
diff --git a/fs/bcachefs/util.h b/fs/bcachefs/util.h
index e07264d2e623..49813c142aee 100644
--- a/fs/bcachefs/util.h
+++ b/fs/bcachefs/util.h
@@ -113,14 +113,7 @@ static inline void *kvpmalloc(size_t size, gfp_t gfp_mask)
 		: vpmalloc(size, gfp_mask);
 }
 
-void mempool_free_vp(void *element, void *pool_data);
-void *mempool_alloc_vp(gfp_t gfp_mask, void *pool_data);
-
-static inline int mempool_init_vp_pool(mempool_t *pool, int min_nr, size_t size)
-{
-	return mempool_init(pool, min_nr, mempool_alloc_vp,
-			    mempool_free_vp, (void *) size);
-}
+int mempool_init_kvpmalloc_pool(mempool_t *, int, size_t);
 
 #define HEAP(type)							\
 struct {								\