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