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;
 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 (active_colsz == pc->active_colsz_def) {
 234                 printf("-");
 235                 active_colsz--;
 236         }
 237         print_padding(NULL, active_colsz, pc);
 238         if (nvlist_lookup_string(dsprops, "mounted", &propstr) == 0) {
 239                 printf("%s", propstr);
 240                 print_padding(propstr, pc->mount_colsz, pc);
 241         } else {
 242                 printf("%s", "-");
 243                 print_padding("-", pc->mount_colsz, pc);
 244         }
 245
 246         oname = get_origin_props(dsprops, &originprops);
 247         if (nvlist_lookup_string(dsprops, "used", &propstr) == 0) {
 248                 /*
 249                  * The space used column is some composition of:
 250                  * - The "used" property of the dataset
 251                  * - The "used" property of the origin snapshot (not -a or -s)
 252                  * - The "used" property of the origin dataset (-D flag only)
 253                  *
 254                  * The -D flag is ignored if -a or -s are specified.
 255                  */
 256                 space = strtoull(propstr, NULL, 10);
 257
 258                 if (!pc->show_all_datasets && !pc->show_snaps &&
 259                     originprops != NULL &&
 260                     nvlist_lookup_string(originprops, "used", &propstr) == 0)
 261                         space += strtoull(propstr, NULL, 10);
 262
 263                 if (pc->show_space && oname != NULL)
 264                         space += dataset_space(oname);
 265
 266                 /* Alas, there's more to it,. */
 267                 be_nicenum(space, buf, 6);
 268                 printf("%s", buf);
 269                 print_padding(buf, pc->space_colsz, pc);
 270         } else {
 271                 printf("-");
 272                 print_padding("-", pc->space_colsz, pc);
 273         }
 274
 275         if (nvlist_lookup_string(dsprops, "creation", &propstr) == 0) {
 276                 ctimenum = strtoull(propstr, NULL, 10);
 277                 strftime(buf, BUFSZ, "%Y-%m-%d %H:%M",
 278                     localtime((time_t *)&ctimenum));
 279                 printf("%s", buf);
 280         }
 281
 282         printf("\n");
 283         if (originprops != NULL)
 284                 be_prop_list_free(originprops);
 285 #undef BUFSZ
 286 }
 287
 288 static void
 289 print_headers(nvlist_t *props, struct printc *pc)
 290 {
 291         const char *chosen_be_header;
 292         nvpair_t *cur;
 293         nvlist_t *dsprops;
 294         char *propstr;
 295         size_t be_maxcol;
 296
 297         if (pc->show_all_datasets || pc->show_snaps)
 298                 chosen_be_header = HEADER_BEPLUS;
 299         else
 300                 chosen_be_header = HEADER_BE;
 301         be_maxcol = strlen(chosen_be_header);
 302         for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
 303             cur = nvlist_next_nvpair(props, cur)) {
 304                 be_maxcol = MAX(be_maxcol, strlen(nvpair_name(cur)));
 305                 if (!pc->show_all_datasets && !pc->show_snaps)
 306                         continue;
 307                 nvpair_value_nvlist(cur, &dsprops);
 308                 if (nvlist_lookup_string(dsprops, "dataset", &propstr) != 0)
 309                         continue;
 310                 be_maxcol = MAX(be_maxcol, strlen(propstr) + INDENT_INCREMENT);
 311                 if (nvlist_lookup_string(dsprops, "origin", &propstr) != 0)
 312                         continue;
 313                 be_maxcol = MAX(be_maxcol,
 314                     strlen(propstr) + INDENT_INCREMENT * 2);
 315         }
 316
 317         pc->be_colsz = be_maxcol;
 318         pc->active_colsz_def = strlen(HEADER_ACTIVE);
 319         pc->mount_colsz = strlen(HEADER_MOUNT);
 320         pc->space_colsz = strlen(HEADER_SPACE);
 321         printf("%*s %s %s %s %s\n", -pc->be_colsz, chosen_be_header,
 322             HEADER_ACTIVE, HEADER_MOUNT, HEADER_SPACE, HEADER_CREATED);
 323
 324         /*
 325          * All other invocations in which we aren't using the default header
 326          * will produce quite a bit of input.  Throw an extra blank line after
 327          * the header to make it look nicer.
 328          */
 329         if (strcmp(chosen_be_header, HEADER_BE) != 0)
 330                 printf("\n");
 331 }
 332
 333 /*
 334  * Sort the given nvlist of boot environments by property.
 335  */
 336 static int
 337 prop_list_sort(nvlist_t *props, char *property, bool reverse)
 338 {
 339         nvpair_t *nvp;
 340         nvlist_t *nvl;
 341         int i, nvp_count;
 342         uint64_t lval, rval;
 343         struct sort_column sc_prev, sc_next;
 344
 345         /* a temporary list to work with */
 346         nvlist_dup(props, &nvl, 0);
 347
 348         nvp_count = fnvlist_num_pairs(nvl);
 349         for (i = 0; i < nvp_count; i++) {
 350
 351                 nvp = nvlist_next_nvpair(nvl, NULL);
 352                 nvpair_value_nvlist(nvp, &sc_prev.nvl);
 353                 nvlist_lookup_string(sc_prev.nvl, "name", &sc_prev.name);
 354                 nvlist_lookup_string(sc_prev.nvl, property, &sc_prev.val);
 355
 356                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
 357
 358                         nvpair_value_nvlist(nvp, &sc_next.nvl);
 359                         nvlist_lookup_string(sc_next.nvl, "name", &sc_next.name);
 360                         nvlist_lookup_string(sc_next.nvl, property, &sc_next.val);
 361
 362                         /* properties that use numerical comparison */
 363                         if (strcmp(property, "creation") == 0 ||
 364                             strcmp(property, "used") == 0 ||
 365                             strcmp(property, "usedds") == 0 ||
 366                             strcmp(property, "usedsnap") == 0 ||
 367                             strcmp(property, "usedrefreserv") == 0) {
 368
 369                                 lval = strtoull(sc_prev.val, NULL, 10);
 370                                 rval = strtoull(sc_next.val, NULL, 10);
 371
 372                                 if ((lval < rval && reverse) ||
 373                                     (lval > rval && !reverse))
 374                                         sc_prev = sc_next;
 375                         }
 376
 377                         /* properties that use string comparison */
 378                         else if (strcmp(property, "name") == 0 ||
 379                                  strcmp(property, "origin") == 0) {
 380                                 if ((strcmp(sc_prev.val, sc_next.val) < 0 && reverse) ||
 381                                     (strcmp(sc_prev.val, sc_next.val) > 0 && !reverse))
 382                                         sc_prev = sc_next;
 383                         }
 384                 }
 385
 386                 /*
 387                  * The 'props' nvlist has been created to only have unique names.
 388                  * When a name is added, any existing nvlist's with the same name
 389                  * will be removed. Eventually, all existing nvlist's are replaced
 390                  * in sorted order.
 391                  */
 392                 nvlist_add_nvlist(props, sc_prev.name, sc_prev.nvl);
 393                 nvlist_remove_all(nvl, sc_prev.name);
 394         }
 395
 396         be_prop_list_free(nvl);
 397
 398         return 0;
 399 }
 400
 401 int
 402 bectl_cmd_list(int argc, char *argv[])
 403 {
 404         struct printc pc;
 405         nvpair_t *cur;
 406         nvlist_t *dsprops, *props;
 407         int opt, printed;
 408         char *column;
 409         bool reverse;
 410
 411         column = NULL;
 412         props = NULL;
 413         printed = 0;
 414         bzero(&pc, sizeof(pc));
 415         reverse = false;
 416         while ((opt = getopt(argc, argv, "aDHsc:C:")) != -1) {
 417                 switch (opt) {
 418                 case 'a':
 419                         pc.show_all_datasets = true;
 420                         break;
 421                 case 'D':
 422                         pc.show_space = true;
 423                         break;
 424                 case 'H':
 425                         pc.script_fmt = true;
 426                         break;
 427                 case 's':
 428                         pc.show_snaps = true;
 429                         break;
 430                 case 'c':
 431                         if (column != NULL)
 432                                 free(column);
 433                         column = strdup(optarg);
 434                         reverse = false;
 435                         break;
 436                 case 'C':
 437                         if (column != NULL)
 438                                 free(column);
 439                         column = strdup(optarg);
 440                         reverse = true;
 441                         break;
 442                 default:
 443                         fprintf(stderr, "bectl list: unknown option '-%c'\n",
 444                             optopt);
 445                         return (usage(false));
 446                 }
 447         }
 448
 449         argc -= optind;
 450
 451         if (argc != 0) {
 452                 fprintf(stderr, "bectl list: extra argument provided\n");
 453                 return (usage(false));
 454         }
 455
 456         if (be_prop_list_alloc(&props) != 0) {
 457                 fprintf(stderr, "bectl list: failed to allocate prop nvlist\n");
 458                 return (1);
 459         }
 460         if (be_get_bootenv_props(be, props) != 0) {
 461                 /* XXX TODO: Real errors */
 462                 fprintf(stderr, "bectl list: failed to fetch boot environments\n");
 463                 return (1);
 464         }
 465
 466         /* List boot environments in alphabetical order by default */
 467         if (column == NULL)
 468                 column = strdup("name");
 469
 470         prop_list_sort(props, column, reverse);
 471
 472         /* Force -D off if either -a or -s are specified */
 473         if (pc.show_all_datasets || pc.show_snaps)
 474                 pc.show_space = false;
 475         if (!pc.script_fmt)
 476                 print_headers(props, &pc);
 477
 478         /* Print boot environments */
 479         for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
 480             cur = nvlist_next_nvpair(props, cur)) {
 481                 nvpair_value_nvlist(cur, &dsprops);
 482
 483                 if (printed > 0 && (pc.show_all_datasets || pc.show_snaps))
 484                         printf("\n");
 485
 486                 print_info(nvpair_name(cur), dsprops, &pc);
 487                 printed++;
 488         }
 489
 490         free(column);
 491         be_prop_list_free(props);
 492
 493         return (0);
 494 }
 495