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