xref: /titanic_41/usr/src/lib/libbe/common/be_activate.c (revision 74cf039b8dfb386f26b18ea4121956743408b4de)
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  */
25 
26 /*
27  * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
28  */
29 
30 #include <assert.h>
31 #include <libintl.h>
32 #include <libnvpair.h>
33 #include <libzfs.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <strings.h>
38 #include <errno.h>
39 #include <sys/mnttab.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <fcntl.h>
43 #include <unistd.h>
44 #include <sys/efi_partition.h>
45 
46 #include <libbe.h>
47 #include <libbe_priv.h>
48 
49 char	*mnttab = MNTTAB;
50 
51 /*
52  * Private function prototypes
53  */
54 static int set_bootfs(char *boot_rpool, char *be_root_ds);
55 static int set_canmount(be_node_list_t *, char *);
56 static boolean_t be_do_installgrub_mbr(char *, nvlist_t *);
57 static int be_do_installgrub_helper(zpool_handle_t *, nvlist_t *, char *,
58     char *);
59 static int be_do_installgrub(be_transaction_data_t *);
60 static int be_get_grub_vers(be_transaction_data_t *, char **, char **);
61 static int get_ver_from_capfile(char *, char **);
62 static int be_promote_zone_ds(char *, char *);
63 static int be_promote_ds_callback(zfs_handle_t *, void *);
64 
65 /* ******************************************************************** */
66 /*			Public Functions				*/
67 /* ******************************************************************** */
68 
69 /*
70  * Function:	be_activate
71  * Description:	Calls _be_activate which activates the BE named in the
72  *		attributes passed in through be_attrs. The process of
73  *		activation sets the bootfs property of the root pool, resets
74  *		the canmount property to noauto, and sets the default in the
75  *		grub menu to the entry corresponding to the entry for the named
76  *		BE.
77  * Parameters:
78  *		be_attrs - pointer to nvlist_t of attributes being passed in.
79  *			The follow attribute values are used by this function:
80  *
81  *			BE_ATTR_ORIG_BE_NAME		*required
82  * Return:
83  *		BE_SUCCESS - Success
84  *		be_errno_t - Failure
85  * Scope:
86  *		Public
87  */
88 int
be_activate(nvlist_t * be_attrs)89 be_activate(nvlist_t *be_attrs)
90 {
91 	int	ret = BE_SUCCESS;
92 	char	*be_name = NULL;
93 
94 	/* Initialize libzfs handle */
95 	if (!be_zfs_init())
96 		return (BE_ERR_INIT);
97 
98 	/* Get the BE name to activate */
99 	if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name)
100 	    != 0) {
101 		be_print_err(gettext("be_activate: failed to "
102 		    "lookup BE_ATTR_ORIG_BE_NAME attribute\n"));
103 		be_zfs_fini();
104 		return (BE_ERR_INVAL);
105 	}
106 
107 	/* Validate BE name */
108 	if (!be_valid_be_name(be_name)) {
109 		be_print_err(gettext("be_activate: invalid BE name %s\n"),
110 		    be_name);
111 		be_zfs_fini();
112 		return (BE_ERR_INVAL);
113 	}
114 
115 	ret = _be_activate(be_name);
116 
117 	be_zfs_fini();
118 
119 	return (ret);
120 }
121 
122 /* ******************************************************************** */
123 /*			Semi Private Functions				*/
124 /* ******************************************************************** */
125 
126 /*
127  * Function:	_be_activate
128  * Description:	This does the actual work described in be_activate.
129  * Parameters:
130  *		be_name - pointer to the name of BE to activate.
131  *
132  * Return:
133  *		BE_SUCCESS - Success
134  *		be_errnot_t - Failure
135  * Scope:
136  *		Public
137  */
138 int
_be_activate(char * be_name)139 _be_activate(char *be_name)
140 {
141 	be_transaction_data_t cb = { 0 };
142 	zfs_handle_t	*zhp = NULL;
143 	char		root_ds[MAXPATHLEN];
144 	char		active_ds[MAXPATHLEN];
145 	char		*cur_vers = NULL, *new_vers = NULL;
146 	be_node_list_t	*be_nodes = NULL;
147 	uuid_t		uu = {0};
148 	int		entry, ret = BE_SUCCESS;
149 	int		zret = 0;
150 
151 	/*
152 	 * TODO: The BE needs to be validated to make sure that it is actually
153 	 * a bootable BE.
154 	 */
155 
156 	if (be_name == NULL)
157 		return (BE_ERR_INVAL);
158 
159 	/* Set obe_name to be_name in the cb structure */
160 	cb.obe_name = be_name;
161 
162 	/* find which zpool the be is in */
163 	if ((zret = zpool_iter(g_zfs, be_find_zpool_callback, &cb)) == 0) {
164 		be_print_err(gettext("be_activate: failed to "
165 		    "find zpool for BE (%s)\n"), cb.obe_name);
166 		return (BE_ERR_BE_NOENT);
167 	} else if (zret < 0) {
168 		be_print_err(gettext("be_activate: "
169 		    "zpool_iter failed: %s\n"),
170 		    libzfs_error_description(g_zfs));
171 		ret = zfs_err_to_be_err(g_zfs);
172 		return (ret);
173 	}
174 
175 	be_make_root_ds(cb.obe_zpool, cb.obe_name, root_ds, sizeof (root_ds));
176 	cb.obe_root_ds = strdup(root_ds);
177 
178 	if (getzoneid() == GLOBAL_ZONEID) {
179 		if (be_has_grub() && (ret = be_get_grub_vers(&cb, &cur_vers,
180 		    &new_vers)) != BE_SUCCESS) {
181 			be_print_err(gettext("be_activate: failed to get grub "
182 			    "versions from capability files.\n"));
183 			return (ret);
184 		}
185 		if (cur_vers != NULL) {
186 			/*
187 			 * We need to check to see if the version number from
188 			 * the BE being activated is greater than the current
189 			 * one.
190 			 */
191 			if (new_vers != NULL &&
192 			    atof(cur_vers) < atof(new_vers)) {
193 				if ((ret = be_do_installgrub(&cb))
194 				    != BE_SUCCESS) {
195 					free(new_vers);
196 					free(cur_vers);
197 					return (ret);
198 				}
199 				free(new_vers);
200 			}
201 			free(cur_vers);
202 		} else if (new_vers != NULL) {
203 			if ((ret = be_do_installgrub(&cb)) != BE_SUCCESS) {
204 				free(new_vers);
205 				return (ret);
206 			}
207 			free(new_vers);
208 		}
209 		if (!be_has_menu_entry(root_ds, cb.obe_zpool, &entry)) {
210 			if ((ret = be_append_menu(cb.obe_name, cb.obe_zpool,
211 			    NULL, NULL, NULL)) != BE_SUCCESS) {
212 				be_print_err(gettext("be_activate: Failed to "
213 				    "add BE (%s) to the GRUB menu\n"),
214 				    cb.obe_name);
215 				goto done;
216 			}
217 		}
218 		if (be_has_grub()) {
219 			if ((ret = be_change_grub_default(cb.obe_name,
220 			    cb.obe_zpool)) != BE_SUCCESS) {
221 				be_print_err(gettext("be_activate: failed to "
222 				    "change the default entry in menu.lst\n"));
223 				goto done;
224 			}
225 		}
226 	}
227 
228 	if ((ret = _be_list(cb.obe_name, &be_nodes)) != BE_SUCCESS) {
229 		return (ret);
230 	}
231 
232 	if ((ret = set_canmount(be_nodes, "noauto")) != BE_SUCCESS) {
233 		be_print_err(gettext("be_activate: failed to set "
234 		    "canmount dataset property\n"));
235 		goto done;
236 	}
237 
238 	if (getzoneid() == GLOBAL_ZONEID) {
239 		if ((ret = set_bootfs(be_nodes->be_rpool,
240 		    root_ds)) != BE_SUCCESS) {
241 			be_print_err(gettext("be_activate: failed to set "
242 			    "bootfs pool property for %s\n"), root_ds);
243 			goto done;
244 		}
245 	}
246 
247 	if ((zhp = zfs_open(g_zfs, root_ds, ZFS_TYPE_FILESYSTEM)) != NULL) {
248 		/*
249 		 * We don't need to close the zfs handle at this
250 		 * point because The callback funtion
251 		 * be_promote_ds_callback() will close it for us.
252 		 */
253 		if (be_promote_ds_callback(zhp, NULL) != 0) {
254 			be_print_err(gettext("be_activate: "
255 			    "failed to activate the "
256 			    "datasets for %s: %s\n"),
257 			    root_ds,
258 			    libzfs_error_description(g_zfs));
259 			ret = BE_ERR_PROMOTE;
260 			goto done;
261 		}
262 	} else {
263 		be_print_err(gettext("be_activate: failed to open "
264 		    "dataset (%s): %s\n"), root_ds,
265 		    libzfs_error_description(g_zfs));
266 		ret = zfs_err_to_be_err(g_zfs);
267 		goto done;
268 	}
269 
270 	if (getzoneid() == GLOBAL_ZONEID &&
271 	    be_get_uuid(cb.obe_root_ds, &uu) == BE_SUCCESS &&
272 	    (ret = be_promote_zone_ds(cb.obe_name, cb.obe_root_ds))
273 	    != BE_SUCCESS) {
274 		be_print_err(gettext("be_activate: failed to promote "
275 		    "the active zonepath datasets for zones in BE %s\n"),
276 		    cb.obe_name);
277 	}
278 
279 	if (getzoneid() != GLOBAL_ZONEID) {
280 		if (!be_zone_compare_uuids(root_ds)) {
281 			be_print_err(gettext("be_activate: activating zone "
282 			    "root dataset from non-active global BE is not "
283 			    "supported\n"));
284 			ret = BE_ERR_NOTSUP;
285 			goto done;
286 		}
287 		if ((zhp = zfs_open(g_zfs, root_ds,
288 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
289 			be_print_err(gettext("be_activate: failed to open "
290 			    "dataset (%s): %s\n"), root_ds,
291 			    libzfs_error_description(g_zfs));
292 			ret = zfs_err_to_be_err(g_zfs);
293 			goto done;
294 		}
295 		/* Find current active zone root dataset */
296 		if ((ret = be_find_active_zone_root(zhp, cb.obe_zpool,
297 		    active_ds, sizeof (active_ds))) != BE_SUCCESS) {
298 			be_print_err(gettext("be_activate: failed to find "
299 			    "active zone root dataset\n"));
300 			ZFS_CLOSE(zhp);
301 			goto done;
302 		}
303 		/* Do nothing if requested BE is already active */
304 		if (strcmp(root_ds, active_ds) == 0) {
305 			ret = BE_SUCCESS;
306 			ZFS_CLOSE(zhp);
307 			goto done;
308 		}
309 
310 		/* Set active property for BE */
311 		if (zfs_prop_set(zhp, BE_ZONE_ACTIVE_PROPERTY, "on") != 0) {
312 			be_print_err(gettext("be_activate: failed to set "
313 			    "active property (%s): %s\n"), root_ds,
314 			    libzfs_error_description(g_zfs));
315 			ret = zfs_err_to_be_err(g_zfs);
316 			ZFS_CLOSE(zhp);
317 			goto done;
318 		}
319 		ZFS_CLOSE(zhp);
320 
321 		/* Unset active property for old active root dataset */
322 		if ((zhp = zfs_open(g_zfs, active_ds,
323 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
324 			be_print_err(gettext("be_activate: failed to open "
325 			    "dataset (%s): %s\n"), active_ds,
326 			    libzfs_error_description(g_zfs));
327 			ret = zfs_err_to_be_err(g_zfs);
328 			goto done;
329 		}
330 		if (zfs_prop_set(zhp, BE_ZONE_ACTIVE_PROPERTY, "off") != 0) {
331 			be_print_err(gettext("be_activate: failed to unset "
332 			    "active property (%s): %s\n"), active_ds,
333 			    libzfs_error_description(g_zfs));
334 			ret = zfs_err_to_be_err(g_zfs);
335 			ZFS_CLOSE(zhp);
336 			goto done;
337 		}
338 		ZFS_CLOSE(zhp);
339 	}
340 done:
341 	be_free_list(be_nodes);
342 	return (ret);
343 }
344 
345 /*
346  * Function:	be_activate_current_be
347  * Description:	Set the currently "active" BE to be "active on boot"
348  * Paramters:
349  *		none
350  * Returns:
351  *		BE_SUCCESS - Success
352  *		be_errnot_t - Failure
353  * Scope:
354  *		Semi-private (library wide use only)
355  */
356 int
be_activate_current_be(void)357 be_activate_current_be(void)
358 {
359 	int ret = BE_SUCCESS;
360 	be_transaction_data_t bt = { 0 };
361 
362 	if ((ret = be_find_current_be(&bt)) != BE_SUCCESS) {
363 		return (ret);
364 	}
365 
366 	if ((ret = _be_activate(bt.obe_name)) != BE_SUCCESS) {
367 		be_print_err(gettext("be_activate_current_be: failed to "
368 		    "activate %s\n"), bt.obe_name);
369 		return (ret);
370 	}
371 
372 	return (BE_SUCCESS);
373 }
374 
375 /*
376  * Function:	be_is_active_on_boot
377  * Description:	Checks if the BE name passed in has the "active on boot"
378  *		property set to B_TRUE.
379  * Paramters:
380  *		be_name - the name of the BE to check
381  * Returns:
382  *		B_TRUE - if active on boot.
383  *		B_FALSE - if not active on boot.
384  * Scope:
385  *		Semi-private (library wide use only)
386  */
387 boolean_t
be_is_active_on_boot(char * be_name)388 be_is_active_on_boot(char *be_name)
389 {
390 	be_node_list_t *be_node = NULL;
391 
392 	if (be_name == NULL) {
393 		be_print_err(gettext("be_is_active_on_boot: "
394 		    "be_name must not be NULL\n"));
395 		return (B_FALSE);
396 	}
397 
398 	if (_be_list(be_name, &be_node) != BE_SUCCESS) {
399 		return (B_FALSE);
400 	}
401 
402 	if (be_node == NULL) {
403 		return (B_FALSE);
404 	}
405 
406 	if (be_node->be_active_on_boot) {
407 		be_free_list(be_node);
408 		return (B_TRUE);
409 	} else {
410 		be_free_list(be_node);
411 		return (B_FALSE);
412 	}
413 }
414 
415 /* ******************************************************************** */
416 /*			Private Functions				*/
417 /* ******************************************************************** */
418 
419 /*
420  * Function:	set_bootfs
421  * Description:	Sets the bootfs property on the boot pool to be the
422  *		root dataset of the activated BE.
423  * Parameters:
424  *		boot_pool - The pool we're setting bootfs in.
425  *		be_root_ds - The main dataset for the BE.
426  * Return:
427  *		BE_SUCCESS - Success
428  *		be_errno_t - Failure
429  * Scope:
430  *		Private
431  */
432 static int
set_bootfs(char * boot_rpool,char * be_root_ds)433 set_bootfs(char *boot_rpool, char *be_root_ds)
434 {
435 	zpool_handle_t *zhp;
436 	int err = BE_SUCCESS;
437 
438 	if ((zhp = zpool_open(g_zfs, boot_rpool)) == NULL) {
439 		be_print_err(gettext("set_bootfs: failed to open pool "
440 		    "(%s): %s\n"), boot_rpool, libzfs_error_description(g_zfs));
441 		err = zfs_err_to_be_err(g_zfs);
442 		return (err);
443 	}
444 
445 	err = zpool_set_prop(zhp, "bootfs", be_root_ds);
446 	if (err) {
447 		be_print_err(gettext("set_bootfs: failed to set "
448 		    "bootfs property for pool %s: %s\n"), boot_rpool,
449 		    libzfs_error_description(g_zfs));
450 		err = zfs_err_to_be_err(g_zfs);
451 		zpool_close(zhp);
452 		return (err);
453 	}
454 
455 	zpool_close(zhp);
456 	return (BE_SUCCESS);
457 }
458 
459 /*
460  * Function:	set_canmount
461  * Description:	Sets the canmount property on the datasets of the
462  *		activated BE.
463  * Parameters:
464  *		be_nodes - The be_node_t returned from be_list
465  *		value - The value of canmount we setting, on|off|noauto.
466  * Return:
467  *		BE_SUCCESS - Success
468  *		be_errno_t - Failure
469  * Scope:
470  *		Private
471  */
472 static int
set_canmount(be_node_list_t * be_nodes,char * value)473 set_canmount(be_node_list_t *be_nodes, char *value)
474 {
475 	char		ds_path[MAXPATHLEN];
476 	zfs_handle_t	*zhp = NULL;
477 	be_node_list_t	*list = be_nodes;
478 	int		err = BE_SUCCESS;
479 
480 	while (list != NULL) {
481 		be_dataset_list_t *datasets = list->be_node_datasets;
482 
483 		be_make_root_ds(list->be_rpool, list->be_node_name, ds_path,
484 		    sizeof (ds_path));
485 
486 		if ((zhp = zfs_open(g_zfs, ds_path, ZFS_TYPE_DATASET)) ==
487 		    NULL) {
488 			be_print_err(gettext("set_canmount: failed to open "
489 			    "dataset (%s): %s\n"), ds_path,
490 			    libzfs_error_description(g_zfs));
491 			err = zfs_err_to_be_err(g_zfs);
492 			return (err);
493 		}
494 		if (zfs_prop_get_int(zhp, ZFS_PROP_MOUNTED)) {
495 			/*
496 			 * it's already mounted so we can't change the
497 			 * canmount property anyway.
498 			 */
499 			err = BE_SUCCESS;
500 		} else {
501 			err = zfs_prop_set(zhp,
502 			    zfs_prop_to_name(ZFS_PROP_CANMOUNT), value);
503 			if (err) {
504 				ZFS_CLOSE(zhp);
505 				be_print_err(gettext("set_canmount: failed to "
506 				    "set dataset property (%s): %s\n"),
507 				    ds_path, libzfs_error_description(g_zfs));
508 				err = zfs_err_to_be_err(g_zfs);
509 				return (err);
510 			}
511 		}
512 		ZFS_CLOSE(zhp);
513 
514 		while (datasets != NULL) {
515 			be_make_root_ds(list->be_rpool,
516 			    datasets->be_dataset_name, ds_path,
517 			    sizeof (ds_path));
518 
519 			if ((zhp = zfs_open(g_zfs, ds_path, ZFS_TYPE_DATASET))
520 			    == NULL) {
521 				be_print_err(gettext("set_canmount: failed to "
522 				    "open dataset %s: %s\n"), ds_path,
523 				    libzfs_error_description(g_zfs));
524 				err = zfs_err_to_be_err(g_zfs);
525 				return (err);
526 			}
527 			if (zfs_prop_get_int(zhp, ZFS_PROP_MOUNTED)) {
528 				/*
529 				 * it's already mounted so we can't change the
530 				 * canmount property anyway.
531 				 */
532 				err = BE_SUCCESS;
533 				ZFS_CLOSE(zhp);
534 				break;
535 			}
536 			err = zfs_prop_set(zhp,
537 			    zfs_prop_to_name(ZFS_PROP_CANMOUNT), value);
538 			if (err) {
539 				ZFS_CLOSE(zhp);
540 				be_print_err(gettext("set_canmount: "
541 				    "Failed to set property value %s "
542 				    "for dataset %s: %s\n"), value, ds_path,
543 				    libzfs_error_description(g_zfs));
544 				err = zfs_err_to_be_err(g_zfs);
545 				return (err);
546 			}
547 			ZFS_CLOSE(zhp);
548 			datasets = datasets->be_next_dataset;
549 		}
550 		list = list->be_next_node;
551 	}
552 	return (err);
553 }
554 
555 /*
556  * Function:	be_get_grub_vers
557  * Description:	Gets the grub version number from /boot/grub/capability. If
558  *              capability file doesn't exist NULL is returned.
559  * Parameters:
560  *              bt - The transaction data for the BE we're getting the grub
561  *                   version for.
562  *              cur_vers - used to return the current version of grub from
563  *                         the root pool.
564  *              new_vers - used to return the grub version of the BE we're
565  *                         activating.
566  * Return:
567  *              BE_SUCCESS - Success
568  *              be_errno_t - Failed to find version
569  * Scope:
570  *		Private
571  */
572 static int
be_get_grub_vers(be_transaction_data_t * bt,char ** cur_vers,char ** new_vers)573 be_get_grub_vers(be_transaction_data_t *bt, char **cur_vers, char **new_vers)
574 {
575 	zfs_handle_t	*zhp = NULL;
576 	zfs_handle_t	*pool_zhp = NULL;
577 	int ret = BE_SUCCESS;
578 	char cap_file[MAXPATHLEN];
579 	char *temp_mntpnt = NULL;
580 	char *zpool_mntpt = NULL;
581 	char *ptmp_mntpnt = NULL;
582 	char *orig_mntpnt = NULL;
583 	boolean_t be_mounted = B_FALSE;
584 	boolean_t pool_mounted = B_FALSE;
585 
586 	if (!be_has_grub()) {
587 		be_print_err(gettext("be_get_grub_vers: Not supported on "
588 		    "this architecture\n"));
589 		return (BE_ERR_NOTSUP);
590 	}
591 
592 	if (bt == NULL || bt->obe_name == NULL || bt->obe_zpool == NULL ||
593 	    bt->obe_root_ds == NULL) {
594 		be_print_err(gettext("be_get_grub_vers: Invalid BE\n"));
595 		return (BE_ERR_INVAL);
596 	}
597 
598 	if ((pool_zhp = zfs_open(g_zfs, bt->obe_zpool, ZFS_TYPE_FILESYSTEM)) ==
599 	    NULL) {
600 		be_print_err(gettext("be_get_grub_vers: zfs_open failed: %s\n"),
601 		    libzfs_error_description(g_zfs));
602 		return (zfs_err_to_be_err(g_zfs));
603 	}
604 
605 	/*
606 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
607 	 * attempt to mount it.
608 	 */
609 	if ((ret = be_mount_pool(pool_zhp, &ptmp_mntpnt,
610 	    &orig_mntpnt, &pool_mounted)) != BE_SUCCESS) {
611 		be_print_err(gettext("be_get_grub_vers: pool dataset "
612 		    "(%s) could not be mounted\n"), bt->obe_zpool);
613 		ZFS_CLOSE(pool_zhp);
614 		return (ret);
615 	}
616 
617 	/*
618 	 * Get the mountpoint for the root pool dataset.
619 	 */
620 	if (!zfs_is_mounted(pool_zhp, &zpool_mntpt)) {
621 		be_print_err(gettext("be_get_grub_vers: pool "
622 		    "dataset (%s) is not mounted. Can't set the "
623 		    "default BE in the grub menu.\n"), bt->obe_zpool);
624 		ret = BE_ERR_NO_MENU;
625 		goto cleanup;
626 	}
627 
628 	/*
629 	 * get the version of the most recent grub update.
630 	 */
631 	(void) snprintf(cap_file, sizeof (cap_file), "%s%s",
632 	    zpool_mntpt, BE_CAP_FILE);
633 	free(zpool_mntpt);
634 	zpool_mntpt = NULL;
635 
636 	if ((ret = get_ver_from_capfile(cap_file, cur_vers)) != BE_SUCCESS)
637 		goto cleanup;
638 
639 	if ((zhp = zfs_open(g_zfs, bt->obe_root_ds, ZFS_TYPE_FILESYSTEM)) ==
640 	    NULL) {
641 		be_print_err(gettext("be_get_grub_vers: failed to "
642 		    "open BE root dataset (%s): %s\n"), bt->obe_root_ds,
643 		    libzfs_error_description(g_zfs));
644 		free(cur_vers);
645 		ret = zfs_err_to_be_err(g_zfs);
646 		goto cleanup;
647 	}
648 	if (!zfs_is_mounted(zhp, &temp_mntpnt)) {
649 		if ((ret = _be_mount(bt->obe_name, &temp_mntpnt,
650 		    BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) {
651 			be_print_err(gettext("be_get_grub_vers: failed to "
652 			    "mount BE (%s)\n"), bt->obe_name);
653 			free(*cur_vers);
654 			*cur_vers = NULL;
655 			ZFS_CLOSE(zhp);
656 			goto cleanup;
657 		}
658 		be_mounted = B_TRUE;
659 	}
660 	ZFS_CLOSE(zhp);
661 
662 	/*
663 	 * Now get the grub version for the BE being activated.
664 	 */
665 	(void) snprintf(cap_file, sizeof (cap_file), "%s%s", temp_mntpnt,
666 	    BE_CAP_FILE);
667 	ret = get_ver_from_capfile(cap_file, new_vers);
668 	if (ret != BE_SUCCESS) {
669 		free(*cur_vers);
670 		*cur_vers = NULL;
671 	}
672 	if (be_mounted)
673 		(void) _be_unmount(bt->obe_name, 0);
674 
675 cleanup:
676 	if (pool_mounted) {
677 		int iret = BE_SUCCESS;
678 		iret = be_unmount_pool(pool_zhp, ptmp_mntpnt, orig_mntpnt);
679 		if (ret == BE_SUCCESS)
680 			ret = iret;
681 		free(orig_mntpnt);
682 		free(ptmp_mntpnt);
683 	}
684 	ZFS_CLOSE(pool_zhp);
685 
686 	free(temp_mntpnt);
687 	return (ret);
688 }
689 
690 /*
691  * Function:	get_ver_from_capfile
692  * Description: Parses the capability file passed in looking for the VERSION
693  *              line. If found the version is returned in vers, if not then
694  *              NULL is returned in vers.
695  *
696  * Parameters:
697  *              file - the path to the capability file we want to parse.
698  *              vers - the version string that will be passed back.
699  * Return:
700  *              BE_SUCCESS - Success
701  *              be_errno_t - Failed to find version
702  * Scope:
703  *		Private
704  */
705 static int
get_ver_from_capfile(char * file,char ** vers)706 get_ver_from_capfile(char *file, char **vers)
707 {
708 	FILE *fp = NULL;
709 	char line[BUFSIZ];
710 	char *last = NULL;
711 	int err = BE_SUCCESS;
712 	errno = 0;
713 
714 	if (!be_has_grub()) {
715 		be_print_err(gettext("get_ver_from_capfile: Not supported "
716 		    "on this architecture\n"));
717 		return (BE_ERR_NOTSUP);
718 	}
719 
720 	/*
721 	 * Set version string to NULL; the only case this shouldn't be set
722 	 * to be NULL is when we've actually found a version in the capability
723 	 * file, which is set below.
724 	 */
725 	*vers = NULL;
726 
727 	/*
728 	 * If the capability file doesn't exist, we're returning success
729 	 * because on older releases, the capability file did not exist
730 	 * so this is a valid scenario.
731 	 */
732 	if (access(file, F_OK) == 0) {
733 		if ((fp = fopen(file, "r")) == NULL) {
734 			err = errno;
735 			be_print_err(gettext("get_ver_from_capfile: failed to "
736 			    "open file %s with error %s\n"), file,
737 			    strerror(err));
738 			err = errno_to_be_err(err);
739 			return (err);
740 		}
741 
742 		while (fgets(line, BUFSIZ, fp)) {
743 			char *tok = strtok_r(line, "=", &last);
744 
745 			if (tok == NULL || tok[0] == '#') {
746 				continue;
747 			} else if (strcmp(tok, "VERSION") == 0) {
748 				*vers = strdup(last);
749 				break;
750 			}
751 		}
752 		(void) fclose(fp);
753 	}
754 
755 	return (BE_SUCCESS);
756 }
757 
758 /*
759  * To be able to boot EFI labeled disks, GRUB stage1 needs to be written
760  * into the MBR. We do not do this if we're on disks with a traditional
761  * fdisk partition table only, or if any foreign EFI partitions exist.
762  * In the trivial case of a whole-disk vdev we always write stage1 into
763  * the MBR.
764  */
765 static boolean_t
be_do_installgrub_mbr(char * diskname,nvlist_t * child)766 be_do_installgrub_mbr(char *diskname, nvlist_t *child)
767 {
768 	struct uuid allowed_uuids[] = {
769 		EFI_UNUSED,
770 		EFI_RESV1,
771 		EFI_BOOT,
772 		EFI_ROOT,
773 		EFI_SWAP,
774 		EFI_USR,
775 		EFI_BACKUP,
776 		EFI_RESV2,
777 		EFI_VAR,
778 		EFI_HOME,
779 		EFI_ALTSCTR,
780 		EFI_RESERVED,
781 		EFI_SYSTEM,
782 		EFI_BIOS_BOOT,
783 		EFI_SYMC_PUB,
784 		EFI_SYMC_CDS
785 	};
786 
787 	uint64_t whole;
788 	struct dk_gpt *gpt;
789 	struct uuid *u;
790 	int fd, npart, i, j;
791 
792 	(void) nvlist_lookup_uint64(child, ZPOOL_CONFIG_WHOLE_DISK,
793 	    &whole);
794 
795 	if (whole)
796 		return (B_TRUE);
797 
798 	if ((fd = open(diskname, O_RDONLY|O_NDELAY)) < 0)
799 		return (B_FALSE);
800 
801 	if ((npart = efi_alloc_and_read(fd, &gpt)) <= 0)
802 		return (B_FALSE);
803 
804 	for (i = 0; i != npart; i++) {
805 		int match = 0;
806 
807 		u = &gpt->efi_parts[i].p_guid;
808 
809 		for (j = 0;
810 		    j != sizeof (allowed_uuids) / sizeof (struct uuid);
811 		    j++)
812 			if (bcmp(u, &allowed_uuids[j],
813 			    sizeof (struct uuid)) == 0)
814 				match++;
815 
816 		if (match == 0)
817 			return (B_FALSE);
818 	}
819 
820 	return (B_TRUE);
821 }
822 
823 static int
be_do_installgrub_helper(zpool_handle_t * zphp,nvlist_t * child,char * stage1,char * stage2)824 be_do_installgrub_helper(zpool_handle_t *zphp, nvlist_t *child, char *stage1,
825     char *stage2)
826 {
827 	char installgrub_cmd[MAXPATHLEN];
828 	char be_run_cmd_errbuf[BUFSIZ];
829 	char diskname[MAXPATHLEN];
830 	char *vname;
831 	char *path, *dsk_ptr;
832 	char *m_flag = "";
833 
834 	if (nvlist_lookup_string(child, ZPOOL_CONFIG_PATH, &path) != 0) {
835 		be_print_err(gettext("be_do_installgrub: "
836 		    "failed to get device path\n"));
837 		return (BE_ERR_NODEV);
838 	}
839 
840 	/*
841 	 * Modify the vdev path to point to the raw disk.
842 	 */
843 	path = strdup(path);
844 	if (path == NULL)
845 		return (BE_ERR_NOMEM);
846 
847 	dsk_ptr = strstr(path, "/dsk/");
848 	if (dsk_ptr != NULL) {
849 		*dsk_ptr = '\0';
850 		dsk_ptr++;
851 	} else {
852 		dsk_ptr = "";
853 	}
854 
855 	(void) snprintf(diskname, sizeof (diskname), "%s/r%s", path, dsk_ptr);
856 	free(path);
857 
858 	if (be_do_installgrub_mbr(diskname, child))
859 		m_flag = "-m -f";
860 
861 	vname = zpool_vdev_name(g_zfs, zphp, child, B_FALSE);
862 	if (vname == NULL) {
863 		be_print_err(gettext("be_do_installgrub: "
864 		    "failed to get device name: %s\n"),
865 		    libzfs_error_description(g_zfs));
866 		return (zfs_err_to_be_err(g_zfs));
867 	}
868 
869 	(void) snprintf(installgrub_cmd, sizeof (installgrub_cmd),
870 	    "%s %s %s %s %s", BE_INSTALL_GRUB, m_flag, stage1, stage2,
871 	    diskname);
872 	if (be_run_cmd(installgrub_cmd, be_run_cmd_errbuf, BUFSIZ, NULL, 0)
873 	    != BE_SUCCESS) {
874 		be_print_err(gettext("be_do_installgrub: installgrub "
875 		    "failed for device %s.\n"), vname);
876 		/* Assume localized cmd err output. */
877 		be_print_err(gettext("  Command: \"%s\"\n"),
878 		    installgrub_cmd);
879 		be_print_err("%s", be_run_cmd_errbuf);
880 		free(vname);
881 		return (BE_ERR_BOOTFILE_INST);
882 	}
883 	free(vname);
884 
885 	return (BE_SUCCESS);
886 }
887 
888 /*
889  * Function:	be_do_installgrub
890  * Description:	This function runs installgrub using the grub loader files
891  *              from the BE we're activating and installing them on the
892  *              pool the BE lives in.
893  *
894  * Parameters:
895  *              bt - The transaction data for the BE we're activating.
896  * Return:
897  *		BE_SUCCESS - Success
898  *		be_errno_t - Failure
899  *
900  * Scope:
901  *		Private
902  */
903 static int
be_do_installgrub(be_transaction_data_t * bt)904 be_do_installgrub(be_transaction_data_t *bt)
905 {
906 	zpool_handle_t  *zphp = NULL;
907 	zfs_handle_t	*zhp = NULL;
908 	nvlist_t **child, *nv, *config;
909 	uint_t c, children = 0;
910 	char *tmp_mntpt = NULL;
911 	char *pool_mntpnt = NULL;
912 	char *ptmp_mntpnt = NULL;
913 	char *orig_mntpnt = NULL;
914 	FILE *cap_fp = NULL;
915 	FILE *zpool_cap_fp = NULL;
916 	char line[BUFSIZ];
917 	char cap_file[MAXPATHLEN];
918 	char zpool_cap_file[MAXPATHLEN];
919 	char stage1[MAXPATHLEN];
920 	char stage2[MAXPATHLEN];
921 	char *vname;
922 	int ret = BE_SUCCESS;
923 	int err = 0;
924 	boolean_t be_mounted = B_FALSE;
925 	boolean_t pool_mounted = B_FALSE;
926 
927 	if (!be_has_grub()) {
928 		be_print_err(gettext("be_do_installgrub: Not supported "
929 		    "on this architecture\n"));
930 		return (BE_ERR_NOTSUP);
931 	}
932 
933 	if ((zhp = zfs_open(g_zfs, bt->obe_root_ds, ZFS_TYPE_FILESYSTEM)) ==
934 	    NULL) {
935 		be_print_err(gettext("be_do_installgrub: failed to "
936 		    "open BE root dataset (%s): %s\n"), bt->obe_root_ds,
937 		    libzfs_error_description(g_zfs));
938 		ret = zfs_err_to_be_err(g_zfs);
939 		return (ret);
940 	}
941 	if (!zfs_is_mounted(zhp, &tmp_mntpt)) {
942 		if ((ret = _be_mount(bt->obe_name, &tmp_mntpt,
943 		    BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) {
944 			be_print_err(gettext("be_do_installgrub: failed to "
945 			    "mount BE (%s)\n"), bt->obe_name);
946 			ZFS_CLOSE(zhp);
947 			return (ret);
948 		}
949 		be_mounted = B_TRUE;
950 	}
951 	ZFS_CLOSE(zhp);
952 
953 	(void) snprintf(stage1, sizeof (stage1), "%s%s", tmp_mntpt, BE_STAGE_1);
954 	(void) snprintf(stage2, sizeof (stage2), "%s%s", tmp_mntpt, BE_STAGE_2);
955 
956 	if ((zphp = zpool_open(g_zfs, bt->obe_zpool)) == NULL) {
957 		be_print_err(gettext("be_do_installgrub: failed to open "
958 		    "pool (%s): %s\n"), bt->obe_zpool,
959 		    libzfs_error_description(g_zfs));
960 		ret = zfs_err_to_be_err(g_zfs);
961 		if (be_mounted)
962 			(void) _be_unmount(bt->obe_name, 0);
963 		free(tmp_mntpt);
964 		return (ret);
965 	}
966 
967 	if ((config = zpool_get_config(zphp, NULL)) == NULL) {
968 		be_print_err(gettext("be_do_installgrub: failed to get zpool "
969 		    "configuration information. %s\n"),
970 		    libzfs_error_description(g_zfs));
971 		ret = zfs_err_to_be_err(g_zfs);
972 		goto done;
973 	}
974 
975 	/*
976 	 * Get the vdev tree
977 	 */
978 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nv) != 0) {
979 		be_print_err(gettext("be_do_installgrub: failed to get vdev "
980 		    "tree: %s\n"), libzfs_error_description(g_zfs));
981 		ret = zfs_err_to_be_err(g_zfs);
982 		goto done;
983 	}
984 
985 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child,
986 	    &children) != 0) {
987 		be_print_err(gettext("be_do_installgrub: failed to traverse "
988 		    "the vdev tree: %s\n"), libzfs_error_description(g_zfs));
989 		ret = zfs_err_to_be_err(g_zfs);
990 		goto done;
991 	}
992 	for (c = 0; c < children; c++) {
993 		uint_t i, nchildren = 0;
994 		nvlist_t **nvchild;
995 		vname = zpool_vdev_name(g_zfs, zphp, child[c], B_FALSE);
996 		if (vname == NULL) {
997 			be_print_err(gettext(
998 			    "be_do_installgrub: "
999 			    "failed to get device name: %s\n"),
1000 			    libzfs_error_description(g_zfs));
1001 			ret = zfs_err_to_be_err(g_zfs);
1002 			goto done;
1003 		}
1004 		if (strcmp(vname, "mirror") == 0 || vname[0] != 'c') {
1005 			free(vname);
1006 
1007 			if (nvlist_lookup_nvlist_array(child[c],
1008 			    ZPOOL_CONFIG_CHILDREN, &nvchild, &nchildren) != 0) {
1009 				be_print_err(gettext("be_do_installgrub: "
1010 				    "failed to traverse the vdev tree: %s\n"),
1011 				    libzfs_error_description(g_zfs));
1012 				ret = zfs_err_to_be_err(g_zfs);
1013 				goto done;
1014 			}
1015 
1016 			for (i = 0; i < nchildren; i++) {
1017 				ret = be_do_installgrub_helper(zphp, nvchild[i],
1018 				    stage1, stage2);
1019 				if (ret != BE_SUCCESS)
1020 					goto done;
1021 			}
1022 		} else {
1023 			free(vname);
1024 
1025 			ret = be_do_installgrub_helper(zphp, child[c], stage1,
1026 			    stage2);
1027 			if (ret != BE_SUCCESS)
1028 				goto done;
1029 		}
1030 	}
1031 
1032 	/*
1033 	 * Copy the grub capability file from the BE we're activating into
1034 	 * the root pool.
1035 	 */
1036 	(void) snprintf(cap_file, sizeof (cap_file), "%s%s", tmp_mntpt,
1037 	    BE_CAP_FILE);
1038 
1039 	if ((zhp = zfs_open(g_zfs, bt->obe_zpool, ZFS_TYPE_FILESYSTEM)) ==
1040 	    NULL) {
1041 		be_print_err(gettext("be_do_installgrub: zfs_open "
1042 		    "failed: %s\n"), libzfs_error_description(g_zfs));
1043 		zpool_close(zphp);
1044 		return (zfs_err_to_be_err(g_zfs));
1045 	}
1046 
1047 	/*
1048 	 * Check to see if the pool's dataset is mounted. If it isn't we'll
1049 	 * attempt to mount it.
1050 	 */
1051 	if ((ret = be_mount_pool(zhp, &ptmp_mntpnt,
1052 	    &orig_mntpnt, &pool_mounted)) != BE_SUCCESS) {
1053 		be_print_err(gettext("be_do_installgrub: pool dataset "
1054 		    "(%s) could not be mounted\n"), bt->obe_zpool);
1055 		ZFS_CLOSE(zhp);
1056 		zpool_close(zphp);
1057 		return (ret);
1058 	}
1059 
1060 	/*
1061 	 * Get the mountpoint for the root pool dataset.
1062 	 */
1063 	if (!zfs_is_mounted(zhp, &pool_mntpnt)) {
1064 		be_print_err(gettext("be_do_installgrub: pool "
1065 		    "dataset (%s) is not mounted. Can't check the grub "
1066 		    "version from the grub capability file.\n"), bt->obe_zpool);
1067 		ret = BE_ERR_NO_MENU;
1068 		goto done;
1069 	}
1070 
1071 	(void) snprintf(zpool_cap_file, sizeof (zpool_cap_file), "%s%s",
1072 	    pool_mntpnt, BE_CAP_FILE);
1073 
1074 	free(pool_mntpnt);
1075 	pool_mntpnt = NULL;
1076 
1077 	if ((cap_fp = fopen(cap_file, "r")) == NULL) {
1078 		err = errno;
1079 		be_print_err(gettext("be_do_installgrub: failed to open grub "
1080 		    "capability file\n"));
1081 		ret = errno_to_be_err(err);
1082 		goto done;
1083 	}
1084 	if ((zpool_cap_fp = fopen(zpool_cap_file, "w")) == NULL) {
1085 		err = errno;
1086 		be_print_err(gettext("be_do_installgrub: failed to open new "
1087 		    "grub capability file\n"));
1088 		ret = errno_to_be_err(err);
1089 		(void) fclose(cap_fp);
1090 		goto done;
1091 	}
1092 
1093 	while (fgets(line, BUFSIZ, cap_fp)) {
1094 		(void) fputs(line, zpool_cap_fp);
1095 	}
1096 
1097 	(void) fclose(zpool_cap_fp);
1098 	(void) fclose(cap_fp);
1099 
1100 done:
1101 	if (pool_mounted) {
1102 		int iret = 0;
1103 		iret = be_unmount_pool(zhp, ptmp_mntpnt, orig_mntpnt);
1104 		if (ret == BE_SUCCESS)
1105 			ret = iret;
1106 		free(orig_mntpnt);
1107 		free(ptmp_mntpnt);
1108 	}
1109 	ZFS_CLOSE(zhp);
1110 	if (be_mounted)
1111 		(void) _be_unmount(bt->obe_name, 0);
1112 	zpool_close(zphp);
1113 	free(tmp_mntpt);
1114 	return (ret);
1115 }
1116 
1117 /*
1118  * Function:	be_promote_zone_ds
1119  * Description:	This function finds the zones for the BE being activated
1120  *              and the active zonepath dataset for each zone. Then each
1121  *              active zonepath dataset is promoted.
1122  *
1123  * Parameters:
1124  *              be_name - the name of the global zone BE that we need to
1125  *                       find the zones for.
1126  *              be_root_ds - the root dataset for be_name.
1127  * Return:
1128  *		BE_SUCCESS - Success
1129  *		be_errno_t - Failure
1130  *
1131  * Scope:
1132  *		Private
1133  */
1134 static int
be_promote_zone_ds(char * be_name,char * be_root_ds)1135 be_promote_zone_ds(char *be_name, char *be_root_ds)
1136 {
1137 	char		*zone_ds = NULL;
1138 	char		*temp_mntpt = NULL;
1139 	char		origin[MAXPATHLEN];
1140 	char		zoneroot_ds[MAXPATHLEN];
1141 	zfs_handle_t	*zhp = NULL;
1142 	zfs_handle_t	*z_zhp = NULL;
1143 	zoneList_t	zone_list = NULL;
1144 	zoneBrandList_t *brands = NULL;
1145 	boolean_t	be_mounted = B_FALSE;
1146 	int		zone_index = 0;
1147 	int		err = BE_SUCCESS;
1148 
1149 	/*
1150 	 * Get the supported zone brands so we can pass that
1151 	 * to z_get_nonglobal_zone_list_by_brand. Currently
1152 	 * only the ipkg and labeled brand zones are supported
1153 	 *
1154 	 */
1155 	if ((brands = be_get_supported_brandlist()) == NULL) {
1156 		be_print_err(gettext("be_promote_zone_ds: no supported "
1157 		    "brands\n"));
1158 		return (BE_SUCCESS);
1159 	}
1160 
1161 	if ((zhp = zfs_open(g_zfs, be_root_ds,
1162 	    ZFS_TYPE_FILESYSTEM)) == NULL) {
1163 		be_print_err(gettext("be_promote_zone_ds: Failed to open "
1164 		    "dataset (%s): %s\n"), be_root_ds,
1165 		    libzfs_error_description(g_zfs));
1166 		err = zfs_err_to_be_err(g_zfs);
1167 		z_free_brand_list(brands);
1168 		return (err);
1169 	}
1170 
1171 	if (!zfs_is_mounted(zhp, &temp_mntpt)) {
1172 		if ((err = _be_mount(be_name, &temp_mntpt,
1173 		    BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) {
1174 			be_print_err(gettext("be_promote_zone_ds: failed to "
1175 			    "mount the BE for zones procesing.\n"));
1176 			ZFS_CLOSE(zhp);
1177 			z_free_brand_list(brands);
1178 			return (err);
1179 		}
1180 		be_mounted = B_TRUE;
1181 	}
1182 
1183 	/*
1184 	 * Set the zone root to the temp mount point for the BE we just mounted.
1185 	 */
1186 	z_set_zone_root(temp_mntpt);
1187 
1188 	/*
1189 	 * Get all the zones based on the brands we're looking for. If no zones
1190 	 * are found that we're interested in unmount the BE and move on.
1191 	 */
1192 	if ((zone_list = z_get_nonglobal_zone_list_by_brand(brands)) == NULL) {
1193 		if (be_mounted)
1194 			(void) _be_unmount(be_name, 0);
1195 		ZFS_CLOSE(zhp);
1196 		z_free_brand_list(brands);
1197 		free(temp_mntpt);
1198 		return (BE_SUCCESS);
1199 	}
1200 	for (zone_index = 0; z_zlist_get_zonename(zone_list, zone_index)
1201 	    != NULL; zone_index++) {
1202 		char *zone_path = NULL;
1203 
1204 		/* Skip zones that aren't at least installed */
1205 		if (z_zlist_get_current_state(zone_list, zone_index) <
1206 		    ZONE_STATE_INSTALLED)
1207 			continue;
1208 
1209 		if (((zone_path =
1210 		    z_zlist_get_zonepath(zone_list, zone_index)) == NULL) ||
1211 		    ((zone_ds = be_get_ds_from_dir(zone_path)) == NULL) ||
1212 		    !be_zone_supported(zone_ds))
1213 			continue;
1214 
1215 		if (be_find_active_zone_root(zhp, zone_ds,
1216 		    zoneroot_ds, sizeof (zoneroot_ds)) != 0) {
1217 			be_print_err(gettext("be_promote_zone_ds: "
1218 			    "Zone does not have an active root "
1219 			    "dataset, skipping this zone.\n"));
1220 			continue;
1221 		}
1222 
1223 		if ((z_zhp = zfs_open(g_zfs, zoneroot_ds,
1224 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
1225 			be_print_err(gettext("be_promote_zone_ds: "
1226 			    "Failed to open dataset "
1227 			    "(%s): %s\n"), zoneroot_ds,
1228 			    libzfs_error_description(g_zfs));
1229 			err = zfs_err_to_be_err(g_zfs);
1230 			goto done;
1231 		}
1232 
1233 		if (zfs_prop_get(z_zhp, ZFS_PROP_ORIGIN, origin,
1234 		    sizeof (origin), NULL, NULL, 0, B_FALSE) != 0) {
1235 			ZFS_CLOSE(z_zhp);
1236 			continue;
1237 		}
1238 
1239 		/*
1240 		 * We don't need to close the zfs handle at this
1241 		 * point because the callback funtion
1242 		 * be_promote_ds_callback() will close it for us.
1243 		 */
1244 		if (be_promote_ds_callback(z_zhp, NULL) != 0) {
1245 			be_print_err(gettext("be_promote_zone_ds: "
1246 			    "failed to activate the "
1247 			    "datasets for %s: %s\n"),
1248 			    zoneroot_ds,
1249 			    libzfs_error_description(g_zfs));
1250 			err = BE_ERR_PROMOTE;
1251 			goto done;
1252 		}
1253 	}
1254 done:
1255 	if (be_mounted)
1256 		(void) _be_unmount(be_name, 0);
1257 	ZFS_CLOSE(zhp);
1258 	free(temp_mntpt);
1259 	z_free_brand_list(brands);
1260 	z_free_zone_list(zone_list);
1261 	return (err);
1262 }
1263 
1264 /*
1265  * Function:	be_promote_ds_callback
1266  * Description:	This function is used to promote the datasets for the BE
1267  *		being activated as well as the datasets for the zones BE
1268  *		being activated.
1269  *
1270  * Parameters:
1271  *              zhp - the zfs handle for zone BE being activated.
1272  *		data - not used.
1273  * Return:
1274  *		0 - Success
1275  *		be_errno_t - Failure
1276  *
1277  * Scope:
1278  *		Private
1279  */
1280 static int
1281 /* LINTED */
be_promote_ds_callback(zfs_handle_t * zhp,void * data)1282 be_promote_ds_callback(zfs_handle_t *zhp, void *data)
1283 {
1284 	char	origin[MAXPATHLEN];
1285 	char	*sub_dataset = NULL;
1286 	int	ret = 0;
1287 
1288 	if (zhp != NULL) {
1289 		sub_dataset = strdup(zfs_get_name(zhp));
1290 		if (sub_dataset == NULL) {
1291 			ret = BE_ERR_NOMEM;
1292 			goto done;
1293 		}
1294 	} else {
1295 		be_print_err(gettext("be_promote_ds_callback: "
1296 		    "Invalid zfs handle passed into function\n"));
1297 		ret = BE_ERR_INVAL;
1298 		goto done;
1299 	}
1300 
1301 	/*
1302 	 * This loop makes sure that we promote the dataset to the
1303 	 * top of the tree so that it is no longer a decendent of any
1304 	 * dataset. The ZFS close and then open is used to make sure that
1305 	 * the promotion is updated before we move on.
1306 	 */
1307 	while (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin,
1308 	    sizeof (origin), NULL, NULL, 0, B_FALSE) == 0) {
1309 		if (zfs_promote(zhp) != 0) {
1310 			if (libzfs_errno(g_zfs) != EZFS_EXISTS) {
1311 				be_print_err(gettext("be_promote_ds_callback: "
1312 				    "promote of %s failed: %s\n"),
1313 				    zfs_get_name(zhp),
1314 				    libzfs_error_description(g_zfs));
1315 				ret = zfs_err_to_be_err(g_zfs);
1316 				goto done;
1317 			} else {
1318 				/*
1319 				 * If the call to zfs_promote returns the
1320 				 * error EZFS_EXISTS we've hit a snapshot name
1321 				 * collision. This means we're probably
1322 				 * attemping to promote a zone dataset above a
1323 				 * parent dataset that belongs to another zone
1324 				 * which this zone was cloned from.
1325 				 *
1326 				 * TODO: If this is a zone dataset at some
1327 				 * point we should skip this if the zone
1328 				 * paths for the dataset and the snapshot
1329 				 * don't match.
1330 				 */
1331 				be_print_err(gettext("be_promote_ds_callback: "
1332 				    "promote of %s failed due to snapshot "
1333 				    "name collision: %s\n"), zfs_get_name(zhp),
1334 				    libzfs_error_description(g_zfs));
1335 				ret = zfs_err_to_be_err(g_zfs);
1336 				goto done;
1337 			}
1338 		}
1339 		ZFS_CLOSE(zhp);
1340 		if ((zhp = zfs_open(g_zfs, sub_dataset,
1341 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
1342 			be_print_err(gettext("be_promote_ds_callback: "
1343 			    "Failed to open dataset (%s): %s\n"), sub_dataset,
1344 			    libzfs_error_description(g_zfs));
1345 			ret = zfs_err_to_be_err(g_zfs);
1346 			goto done;
1347 		}
1348 	}
1349 
1350 	/* Iterate down this dataset's children and promote them */
1351 	ret = zfs_iter_filesystems(zhp, be_promote_ds_callback, NULL);
1352 
1353 done:
1354 	free(sub_dataset);
1355 	ZFS_CLOSE(zhp);
1356 	return (ret);
1357 }
1358