]> git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/disk_groups.c
Update bcachefs sources to 2115a2ffde bcachefs: Kill bch2_verify_bucket_evacuated()
[bcachefs-tools-debian] / libbcachefs / disk_groups.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include "bcachefs.h"
3 #include "disk_groups.h"
4 #include "super-io.h"
5
6 #include <linux/sort.h>
7
8 static int group_cmp(const void *_l, const void *_r)
9 {
10         const struct bch_disk_group *l = _l;
11         const struct bch_disk_group *r = _r;
12
13         return ((BCH_GROUP_DELETED(l) > BCH_GROUP_DELETED(r)) -
14                 (BCH_GROUP_DELETED(l) < BCH_GROUP_DELETED(r))) ?:
15                 ((BCH_GROUP_PARENT(l) > BCH_GROUP_PARENT(r)) -
16                  (BCH_GROUP_PARENT(l) < BCH_GROUP_PARENT(r))) ?:
17                 strncmp(l->label, r->label, sizeof(l->label));
18 }
19
20 static int bch2_sb_disk_groups_validate(struct bch_sb *sb,
21                                         struct bch_sb_field *f,
22                                         struct printbuf *err)
23 {
24         struct bch_sb_field_disk_groups *groups =
25                 field_to_type(f, disk_groups);
26         struct bch_disk_group *g, *sorted = NULL;
27         struct bch_sb_field_members *mi = bch2_sb_get_members(sb);
28         unsigned nr_groups = disk_groups_nr(groups);
29         unsigned i, len;
30         int ret = 0;
31
32         for (i = 0; i < sb->nr_devices; i++) {
33                 struct bch_member *m = mi->members + i;
34                 unsigned g;
35
36                 if (!BCH_MEMBER_GROUP(m))
37                         continue;
38
39                 g = BCH_MEMBER_GROUP(m) - 1;
40
41                 if (g >= nr_groups) {
42                         prt_printf(err, "disk %u has invalid label %u (have %u)",
43                                i, g, nr_groups);
44                         return -BCH_ERR_invalid_sb_disk_groups;
45                 }
46
47                 if (BCH_GROUP_DELETED(&groups->entries[g])) {
48                         prt_printf(err, "disk %u has deleted label %u", i, g);
49                         return -BCH_ERR_invalid_sb_disk_groups;
50                 }
51         }
52
53         if (!nr_groups)
54                 return 0;
55
56         for (i = 0; i < nr_groups; i++) {
57                 g = groups->entries + i;
58
59                 if (BCH_GROUP_DELETED(g))
60                         continue;
61
62                 len = strnlen(g->label, sizeof(g->label));
63                 if (!len) {
64                         prt_printf(err, "label %u empty", i);
65                         return -BCH_ERR_invalid_sb_disk_groups;
66                 }
67         }
68
69         sorted = kmalloc_array(nr_groups, sizeof(*sorted), GFP_KERNEL);
70         if (!sorted)
71                 return -BCH_ERR_ENOMEM_disk_groups_validate;
72
73         memcpy(sorted, groups->entries, nr_groups * sizeof(*sorted));
74         sort(sorted, nr_groups, sizeof(*sorted), group_cmp, NULL);
75
76         for (g = sorted; g + 1 < sorted + nr_groups; g++)
77                 if (!BCH_GROUP_DELETED(g) &&
78                     !group_cmp(&g[0], &g[1])) {
79                         prt_printf(err, "duplicate label %llu.%.*s",
80                                BCH_GROUP_PARENT(g),
81                                (int) sizeof(g->label), g->label);
82                         ret = -BCH_ERR_invalid_sb_disk_groups;
83                         goto err;
84                 }
85 err:
86         kfree(sorted);
87         return ret;
88 }
89
90 static void bch2_sb_disk_groups_to_text(struct printbuf *out,
91                                         struct bch_sb *sb,
92                                         struct bch_sb_field *f)
93 {
94         struct bch_sb_field_disk_groups *groups =
95                 field_to_type(f, disk_groups);
96         struct bch_disk_group *g;
97         unsigned nr_groups = disk_groups_nr(groups);
98
99         for (g = groups->entries;
100              g < groups->entries + nr_groups;
101              g++) {
102                 if (g != groups->entries)
103                         prt_printf(out, " ");
104
105                 if (BCH_GROUP_DELETED(g))
106                         prt_printf(out, "[deleted]");
107                 else
108                         prt_printf(out, "[parent %llu name %s]",
109                                BCH_GROUP_PARENT(g), g->label);
110         }
111 }
112
113 const struct bch_sb_field_ops bch_sb_field_ops_disk_groups = {
114         .validate       = bch2_sb_disk_groups_validate,
115         .to_text        = bch2_sb_disk_groups_to_text
116 };
117
118 int bch2_sb_disk_groups_to_cpu(struct bch_fs *c)
119 {
120         struct bch_sb_field_members *mi;
121         struct bch_sb_field_disk_groups *groups;
122         struct bch_disk_groups_cpu *cpu_g, *old_g;
123         unsigned i, g, nr_groups;
124
125         lockdep_assert_held(&c->sb_lock);
126
127         mi              = bch2_sb_get_members(c->disk_sb.sb);
128         groups          = bch2_sb_get_disk_groups(c->disk_sb.sb);
129         nr_groups       = disk_groups_nr(groups);
130
131         if (!groups)
132                 return 0;
133
134         cpu_g = kzalloc(sizeof(*cpu_g) +
135                         sizeof(cpu_g->entries[0]) * nr_groups, GFP_KERNEL);
136         if (!cpu_g)
137                 return -BCH_ERR_ENOMEM_disk_groups_to_cpu;
138
139         cpu_g->nr = nr_groups;
140
141         for (i = 0; i < nr_groups; i++) {
142                 struct bch_disk_group *src      = &groups->entries[i];
143                 struct bch_disk_group_cpu *dst  = &cpu_g->entries[i];
144
145                 dst->deleted    = BCH_GROUP_DELETED(src);
146                 dst->parent     = BCH_GROUP_PARENT(src);
147         }
148
149         for (i = 0; i < c->disk_sb.sb->nr_devices; i++) {
150                 struct bch_member *m = mi->members + i;
151                 struct bch_disk_group_cpu *dst =
152                         &cpu_g->entries[BCH_MEMBER_GROUP(m)];
153
154                 if (!bch2_member_exists(m))
155                         continue;
156
157                 g = BCH_MEMBER_GROUP(m);
158                 while (g) {
159                         dst = &cpu_g->entries[g - 1];
160                         __set_bit(i, dst->devs.d);
161                         g = dst->parent;
162                 }
163         }
164
165         old_g = rcu_dereference_protected(c->disk_groups,
166                                 lockdep_is_held(&c->sb_lock));
167         rcu_assign_pointer(c->disk_groups, cpu_g);
168         if (old_g)
169                 kfree_rcu(old_g, rcu);
170
171         return 0;
172 }
173
174 const struct bch_devs_mask *bch2_target_to_mask(struct bch_fs *c, unsigned target)
175 {
176         struct target t = target_decode(target);
177
178         switch (t.type) {
179         case TARGET_NULL:
180                 return NULL;
181         case TARGET_DEV: {
182                 struct bch_dev *ca = t.dev < c->sb.nr_devices
183                         ? rcu_dereference(c->devs[t.dev])
184                         : NULL;
185                 return ca ? &ca->self : NULL;
186         }
187         case TARGET_GROUP: {
188                 struct bch_disk_groups_cpu *g = rcu_dereference(c->disk_groups);
189
190                 return g && t.group < g->nr && !g->entries[t.group].deleted
191                         ? &g->entries[t.group].devs
192                         : NULL;
193         }
194         default:
195                 BUG();
196         }
197 }
198
199 bool bch2_dev_in_target(struct bch_fs *c, unsigned dev, unsigned target)
200 {
201         struct target t = target_decode(target);
202
203         switch (t.type) {
204         case TARGET_NULL:
205                 return false;
206         case TARGET_DEV:
207                 return dev == t.dev;
208         case TARGET_GROUP: {
209                 struct bch_disk_groups_cpu *g;
210                 const struct bch_devs_mask *m;
211                 bool ret;
212
213                 rcu_read_lock();
214                 g = rcu_dereference(c->disk_groups);
215                 m = g && t.group < g->nr && !g->entries[t.group].deleted
216                         ? &g->entries[t.group].devs
217                         : NULL;
218
219                 ret = m ? test_bit(dev, m->d) : false;
220                 rcu_read_unlock();
221
222                 return ret;
223         }
224         default:
225                 BUG();
226         }
227 }
228
229 static int __bch2_disk_group_find(struct bch_sb_field_disk_groups *groups,
230                                   unsigned parent,
231                                   const char *name, unsigned namelen)
232 {
233         unsigned i, nr_groups = disk_groups_nr(groups);
234
235         if (!namelen || namelen > BCH_SB_LABEL_SIZE)
236                 return -EINVAL;
237
238         for (i = 0; i < nr_groups; i++) {
239                 struct bch_disk_group *g = groups->entries + i;
240
241                 if (BCH_GROUP_DELETED(g))
242                         continue;
243
244                 if (!BCH_GROUP_DELETED(g) &&
245                     BCH_GROUP_PARENT(g) == parent &&
246                     strnlen(g->label, sizeof(g->label)) == namelen &&
247                     !memcmp(name, g->label, namelen))
248                         return i;
249         }
250
251         return -1;
252 }
253
254 static int __bch2_disk_group_add(struct bch_sb_handle *sb, unsigned parent,
255                                  const char *name, unsigned namelen)
256 {
257         struct bch_sb_field_disk_groups *groups =
258                 bch2_sb_get_disk_groups(sb->sb);
259         unsigned i, nr_groups = disk_groups_nr(groups);
260         struct bch_disk_group *g;
261
262         if (!namelen || namelen > BCH_SB_LABEL_SIZE)
263                 return -EINVAL;
264
265         for (i = 0;
266              i < nr_groups && !BCH_GROUP_DELETED(&groups->entries[i]);
267              i++)
268                 ;
269
270         if (i == nr_groups) {
271                 unsigned u64s =
272                         (sizeof(struct bch_sb_field_disk_groups) +
273                          sizeof(struct bch_disk_group) * (nr_groups + 1)) /
274                         sizeof(u64);
275
276                 groups = bch2_sb_resize_disk_groups(sb, u64s);
277                 if (!groups)
278                         return -BCH_ERR_ENOSPC_disk_label_add;
279
280                 nr_groups = disk_groups_nr(groups);
281         }
282
283         BUG_ON(i >= nr_groups);
284
285         g = &groups->entries[i];
286
287         memcpy(g->label, name, namelen);
288         if (namelen < sizeof(g->label))
289                 g->label[namelen] = '\0';
290         SET_BCH_GROUP_DELETED(g, 0);
291         SET_BCH_GROUP_PARENT(g, parent);
292         SET_BCH_GROUP_DATA_ALLOWED(g, ~0);
293
294         return i;
295 }
296
297 int bch2_disk_path_find(struct bch_sb_handle *sb, const char *name)
298 {
299         struct bch_sb_field_disk_groups *groups =
300                 bch2_sb_get_disk_groups(sb->sb);
301         int v = -1;
302
303         do {
304                 const char *next = strchrnul(name, '.');
305                 unsigned len = next - name;
306
307                 if (*next == '.')
308                         next++;
309
310                 v = __bch2_disk_group_find(groups, v + 1, name, len);
311                 name = next;
312         } while (*name && v >= 0);
313
314         return v;
315 }
316
317 int bch2_disk_path_find_or_create(struct bch_sb_handle *sb, const char *name)
318 {
319         struct bch_sb_field_disk_groups *groups;
320         unsigned parent = 0;
321         int v = -1;
322
323         do {
324                 const char *next = strchrnul(name, '.');
325                 unsigned len = next - name;
326
327                 if (*next == '.')
328                         next++;
329
330                 groups = bch2_sb_get_disk_groups(sb->sb);
331
332                 v = __bch2_disk_group_find(groups, parent, name, len);
333                 if (v < 0)
334                         v = __bch2_disk_group_add(sb, parent, name, len);
335                 if (v < 0)
336                         return v;
337
338                 parent = v + 1;
339                 name = next;
340         } while (*name && v >= 0);
341
342         return v;
343 }
344
345 void bch2_disk_path_to_text(struct printbuf *out, struct bch_sb *sb, unsigned v)
346 {
347         struct bch_sb_field_disk_groups *groups =
348                 bch2_sb_get_disk_groups(sb);
349         struct bch_disk_group *g;
350         unsigned nr = 0;
351         u16 path[32];
352
353         while (1) {
354                 if (nr == ARRAY_SIZE(path))
355                         goto inval;
356
357                 if (v >= disk_groups_nr(groups))
358                         goto inval;
359
360                 g = groups->entries + v;
361
362                 if (BCH_GROUP_DELETED(g))
363                         goto inval;
364
365                 path[nr++] = v;
366
367                 if (!BCH_GROUP_PARENT(g))
368                         break;
369
370                 v = BCH_GROUP_PARENT(g) - 1;
371         }
372
373         while (nr) {
374                 v = path[--nr];
375                 g = groups->entries + v;
376
377                 prt_printf(out, "%.*s", (int) sizeof(g->label), g->label);
378                 if (nr)
379                         prt_printf(out, ".");
380         }
381         return;
382 inval:
383         prt_printf(out, "invalid label %u", v);
384 }
385
386 int __bch2_dev_group_set(struct bch_fs *c, struct bch_dev *ca, const char *name)
387 {
388         struct bch_member *mi;
389         int ret, v = -1;
390
391         if (!strlen(name) || !strcmp(name, "none"))
392                 return 0;
393
394         v = bch2_disk_path_find_or_create(&c->disk_sb, name);
395         if (v < 0)
396                 return v;
397
398         ret = bch2_sb_disk_groups_to_cpu(c);
399         if (ret)
400                 return ret;
401
402         mi = &bch2_sb_get_members(c->disk_sb.sb)->members[ca->dev_idx];
403         SET_BCH_MEMBER_GROUP(mi, v + 1);
404         return 0;
405 }
406
407 int bch2_dev_group_set(struct bch_fs *c, struct bch_dev *ca, const char *name)
408 {
409         int ret;
410
411         mutex_lock(&c->sb_lock);
412         ret = __bch2_dev_group_set(c, ca, name) ?:
413                 bch2_write_super(c);
414         mutex_unlock(&c->sb_lock);
415
416         return ret;
417 }
418
419 int bch2_opt_target_parse(struct bch_fs *c, const char *buf, u64 *v)
420 {
421         struct bch_dev *ca;
422         int g;
423
424         if (!strlen(buf) || !strcmp(buf, "none")) {
425                 *v = 0;
426                 return 0;
427         }
428
429         /* Is it a device? */
430         ca = bch2_dev_lookup(c, buf);
431         if (!IS_ERR(ca)) {
432                 *v = dev_to_target(ca->dev_idx);
433                 percpu_ref_put(&ca->ref);
434                 return 0;
435         }
436
437         mutex_lock(&c->sb_lock);
438         g = bch2_disk_path_find(&c->disk_sb, buf);
439         mutex_unlock(&c->sb_lock);
440
441         if (g >= 0) {
442                 *v = group_to_target(g);
443                 return 0;
444         }
445
446         return -EINVAL;
447 }
448
449 void bch2_opt_target_to_text(struct printbuf *out,
450                              struct bch_fs *c,
451                              struct bch_sb *sb,
452                              u64 v)
453 {
454         struct target t = target_decode(v);
455
456         switch (t.type) {
457         case TARGET_NULL:
458                 prt_printf(out, "none");
459                 break;
460         case TARGET_DEV:
461                 if (c) {
462                         struct bch_dev *ca;
463
464                         rcu_read_lock();
465                         ca = t.dev < c->sb.nr_devices
466                                 ? rcu_dereference(c->devs[t.dev])
467                                 : NULL;
468
469                         if (ca && percpu_ref_tryget(&ca->io_ref)) {
470                                 prt_printf(out, "/dev/%pg", ca->disk_sb.bdev);
471                                 percpu_ref_put(&ca->io_ref);
472                         } else if (ca) {
473                                 prt_printf(out, "offline device %u", t.dev);
474                         } else {
475                                 prt_printf(out, "invalid device %u", t.dev);
476                         }
477
478                         rcu_read_unlock();
479                 } else {
480                         struct bch_sb_field_members *mi = bch2_sb_get_members(sb);
481                         struct bch_member *m = mi->members + t.dev;
482
483                         if (bch2_dev_exists(sb, mi, t.dev)) {
484                                 prt_printf(out, "Device ");
485                                 pr_uuid(out, m->uuid.b);
486                                 prt_printf(out, " (%u)", t.dev);
487                         } else {
488                                 prt_printf(out, "Bad device %u", t.dev);
489                         }
490                 }
491                 break;
492         case TARGET_GROUP:
493                 if (c) {
494                         mutex_lock(&c->sb_lock);
495                         bch2_disk_path_to_text(out, c->disk_sb.sb, t.group);
496                         mutex_unlock(&c->sb_lock);
497                 } else {
498                         bch2_disk_path_to_text(out, sb, t.group);
499                 }
500                 break;
501         default:
502                 BUG();
503         }
504 }