git.sesse.net Git - bcachefs-tools-debian/blob - cmd_fs.c

   1
   2 #include <stdio.h>
   3 #include <sys/ioctl.h>
   4
   5 #include <uuid/uuid.h>
   6
   7 #include "linux/sort.h"
   8
   9 #include "libbcachefs/bcachefs_ioctl.h"
  10 #include "libbcachefs/darray.h"
  11 #include "libbcachefs/opts.h"
  12
  13 #include "cmds.h"
  14 #include "libbcachefs.h"
  15
  16 static void __dev_usage_type_to_text(struct printbuf *out,
  17                                      const char *type,
  18                                      unsigned bucket_size,
  19                                      u64 buckets, u64 sectors, u64 frag)
  20 {
  21         pr_buf(out, "%s:", type);
  22         pr_tab(out);
  23
  24         pr_sectors(out, sectors);
  25         pr_tab_rjust(out);
  26
  27         pr_buf(out, "%llu", buckets);
  28         pr_tab_rjust(out);
  29
  30         if (frag) {
  31                 pr_sectors(out, frag);
  32                 pr_tab_rjust(out);
  33         }
  34         pr_newline(out);
  35 }
  36
  37 static void dev_usage_type_to_text(struct printbuf *out,
  38                                    struct bch_ioctl_dev_usage *u,
  39                                    enum bch_data_type type)
  40 {
  41         __dev_usage_type_to_text(out, bch2_data_types[type],
  42                         u->bucket_size,
  43                         u->d[type].buckets,
  44                         u->d[type].sectors,
  45                         u->d[type].fragmented);
  46 }
  47
  48 static void dev_usage_to_text(struct printbuf *out,
  49                               struct bchfs_handle fs,
  50                               struct dev_name *d)
  51 {
  52         struct bch_ioctl_dev_usage u = bchu_dev_usage(fs, d->idx);
  53         unsigned i;
  54
  55         pr_newline(out);
  56         pr_buf(out, "%s (device %u):", d->label ?: "(no label)", d->idx);
  57         pr_tab(out);
  58         pr_buf(out, "%s", d->dev ?: "(device not found)");
  59         pr_tab_rjust(out);
  60
  61         pr_buf(out, "%s", bch2_member_states[u.state]);
  62         pr_tab_rjust(out);
  63
  64         pr_newline(out);
  65
  66         pr_indent_push(out, 2);
  67         pr_tab(out);
  68
  69         pr_buf(out, "data");
  70         pr_tab_rjust(out);
  71
  72         pr_buf(out, "buckets");
  73         pr_tab_rjust(out);
  74
  75         pr_buf(out, "fragmented");
  76         pr_tab_rjust(out);
  77
  78         pr_newline(out);
  79
  80         for (i = 0; i < BCH_DATA_NR; i++)
  81                 dev_usage_type_to_text(out, &u, i);
  82         __dev_usage_type_to_text(out, "erasure coded",
  83                                  u.bucket_size,
  84                                  u.buckets_ec, u.buckets_ec * u.bucket_size, 0);
  85
  86         pr_buf(out, "capacity:");
  87         pr_tab(out);
  88
  89         pr_sectors(out, u.nr_buckets * u.bucket_size);
  90         pr_tab_rjust(out);
  91         pr_buf(out, "%llu", u.nr_buckets);
  92         pr_tab_rjust(out);
  93
  94         pr_indent_pop(out, 2);
  95
  96         pr_newline(out);
  97 }
  98
  99 static int dev_by_label_cmp(const void *_l, const void *_r)
 100 {
 101         const struct dev_name *l = _l, *r = _r;
 102
 103         return  (l->label && r->label
 104                  ? strcmp(l->label, r->label) : 0) ?:
 105                 (l->dev && r->dev
 106                  ? strcmp(l->dev, r->dev) : 0) ?:
 107                 cmp_int(l->idx, r->idx);
 108 }
 109
 110 static struct dev_name *dev_idx_to_name(dev_names *dev_names, unsigned idx)
 111 {
 112         struct dev_name *dev;
 113
 114         darray_for_each(*dev_names, dev)
 115                 if (dev->idx == idx)
 116                         return dev;
 117
 118         return NULL;
 119 }
 120
 121 static void replicas_usage_to_text(struct printbuf *out,
 122                                    const struct bch_replicas_usage *r,
 123                                    dev_names *dev_names)
 124 {
 125         unsigned i;
 126
 127         if (!r->sectors)
 128                 return;
 129
 130         char devs[4096], *d = devs;
 131         *d++ = '[';
 132
 133         for (i = 0; i < r->r.nr_devs; i++) {
 134                 unsigned dev_idx = r->r.devs[i];
 135                 struct dev_name *dev = dev_idx_to_name(dev_names, dev_idx);
 136
 137                 if (i)
 138                         *d++ = ' ';
 139
 140                 d += dev && dev->dev
 141                         ? sprintf(d, "%s", dev->dev)
 142                         : sprintf(d, "%u", dev_idx);
 143         }
 144         *d++ = ']';
 145         *d++ = '\0';
 146
 147         pr_buf(out, "%s: ", bch2_data_types[r->r.data_type]);
 148         pr_tab(out);
 149
 150         pr_buf(out, "%u/%u ", r->r.nr_required, r->r.nr_devs);
 151         pr_tab(out);
 152
 153         pr_buf(out, "%s ", devs);
 154         pr_tab(out);
 155
 156         pr_sectors(out, r->sectors);
 157         pr_tab_rjust(out);
 158         pr_newline(out);
 159 }
 160
 161 #define for_each_usage_replica(_u, _r)                                  \
 162         for (_r = (_u)->replicas;                                       \
 163              _r != (void *) (_u)->replicas + (_u)->replica_entries_bytes;\
 164              _r = replicas_usage_next(_r),                              \
 165              BUG_ON((void *) _r > (void *) (_u)->replicas + (_u)->replica_entries_bytes))
 166
 167 static void fs_usage_to_text(struct printbuf *out, const char *path)
 168 {
 169         unsigned i;
 170
 171         struct bchfs_handle fs = bcache_fs_open(path);
 172
 173         struct dev_name *dev;
 174         dev_names dev_names = bchu_fs_get_devices(fs);
 175
 176         struct bch_ioctl_fs_usage *u = bchu_fs_usage(fs);
 177
 178         pr_buf(out, "Filesystem: ");
 179         pr_uuid(out, fs.uuid.b);
 180         pr_newline(out);
 181
 182         out->tabstops[0] = 20;
 183         out->tabstops[1] = 36;
 184
 185         pr_buf(out, "Size:");
 186         pr_tab(out);
 187         pr_sectors(out, u->capacity);
 188         pr_tab_rjust(out);
 189         pr_newline(out);
 190
 191         pr_buf(out, "Used:");
 192         pr_tab(out);
 193         pr_sectors(out, u->used);
 194         pr_tab_rjust(out);
 195         pr_newline(out);
 196
 197         pr_buf(out, "Online reserved:");
 198         pr_tab(out);
 199         pr_sectors(out, u->online_reserved);
 200         pr_tab_rjust(out);
 201         pr_newline(out);
 202
 203         pr_newline(out);
 204
 205         out->tabstops[0] = 16;
 206         out->tabstops[1] = 32;
 207         out->tabstops[2] = 50;
 208         out->tabstops[3] = 68;
 209
 210         pr_buf(out, "Data type");
 211         pr_tab(out);
 212
 213         pr_buf(out, "Required/total");
 214         pr_tab(out);
 215
 216         pr_buf(out, "Devices");
 217         pr_newline(out);
 218
 219         for (i = 0; i < BCH_REPLICAS_MAX; i++) {
 220                 if (!u->persistent_reserved[i])
 221                         continue;
 222
 223                 pr_buf(out, "reserved:");
 224                 pr_tab(out);
 225                 pr_buf(out, "%u/%u ", 1, i);
 226                 pr_tab(out);
 227                 pr_buf(out, "[] ");
 228                 pr_sectors(out, u->persistent_reserved[i]);
 229                 pr_tab_rjust(out);
 230                 pr_newline(out);
 231         }
 232
 233         struct bch_replicas_usage *r;
 234
 235         for_each_usage_replica(u, r)
 236                 if (r->r.data_type < BCH_DATA_user)
 237                         replicas_usage_to_text(out, r, &dev_names);
 238
 239         for_each_usage_replica(u, r)
 240                 if (r->r.data_type == BCH_DATA_user &&
 241                     r->r.nr_required <= 1)
 242                         replicas_usage_to_text(out, r, &dev_names);
 243
 244         for_each_usage_replica(u, r)
 245                 if (r->r.data_type == BCH_DATA_user &&
 246                     r->r.nr_required > 1)
 247                         replicas_usage_to_text(out, r, &dev_names);
 248
 249         for_each_usage_replica(u, r)
 250                 if (r->r.data_type > BCH_DATA_user)
 251                         replicas_usage_to_text(out, r, &dev_names);
 252
 253         free(u);
 254
 255         sort(dev_names.data, dev_names.nr,
 256              sizeof(dev_names.data[0]), dev_by_label_cmp, NULL);
 257
 258         out->tabstops[0] = 16;
 259         out->tabstops[1] = 36;
 260         out->tabstops[2] = 52;
 261         out->tabstops[3] = 68;
 262
 263         darray_for_each(dev_names, dev)
 264                 dev_usage_to_text(out, fs, dev);
 265
 266         darray_for_each(dev_names, dev) {
 267                 free(dev->dev);
 268                 free(dev->label);
 269         }
 270         darray_exit(dev_names);
 271
 272         bcache_fs_close(fs);
 273 }
 274
 275 int fs_usage(void)
 276 {
 277        puts("bcachefs fs - manage a running filesystem\n"
 278             "Usage: bcachefs fs <CMD> [OPTION]... path\n"
 279             "\n"
 280             "Commands:\n"
 281             "  usage                      show disk usage\n"
 282             "\n"
 283             "Report bugs to <linux-bcachefs@vger.kernel.org>");
 284        return 0;
 285 }
 286
 287 int cmd_fs_usage(int argc, char *argv[])
 288 {
 289         enum printbuf_units units = PRINTBUF_UNITS_BYTES;
 290         struct printbuf buf = PRINTBUF;
 291         char *fs;
 292         int opt;
 293
 294         while ((opt = getopt(argc, argv, "h")) != -1)
 295                 switch (opt) {
 296                 case 'h':
 297                         units = PRINTBUF_UNITS_HUMAN_READABLE;
 298                         break;
 299                 }
 300         args_shift(optind);
 301
 302         if (!argc) {
 303                 printbuf_reset(&buf);
 304                 buf.units = units;
 305                 fs_usage_to_text(&buf, ".");
 306                 printf("%s", buf.buf);
 307         } else {
 308                 while ((fs = arg_pop())) {
 309                         printbuf_reset(&buf);
 310                         buf.units = units;
 311                         fs_usage_to_text(&buf, fs);
 312                         printf("%s", buf.buf);
 313                 }
 314         }
 315
 316         printbuf_exit(&buf);
 317         return 0;
 318 }