1 // SPDX-License-Identifier: GPL-2.0
4 #include "disk_groups.h"
7 #include "sb-members.h"
10 /* Code for bch_sb_field_members_v1: */
12 static struct bch_member *members_v2_get_mut(struct bch_sb_field_members_v2 *mi, int i)
14 return (void *) mi->_members + (i * le16_to_cpu(mi->member_bytes));
17 struct bch_member *bch2_members_v2_get_mut(struct bch_sb *sb, int i)
19 return members_v2_get_mut(bch2_sb_field_get(sb, members_v2), i);
22 static struct bch_member members_v2_get(struct bch_sb_field_members_v2 *mi, int i)
24 struct bch_member ret, *p = members_v2_get_mut(mi, i);
25 memset(&ret, 0, sizeof(ret));
26 memcpy(&ret, p, min_t(size_t, le16_to_cpu(mi->member_bytes), sizeof(ret)));
30 static struct bch_member *members_v1_get_mut(struct bch_sb_field_members_v1 *mi, int i)
32 return (void *) mi->_members + (i * BCH_MEMBER_V1_BYTES);
35 static struct bch_member members_v1_get(struct bch_sb_field_members_v1 *mi, int i)
37 struct bch_member ret, *p = members_v1_get_mut(mi, i);
38 memset(&ret, 0, sizeof(ret));
39 memcpy(&ret, p, min_t(size_t, sizeof(struct bch_member), sizeof(ret))); return ret;
42 struct bch_member bch2_sb_member_get(struct bch_sb *sb, int i)
44 struct bch_sb_field_members_v2 *mi2 = bch2_sb_field_get(sb, members_v2);
46 return members_v2_get(mi2, i);
47 struct bch_sb_field_members_v1 *mi1 = bch2_sb_field_get(sb, members_v1);
48 return members_v1_get(mi1, i);
51 static int sb_members_v2_resize_entries(struct bch_fs *c)
53 struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2);
55 if (le16_to_cpu(mi->member_bytes) < sizeof(struct bch_member)) {
56 unsigned u64s = DIV_ROUND_UP((sizeof(*mi) + sizeof(mi->_members[0]) *
57 c->disk_sb.sb->nr_devices), 8);
59 mi = bch2_sb_field_resize(&c->disk_sb, members_v2, u64s);
61 return -BCH_ERR_ENOSPC_sb_members_v2;
63 for (int i = c->disk_sb.sb->nr_devices - 1; i >= 0; --i) {
64 void *dst = (void *) mi->_members + (i * sizeof(struct bch_member));
65 memmove(dst, members_v2_get_mut(mi, i), le16_to_cpu(mi->member_bytes));
66 memset(dst + le16_to_cpu(mi->member_bytes),
67 0, (sizeof(struct bch_member) - le16_to_cpu(mi->member_bytes)));
69 mi->member_bytes = cpu_to_le16(sizeof(struct bch_member));
74 int bch2_members_v2_init(struct bch_fs *c)
76 struct bch_sb_field_members_v1 *mi1;
77 struct bch_sb_field_members_v2 *mi2;
79 if (!bch2_sb_field_get(c->disk_sb.sb, members_v2)) {
80 mi2 = bch2_sb_field_resize(&c->disk_sb, members_v2,
81 DIV_ROUND_UP(sizeof(*mi2) +
82 sizeof(struct bch_member) * c->sb.nr_devices,
84 mi1 = bch2_sb_field_get(c->disk_sb.sb, members_v1);
85 memcpy(&mi2->_members[0], &mi1->_members[0],
86 BCH_MEMBER_V1_BYTES * c->sb.nr_devices);
87 memset(&mi2->pad[0], 0, sizeof(mi2->pad));
88 mi2->member_bytes = cpu_to_le16(BCH_MEMBER_V1_BYTES);
91 return sb_members_v2_resize_entries(c);
94 int bch_members_cpy_v2_v1(struct bch_sb_handle *disk_sb)
96 struct bch_sb_field_members_v1 *mi1;
97 struct bch_sb_field_members_v2 *mi2;
99 mi1 = bch2_sb_field_resize(disk_sb, members_v1,
100 DIV_ROUND_UP(sizeof(*mi1) + BCH_MEMBER_V1_BYTES *
101 disk_sb->sb->nr_devices, sizeof(u64)));
103 return -BCH_ERR_ENOSPC_sb_members;
105 mi2 = bch2_sb_field_get(disk_sb->sb, members_v2);
107 for (unsigned i = 0; i < disk_sb->sb->nr_devices; i++)
108 memcpy(members_v1_get_mut(mi1, i), members_v2_get_mut(mi2, i), BCH_MEMBER_V1_BYTES);
113 static int validate_member(struct printbuf *err,
118 if (le64_to_cpu(m.nbuckets) > LONG_MAX) {
119 prt_printf(err, "device %u: too many buckets (got %llu, max %lu)",
120 i, le64_to_cpu(m.nbuckets), LONG_MAX);
121 return -BCH_ERR_invalid_sb_members;
124 if (le64_to_cpu(m.nbuckets) -
125 le16_to_cpu(m.first_bucket) < BCH_MIN_NR_NBUCKETS) {
126 prt_printf(err, "device %u: not enough buckets (got %llu, max %u)",
127 i, le64_to_cpu(m.nbuckets), BCH_MIN_NR_NBUCKETS);
128 return -BCH_ERR_invalid_sb_members;
131 if (le16_to_cpu(m.bucket_size) <
132 le16_to_cpu(sb->block_size)) {
133 prt_printf(err, "device %u: bucket size %u smaller than block size %u",
134 i, le16_to_cpu(m.bucket_size), le16_to_cpu(sb->block_size));
135 return -BCH_ERR_invalid_sb_members;
138 if (le16_to_cpu(m.bucket_size) <
139 BCH_SB_BTREE_NODE_SIZE(sb)) {
140 prt_printf(err, "device %u: bucket size %u smaller than btree node size %llu",
141 i, le16_to_cpu(m.bucket_size), BCH_SB_BTREE_NODE_SIZE(sb));
142 return -BCH_ERR_invalid_sb_members;
148 static void member_to_text(struct printbuf *out,
150 struct bch_sb_field_disk_groups *gi,
154 unsigned data_have = bch2_sb_dev_has_data(sb, i);
155 u64 bucket_size = le16_to_cpu(m.bucket_size);
156 u64 device_size = le64_to_cpu(m.nbuckets) * bucket_size;
159 prt_printf(out, "Device:");
161 prt_printf(out, "%u", i);
164 printbuf_indent_add(out, 2);
166 prt_printf(out, "UUID:");
168 pr_uuid(out, m.uuid.b);
171 prt_printf(out, "Size:");
173 prt_units_u64(out, device_size << 9);
176 for (unsigned i = 0; i < BCH_IOPS_NR; i++) {
177 prt_printf(out, "%s iops:", bch2_iops_measurements[i]);
179 prt_printf(out, "%u", le32_to_cpu(m.iops[i]));
183 prt_printf(out, "Bucket size:");
185 prt_units_u64(out, bucket_size << 9);
188 prt_printf(out, "First bucket:");
190 prt_printf(out, "%u", le16_to_cpu(m.first_bucket));
193 prt_printf(out, "Buckets:");
195 prt_printf(out, "%llu", le64_to_cpu(m.nbuckets));
198 prt_printf(out, "Last mount:");
201 pr_time(out, le64_to_cpu(m.last_mount));
203 prt_printf(out, "(never)");
206 prt_printf(out, "State:");
208 prt_printf(out, "%s",
209 BCH_MEMBER_STATE(&m) < BCH_MEMBER_STATE_NR
210 ? bch2_member_states[BCH_MEMBER_STATE(&m)]
214 prt_printf(out, "Label:");
216 if (BCH_MEMBER_GROUP(&m)) {
217 unsigned idx = BCH_MEMBER_GROUP(&m) - 1;
219 if (idx < disk_groups_nr(gi))
220 prt_printf(out, "%s (%u)",
221 gi->entries[idx].label, idx);
223 prt_printf(out, "(bad disk labels section)");
225 prt_printf(out, "(none)");
229 prt_printf(out, "Data allowed:");
231 if (BCH_MEMBER_DATA_ALLOWED(&m))
232 prt_bitflags(out, bch2_data_types, BCH_MEMBER_DATA_ALLOWED(&m));
234 prt_printf(out, "(none)");
237 prt_printf(out, "Has data:");
240 prt_bitflags(out, bch2_data_types, data_have);
242 prt_printf(out, "(none)");
245 prt_printf(out, "Discard:");
247 prt_printf(out, "%llu", BCH_MEMBER_DISCARD(&m));
250 prt_printf(out, "Freespace initialized:");
252 prt_printf(out, "%llu", BCH_MEMBER_FREESPACE_INITIALIZED(&m));
255 printbuf_indent_sub(out, 2);
258 static int bch2_sb_members_v1_validate(struct bch_sb *sb,
259 struct bch_sb_field *f,
260 struct printbuf *err)
262 struct bch_sb_field_members_v1 *mi = field_to_type(f, members_v1);
265 if ((void *) members_v1_get_mut(mi, sb->nr_devices) >
266 vstruct_end(&mi->field)) {
267 prt_printf(err, "too many devices for section size");
268 return -BCH_ERR_invalid_sb_members;
271 for (i = 0; i < sb->nr_devices; i++) {
272 struct bch_member m = members_v1_get(mi, i);
274 int ret = validate_member(err, m, sb, i);
282 static void bch2_sb_members_v1_to_text(struct printbuf *out, struct bch_sb *sb,
283 struct bch_sb_field *f)
285 struct bch_sb_field_members_v1 *mi = field_to_type(f, members_v1);
286 struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups);
289 for (i = 0; i < sb->nr_devices; i++) {
290 struct bch_member m = members_v1_get(mi, i);
291 member_to_text(out, m, gi, sb, i);
295 const struct bch_sb_field_ops bch_sb_field_ops_members_v1 = {
296 .validate = bch2_sb_members_v1_validate,
297 .to_text = bch2_sb_members_v1_to_text,
300 static void bch2_sb_members_v2_to_text(struct printbuf *out, struct bch_sb *sb,
301 struct bch_sb_field *f)
303 struct bch_sb_field_members_v2 *mi = field_to_type(f, members_v2);
304 struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups);
307 for (i = 0; i < sb->nr_devices; i++) {
308 struct bch_member m = members_v2_get(mi, i);
309 member_to_text(out, m, gi, sb, i);
313 static int bch2_sb_members_v2_validate(struct bch_sb *sb,
314 struct bch_sb_field *f,
315 struct printbuf *err)
317 struct bch_sb_field_members_v2 *mi = field_to_type(f, members_v2);
318 size_t mi_bytes = (void *) members_v2_get_mut(mi, sb->nr_devices) -
321 if (mi_bytes > vstruct_bytes(&mi->field)) {
322 prt_printf(err, "section too small (%zu > %zu)",
323 mi_bytes, vstruct_bytes(&mi->field));
324 return -BCH_ERR_invalid_sb_members;
327 for (unsigned i = 0; i < sb->nr_devices; i++) {
328 int ret = validate_member(err, members_v2_get(mi, i), sb, i);
336 const struct bch_sb_field_ops bch_sb_field_ops_members_v2 = {
337 .validate = bch2_sb_members_v2_validate,
338 .to_text = bch2_sb_members_v2_to_text,