bcachefs: bch2_sb_field_get() refactoring

Instead of using token pasting to generate methods for each superblock
section, just make the type a parameter to bch2_sb_field_get().

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

Author: Kent Overstreet

fs/bcachefs/checksum.c

@@ -678,7 +678,7 @@ int bch2_disable_encryption(struct bch_fs *c)
 
 	mutex_lock(&c->sb_lock);
 
-	crypt = bch2_sb_get_crypt(c->disk_sb.sb);
+	crypt = bch2_sb_field_get(c->disk_sb.sb, crypt);
 	if (!crypt)
 		goto out;
 
@@ -712,7 +712,7 @@ int bch2_enable_encryption(struct bch_fs *c, bool keyed)
 	mutex_lock(&c->sb_lock);
 
 	/* Do we already have an encryption key? */
-	if (bch2_sb_get_crypt(c->disk_sb.sb))
+	if (bch2_sb_field_get(c->disk_sb.sb, crypt))
 		goto err;
 
 	ret = bch2_alloc_ciphers(c);
@@ -740,7 +740,8 @@ int bch2_enable_encryption(struct bch_fs *c, bool keyed)
 	if (ret)
 		goto err;
 
-	crypt = bch2_sb_resize_crypt(&c->disk_sb, sizeof(*crypt) / sizeof(u64));
+	crypt = bch2_sb_field_resize(&c->disk_sb, crypt,
+				     sizeof(*crypt) / sizeof(u64));
 	if (!crypt) {
 		ret = -BCH_ERR_ENOSPC_sb_crypt;
 		goto err;
@@ -781,7 +782,7 @@ int bch2_fs_encryption_init(struct bch_fs *c)
 		goto out;
 	}
 
-	crypt = bch2_sb_get_crypt(c->disk_sb.sb);
+	crypt = bch2_sb_field_get(c->disk_sb.sb, crypt);
 	if (!crypt)
 		goto out;
 

fs/bcachefs/counters.c

