xref: /illumos-gate/usr/src/lib/libbe/common/be_utils.c (revision 5328fc53d11d7151861fa272e4fb0248b8f0e145)
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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25  * Copyright 2016 Toomas Soome <tsoome@me.com>
26  * Copyright (c) 2015 by Delphix. All rights reserved.
27  * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
28  * Copyright (c) 2018, Joyent, Inc.
29  */
30 
31 
32 /*
33  * System includes
34  */
35 #include <assert.h>
36 #include <errno.h>
37 #include <libgen.h>
38 #include <libintl.h>
39 #include <libnvpair.h>
40 #include <libzfs.h>
41 #include <libgen.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <sys/stat.h>
46 #include <sys/types.h>
47 #include <sys/vfstab.h>
48 #include <sys/param.h>
49 #include <sys/systeminfo.h>
50 #include <ctype.h>
51 #include <time.h>
52 #include <unistd.h>
53 #include <fcntl.h>
54 #include <deflt.h>
55 #include <wait.h>
56 #include <libdevinfo.h>
57 #include <libgen.h>
58 
59 #include <libbe.h>
60 #include <libbe_priv.h>
61 #include <boot_utils.h>
62 #include <ficl.h>
63 #include <ficlplatform/emu.h>
64 
65 /* Private function prototypes */
66 static int update_dataset(char *, int, char *, char *, char *);
67 static int _update_vfstab(char *, char *, char *, char *, be_fs_list_data_t *);
68 static int be_open_menu(char *, char *, FILE **, char *, boolean_t);
69 static int be_create_menu(char *, char *, FILE **, char *);
70 static char *be_get_auto_name(char *, char *, boolean_t);
71 
72 /*
73  * Global error printing
74  */
75 boolean_t do_print = B_FALSE;
76 
77 /*
78  * Private datatypes
79  */
80 typedef struct zone_be_name_cb_data {
81 	char *base_be_name;
82 	int num;
83 } zone_be_name_cb_data_t;
84 
85 /* ********************************************************************	*/
86 /*			Public Functions				*/
87 /* ******************************************************************** */
88 
89 /*
90  * Callback for ficl to suppress all output from ficl, as we do not
91  * want to confuse user with messages from ficl, and we are only
92  * checking results from function calls.
93  */
94 /*ARGSUSED*/
95 static void
96 ficlSuppressTextOutput(ficlCallback *cb, char *text)
97 {
98 	/* This function is intentionally doing nothing. */
99 }
100 
101 /*
102  * Function:	be_get_boot_args
103  * Description:	Returns the fast boot argument string for enumerated BE.
104  * Parameters:
105  *		fbarg - pointer to argument string.
106  *		entry - index of BE.
107  * Returns:
108  *		fast boot argument string.
109  * Scope:
110  *		Public
111  */
112 int
113 be_get_boot_args(char **fbarg, int entry)
114 {
115 	be_node_list_t *node, *be_nodes = NULL;
116 	be_transaction_data_t bt = {0};
117 	char *mountpoint = NULL;
118 	boolean_t be_mounted = B_FALSE;
119 	int ret = BE_SUCCESS;
120 	int index;
121 	ficlVm *vm;
122 
123 	*fbarg = NULL;
124 	if (!be_zfs_init())
125 		return (BE_ERR_INIT);
126 
127 	/*
128 	 * need pool name, menu.lst has entries from our pool only
129 	 */
130 	ret = be_find_current_be(&bt);
131 	if (ret != BE_SUCCESS) {
132 		be_zfs_fini();
133 		return (ret);
134 	}
135 
136 	/*
137 	 * be_get_boot_args() is for loader, fail with grub will trigger
138 	 * normal boot.
139 	 */
140 	if (be_has_grub()) {
141 		ret = BE_ERR_INIT;
142 		goto done;
143 	}
144 
145 	ret = _be_list(NULL, &be_nodes, BE_LIST_DEFAULT);
146 	if (ret != BE_SUCCESS)
147 		goto done;
148 
149 	/*
150 	 * iterate through be_nodes,
151 	 * if entry == -1, stop if be_active_on_boot,
152 	 * else stop if index == entry.
153 	 */
154 	index = 0;
155 	for (node = be_nodes; node != NULL; node = node->be_next_node) {
156 		if (strcmp(node->be_rpool, bt.obe_zpool) != 0)
157 			continue;
158 		if (entry == BE_ENTRY_DEFAULT &&
159 		    node->be_active_on_boot == B_TRUE)
160 			break;
161 		if (index == entry)
162 			break;
163 		index++;
164 	}
165 	if (node == NULL) {
166 		be_free_list(be_nodes);
167 		ret = BE_ERR_NOENT;
168 		goto done;
169 	}
170 
171 	/* try to mount inactive be */
172 	if (node->be_active == B_FALSE) {
173 		ret = _be_mount(node->be_node_name, &mountpoint,
174 		    BE_MOUNT_FLAG_NO_ZONES);
175 		if (ret != BE_SUCCESS && ret != BE_ERR_MOUNTED) {
176 			be_free_list(be_nodes);
177 			goto done;
178 		} else
179 			be_mounted = B_TRUE;
180 	}
181 
182 	vm = bf_init("", ficlSuppressTextOutput);
183 	if (vm != NULL) {
184 		/*
185 		 * zfs MAXNAMELEN is 256, so we need to pick buf large enough
186 		 * to contain such names.
187 		 */
188 		char buf[MAXNAMELEN * 2];
189 		char *kernel_options = NULL;
190 		char *kernel = NULL;
191 		char *tmp;
192 		zpool_handle_t *zph;
193 
194 		/*
195 		 * just try to interpret following words. on error
196 		 * we will be missing kernelname, and will get out.
197 		 */
198 		(void) snprintf(buf, sizeof (buf), "set currdev=zfs:%s:",
199 		    node->be_root_ds);
200 		ret = ficlVmEvaluate(vm, buf);
201 		if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
202 			be_print_err(gettext("be_get_boot_args: error "
203 			    "interpreting boot config: %d\n"), ret);
204 			bf_fini();
205 			ret = BE_ERR_NO_MENU;
206 			goto cleanup;
207 		}
208 		(void) snprintf(buf, sizeof (buf),
209 		    "include /boot/forth/loader.4th");
210 		ret = ficlVmEvaluate(vm, buf);
211 		if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
212 			be_print_err(gettext("be_get_boot_args: error "
213 			    "interpreting boot config: %d\n"), ret);
214 			bf_fini();
215 			ret = BE_ERR_NO_MENU;
216 			goto cleanup;
217 		}
218 		(void) snprintf(buf, sizeof (buf), "start");
219 		ret = ficlVmEvaluate(vm, buf);
220 		if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
221 			be_print_err(gettext("be_get_boot_args: error "
222 			    "interpreting boot config: %d\n"), ret);
223 			bf_fini();
224 			ret = BE_ERR_NO_MENU;
225 			goto cleanup;
226 		}
227 		(void) snprintf(buf, sizeof (buf), "boot");
228 		ret = ficlVmEvaluate(vm, buf);
229 		bf_fini();
230 		if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
231 			be_print_err(gettext("be_get_boot_args: error "
232 			    "interpreting boot config: %d\n"), ret);
233 			ret = BE_ERR_NO_MENU;
234 			goto cleanup;
235 		}
236 
237 		kernel_options = getenv("boot-args");
238 		kernel = getenv("kernelname");
239 
240 		if (kernel == NULL) {
241 			be_print_err(gettext("be_get_boot_args: no kernel\n"));
242 			ret = BE_ERR_NOENT;
243 			goto cleanup;
244 		}
245 
246 		if ((zph = zpool_open(g_zfs, node->be_rpool)) == NULL) {
247 			be_print_err(gettext("be_get_boot_args: failed to "
248 			    "open root pool (%s): %s\n"), node->be_rpool,
249 			    libzfs_error_description(g_zfs));
250 			ret = zfs_err_to_be_err(g_zfs);
251 			goto cleanup;
252 		}
253 		ret = zpool_get_physpath(zph, buf, sizeof (buf));
254 		zpool_close(zph);
255 		if (ret != 0) {
256 			be_print_err(gettext("be_get_boot_args: failed to "
257 			    "get physpath\n"));
258 			goto cleanup;
259 		}
260 
261 		/* zpool_get_physpath() can return space separated list */
262 		tmp = buf;
263 		tmp = strsep(&tmp, " ");
264 
265 		if (kernel_options == NULL || *kernel_options == '\0')
266 			(void) asprintf(fbarg, "/ %s "
267 			    "-B zfs-bootfs=%s,bootpath=\"%s\"\n", kernel,
268 			    node->be_root_ds, tmp);
269 		else
270 			(void) asprintf(fbarg, "/ %s %s "
271 			    "-B zfs-bootfs=%s,bootpath=\"%s\"\n", kernel,
272 			    kernel_options, node->be_root_ds, tmp);
273 
274 		if (*fbarg == NULL)
275 			ret = BE_ERR_NOMEM;
276 		else
277 			ret = 0;
278 	} else
279 		ret = BE_ERR_NOMEM;
280 cleanup:
281 	if (be_mounted == B_TRUE)
282 		(void) _be_unmount(node->be_node_name, BE_UNMOUNT_FLAG_FORCE);
283 	be_free_list(be_nodes);
284 done:
285 	free(mountpoint);
286 	free(bt.obe_name);
287 	free(bt.obe_root_ds);
288 	free(bt.obe_zpool);
289 	free(bt.obe_snap_name);
290 	free(bt.obe_altroot);
291 	be_zfs_fini();
292 	return (ret);
293 }
294 
295 /*
296  * Function:	be_max_avail
297  * Description:	Returns the available size for the zfs dataset passed in.
298  * Parameters:
299  *		dataset - The dataset we want to get the available space for.
300  *		ret - The available size will be returned in this.
301  * Returns:
302  *		The error returned by the zfs get property function.
303  * Scope:
304  *		Public
305  */
306 int
307 be_max_avail(char *dataset, uint64_t *ret)
308 {
309 	zfs_handle_t *zhp;
310 	int err = 0;
311 
312 	/* Initialize libzfs handle */
313 	if (!be_zfs_init())
314 		return (BE_ERR_INIT);
315 
316 	zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_DATASET);
317 	if (zhp == NULL) {
318 		/*
319 		 * The zfs_open failed return an error
320 		 */
321 		err = zfs_err_to_be_err(g_zfs);
322 	} else {
323 		err = be_maxsize_avail(zhp, ret);
324 	}
325 	ZFS_CLOSE(zhp);
326 	be_zfs_fini();
327 	return (err);
328 }
329 
330 /*
331  * Function:	libbe_print_errors
332  * Description:	Turns on/off error output for the library.
333  * Parameter:
334  *		set_do_print - Boolean that turns library error
335  *			       printing on or off.
336  * Returns:
337  *		None
338  * Scope:
339  *		Public;
340  */
341 void
342 libbe_print_errors(boolean_t set_do_print)
343 {
344 	do_print = set_do_print;
345 }
346 
347 /* ********************************************************************	*/
348 /*			Semi-Private Functions				*/
349 /* ******************************************************************** */
350 
351 /*
352  * Function:	be_zfs_init
353  * Description:	Initializes the libary global libzfs handle.
354  * Parameters:
355  *		None
356  * Returns:
357  *		B_TRUE - Success
358  *		B_FALSE - Failure
359  * Scope:
360  *		Semi-private (library wide use only)
361  */
362 boolean_t
363 be_zfs_init(void)
364 {
365 	be_zfs_fini();
366 
367 	if ((g_zfs = libzfs_init()) == NULL) {
368 		be_print_err(gettext("be_zfs_init: failed to initialize ZFS "
369 		    "library\n"));
370 		return (B_FALSE);
371 	}
372 
373 	return (B_TRUE);
374 }
375 
376 /*
377  * Function:	be_zfs_fini
378  * Description:	Closes the library global libzfs handle if it currently open.
379  * Parameter:
380  *		None
381  * Returns:
382  *		None
383  * Scope:
384  *		Semi-private (library wide use only)
385  */
386 void
387 be_zfs_fini(void)
388 {
389 	if (g_zfs)
390 		libzfs_fini(g_zfs);
391 
392 	g_zfs = NULL;
393 }
394 
395 /*
396  * Function:	be_get_defaults
397  * Description:	Open defaults and gets be default paramets
398  * Parameters:
399  *		defaults - be defaults struct
400  * Returns:
401  *		None
402  * Scope:
403  *		Semi-private (library wide use only)
404  */
405 void
406 be_get_defaults(struct be_defaults *defaults)
407 {
408 	void	*defp;
409 
410 	defaults->be_deflt_grub = B_FALSE;
411 	defaults->be_deflt_rpool_container = B_FALSE;
412 	defaults->be_deflt_bename_starts_with[0] = '\0';
413 
414 	if ((defp = defopen_r(BE_DEFAULTS)) != NULL) {
415 		const char *res = defread_r(BE_DFLT_BENAME_STARTS, defp);
416 		if (res != NULL && res[0] != '\0') {
417 			(void) strlcpy(defaults->be_deflt_bename_starts_with,
418 			    res, ZFS_MAX_DATASET_NAME_LEN);
419 			defaults->be_deflt_rpool_container = B_TRUE;
420 		}
421 		if (be_is_isa("i386")) {
422 			res = defread_r(BE_DFLT_BE_HAS_GRUB, defp);
423 			if (res != NULL && res[0] != '\0') {
424 				if (strcasecmp(res, "true") == 0)
425 					defaults->be_deflt_grub = B_TRUE;
426 			}
427 		}
428 		defclose_r(defp);
429 	}
430 }
431 
432 /*
433  * Function:	be_make_root_ds
434  * Description:	Generate string for BE's root dataset given the pool
435  *		it lives in and the BE name.
436  * Parameters:
437  *		zpool - pointer zpool name.
438  *		be_name - pointer to BE name.
439  *		be_root_ds - pointer to buffer to return BE root dataset in.
440  *		be_root_ds_size - size of be_root_ds
441  * Returns:
442  *		None
443  * Scope:
444  *		Semi-private (library wide use only)
445  */
446 void
447 be_make_root_ds(const char *zpool, const char *be_name, char *be_root_ds,
448     int be_root_ds_size)
449 {
450 	struct be_defaults be_defaults;
451 	be_get_defaults(&be_defaults);
452 	char	*root_ds = NULL;
453 
454 	if (getzoneid() == GLOBAL_ZONEID) {
455 		if (be_defaults.be_deflt_rpool_container) {
456 			(void) snprintf(be_root_ds, be_root_ds_size,
457 			    "%s/%s", zpool, be_name);
458 		} else {
459 			(void) snprintf(be_root_ds, be_root_ds_size,
460 			    "%s/%s/%s", zpool, BE_CONTAINER_DS_NAME, be_name);
461 		}
462 	} else {
463 		/*
464 		 * In non-global zone we can use path from mounted root dataset
465 		 * to generate BE's root dataset string.
466 		 */
467 		if ((root_ds = be_get_ds_from_dir("/")) != NULL) {
468 			(void) snprintf(be_root_ds, be_root_ds_size, "%s/%s",
469 			    dirname(root_ds), be_name);
470 		} else {
471 			be_print_err(gettext("be_make_root_ds: zone root "
472 			    "dataset is not mounted\n"));
473 			return;
474 		}
475 	}
476 }
477 
478 /*
479  * Function:	be_make_container_ds
480  * Description:	Generate string for the BE container dataset given a pool name.
481  * Parameters:
482  *		zpool - pointer zpool name.
483  *		container_ds - pointer to buffer to return BE container
484  *			dataset in.
485  *		container_ds_size - size of container_ds
486  * Returns:
487  *		None
488  * Scope:
489  *		Semi-private (library wide use only)
490  */
491 void
492 be_make_container_ds(const char *zpool,  char *container_ds,
493     int container_ds_size)
494 {
495 	struct be_defaults be_defaults;
496 	be_get_defaults(&be_defaults);
497 	char	*root_ds = NULL;
498 
499 	if (getzoneid() == GLOBAL_ZONEID) {
500 		if (be_defaults.be_deflt_rpool_container) {
501 			(void) snprintf(container_ds, container_ds_size,
502 			    "%s", zpool);
503 		} else {
504 			(void) snprintf(container_ds, container_ds_size,
505 			    "%s/%s", zpool, BE_CONTAINER_DS_NAME);
506 		}
507 	} else {
508 		if ((root_ds = be_get_ds_from_dir("/")) != NULL) {
509 			(void) strlcpy(container_ds, dirname(root_ds),
510 			    container_ds_size);
511 		} else {
512 			be_print_err(gettext("be_make_container_ds: zone root "
513 			    "dataset is not mounted\n"));
514 			return;
515 		}
516 	}
517 }
518 
519 /*
520  * Function:	be_make_name_from_ds
521  * Description:	This function takes a dataset name and strips off the
522  *		BE container dataset portion from the beginning.  The
523  *		returned name is allocated in heap storage, so the caller
524  *		is responsible for freeing it.
525  * Parameters:
526  *		dataset - dataset to get name from.
527  *		rc_loc - dataset underwhich the root container dataset lives.
528  * Returns:
529  *		name of dataset relative to BE container dataset.
530  *		NULL if dataset is not under a BE root dataset.
531  * Scope:
532  *		Semi-primate (library wide use only)
533  */
534 char *
535 be_make_name_from_ds(const char *dataset, char *rc_loc)
536 {
537 	char	ds[ZFS_MAX_DATASET_NAME_LEN];
538 	char	*tok = NULL;
539 	char	*name = NULL;
540 	struct be_defaults be_defaults;
541 	int	rlen = strlen(rc_loc);
542 
543 	be_get_defaults(&be_defaults);
544 
545 	/*
546 	 * First token is the location of where the root container dataset
547 	 * lives; it must match rc_loc.
548 	 */
549 	if (strncmp(dataset, rc_loc, rlen) == 0 && dataset[rlen] == '/')
550 		(void) strlcpy(ds, dataset + rlen + 1, sizeof (ds));
551 	else
552 		return (NULL);
553 
554 	if (be_defaults.be_deflt_rpool_container) {
555 		if ((name = strdup(ds)) == NULL) {
556 			be_print_err(gettext("be_make_name_from_ds: "
557 			    "memory allocation failed\n"));
558 			return (NULL);
559 		}
560 	} else {
561 		/* Second token must be BE container dataset name */
562 		if ((tok = strtok(ds, "/")) == NULL ||
563 		    strcmp(tok, BE_CONTAINER_DS_NAME) != 0)
564 			return (NULL);
565 
566 		/* Return the remaining token if one exists */
567 		if ((tok = strtok(NULL, "")) == NULL)
568 			return (NULL);
569 
570 		if ((name = strdup(tok)) == NULL) {
571 			be_print_err(gettext("be_make_name_from_ds: "
572 			    "memory allocation failed\n"));
573 			return (NULL);
574 		}
575 	}
576 
577 	return (name);
578 }
579 
580 /*
581  * Function:	be_maxsize_avail
582  * Description:	Returns the available size for the zfs handle passed in.
583  * Parameters:
584  *		zhp - A pointer to the open zfs handle.
585  *		ret - The available size will be returned in this.
586  * Returns:
587  *		The error returned by the zfs get property function.
588  * Scope:
589  *		Semi-private (library wide use only)
590  */
591 int
592 be_maxsize_avail(zfs_handle_t *zhp, uint64_t *ret)
593 {
594 	return ((*ret = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE)));
595 }
596 
597 /*
598  * Function:	be_append_menu
599  * Description:	Appends an entry for a BE into the menu.lst.
600  * Parameters:
601  *		be_name - pointer to name of BE to add boot menu entry for.
602  *		be_root_pool - pointer to name of pool BE lives in.
603  *		boot_pool - Used if the pool containing the grub menu is
604  *			    different than the one contaiing the BE. This
605  *			    will normally be NULL.
606  *		be_orig_root_ds - The root dataset for the BE. This is
607  *			used to check to see if an entry already exists
608  *			for this BE.
609  *		description - pointer to description of BE to be added in
610  *			the title line for this BEs entry.
611  * Returns:
612  *		BE_SUCCESS - Success
613  *		be_errno_t - Failure
614  * Scope:
615  *		Semi-private (library wide use only)
616  */
617 int
618 be_append_menu(char *be_name, char *be_root_pool, char *boot_pool,
619     char *be_orig_root_ds, char *description)
620 {
621 	zfs_handle_t *zhp = NULL;
622 	char menu_file[MAXPATHLEN];
623 	char be_root_ds[MAXPATHLEN];
624 	char line[BUFSIZ];
625 	char temp_line[BUFSIZ];
626 	char title[MAXPATHLEN];
627 	char *entries[BUFSIZ];
628 	char *tmp_entries[BUFSIZ];
629 	char *pool_mntpnt = NULL;
630 	char *ptmp_mntpnt = NULL;
631 	char *orig_mntpnt = NULL;
632 	boolean_t found_be = B_FALSE;
633 	boolean_t found_orig_be = B_FALSE;
634 	boolean_t found_title = B_FALSE;
635 	boolean_t pool_mounted = B_FALSE;
636 	boolean_t collect_lines = B_FALSE;
637 	FILE *menu_fp = NULL;
638 	int err = 0, ret = BE_SUCCESS;
639 	int i, num_tmp_lines = 0, num_lines = 0;
640 
641 	if (be_name == NULL || be_root_pool == NULL)
642 		return (BE_ERR_INVAL);
643 
644 	if (boot_pool == NULL)
645 		boot_pool = be_root_pool;
646 
647 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
648 		be_print_err(gettext("be_append_menu: failed to open "
649 		    "pool dataset for %s: %s\n"), be_root_pool,
650 		    libzfs_error_description(g_zfs));
651 		return (zfs_err_to_be_err(g_zfs));
652 	}
653 
654 	/*
655 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
656 	 * attempt to mount it.
657 	 */
658 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
659 	    &pool_mounted)) != BE_SUCCESS) {
660 		be_print_err(gettext("be_append_menu: pool dataset "
661 		    "(%s) could not be mounted\n"), be_root_pool);
662 		ZFS_CLOSE(zhp);
663 		return (ret);
664 	}
665 
666 	/*
667 	 * Get the mountpoint for the root pool dataset.
668 	 */
669 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
670 		be_print_err(gettext("be_append_menu: pool "
671 		    "dataset (%s) is not mounted. Can't set "
672 		    "the default BE in the grub menu.\n"), be_root_pool);
673 		ret = BE_ERR_NO_MENU;
674 		goto cleanup;
675 	}
676 
677 	/*
678 	 * Check to see if this system supports grub
679 	 */
680 	if (be_has_grub()) {
681 		(void) snprintf(menu_file, sizeof (menu_file),
682 		    "%s%s", pool_mntpnt, BE_GRUB_MENU);
683 	} else {
684 		(void) snprintf(menu_file, sizeof (menu_file),
685 		    "%s%s", pool_mntpnt, BE_SPARC_MENU);
686 	}
687 
688 	be_make_root_ds(be_root_pool, be_name, be_root_ds, sizeof (be_root_ds));
689 
690 	/*
691 	 * Iterate through menu first to make sure the BE doesn't already
692 	 * have an entry in the menu.
693 	 *
694 	 * Additionally while iterating through the menu, if we have an
695 	 * original root dataset for a BE we're cloning from, we need to keep
696 	 * track of that BE's menu entry. We will then use the lines from
697 	 * that entry to create the entry for the new BE.
698 	 */
699 	if ((ret = be_open_menu(be_root_pool, menu_file,
700 	    &menu_fp, "r", B_TRUE)) != BE_SUCCESS) {
701 		goto cleanup;
702 	} else if (menu_fp == NULL) {
703 		ret = BE_ERR_NO_MENU;
704 		goto cleanup;
705 	}
706 
707 	free(pool_mntpnt);
708 	pool_mntpnt = NULL;
709 
710 	while (fgets(line, BUFSIZ, menu_fp)) {
711 		char *tok = NULL;
712 
713 		(void) strlcpy(temp_line, line, BUFSIZ);
714 		tok = strtok(line, BE_WHITE_SPACE);
715 
716 		if (tok == NULL || tok[0] == '#') {
717 			continue;
718 		} else if (strcmp(tok, "title") == 0) {
719 			collect_lines = B_FALSE;
720 			if ((tok = strtok(NULL, "\n")) == NULL)
721 				(void) strlcpy(title, "", sizeof (title));
722 			else
723 				(void) strlcpy(title, tok, sizeof (title));
724 			found_title = B_TRUE;
725 
726 			if (num_tmp_lines != 0) {
727 				for (i = 0; i < num_tmp_lines; i++) {
728 					free(tmp_entries[i]);
729 					tmp_entries[i] = NULL;
730 				}
731 				num_tmp_lines = 0;
732 			}
733 		} else if (strcmp(tok, "bootfs") == 0) {
734 			char *bootfs = strtok(NULL, BE_WHITE_SPACE);
735 			found_title = B_FALSE;
736 			if (bootfs == NULL)
737 				continue;
738 
739 			if (strcmp(bootfs, be_root_ds) == 0) {
740 				found_be = B_TRUE;
741 				break;
742 			}
743 
744 			if (be_orig_root_ds != NULL &&
745 			    strcmp(bootfs, be_orig_root_ds) == 0 &&
746 			    !found_orig_be) {
747 				char str[BUFSIZ];
748 				found_orig_be = B_TRUE;
749 				num_lines = 0;
750 				/*
751 				 * Store the new title line
752 				 */
753 				(void) snprintf(str, BUFSIZ, "title %s\n",
754 				    description ? description : be_name);
755 				entries[num_lines] = strdup(str);
756 				num_lines++;
757 				/*
758 				 * If there are any lines between the title
759 				 * and the bootfs line store these. Also
760 				 * free the temporary lines.
761 				 */
762 				for (i = 0; i < num_tmp_lines; i++) {
763 					entries[num_lines] = tmp_entries[i];
764 					tmp_entries[i] = NULL;
765 					num_lines++;
766 				}
767 				num_tmp_lines = 0;
768 				/*
769 				 * Store the new bootfs line.
770 				 */
771 				(void) snprintf(str, BUFSIZ, "bootfs %s\n",
772 				    be_root_ds);
773 				entries[num_lines] = strdup(str);
774 				num_lines++;
775 				collect_lines = B_TRUE;
776 			}
777 		} else if (found_orig_be && collect_lines) {
778 			/*
779 			 * get the rest of the lines for the original BE and
780 			 * store them.
781 			 */
782 			if (strstr(line, BE_GRUB_COMMENT) != NULL ||
783 			    strstr(line, "BOOTADM") != NULL)
784 				continue;
785 			if (strcmp(tok, "splashimage") == 0) {
786 				entries[num_lines] =
787 				    strdup("splashimage "
788 				    "/boot/splashimage.xpm\n");
789 			} else {
790 				entries[num_lines] = strdup(temp_line);
791 			}
792 			num_lines++;
793 		} else if (found_title && !found_orig_be) {
794 			tmp_entries[num_tmp_lines] = strdup(temp_line);
795 			num_tmp_lines++;
796 		}
797 	}
798 
799 	(void) fclose(menu_fp);
800 
801 	if (found_be) {
802 		/*
803 		 * If an entry for this BE was already in the menu, then if
804 		 * that entry's title matches what we would have put in
805 		 * return success.  Otherwise return failure.
806 		 */
807 		char *new_title = description ? description : be_name;
808 
809 		if (strcmp(title, new_title) == 0) {
810 			ret = BE_SUCCESS;
811 			goto cleanup;
812 		} else {
813 			if (be_remove_menu(be_name, be_root_pool,
814 			    boot_pool) != BE_SUCCESS) {
815 				be_print_err(gettext("be_append_menu: "
816 				    "Failed to remove existing unusable "
817 				    "entry '%s' in boot menu.\n"), be_name);
818 				ret = BE_ERR_BE_EXISTS;
819 				goto cleanup;
820 			}
821 		}
822 	}
823 
824 	/* Append BE entry to the end of the file */
825 	menu_fp = fopen(menu_file, "a+");
826 	err = errno;
827 	if (menu_fp == NULL) {
828 		be_print_err(gettext("be_append_menu: failed "
829 		    "to open menu.lst file %s\n"), menu_file);
830 		ret = errno_to_be_err(err);
831 		goto cleanup;
832 	}
833 
834 	if (found_orig_be) {
835 		/*
836 		 * write out all the stored lines
837 		 */
838 		for (i = 0; i < num_lines; i++) {
839 			(void) fprintf(menu_fp, "%s", entries[i]);
840 			free(entries[i]);
841 		}
842 		num_lines = 0;
843 
844 		/*
845 		 * Check to see if this system supports grub
846 		 */
847 		if (be_has_grub())
848 			(void) fprintf(menu_fp, "%s\n", BE_GRUB_COMMENT);
849 		ret = BE_SUCCESS;
850 	} else {
851 		(void) fprintf(menu_fp, "title %s\n",
852 		    description ? description : be_name);
853 		(void) fprintf(menu_fp, "bootfs %s\n", be_root_ds);
854 
855 		/*
856 		 * Check to see if this system supports grub
857 		 */
858 		if (be_has_grub()) {
859 			(void) fprintf(menu_fp, "kernel$ "
860 			    "/platform/i86pc/kernel/$ISADIR/unix -B "
861 			    "$ZFS-BOOTFS\n");
862 			(void) fprintf(menu_fp, "module$ "
863 			    "/platform/i86pc/$ISADIR/boot_archive\n");
864 			(void) fprintf(menu_fp, "%s\n", BE_GRUB_COMMENT);
865 		}
866 		ret = BE_SUCCESS;
867 	}
868 	(void) fclose(menu_fp);
869 cleanup:
870 	if (pool_mounted) {
871 		int err = BE_SUCCESS;
872 		err = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
873 		if (ret == BE_SUCCESS)
874 			ret = err;
875 		free(orig_mntpnt);
876 		free(ptmp_mntpnt);
877 	}
878 	ZFS_CLOSE(zhp);
879 	if (num_tmp_lines > 0) {
880 		for (i = 0; i < num_tmp_lines; i++) {
881 			free(tmp_entries[i]);
882 			tmp_entries[i] = NULL;
883 		}
884 	}
885 	if (num_lines > 0) {
886 		for (i = 0; i < num_lines; i++) {
887 			free(entries[i]);
888 			entries[i] = NULL;
889 		}
890 	}
891 	return (ret);
892 }
893 
894 /*
895  * Function:	be_remove_menu
896  * Description:	Removes a BE's entry from a menu.lst file.
897  * Parameters:
898  *		be_name - the name of BE whose entry is to be removed from
899  *			the menu.lst file.
900  *		be_root_pool - the pool that be_name lives in.
901  *		boot_pool - the pool where the BE is, if different than
902  *			the pool containing the boot menu.  If this is
903  *			NULL it will be set to be_root_pool.
904  * Returns:
905  *		BE_SUCCESS - Success
906  *		be_errno_t - Failure
907  * Scope:
908  *		Semi-private (library wide use only)
909  */
910 int
911 be_remove_menu(char *be_name, char *be_root_pool, char *boot_pool)
912 {
913 	zfs_handle_t	*zhp = NULL;
914 	char		be_root_ds[MAXPATHLEN];
915 	char		**buffer = NULL;
916 	char		menu_buf[BUFSIZ];
917 	char		menu[MAXPATHLEN];
918 	char		*pool_mntpnt = NULL;
919 	char		*ptmp_mntpnt = NULL;
920 	char		*orig_mntpnt = NULL;
921 	char		*tmp_menu = NULL;
922 	FILE		*menu_fp = NULL;
923 	FILE		*tmp_menu_fp = NULL;
924 	struct stat	sb;
925 	int		ret = BE_SUCCESS;
926 	int		i;
927 	int		fd;
928 	int		err = 0;
929 	int		nlines = 0;
930 	int		default_entry = 0;
931 	int		entry_cnt = 0;
932 	int		entry_del = 0;
933 	int		num_entry_del = 0;
934 	int		tmp_menu_len = 0;
935 	boolean_t	write = B_TRUE;
936 	boolean_t	do_buffer = B_FALSE;
937 	boolean_t	pool_mounted = B_FALSE;
938 
939 	if (boot_pool == NULL)
940 		boot_pool = be_root_pool;
941 
942 	/* Get name of BE's root dataset */
943 	be_make_root_ds(be_root_pool, be_name, be_root_ds, sizeof (be_root_ds));
944 
945 	/* Get handle to pool dataset */
946 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
947 		be_print_err(gettext("be_remove_menu: "
948 		    "failed to open pool dataset for %s: %s"),
949 		    be_root_pool, libzfs_error_description(g_zfs));
950 		return (zfs_err_to_be_err(g_zfs));
951 	}
952 
953 	/*
954 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
955 	 * attempt to mount it.
956 	 */
957 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
958 	    &pool_mounted)) != BE_SUCCESS) {
959 		be_print_err(gettext("be_remove_menu: pool dataset "
960 		    "(%s) could not be mounted\n"), be_root_pool);
961 		ZFS_CLOSE(zhp);
962 		return (ret);
963 	}
964 
965 	/*
966 	 * Get the mountpoint for the root pool dataset.
967 	 */
968 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
969 		be_print_err(gettext("be_remove_menu: pool "
970 		    "dataset (%s) is not mounted. Can't set "
971 		    "the default BE in the grub menu.\n"), be_root_pool);
972 		ret = BE_ERR_NO_MENU;
973 		goto cleanup;
974 	}
975 
976 	/* Get path to boot menu */
977 	(void) strlcpy(menu, pool_mntpnt, sizeof (menu));
978 
979 	/*
980 	 * Check to see if this system supports grub
981 	 */
982 	if (be_has_grub())
983 		(void) strlcat(menu, BE_GRUB_MENU, sizeof (menu));
984 	else
985 		(void) strlcat(menu, BE_SPARC_MENU, sizeof (menu));
986 
987 	/* Get handle to boot menu file */
988 	if ((ret = be_open_menu(be_root_pool, menu, &menu_fp, "r",
989 	    B_TRUE)) != BE_SUCCESS) {
990 		goto cleanup;
991 	} else if (menu_fp == NULL) {
992 		ret = BE_ERR_NO_MENU;
993 		goto cleanup;
994 	}
995 
996 	free(pool_mntpnt);
997 	pool_mntpnt = NULL;
998 
999 	/* Grab the stats of the original menu file */
1000 	if (stat(menu, &sb) != 0) {
1001 		err = errno;
1002 		be_print_err(gettext("be_remove_menu: "
1003 		    "failed to stat file %s: %s\n"), menu, strerror(err));
1004 		ret = errno_to_be_err(err);
1005 		goto cleanup;
1006 	}
1007 
1008 	/* Create a tmp file for the modified menu.lst */
1009 	tmp_menu_len = strlen(menu) + 7;
1010 	if ((tmp_menu = (char *)malloc(tmp_menu_len)) == NULL) {
1011 		be_print_err(gettext("be_remove_menu: malloc failed\n"));
1012 		ret = BE_ERR_NOMEM;
1013 		goto cleanup;
1014 	}
1015 	(void) memset(tmp_menu, 0, tmp_menu_len);
1016 	(void) strlcpy(tmp_menu, menu, tmp_menu_len);
1017 	(void) strlcat(tmp_menu, "XXXXXX", tmp_menu_len);
1018 	if ((fd = mkstemp(tmp_menu)) == -1) {
1019 		err = errno;
1020 		be_print_err(gettext("be_remove_menu: mkstemp failed\n"));
1021 		ret = errno_to_be_err(err);
1022 		free(tmp_menu);
1023 		tmp_menu = NULL;
1024 		goto cleanup;
1025 	}
1026 	if ((tmp_menu_fp = fdopen(fd, "w")) == NULL) {
1027 		err = errno;
1028 		be_print_err(gettext("be_remove_menu: "
1029 		    "could not open tmp file for write: %s\n"), strerror(err));
1030 		(void) close(fd);
1031 		ret = errno_to_be_err(err);
1032 		goto cleanup;
1033 	}
1034 
1035 	while (fgets(menu_buf, BUFSIZ, menu_fp)) {
1036 		char tline [BUFSIZ];
1037 		char *tok = NULL;
1038 
1039 		(void) strlcpy(tline, menu_buf, sizeof (tline));
1040 
1041 		/* Tokenize line */
1042 		tok = strtok(tline, BE_WHITE_SPACE);
1043 
1044 		if (tok == NULL || tok[0] == '#') {
1045 			/* Found empty line or comment line */
1046 			if (do_buffer) {
1047 				/* Buffer this line */
1048 				if ((buffer = (char **)realloc(buffer,
1049 				    sizeof (char *)*(nlines + 1))) == NULL) {
1050 					ret = BE_ERR_NOMEM;
1051 					goto cleanup;
1052 				}
1053 				if ((buffer[nlines++] = strdup(menu_buf))
1054 				    == NULL) {
1055 					ret = BE_ERR_NOMEM;
1056 					goto cleanup;
1057 				}
1058 
1059 			} else if (write || strncmp(menu_buf, BE_GRUB_COMMENT,
1060 			    strlen(BE_GRUB_COMMENT)) != 0) {
1061 				/* Write this line out */
1062 				(void) fputs(menu_buf, tmp_menu_fp);
1063 			}
1064 		} else if (strcmp(tok, "default") == 0) {
1065 			/*
1066 			 * Record what 'default' is set to because we might
1067 			 * need to adjust this upon deleting an entry.
1068 			 */
1069 			tok = strtok(NULL, BE_WHITE_SPACE);
1070 
1071 			if (tok != NULL) {
1072 				default_entry = atoi(tok);
1073 			}
1074 
1075 			(void) fputs(menu_buf, tmp_menu_fp);
1076 		} else if (strcmp(tok, "title") == 0) {
1077 			/*
1078 			 * If we've reached a 'title' line and do_buffer is
1079 			 * is true, that means we've just buffered an entire
1080 			 * entry without finding a 'bootfs' directive.  We
1081 			 * need to write that entry out and keep searching.
1082 			 */
1083 			if (do_buffer) {
1084 				for (i = 0; i < nlines; i++) {
1085 					(void) fputs(buffer[i], tmp_menu_fp);
1086 					free(buffer[i]);
1087 				}
1088 				free(buffer);
1089 				buffer = NULL;
1090 				nlines = 0;
1091 			}
1092 
1093 			/*
1094 			 * Turn writing off and buffering on, and increment
1095 			 * our entry counter.
1096 			 */
1097 			write = B_FALSE;
1098 			do_buffer = B_TRUE;
1099 			entry_cnt++;
1100 
1101 			/* Buffer this 'title' line */
1102 			if ((buffer = (char **)realloc(buffer,
1103 			    sizeof (char *)*(nlines + 1))) == NULL) {
1104 				ret = BE_ERR_NOMEM;
1105 				goto cleanup;
1106 			}
1107 			if ((buffer[nlines++] = strdup(menu_buf)) == NULL) {
1108 				ret = BE_ERR_NOMEM;
1109 				goto cleanup;
1110 			}
1111 
1112 		} else if (strcmp(tok, "bootfs") == 0) {
1113 			char *bootfs = NULL;
1114 
1115 			/*
1116 			 * Found a 'bootfs' line.  See if it matches the
1117 			 * BE we're looking for.
1118 			 */
1119 			if ((bootfs = strtok(NULL, BE_WHITE_SPACE)) == NULL ||
1120 			    strcmp(bootfs, be_root_ds) != 0) {
1121 				/*
1122 				 * Either there's nothing after the 'bootfs'
1123 				 * or this is not the BE we're looking for,
1124 				 * write out the line(s) we've buffered since
1125 				 * finding the title.
1126 				 */
1127 				for (i = 0; i < nlines; i++) {
1128 					(void) fputs(buffer[i], tmp_menu_fp);
1129 					free(buffer[i]);
1130 				}
1131 				free(buffer);
1132 				buffer = NULL;
1133 				nlines = 0;
1134 
1135 				/*
1136 				 * Turn writing back on, and turn off buffering
1137 				 * since this isn't the entry we're looking
1138 				 * for.
1139 				 */
1140 				write = B_TRUE;
1141 				do_buffer = B_FALSE;
1142 
1143 				/* Write this 'bootfs' line out. */
1144 				(void) fputs(menu_buf, tmp_menu_fp);
1145 			} else {
1146 				/*
1147 				 * Found the entry we're looking for.
1148 				 * Record its entry number, increment the
1149 				 * number of entries we've deleted, and turn
1150 				 * writing off.  Also, throw away the lines
1151 				 * we've buffered for this entry so far, we
1152 				 * don't need them.
1153 				 */
1154 				entry_del = entry_cnt - 1;
1155 				num_entry_del++;
1156 				write = B_FALSE;
1157 				do_buffer = B_FALSE;
1158 
1159 				for (i = 0; i < nlines; i++) {
1160 					free(buffer[i]);
1161 				}
1162 				free(buffer);
1163 				buffer = NULL;
1164 				nlines = 0;
1165 			}
1166 		} else {
1167 			if (do_buffer) {
1168 				/* Buffer this line */
1169 				if ((buffer = (char **)realloc(buffer,
1170 				    sizeof (char *)*(nlines + 1))) == NULL) {
1171 					ret = BE_ERR_NOMEM;
1172 					goto cleanup;
1173 				}
1174 				if ((buffer[nlines++] = strdup(menu_buf))
1175 				    == NULL) {
1176 					ret = BE_ERR_NOMEM;
1177 					goto cleanup;
1178 				}
1179 			} else if (write) {
1180 				/* Write this line out */
1181 				(void) fputs(menu_buf, tmp_menu_fp);
1182 			}
1183 		}
1184 	}
1185 
1186 	(void) fclose(menu_fp);
1187 	menu_fp = NULL;
1188 	(void) fclose(tmp_menu_fp);
1189 	tmp_menu_fp = NULL;
1190 
1191 	/* Copy the modified menu.lst into place */
1192 	if (rename(tmp_menu, menu) != 0) {
1193 		err = errno;
1194 		be_print_err(gettext("be_remove_menu: "
1195 		    "failed to rename file %s to %s: %s\n"),
1196 		    tmp_menu, menu, strerror(err));
1197 		ret = errno_to_be_err(err);
1198 		goto cleanup;
1199 	}
1200 	free(tmp_menu);
1201 	tmp_menu = NULL;
1202 
1203 	/*
1204 	 * If we've removed an entry, see if we need to
1205 	 * adjust the default value in the menu.lst.  If the
1206 	 * entry we've deleted comes before the default entry
1207 	 * we need to adjust the default value accordingly.
1208 	 *
1209 	 * be_has_grub is used here to check to see if this system
1210 	 * supports grub.
1211 	 */
1212 	if (be_has_grub() && num_entry_del > 0) {
1213 		if (entry_del <= default_entry) {
1214 			default_entry = default_entry - num_entry_del;
1215 			if (default_entry < 0)
1216 				default_entry = 0;
1217 
1218 			/*
1219 			 * Adjust the default value by rewriting the
1220 			 * menu.lst file.  This may be overkill, but to
1221 			 * preserve the location of the 'default' entry
1222 			 * in the file, we need to do this.
1223 			 */
1224 
1225 			/* Get handle to boot menu file */
1226 			if ((menu_fp = fopen(menu, "r")) == NULL) {
1227 				err = errno;
1228 				be_print_err(gettext("be_remove_menu: "
1229 				    "failed to open menu.lst (%s): %s\n"),
1230 				    menu, strerror(err));
1231 				ret = errno_to_be_err(err);
1232 				goto cleanup;
1233 			}
1234 
1235 			/* Create a tmp file for the modified menu.lst */
1236 			tmp_menu_len = strlen(menu) + 7;
1237 			if ((tmp_menu = (char *)malloc(tmp_menu_len))
1238 			    == NULL) {
1239 				be_print_err(gettext("be_remove_menu: "
1240 				    "malloc failed\n"));
1241 				ret = BE_ERR_NOMEM;
1242 				goto cleanup;
1243 			}
1244 			(void) memset(tmp_menu, 0, tmp_menu_len);
1245 			(void) strlcpy(tmp_menu, menu, tmp_menu_len);
1246 			(void) strlcat(tmp_menu, "XXXXXX", tmp_menu_len);
1247 			if ((fd = mkstemp(tmp_menu)) == -1) {
1248 				err = errno;
1249 				be_print_err(gettext("be_remove_menu: "
1250 				    "mkstemp failed: %s\n"), strerror(err));
1251 				ret = errno_to_be_err(err);
1252 				free(tmp_menu);
1253 				tmp_menu = NULL;
1254 				goto cleanup;
1255 			}
1256 			if ((tmp_menu_fp = fdopen(fd, "w")) == NULL) {
1257 				err = errno;
1258 				be_print_err(gettext("be_remove_menu: "
1259 				    "could not open tmp file for write: %s\n"),
1260 				    strerror(err));
1261 				(void) close(fd);
1262 				ret = errno_to_be_err(err);
1263 				goto cleanup;
1264 			}
1265 
1266 			while (fgets(menu_buf, BUFSIZ, menu_fp)) {
1267 				char tline [BUFSIZ];
1268 				char *tok = NULL;
1269 
1270 				(void) strlcpy(tline, menu_buf, sizeof (tline));
1271 
1272 				/* Tokenize line */
1273 				tok = strtok(tline, BE_WHITE_SPACE);
1274 
1275 				if (tok == NULL) {
1276 					/* Found empty line, write it out */
1277 					(void) fputs(menu_buf, tmp_menu_fp);
1278 				} else if (strcmp(tok, "default") == 0) {
1279 					/* Found the default line, adjust it */
1280 					(void) snprintf(tline, sizeof (tline),
1281 					    "default %d\n", default_entry);
1282 
1283 					(void) fputs(tline, tmp_menu_fp);
1284 				} else {
1285 					/* Pass through all other lines */
1286 					(void) fputs(menu_buf, tmp_menu_fp);
1287 				}
1288 			}
1289 
1290 			(void) fclose(menu_fp);
1291 			menu_fp = NULL;
1292 			(void) fclose(tmp_menu_fp);
1293 			tmp_menu_fp = NULL;
1294 
1295 			/* Copy the modified menu.lst into place */
1296 			if (rename(tmp_menu, menu) != 0) {
1297 				err = errno;
1298 				be_print_err(gettext("be_remove_menu: "
1299 				    "failed to rename file %s to %s: %s\n"),
1300 				    tmp_menu, menu, strerror(err));
1301 				ret = errno_to_be_err(err);
1302 				goto cleanup;
1303 			}
1304 
1305 			free(tmp_menu);
1306 			tmp_menu = NULL;
1307 		}
1308 	}
1309 
1310 	/* Set the perms and ownership of the updated file */
1311 	if (chmod(menu, sb.st_mode) != 0) {
1312 		err = errno;
1313 		be_print_err(gettext("be_remove_menu: "
1314 		    "failed to chmod %s: %s\n"), menu, strerror(err));
1315 		ret = errno_to_be_err(err);
1316 		goto cleanup;
1317 	}
1318 	if (chown(menu, sb.st_uid, sb.st_gid) != 0) {
1319 		err = errno;
1320 		be_print_err(gettext("be_remove_menu: "
1321 		    "failed to chown %s: %s\n"), menu, strerror(err));
1322 		ret = errno_to_be_err(err);
1323 		goto cleanup;
1324 	}
1325 
1326 cleanup:
1327 	if (pool_mounted) {
1328 		int err = BE_SUCCESS;
1329 		err = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
1330 		if (ret == BE_SUCCESS)
1331 			ret = err;
1332 		free(orig_mntpnt);
1333 		free(ptmp_mntpnt);
1334 	}
1335 	ZFS_CLOSE(zhp);
1336 
1337 	free(buffer);
1338 	if (menu_fp != NULL)
1339 		(void) fclose(menu_fp);
1340 	if (tmp_menu_fp != NULL)
1341 		(void) fclose(tmp_menu_fp);
1342 	if (tmp_menu != NULL) {
1343 		(void) unlink(tmp_menu);
1344 		free(tmp_menu);
1345 	}
1346 
1347 	return (ret);
1348 }
1349 
1350 /*
1351  * Function:	be_default_grub_bootfs
1352  * Description:	This function returns the dataset in the default entry of
1353  *		the grub menu. If no default entry is found with a valid bootfs
1354  *		entry NULL is returned.
1355  * Parameters:
1356  *		be_root_pool - This is the name of the root pool where the
1357  *			       grub menu can be found.
1358  *              def_bootfs - This is used to pass back the bootfs string. On
1359  *				error NULL is returned here.
1360  * Returns:
1361  *		Success - BE_SUCCESS is returned.
1362  *		Failure - a be_errno_t is returned.
1363  * Scope:
1364  *		Semi-private (library wide use only)
1365  */
1366 int
1367 be_default_grub_bootfs(const char *be_root_pool, char **def_bootfs)
1368 {
1369 	zfs_handle_t	*zhp = NULL;
1370 	char		grub_file[MAXPATHLEN];
1371 	FILE		*menu_fp;
1372 	char		line[BUFSIZ];
1373 	char		*pool_mntpnt = NULL;
1374 	char		*ptmp_mntpnt = NULL;
1375 	char		*orig_mntpnt = NULL;
1376 	int		default_entry = 0, entries = 0;
1377 	int		found_default = 0;
1378 	int		ret = BE_SUCCESS;
1379 	boolean_t	pool_mounted = B_FALSE;
1380 
1381 	errno = 0;
1382 
1383 	/*
1384 	 * Check to see if this system supports grub
1385 	 */
1386 	if (!be_has_grub()) {
1387 		be_print_err(gettext("be_default_grub_bootfs: operation "
1388 		    "not supported on this architecture\n"));
1389 		return (BE_ERR_NOTSUP);
1390 	}
1391 
1392 	*def_bootfs = NULL;
1393 
1394 	/* Get handle to pool dataset */
1395 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
1396 		be_print_err(gettext("be_default_grub_bootfs: "
1397 		    "failed to open pool dataset for %s: %s"),
1398 		    be_root_pool, libzfs_error_description(g_zfs));
1399 		return (zfs_err_to_be_err(g_zfs));
1400 	}
1401 
1402 	/*
1403 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
1404 	 * attempt to mount it.
1405 	 */
1406 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
1407 	    &pool_mounted)) != BE_SUCCESS) {
1408 		be_print_err(gettext("be_default_grub_bootfs: pool dataset "
1409 		    "(%s) could not be mounted\n"), be_root_pool);
1410 		ZFS_CLOSE(zhp);
1411 		return (ret);
1412 	}
1413 
1414 	/*
1415 	 * Get the mountpoint for the root pool dataset.
1416 	 */
1417 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
1418 		be_print_err(gettext("be_default_grub_bootfs: failed "
1419 		    "to get mount point for the root pool. Can't set "
1420 		    "the default BE in the grub menu.\n"));
1421 		ret = BE_ERR_NO_MENU;
1422 		goto cleanup;
1423 	}
1424 
1425 	(void) snprintf(grub_file, MAXPATHLEN, "%s%s",
1426 	    pool_mntpnt, BE_GRUB_MENU);
1427 
1428 	if ((ret = be_open_menu((char *)be_root_pool, grub_file,
1429 	    &menu_fp, "r", B_FALSE)) != BE_SUCCESS) {
1430 		goto cleanup;
1431 	} else if (menu_fp == NULL) {
1432 		ret = BE_ERR_NO_MENU;
1433 		goto cleanup;
1434 	}
1435 
1436 	free(pool_mntpnt);
1437 	pool_mntpnt = NULL;
1438 
1439 	while (fgets(line, BUFSIZ, menu_fp)) {
1440 		char *tok = strtok(line, BE_WHITE_SPACE);
1441 
1442 		if (tok != NULL && tok[0] != '#') {
1443 			if (!found_default) {
1444 				if (strcmp(tok, "default") == 0) {
1445 					tok = strtok(NULL, BE_WHITE_SPACE);
1446 					if (tok != NULL) {
1447 						default_entry = atoi(tok);
1448 						rewind(menu_fp);
1449 						found_default = 1;
1450 					}
1451 				}
1452 				continue;
1453 			}
1454 			if (strcmp(tok, "title") == 0) {
1455 				entries++;
1456 			} else if (default_entry == entries - 1) {
1457 				if (strcmp(tok, "bootfs") == 0) {
1458 					tok = strtok(NULL, BE_WHITE_SPACE);
1459 					(void) fclose(menu_fp);
1460 
1461 					if (tok == NULL) {
1462 						ret = BE_SUCCESS;
1463 						goto cleanup;
1464 					}
1465 
1466 					if ((*def_bootfs = strdup(tok)) !=
1467 					    NULL) {
1468 						ret = BE_SUCCESS;
1469 						goto cleanup;
1470 					}
1471 					be_print_err(gettext(
1472 					    "be_default_grub_bootfs: "
1473 					    "memory allocation failed\n"));
1474 					ret = BE_ERR_NOMEM;
1475 					goto cleanup;
1476 				}
1477 			} else if (default_entry < entries - 1) {
1478 				/*
1479 				 * no bootfs entry for the default entry.
1480 				 */
1481 				break;
1482 			}
1483 		}
1484 	}
1485 	(void) fclose(menu_fp);
1486 
1487 cleanup:
1488 	if (pool_mounted) {
1489 		int err = BE_SUCCESS;
1490 		err = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
1491 		if (ret == BE_SUCCESS)
1492 			ret = err;
1493 		free(orig_mntpnt);
1494 		free(ptmp_mntpnt);
1495 	}
1496 	ZFS_CLOSE(zhp);
1497 	return (ret);
1498 }
1499 
1500 /*
1501  * Function:	be_change_grub_default
1502  * Description:	This function takes two parameters. These are the name of
1503  *		the BE we want to have as the default booted in the grub
1504  *		menu and the root pool where the path to the grub menu exists.
1505  *		The code takes this and finds the BE's entry in the grub menu
1506  *		and changes the default entry to point to that entry in the
1507  *		list.
1508  * Parameters:
1509  *		be_name - This is the name of the BE wanted as the default
1510  *			for the next boot.
1511  *		be_root_pool - This is the name of the root pool where the
1512  *			grub menu can be found.
1513  * Returns:
1514  *		BE_SUCCESS - Success
1515  *		be_errno_t - Failure
1516  * Scope:
1517  *		Semi-private (library wide use only)
1518  */
1519 int
1520 be_change_grub_default(char *be_name, char *be_root_pool)
1521 {
1522 	zfs_handle_t	*zhp = NULL;
1523 	char	grub_file[MAXPATHLEN];
1524 	char	*temp_grub = NULL;
1525 	char	*pool_mntpnt = NULL;
1526 	char	*ptmp_mntpnt = NULL;
1527 	char	*orig_mntpnt = NULL;
1528 	char	line[BUFSIZ];
1529 	char	temp_line[BUFSIZ];
1530 	char	be_root_ds[MAXPATHLEN];
1531 	FILE	*grub_fp = NULL;
1532 	FILE	*temp_fp = NULL;
1533 	struct stat	sb;
1534 	int	temp_grub_len = 0;
1535 	int	fd, entries = 0;
1536 	int	err = 0;
1537 	int	ret = BE_SUCCESS;
1538 	boolean_t	found_default = B_FALSE;
1539 	boolean_t	pool_mounted = B_FALSE;
1540 
1541 	errno = 0;
1542 
1543 	/*
1544 	 * Check to see if this system supports grub
1545 	 */
1546 	if (!be_has_grub()) {
1547 		be_print_err(gettext("be_change_grub_default: operation "
1548 		    "not supported on this architecture\n"));
1549 		return (BE_ERR_NOTSUP);
1550 	}
1551 
1552 	/* Generate string for BE's root dataset */
1553 	be_make_root_ds(be_root_pool, be_name, be_root_ds, sizeof (be_root_ds));
1554 
1555 	/* Get handle to pool dataset */
1556 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
1557 		be_print_err(gettext("be_change_grub_default: "
1558 		    "failed to open pool dataset for %s: %s"),
1559 		    be_root_pool, libzfs_error_description(g_zfs));
1560 		return (zfs_err_to_be_err(g_zfs));
1561 	}
1562 
1563 	/*
1564 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
1565 	 * attempt to mount it.
1566 	 */
1567 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
1568 	    &pool_mounted)) != BE_SUCCESS) {
1569 		be_print_err(gettext("be_change_grub_default: pool dataset "
1570 		    "(%s) could not be mounted\n"), be_root_pool);
1571 		ZFS_CLOSE(zhp);
1572 		return (ret);
1573 	}
1574 
1575 	/*
1576 	 * Get the mountpoint for the root pool dataset.
1577 	 */
1578 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
1579 		be_print_err(gettext("be_change_grub_default: pool "
1580 		    "dataset (%s) is not mounted. Can't set "
1581 		    "the default BE in the grub menu.\n"), be_root_pool);
1582 		ret = BE_ERR_NO_MENU;
1583 		goto cleanup;
1584 	}
1585 
1586 	(void) snprintf(grub_file, MAXPATHLEN, "%s%s",
1587 	    pool_mntpnt, BE_GRUB_MENU);
1588 
1589 	if ((ret = be_open_menu(be_root_pool, grub_file,
1590 	    &grub_fp, "r+", B_TRUE)) != BE_SUCCESS) {
1591 		goto cleanup;
1592 	} else if (grub_fp == NULL) {
1593 		ret = BE_ERR_NO_MENU;
1594 		goto cleanup;
1595 	}
1596 
1597 	free(pool_mntpnt);
1598 	pool_mntpnt = NULL;
1599 
1600 	/* Grab the stats of the original menu file */
1601 	if (stat(grub_file, &sb) != 0) {
1602 		err = errno;
1603 		be_print_err(gettext("be_change_grub_default: "
1604 		    "failed to stat file %s: %s\n"), grub_file, strerror(err));
1605 		ret = errno_to_be_err(err);
1606 		goto cleanup;
1607 	}
1608 
1609 	/* Create a tmp file for the modified menu.lst */
1610 	temp_grub_len = strlen(grub_file) + 7;
1611 	if ((temp_grub = (char *)malloc(temp_grub_len)) == NULL) {
1612 		be_print_err(gettext("be_change_grub_default: "
1613 		    "malloc failed\n"));
1614 		ret = BE_ERR_NOMEM;
1615 		goto cleanup;
1616 	}
1617 	(void) memset(temp_grub, 0, temp_grub_len);
1618 	(void) strlcpy(temp_grub, grub_file, temp_grub_len);
1619 	(void) strlcat(temp_grub, "XXXXXX", temp_grub_len);
1620 	if ((fd = mkstemp(temp_grub)) == -1) {
1621 		err = errno;
1622 		be_print_err(gettext("be_change_grub_default: "
1623 		    "mkstemp failed: %s\n"), strerror(err));
1624 		ret = errno_to_be_err(err);
1625 		free(temp_grub);
1626 		temp_grub = NULL;
1627 		goto cleanup;
1628 	}
1629 	if ((temp_fp = fdopen(fd, "w")) == NULL) {
1630 		err = errno;
1631 		be_print_err(gettext("be_change_grub_default: "
1632 		    "failed to open %s file: %s\n"),
1633 		    temp_grub, strerror(err));
1634 		(void) close(fd);
1635 		ret = errno_to_be_err(err);
1636 		goto cleanup;
1637 	}
1638 
1639 	while (fgets(line, BUFSIZ, grub_fp)) {
1640 		char *tok = strtok(line, BE_WHITE_SPACE);
1641 
1642 		if (tok == NULL || tok[0] == '#') {
1643 			continue;
1644 		} else if (strcmp(tok, "title") == 0) {
1645 			entries++;
1646 			continue;
1647 		} else if (strcmp(tok, "bootfs") == 0) {
1648 			char *bootfs = strtok(NULL, BE_WHITE_SPACE);
1649 			if (bootfs == NULL)
1650 				continue;
1651 
1652 			if (strcmp(bootfs, be_root_ds) == 0) {
1653 				found_default = B_TRUE;
1654 				break;
1655 			}
1656 		}
1657 	}
1658 
1659 	if (!found_default) {
1660 		be_print_err(gettext("be_change_grub_default: failed "
1661 		    "to find entry for %s in the grub menu\n"),
1662 		    be_name);
1663 		ret = BE_ERR_BE_NOENT;
1664 		goto cleanup;
1665 	}
1666 
1667 	rewind(grub_fp);
1668 
1669 	while (fgets(line, BUFSIZ, grub_fp)) {
1670 		char *tok = NULL;
1671 
1672 		(void) strncpy(temp_line, line, BUFSIZ);
1673 
1674 		if ((tok = strtok(temp_line, BE_WHITE_SPACE)) != NULL &&
1675 		    strcmp(tok, "default") == 0) {
1676 			(void) snprintf(temp_line, BUFSIZ, "default %d\n",
1677 			    entries - 1 >= 0 ? entries - 1 : 0);
1678 			(void) fputs(temp_line, temp_fp);
1679 		} else {
1680 			(void) fputs(line, temp_fp);
1681 		}
1682 	}
1683 
1684 	(void) fclose(grub_fp);
1685 	grub_fp = NULL;
1686 	(void) fclose(temp_fp);
1687 	temp_fp = NULL;
1688 
1689 	if (rename(temp_grub, grub_file) != 0) {
1690 		err = errno;
1691 		be_print_err(gettext("be_change_grub_default: "
1692 		    "failed to rename file %s to %s: %s\n"),
1693 		    temp_grub, grub_file, strerror(err));
1694 		ret = errno_to_be_err(err);
1695 		goto cleanup;
1696 	}
1697 	free(temp_grub);
1698 	temp_grub = NULL;
1699 
1700 	/* Set the perms and ownership of the updated file */
1701 	if (chmod(grub_file, sb.st_mode) != 0) {
1702 		err = errno;
1703 		be_print_err(gettext("be_change_grub_default: "
1704 		    "failed to chmod %s: %s\n"), grub_file, strerror(err));
1705 		ret = errno_to_be_err(err);
1706 		goto cleanup;
1707 	}
1708 	if (chown(grub_file, sb.st_uid, sb.st_gid) != 0) {
1709 		err = errno;
1710 		be_print_err(gettext("be_change_grub_default: "
1711 		    "failed to chown %s: %s\n"), grub_file, strerror(err));
1712 		ret = errno_to_be_err(err);
1713 	}
1714 
1715 cleanup:
1716 	if (pool_mounted) {
1717 		int err = BE_SUCCESS;
1718 		err = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
1719 		if (ret == BE_SUCCESS)
1720 			ret = err;
1721 		free(orig_mntpnt);
1722 		free(ptmp_mntpnt);
1723 	}
1724 	ZFS_CLOSE(zhp);
1725 	if (grub_fp != NULL)
1726 		(void) fclose(grub_fp);
1727 	if (temp_fp != NULL)
1728 		(void) fclose(temp_fp);
1729 	if (temp_grub != NULL) {
1730 		(void) unlink(temp_grub);
1731 		free(temp_grub);
1732 	}
1733 
1734 	return (ret);
1735 }
1736 
1737 /*
1738  * Function:	be_update_menu
1739  * Description:	This function is used by be_rename to change the BE name in
1740  *		an existing entry in the grub menu to the new name of the BE.
1741  * Parameters:
1742  *		be_orig_name - the original name of the BE
1743  *		be_new_name - the new name the BE is being renameed to.
1744  *		be_root_pool - The pool which contains the grub menu
1745  *		boot_pool - the pool where the BE is, if different than
1746  *			the pool containing the boot menu.  If this is
1747  *			NULL it will be set to be_root_pool.
1748  * Returns:
1749  *		BE_SUCCESS - Success
1750  *		be_errno_t - Failure
1751  * Scope:
1752  *		Semi-private (library wide use only)
1753  */
1754 int
1755 be_update_menu(char *be_orig_name, char *be_new_name, char *be_root_pool,
1756     char *boot_pool)
1757 {
1758 	zfs_handle_t *zhp = NULL;
1759 	char menu_file[MAXPATHLEN];
1760 	char be_root_ds[MAXPATHLEN];
1761 	char be_new_root_ds[MAXPATHLEN];
1762 	char line[BUFSIZ];
1763 	char *pool_mntpnt = NULL;
1764 	char *ptmp_mntpnt = NULL;
1765 	char *orig_mntpnt = NULL;
1766 	char *temp_menu = NULL;
1767 	FILE *menu_fp = NULL;
1768 	FILE *new_fp = NULL;
1769 	struct stat sb;
1770 	int temp_menu_len = 0;
1771 	int tmp_fd;
1772 	int ret = BE_SUCCESS;
1773 	int err = 0;
1774 	boolean_t pool_mounted = B_FALSE;
1775 
1776 	errno = 0;
1777 
1778 	if (boot_pool == NULL)
1779 		boot_pool = be_root_pool;
1780 
1781 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
1782 		be_print_err(gettext("be_update_menu: failed to open "
1783 		    "pool dataset for %s: %s\n"), be_root_pool,
1784 		    libzfs_error_description(g_zfs));
1785 		return (zfs_err_to_be_err(g_zfs));
1786 	}
1787 
1788 	/*
1789 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
1790 	 * attempt to mount it.
1791 	 */
1792 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
1793 	    &pool_mounted)) != BE_SUCCESS) {
1794 		be_print_err(gettext("be_update_menu: pool dataset "
1795 		    "(%s) could not be mounted\n"), be_root_pool);
1796 		ZFS_CLOSE(zhp);
1797 		return (ret);
1798 	}
1799 
1800 	/*
1801 	 * Get the mountpoint for the root pool dataset.
1802 	 */
1803 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
1804 		be_print_err(gettext("be_update_menu: failed "
1805 		    "to get mount point for the root pool. Can't set "
1806 		    "the default BE in the grub menu.\n"));
1807 		ret = BE_ERR_NO_MENU;
1808 		goto cleanup;
1809 	}
1810 
1811 	/*
1812 	 * Check to see if this system supports grub
1813 	 */
1814 	if (be_has_grub()) {
1815 		(void) snprintf(menu_file, sizeof (menu_file),
1816 		    "%s%s", pool_mntpnt, BE_GRUB_MENU);
1817 	} else {
1818 		(void) snprintf(menu_file, sizeof (menu_file),
1819 		    "%s%s", pool_mntpnt, BE_SPARC_MENU);
1820 	}
1821 
1822 	be_make_root_ds(be_root_pool, be_orig_name, be_root_ds,
1823 	    sizeof (be_root_ds));
1824 	be_make_root_ds(be_root_pool, be_new_name, be_new_root_ds,
1825 	    sizeof (be_new_root_ds));
1826 
1827 	if ((ret = be_open_menu(be_root_pool, menu_file,
1828 	    &menu_fp, "r", B_TRUE)) != BE_SUCCESS) {
1829 		goto cleanup;
1830 	} else if (menu_fp == NULL) {
1831 		ret = BE_ERR_NO_MENU;
1832 		goto cleanup;
1833 	}
1834 
1835 	free(pool_mntpnt);
1836 	pool_mntpnt = NULL;
1837 
1838 	/* Grab the stat of the original menu file */
1839 	if (stat(menu_file, &sb) != 0) {
1840 		err = errno;
1841 		be_print_err(gettext("be_update_menu: "
1842 		    "failed to stat file %s: %s\n"), menu_file, strerror(err));
1843 		(void) fclose(menu_fp);
1844 		ret = errno_to_be_err(err);
1845 		goto cleanup;
1846 	}
1847 
1848 	/* Create tmp file for modified menu.lst */
1849 	temp_menu_len = strlen(menu_file) + 7;
1850 	if ((temp_menu = (char *)malloc(temp_menu_len))
1851 	    == NULL) {
1852 		be_print_err(gettext("be_update_menu: "
1853 		    "malloc failed\n"));
1854 		(void) fclose(menu_fp);
1855 		ret = BE_ERR_NOMEM;
1856 		goto cleanup;
1857 	}
1858 	(void) memset(temp_menu, 0, temp_menu_len);
1859 	(void) strlcpy(temp_menu, menu_file, temp_menu_len);
1860 	(void) strlcat(temp_menu, "XXXXXX", temp_menu_len);
1861 	if ((tmp_fd = mkstemp(temp_menu)) == -1) {
1862 		err = errno;
1863 		be_print_err(gettext("be_update_menu: "
1864 		    "mkstemp failed: %s\n"), strerror(err));
1865 		(void) fclose(menu_fp);
1866 		free(temp_menu);
1867 		ret = errno_to_be_err(err);
1868 		goto cleanup;
1869 	}
1870 	if ((new_fp = fdopen(tmp_fd, "w")) == NULL) {
1871 		err = errno;
1872 		be_print_err(gettext("be_update_menu: "
1873 		    "fdopen failed: %s\n"), strerror(err));
1874 		(void) close(tmp_fd);
1875 		(void) fclose(menu_fp);
1876 		free(temp_menu);
1877 		ret = errno_to_be_err(err);
1878 		goto cleanup;
1879 	}
1880 
1881 	while (fgets(line, BUFSIZ, menu_fp)) {
1882 		char tline[BUFSIZ];
1883 		char new_line[BUFSIZ];
1884 		char *c = NULL;
1885 
1886 		(void) strlcpy(tline, line, sizeof (tline));
1887 
1888 		/* Tokenize line */
1889 		c = strtok(tline, BE_WHITE_SPACE);
1890 
1891 		if (c == NULL) {
1892 			/* Found empty line, write it out. */
1893 			(void) fputs(line, new_fp);
1894 		} else if (c[0] == '#') {
1895 			/* Found a comment line, write it out. */
1896 			(void) fputs(line, new_fp);
1897 		} else if (strcmp(c, "title") == 0) {
1898 			char *name = NULL;
1899 			char *desc = NULL;
1900 
1901 			/*
1902 			 * Found a 'title' line, parse out BE name or
1903 			 * the description.
1904 			 */
1905 			name = strtok(NULL, BE_WHITE_SPACE);
1906 
1907 			if (name == NULL) {
1908 				/*
1909 				 * Nothing after 'title', just push
1910 				 * this line through
1911 				 */
1912 				(void) fputs(line, new_fp);
1913 			} else {
1914 				/*
1915 				 * Grab the remainder of the title which
1916 				 * could be a multi worded description
1917 				 */
1918 				desc = strtok(NULL, "\n");
1919 
1920 				if (strcmp(name, be_orig_name) == 0) {
1921 					/*
1922 					 * The first token of the title is
1923 					 * the old BE name, replace it with
1924 					 * the new one, and write it out
1925 					 * along with the remainder of
1926 					 * description if there is one.
1927 					 */
1928 					if (desc) {
1929 						(void) snprintf(new_line,
1930 						    sizeof (new_line),
1931 						    "title %s %s\n",
1932 						    be_new_name, desc);
1933 					} else {
1934 						(void) snprintf(new_line,
1935 						    sizeof (new_line),
1936 						    "title %s\n", be_new_name);
1937 					}
1938 
1939 					(void) fputs(new_line, new_fp);
1940 				} else {
1941 					(void) fputs(line, new_fp);
1942 				}
1943 			}
1944 		} else if (strcmp(c, "bootfs") == 0) {
1945 			/*
1946 			 * Found a 'bootfs' line, parse out the BE root
1947 			 * dataset value.
1948 			 */
1949 			char *root_ds = strtok(NULL, BE_WHITE_SPACE);
1950 
1951 			if (root_ds == NULL) {
1952 				/*
1953 				 * Nothing after 'bootfs', just push
1954 				 * this line through
1955 				 */
1956 				(void) fputs(line, new_fp);
1957 			} else {
1958 				/*
1959 				 * If this bootfs is the one we're renaming,
1960 				 * write out the new root dataset value
1961 				 */
1962 				if (strcmp(root_ds, be_root_ds) == 0) {
1963 					(void) snprintf(new_line,
1964 					    sizeof (new_line), "bootfs %s\n",
1965 					    be_new_root_ds);
1966 
1967 					(void) fputs(new_line, new_fp);
1968 				} else {
1969 					(void) fputs(line, new_fp);
1970 				}
1971 			}
1972 		} else {
1973 			/*
1974 			 * Found some other line we don't care
1975 			 * about, write it out.
1976 			 */
1977 			(void) fputs(line, new_fp);
1978 		}
1979 	}
1980 
1981 	(void) fclose(menu_fp);
1982 	(void) fclose(new_fp);
1983 	(void) close(tmp_fd);
1984 
1985 	if (rename(temp_menu, menu_file) != 0) {
1986 		err = errno;
1987 		be_print_err(gettext("be_update_menu: "
1988 		    "failed to rename file %s to %s: %s\n"),
1989 		    temp_menu, menu_file, strerror(err));
1990 		ret = errno_to_be_err(err);
1991 	}
1992 	free(temp_menu);
1993 
1994 	/* Set the perms and ownership of the updated file */
1995 	if (chmod(menu_file, sb.st_mode) != 0) {
1996 		err = errno;
1997 		be_print_err(gettext("be_update_menu: "
1998 		    "failed to chmod %s: %s\n"), menu_file, strerror(err));
1999 		ret = errno_to_be_err(err);
2000 		goto cleanup;
2001 	}
2002 	if (chown(menu_file, sb.st_uid, sb.st_gid) != 0) {
2003 		err = errno;
2004 		be_print_err(gettext("be_update_menu: "
2005 		    "failed to chown %s: %s\n"), menu_file, strerror(err));
2006 		ret = errno_to_be_err(err);
2007 	}
2008 
2009 cleanup:
2010 	if (pool_mounted) {
2011 		int err = BE_SUCCESS;
2012 		err = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
2013 		if (ret == BE_SUCCESS)
2014 			ret = err;
2015 		free(orig_mntpnt);
2016 		free(ptmp_mntpnt);
2017 	}
2018 	ZFS_CLOSE(zhp);
2019 	return (ret);
2020 }
2021 
2022 /*
2023  * Function:	be_has_menu_entry
2024  * Description:	Checks to see if the BEs root dataset has an entry in the grub
2025  *		menu.
2026  * Parameters:
2027  *		be_dataset - The root dataset of the BE
2028  *		be_root_pool - The pool which contains the boot menu
2029  *		entry - A pointer the the entry number of the BE if found.
2030  * Returns:
2031  *		B_TRUE - Success
2032  *		B_FALSE - Failure
2033  * Scope:
2034  *		Semi-private (library wide use only)
2035  */
2036 boolean_t
2037 be_has_menu_entry(char *be_dataset, char *be_root_pool, int *entry)
2038 {
2039 	zfs_handle_t *zhp = NULL;
2040 	char		menu_file[MAXPATHLEN];
2041 	FILE		*menu_fp;
2042 	char		line[BUFSIZ];
2043 	char		*last;
2044 	char		*rpool_mntpnt = NULL;
2045 	char		*ptmp_mntpnt = NULL;
2046 	char		*orig_mntpnt = NULL;
2047 	int		ent_num = 0;
2048 	boolean_t	ret = 0;
2049 	boolean_t	pool_mounted = B_FALSE;
2050 
2051 
2052 	/*
2053 	 * Check to see if this system supports grub
2054 	 */
2055 	if ((zhp = zfs_open(g_zfs, be_root_pool, ZFS_TYPE_DATASET)) == NULL) {
2056 		be_print_err(gettext("be_has_menu_entry: failed to open "
2057 		    "pool dataset for %s: %s\n"), be_root_pool,
2058 		    libzfs_error_description(g_zfs));
2059 		return (B_FALSE);
2060 	}
2061 
2062 	/*
2063 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
2064 	 * attempt to mount it.
2065 	 */
2066 	if (be_mount_pool(zhp, &ptmp_mntpnt, &orig_mntpnt,
2067 	    &pool_mounted) != 0) {
2068 		be_print_err(gettext("be_has_menu_entry: pool dataset "
2069 		    "(%s) could not be mounted\n"), be_root_pool);
2070 		ZFS_CLOSE(zhp);
2071 		return (B_FALSE);
2072 	}
2073 
2074 	/*
2075 	 * Get the mountpoint for the root pool dataset.
2076 	 */
2077 	if (!zfs_is_mounted(zhp, &rpool_mntpnt)) {
2078 		be_print_err(gettext("be_has_menu_entry: pool "
2079 		    "dataset (%s) is not mounted. Can't set "
2080 		    "the default BE in the grub menu.\n"), be_root_pool);
2081 		ret = B_FALSE;
2082 		goto cleanup;
2083 	}
2084 
2085 	if (be_has_grub()) {
2086 		(void) snprintf(menu_file, MAXPATHLEN, "/%s%s",
2087 		    rpool_mntpnt, BE_GRUB_MENU);
2088 	} else {
2089 		(void) snprintf(menu_file, MAXPATHLEN, "/%s%s",
2090 		    rpool_mntpnt, BE_SPARC_MENU);
2091 	}
2092 
2093 	if (be_open_menu(be_root_pool, menu_file, &menu_fp, "r",
2094 	    B_FALSE) != 0) {
2095 		ret = B_FALSE;
2096 		goto cleanup;
2097 	} else if (menu_fp == NULL) {
2098 		ret = B_FALSE;
2099 		goto cleanup;
2100 	}
2101 
2102 	free(rpool_mntpnt);
2103 	rpool_mntpnt = NULL;
2104 
2105 	while (fgets(line, BUFSIZ, menu_fp)) {
2106 		char *tok = strtok_r(line, BE_WHITE_SPACE, &last);
2107 
2108 		if (tok != NULL && tok[0] != '#') {
2109 			if (strcmp(tok, "bootfs") == 0) {
2110 				tok = strtok_r(last, BE_WHITE_SPACE, &last);
2111 				if (tok != NULL && strcmp(tok,
2112 				    be_dataset) == 0) {
2113 					(void) fclose(menu_fp);
2114 					/*
2115 					 * The entry number needs to be
2116 					 * decremented here because the title
2117 					 * will always be the first line for
2118 					 * an entry. Because of this we'll
2119 					 * always be off by one entry when we
2120 					 * check for bootfs.
2121 					 */
2122 					*entry = ent_num - 1;
2123 					ret = B_TRUE;
2124 					goto cleanup;
2125 				}
2126 			} else if (strcmp(tok, "title") == 0)
2127 				ent_num++;
2128 		}
2129 	}
2130 
2131 cleanup:
2132 	if (pool_mounted) {
2133 		(void) be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
2134 		free(orig_mntpnt);
2135 		free(ptmp_mntpnt);
2136 	}
2137 	ZFS_CLOSE(zhp);
2138 	(void) fclose(menu_fp);
2139 	return (ret);
2140 }
2141 
2142 /*
2143  * Function:	be_update_vfstab
2144  * Description:	This function digs into a BE's vfstab and updates all
2145  *		entries with file systems listed in be_fs_list_data_t.
2146  *		The entry's root container dataset and be_name will be
2147  *		updated with the parameters passed in.
2148  * Parameters:
2149  *		be_name - name of BE to update
2150  *		old_rc_loc - dataset under which the root container dataset
2151  *			of the old BE resides in.
2152  *		new_rc_loc - dataset under which the root container dataset
2153  *			of the new BE resides in.
2154  *		fld - be_fs_list_data_t pointer providing the list of
2155  *			file systems to look for in vfstab.
2156  *		mountpoint - directory of where BE is currently mounted.
2157  *			If NULL, then BE is not currently mounted.
2158  * Returns:
2159  *		BE_SUCCESS - Success
2160  *		be_errno_t - Failure
2161  * Scope:
2162  *		Semi-private (library wide use only)
2163  */
2164 int
2165 be_update_vfstab(char *be_name, char *old_rc_loc, char *new_rc_loc,
2166     be_fs_list_data_t *fld, char *mountpoint)
2167 {
2168 	char		*tmp_mountpoint = NULL;
2169 	char		alt_vfstab[MAXPATHLEN];
2170 	int		ret = BE_SUCCESS, err = BE_SUCCESS;
2171 
2172 	if (fld == NULL || fld->fs_list == NULL || fld->fs_num == 0)
2173 		return (BE_SUCCESS);
2174 
2175 	/* If BE not already mounted, mount the BE */
2176 	if (mountpoint == NULL) {
2177 		if ((ret = _be_mount(be_name, &tmp_mountpoint,
2178 		    BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) {
2179 			be_print_err(gettext("be_update_vfstab: "
2180 			    "failed to mount BE (%s)\n"), be_name);
2181 			return (ret);
2182 		}
2183 	} else {
2184 		tmp_mountpoint = mountpoint;
2185 	}
2186 
2187 	/* Get string for vfstab in the mounted BE. */
2188 	(void) snprintf(alt_vfstab, sizeof (alt_vfstab), "%s/etc/vfstab",
2189 	    tmp_mountpoint);
2190 
2191 	/* Update the vfstab */
2192 	ret = _update_vfstab(alt_vfstab, be_name, old_rc_loc, new_rc_loc,
2193 	    fld);
2194 
2195 	/* Unmount BE if we mounted it */
2196 	if (mountpoint == NULL) {
2197 		if ((err = _be_unmount(be_name, 0)) == BE_SUCCESS) {
2198 			/* Remove temporary mountpoint */
2199 			(void) rmdir(tmp_mountpoint);
2200 		} else {
2201 			be_print_err(gettext("be_update_vfstab: "
2202 			    "failed to unmount BE %s mounted at %s\n"),
2203 			    be_name, tmp_mountpoint);
2204 			if (ret == BE_SUCCESS)
2205 				ret = err;
2206 		}
2207 
2208 		free(tmp_mountpoint);
2209 	}
2210 
2211 	return (ret);
2212 }
2213 
2214 /*
2215  * Function:	be_update_zone_vfstab
2216  * Description:	This function digs into a zone BE's vfstab and updates all
2217  *		entries with file systems listed in be_fs_list_data_t.
2218  *		The entry's root container dataset and be_name will be
2219  *		updated with the parameters passed in.
2220  * Parameters:
2221  *		zhp - zfs_handle_t pointer to zone root dataset.
2222  *		be_name - name of zone BE to update
2223  *		old_rc_loc - dataset under which the root container dataset
2224  *			of the old zone BE resides in.
2225  *		new_rc_loc - dataset under which the root container dataset
2226  *			of the new zone BE resides in.
2227  *		fld - be_fs_list_data_t pointer providing the list of
2228  *			file systems to look for in vfstab.
2229  * Returns:
2230  *		BE_SUCCESS - Success
2231  *		be_errno_t - Failure
2232  * Scope:
2233  *		Semi-private (library wide use only)
2234  */
2235 int
2236 be_update_zone_vfstab(zfs_handle_t *zhp, char *be_name, char *old_rc_loc,
2237     char *new_rc_loc, be_fs_list_data_t *fld)
2238 {
2239 	be_mount_data_t		md = { 0 };
2240 	be_unmount_data_t	ud = { 0 };
2241 	char			alt_vfstab[MAXPATHLEN];
2242 	boolean_t		mounted_here = B_FALSE;
2243 	int			ret = BE_SUCCESS;
2244 
2245 	/*
2246 	 * If zone root not already mounted, mount it at a
2247 	 * temporary location.
2248 	 */
2249 	if (!zfs_is_mounted(zhp, &md.altroot)) {
2250 		/* Generate temporary mountpoint to mount zone root */
2251 		if ((ret = be_make_tmp_mountpoint(&md.altroot)) != BE_SUCCESS) {
2252 			be_print_err(gettext("be_update_zone_vfstab: "
2253 			    "failed to make temporary mountpoint to "
2254 			    "mount zone root\n"));
2255 			return (ret);
2256 		}
2257 
2258 		if (be_mount_zone_root(zhp, &md) != BE_SUCCESS) {
2259 			be_print_err(gettext("be_update_zone_vfstab: "
2260 			    "failed to mount zone root %s\n"),
2261 			    zfs_get_name(zhp));
2262 			free(md.altroot);
2263 			return (BE_ERR_MOUNT_ZONEROOT);
2264 		}
2265 		mounted_here = B_TRUE;
2266 	}
2267 
2268 	/* Get string from vfstab in the mounted zone BE */
2269 	(void) snprintf(alt_vfstab, sizeof (alt_vfstab), "%s/etc/vfstab",
2270 	    md.altroot);
2271 
2272 	/* Update the vfstab */
2273 	ret = _update_vfstab(alt_vfstab, be_name, old_rc_loc, new_rc_loc,
2274 	    fld);
2275 
2276 	/* Unmount zone root if we mounted it */
2277 	if (mounted_here) {
2278 		ud.force = B_TRUE;
2279 
2280 		if (be_unmount_zone_root(zhp, &ud) == BE_SUCCESS) {
2281 			/* Remove the temporary mountpoint */
2282 			(void) rmdir(md.altroot);
2283 		} else {
2284 			be_print_err(gettext("be_update_zone_vfstab: "
2285 			    "failed to unmount zone root %s from %s\n"),
2286 			    zfs_get_name(zhp), md.altroot);
2287 			if (ret == 0)
2288 				ret = BE_ERR_UMOUNT_ZONEROOT;
2289 		}
2290 	}
2291 
2292 	free(md.altroot);
2293 	return (ret);
2294 }
2295 
2296 /*
2297  * Function:	be_auto_snap_name
2298  * Description:	Generate an auto snapshot name constructed based on the
2299  *		current date and time.  The auto snapshot name is of the form:
2300  *
2301  *			<date>-<time>
2302  *
2303  *		where <date> is in ISO standard format, so the resultant name
2304  *		is of the form:
2305  *
2306  *			%Y-%m-%d-%H:%M:%S
2307  *
2308  * Parameters:
2309  *		None
2310  * Returns:
2311  *		Success - pointer to auto generated snapshot name.  The name
2312  *			is allocated in heap storage so the caller is
2313  *			responsible for free'ing the name.
2314  *		Failure - NULL
2315  * Scope:
2316  *		Semi-private (library wide use only)
2317  */
2318 char *
2319 be_auto_snap_name(void)
2320 {
2321 	time_t		utc_tm = 0;
2322 	struct tm	*gmt_tm = NULL;
2323 	char		gmt_time_str[64];
2324 	char		*auto_snap_name = NULL;
2325 
2326 	if (time(&utc_tm) == -1) {
2327 		be_print_err(gettext("be_auto_snap_name: time() failed\n"));
2328 		return (NULL);
2329 	}
2330 
2331 	if ((gmt_tm = gmtime(&utc_tm)) == NULL) {
2332 		be_print_err(gettext("be_auto_snap_name: gmtime() failed\n"));
2333 		return (NULL);
2334 	}
2335 
2336 	(void) strftime(gmt_time_str, sizeof (gmt_time_str), "%F-%T", gmt_tm);
2337 
2338 	if ((auto_snap_name = strdup(gmt_time_str)) == NULL) {
2339 		be_print_err(gettext("be_auto_snap_name: "
2340 		    "memory allocation failed\n"));
2341 		return (NULL);
2342 	}
2343 
2344 	return (auto_snap_name);
2345 }
2346 
2347 /*
2348  * Function:	be_auto_be_name
2349  * Description:	Generate an auto BE name constructed based on the BE name
2350  *		of the original BE being cloned.
2351  * Parameters:
2352  *		obe_name - name of the original BE being cloned.
2353  * Returns:
2354  *		Success - pointer to auto generated BE name.  The name
2355  *			is allocated in heap storage so the caller is
2356  *			responsible for free'ing the name.
2357  *		Failure - NULL
2358  * Scope:
2359  *		Semi-private (library wide use only)
2360  */
2361 char *
2362 be_auto_be_name(char *obe_name)
2363 {
2364 	return (be_get_auto_name(obe_name, NULL, B_FALSE));
2365 }
2366 
2367 /*
2368  * Function:	be_auto_zone_be_name
2369  * Description:	Generate an auto BE name for a zone constructed based on
2370  *              the BE name of the original zone BE being cloned.
2371  * Parameters:
2372  *              container_ds - container dataset for the zone.
2373  *		zbe_name - name of the original zone BE being cloned.
2374  * Returns:
2375  *		Success - pointer to auto generated BE name.  The name
2376  *			is allocated in heap storage so the caller is
2377  *			responsible for free'ing the name.
2378  *		Failure - NULL
2379  * Scope:
2380  *		Semi-private (library wide use only)
2381  */
2382 char *
2383 be_auto_zone_be_name(char *container_ds, char *zbe_name)
2384 {
2385 	return (be_get_auto_name(zbe_name, container_ds, B_TRUE));
2386 }
2387 
2388 /*
2389  * Function:	be_valid_be_name
2390  * Description:	Validates a BE name.
2391  * Parameters:
2392  *		be_name - name of BE to validate
2393  * Returns:
2394  *		B_TRUE - be_name is valid
2395  *		B_FALSE - be_name is invalid
2396  * Scope:
2397  *		Semi-private (library wide use only)
2398  */
2399 
2400 boolean_t
2401 be_valid_be_name(const char *be_name)
2402 {
2403 	const char	*c = NULL;
2404 	struct be_defaults be_defaults;
2405 
2406 	if (be_name == NULL)
2407 		return (B_FALSE);
2408 
2409 	be_get_defaults(&be_defaults);
2410 
2411 	/*
2412 	 * A BE name must not be a multi-level dataset name.  We also check
2413 	 * that it does not contain the ' ' and '%' characters.  The ' ' is
2414 	 * a valid character for datasets, however we don't allow that in a
2415 	 * BE name.  The '%' is invalid, but zfs_name_valid() allows it for
2416 	 * internal reasons, so we explicitly check for it here.
2417 	 */
2418 	c = be_name;
2419 	while (*c != '\0' && *c != '/' && *c != ' ' && *c != '%')
2420 		c++;
2421 
2422 	if (*c != '\0')
2423 		return (B_FALSE);
2424 
2425 	/*
2426 	 * The BE name must comply with a zfs dataset filesystem. We also
2427 	 * verify its length to be < BE_NAME_MAX_LEN.
2428 	 */
2429 	if (!zfs_name_valid(be_name, ZFS_TYPE_FILESYSTEM) ||
2430 	    strlen(be_name) > BE_NAME_MAX_LEN)
2431 		return (B_FALSE);
2432 
2433 	if (be_defaults.be_deflt_bename_starts_with[0] != '\0' &&
2434 	    strstr(be_name, be_defaults.be_deflt_bename_starts_with) == NULL) {
2435 		return (B_FALSE);
2436 	}
2437 
2438 	return (B_TRUE);
2439 }
2440 
2441 /*
2442  * Function:	be_valid_auto_snap_name
2443  * Description:	This function checks that a snapshot name is a valid auto
2444  *		generated snapshot name.  A valid auto generated snapshot
2445  *		name is of the form:
2446  *
2447  *			%Y-%m-%d-%H:%M:%S
2448  *
2449  *		An older form of the auto generated snapshot name also
2450  *		included the snapshot's BE cleanup policy and a reserved
2451  *		field.  Those names will also be verified by this function.
2452  *
2453  *		Examples of valid auto snapshot names are:
2454  *
2455  *			2008-03-31-18:41:30
2456  *			2008-03-31-22:17:24
2457  *			<policy>:-:2008:04-05-09:12:55
2458  *			<policy>:-:2008:04-06-15:34:12
2459  *
2460  * Parameters:
2461  *		name - name of the snapshot to be validated.
2462  * Returns:
2463  *		B_TRUE - the name is a valid auto snapshot name.
2464  *		B_FALSE - the name is not a valid auto snapshot name.
2465  * Scope:
2466  *		Semi-private (library wide use only)
2467  */
2468 boolean_t
2469 be_valid_auto_snap_name(char *name)
2470 {
2471 	struct tm gmt_tm;
2472 
2473 	char *policy = NULL;
2474 	char *reserved = NULL;
2475 	char *date = NULL;
2476 	char *c = NULL;
2477 
2478 	/* Validate the snapshot name by converting it into utc time */
2479 	if (strptime(name, "%Y-%m-%d-%T", &gmt_tm) != NULL &&
2480 	    (mktime(&gmt_tm) != -1)) {
2481 		return (B_TRUE);
2482 	}
2483 
2484 	/*
2485 	 * Validate the snapshot name against the older form of an
2486 	 * auto generated snapshot name.
2487 	 */
2488 	policy = strdup(name);
2489 
2490 	/*
2491 	 * Get the first field from the snapshot name,
2492 	 * which is the BE policy
2493 	 */
2494 	c = strchr(policy, ':');
2495 	if (c == NULL) {
2496 		free(policy);
2497 		return (B_FALSE);
2498 	}
2499 	c[0] = '\0';
2500 
2501 	/* Validate the policy name */
2502 	if (!valid_be_policy(policy)) {
2503 		free(policy);
2504 		return (B_FALSE);
2505 	}
2506 
2507 	/* Get the next field, which is the reserved field. */
2508 	if (c[1] == '\0') {
2509 		free(policy);
2510 		return (B_FALSE);
2511 	}
2512 	reserved = c+1;
2513 	c = strchr(reserved, ':');
2514 	if (c == NULL) {
2515 		free(policy);
2516 		return (B_FALSE);
2517 	}
2518 	c[0] = '\0';
2519 
2520 	/* Validate the reserved field */
2521 	if (strcmp(reserved, "-") != 0) {
2522 		free(policy);
2523 		return (B_FALSE);
2524 	}
2525 
2526 	/* The remaining string should be the date field */
2527 	if (c[1] == '\0') {
2528 		free(policy);
2529 		return (B_FALSE);
2530 	}
2531 	date = c+1;
2532 
2533 	/* Validate the date string by converting it into utc time */
2534 	if (strptime(date, "%Y-%m-%d-%T", &gmt_tm) == NULL ||
2535 	    (mktime(&gmt_tm) == -1)) {
2536 		be_print_err(gettext("be_valid_auto_snap_name: "
2537 		    "invalid auto snapshot name\n"));
2538 		free(policy);
2539 		return (B_FALSE);
2540 	}
2541 
2542 	free(policy);
2543 	return (B_TRUE);
2544 }
2545 
2546 /*
2547  * Function:	be_default_policy
2548  * Description:	Temporary hardcoded policy support.  This function returns
2549  *		the default policy type to be used to create a BE or a BE
2550  *		snapshot.
2551  * Parameters:
2552  *		None
2553  * Returns:
2554  *		Name of default BE policy.
2555  * Scope:
2556  *		Semi-private (library wide use only)
2557  */
2558 char *
2559 be_default_policy(void)
2560 {
2561 	return (BE_PLCY_STATIC);
2562 }
2563 
2564 /*
2565  * Function:	valid_be_policy
2566  * Description:	Temporary hardcoded policy support.  This function valids
2567  *		whether a policy is a valid known policy or not.
2568  * Paramters:
2569  *		policy - name of policy to validate.
2570  * Returns:
2571  *		B_TRUE - policy is a valid.
2572  *		B_FALSE - policy is invalid.
2573  * Scope:
2574  *		Semi-private (library wide use only)
2575  */
2576 boolean_t
2577 valid_be_policy(char *policy)
2578 {
2579 	if (policy == NULL)
2580 		return (B_FALSE);
2581 
2582 	if (strcmp(policy, BE_PLCY_STATIC) == 0 ||
2583 	    strcmp(policy, BE_PLCY_VOLATILE) == 0) {
2584 		return (B_TRUE);
2585 	}
2586 
2587 	return (B_FALSE);
2588 }
2589 
2590 /*
2591  * Function:	be_print_err
2592  * Description:	This function prints out error messages if do_print is
2593  *		set to B_TRUE or if the BE_PRINT_ERR environment variable
2594  *		is set to true.
2595  * Paramters:
2596  *		prnt_str - the string we wish to print and any arguments
2597  *		for the format of that string.
2598  * Returns:
2599  *		void
2600  * Scope:
2601  *		Semi-private (library wide use only)
2602  */
2603 void
2604 be_print_err(char *prnt_str, ...)
2605 {
2606 	va_list ap;
2607 	char buf[BUFSIZ];
2608 	char *env_buf;
2609 	static boolean_t env_checked = B_FALSE;
2610 
2611 	if (!env_checked) {
2612 		if ((env_buf = getenv("BE_PRINT_ERR")) != NULL) {
2613 			if (strcasecmp(env_buf, "true") == 0) {
2614 				do_print = B_TRUE;
2615 			}
2616 		}
2617 		env_checked = B_TRUE;
2618 	}
2619 
2620 	if (do_print) {
2621 		va_start(ap, prnt_str);
2622 		/* LINTED variable format specifier */
2623 		(void) vsnprintf(buf, BUFSIZ, prnt_str, ap);
2624 		(void) fputs(buf, stderr);
2625 		va_end(ap);
2626 	}
2627 }
2628 
2629 /*
2630  * Function:	be_find_current_be
2631  * Description:	Find the currently "active" BE. Fill in the
2632  *		passed in be_transaction_data_t reference with the
2633  *		active BE's data.
2634  * Paramters:
2635  *		none
2636  * Returns:
2637  *		BE_SUCCESS - Success
2638  *		be_errnot_t - Failure
2639  * Scope:
2640  *		Semi-private (library wide use only)
2641  * Notes:
2642  *		The caller is responsible for initializing the libzfs handle
2643  *		and freeing the memory used by the active be_name.
2644  */
2645 int
2646 be_find_current_be(be_transaction_data_t *bt)
2647 {
2648 	int	zret;
2649 
2650 	if ((zret = zpool_iter(g_zfs, be_zpool_find_current_be_callback,
2651 	    bt)) == 0) {
2652 		be_print_err(gettext("be_find_current_be: failed to "
2653 		    "find current BE name\n"));
2654 		return (BE_ERR_BE_NOENT);
2655 	} else if (zret < 0) {
2656 		be_print_err(gettext("be_find_current_be: "
2657 		    "zpool_iter failed: %s\n"),
2658 		    libzfs_error_description(g_zfs));
2659 		return (zfs_err_to_be_err(g_zfs));
2660 	}
2661 
2662 	return (BE_SUCCESS);
2663 }
2664 
2665 /*
2666  * Function:	be_zpool_find_current_be_callback
2667  * Description: Callback function used to iterate through all existing pools
2668  *		to find the BE that is the currently booted BE.
2669  * Parameters:
2670  *		zlp - zpool_handle_t pointer to the current pool being
2671  *			looked at.
2672  *		data - be_transaction_data_t pointer.
2673  *			Upon successfully finding the current BE, the
2674  *			obe_zpool member of this parameter is set to the
2675  *			pool it is found in.
2676  * Return:
2677  *		1 - Found current BE in this pool.
2678  *		0 - Did not find current BE in this pool.
2679  * Scope:
2680  *		Semi-private (library wide use only)
2681  */
2682 int
2683 be_zpool_find_current_be_callback(zpool_handle_t *zlp, void *data)
2684 {
2685 	be_transaction_data_t	*bt = data;
2686 	zfs_handle_t		*zhp = NULL;
2687 	const char		*zpool =  zpool_get_name(zlp);
2688 	char			be_container_ds[MAXPATHLEN];
2689 	char			*zpath = NULL;
2690 
2691 	/*
2692 	 * Generate string for BE container dataset
2693 	 */
2694 	if (getzoneid() != GLOBAL_ZONEID) {
2695 		if ((zpath = be_get_ds_from_dir("/")) != NULL) {
2696 			(void) strlcpy(be_container_ds, dirname(zpath),
2697 			    sizeof (be_container_ds));
2698 		} else {
2699 			be_print_err(gettext(
2700 			    "be_zpool_find_current_be_callback: "
2701 			    "zone root dataset is not mounted\n"));
2702 			return (0);
2703 		}
2704 	} else {
2705 		be_make_container_ds(zpool, be_container_ds,
2706 		    sizeof (be_container_ds));
2707 	}
2708 
2709 	/*
2710 	 * Check if a BE container dataset exists in this pool.
2711 	 */
2712 	if (!zfs_dataset_exists(g_zfs, be_container_ds, ZFS_TYPE_FILESYSTEM)) {
2713 		zpool_close(zlp);
2714 		return (0);
2715 	}
2716 
2717 	/*
2718 	 * Get handle to this zpool's BE container dataset.
2719 	 */
2720 	if ((zhp = zfs_open(g_zfs, be_container_ds, ZFS_TYPE_FILESYSTEM)) ==
2721 	    NULL) {
2722 		be_print_err(gettext("be_zpool_find_current_be_callback: "
2723 		    "failed to open BE container dataset (%s)\n"),
2724 		    be_container_ds);
2725 		zpool_close(zlp);
2726 		return (0);
2727 	}
2728 
2729 	/*
2730 	 * Iterate through all potential BEs in this zpool
2731 	 */
2732 	if (zfs_iter_filesystems(zhp, be_zfs_find_current_be_callback, bt)) {
2733 		/*
2734 		 * Found current BE dataset; set obe_zpool
2735 		 */
2736 		if ((bt->obe_zpool = strdup(zpool)) == NULL) {
2737 			be_print_err(gettext(
2738 			    "be_zpool_find_current_be_callback: "
2739 			    "memory allocation failed\n"));
2740 			ZFS_CLOSE(zhp);
2741 			zpool_close(zlp);
2742 			return (0);
2743 		}
2744 
2745 		ZFS_CLOSE(zhp);
2746 		zpool_close(zlp);
2747 		return (1);
2748 	}
2749 
2750 	ZFS_CLOSE(zhp);
2751 	zpool_close(zlp);
2752 
2753 	return (0);
2754 }
2755 
2756 /*
2757  * Function:	be_zfs_find_current_be_callback
2758  * Description:	Callback function used to iterate through all BEs in a
2759  *		pool to find the BE that is the currently booted BE.
2760  * Parameters:
2761  *		zhp - zfs_handle_t pointer to current filesystem being checked.
2762  *		data - be_transaction-data_t pointer
2763  *			Upon successfully finding the current BE, the
2764  *			obe_name and obe_root_ds members of this parameter
2765  *			are set to the BE name and BE's root dataset
2766  *			respectively.
2767  * Return:
2768  *		1 - Found current BE.
2769  *		0 - Did not find current BE.
2770  * Scope:
2771  *		Semi-private (library wide use only)
2772  */
2773 int
2774 be_zfs_find_current_be_callback(zfs_handle_t *zhp, void *data)
2775 {
2776 	be_transaction_data_t	*bt = data;
2777 	char			*mp = NULL;
2778 
2779 	/*
2780 	 * Check if dataset is mounted, and if so where.
2781 	 */
2782 	if (zfs_is_mounted(zhp, &mp)) {
2783 		/*
2784 		 * If mounted at root, set obe_root_ds and obe_name
2785 		 */
2786 		if (mp != NULL && strcmp(mp, "/") == 0) {
2787 			free(mp);
2788 
2789 			if ((bt->obe_root_ds = strdup(zfs_get_name(zhp)))
2790 			    == NULL) {
2791 				be_print_err(gettext(
2792 				    "be_zfs_find_current_be_callback: "
2793 				    "memory allocation failed\n"));
2794 				ZFS_CLOSE(zhp);
2795 				return (0);
2796 			}
2797 
2798 			if ((bt->obe_name = strdup(basename(bt->obe_root_ds)))
2799 			    == NULL) {
2800 				be_print_err(gettext(
2801 				    "be_zfs_find_current_be_callback: "
2802 				    "memory allocation failed\n"));
2803 				ZFS_CLOSE(zhp);
2804 				return (0);
2805 			}
2806 
2807 			ZFS_CLOSE(zhp);
2808 			return (1);
2809 		}
2810 
2811 		free(mp);
2812 	}
2813 	ZFS_CLOSE(zhp);
2814 
2815 	return (0);
2816 }
2817 
2818 /*
2819  * Function:	be_check_be_roots_callback
2820  * Description:	This function checks whether or not the dataset name passed
2821  *		is hierachically located under the BE root container dataset
2822  *		for this pool.
2823  * Parameters:
2824  *		zlp - zpool_handle_t pointer to current pool being processed.
2825  *		data - name of dataset to check
2826  * Returns:
2827  *		0 - dataset is not in this pool's BE root container dataset
2828  *		1 - dataset is in this pool's BE root container dataset
2829  * Scope:
2830  *		Semi-private (library wide use only)
2831  */
2832 int
2833 be_check_be_roots_callback(zpool_handle_t *zlp, void *data)
2834 {
2835 	const char	*zpool = zpool_get_name(zlp);
2836 	char		*ds = data;
2837 	char		be_container_ds[MAXPATHLEN];
2838 
2839 	/* Generate string for this pool's BE root container dataset */
2840 	be_make_container_ds(zpool, be_container_ds, sizeof (be_container_ds));
2841 
2842 	/*
2843 	 * If dataset lives under the BE root container dataset
2844 	 * of this pool, return failure.
2845 	 */
2846 	if (strncmp(be_container_ds, ds, strlen(be_container_ds)) == 0 &&
2847 	    ds[strlen(be_container_ds)] == '/') {
2848 		zpool_close(zlp);
2849 		return (1);
2850 	}
2851 
2852 	zpool_close(zlp);
2853 	return (0);
2854 }
2855 
2856 /*
2857  * Function:	zfs_err_to_be_err
2858  * Description:	This function takes the error stored in the libzfs handle
2859  *		and maps it to an be_errno_t. If there are no matching
2860  *		be_errno_t's then BE_ERR_ZFS is returned.
2861  * Paramters:
2862  *		zfsh - The libzfs handle containing the error we're looking up.
2863  * Returns:
2864  *		be_errno_t
2865  * Scope:
2866  *		Semi-private (library wide use only)
2867  */
2868 int
2869 zfs_err_to_be_err(libzfs_handle_t *zfsh)
2870 {
2871 	int err = libzfs_errno(zfsh);
2872 
2873 	switch (err) {
2874 	case 0:
2875 		return (BE_SUCCESS);
2876 	case EZFS_PERM:
2877 		return (BE_ERR_PERM);
2878 	case EZFS_INTR:
2879 		return (BE_ERR_INTR);
2880 	case EZFS_NOENT:
2881 		return (BE_ERR_NOENT);
2882 	case EZFS_NOSPC:
2883 		return (BE_ERR_NOSPC);
2884 	case EZFS_MOUNTFAILED:
2885 		return (BE_ERR_MOUNT);
2886 	case EZFS_UMOUNTFAILED:
2887 		return (BE_ERR_UMOUNT);
2888 	case EZFS_EXISTS:
2889 		return (BE_ERR_BE_EXISTS);
2890 	case EZFS_BUSY:
2891 		return (BE_ERR_DEV_BUSY);
2892 	case EZFS_POOLREADONLY:
2893 		return (BE_ERR_ROFS);
2894 	case EZFS_NAMETOOLONG:
2895 		return (BE_ERR_NAMETOOLONG);
2896 	case EZFS_NODEVICE:
2897 		return (BE_ERR_NODEV);
2898 	case EZFS_POOL_INVALARG:
2899 		return (BE_ERR_INVAL);
2900 	case EZFS_PROPTYPE:
2901 		return (BE_ERR_INVALPROP);
2902 	case EZFS_BADTYPE:
2903 		return (BE_ERR_DSTYPE);
2904 	case EZFS_PROPNONINHERIT:
2905 		return (BE_ERR_NONINHERIT);
2906 	case EZFS_PROPREADONLY:
2907 		return (BE_ERR_READONLYPROP);
2908 	case EZFS_RESILVERING:
2909 	case EZFS_POOLUNAVAIL:
2910 		return (BE_ERR_UNAVAIL);
2911 	case EZFS_DSREADONLY:
2912 		return (BE_ERR_READONLYDS);
2913 	default:
2914 		return (BE_ERR_ZFS);
2915 	}
2916 }
2917 
2918 /*
2919  * Function:	errno_to_be_err
2920  * Description:	This function takes an errno and maps it to an be_errno_t.
2921  *		If there are no matching be_errno_t's then BE_ERR_UNKNOWN is
2922  *		returned.
2923  * Paramters:
2924  *		err - The errno we're compairing against.
2925  * Returns:
2926  *		be_errno_t
2927  * Scope:
2928  *		Semi-private (library wide use only)
2929  */
2930 int
2931 errno_to_be_err(int err)
2932 {
2933 	switch (err) {
2934 	case EPERM:
2935 		return (BE_ERR_PERM);
2936 	case EACCES:
2937 		return (BE_ERR_ACCESS);
2938 	case ECANCELED:
2939 		return (BE_ERR_CANCELED);
2940 	case EINTR:
2941 		return (BE_ERR_INTR);
2942 	case ENOENT:
2943 		return (BE_ERR_NOENT);
2944 	case ENOSPC:
2945 	case EDQUOT:
2946 		return (BE_ERR_NOSPC);
2947 	case EEXIST:
2948 		return (BE_ERR_BE_EXISTS);
2949 	case EBUSY:
2950 		return (BE_ERR_BUSY);
2951 	case EROFS:
2952 		return (BE_ERR_ROFS);
2953 	case ENAMETOOLONG:
2954 		return (BE_ERR_NAMETOOLONG);
2955 	case ENXIO:
2956 		return (BE_ERR_NXIO);
2957 	case EINVAL:
2958 		return (BE_ERR_INVAL);
2959 	case EFAULT:
2960 		return (BE_ERR_FAULT);
2961 	default:
2962 		return (BE_ERR_UNKNOWN);
2963 	}
2964 }
2965 
2966 /*
2967  * Function:	be_err_to_str
2968  * Description:	This function takes a be_errno_t and maps it to a message.
2969  *		If there are no matching be_errno_t's then NULL is returned.
2970  * Paramters:
2971  *		be_errno_t - The be_errno_t we're mapping.
2972  * Returns:
2973  *		string or NULL if the error code is not known.
2974  * Scope:
2975  *		Semi-private (library wide use only)
2976  */
2977 char *
2978 be_err_to_str(int err)
2979 {
2980 	switch (err) {
2981 	case BE_ERR_ACCESS:
2982 		return (gettext("Permission denied."));
2983 	case BE_ERR_ACTIVATE_CURR:
2984 		return (gettext("Activation of current BE failed."));
2985 	case BE_ERR_AUTONAME:
2986 		return (gettext("Auto naming failed."));
2987 	case BE_ERR_BE_NOENT:
2988 		return (gettext("No such BE."));
2989 	case BE_ERR_BUSY:
2990 		return (gettext("Mount busy."));
2991 	case BE_ERR_DEV_BUSY:
2992 		return (gettext("Device busy."));
2993 	case BE_ERR_CANCELED:
2994 		return (gettext("Operation canceled."));
2995 	case BE_ERR_CLONE:
2996 		return (gettext("BE clone failed."));
2997 	case BE_ERR_COPY:
2998 		return (gettext("BE copy failed."));
2999 	case BE_ERR_CREATDS:
3000 		return (gettext("Dataset creation failed."));
3001 	case BE_ERR_CURR_BE_NOT_FOUND:
3002 		return (gettext("Can't find current BE."));
3003 	case BE_ERR_DESTROY:
3004 		return (gettext("Failed to destroy BE or snapshot."));
3005 	case BE_ERR_DESTROY_CURR_BE:
3006 		return (gettext("Cannot destroy current BE."));
3007 	case BE_ERR_DEMOTE:
3008 		return (gettext("BE demotion failed."));
3009 	case BE_ERR_DSTYPE:
3010 		return (gettext("Invalid dataset type."));
3011 	case BE_ERR_BE_EXISTS:
3012 		return (gettext("BE exists."));
3013 	case BE_ERR_INIT:
3014 		return (gettext("be_zfs_init failed."));
3015 	case BE_ERR_INTR:
3016 		return (gettext("Interupted system call."));
3017 	case BE_ERR_INVAL:
3018 		return (gettext("Invalid argument."));
3019 	case BE_ERR_INVALPROP:
3020 		return (gettext("Invalid property for dataset."));
3021 	case BE_ERR_INVALMOUNTPOINT:
3022 		return (gettext("Unexpected mountpoint."));
3023 	case BE_ERR_MOUNT:
3024 		return (gettext("Mount failed."));
3025 	case BE_ERR_MOUNTED:
3026 		return (gettext("Already mounted."));
3027 	case BE_ERR_NAMETOOLONG:
3028 		return (gettext("name > BUFSIZ."));
3029 	case BE_ERR_NOENT:
3030 		return (gettext("Doesn't exist."));
3031 	case BE_ERR_POOL_NOENT:
3032 		return (gettext("No such pool."));
3033 	case BE_ERR_NODEV:
3034 		return (gettext("No such device."));
3035 	case BE_ERR_NOTMOUNTED:
3036 		return (gettext("File system not mounted."));
3037 	case BE_ERR_NOMEM:
3038 		return (gettext("Not enough memory."));
3039 	case BE_ERR_NONINHERIT:
3040 		return (gettext(
3041 		    "Property is not inheritable for the BE dataset."));
3042 	case BE_ERR_NXIO:
3043 		return (gettext("No such device or address."));
3044 	case BE_ERR_NOSPC:
3045 		return (gettext("No space on device."));
3046 	case BE_ERR_NOTSUP:
3047 		return (gettext("Operation not supported."));
3048 	case BE_ERR_OPEN:
3049 		return (gettext("Open failed."));
3050 	case BE_ERR_PERM:
3051 		return (gettext("Not owner."));
3052 	case BE_ERR_UNAVAIL:
3053 		return (gettext("The BE is currently unavailable."));
3054 	case BE_ERR_PROMOTE:
3055 		return (gettext("BE promotion failed."));
3056 	case BE_ERR_ROFS:
3057 		return (gettext("Read only file system."));
3058 	case BE_ERR_READONLYDS:
3059 		return (gettext("Read only dataset."));
3060 	case BE_ERR_READONLYPROP:
3061 		return (gettext("Read only property."));
3062 	case BE_ERR_RENAME_ACTIVE:
3063 		return (gettext("Renaming the active BE is not supported."));
3064 	case BE_ERR_SS_EXISTS:
3065 		return (gettext("Snapshot exists."));
3066 	case BE_ERR_SS_NOENT:
3067 		return (gettext("No such snapshot."));
3068 	case BE_ERR_UMOUNT:
3069 		return (gettext("Unmount failed."));
3070 	case BE_ERR_UMOUNT_CURR_BE:
3071 		return (gettext("Can't unmount the current BE."));
3072 	case BE_ERR_UMOUNT_SHARED:
3073 		return (gettext("Unmount of a shared File System failed."));
3074 	case BE_ERR_FAULT:
3075 		return (gettext("Bad address."));
3076 	case BE_ERR_UNKNOWN:
3077 		return (gettext("Unknown error."));
3078 	case BE_ERR_ZFS:
3079 		return (gettext("ZFS returned an error."));
3080 	case BE_ERR_GEN_UUID:
3081 		return (gettext("Failed to generate uuid."));
3082 	case BE_ERR_PARSE_UUID:
3083 		return (gettext("Failed to parse uuid."));
3084 	case BE_ERR_NO_UUID:
3085 		return (gettext("No uuid"));
3086 	case BE_ERR_ZONE_NO_PARENTBE:
3087 		return (gettext("No parent uuid"));
3088 	case BE_ERR_ZONE_MULTIPLE_ACTIVE:
3089 		return (gettext("Multiple active zone roots"));
3090 	case BE_ERR_ZONE_NO_ACTIVE_ROOT:
3091 		return (gettext("No active zone root"));
3092 	case BE_ERR_ZONE_ROOT_NOT_LEGACY:
3093 		return (gettext("Zone root not legacy"));
3094 	case BE_ERR_MOUNT_ZONEROOT:
3095 		return (gettext("Failed to mount a zone root."));
3096 	case BE_ERR_UMOUNT_ZONEROOT:
3097 		return (gettext("Failed to unmount a zone root."));
3098 	case BE_ERR_NO_MOUNTED_ZONE:
3099 		return (gettext("Zone is not mounted"));
3100 	case BE_ERR_ZONES_UNMOUNT:
3101 		return (gettext("Unable to unmount a zone BE."));
3102 	case BE_ERR_NO_MENU:
3103 		return (gettext("Missing boot menu file."));
3104 	case BE_ERR_BAD_MENU_PATH:
3105 		return (gettext("Invalid path for menu.lst file"));
3106 	case BE_ERR_ZONE_SS_EXISTS:
3107 		return (gettext("Zone snapshot exists."));
3108 	case BE_ERR_BOOTFILE_INST:
3109 		return (gettext("Error installing boot files."));
3110 	case BE_ERR_EXTCMD:
3111 		return (gettext("Error running an external command."));
3112 	default:
3113 		return (NULL);
3114 	}
3115 }
3116 
3117 /*
3118  * Function:    be_has_grub
3119  * Description: Boolean function indicating whether the current system
3120  *		uses grub.
3121  * Return:      B_FALSE - the system does not have grub
3122  *              B_TRUE - the system does have grub.
3123  * Scope:
3124  *		Semi-private (library wide use only)
3125  */
3126 boolean_t
3127 be_has_grub(void)
3128 {
3129 	static struct be_defaults be_defaults;
3130 	static boolean_t be_deflts_set = B_FALSE;
3131 
3132 	/* Cache the defaults, because be_has_grub is used often. */
3133 	if (be_deflts_set == B_FALSE) {
3134 		be_get_defaults(&be_defaults);
3135 		be_deflts_set = B_TRUE;
3136 	}
3137 
3138 	return (be_defaults.be_deflt_grub);
3139 }
3140 
3141 /*
3142  * Function:    be_is_isa
3143  * Description: Boolean function indicating whether the instruction set
3144  *              architecture of the executing system matches the name provided.
3145  *              The string must match a system defined architecture (e.g.
3146  *              "i386", "sparc") and is case sensitive.
3147  * Parameters:  name - string representing the name of instruction set
3148  *			architecture being tested
3149  * Returns:     B_FALSE - the system instruction set architecture is different
3150  *			from the one specified
3151  *              B_TRUE - the system instruction set architecture is the same
3152  *			as the one specified
3153  * Scope:
3154  *		Semi-private (library wide use only)
3155  */
3156 boolean_t
3157 be_is_isa(char *name)
3158 {
3159 	return ((strcmp((char *)be_get_default_isa(), name) == 0));
3160 }
3161 
3162 /*
3163  * Function: be_get_default_isa
3164  * Description:
3165  *      Returns the default instruction set architecture of the
3166  *      machine it is executed on. (eg. sparc, i386, ...)
3167  *      NOTE:   SYS_INST environment variable may override default
3168  *              return value
3169  * Parameters:
3170  *		none
3171  * Returns:
3172  *		NULL - the architecture returned by sysinfo() was too
3173  *			long for local variables
3174  *		char * - pointer to a string containing the default
3175  *			implementation
3176  * Scope:
3177  *		Semi-private (library wide use only)
3178  */
3179 char *
3180 be_get_default_isa(void)
3181 {
3182 	int	i;
3183 	char	*envp;
3184 	static char	default_inst[ARCH_LENGTH] = "";
3185 
3186 	if (default_inst[0] == '\0') {
3187 		if ((envp = getenv("SYS_INST")) != NULL) {
3188 			if ((int)strlen(envp) >= ARCH_LENGTH)
3189 				return (NULL);
3190 			else
3191 				(void) strcpy(default_inst, envp);
3192 		} else  {
3193 			i = sysinfo(SI_ARCHITECTURE, default_inst, ARCH_LENGTH);
3194 			if (i < 0 || i > ARCH_LENGTH)
3195 				return (NULL);
3196 		}
3197 	}
3198 	return (default_inst);
3199 }
3200 
3201 /*
3202  * Function: be_get_platform
3203  * Description:
3204  *      Returns the platfom name
3205  * Parameters:
3206  *		none
3207  * Returns:
3208  *		NULL - the platform name returned by sysinfo() was too
3209  *			long for local variables
3210  *		char * - pointer to a string containing the platform name
3211  * Scope:
3212  *		Semi-private (library wide use only)
3213  */
3214 char *
3215 be_get_platform(void)
3216 {
3217 	int	i;
3218 	static char	default_inst[ARCH_LENGTH] = "";
3219 
3220 	if (default_inst[0] == '\0') {
3221 		i = sysinfo(SI_PLATFORM, default_inst, ARCH_LENGTH);
3222 		if (i < 0 || i > ARCH_LENGTH)
3223 			return (NULL);
3224 	}
3225 	return (default_inst);
3226 }
3227 
3228 /*
3229  * Function: be_run_cmd
3230  * Description:
3231  *	Runs a command in a separate subprocess.  Splits out stdout from stderr
3232  *	and sends each to its own buffer.  Buffers must be pre-allocated and
3233  *	passed in as arguments.  Buffer sizes are also passed in as arguments.
3234  *
3235  *	Notes / caveats:
3236  *	- Command being run is assumed to not have any stdout or stderr
3237  *		redirection.
3238  *	- Commands which emit total stderr output of greater than PIPE_BUF
3239  *		bytes can hang.  For such commands, a different implementation
3240  *		which uses poll(2) must be used.
3241  *	- stdout_buf can be NULL.  In this case, stdout_bufsize is ignored, and
3242  *		the stream which would have gone to it is sent to the bit
3243  *		bucket.
3244  *	- stderr_buf cannot be NULL.
3245  *	- Only subprocess errors are appended to the stderr_buf.  Errors
3246  *		running the command are reported through be_print_err().
3247  *	- Data which would overflow its respective buffer is sent to the bit
3248  *		bucket.
3249  *
3250  * Parameters:
3251  *		command: command to run.  Assumed not to have embedded stdout
3252  *			or stderr redirection.  May have stdin redirection,
3253  *			however.
3254  *		stderr_buf: buffer returning subprocess stderr data.  Errors
3255  *			reported by this function are reported through
3256  *			be_print_err().
3257  *		stderr_bufsize: size of stderr_buf
3258  *		stdout_buf: buffer returning subprocess stdout data.
3259  *		stdout_bufsize: size of stdout_buf
3260  * Returns:
3261  *		BE_SUCCESS - The command ran successfully without returning
3262  *			errors.
3263  *		BE_ERR_EXTCMD
3264  *			- The command could not be run.
3265  *			- The command terminated with error status.
3266  *			- There were errors extracting or returning subprocess
3267  *				data.
3268  *		BE_ERR_NOMEM - The command exceeds the command buffer size.
3269  *		BE_ERR_INVAL - An invalid argument was specified.
3270  * Scope:
3271  *		Semi-private (library wide use only)
3272  */
3273 int
3274 be_run_cmd(char *command, char *stderr_buf, int stderr_bufsize,
3275     char *stdout_buf, int stdout_bufsize)
3276 {
3277 	char *temp_filename = strdup(tmpnam(NULL));
3278 	FILE *stdout_str = NULL;
3279 	FILE *stderr_str = NULL;
3280 	char cmdline[BUFSIZ];
3281 	char oneline[BUFSIZ];
3282 	int exit_status;
3283 	int rval = BE_SUCCESS;
3284 
3285 	if ((command == NULL) || (stderr_buf == NULL) ||
3286 	    (stderr_bufsize <= 0) || (stdout_bufsize <  0) ||
3287 	    ((stdout_buf != NULL) ^ (stdout_bufsize != 0))) {
3288 		return (BE_ERR_INVAL);
3289 	}
3290 
3291 	/* Set up command so popen returns stderr, not stdout */
3292 	if (snprintf(cmdline, BUFSIZ, "%s 2> %s", command,
3293 	    temp_filename) >= BUFSIZ) {
3294 		rval = BE_ERR_NOMEM;
3295 		goto cleanup;
3296 	}
3297 
3298 	/* Set up the fifo that will make stderr available. */
3299 	if (mkfifo(temp_filename, 0600) != 0) {
3300 		(void) be_print_err(gettext("be_run_cmd: mkfifo: %s\n"),
3301 		    strerror(errno));
3302 		rval = BE_ERR_EXTCMD;
3303 		goto cleanup;
3304 	}
3305 
3306 	if ((stdout_str = popen(cmdline, "r")) == NULL) {
3307 		(void) be_print_err(gettext("be_run_cmd: popen: %s\n"),
3308 		    strerror(errno));
3309 		rval = BE_ERR_EXTCMD;
3310 		goto cleanup;
3311 	}
3312 
3313 	if ((stderr_str = fopen(temp_filename, "r")) == NULL) {
3314 		(void) be_print_err(gettext("be_run_cmd: fopen: %s\n"),
3315 		    strerror(errno));
3316 		(void) pclose(stdout_str);
3317 		rval = BE_ERR_EXTCMD;
3318 		goto cleanup;
3319 	}
3320 
3321 	/* Read stdout first, as it usually outputs more than stderr. */
3322 	oneline[BUFSIZ-1] = '\0';
3323 	while (fgets(oneline, BUFSIZ-1, stdout_str) != NULL) {
3324 		if (stdout_str != NULL) {
3325 			(void) strlcat(stdout_buf, oneline, stdout_bufsize);
3326 		}
3327 	}
3328 
3329 	while (fgets(oneline, BUFSIZ-1, stderr_str) != NULL) {
3330 		(void) strlcat(stderr_buf, oneline, stderr_bufsize);
3331 	}
3332 
3333 	/* Close pipe, get exit status. */
3334 	if ((exit_status = pclose(stdout_str)) == -1) {
3335 		(void) be_print_err(gettext("be_run_cmd: pclose: %s\n"),
3336 		    strerror(errno));
3337 		rval = BE_ERR_EXTCMD;
3338 	} else if (WIFEXITED(exit_status)) {
3339 		exit_status = (int)((char)WEXITSTATUS(exit_status));
3340 		/*
3341 		 * error code BC_NOUPDT means more recent version
3342 		 * is installed
3343 		 */
3344 		if (exit_status != BC_SUCCESS && exit_status != BC_NOUPDT) {
3345 			(void) snprintf(oneline, BUFSIZ, gettext("be_run_cmd: "
3346 			    "command terminated with error status: %d\n"),
3347 			    exit_status);
3348 			(void) strlcat(stderr_buf, oneline, stderr_bufsize);
3349 			rval = BE_ERR_EXTCMD;
3350 		}
3351 	} else {
3352 		(void) snprintf(oneline, BUFSIZ, gettext("be_run_cmd: command "
3353 		    "terminated on signal: %s\n"),
3354 		    strsignal(WTERMSIG(exit_status)));
3355 		(void) strlcat(stderr_buf, oneline, stderr_bufsize);
3356 		rval = BE_ERR_EXTCMD;
3357 	}
3358 
3359 cleanup:
3360 	(void) unlink(temp_filename);
3361 	(void) free(temp_filename);
3362 
3363 	return (rval);
3364 }
3365 
3366 /* ********************************************************************	*/
3367 /*			Private Functions				*/
3368 /* ******************************************************************** */
3369 
3370 /*
3371  * Function:	update_dataset
3372  * Description:	This function takes a dataset name and replaces the zpool
3373  *		and be_name components of the dataset with the new be_name
3374  *		zpool passed in.
3375  * Parameters:
3376  *		dataset - name of dataset
3377  *		dataset_len - lenth of buffer in which dataset is passed in.
3378  *		be_name - name of new BE name to update to.
3379  *		old_rc_loc - dataset under which the root container dataset
3380  *			for the old BE lives.
3381  *		new_rc_loc - dataset under which the root container dataset
3382  *			for the new BE lives.
3383  * Returns:
3384  *		BE_SUCCESS - Success
3385  *		be_errno_t - Failure
3386  * Scope:
3387  *		Private
3388  */
3389 static int
3390 update_dataset(char *dataset, int dataset_len, char *be_name,
3391     char *old_rc_loc, char *new_rc_loc)
3392 {
3393 	char	*ds = NULL;
3394 	char	*sub_ds = NULL;
3395 
3396 	/* Tear off the BE container dataset */
3397 	if ((ds = be_make_name_from_ds(dataset, old_rc_loc)) == NULL) {
3398 		return (BE_ERR_INVAL);
3399 	}
3400 
3401 	/* Get dataset name relative to BE root, if there is one */
3402 	sub_ds = strchr(ds, '/');
3403 
3404 	/* Generate the BE root dataset name */
3405 	be_make_root_ds(new_rc_loc, be_name, dataset, dataset_len);
3406 
3407 	/* If a subordinate dataset name was found, append it */
3408 	if (sub_ds != NULL)
3409 		(void) strlcat(dataset, sub_ds, dataset_len);
3410 
3411 	free(ds);
3412 	return (BE_SUCCESS);
3413 }
3414 
3415 /*
3416  * Function:	_update_vfstab
3417  * Description:	This function updates a vfstab file to reflect the new
3418  *		root container dataset location and be_name for all
3419  *		entries listed in the be_fs_list_data_t structure passed in.
3420  * Parameters:
3421  *		vfstab - vfstab file to modify
3422  *		be_name - name of BE to update.
3423  *		old_rc_loc - dataset under which the root container dataset
3424  *			of the old BE resides in.
3425  *		new_rc_loc - dataset under which the root container dataset
3426  *			of the new BE resides in.
3427  *		fld - be_fs_list_data_t pointer providing the list of
3428  *			file systems to look for in vfstab.
3429  * Returns:
3430  *		BE_SUCCESS - Success
3431  *		be_errno_t - Failure
3432  * Scope:
3433  *		Private
3434  */
3435 static int
3436 _update_vfstab(char *vfstab, char *be_name, char *old_rc_loc,
3437     char *new_rc_loc, be_fs_list_data_t *fld)
3438 {
3439 	struct vfstab	vp;
3440 	char		*tmp_vfstab = NULL;
3441 	char		comments_buf[BUFSIZ];
3442 	FILE		*comments = NULL;
3443 	FILE		*vfs_ents = NULL;
3444 	FILE		*tfile = NULL;
3445 	struct stat	sb;
3446 	char		dev[MAXPATHLEN];
3447 	char		*c;
3448 	int		fd;
3449 	int		ret = BE_SUCCESS, err = 0;
3450 	int		i;
3451 	int		tmp_vfstab_len = 0;
3452 
3453 	errno = 0;
3454 
3455 	/*
3456 	 * Open vfstab for reading twice.  First is for comments,
3457 	 * second is for actual entries.
3458 	 */
3459 	if ((comments = fopen(vfstab, "r")) == NULL ||
3460 	    (vfs_ents = fopen(vfstab, "r")) == NULL) {
3461 		err = errno;
3462 		be_print_err(gettext("_update_vfstab: "
3463 		    "failed to open vfstab (%s): %s\n"), vfstab,
3464 		    strerror(err));
3465 		ret = errno_to_be_err(err);
3466 		goto cleanup;
3467 	}
3468 
3469 	/* Grab the stats of the original vfstab file */
3470 	if (stat(vfstab, &sb) != 0) {
3471 		err = errno;
3472 		be_print_err(gettext("_update_vfstab: "
3473 		    "failed to stat file %s: %s\n"), vfstab,
3474 		    strerror(err));
3475 		ret = errno_to_be_err(err);
3476 		goto cleanup;
3477 	}
3478 
3479 	/* Create tmp file for modified vfstab */
3480 	if ((tmp_vfstab = (char *)malloc(strlen(vfstab) + 7))
3481 	    == NULL) {
3482 		be_print_err(gettext("_update_vfstab: "
3483 		    "malloc failed\n"));
3484 		ret = BE_ERR_NOMEM;
3485 		goto cleanup;
3486 	}
3487 	tmp_vfstab_len = strlen(vfstab) + 7;
3488 	(void) memset(tmp_vfstab, 0, tmp_vfstab_len);
3489 	(void) strlcpy(tmp_vfstab, vfstab, tmp_vfstab_len);
3490 	(void) strlcat(tmp_vfstab, "XXXXXX", tmp_vfstab_len);
3491 	if ((fd = mkstemp(tmp_vfstab)) == -1) {
3492 		err = errno;
3493 		be_print_err(gettext("_update_vfstab: "
3494 		    "mkstemp failed: %s\n"), strerror(err));
3495 		ret = errno_to_be_err(err);
3496 		goto cleanup;
3497 	}
3498 	if ((tfile = fdopen(fd, "w")) == NULL) {
3499 		err = errno;
3500 		be_print_err(gettext("_update_vfstab: "
3501 		    "could not open file for write\n"));
3502 		(void) close(fd);
3503 		ret = errno_to_be_err(err);
3504 		goto cleanup;
3505 	}
3506 
3507 	while (fgets(comments_buf, BUFSIZ, comments)) {
3508 		for (c = comments_buf; *c != '\0' && isspace(*c); c++)
3509 			;
3510 		if (*c == '\0') {
3511 			continue;
3512 		} else if (*c == '#') {
3513 			/*
3514 			 * If line is a comment line, just put
3515 			 * it through to the tmp vfstab.
3516 			 */
3517 			(void) fputs(comments_buf, tfile);
3518 		} else {
3519 			/*
3520 			 * Else line is a vfstab entry, grab it
3521 			 * into a vfstab struct.
3522 			 */
3523 			if (getvfsent(vfs_ents, &vp) != 0) {
3524 				err = errno;
3525 				be_print_err(gettext("_update_vfstab: "
3526 				    "getvfsent failed: %s\n"), strerror(err));
3527 				ret = errno_to_be_err(err);
3528 				goto cleanup;
3529 			}
3530 
3531 			if (vp.vfs_special == NULL || vp.vfs_mountp == NULL) {
3532 				(void) putvfsent(tfile, &vp);
3533 				continue;
3534 			}
3535 
3536 			/*
3537 			 * If the entry is one of the entries in the list
3538 			 * of file systems to update, modify it's device
3539 			 * field to be correct for this BE.
3540 			 */
3541 			for (i = 0; i < fld->fs_num; i++) {
3542 				if (strcmp(vp.vfs_special, fld->fs_list[i])
3543 				    == 0) {
3544 					/*
3545 					 * Found entry that needs an update.
3546 					 * Replace the root container dataset
3547 					 * location and be_name in the
3548 					 * entry's device.
3549 					 */
3550 					(void) strlcpy(dev, vp.vfs_special,
3551 					    sizeof (dev));
3552 
3553 					if ((ret = update_dataset(dev,
3554 					    sizeof (dev), be_name, old_rc_loc,
3555 					    new_rc_loc)) != 0) {
3556 						be_print_err(
3557 						    gettext("_update_vfstab: "
3558 						    "Failed to update device "
3559 						    "field for vfstab entry "
3560 						    "%s\n"), fld->fs_list[i]);
3561 						goto cleanup;
3562 					}
3563 
3564 					vp.vfs_special = dev;
3565 					break;
3566 				}
3567 			}
3568 
3569 			/* Put entry through to tmp vfstab */
3570 			(void) putvfsent(tfile, &vp);
3571 		}
3572 	}
3573 
3574 	(void) fclose(comments);
3575 	comments = NULL;
3576 	(void) fclose(vfs_ents);
3577 	vfs_ents = NULL;
3578 	(void) fclose(tfile);
3579 	tfile = NULL;
3580 
3581 	/* Copy tmp vfstab into place */
3582 	if (rename(tmp_vfstab, vfstab) != 0) {
3583 		err = errno;
3584 		be_print_err(gettext("_update_vfstab: "
3585 		    "failed to rename file %s to %s: %s\n"), tmp_vfstab,
3586 		    vfstab, strerror(err));
3587 		ret = errno_to_be_err(err);
3588 		goto cleanup;
3589 	}
3590 
3591 	/* Set the perms and ownership of the updated file */
3592 	if (chmod(vfstab, sb.st_mode) != 0) {
3593 		err = errno;
3594 		be_print_err(gettext("_update_vfstab: "
3595 		    "failed to chmod %s: %s\n"), vfstab, strerror(err));
3596 		ret = errno_to_be_err(err);
3597 		goto cleanup;
3598 	}
3599 	if (chown(vfstab, sb.st_uid, sb.st_gid) != 0) {
3600 		err = errno;
3601 		be_print_err(gettext("_update_vfstab: "
3602 		    "failed to chown %s: %s\n"), vfstab, strerror(err));
3603 		ret = errno_to_be_err(err);
3604 		goto cleanup;
3605 	}
3606 
3607 cleanup:
3608 	if (comments != NULL)
3609 		(void) fclose(comments);
3610 	if (vfs_ents != NULL)
3611 		(void) fclose(vfs_ents);
3612 	(void) unlink(tmp_vfstab);
3613 	(void) free(tmp_vfstab);
3614 	if (tfile != NULL)
3615 		(void) fclose(tfile);
3616 
3617 	return (ret);
3618 }
3619 
3620 
3621 /*
3622  * Function:	be_get_auto_name
3623  * Description:	Generate an auto name constructed based on the BE name
3624  *		of the original BE or zone BE being cloned.
3625  * Parameters:
3626  *		obe_name - name of the original BE or zone BE being cloned.
3627  *              container_ds - container dataset for the zone.
3628  *                             Note: if zone_be is false this should be
3629  *                                  NULL.
3630  *		zone_be - flag that indicates if we are operating on a zone BE.
3631  * Returns:
3632  *		Success - pointer to auto generated BE name.  The name
3633  *			is allocated in heap storage so the caller is
3634  *			responsible for free'ing the name.
3635  *		Failure - NULL
3636  * Scope:
3637  *		Private
3638  */
3639 static char *
3640 be_get_auto_name(char *obe_name, char *be_container_ds, boolean_t zone_be)
3641 {
3642 	be_node_list_t	*be_nodes = NULL;
3643 	be_node_list_t	*cur_be = NULL;
3644 	char		auto_be_name[MAXPATHLEN];
3645 	char		base_be_name[MAXPATHLEN];
3646 	char		cur_be_name[MAXPATHLEN];
3647 	char		*num_str = NULL;
3648 	char		*c = NULL;
3649 	int		num = 0;
3650 	int		cur_num = 0;
3651 
3652 	errno = 0;
3653 
3654 	/*
3655 	 * Check if obe_name is already in an auto BE name format.
3656 	 * If it is, then strip off the increment number to get the
3657 	 * base name.
3658 	 */
3659 	(void) strlcpy(base_be_name, obe_name, sizeof (base_be_name));
3660 
3661 	if ((num_str = strrchr(base_be_name, BE_AUTO_NAME_DELIM))
3662 	    != NULL) {
3663 		/* Make sure remaining string is all digits */
3664 		c = num_str + 1;
3665 		while (c[0] != '\0' && isdigit(c[0]))
3666 			c++;
3667 		/*
3668 		 * If we're now at the end of the string strip off the
3669 		 * increment number.
3670 		 */
3671 		if (c[0] == '\0')
3672 			num_str[0] = '\0';
3673 	}
3674 
3675 	if (zone_be) {
3676 		if (be_container_ds == NULL)
3677 			return (NULL);
3678 		if (be_get_zone_be_list(obe_name, be_container_ds,
3679 		    &be_nodes) != BE_SUCCESS) {
3680 			be_print_err(gettext("be_get_auto_name: "
3681 			    "be_get_zone_be_list failed\n"));
3682 			return (NULL);
3683 		}
3684 	} else if (_be_list(NULL, &be_nodes, BE_LIST_DEFAULT) != BE_SUCCESS) {
3685 		be_print_err(gettext("be_get_auto_name: be_list failed\n"));
3686 		return (NULL);
3687 	}
3688 
3689 	for (cur_be = be_nodes; cur_be != NULL; cur_be = cur_be->be_next_node) {
3690 		(void) strlcpy(cur_be_name, cur_be->be_node_name,
3691 		    sizeof (cur_be_name));
3692 
3693 		/* If cur_be_name doesn't match at least base be name, skip. */
3694 		if (strncmp(cur_be_name, base_be_name, strlen(base_be_name))
3695 		    != 0)
3696 			continue;
3697 
3698 		/* Get the string following the base be name */
3699 		num_str = cur_be_name + strlen(base_be_name);
3700 
3701 		/*
3702 		 * If nothing follows the base be name, this cur_be_name
3703 		 * is the BE named with the base be name, skip.
3704 		 */
3705 		if (num_str == NULL || num_str[0] == '\0')
3706 			continue;
3707 
3708 		/*
3709 		 * Remove the name delimiter.  If its not there,
3710 		 * cur_be_name isn't part of this BE name stream, skip.
3711 		 */
3712 		if (num_str[0] == BE_AUTO_NAME_DELIM)
3713 			num_str++;
3714 		else
3715 			continue;
3716 
3717 		/* Make sure remaining string is all digits */
3718 		c = num_str;
3719 		while (c[0] != '\0' && isdigit(c[0]))
3720 			c++;
3721 		if (c[0] != '\0')
3722 			continue;
3723 
3724 		/* Convert the number string to an int */
3725 		cur_num = atoi(num_str);
3726 
3727 		/*
3728 		 * If failed to convert the string, skip it.  If its too
3729 		 * long to be converted to an int, we wouldn't auto generate
3730 		 * this number anyway so there couldn't be a conflict.
3731 		 * We treat it as a manually created BE name.
3732 		 */
3733 		if (cur_num == 0 && errno == EINVAL)
3734 			continue;
3735 
3736 		/*
3737 		 * Compare current number to current max number,
3738 		 * take higher of the two.
3739 		 */
3740 		if (cur_num > num)
3741 			num = cur_num;
3742 	}
3743 
3744 	/*
3745 	 * Store off a copy of 'num' incase we need it later.  If incrementing
3746 	 * 'num' causes it to roll over, this means 'num' is the largest
3747 	 * positive int possible; we'll need it later in the loop to determine
3748 	 * if we've exhausted all possible increment numbers.  We store it in
3749 	 * 'cur_num'.
3750 	 */
3751 	cur_num = num;
3752 
3753 	/* Increment 'num' to get new auto BE name number */
3754 	if (++num <= 0) {
3755 		int ret = 0;
3756 
3757 		/*
3758 		 * Since incrementing 'num' caused it to rollover, start
3759 		 * over at 0 and find the first available number.
3760 		 */
3761 		for (num = 0; num < cur_num; num++) {
3762 
3763 			(void) snprintf(cur_be_name, sizeof (cur_be_name),
3764 			    "%s%c%d", base_be_name, BE_AUTO_NAME_DELIM, num);
3765 
3766 			ret = zpool_iter(g_zfs, be_exists_callback,
3767 			    cur_be_name);
3768 
3769 			if (ret == 0) {
3770 				/*
3771 				 * BE name doesn't exist, break out
3772 				 * to use 'num'.
3773 				 */
3774 				break;
3775 			} else if (ret == 1) {
3776 				/* BE name exists, continue looking */
3777 				continue;
3778 			} else {
3779 				be_print_err(gettext("be_get_auto_name: "
3780 				    "zpool_iter failed: %s\n"),
3781 				    libzfs_error_description(g_zfs));
3782 				be_free_list(be_nodes);
3783 				return (NULL);
3784 			}
3785 		}
3786 
3787 		/*
3788 		 * If 'num' equals 'cur_num', we've exhausted all possible
3789 		 * auto BE names for this base BE name.
3790 		 */
3791 		if (num == cur_num) {
3792 			be_print_err(gettext("be_get_auto_name: "
3793 			    "No more available auto BE names for base "
3794 			    "BE name %s\n"), base_be_name);
3795 			be_free_list(be_nodes);
3796 			return (NULL);
3797 		}
3798 	}
3799 
3800 	be_free_list(be_nodes);
3801 
3802 	/*
3803 	 * Generate string for auto BE name.
3804 	 */
3805 	(void) snprintf(auto_be_name, sizeof (auto_be_name), "%s%c%d",
3806 	    base_be_name, BE_AUTO_NAME_DELIM, num);
3807 
3808 	if ((c = strdup(auto_be_name)) == NULL) {
3809 		be_print_err(gettext("be_get_auto_name: "
3810 		    "memory allocation failed\n"));
3811 		return (NULL);
3812 	}
3813 
3814 	return (c);
3815 }
3816 
3817 /*
3818  * Function:	be_get_console_prop
3819  * Description:	Determine console device.
3820  * Returns:
3821  *		Success - pointer to console setting.
3822  *		Failure - NULL
3823  * Scope:
3824  *		Private
3825  */
3826 static char *
3827 be_get_console_prop(void)
3828 {
3829 	di_node_t	dn;
3830 	char *console = NULL;
3831 
3832 	if ((dn = di_init("/", DINFOPROP)) == DI_NODE_NIL) {
3833 		be_print_err(gettext("be_get_console_prop: "
3834 		    "di_init() failed\n"));
3835 		return (NULL);
3836 	}
3837 
3838 	if (di_prop_lookup_strings(DDI_DEV_T_ANY, dn,
3839 	    "console", &console) != -1) {
3840 		di_fini(dn);
3841 		return (console);
3842 	}
3843 
3844 	if (console == NULL) {
3845 		if (di_prop_lookup_strings(DDI_DEV_T_ANY, dn,
3846 		    "output-device", &console) != -1) {
3847 			di_fini(dn);
3848 			if (strncmp(console, "screen", strlen("screen")) == 0)
3849 				console = BE_DEFAULT_CONSOLE;
3850 		}
3851 	}
3852 
3853 	/*
3854 	 * Default console to text
3855 	 */
3856 	if (console == NULL) {
3857 		console = BE_DEFAULT_CONSOLE;
3858 	}
3859 
3860 	return (console);
3861 }
3862 
3863 /*
3864  * Function:	be_create_menu
3865  * Description:
3866  *		This function is used if no menu.lst file exists. In
3867  *		this case a new file is created and if needed default
3868  *		lines are added to the file.
3869  * Parameters:
3870  *		pool - The name of the pool the menu.lst file is on
3871  *		menu_file - The name of the file we're creating.
3872  *		menu_fp - A pointer to the file pointer of the file we
3873  *			  created. This is also used to pass back the file
3874  *			  pointer to the newly created file.
3875  *		mode - the original mode used for the failed attempt to
3876  *		       non-existent file.
3877  * Returns:
3878  *		BE_SUCCESS - Success
3879  *		be_errno_t - Failure
3880  * Scope:
3881  *		Private
3882  */
3883 static int
3884 be_create_menu(
3885 	char *pool,
3886 	char *menu_file,
3887 	FILE **menu_fp,
3888 	char *mode)
3889 {
3890 	be_node_list_t	*be_nodes = NULL;
3891 	char *menu_path = NULL;
3892 	char *be_rpool = NULL;
3893 	char *be_name = NULL;
3894 	char *console = NULL;
3895 	errno = 0;
3896 
3897 	if (menu_file == NULL || menu_fp == NULL || mode == NULL)
3898 		return (BE_ERR_INVAL);
3899 
3900 	menu_path = strdup(menu_file);
3901 	if (menu_path == NULL)
3902 		return (BE_ERR_NOMEM);
3903 
3904 	(void) dirname(menu_path);
3905 	if (*menu_path == '.') {
3906 		free(menu_path);
3907 		return (BE_ERR_BAD_MENU_PATH);
3908 	}
3909 	if (mkdirp(menu_path,
3910 	    S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1 &&
3911 	    errno != EEXIST) {
3912 		be_print_err(gettext("be_create_menu: Failed to create the %s "
3913 		    "directory: %s\n"), menu_path, strerror(errno));
3914 		free(menu_path);
3915 		return (errno_to_be_err(errno));
3916 	}
3917 	free(menu_path);
3918 
3919 	/*
3920 	 * Check to see if this system supports grub
3921 	 */
3922 	if (be_has_grub()) {
3923 		/*
3924 		 * The grub menu is missing so we need to create it
3925 		 * and fill in the first few lines.
3926 		 */
3927 		FILE *temp_fp = fopen(menu_file, "a+");
3928 		if (temp_fp == NULL) {
3929 			*menu_fp = NULL;
3930 			return (errno_to_be_err(errno));
3931 		}
3932 
3933 		if ((console = be_get_console_prop()) != NULL) {
3934 
3935 			/*
3936 			 * If console is redirected to serial line,
3937 			 * GRUB splash screen will not be enabled.
3938 			 */
3939 			if (strncmp(console, "text", strlen("text")) == 0 ||
3940 			    strncmp(console, "graphics",
3941 			    strlen("graphics")) == 0) {
3942 
3943 				(void) fprintf(temp_fp, "%s\n", BE_GRUB_SPLASH);
3944 				(void) fprintf(temp_fp, "%s\n",
3945 				    BE_GRUB_FOREGROUND);
3946 				(void) fprintf(temp_fp, "%s\n",
3947 				    BE_GRUB_BACKGROUND);
3948 				(void) fprintf(temp_fp, "%s\n",
3949 				    BE_GRUB_DEFAULT);
3950 			} else {
3951 				be_print_err(gettext("be_create_menu: "
3952 				    "console on serial line, "
3953 				    "GRUB splash image will be disabled\n"));
3954 			}
3955 		}
3956 
3957 		(void) fprintf(temp_fp,	"timeout 30\n");
3958 		(void) fclose(temp_fp);
3959 
3960 	} else {
3961 		/*
3962 		 * The menu file doesn't exist so we need to create a
3963 		 * blank file.
3964 		 */
3965 		FILE *temp_fp = fopen(menu_file, "w+");
3966 		if (temp_fp == NULL) {
3967 			*menu_fp = NULL;
3968 			return (errno_to_be_err(errno));
3969 		}
3970 		(void) fclose(temp_fp);
3971 	}
3972 
3973 	/*
3974 	 * Now we need to add all the BE's back into the the file.
3975 	 */
3976 	if (_be_list(NULL, &be_nodes, BE_LIST_DEFAULT) == BE_SUCCESS) {
3977 		while (be_nodes != NULL) {
3978 			if (strcmp(pool, be_nodes->be_rpool) == 0) {
3979 				(void) be_append_menu(be_nodes->be_node_name,
3980 				    be_nodes->be_rpool, NULL, NULL, NULL);
3981 			}
3982 			if (be_nodes->be_active_on_boot) {
3983 				be_rpool = strdup(be_nodes->be_rpool);
3984 				be_name = strdup(be_nodes->be_node_name);
3985 			}
3986 
3987 			be_nodes = be_nodes->be_next_node;
3988 		}
3989 	}
3990 	be_free_list(be_nodes);
3991 
3992 	/*
3993 	 * Check to see if this system supports grub
3994 	 */
3995 	if (be_has_grub()) {
3996 		int err = be_change_grub_default(be_name, be_rpool);
3997 		if (err != BE_SUCCESS)
3998 			return (err);
3999 	}
4000 	*menu_fp = fopen(menu_file, mode);
4001 	if (*menu_fp == NULL)
4002 		return (errno_to_be_err(errno));
4003 
4004 	return (BE_SUCCESS);
4005 }
4006 
4007 /*
4008  * Function:	be_open_menu
4009  * Description:
4010  *		This function is used it open the menu.lst file. If this
4011  *              file does not exist be_create_menu is called to create it
4012  *              and the open file pointer is returned. If the file does
4013  *              exist it is simply opened using the mode passed in.
4014  * Parameters:
4015  *		pool - The name of the pool the menu.lst file is on
4016  *		menu_file - The name of the file we're opening.
4017  *		menu_fp - A pointer to the file pointer of the file we're
4018  *			  opening. This is also used to pass back the file
4019  *			  pointer.
4020  *		mode - the original mode to be used for opening the menu.lst
4021  *                     file.
4022  *              create_menu - If this is true and the menu.lst file does not
4023  *                            exist we will attempt to re-create it. However
4024  *                            if it's false the error returned from the fopen
4025  *                            will be returned.
4026  * Returns:
4027  *		BE_SUCCESS - Success
4028  *		be_errno_t - Failure
4029  * Scope:
4030  *		Private
4031  */
4032 static int
4033 be_open_menu(
4034 	char *pool,
4035 	char *menu_file,
4036 	FILE **menu_fp,
4037 	char *mode,
4038 	boolean_t create_menu)
4039 {
4040 	int	err = 0;
4041 	boolean_t	set_print = B_FALSE;
4042 
4043 	*menu_fp = fopen(menu_file, mode);
4044 	err = errno;
4045 	if (*menu_fp == NULL) {
4046 		if (err == ENOENT && create_menu) {
4047 			be_print_err(gettext("be_open_menu: menu.lst "
4048 			    "file %s does not exist,\n"), menu_file);
4049 			if (!do_print) {
4050 				set_print = B_TRUE;
4051 				do_print = B_TRUE;
4052 			}
4053 			be_print_err(gettext("WARNING: menu.lst "
4054 			    "file %s does not exist,\n         generating "
4055 			    "a new menu.lst file\n"), menu_file);
4056 			if (set_print)
4057 				do_print = B_FALSE;
4058 			err = 0;
4059 			if ((err = be_create_menu(pool, menu_file,
4060 			    menu_fp, mode)) == ENOENT)
4061 				return (BE_ERR_NO_MENU);
4062 			else if (err != BE_SUCCESS)
4063 				return (err);
4064 			else if (*menu_fp == NULL)
4065 				return (BE_ERR_NO_MENU);
4066 		} else {
4067 			be_print_err(gettext("be_open_menu: failed "
4068 			    "to open menu.lst file %s\n"), menu_file);
4069 			if (err == ENOENT)
4070 				return (BE_ERR_NO_MENU);
4071 			else
4072 				return (errno_to_be_err(err));
4073 		}
4074 	}
4075 	return (BE_SUCCESS);
4076 }
4077