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