@@ -48,7 +48,7 @@ static void bch2_sb_counters_to_text(struct printbuf *out, struct bch_sb *sb,
 
 int bch2_sb_counters_to_cpu(struct bch_fs *c)
 {
-	struct bch_sb_field_counters *ctrs = bch2_sb_get_counters(c->disk_sb.sb);
+	struct bch_sb_field_counters *ctrs = bch2_sb_field_get(c->disk_sb.sb, counters);
 	unsigned int i;
 	unsigned int nr = bch2_sb_counter_nr_entries(ctrs);
 	u64 val = 0;
@@ -66,13 +66,13 @@ int bch2_sb_counters_to_cpu(struct bch_fs *c)
 
 int bch2_sb_counters_from_cpu(struct bch_fs *c)
 {
-	struct bch_sb_field_counters *ctrs = bch2_sb_get_counters(c->disk_sb.sb);
+	struct bch_sb_field_counters *ctrs = bch2_sb_field_get(c->disk_sb.sb, counters);
 	struct bch_sb_field_counters *ret;
 	unsigned int i;
 	unsigned int nr = bch2_sb_counter_nr_entries(ctrs);
 
 	if (nr < BCH_COUNTER_NR) {
-		ret = bch2_sb_resize_counters(&c->disk_sb,
+		ret = bch2_sb_field_resize(&c->disk_sb, counters,
 					       sizeof(*ctrs) / sizeof(u64) + BCH_COUNTER_NR);
 
 		if (ret) {

fs/bcachefs/disk_groups.c

@@ -157,7 +157,7 @@ int bch2_sb_disk_groups_to_cpu(struct bch_fs *c)
 
 	lockdep_assert_held(&c->sb_lock);
 
-	groups		= bch2_sb_get_disk_groups(c->disk_sb.sb);
+	groups		= bch2_sb_field_get(c->disk_sb.sb, disk_groups);
 	nr_groups	= disk_groups_nr(groups);
 
 	if (!groups)
@@ -295,7 +295,7 @@ static int __bch2_disk_group_add(struct bch_sb_handle *sb, unsigned parent,
 				 const char *name, unsigned namelen)
 {
 	struct bch_sb_field_disk_groups *groups =
-		bch2_sb_get_disk_groups(sb->sb);
+		bch2_sb_field_get(sb->sb, disk_groups);
 	unsigned i, nr_groups = disk_groups_nr(groups);
 	struct bch_disk_group *g;
 
@@ -313,7 +313,7 @@ static int __bch2_disk_group_add(struct bch_sb_handle *sb, unsigned parent,
 			 sizeof(struct bch_disk_group) * (nr_groups + 1)) /
 			sizeof(u64);
 
-		groups = bch2_sb_resize_disk_groups(sb, u64s);
+		groups = bch2_sb_field_resize(sb, disk_groups, u64s);
 		if (!groups)
 			return -BCH_ERR_ENOSPC_disk_label_add;
 
@@ -337,7 +337,7 @@ static int __bch2_disk_group_add(struct bch_sb_handle *sb, unsigned parent,
 int bch2_disk_path_find(struct bch_sb_handle *sb, const char *name)
 {
 	struct bch_sb_field_disk_groups *groups =
-		bch2_sb_get_disk_groups(sb->sb);
+		bch2_sb_field_get(sb->sb, disk_groups);
 	int v = -1;
 
 	do {
@@ -367,7 +367,7 @@ int bch2_disk_path_find_or_create(struct bch_sb_handle *sb, const char *name)
 		if (*next == '.')
 			next++;
 
-		groups = bch2_sb_get_disk_groups(sb->sb);
+		groups = bch2_sb_field_get(sb->sb, disk_groups);
 
 		v = __bch2_disk_group_find(groups, parent, name, len);
 		if (v < 0)
@@ -385,7 +385,7 @@ int bch2_disk_path_find_or_create(struct bch_sb_handle *sb, const char *name)
 void bch2_disk_path_to_text(struct printbuf *out, struct bch_sb *sb, unsigned v)
 {
 	struct bch_sb_field_disk_groups *groups =
-		bch2_sb_get_disk_groups(sb);
+		bch2_sb_field_get(sb, disk_groups);
 	struct bch_disk_group *g;
 	unsigned nr = 0;
 	u16 path[32];

fs/bcachefs/journal.c

@@ -1170,9 +1170,9 @@ int bch2_dev_journal_init(struct bch_dev *ca, struct bch_sb *sb)
 {
 	struct journal_device *ja = &ca->journal;
 	struct bch_sb_field_journal *journal_buckets =
-		bch2_sb_get_journal(sb);
+		bch2_sb_field_get(sb, journal);
 	struct bch_sb_field_journal_v2 *journal_buckets_v2 =
-		bch2_sb_get_journal_v2(sb);
+		bch2_sb_field_get(sb, journal_v2);
 	unsigned i, nr_bvecs;
 
 	ja->nr = 0;

fs/bcachefs/journal_sb.c

@@ -194,7 +194,7 @@ int bch2_journal_buckets_to_sb(struct bch_fs *c, struct bch_dev *ca,
 		if (buckets[i] + 1 != buckets[i + 1])
 			nr_compacted++;
 
-	j = bch2_sb_resize_journal_v2(&ca->disk_sb,
+	j = bch2_sb_field_resize(&ca->disk_sb, journal_v2,
 			 (sizeof(*j) + sizeof(j->d[0]) * nr_compacted) / sizeof(u64));
 	if (!j)
 		return -BCH_ERR_ENOSPC_sb_journal;

fs/bcachefs/journal_seq_blacklist.c

@@ -58,8 +58,8 @@ blacklist_entry_try_merge(struct bch_fs *c,
 			&bl->start[i + 1],
 			sizeof(bl->start[0]) * (nr - i));
 
-		bl = bch2_sb_resize_journal_seq_blacklist(&c->disk_sb,
-							sb_blacklist_u64s(nr));
+		bl = bch2_sb_field_resize(&c->disk_sb, journal_seq_blacklist,
+					  sb_blacklist_u64s(nr));
 		BUG_ON(!bl);
 	}
 
@@ -79,7 +79,7 @@ int bch2_journal_seq_blacklist_add(struct bch_fs *c, u64 start, u64 end)
 	int ret = 0;
 
 	mutex_lock(&c->sb_lock);
-	bl = bch2_sb_get_journal_seq_blacklist(c->disk_sb.sb);
+	bl = bch2_sb_field_get(c->disk_sb.sb, journal_seq_blacklist);
 	nr = blacklist_nr_entries(bl);
 
 	for (i = 0; i < nr; i++) {
@@ -100,8 +100,8 @@ int bch2_journal_seq_blacklist_add(struct bch_fs *c, u64 start, u64 end)
 		}
 	}
 
-	bl = bch2_sb_resize_journal_seq_blacklist(&c->disk_sb,
-					sb_blacklist_u64s(nr + 1));
+	bl = bch2_sb_field_resize(&c->disk_sb, journal_seq_blacklist,
+				  sb_blacklist_u64s(nr + 1));
 	if (!bl) {
 		ret = -BCH_ERR_ENOSPC_sb_journal_seq_blacklist;
 		goto out;
@@ -158,7 +158,7 @@ bool bch2_journal_seq_is_blacklisted(struct bch_fs *c, u64 seq,
 int bch2_blacklist_table_initialize(struct bch_fs *c)
 {
 	struct bch_sb_field_journal_seq_blacklist *bl =
-		bch2_sb_get_journal_seq_blacklist(c->disk_sb.sb);
+		bch2_sb_field_get(c->disk_sb.sb, journal_seq_blacklist);
 	struct journal_seq_blacklist_table *t;
 	unsigned i, nr = blacklist_nr_entries(bl);
 
@@ -281,7 +281,7 @@ void bch2_blacklist_entries_gc(struct work_struct *work)
 		return;
 
 	mutex_lock(&c->sb_lock);
-	bl = bch2_sb_get_journal_seq_blacklist(c->disk_sb.sb);
+	bl = bch2_sb_field_get(c->disk_sb.sb, journal_seq_blacklist);
 	if (!bl)
 		goto out;
 
@@ -306,7 +306,7 @@ void bch2_blacklist_entries_gc(struct work_struct *work)
 	bch_info(c, "nr blacklist entries was %u, now %u", nr, new_nr);
 
 	if (new_nr != nr) {
-		bl = bch2_sb_resize_journal_seq_blacklist(&c->disk_sb,
+		bl = bch2_sb_field_resize(&c->disk_sb, journal_seq_blacklist,
 				new_nr ? sb_blacklist_u64s(new_nr) : 0);
 		BUG_ON(new_nr && !bl);
 

fs/bcachefs/quota.c

@@ -513,12 +513,12 @@ void bch2_fs_quota_init(struct bch_fs *c)
 
 static struct bch_sb_field_quota *bch2_sb_get_or_create_quota(struct bch_sb_handle *sb)
 {
-	struct bch_sb_field_quota *sb_quota = bch2_sb_get_quota(sb->sb);
+	struct bch_sb_field_quota *sb_quota = bch2_sb_field_get(sb->sb, quota);
 
 	if (sb_quota)
 		return sb_quota;
 
-	sb_quota = bch2_sb_resize_quota(sb, sizeof(*sb_quota) / sizeof(u64));
+	sb_quota = bch2_sb_field_resize(sb, quota, sizeof(*sb_quota) / sizeof(u64));
 	if (sb_quota) {
 		unsigned qtype, qc;
 
@@ -536,7 +536,7 @@ static void bch2_sb_quota_read(struct bch_fs *c)
 	struct bch_sb_field_quota *sb_quota;
 	unsigned i, j;
 
-	sb_quota = bch2_sb_get_quota(c->disk_sb.sb);
+	sb_quota = bch2_sb_field_get(c->disk_sb.sb, quota);
 	if (!sb_quota)
 		return;
 

fs/bcachefs/replicas.c

@@ -700,9 +700,9 @@ int bch2_sb_replicas_to_cpu_replicas(struct bch_fs *c)
 	struct bch_replicas_cpu new_r = { 0, 0, NULL };
 	int ret = 0;
 
-	if ((sb_v1 = bch2_sb_get_replicas(c->disk_sb.sb)))
+	if ((sb_v1 = bch2_sb_field_get(c->disk_sb.sb, replicas)))
 		ret = __bch2_sb_replicas_to_cpu_replicas(sb_v1, &new_r);
-	else if ((sb_v0 = bch2_sb_get_replicas_v0(c->disk_sb.sb)))
+	else if ((sb_v0 = bch2_sb_field_get(c->disk_sb.sb, replicas_v0)))
 		ret = __bch2_sb_replicas_v0_to_cpu_replicas(sb_v0, &new_r);
 	if (ret)
 		return ret;
@@ -732,13 +732,13 @@ static int bch2_cpu_replicas_to_sb_replicas_v0(struct bch_fs *c,
 	for_each_cpu_replicas_entry(r, src)
 		bytes += replicas_entry_bytes(src) - 1;
 
-	sb_r = bch2_sb_resize_replicas_v0(&c->disk_sb,
+	sb_r = bch2_sb_field_resize(&c->disk_sb, replicas_v0,
 			DIV_ROUND_UP(bytes, sizeof(u64)));
 	if (!sb_r)
 		return -BCH_ERR_ENOSPC_sb_replicas;
 
 	bch2_sb_field_delete(&c->disk_sb, BCH_SB_FIELD_replicas);
-	sb_r = bch2_sb_get_replicas_v0(c->disk_sb.sb);
+	sb_r = bch2_sb_field_get(c->disk_sb.sb, replicas_v0);
 
 	memset(&sb_r->entries, 0,
 	       vstruct_end(&sb_r->field) -
@@ -777,13 +777,13 @@ static int bch2_cpu_replicas_to_sb_replicas(struct bch_fs *c,
 	if (!need_v1)
 		return bch2_cpu_replicas_to_sb_replicas_v0(c, r);
 
-	sb_r = bch2_sb_resize_replicas(&c->disk_sb,
+	sb_r = bch2_sb_field_resize(&c->disk_sb, replicas,
 			DIV_ROUND_UP(bytes, sizeof(u64)));
 	if (!sb_r)
 		return -BCH_ERR_ENOSPC_sb_replicas;
 
 	bch2_sb_field_delete(&c->disk_sb, BCH_SB_FIELD_replicas_v0);
-	sb_r = bch2_sb_get_replicas(c->disk_sb.sb);
+	sb_r = bch2_sb_field_get(c->disk_sb.sb, replicas);
 
 	memset(&sb_r->entries, 0,
 	       vstruct_end(&sb_r->field) -
@@ -998,8 +998,8 @@ unsigned bch2_sb_dev_has_data(struct bch_sb *sb, unsigned dev)
 	struct bch_sb_field_replicas_v0 *replicas_v0;
 	unsigned i, data_has = 0;
 
-	replicas = bch2_sb_get_replicas(sb);
-	replicas_v0 = bch2_sb_get_replicas_v0(sb);
+	replicas = bch2_sb_field_get(sb, replicas);
+	replicas_v0 = bch2_sb_field_get(sb, replicas_v0);
 
 	if (replicas) {
 		struct bch_replicas_entry *r;

fs/bcachefs/sb-clean.c

@@ -137,7 +137,7 @@ struct bch_sb_field_clean *bch2_read_superblock_clean(struct bch_fs *c)
 	int ret;
 
 	mutex_lock(&c->sb_lock);
-	sb_clean = bch2_sb_get_clean(c->disk_sb.sb);
+	sb_clean = bch2_sb_field_get(c->disk_sb.sb, clean);
 
 	if (fsck_err_on(!sb_clean, c,
 			"superblock marked clean but clean section not present")) {
@@ -359,7 +359,7 @@ void bch2_fs_mark_clean(struct bch_fs *c)
 
 	u64s = sizeof(*sb_clean) / sizeof(u64) + c->journal.entry_u64s_reserved;
 
-	sb_clean = bch2_sb_resize_clean(&c->disk_sb, u64s);
+	sb_clean = bch2_sb_field_resize(&c->disk_sb, clean, u64s);
 	if (!sb_clean) {
 		bch_err(c, "error resizing superblock while setting filesystem clean");
 		goto out;

fs/bcachefs/sb-members.c

@@ -16,7 +16,7 @@ static struct bch_member *members_v2_get_mut(struct bch_sb_field_members_v2 *mi,
 
 struct bch_member *bch2_members_v2_get_mut(struct bch_sb *sb, int i)
 {
-	return members_v2_get_mut(bch2_sb_get_members_v2(sb), i);
+	return members_v2_get_mut(bch2_sb_field_get(sb, members_v2), i);
 }
 
 static struct bch_member members_v2_get(struct bch_sb_field_members_v2 *mi, int i)
@@ -41,22 +41,22 @@ static struct bch_member members_v1_get(struct bch_sb_field_members_v1 *mi, int
 
 struct bch_member bch2_sb_member_get(struct bch_sb *sb, int i)
 {
-	struct bch_sb_field_members_v2 *mi2 = bch2_sb_get_members_v2(sb);
+	struct bch_sb_field_members_v2 *mi2 = bch2_sb_field_get(sb, members_v2);
 	if (mi2)
 		return members_v2_get(mi2, i);
-	struct bch_sb_field_members_v1 *mi1 = bch2_sb_get_members_v1(sb);
+	struct bch_sb_field_members_v1 *mi1 = bch2_sb_field_get(sb, members_v1);
 	return members_v1_get(mi1, i);
 }
 
 static int sb_members_v2_resize_entries(struct bch_fs *c)
 {
-	struct bch_sb_field_members_v2 *mi = bch2_sb_get_members_v2(c->disk_sb.sb);
+	struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2);
 
 	if (le16_to_cpu(mi->member_bytes) < sizeof(struct bch_member)) {
 		unsigned u64s = DIV_ROUND_UP((sizeof(*mi) + sizeof(mi->_members[0]) *
 					      c->disk_sb.sb->nr_devices), 8);
 
-		mi = bch2_sb_resize_members_v2(&c->disk_sb, u64s);
+		mi = bch2_sb_field_resize(&c->disk_sb, members_v2, u64s);
 		if (!mi)
 			return -BCH_ERR_ENOSPC_sb_members_v2;
 
@@ -76,12 +76,12 @@ int bch2_members_v2_init(struct bch_fs *c)
 	struct bch_sb_field_members_v1 *mi1;
 	struct bch_sb_field_members_v2 *mi2;
 
-	if (!bch2_sb_get_members_v2(c->disk_sb.sb)) {
-		mi2 = bch2_sb_resize_members_v2(&c->disk_sb,
+	if (!bch2_sb_field_get(c->disk_sb.sb, members_v2)) {
+		mi2 = bch2_sb_field_resize(&c->disk_sb, members_v2,
 				DIV_ROUND_UP(sizeof(*mi2) +
 					     sizeof(struct bch_member) * c->sb.nr_devices,
 					     sizeof(u64)));
-		mi1 = bch2_sb_get_members_v1(c->disk_sb.sb);
+		mi1 = bch2_sb_field_get(c->disk_sb.sb, members_v1);
 		memcpy(&mi2->_members[0], &mi1->_members[0],
 		       BCH_MEMBER_V1_BYTES * c->sb.nr_devices);
 		memset(&mi2->pad[0], 0, sizeof(mi2->pad));
@@ -96,13 +96,13 @@ int bch_members_cpy_v2_v1(struct bch_sb_handle *disk_sb)
 	struct bch_sb_field_members_v1 *mi1;
 	struct bch_sb_field_members_v2 *mi2;
 
-	mi1 = bch2_sb_resize_members_v1(disk_sb,
+	mi1 = bch2_sb_field_resize(disk_sb, members_v1,
 			DIV_ROUND_UP(sizeof(*mi1) + BCH_MEMBER_V1_BYTES *
 				     disk_sb->sb->nr_devices, sizeof(u64)));
 	if (!mi1)
 		return -BCH_ERR_ENOSPC_sb_members;
 
-	mi2 = bch2_sb_get_members_v2(disk_sb->sb);
+	mi2 = bch2_sb_field_get(disk_sb->sb, members_v2);
 
 	for (unsigned i = 0; i < disk_sb->sb->nr_devices; i++)
 		memcpy(members_v1_get_mut(mi1, i), members_v2_get_mut(mi2, i), BCH_MEMBER_V1_BYTES);
@@ -283,7 +283,7 @@ static void bch2_sb_members_v1_to_text(struct printbuf *out, struct bch_sb *sb,
 				       struct bch_sb_field *f)
 {
 	struct bch_sb_field_members_v1 *mi = field_to_type(f, members_v1);
-	struct bch_sb_field_disk_groups *gi = bch2_sb_get_disk_groups(sb);
+	struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups);
 	unsigned i;
 
 	for (i = 0; i < sb->nr_devices; i++) {
@@ -301,7 +301,7 @@ static void bch2_sb_members_v2_to_text(struct printbuf *out, struct bch_sb *sb,
 				       struct bch_sb_field *f)
 {
 	struct bch_sb_field_members_v2 *mi = field_to_type(f, members_v2);
-	struct bch_sb_field_disk_groups *gi = bch2_sb_get_disk_groups(sb);
+	struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups);
 	unsigned i;
 
 	for (i = 0; i < sb->nr_devices; i++) {