sbin/bectl/bectl_list.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 #include <be.h>
  38
  39 #include "bectl.h"
  40
  41 struct sort_column {
  42         char *name;
  43         char *val;
  44         nvlist_t *nvl;
  45 };
  46
  47 struct printc {
  48         int     active_colsz_def;
  49         int     be_colsz;
  50         int     current_indent;
  51         int     mount_colsz;
  52         int     space_colsz;
  53         bool    script_fmt;
  54         bool    show_all_datasets;
  55         bool    show_snaps;
  56         bool    show_space;
  57 };
  58
  59 static const char *get_origin_props(nvlist_t *dsprops, nvlist_t **originprops);
  60 static void print_padding(const char *fval, int colsz, struct printc *pc);
  61 static int print_snapshots(const char *dsname, struct printc *pc);
  62 static void print_info(const char *name, nvlist_t *dsprops, struct printc *pc);
  63 static void print_headers(nvlist_t *props, struct printc *pc);
  64 static unsigned long long dataset_space(const char *oname);
  65
  66 #define HEADER_BE       "BE"
  67 #define HEADER_BEPLUS   "BE/Dataset/Snapshot"
  68 #define HEADER_ACTIVE   "Active"
  69 #define HEADER_MOUNT    "Mountpoint"
  70 #define HEADER_SPACE    "Space"
  71 #define HEADER_CREATED  "Created"
  72
  73 /* Spaces */
  74 #define INDENT_INCREMENT        2
  75
  76 /*
  77  * Given a set of dataset properties (for a BE dataset), populate originprops
  78  * with the origin's properties.
  79  */
  80 static const char *
  81 get_origin_props(nvlist_t *dsprops, nvlist_t **originprops)
  82 {
  83         char *propstr;
  84
  85         if (nvlist_lookup_string(dsprops, "origin", &propstr) == 0) {
  86                 if (be_prop_list_alloc(originprops) != 0) {
  87                         fprintf(stderr,
  88                             "bectl list: failed to allocate origin prop nvlist\n");
  89                         return (NULL);
  90                 }
  91                 if (be_get_dataset_props(be, propstr, *originprops) != 0) {
  92                         /* XXX TODO: Real errors */
  93                         fprintf(stderr,
  94                             "bectl list: failed to fetch origin properties\n");
  95                         return (NULL);
  96                 }
  97
  98                 return (propstr);
  99         }
 100         return (NULL);
 101 }
 102
 103 static void
 104 print_padding(const char *fval, int colsz, struct printc *pc)
 105 {
 106
 107         /* -H flag handling; all delimiters/padding are a single tab */
 108         if (pc->script_fmt) {
 109                 printf("\t");
 110                 return;
 111         }
 112
 113         if (fval != NULL)
 114                 colsz -= strlen(fval);
 115         printf("%*s ", colsz, "");
 116 }
 117
 118 static unsigned long long
 119 dataset_space(const char *oname)
 120 {
 121         unsigned long long space;
 122         char *dsname, *propstr, *sep;
 123         nvlist_t *dsprops;
 124
 125         space = 0;
 126         dsname = strdup(oname);
 127         if (dsname == NULL)
 128                 return (0);
 129
 130         /* Truncate snapshot to dataset name, as needed */
 131         if ((sep = strchr(dsname, '@')) != NULL)
 132                 *sep = '\0';
 133
 134         if (be_prop_list_alloc(&dsprops) != 0) {
 135                 free(dsname);
 136                 return (0);
 137         }
 138
 139         if (be_get_dataset_props(be, dsname, dsprops) != 0) {
 140                 nvlist_free(dsprops);
 141                 free(dsname);
 142                 return (0);
 143         }
 144
 145         if (nvlist_lookup_string(dsprops, "used", &propstr) == 0)
 146                 space = strtoull(propstr, NULL, 10);
 147
 148         nvlist_free(dsprops);
 149         free(dsname);
 150         return (space);
 151 }
 152
 153 static int
 154 print_snapshots(const char *dsname, struct printc *pc)
 155 {
 156         nvpair_t *cur;
 157         nvlist_t *props, *sprops;
 158
 159         if (be_prop_list_alloc(&props) != 0) {
 160                 fprintf(stderr, "bectl list: failed to allocate snapshot nvlist\n");
 161                 return (1);
 162         }
 163         if (be_get_dataset_snapshots(be, dsname, props) != 0) {
 164                 fprintf(stderr, "bectl list: failed to fetch boot ds snapshots\n");
 165                 return (1);
 166         }
 167         for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
 168             cur = nvlist_next_nvpair(props, cur)) {
 169                 nvpair_value_nvlist(cur, &sprops);
 170                 print_info(nvpair_name(cur), sprops, pc);
 171         }
 172         return (0);
 173 }
 174
 175 static void
 176 print_info(const char *name, nvlist_t *dsprops, struct printc *pc)
 177 {
 178 #define BUFSZ   64
 179         char buf[BUFSZ];
 180         unsigned long long ctimenum, space;
 181         nvlist_t *originprops;
 182         const char *oname;
 183         char *dsname, *propstr;
 184         int active_colsz;
 185         boolean_t active_now, active_reboot, bootonce;
 186
 187         dsname = NULL;
 188         originprops = NULL;
 189         printf("%*s%s", pc->current_indent, "", name);
 190         nvlist_lookup_string(dsprops, "dataset", &dsname);
 191
 192         /* Recurse at the base level if we're breaking info down */
 193         if (pc->current_indent == 0 && (pc->show_all_datasets ||
 194             pc->show_snaps)) {
 195                 printf("\n");
 196                 if (dsname == NULL)
 197                         /* XXX TODO: Error? */
 198                         return;
 199                 /*
 200                  * Whether we're dealing with -a or -s, we'll always print the
 201                  * dataset name/information followed by its origin. For -s, we
 202                  * additionally iterate through all snapshots of this boot
 203                  * environment and also print their information.
 204                  */
 205                 pc->current_indent += INDENT_INCREMENT;
 206                 print_info(dsname, dsprops, pc);
 207                 pc->current_indent += INDENT_INCREMENT;
 208                 if ((oname = get_origin_props(dsprops, &originprops)) != NULL) {
 209                         print_info(oname, originprops, pc);
 210                         nvlist_free(originprops);
 211                 }
 212
 213                 /* Back up a level; snapshots at the same level as dataset */
 214                 pc->current_indent -= INDENT_INCREMENT;
 215                 if (pc->show_snaps)
 216                         print_snapshots(dsname, pc);
 217                 pc->current_indent = 0;
 218                 return;
 219         } else
 220                 print_padding(name, pc->be_colsz - pc->current_indent, pc);
 221
 222         active_colsz = pc->active_colsz_def;
 223         if (nvlist_lookup_boolean_value(dsprops, "active",
 224             &active_now) == 0 && active_now) {
 225                 printf("N");
 226                 active_colsz--;
 227         }
 228         if (nvlist_lookup_boolean_value(dsprops, "nextboot",
 229             &active_reboot) == 0 && active_reboot) {
 230                 printf("R");
 231                 active_colsz--;
 232         }
 233         if (nvlist_lookup_boolean_value(dsprops, "bootonce",
 234             &bootonce) == 0 && bootonce) {
 235                 printf("T");
 236                 active_colsz--;
 237         }
 238         if (active_colsz == pc->active_colsz_def) {
 239                 printf("-");
 240                 active_colsz--;
 241         }
 242         print_padding(NULL, active_colsz, pc);
 243         if (nvlist_lookup_string(dsprops, "mounted", &propstr) == 0) {
 244                 printf("%s", propstr);
 245                 print_padding(propstr, pc->mount_colsz, pc);
 246         } else {
 247                 printf("%s", "-");
 248                 print_padding("-", pc->mount_colsz, pc);
 249         }
 250
 251         oname = get_origin_props(dsprops, &originprops);
 252         if (nvlist_lookup_string(dsprops, "used", &propstr) == 0) {
 253                 /*
 254                  * The space used column is some composition of:
 255                  * - The "used" property of the dataset
 256                  * - The "used" property of the origin snapshot (not -a or -s)
 257                  * - The "used" property of the origin dataset (-D flag only)
 258                  *
 259                  * The -D flag is ignored if -a or -s are specified.
 260                  */
 261                 space = strtoull(propstr, NULL, 10);
 262
 263                 if (!pc->show_all_datasets && !pc->show_snaps &&
 264                     originprops != NULL &&
 265                     nvlist_lookup_string(originprops, "used", &propstr) == 0)
 266                         space += strtoull(propstr, NULL, 10);
 267
 268                 if (pc->show_space && oname != NULL)
 269                         space += dataset_space(oname);
 270
 271                 /* Alas, there's more to it,. */
 272                 be_nicenum(space, buf, 6);
 273                 printf("%s", buf);
 274                 print_padding(buf, pc->space_colsz, pc);
 275         } else {
 276                 printf("-");
 277                 print_padding("-", pc->space_colsz, pc);
 278         }
 279
 280         if (nvlist_lookup_string(dsprops, "creation", &propstr) == 0) {
 281                 ctimenum = strtoull(propstr, NULL, 10);
 282                 strftime(buf, BUFSZ, "%Y-%m-%d %H:%M",
 283                     localtime((time_t *)&ctimenum));
 284                 printf("%s", buf);
 285         }
 286
 287         printf("\n");
 288         if (originprops != NULL)
 289                 be_prop_list_free(originprops);
 290 #undef BUFSZ
 291 }
 292
 293 static void
 294 print_headers(nvlist_t *props, struct printc *pc)
 295 {
 296         const char *chosen_be_header;
 297         nvpair_t *cur;
 298         nvlist_t *dsprops;
 299         char *propstr;
 300         size_t be_maxcol, mount_colsz;
 301
 302         if (pc->show_all_datasets || pc->show_snaps)
 303                 chosen_be_header = HEADER_BEPLUS;
 304         else
 305                 chosen_be_header = HEADER_BE;
 306         be_maxcol = strlen(chosen_be_header);
 307         mount_colsz = strlen(HEADER_MOUNT);
 308         for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
 309             cur = nvlist_next_nvpair(props, cur)) {
 310                 be_maxcol = MAX(be_maxcol, strlen(nvpair_name(cur)));
 311                 nvpair_value_nvlist(cur, &dsprops);
 312
 313                 if (nvlist_lookup_string(dsprops, "mounted", &propstr) == 0)
 314                         mount_colsz = MAX(mount_colsz, strlen(propstr));
 315                 if (!pc->show_all_datasets && !pc->show_snaps)
 316                         continue;
 317                 if (nvlist_lookup_string(dsprops, "dataset", &propstr) != 0)
 318                         continue;
 319                 be_maxcol = MAX(be_maxcol, strlen(propstr) + INDENT_INCREMENT);
 320                 if (nvlist_lookup_string(dsprops, "origin", &propstr) != 0)
 321                         continue;
 322                 be_maxcol = MAX(be_maxcol,
 323                     strlen(propstr) + INDENT_INCREMENT * 2);
 324         }
 325
 326         pc->be_colsz = be_maxcol;
 327         pc->active_colsz_def = strlen(HEADER_ACTIVE);
 328         pc->mount_colsz = mount_colsz;
 329         pc->space_colsz = strlen(HEADER_SPACE);
 330         printf("%*s %s %*s %s %s\n", -pc->be_colsz, chosen_be_header,
 331             HEADER_ACTIVE, -pc->mount_colsz, HEADER_MOUNT, HEADER_SPACE, HEADER_CREATED);
 332
 333         /*
 334          * All other invocations in which we aren't using the default header
 335          * will produce quite a bit of input.  Throw an extra blank line after
 336          * the header to make it look nicer.
 337          */
 338         if (strcmp(chosen_be_header, HEADER_BE) != 0)
 339                 printf("\n");
 340 }
 341
 342 /*
 343  * Sort the given nvlist of boot environments by property.
 344  */
 345 static int
 346 prop_list_sort(nvlist_t *props, char *property, bool reverse)
 347 {
 348         nvpair_t *nvp;
 349         nvlist_t *nvl;
 350         int i, nvp_count;
 351         uint64_t lval, rval;
 352         struct sort_column sc_prev, sc_next;
 353
 354         /* a temporary list to work with */
 355         nvlist_dup(props, &nvl, 0);
 356
 357         nvp_count = fnvlist_num_pairs(nvl);
 358         for (i = 0; i < nvp_count; i++) {
 359
 360                 nvp = nvlist_next_nvpair(nvl, NULL);
 361                 nvpair_value_nvlist(nvp, &sc_prev.nvl);
 362                 nvlist_lookup_string(sc_prev.nvl, "name", &sc_prev.name);
 363                 nvlist_lookup_string(sc_prev.nvl, property, &sc_prev.val);
 364
 365                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
 366
 367                         nvpair_value_nvlist(nvp, &sc_next.nvl);
 368                         nvlist_lookup_string(sc_next.nvl, "name", &sc_next.name);
 369                         nvlist_lookup_string(sc_next.nvl, property, &sc_next.val);
 370
 371                         /* properties that use numerical comparison */
 372                         if (strcmp(property, "creation") == 0 ||
 373                             strcmp(property, "used") == 0 ||
 374                             strcmp(property, "usedds") == 0 ||
 375                             strcmp(property, "usedsnap") == 0 ||
 376                             strcmp(property, "usedrefreserv") == 0) {
 377
 378                                 lval = strtoull(sc_prev.val, NULL, 10);
 379                                 rval = strtoull(sc_next.val, NULL, 10);
 380
 381                                 if ((lval < rval && reverse) ||
 382                                     (lval > rval && !reverse))
 383                                         sc_prev = sc_next;
 384                         }
 385
 386                         /* properties that use string comparison */
 387                         else if (strcmp(property, "name") == 0 ||
 388                                  strcmp(property, "origin") == 0) {
 389                                 if ((strcmp(sc_prev.val, sc_next.val) < 0 && reverse) ||
 390                                     (strcmp(sc_prev.val, sc_next.val) > 0 && !reverse))
 391                                         sc_prev = sc_next;
 392                         }
 393                 }
 394
 395                 /*
 396                  * The 'props' nvlist has been created to only have unique names.
 397                  * When a name is added, any existing nvlist's with the same name
 398                  * will be removed. Eventually, all existing nvlist's are replaced
 399                  * in sorted order.
 400                  */
 401                 nvlist_add_nvlist(props, sc_prev.name, sc_prev.nvl);
 402                 nvlist_remove_all(nvl, sc_prev.name);
 403         }
 404
 405         be_prop_list_free(nvl);
 406
 407         return 0;
 408 }
 409
 410 int
 411 bectl_cmd_list(int argc, char *argv[])
 412 {
 413         struct printc pc;
 414         nvpair_t *cur;
 415         nvlist_t *dsprops, *props;
 416         int opt, printed;
 417         char *column;
 418         bool reverse;
 419
 420         column = NULL;
 421         props = NULL;
 422         printed = 0;
 423         bzero(&pc, sizeof(pc));
 424         reverse = false;
 425         while ((opt = getopt(argc, argv, "aDHsc:C:")) != -1) {
 426                 switch (opt) {
 427                 case 'a':
 428                         pc.show_all_datasets = true;
 429                         break;
 430                 case 'D':
 431                         pc.show_space = true;
 432                         break;
 433                 case 'H':
 434                         pc.script_fmt = true;
 435                         break;
 436                 case 's':
 437                         pc.show_snaps = true;
 438                         break;
 439                 case 'c':
 440                         if (column != NULL)
 441                                 free(column);
 442                         column = strdup(optarg);
 443                         reverse = false;
 444                         break;
 445                 case 'C':
 446                         if (column != NULL)
 447                                 free(column);
 448                         column = strdup(optarg);
 449                         reverse = true;
 450                         break;
 451                 default:
 452                         fprintf(stderr, "bectl list: unknown option '-%c'\n",
 453                             optopt);
 454                         return (usage(false));
 455                 }
 456         }
 457
 458         argc -= optind;
 459
 460         if (argc != 0) {
 461                 fprintf(stderr, "bectl list: extra argument provided\n");
 462                 return (usage(false));
 463         }
 464
 465         if (be_prop_list_alloc(&props) != 0) {
 466                 fprintf(stderr, "bectl list: failed to allocate prop nvlist\n");
 467                 return (1);
 468         }
 469         if (be_get_bootenv_props(be, props) != 0) {
 470                 /* XXX TODO: Real errors */
 471                 fprintf(stderr, "bectl list: failed to fetch boot environments\n");
 472                 return (1);
 473         }
 474
 475         /* List boot environments in alphabetical order by default */
 476         if (column == NULL)
 477                 column = strdup("name");
 478
 479         prop_list_sort(props, column, reverse);
 480
 481         /* Force -D off if either -a or -s are specified */
 482         if (pc.show_all_datasets || pc.show_snaps)
 483                 pc.show_space = false;
 484         if (!pc.script_fmt)
 485                 print_headers(props, &pc);
 486
 487         /* Print boot environments */
 488         for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
 489             cur = nvlist_next_nvpair(props, cur)) {
 490                 nvpair_value_nvlist(cur, &dsprops);
 491
 492                 if (printed > 0 && (pc.show_all_datasets || pc.show_snaps))
 493                         printf("\n");
 494
 495                 print_info(nvpair_name(cur), dsprops, &pc);
 496                 printed++;
 497         }
 498
 499         free(column);
 500         be_prop_list_free(props);
 501
 502         return (0);
 503 }
 504