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