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 } 4076