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