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