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

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