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