1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 25 * Copyright 2015 Toomas Soome <tsoome@me.com> 26 * Copyright 2015 Gary Mills 27 * Copyright (c) 2015 by Delphix. All rights reserved. 28 * Copyright 2017 Jason King 29 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 30 */ 31 32 /* 33 * System includes 34 */ 35 36 #include <assert.h> 37 #include <stdio.h> 38 #include <strings.h> 39 #include <libzfs.h> 40 #include <locale.h> 41 #include <langinfo.h> 42 #include <stdlib.h> 43 #include <wchar.h> 44 #include <sys/types.h> 45 #include <sys/debug.h> 46 #include <libcmdutils.h> 47 48 #include "libbe.h" 49 50 #ifndef lint 51 #define _(x) gettext(x) 52 #else 53 #define _(x) (x) 54 #endif 55 56 #ifndef TEXT_DOMAIN 57 #define TEXT_DOMAIN "SYS_TEST" 58 #endif 59 60 #define DT_BUF_LEN (128) 61 #define NUM_COLS (6) 62 CTASSERT(DT_BUF_LEN >= NN_NUMBUF_SZ); 63 64 static int be_do_activate(int argc, char **argv); 65 static int be_do_create(int argc, char **argv); 66 static int be_do_destroy(int argc, char **argv); 67 static int be_do_list(int argc, char **argv); 68 static int be_do_mount(int argc, char **argv); 69 static int be_do_unmount(int argc, char **argv); 70 static int be_do_rename(int argc, char **argv); 71 static int be_do_rollback(int argc, char **argv); 72 static void usage(void); 73 74 /* 75 * single column name/width output format description 76 */ 77 struct col_info { 78 const char *col_name; 79 size_t width; 80 }; 81 82 /* 83 * all columns output format 84 */ 85 struct hdr_info { 86 struct col_info cols[NUM_COLS]; 87 }; 88 89 /* 90 * type of possible output formats 91 */ 92 enum be_fmt { 93 BE_FMT_DEFAULT, 94 BE_FMT_DATASET, 95 BE_FMT_SNAPSHOT, 96 BE_FMT_ALL 97 }; 98 99 /* 100 * command handler description 101 */ 102 typedef struct be_command { 103 const char *name; 104 int (*func)(int argc, char **argv); 105 } be_command_t; 106 107 /* 108 * sorted list of be commands 109 */ 110 static const be_command_t be_command_tbl[] = { 111 { "activate", be_do_activate }, 112 { "create", be_do_create }, 113 { "destroy", be_do_destroy }, 114 { "list", be_do_list }, 115 { "mount", be_do_mount }, 116 { "unmount", be_do_unmount }, 117 { "umount", be_do_unmount }, /* unmount alias */ 118 { "rename", be_do_rename }, 119 { "rollback", be_do_rollback }, 120 { NULL, NULL }, 121 }; 122 123 static void 124 usage(void) 125 { 126 (void) fprintf(stderr, _("usage:\n" 127 "\tbeadm subcommand cmd_options\n" 128 "\n" 129 "\tsubcommands:\n" 130 "\n" 131 "\tbeadm activate [-v] beName\n" 132 "\tbeadm create [-a] [-d BE_desc]\n" 133 "\t\t[-o property=value] ... [-p zpool] \n" 134 "\t\t[-e nonActiveBe | beName@snapshot] [-v] beName\n" 135 "\tbeadm create [-d BE_desc]\n" 136 "\t\t[-o property=value] ... [-p zpool] [-v] beName@snapshot\n" 137 "\tbeadm destroy [-Ffsv] beName \n" 138 "\tbeadm destroy [-Fv] beName@snapshot \n" 139 "\tbeadm list [[-a] | [-d] [-s]] [-H]\n" 140 "\t\t[-k|-K date | name | space] [-v] [beName]\n" 141 "\tbeadm mount [-s ro|rw] [-v] beName [mountpoint]\n" 142 "\tbeadm unmount [-fv] beName | mountpoint\n" 143 "\tbeadm umount [-fv] beName | mountpoint\n" 144 "\tbeadm rename [-v] origBeName newBeName\n" 145 "\tbeadm rollback [-v] beName snapshot\n" 146 "\tbeadm rollback [-v] beName@snapshot\n")); 147 } 148 149 static int 150 run_be_cmd(const char *cmdname, int argc, char **argv) 151 { 152 const be_command_t *command; 153 154 for (command = &be_command_tbl[0]; command->name != NULL; command++) 155 if (strcmp(command->name, cmdname) == 0) 156 return (command->func(argc, argv)); 157 158 (void) fprintf(stderr, _("Invalid command: %s\n"), cmdname); 159 usage(); 160 return (1); 161 } 162 163 int 164 main(int argc, char **argv) 165 { 166 const char *cmdname; 167 168 (void) setlocale(LC_ALL, ""); 169 (void) textdomain(TEXT_DOMAIN); 170 171 if (argc < 2) { 172 usage(); 173 return (1); 174 } 175 176 cmdname = argv[1]; 177 178 /* Turn error printing off */ 179 libbe_print_errors(B_FALSE); 180 181 return (run_be_cmd(cmdname, --argc, ++argv)); 182 } 183 184 static void 185 print_hdr(struct hdr_info *hdr_info) 186 { 187 boolean_t first = B_TRUE; 188 size_t i; 189 for (i = 0; i < NUM_COLS; i++) { 190 struct col_info *col_info = &hdr_info->cols[i]; 191 const char *name = col_info->col_name; 192 size_t width = col_info->width; 193 if (name == NULL) 194 continue; 195 196 if (first) { 197 (void) printf("%-*s", width, name); 198 first = B_FALSE; 199 } else 200 (void) printf(" %-*s", width, name); 201 } 202 (void) putchar('\n'); 203 } 204 205 static void 206 init_hdr_cols(enum be_fmt be_fmt, struct hdr_info *hdr) 207 { 208 struct col_info *col = hdr->cols; 209 size_t i; 210 211 col[1].col_name = _("Active"); 212 col[2].col_name = _("Mountpoint"); 213 col[3].col_name = _("Space"); 214 col[4].col_name = _("Policy"); 215 col[5].col_name = _("Created"); 216 col[6].col_name = NULL; 217 218 switch (be_fmt) { 219 case BE_FMT_ALL: 220 col[0].col_name = _("BE/Dataset/Snapshot"); 221 break; 222 case BE_FMT_DATASET: 223 col[0].col_name = _("BE/Dataset"); 224 break; 225 case BE_FMT_SNAPSHOT: 226 col[0].col_name = _("BE/Snapshot"); 227 col[1].col_name = NULL; 228 col[2].col_name = NULL; 229 break; 230 case BE_FMT_DEFAULT: 231 default: 232 col[0].col_name = _("BE"); 233 } 234 235 for (i = 0; i < NUM_COLS; i++) { 236 const char *name = col[i].col_name; 237 col[i].width = 0; 238 239 if (name != NULL) { 240 wchar_t wname[128]; 241 size_t sz = mbstowcs(wname, name, sizeof (wname) / 242 sizeof (wchar_t)); 243 if (sz > 0) { 244 int wcsw = wcswidth(wname, sz); 245 if (wcsw > 0) 246 col[i].width = wcsw; 247 else 248 col[i].width = sz; 249 } else { 250 col[i].width = strlen(name); 251 } 252 } 253 } 254 } 255 256 static void 257 count_widths(enum be_fmt be_fmt, struct hdr_info *hdr, be_node_list_t *be_nodes) 258 { 259 size_t len[NUM_COLS]; 260 char buf[DT_BUF_LEN]; 261 int i; 262 be_node_list_t *cur_be; 263 264 for (i = 0; i < NUM_COLS; i++) 265 len[i] = hdr->cols[i].width; 266 267 for (cur_be = be_nodes; cur_be != NULL; cur_be = cur_be->be_next_node) { 268 char name[ZFS_MAX_DATASET_NAME_LEN + 1]; 269 const char *be_name = cur_be->be_node_name; 270 const char *root_ds = cur_be->be_root_ds; 271 char *pos; 272 size_t node_name_len = strlen(cur_be->be_node_name); 273 size_t root_ds_len = strlen(cur_be->be_root_ds); 274 size_t mntpt_len = 0; 275 size_t policy_len = 0; 276 size_t used_len; 277 uint64_t used = cur_be->be_space_used; 278 be_snapshot_list_t *snap = NULL; 279 280 if (cur_be->be_mntpt != NULL) 281 mntpt_len = strlen(cur_be->be_mntpt); 282 if (cur_be->be_policy_type != NULL) 283 policy_len = strlen(cur_be->be_policy_type); 284 285 (void) strlcpy(name, root_ds, sizeof (name)); 286 pos = strstr(name, be_name); 287 288 if (be_fmt == BE_FMT_DEFAULT) { 289 if (node_name_len > len[0]) 290 len[0] = node_name_len; 291 } else { 292 if (root_ds_len + 3 > len[0]) 293 len[0] = root_ds_len + 3; 294 } 295 296 if (mntpt_len > len[2]) 297 len[2] = mntpt_len; 298 if (policy_len > len[4]) 299 len[4] = policy_len; 300 301 for (snap = cur_be->be_node_snapshots; snap != NULL; 302 snap = snap->be_next_snapshot) { 303 uint64_t snap_used = snap->be_snapshot_space_used; 304 const char *snap_name = snap->be_snapshot_name; 305 (void) strcpy(pos, snap_name); 306 307 if (be_fmt == BE_FMT_DEFAULT) 308 used += snap_used; 309 else if (be_fmt & BE_FMT_SNAPSHOT) { 310 int snap_len = strlen(name) + 3; 311 if (be_fmt == BE_FMT_SNAPSHOT) 312 snap_len -= pos - name; 313 if (snap_len > len[0]) 314 len[0] = snap_len; 315 nicenum(snap_used, buf, sizeof (buf)); 316 used_len = strlen(buf); 317 if (used_len > len[3]) 318 len[3] = used_len; 319 } 320 } 321 322 if (be_fmt == BE_FMT_DEFAULT) { 323 int used_len; 324 nicenum(used, buf, sizeof (buf)); 325 used_len = strlen(buf); 326 if (used_len > len[3]) 327 len[3] = used_len; 328 } 329 330 nicenum(used, buf, sizeof (buf)); 331 } 332 333 for (i = 0; i < NUM_COLS; i++) 334 hdr->cols[i].width = len[i]; 335 } 336 337 static void 338 print_be_nodes(const char *be_name, boolean_t parsable, struct hdr_info *hdr, 339 be_node_list_t *nodes) 340 { 341 char buf[64]; 342 char datetime[DT_BUF_LEN]; 343 be_node_list_t *cur_be; 344 345 for (cur_be = nodes; cur_be != NULL; cur_be = cur_be->be_next_node) { 346 char active[3] = "-\0"; 347 int ai = 0; 348 const char *datetime_fmt = "%F %R"; 349 const char *name = cur_be->be_node_name; 350 const char *mntpt = cur_be->be_mntpt; 351 const char *uuid_str = cur_be->be_uuid_str; 352 be_snapshot_list_t *snap = NULL; 353 uint64_t used = cur_be->be_space_used; 354 time_t creation = cur_be->be_node_creation; 355 struct tm *tm; 356 357 if (be_name != NULL && strcmp(be_name, name) != 0) 358 continue; 359 360 if (parsable) 361 active[0] = '\0'; 362 363 tm = localtime(&creation); 364 (void) strftime(datetime, DT_BUF_LEN, datetime_fmt, tm); 365 366 for (snap = cur_be->be_node_snapshots; snap != NULL; 367 snap = snap->be_next_snapshot) 368 used += snap->be_snapshot_space_used; 369 370 if (!cur_be->be_global_active) 371 active[ai++] = 'x'; 372 373 if (cur_be->be_active) 374 active[ai++] = 'N'; 375 if (cur_be->be_active_on_boot) { 376 if (!cur_be->be_global_active) 377 active[ai] = 'b'; 378 else 379 active[ai] = 'R'; 380 } 381 382 nicenum(used, buf, sizeof (buf)); 383 if (parsable) 384 (void) printf("%s;%s;%s;%s;%llu;%s;%ld\n", 385 name, 386 (uuid_str != NULL ? uuid_str: ""), 387 active, 388 (cur_be->be_mounted ? mntpt: ""), 389 used, 390 cur_be->be_policy_type, 391 creation); 392 else 393 (void) printf("%-*s %-*s %-*s %-*s %-*s %-*s\n", 394 hdr->cols[0].width, name, 395 hdr->cols[1].width, active, 396 hdr->cols[2].width, (cur_be->be_mounted ? mntpt: 397 "-"), 398 hdr->cols[3].width, buf, 399 hdr->cols[4].width, cur_be->be_policy_type, 400 hdr->cols[5].width, datetime); 401 } 402 } 403 404 static void 405 print_be_snapshots(be_node_list_t *be, struct hdr_info *hdr, boolean_t parsable) 406 { 407 char buf[64]; 408 char datetime[DT_BUF_LEN]; 409 be_snapshot_list_t *snap = NULL; 410 411 for (snap = be->be_node_snapshots; snap != NULL; 412 snap = snap->be_next_snapshot) { 413 char name[ZFS_MAX_DATASET_NAME_LEN + 1]; 414 const char *datetime_fmt = "%F %R"; 415 const char *be_name = be->be_node_name; 416 const char *root_ds = be->be_root_ds; 417 const char *snap_name = snap->be_snapshot_name; 418 char *pos; 419 uint64_t used = snap->be_snapshot_space_used; 420 time_t creation = snap->be_snapshot_creation; 421 struct tm *tm = localtime(&creation); 422 423 (void) strncpy(name, root_ds, sizeof (name)); 424 pos = strstr(name, be_name); 425 (void) strcpy(pos, snap_name); 426 427 (void) strftime(datetime, DT_BUF_LEN, datetime_fmt, tm); 428 nicenum(used, buf, sizeof (buf)); 429 430 if (parsable) 431 if (hdr->cols[1].width != 0) 432 (void) printf("%s;%s;%s;%s;%llu;%s;%ld\n", 433 be_name, 434 snap_name, 435 "", 436 "", 437 used, 438 be->be_policy_type, 439 creation); 440 else 441 (void) printf("%s;%s;%llu;%s;%ld\n", 442 be_name, 443 snap_name, 444 used, 445 be->be_policy_type, 446 creation); 447 else 448 if (hdr->cols[1].width != 0) 449 (void) printf(" %-*s %-*s %-*s %-*s %-*s " 450 "%-*s\n", 451 hdr->cols[0].width-3, name, 452 hdr->cols[1].width, "-", 453 hdr->cols[2].width, "-", 454 hdr->cols[3].width, buf, 455 hdr->cols[4].width, be->be_policy_type, 456 hdr->cols[5].width, datetime); 457 else 458 (void) printf(" %-*s %-*s %-*s %-*s\n", 459 hdr->cols[0].width-3, snap_name, 460 hdr->cols[3].width, buf, 461 hdr->cols[4].width, be->be_policy_type, 462 hdr->cols[5].width, datetime); 463 } 464 } 465 466 static void 467 print_fmt_nodes(const char *be_name, enum be_fmt be_fmt, boolean_t parsable, 468 struct hdr_info *hdr, be_node_list_t *nodes) 469 { 470 char buf[64]; 471 char datetime[DT_BUF_LEN]; 472 be_node_list_t *cur_be; 473 474 for (cur_be = nodes; cur_be != NULL; cur_be = cur_be->be_next_node) { 475 char active[3] = "-\0"; 476 int ai = 0; 477 const char *datetime_fmt = "%F %R"; 478 const char *name = cur_be->be_node_name; 479 const char *mntpt = cur_be->be_mntpt; 480 uint64_t used = cur_be->be_space_used; 481 time_t creation = cur_be->be_node_creation; 482 struct tm *tm; 483 484 if (be_name != NULL && strcmp(be_name, name) != 0) 485 continue; 486 487 if (!parsable) 488 (void) printf("%-s\n", name); 489 else 490 active[0] = '\0'; 491 492 tm = localtime(&creation); 493 (void) strftime(datetime, DT_BUF_LEN, datetime_fmt, tm); 494 495 if (cur_be->be_active) 496 active[ai++] = 'N'; 497 if (cur_be->be_active_on_boot) 498 active[ai] = 'R'; 499 500 nicenum(used, buf, sizeof (buf)); 501 if (be_fmt & BE_FMT_DATASET) 502 if (parsable) 503 (void) printf("%s;%s;%s;%s;%llu;%s;%ld\n", 504 cur_be->be_node_name, 505 cur_be->be_root_ds, 506 active, 507 (cur_be->be_mounted ? mntpt: ""), 508 used, 509 cur_be->be_policy_type, 510 creation); 511 else 512 (void) printf(" %-*s %-*s %-*s %-*s %-*s " 513 "%-*s\n", 514 hdr->cols[0].width-3, cur_be->be_root_ds, 515 hdr->cols[1].width, active, 516 hdr->cols[2].width, (cur_be->be_mounted ? 517 mntpt: "-"), 518 hdr->cols[3].width, buf, 519 hdr->cols[4].width, cur_be->be_policy_type, 520 hdr->cols[5].width, datetime); 521 522 if (be_fmt & BE_FMT_SNAPSHOT) 523 print_be_snapshots(cur_be, hdr, parsable); 524 } 525 } 526 527 static void 528 print_nodes(const char *be_name, boolean_t dsets, boolean_t snaps, 529 boolean_t parsable, be_node_list_t *be_nodes) 530 { 531 struct hdr_info hdr; 532 enum be_fmt be_fmt = BE_FMT_DEFAULT; 533 534 if (dsets) 535 be_fmt |= BE_FMT_DATASET; 536 if (snaps) 537 be_fmt |= BE_FMT_SNAPSHOT; 538 539 if (!parsable) { 540 init_hdr_cols(be_fmt, &hdr); 541 count_widths(be_fmt, &hdr, be_nodes); 542 print_hdr(&hdr); 543 } 544 545 if (be_fmt == BE_FMT_DEFAULT) 546 print_be_nodes(be_name, parsable, &hdr, be_nodes); 547 else 548 print_fmt_nodes(be_name, be_fmt, parsable, &hdr, be_nodes); 549 } 550 551 static boolean_t 552 confirm_destroy(const char *name) 553 { 554 boolean_t res = B_FALSE; 555 const char *yesre = nl_langinfo(YESEXPR); 556 const char *nore = nl_langinfo(NOEXPR); 557 regex_t yes_re; 558 regex_t no_re; 559 char buf[128]; 560 char *answer; 561 int cflags = REG_EXTENDED; 562 563 if (regcomp(&yes_re, yesre, cflags) != 0) { 564 /* should not happen */ 565 (void) fprintf(stderr, _("Failed to compile 'yes' regexp\n")); 566 return (res); 567 } 568 if (regcomp(&no_re, nore, cflags) != 0) { 569 /* should not happen */ 570 (void) fprintf(stderr, _("Failed to compile 'no' regexp\n")); 571 regfree(&yes_re); 572 return (res); 573 } 574 575 (void) printf(_("Are you sure you want to destroy %s?\n" 576 "This action cannot be undone (y/[n]): "), name); 577 578 answer = fgets(buf, sizeof (buf), stdin); 579 if (answer == NULL || *answer == '\0' || *answer == 10) 580 goto out; 581 582 if (regexec(&yes_re, answer, 0, NULL, 0) == 0) { 583 res = B_TRUE; 584 } else if (regexec(&no_re, answer, 0, NULL, 0) != 0) { 585 (void) fprintf(stderr, _("Invalid response. " 586 "Please enter 'y' or 'n'.\n")); 587 } 588 589 out: 590 regfree(&yes_re); 591 regfree(&no_re); 592 return (res); 593 } 594 595 static int 596 be_nvl_alloc(nvlist_t **nvlp) 597 { 598 assert(nvlp != NULL); 599 600 if (nvlist_alloc(nvlp, NV_UNIQUE_NAME, 0) != 0) { 601 (void) perror(_("nvlist_alloc failed.\n")); 602 return (1); 603 } 604 605 return (0); 606 } 607 608 static int 609 be_nvl_add_string(nvlist_t *nvl, const char *name, const char *val) 610 { 611 assert(nvl != NULL); 612 613 if (nvlist_add_string(nvl, name, val) != 0) { 614 (void) fprintf(stderr, _("nvlist_add_string failed for " 615 "%s (%s).\n"), name, val); 616 return (1); 617 } 618 619 return (0); 620 } 621 622 static int 623 be_nvl_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val) 624 { 625 assert(nvl != NULL); 626 627 if (nvlist_add_nvlist(nvl, name, val) != 0) { 628 (void) fprintf(stderr, _("nvlist_add_nvlist failed for %s.\n"), 629 name); 630 return (1); 631 } 632 633 return (0); 634 } 635 636 static int 637 be_nvl_add_uint16(nvlist_t *nvl, const char *name, uint16_t val) 638 { 639 assert(nvl != NULL); 640 641 if (nvlist_add_uint16(nvl, name, val) != 0) { 642 (void) fprintf(stderr, _("nvlist_add_uint16 failed for " 643 "%s (%hu).\n"), name, val); 644 return (1); 645 } 646 647 return (0); 648 } 649 650 static int 651 be_do_activate(int argc, char **argv) 652 { 653 nvlist_t *be_attrs; 654 int err = 1; 655 int c; 656 char *obe_name; 657 658 while ((c = getopt(argc, argv, "v")) != -1) { 659 switch (c) { 660 case 'v': 661 libbe_print_errors(B_TRUE); 662 break; 663 default: 664 usage(); 665 return (1); 666 } 667 } 668 669 argc -= optind; 670 argv += optind; 671 672 if (argc != 1) { 673 usage(); 674 return (1); 675 } 676 677 obe_name = argv[0]; 678 679 if (be_nvl_alloc(&be_attrs) != 0) 680 return (1); 681 682 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 683 goto out; 684 685 err = be_activate(be_attrs); 686 687 switch (err) { 688 case BE_SUCCESS: 689 (void) printf(_("Activated successfully\n")); 690 break; 691 case BE_ERR_BE_NOENT: 692 (void) fprintf(stderr, _("%s does not exist or appear " 693 "to be a valid BE.\nPlease check that the name of " 694 "the BE provided is correct.\n"), obe_name); 695 break; 696 case BE_ERR_PERM: 697 case BE_ERR_ACCESS: 698 (void) fprintf(stderr, _("Unable to activate %s.\n"), obe_name); 699 (void) fprintf(stderr, _("You have insufficient privileges to " 700 "execute this command.\n")); 701 break; 702 case BE_ERR_ACTIVATE_CURR: 703 default: 704 (void) fprintf(stderr, _("Unable to activate %s.\n"), obe_name); 705 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 706 } 707 708 out: 709 nvlist_free(be_attrs); 710 return (err); 711 } 712 713 static int 714 be_do_create(int argc, char **argv) 715 { 716 nvlist_t *be_attrs; 717 nvlist_t *zfs_props = NULL; 718 boolean_t activate = B_FALSE; 719 boolean_t is_snap = B_FALSE; 720 int c; 721 int err = 1; 722 char *obe_name = NULL; 723 char *snap_name = NULL; 724 char *nbe_zpool = NULL; 725 char *nbe_name = NULL; 726 char *nbe_desc = NULL; 727 char *propname = NULL; 728 char *propval = NULL; 729 char *strval = NULL; 730 731 while ((c = getopt(argc, argv, "ad:e:io:p:v")) != -1) { 732 switch (c) { 733 case 'a': 734 activate = B_TRUE; 735 break; 736 case 'd': 737 nbe_desc = optarg; 738 break; 739 case 'e': 740 obe_name = optarg; 741 break; 742 case 'o': 743 if (zfs_props == NULL && be_nvl_alloc(&zfs_props) != 0) 744 return (1); 745 746 propname = optarg; 747 if ((propval = strchr(propname, '=')) == NULL) { 748 (void) fprintf(stderr, _("missing " 749 "'=' for -o option\n")); 750 goto out2; 751 } 752 *propval = '\0'; 753 propval++; 754 if (nvlist_lookup_string(zfs_props, propname, 755 &strval) == 0) { 756 (void) fprintf(stderr, _("property '%s' " 757 "specified multiple times\n"), propname); 758 goto out2; 759 760 } 761 if (be_nvl_add_string(zfs_props, propname, propval) 762 != 0) 763 goto out2; 764 765 break; 766 case 'p': 767 nbe_zpool = optarg; 768 break; 769 case 'v': 770 libbe_print_errors(B_TRUE); 771 break; 772 default: 773 usage(); 774 goto out2; 775 } 776 } 777 778 argc -= optind; 779 argv += optind; 780 781 if (argc != 1) { 782 usage(); 783 goto out2; 784 } 785 786 nbe_name = argv[0]; 787 788 if ((snap_name = strrchr(nbe_name, '@')) != NULL) { 789 if (snap_name[1] == '\0') { 790 usage(); 791 goto out2; 792 } 793 794 snap_name[0] = '\0'; 795 snap_name++; 796 is_snap = B_TRUE; 797 } 798 799 if (obe_name) { 800 if (is_snap) { 801 usage(); 802 goto out2; 803 } 804 805 /* 806 * Check if obe_name is really a snapshot name. 807 * If so, split it out. 808 */ 809 if ((snap_name = strrchr(obe_name, '@')) != NULL) { 810 if (snap_name[1] == '\0') { 811 usage(); 812 goto out2; 813 } 814 815 snap_name[0] = '\0'; 816 snap_name++; 817 } 818 } else if (is_snap) { 819 obe_name = nbe_name; 820 nbe_name = NULL; 821 } 822 823 if (be_nvl_alloc(&be_attrs) != 0) 824 goto out2; 825 826 827 if (zfs_props != NULL && be_nvl_add_nvlist(be_attrs, 828 BE_ATTR_ORIG_BE_NAME, zfs_props) != 0) 829 goto out; 830 831 if (obe_name != NULL && be_nvl_add_string(be_attrs, 832 BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 833 goto out; 834 835 if (snap_name != NULL && be_nvl_add_string(be_attrs, 836 BE_ATTR_SNAP_NAME, snap_name) != 0) 837 goto out; 838 839 if (nbe_zpool != NULL && be_nvl_add_string(be_attrs, 840 BE_ATTR_NEW_BE_POOL, nbe_zpool) != 0) 841 goto out; 842 843 if (nbe_name != NULL && be_nvl_add_string(be_attrs, 844 BE_ATTR_NEW_BE_NAME, nbe_name) != 0) 845 goto out; 846 847 if (nbe_desc != NULL && be_nvl_add_string(be_attrs, 848 BE_ATTR_NEW_BE_DESC, nbe_desc) != 0) 849 goto out; 850 851 if (is_snap) 852 err = be_create_snapshot(be_attrs); 853 else 854 err = be_copy(be_attrs); 855 856 switch (err) { 857 case BE_SUCCESS: 858 if (!is_snap && !nbe_name) { 859 /* 860 * We requested an auto named BE; find out the 861 * name of the BE that was created for us and 862 * the auto snapshot created from the original BE. 863 */ 864 if (nvlist_lookup_string(be_attrs, BE_ATTR_NEW_BE_NAME, 865 &nbe_name) != 0) { 866 (void) fprintf(stderr, _("failed to get %s " 867 "attribute\n"), BE_ATTR_NEW_BE_NAME); 868 break; 869 } else 870 (void) printf(_("Auto named BE: %s\n"), 871 nbe_name); 872 873 if (nvlist_lookup_string(be_attrs, BE_ATTR_SNAP_NAME, 874 &snap_name) != 0) { 875 (void) fprintf(stderr, _("failed to get %s " 876 "attribute\n"), BE_ATTR_SNAP_NAME); 877 break; 878 } else 879 (void) printf(_("Auto named snapshot: %s\n"), 880 snap_name); 881 } 882 883 if (!is_snap && activate) { 884 char *args[] = { "activate", "", NULL }; 885 args[1] = nbe_name; 886 optind = 1; 887 888 err = be_do_activate(2, args); 889 goto out; 890 } 891 892 (void) printf(_("Created successfully\n")); 893 break; 894 case BE_ERR_BE_EXISTS: 895 (void) fprintf(stderr, _("BE %s already exists\n." 896 "Please choose a different BE name.\n"), nbe_name); 897 break; 898 case BE_ERR_SS_EXISTS: 899 (void) fprintf(stderr, _("BE %s snapshot %s already exists.\n" 900 "Please choose a different snapshot name.\n"), obe_name, 901 snap_name); 902 break; 903 case BE_ERR_PERM: 904 case BE_ERR_ACCESS: 905 if (is_snap) 906 (void) fprintf(stderr, _("Unable to create snapshot " 907 "%s.\n"), snap_name); 908 else 909 (void) fprintf(stderr, _("Unable to create %s.\n"), 910 nbe_name); 911 (void) fprintf(stderr, _("You have insufficient privileges to " 912 "execute this command.\n")); 913 break; 914 default: 915 if (is_snap) 916 (void) fprintf(stderr, _("Unable to create snapshot " 917 "%s.\n"), snap_name); 918 else 919 (void) fprintf(stderr, _("Unable to create %s.\n"), 920 nbe_name); 921 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 922 } 923 924 out: 925 nvlist_free(be_attrs); 926 out2: 927 nvlist_free(zfs_props); 928 929 return (err); 930 } 931 932 static int 933 be_do_destroy(int argc, char **argv) 934 { 935 nvlist_t *be_attrs; 936 boolean_t is_snap = B_FALSE; 937 boolean_t suppress_prompt = B_FALSE; 938 int err = 1; 939 int c; 940 int destroy_flags = 0; 941 char *snap_name; 942 char *be_name; 943 944 while ((c = getopt(argc, argv, "fFsv")) != -1) { 945 switch (c) { 946 case 'f': 947 destroy_flags |= BE_DESTROY_FLAG_FORCE_UNMOUNT; 948 break; 949 case 's': 950 destroy_flags |= BE_DESTROY_FLAG_SNAPSHOTS; 951 break; 952 case 'v': 953 libbe_print_errors(B_TRUE); 954 break; 955 case 'F': 956 suppress_prompt = B_TRUE; 957 break; 958 default: 959 usage(); 960 return (1); 961 } 962 } 963 964 argc -= optind; 965 argv += optind; 966 967 if (argc != 1) { 968 usage(); 969 return (1); 970 } 971 972 be_name = argv[0]; 973 if (!suppress_prompt && !confirm_destroy(be_name)) { 974 (void) printf(_("%s has not been destroyed.\n"), be_name); 975 return (0); 976 } 977 978 if ((snap_name = strrchr(be_name, '@')) != NULL) { 979 if (snap_name[1] == '\0') { 980 usage(); 981 return (1); 982 } 983 984 is_snap = B_TRUE; 985 *snap_name = '\0'; 986 snap_name++; 987 } 988 989 if (be_nvl_alloc(&be_attrs) != 0) 990 return (1); 991 992 993 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, be_name) != 0) 994 goto out; 995 996 if (is_snap) { 997 if (be_nvl_add_string(be_attrs, BE_ATTR_SNAP_NAME, 998 snap_name) != 0) 999 goto out; 1000 1001 err = be_destroy_snapshot(be_attrs); 1002 } else { 1003 if (be_nvl_add_uint16(be_attrs, BE_ATTR_DESTROY_FLAGS, 1004 destroy_flags) != 0) 1005 goto out; 1006 1007 err = be_destroy(be_attrs); 1008 } 1009 1010 switch (err) { 1011 case BE_SUCCESS: 1012 (void) printf(_("Destroyed successfully\n")); 1013 break; 1014 case BE_ERR_MOUNTED: 1015 (void) fprintf(stderr, _("Unable to destroy %s.\n"), be_name); 1016 (void) fprintf(stderr, _("It is currently mounted and must be " 1017 "unmounted before it can be destroyed.\n" "Use 'beadm " 1018 "unmount %s' to unmount the BE before destroying\nit or " 1019 "'beadm destroy -f %s'.\n"), be_name, be_name); 1020 break; 1021 case BE_ERR_DESTROY_CURR_BE: 1022 (void) fprintf(stderr, _("%s is the currently active BE and " 1023 "cannot be destroyed.\nYou must boot from another BE in " 1024 "order to destroy %s.\n"), be_name, be_name); 1025 break; 1026 case BE_ERR_ZONES_UNMOUNT: 1027 (void) fprintf(stderr, _("Unable to destroy one of " "%s's " 1028 "zone BE's.\nUse 'beadm destroy -f %s' or " 1029 "'zfs -f destroy <dataset>'.\n"), be_name, be_name); 1030 break; 1031 case BE_ERR_SS_NOENT: 1032 (void) fprintf(stderr, _("%s does not exist or appear " 1033 "to be a valid snapshot.\nPlease check that the name of " 1034 "the snapshot provided is correct.\n"), snap_name); 1035 break; 1036 case BE_ERR_PERM: 1037 case BE_ERR_ACCESS: 1038 (void) fprintf(stderr, _("Unable to destroy %s.\n"), be_name); 1039 (void) fprintf(stderr, _("You have insufficient privileges to " 1040 "execute this command.\n")); 1041 break; 1042 case BE_ERR_SS_EXISTS: 1043 (void) fprintf(stderr, _("Unable to destroy %s: " 1044 "BE has snapshots.\nUse 'beadm destroy -s %s' or " 1045 "'zfs -r destroy <dataset>'.\n"), be_name, be_name); 1046 break; 1047 default: 1048 (void) fprintf(stderr, _("Unable to destroy %s.\n"), be_name); 1049 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1050 } 1051 1052 out: 1053 nvlist_free(be_attrs); 1054 return (err); 1055 } 1056 1057 static int 1058 be_do_list(int argc, char **argv) 1059 { 1060 be_node_list_t *be_nodes = NULL; 1061 boolean_t all = B_FALSE; 1062 boolean_t dsets = B_FALSE; 1063 boolean_t snaps = B_FALSE; 1064 boolean_t parsable = B_FALSE; 1065 int err = 1; 1066 int c = 0; 1067 char *be_name = NULL; 1068 be_sort_t order = BE_SORT_UNSPECIFIED; 1069 1070 while ((c = getopt(argc, argv, "adk:svHK:")) != -1) { 1071 switch (c) { 1072 case 'a': 1073 all = B_TRUE; 1074 break; 1075 case 'd': 1076 dsets = B_TRUE; 1077 break; 1078 case 'k': 1079 case 'K': 1080 if (order != BE_SORT_UNSPECIFIED) { 1081 (void) fprintf(stderr, _("Sort key can be " 1082 "specified only once.\n")); 1083 usage(); 1084 return (1); 1085 } 1086 if (strcmp(optarg, "date") == 0) { 1087 if (c == 'k') 1088 order = BE_SORT_DATE; 1089 else 1090 order = BE_SORT_DATE_REV; 1091 break; 1092 } 1093 if (strcmp(optarg, "name") == 0) { 1094 if (c == 'k') 1095 order = BE_SORT_NAME; 1096 else 1097 order = BE_SORT_NAME_REV; 1098 break; 1099 } 1100 if (strcmp(optarg, "space") == 0) { 1101 if (c == 'k') 1102 order = BE_SORT_SPACE; 1103 else 1104 order = BE_SORT_SPACE_REV; 1105 break; 1106 } 1107 (void) fprintf(stderr, _("Unknown sort key: %s\n"), 1108 optarg); 1109 usage(); 1110 return (1); 1111 case 's': 1112 snaps = B_TRUE; 1113 break; 1114 case 'v': 1115 libbe_print_errors(B_TRUE); 1116 break; 1117 case 'H': 1118 parsable = B_TRUE; 1119 break; 1120 default: 1121 usage(); 1122 return (1); 1123 } 1124 } 1125 1126 if (all) { 1127 if (dsets) { 1128 (void) fprintf(stderr, _("Invalid options: -a and %s " 1129 "are mutually exclusive.\n"), "-d"); 1130 usage(); 1131 return (1); 1132 } 1133 if (snaps) { 1134 (void) fprintf(stderr, _("Invalid options: -a and %s " 1135 "are mutually exclusive.\n"), "-s"); 1136 usage(); 1137 return (1); 1138 } 1139 1140 dsets = B_TRUE; 1141 snaps = B_TRUE; 1142 } 1143 1144 argc -= optind; 1145 argv += optind; 1146 1147 1148 if (argc == 1) 1149 be_name = argv[0]; 1150 1151 err = be_list(be_name, &be_nodes, 1152 snaps ? BE_LIST_SNAPSHOTS : BE_LIST_DEFAULT); 1153 1154 switch (err) { 1155 case BE_SUCCESS: 1156 /* the default sort is ascending date, no need to sort twice */ 1157 if (order == BE_SORT_UNSPECIFIED) 1158 order = BE_SORT_DATE; 1159 1160 if (order != BE_SORT_DATE) { 1161 err = be_sort(&be_nodes, order); 1162 if (err != BE_SUCCESS) { 1163 (void) fprintf(stderr, _("Unable to sort Boot " 1164 "Environment\n")); 1165 (void) fprintf(stderr, "%s\n", 1166 be_err_to_str(err)); 1167 break; 1168 } 1169 } 1170 1171 print_nodes(be_name, dsets, snaps, parsable, be_nodes); 1172 break; 1173 case BE_ERR_BE_NOENT: 1174 if (be_name == NULL) 1175 (void) fprintf(stderr, _("No boot environments found " 1176 "on this system.\n")); 1177 else { 1178 (void) fprintf(stderr, _("%s does not exist or appear " 1179 "to be a valid BE.\nPlease check that the name of " 1180 "the BE provided is correct.\n"), be_name); 1181 } 1182 break; 1183 default: 1184 (void) fprintf(stderr, _("Unable to display Boot " 1185 "Environment\n")); 1186 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1187 } 1188 1189 if (be_nodes != NULL) 1190 be_free_list(be_nodes); 1191 return (err); 1192 } 1193 1194 static int 1195 be_do_mount(int argc, char **argv) 1196 { 1197 nvlist_t *be_attrs; 1198 boolean_t shared_fs = B_FALSE; 1199 int err = 1; 1200 int c; 1201 int mount_flags = 0; 1202 char *obe_name; 1203 char *mountpoint; 1204 char *tmp_mp = NULL; 1205 1206 while ((c = getopt(argc, argv, "s:v")) != -1) { 1207 switch (c) { 1208 case 's': 1209 shared_fs = B_TRUE; 1210 1211 mount_flags |= BE_MOUNT_FLAG_SHARED_FS; 1212 1213 if (strcmp(optarg, "rw") == 0) { 1214 mount_flags |= BE_MOUNT_FLAG_SHARED_RW; 1215 } else if (strcmp(optarg, "ro") != 0) { 1216 (void) fprintf(stderr, _("The -s flag " 1217 "requires an argument [ rw | ro ]\n")); 1218 usage(); 1219 return (1); 1220 } 1221 1222 break; 1223 case 'v': 1224 libbe_print_errors(B_TRUE); 1225 break; 1226 default: 1227 usage(); 1228 return (1); 1229 } 1230 } 1231 1232 argc -= optind; 1233 argv += optind; 1234 1235 if (argc < 1 || argc > 2) { 1236 usage(); 1237 return (1); 1238 } 1239 1240 obe_name = argv[0]; 1241 1242 if (argc == 2) { 1243 mountpoint = argv[1]; 1244 if (mountpoint[0] != '/') { 1245 (void) fprintf(stderr, _("Invalid mount point %s. " 1246 "Mount point must start with a /.\n"), mountpoint); 1247 return (1); 1248 } 1249 } else { 1250 const char *tmpdir = getenv("TMPDIR"); 1251 const char *tmpname = "tmp.XXXXXX"; 1252 int sz; 1253 1254 if (tmpdir == NULL) 1255 tmpdir = "/tmp"; 1256 1257 sz = asprintf(&tmp_mp, "%s/%s", tmpdir, tmpname); 1258 if (sz < 0) { 1259 (void) fprintf(stderr, _("internal error: " 1260 "out of memory\n")); 1261 return (1); 1262 } 1263 1264 mountpoint = mkdtemp(tmp_mp); 1265 } 1266 1267 if (be_nvl_alloc(&be_attrs) != 0) 1268 return (1); 1269 1270 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 1271 goto out; 1272 1273 if (be_nvl_add_string(be_attrs, BE_ATTR_MOUNTPOINT, mountpoint) != 0) 1274 goto out; 1275 1276 if (shared_fs && be_nvl_add_uint16(be_attrs, BE_ATTR_MOUNT_FLAGS, 1277 mount_flags) != 0) 1278 goto out; 1279 1280 err = be_mount(be_attrs); 1281 1282 switch (err) { 1283 case BE_SUCCESS: 1284 (void) printf(_("Mounted successfully on: '%s'\n"), mountpoint); 1285 break; 1286 case BE_ERR_BE_NOENT: 1287 (void) fprintf(stderr, _("%s does not exist or appear " 1288 "to be a valid BE.\nPlease check that the name of " 1289 "the BE provided is correct.\n"), obe_name); 1290 break; 1291 case BE_ERR_MOUNTED: 1292 (void) fprintf(stderr, _("%s is already mounted.\n" 1293 "Please unmount the BE before mounting it again.\n"), 1294 obe_name); 1295 break; 1296 case BE_ERR_PERM: 1297 case BE_ERR_ACCESS: 1298 (void) fprintf(stderr, _("Unable to mount %s.\n"), obe_name); 1299 (void) fprintf(stderr, _("You have insufficient privileges to " 1300 "execute this command.\n")); 1301 break; 1302 case BE_ERR_NO_MOUNTED_ZONE: 1303 (void) fprintf(stderr, _("Mounted on '%s'.\nUnable to mount " 1304 "one of %s's zone BE's.\n"), mountpoint, obe_name); 1305 break; 1306 default: 1307 (void) fprintf(stderr, _("Unable to mount %s.\n"), obe_name); 1308 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1309 } 1310 1311 out: 1312 if (tmp_mp != NULL) 1313 free(tmp_mp); 1314 nvlist_free(be_attrs); 1315 return (err); 1316 } 1317 1318 static int 1319 be_do_unmount(int argc, char **argv) 1320 { 1321 nvlist_t *be_attrs; 1322 char *obe_name; 1323 int err = 1; 1324 int c; 1325 int unmount_flags = 0; 1326 1327 while ((c = getopt(argc, argv, "fv")) != -1) { 1328 switch (c) { 1329 case 'f': 1330 unmount_flags |= BE_UNMOUNT_FLAG_FORCE; 1331 break; 1332 case 'v': 1333 libbe_print_errors(B_TRUE); 1334 break; 1335 default: 1336 usage(); 1337 return (1); 1338 } 1339 } 1340 1341 argc -= optind; 1342 argv += optind; 1343 1344 if (argc != 1) { 1345 usage(); 1346 return (1); 1347 } 1348 1349 obe_name = argv[0]; 1350 1351 if (be_nvl_alloc(&be_attrs) != 0) 1352 return (1); 1353 1354 1355 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 1356 goto out; 1357 1358 if (be_nvl_add_uint16(be_attrs, BE_ATTR_UNMOUNT_FLAGS, 1359 unmount_flags) != 0) 1360 goto out; 1361 1362 err = be_unmount(be_attrs); 1363 1364 switch (err) { 1365 case BE_SUCCESS: 1366 (void) printf(_("Unmounted successfully\n")); 1367 break; 1368 case BE_ERR_BE_NOENT: 1369 (void) fprintf(stderr, _("%s does not exist or appear " 1370 "to be a valid BE.\nPlease check that the name of " 1371 "the BE provided is correct.\n"), obe_name); 1372 break; 1373 case BE_ERR_UMOUNT_CURR_BE: 1374 (void) fprintf(stderr, _("%s is the currently active BE.\n" 1375 "It cannot be unmounted unless another BE is the " 1376 "currently active BE.\n"), obe_name); 1377 break; 1378 case BE_ERR_UMOUNT_SHARED: 1379 (void) fprintf(stderr, _("%s is a shared file system and it " 1380 "cannot be unmounted.\n"), obe_name); 1381 break; 1382 case BE_ERR_PERM: 1383 case BE_ERR_ACCESS: 1384 (void) fprintf(stderr, _("Unable to unmount %s.\n"), obe_name); 1385 (void) fprintf(stderr, _("You have insufficient privileges to " 1386 "execute this command.\n")); 1387 break; 1388 default: 1389 (void) fprintf(stderr, _("Unable to unmount %s.\n"), obe_name); 1390 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1391 } 1392 1393 out: 1394 nvlist_free(be_attrs); 1395 return (err); 1396 } 1397 1398 static int 1399 be_do_rename(int argc, char **argv) 1400 { 1401 nvlist_t *be_attrs; 1402 char *obe_name; 1403 char *nbe_name; 1404 int err = 1; 1405 int c; 1406 1407 while ((c = getopt(argc, argv, "v")) != -1) { 1408 switch (c) { 1409 case 'v': 1410 libbe_print_errors(B_TRUE); 1411 break; 1412 default: 1413 usage(); 1414 return (1); 1415 } 1416 } 1417 1418 argc -= optind; 1419 argv += optind; 1420 1421 if (argc != 2) { 1422 usage(); 1423 return (1); 1424 } 1425 1426 obe_name = argv[0]; 1427 nbe_name = argv[1]; 1428 1429 if (be_nvl_alloc(&be_attrs) != 0) 1430 return (1); 1431 1432 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 1433 goto out; 1434 1435 if (be_nvl_add_string(be_attrs, BE_ATTR_NEW_BE_NAME, nbe_name) != 0) 1436 goto out; 1437 1438 err = be_rename(be_attrs); 1439 1440 switch (err) { 1441 case BE_SUCCESS: 1442 (void) printf(_("Renamed successfully\n")); 1443 break; 1444 case BE_ERR_BE_NOENT: 1445 (void) fprintf(stderr, _("%s does not exist or appear " 1446 "to be a valid BE.\nPlease check that the name of " 1447 "the BE provided is correct.\n"), obe_name); 1448 break; 1449 case BE_ERR_PERM: 1450 case BE_ERR_ACCESS: 1451 (void) fprintf(stderr, _("Rename of BE %s failed.\n"), 1452 obe_name); 1453 (void) fprintf(stderr, _("You have insufficient privileges to " 1454 "execute this command.\n")); 1455 break; 1456 default: 1457 (void) fprintf(stderr, _("Rename of BE %s failed.\n"), 1458 obe_name); 1459 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1460 } 1461 1462 out: 1463 nvlist_free(be_attrs); 1464 return (err); 1465 } 1466 1467 static int 1468 be_do_rollback(int argc, char **argv) 1469 { 1470 nvlist_t *be_attrs; 1471 char *obe_name; 1472 char *snap_name; 1473 int err = 1; 1474 int c; 1475 1476 while ((c = getopt(argc, argv, "v")) != -1) { 1477 switch (c) { 1478 case 'v': 1479 libbe_print_errors(B_TRUE); 1480 break; 1481 default: 1482 usage(); 1483 return (1); 1484 } 1485 } 1486 1487 argc -= optind; 1488 argv += optind; 1489 1490 if (argc < 1 || argc > 2) { 1491 usage(); 1492 return (1); 1493 } 1494 1495 obe_name = argv[0]; 1496 if (argc == 2) 1497 snap_name = argv[1]; 1498 else { /* argc == 1 */ 1499 if ((snap_name = strrchr(obe_name, '@')) != NULL) { 1500 if (snap_name[1] == '\0') { 1501 usage(); 1502 return (1); 1503 } 1504 1505 snap_name[0] = '\0'; 1506 snap_name++; 1507 } else { 1508 usage(); 1509 return (1); 1510 } 1511 } 1512 1513 if (be_nvl_alloc(&be_attrs) != 0) 1514 return (1); 1515 1516 if (be_nvl_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, obe_name) != 0) 1517 goto out; 1518 1519 if (be_nvl_add_string(be_attrs, BE_ATTR_SNAP_NAME, snap_name) != 0) 1520 goto out; 1521 1522 err = be_rollback(be_attrs); 1523 1524 switch (err) { 1525 case BE_SUCCESS: 1526 (void) printf(_("Rolled back successfully\n")); 1527 break; 1528 case BE_ERR_BE_NOENT: 1529 (void) fprintf(stderr, _("%s does not exist or appear " 1530 "to be a valid BE.\nPlease check that the name of " 1531 "the BE provided is correct.\n"), obe_name); 1532 break; 1533 case BE_ERR_SS_NOENT: 1534 (void) fprintf(stderr, _("%s does not exist or appear " 1535 "to be a valid snapshot.\nPlease check that the name of " 1536 "the snapshot provided is correct.\n"), snap_name); 1537 break; 1538 case BE_ERR_PERM: 1539 case BE_ERR_ACCESS: 1540 (void) fprintf(stderr, _("Rollback of BE %s snapshot %s " 1541 "failed.\n"), obe_name, snap_name); 1542 (void) fprintf(stderr, _("You have insufficient privileges to " 1543 "execute this command.\n")); 1544 break; 1545 default: 1546 (void) fprintf(stderr, _("Rollback of BE %s snapshot %s " 1547 "failed.\n"), obe_name, snap_name); 1548 (void) fprintf(stderr, "%s\n", be_err_to_str(err)); 1549 } 1550 1551 out: 1552 nvlist_free(be_attrs); 1553 return (err); 1554 } 1555