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