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) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2012 Milan Jurik. All rights reserved. 25 * Copyright (c) 2015 by Delphix. All rights reserved. 26 * Copyright 2016 Toomas Soome <tsoome@me.com> 27 * Copyright 2017 Nexenta Systems, Inc. 28 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 29 */ 30 31 /* 32 * bootadm(1M) is a new utility for managing bootability of 33 * Solaris *Newboot* environments. It has two primary tasks: 34 * - Allow end users to manage bootability of Newboot Solaris instances 35 * - Provide services to other subsystems in Solaris (primarily Install) 36 */ 37 38 /* Headers */ 39 #include <stdio.h> 40 #include <errno.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <unistd.h> 44 #include <sys/types.h> 45 #include <sys/stat.h> 46 #include <alloca.h> 47 #include <stdarg.h> 48 #include <limits.h> 49 #include <signal.h> 50 #include <sys/wait.h> 51 #include <sys/mnttab.h> 52 #include <sys/mntent.h> 53 #include <sys/statvfs.h> 54 #include <libnvpair.h> 55 #include <ftw.h> 56 #include <fcntl.h> 57 #include <strings.h> 58 #include <utime.h> 59 #include <sys/systeminfo.h> 60 #include <sys/dktp/fdisk.h> 61 #include <sys/param.h> 62 #include <dirent.h> 63 #include <ctype.h> 64 #include <libgen.h> 65 #include <sys/sysmacros.h> 66 #include <sys/elf.h> 67 #include <libscf.h> 68 #include <zlib.h> 69 #include <sys/lockfs.h> 70 #include <sys/filio.h> 71 #include <libbe.h> 72 #include <deflt.h> 73 #ifdef i386 74 #include <libfdisk.h> 75 #endif 76 77 #if !defined(_OBP) 78 #include <sys/ucode.h> 79 #endif 80 81 #include <pwd.h> 82 #include <grp.h> 83 #include <device_info.h> 84 #include <sys/vtoc.h> 85 #include <sys/efi_partition.h> 86 #include <regex.h> 87 #include <locale.h> 88 #include <sys/mkdev.h> 89 90 #include "bootadm.h" 91 92 #ifndef TEXT_DOMAIN 93 #define TEXT_DOMAIN "SUNW_OST_OSCMD" 94 #endif /* TEXT_DOMAIN */ 95 96 /* Type definitions */ 97 98 /* Primary subcmds */ 99 typedef enum { 100 BAM_MENU = 3, 101 BAM_ARCHIVE, 102 BAM_INSTALL 103 } subcmd_t; 104 105 #define LINE_INIT 0 /* lineNum initial value */ 106 #define ENTRY_INIT -1 /* entryNum initial value */ 107 #define ALL_ENTRIES -2 /* selects all boot entries */ 108 109 #define PARTNO_NOTFOUND -1 /* Solaris partition not found */ 110 #define PARTNO_EFI -2 /* EFI partition table found */ 111 112 #define GRUB_DIR "/boot/grub" 113 #define GRUB_STAGE2 GRUB_DIR "/stage2" 114 #define GRUB_MENU "/boot/grub/menu.lst" 115 #define MENU_TMP "/boot/grub/menu.lst.tmp" 116 #define GRUB_BACKUP_MENU "/etc/lu/GRUB_backup_menu" 117 #define RAMDISK_SPECIAL "/devices/ramdisk" 118 #define STUBBOOT "/stubboot" 119 #define MULTIBOOT "/platform/i86pc/multiboot" 120 #define GRUBSIGN_DIR "/boot/grub/bootsign" 121 #define GRUBSIGN_BACKUP "/etc/bootsign" 122 #define GRUBSIGN_UFS_PREFIX "rootfs" 123 #define GRUBSIGN_ZFS_PREFIX "pool_" 124 #define GRUBSIGN_LU_PREFIX "BE_" 125 #define UFS_SIGNATURE_LIST "/var/run/grub_ufs_signatures" 126 #define ZFS_LEGACY_MNTPT "/tmp/bootadm_mnt_zfs_legacy" 127 128 /* SMF */ 129 #define BOOT_ARCHIVE_FMRI "system/boot-archive:default" 130 #define SCF_PG_CONFIG "config" 131 #define SCF_PROPERTY_FORMAT "format" 132 133 /* BE defaults */ 134 #define BE_DEFAULTS "/etc/default/be" 135 #define BE_DFLT_BE_HAS_GRUB "BE_HAS_GRUB=" 136 137 #define BOOTADM_RDONLY_TEST "BOOTADM_RDONLY_TEST" 138 139 /* lock related */ 140 #define BAM_LOCK_FILE "/var/run/bootadm.lock" 141 #define LOCK_FILE_PERMS (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 142 143 #define CREATE_RAMDISK "boot/solaris/bin/create_ramdisk" 144 #define CREATE_DISKMAP "boot/solaris/bin/create_diskmap" 145 #define EXTRACT_BOOT_FILELIST "boot/solaris/bin/extract_boot_filelist" 146 #define GRUBDISK_MAP "/var/run/solaris_grubdisk.map" 147 148 #define GRUB_slice "/etc/lu/GRUB_slice" 149 #define GRUB_root "/etc/lu/GRUB_root" 150 #define GRUB_fdisk "/etc/lu/GRUB_fdisk" 151 #define GRUB_fdisk_target "/etc/lu/GRUB_fdisk_target" 152 #define FINDROOT_INSTALLGRUB "/etc/lu/installgrub.findroot" 153 #define LULIB "/usr/lib/lu/lulib" 154 #define LULIB_PROPAGATE_FILE "lulib_propagate_file" 155 #define CKSUM "/usr/bin/cksum" 156 #define LU_MENU_CKSUM "/etc/lu/menu.cksum" 157 #define BOOTADM "/sbin/bootadm" 158 159 #define INSTALLGRUB "/sbin/installgrub" 160 #define STAGE1 "/boot/grub/stage1" 161 #define STAGE2 "/boot/grub/stage2" 162 163 #define ETC_SYSTEM_DIR "etc/system.d" 164 #define SELF_ASSEMBLY "etc/system.d/.self-assembly" 165 166 /* 167 * Default file attributes 168 */ 169 #define DEFAULT_DEV_MODE 0644 /* default permissions */ 170 #define DEFAULT_DEV_UID 0 /* user root */ 171 #define DEFAULT_DEV_GID 3 /* group sys */ 172 173 /* 174 * Menu related 175 * menu_cmd_t and menu_cmds must be kept in sync 176 */ 177 char *menu_cmds[] = { 178 "default", /* DEFAULT_CMD */ 179 "timeout", /* TIMEOUT_CMD */ 180 "title", /* TITLE_CMD */ 181 "root", /* ROOT_CMD */ 182 "kernel", /* KERNEL_CMD */ 183 "kernel$", /* KERNEL_DOLLAR_CMD */ 184 "module", /* MODULE_CMD */ 185 "module$", /* MODULE_DOLLAR_CMD */ 186 " ", /* SEP_CMD */ 187 "#", /* COMMENT_CMD */ 188 "chainloader", /* CHAINLOADER_CMD */ 189 "args", /* ARGS_CMD */ 190 "findroot", /* FINDROOT_CMD */ 191 "bootfs", /* BOOTFS_CMD */ 192 NULL 193 }; 194 195 char *bam_formats[] = { 196 "hsfs", 197 "ufs", 198 "cpio", 199 "ufs-nocompress", 200 NULL 201 }; 202 #define BAM_FORMAT_UNSET -1 203 #define BAM_FORMAT_HSFS 0 204 short bam_format = BAM_FORMAT_UNSET; 205 206 #define OPT_ENTRY_NUM "entry" 207 208 /* 209 * exec_cmd related 210 */ 211 typedef struct { 212 line_t *head; 213 line_t *tail; 214 } filelist_t; 215 216 #define BOOT_FILE_LIST "boot/solaris/filelist.ramdisk" 217 #define ETC_FILE_LIST "etc/boot/solaris/filelist.ramdisk" 218 219 #define FILE_STAT "boot/solaris/filestat.ramdisk" 220 #define FILE_STAT_TMP "boot/solaris/filestat.ramdisk.tmp" 221 #define DIR_PERMS (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 222 #define FILE_STAT_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 223 224 #define FILE_STAT_TIMESTAMP "boot/solaris/timestamp.cache" 225 226 /* Globals */ 227 int bam_verbose; 228 int bam_force; 229 int bam_debug; 230 int bam_skip_lock; 231 static char *prog; 232 static subcmd_t bam_cmd; 233 char *bam_root; 234 int bam_rootlen; 235 static int bam_root_readonly; 236 int bam_alt_root; 237 static int bam_extend = 0; 238 static int bam_purge = 0; 239 static char *bam_subcmd; 240 static char *bam_opt; 241 static char **bam_argv; 242 static char *bam_pool; 243 static int bam_argc; 244 static int bam_check; 245 static int bam_saved_check; 246 static int bam_smf_check; 247 static int bam_lock_fd = -1; 248 static int bam_zfs; 249 static int bam_mbr; 250 char rootbuf[PATH_MAX] = "/"; 251 static char self_assembly[PATH_MAX]; 252 static int bam_update_all; 253 static int bam_alt_platform; 254 static char *bam_platform; 255 static char *bam_home_env = NULL; 256 257 /* function prototypes */ 258 static void parse_args_internal(int, char *[]); 259 static void parse_args(int, char *argv[]); 260 static error_t bam_menu(char *, char *, int, char *[]); 261 static error_t bam_install(char *, char *); 262 static error_t bam_archive(char *, char *); 263 264 static void bam_lock(void); 265 static void bam_unlock(void); 266 267 static int exec_cmd(char *, filelist_t *); 268 static error_t read_globals(menu_t *, char *, char *, int); 269 static int menu_on_bootdisk(char *os_root, char *menu_root); 270 static menu_t *menu_read(char *); 271 static error_t menu_write(char *, menu_t *); 272 static void linelist_free(line_t *); 273 static void menu_free(menu_t *); 274 static void filelist_free(filelist_t *); 275 static error_t list2file(char *, char *, char *, line_t *); 276 static error_t list_entry(menu_t *, char *, char *); 277 static error_t list_setting(menu_t *, char *, char *); 278 static error_t delete_all_entries(menu_t *, char *, char *); 279 static error_t update_entry(menu_t *mp, char *menu_root, char *opt); 280 static error_t update_temp(menu_t *mp, char *dummy, char *opt); 281 282 static error_t install_bootloader(void); 283 static error_t update_archive(char *, char *); 284 static error_t list_archive(char *, char *); 285 static error_t update_all(char *, char *); 286 static error_t read_list(char *, filelist_t *); 287 static error_t set_option(menu_t *, char *, char *); 288 static error_t set_kernel(menu_t *, menu_cmd_t, char *, char *, size_t); 289 static error_t get_kernel(menu_t *, menu_cmd_t, char *, size_t); 290 static error_t build_etc_system_dir(char *); 291 static char *expand_path(const char *); 292 293 static long s_strtol(char *); 294 static int s_fputs(char *, FILE *); 295 296 static int is_amd64(void); 297 static char *get_machine(void); 298 static void append_to_flist(filelist_t *, char *); 299 static int ufs_add_to_sign_list(char *sign); 300 static error_t synchronize_BE_menu(void); 301 302 #if !defined(_OBP) 303 static void ucode_install(); 304 #endif 305 306 /* Menu related sub commands */ 307 static subcmd_defn_t menu_subcmds[] = { 308 "set_option", OPT_ABSENT, set_option, 0, /* PUB */ 309 "list_entry", OPT_OPTIONAL, list_entry, 1, /* PUB */ 310 "delete_all_entries", OPT_ABSENT, delete_all_entries, 0, /* PVT */ 311 "update_entry", OPT_REQ, update_entry, 0, /* menu */ 312 "update_temp", OPT_OPTIONAL, update_temp, 0, /* reboot */ 313 "upgrade", OPT_ABSENT, upgrade_menu, 0, /* menu */ 314 "list_setting", OPT_OPTIONAL, list_setting, 1, /* menu */ 315 "disable_hypervisor", OPT_ABSENT, cvt_to_metal, 0, /* menu */ 316 "enable_hypervisor", OPT_ABSENT, cvt_to_hyper, 0, /* menu */ 317 NULL, 0, NULL, 0 /* must be last */ 318 }; 319 320 /* Archive related sub commands */ 321 static subcmd_defn_t arch_subcmds[] = { 322 "update", OPT_ABSENT, update_archive, 0, /* PUB */ 323 "update_all", OPT_ABSENT, update_all, 0, /* PVT */ 324 "list", OPT_OPTIONAL, list_archive, 1, /* PUB */ 325 NULL, 0, NULL, 0 /* must be last */ 326 }; 327 328 /* Install related sub commands */ 329 static subcmd_defn_t inst_subcmds[] = { 330 "install_bootloader", OPT_ABSENT, install_bootloader, 0, /* PUB */ 331 NULL, 0, NULL, 0 /* must be last */ 332 }; 333 334 #define build_path(buf, len, root, prefix, suffix) \ 335 snprintf((buf), (len), "%s%s%s%s%s", (root), (prefix), get_machine(), \ 336 is_flag_on(IS_SPARC_TARGET) ? "" : "/amd64", (suffix)) 337 338 /* 339 * Directory specific flags: 340 * NEED_UPDATE : the specified archive needs to be updated 341 * NO_EXTEND : don't extend the specified archive, but recreate it 342 */ 343 #define NEED_UPDATE 0x00000001 344 #define NO_EXTEND 0x00000002 345 346 #define set_dir_flag(f) (walk_arg.dirinfo.flags |= (f)) 347 #define unset_dir_flag(f) (walk_arg.dirinfo.flags &= ~(f)) 348 #define is_dir_flag_on(f) (walk_arg.dirinfo.flags & (f) ? 1 : 0) 349 350 #define get_cachedir() (walk_arg.dirinfo.cdir_path) 351 #define get_updatedir() (walk_arg.dirinfo.update_path) 352 #define get_count() (walk_arg.dirinfo.count) 353 #define has_cachedir() (walk_arg.dirinfo.has_dir) 354 #define set_dir_present() (walk_arg.dirinfo.has_dir = 1) 355 356 /* 357 * dirinfo_t (specific cache directory information): 358 * cdir_path: path to the archive cache directory 359 * update_path: path to the update directory (contains the files that will be 360 * used to extend the archive) 361 * has_dir: the specified cache directory is active 362 * count: the number of files to update 363 * flags: directory specific flags 364 */ 365 typedef struct _dirinfo { 366 char cdir_path[PATH_MAX]; 367 char update_path[PATH_MAX]; 368 int has_dir; 369 int count; 370 int flags; 371 } dirinfo_t; 372 373 /* 374 * Update flags: 375 * NEED_CACHE_DIR : cache directory is missing and needs to be created 376 * IS_SPARC_TARGET : the target mountpoint is a SPARC environment 377 * UPDATE_ERROR : an error occourred while traversing the list of files 378 * RDONLY_FSCHK : the target filesystem is read-only 379 * RAMDSK_FSCHK : the target filesystem is on a ramdisk 380 */ 381 #define NEED_CACHE_DIR 0x00000001 382 #define IS_SPARC_TARGET 0x00000002 383 #define UPDATE_ERROR 0x00000004 384 #define RDONLY_FSCHK 0x00000008 385 #define INVALIDATE_CACHE 0x00000010 386 387 #define is_flag_on(flag) (walk_arg.update_flags & flag ? 1 : 0) 388 #define set_flag(flag) (walk_arg.update_flags |= flag) 389 #define unset_flag(flag) (walk_arg.update_flags &= ~flag) 390 391 /* 392 * struct walk_arg : 393 * update_flags: flags related to the current updating process 394 * new_nvlp/old_nvlp: new and old list of archive-files / attributes pairs 395 * sparcfile: list of file paths for mkisofs -path-list (SPARC only) 396 */ 397 static struct { 398 int update_flags; 399 nvlist_t *new_nvlp; 400 nvlist_t *old_nvlp; 401 FILE *sparcfile; 402 dirinfo_t dirinfo; 403 } walk_arg; 404 405 struct safefile { 406 char *name; 407 struct safefile *next; 408 }; 409 410 static struct safefile *safefiles = NULL; 411 412 /* 413 * svc:/system/filesystem/usr:default service checks for this file and 414 * does a boot archive update and then reboot the system. 415 */ 416 #define NEED_UPDATE_FILE "/etc/svc/volatile/boot_archive_needs_update" 417 418 /* 419 * svc:/system/boot-archive-update:default checks for this file and 420 * updates the boot archive. 421 */ 422 #define NEED_UPDATE_SAFE_FILE "/etc/svc/volatile/boot_archive_safefile_update" 423 424 /* Thanks growisofs */ 425 #define CD_BLOCK ((off64_t)2048) 426 #define VOLDESC_OFF 16 427 #define DVD_BLOCK (32*1024) 428 #define MAX_IVDs 16 429 430 struct iso_pdesc { 431 unsigned char type [1]; 432 unsigned char id [5]; 433 unsigned char void1 [80-5-1]; 434 unsigned char volume_space_size [8]; 435 unsigned char void2 [2048-80-8]; 436 }; 437 438 /* 439 * COUNT_MAX: maximum number of changed files to justify a multisession update 440 * BA_SIZE_MAX: maximum size of the boot_archive to justify a multisession 441 * update 442 */ 443 #define COUNT_MAX 50 444 #define BA_SIZE_MAX (50 * 1024 * 1024) 445 446 #define bam_nowrite() (bam_check || bam_smf_check) 447 448 static int sync_menu = 1; /* whether we need to sync the BE menus */ 449 450 static void 451 usage(void) 452 { 453 (void) fprintf(stderr, "USAGE:\n"); 454 455 /* archive usage */ 456 (void) fprintf(stderr, 457 "\t%s update-archive [-vnf] [-R altroot [-p platform]] " 458 "[-F format]\n", prog); 459 (void) fprintf(stderr, 460 "\t%s list-archive [-R altroot [-p platform]]\n", prog); 461 #if defined(_OBP) 462 (void) fprintf(stderr, 463 "\t%s install-bootloader [-fv] [-R altroot] [-P pool]\n", prog); 464 #else 465 (void) fprintf(stderr, 466 "\t%s install-bootloader [-Mfv] [-R altroot] [-P pool]\n", prog); 467 #endif 468 #if !defined(_OBP) 469 /* x86 only */ 470 (void) fprintf(stderr, "\t%s set-menu [-R altroot] key=value\n", prog); 471 (void) fprintf(stderr, "\t%s list-menu [-R altroot]\n", prog); 472 #endif 473 } 474 475 /* 476 * Best effort attempt to restore the $HOME value. 477 */ 478 static void 479 restore_env() 480 { 481 char home_env[PATH_MAX]; 482 483 if (bam_home_env) { 484 (void) snprintf(home_env, sizeof (home_env), "HOME=%s", 485 bam_home_env); 486 (void) putenv(home_env); 487 } 488 } 489 490 491 #define SLEEP_TIME 5 492 #define MAX_TRIES 4 493 494 /* 495 * Sanitize the environment in which bootadm will execute its sub-processes 496 * (ex. mkisofs). This is done to prevent those processes from attempting 497 * to access files (ex. .mkisofsrc) or stat paths that might be on NFS 498 * or, potentially, insecure. 499 */ 500 static void 501 sanitize_env() 502 { 503 int stry = 0; 504 505 /* don't depend on caller umask */ 506 (void) umask(0022); 507 508 /* move away from a potential unsafe current working directory */ 509 while (chdir("/") == -1) { 510 if (errno != EINTR) { 511 bam_print("WARNING: unable to chdir to /"); 512 break; 513 } 514 } 515 516 bam_home_env = getenv("HOME"); 517 while (bam_home_env != NULL && putenv("HOME=/") == -1) { 518 if (errno == ENOMEM) { 519 /* retry no more than MAX_TRIES times */ 520 if (++stry > MAX_TRIES) { 521 bam_print("WARNING: unable to recover from " 522 "system memory pressure... aborting \n"); 523 bam_exit(EXIT_FAILURE); 524 } 525 /* memory is tight, try to sleep */ 526 bam_print("Attempting to recover from memory pressure: " 527 "sleeping for %d seconds\n", SLEEP_TIME * stry); 528 (void) sleep(SLEEP_TIME * stry); 529 } else { 530 bam_print("WARNING: unable to sanitize HOME\n"); 531 } 532 } 533 } 534 535 int 536 main(int argc, char *argv[]) 537 { 538 error_t ret = BAM_SUCCESS; 539 540 (void) setlocale(LC_ALL, ""); 541 (void) textdomain(TEXT_DOMAIN); 542 543 if ((prog = strrchr(argv[0], '/')) == NULL) { 544 prog = argv[0]; 545 } else { 546 prog++; 547 } 548 549 INJECT_ERROR1("ASSERT_ON", assert(0)) 550 551 sanitize_env(); 552 553 parse_args(argc, argv); 554 555 switch (bam_cmd) { 556 case BAM_MENU: 557 if (is_grub(bam_alt_root ? bam_root : "/")) { 558 ret = bam_menu(bam_subcmd, bam_opt, 559 bam_argc, bam_argv); 560 } else { 561 ret = bam_loader_menu(bam_subcmd, bam_opt, 562 bam_argc, bam_argv); 563 } 564 break; 565 case BAM_ARCHIVE: 566 ret = bam_archive(bam_subcmd, bam_opt); 567 break; 568 case BAM_INSTALL: 569 ret = bam_install(bam_subcmd, bam_opt); 570 break; 571 default: 572 usage(); 573 bam_exit(1); 574 } 575 576 if (ret != BAM_SUCCESS) 577 bam_exit((ret == BAM_NOCHANGE) ? 2 : 1); 578 579 bam_unlock(); 580 return (0); 581 } 582 583 /* 584 * Equivalence of public and internal commands: 585 * update-archive -- -a update 586 * list-archive -- -a list 587 * set-menu -- -m set_option 588 * list-menu -- -m list_entry 589 * update-menu -- -m update_entry 590 * install-bootloader -- -i install_bootloader 591 */ 592 static struct cmd_map { 593 char *bam_cmdname; 594 int bam_cmd; 595 char *bam_subcmd; 596 } cmd_map[] = { 597 { "update-archive", BAM_ARCHIVE, "update"}, 598 { "list-archive", BAM_ARCHIVE, "list"}, 599 { "set-menu", BAM_MENU, "set_option"}, 600 { "list-menu", BAM_MENU, "list_entry"}, 601 { "update-menu", BAM_MENU, "update_entry"}, 602 { "install-bootloader", BAM_INSTALL, "install_bootloader"}, 603 { NULL, 0, NULL} 604 }; 605 606 /* 607 * Commands syntax published in bootadm(1M) are parsed here 608 */ 609 static void 610 parse_args(int argc, char *argv[]) 611 { 612 struct cmd_map *cmp = cmd_map; 613 614 /* command conforming to the final spec */ 615 if (argc > 1 && argv[1][0] != '-') { 616 /* 617 * Map commands to internal table. 618 */ 619 while (cmp->bam_cmdname) { 620 if (strcmp(argv[1], cmp->bam_cmdname) == 0) { 621 bam_cmd = cmp->bam_cmd; 622 bam_subcmd = cmp->bam_subcmd; 623 break; 624 } 625 cmp++; 626 } 627 if (cmp->bam_cmdname == NULL) { 628 usage(); 629 bam_exit(1); 630 } 631 argc--; 632 argv++; 633 } 634 635 parse_args_internal(argc, argv); 636 } 637 638 /* 639 * A combination of public and private commands are parsed here. 640 * The internal syntax and the corresponding functionality are: 641 * -a update -- update-archive 642 * -a list -- list-archive 643 * -a update_all -- (reboot to sync all mnted OS archive) 644 * -i install_bootloader -- install-bootloader 645 * -m update_entry -- update-menu 646 * -m list_entry -- list-menu 647 * -m update_temp -- (reboot -- [boot-args]) 648 * -m delete_all_entries -- (called from install) 649 * -m enable_hypervisor [args] -- cvt_to_hyper 650 * -m disable_hypervisor -- cvt_to_metal 651 * -m list_setting [entry] [value] -- list_setting 652 * 653 * A set of private flags is there too: 654 * -Q -- purge the cache directories and rebuild them 655 * -e -- use the (faster) archive update approach (used by 656 * reboot) 657 * -L -- skip locking 658 */ 659 static void 660 parse_args_internal(int argc, char *argv[]) 661 { 662 int c, i, error; 663 extern char *optarg; 664 extern int optind, opterr; 665 #if defined(_OBP) 666 const char *optstring = "a:d:fF:i:m:no:veQCLR:p:P:XZ"; 667 #else 668 const char *optstring = "a:d:fF:i:m:no:veQCMLR:p:P:XZ"; 669 #endif 670 671 /* Suppress error message from getopt */ 672 opterr = 0; 673 674 error = 0; 675 while ((c = getopt(argc, argv, optstring)) != -1) { 676 switch (c) { 677 case 'a': 678 if (bam_cmd) { 679 error = 1; 680 bam_error( 681 _("multiple commands specified: -%c\n"), c); 682 } 683 bam_cmd = BAM_ARCHIVE; 684 bam_subcmd = optarg; 685 break; 686 case 'd': 687 if (bam_debug) { 688 error = 1; 689 bam_error( 690 _("duplicate options specified: -%c\n"), c); 691 } 692 bam_debug = s_strtol(optarg); 693 break; 694 case 'f': 695 bam_force = 1; 696 break; 697 case 'F': 698 if (bam_format != BAM_FORMAT_UNSET) { 699 error = 1; 700 bam_error( 701 _("multiple formats specified: -%c\n"), c); 702 } 703 for (i = 0; bam_formats[i] != NULL; i++) { 704 if (strcmp(bam_formats[i], optarg) == 0) { 705 bam_format = i; 706 break; 707 } 708 } 709 if (bam_format == BAM_FORMAT_UNSET) { 710 error = 1; 711 bam_error( 712 _("unknown format specified: -%c %s\n"), 713 c, optarg); 714 } 715 break; 716 case 'Q': 717 bam_purge = 1; 718 break; 719 case 'L': 720 bam_skip_lock = 1; 721 break; 722 case 'i': 723 if (bam_cmd) { 724 error = 1; 725 bam_error( 726 _("multiple commands specified: -%c\n"), c); 727 } 728 bam_cmd = BAM_INSTALL; 729 bam_subcmd = optarg; 730 break; 731 case 'm': 732 if (bam_cmd) { 733 error = 1; 734 bam_error( 735 _("multiple commands specified: -%c\n"), c); 736 } 737 bam_cmd = BAM_MENU; 738 bam_subcmd = optarg; 739 break; 740 #if !defined(_OBP) 741 case 'M': 742 bam_mbr = 1; 743 break; 744 #endif 745 case 'n': 746 bam_check = 1; 747 /* 748 * We save the original value of bam_check. The new 749 * approach in case of a read-only filesystem is to 750 * behave as a check, so we need a way to restore the 751 * original value after the evaluation of the read-only 752 * filesystem has been done. 753 * Even if we don't allow at the moment a check with 754 * update_all, this approach is more robust than 755 * simply resetting bam_check to zero. 756 */ 757 bam_saved_check = 1; 758 break; 759 case 'o': 760 if (bam_opt) { 761 error = 1; 762 bam_error( 763 _("duplicate options specified: -%c\n"), c); 764 } 765 bam_opt = optarg; 766 break; 767 case 'v': 768 bam_verbose = 1; 769 break; 770 case 'C': 771 bam_smf_check = 1; 772 break; 773 case 'P': 774 if (bam_pool != NULL) { 775 error = 1; 776 bam_error( 777 _("duplicate options specified: -%c\n"), c); 778 } 779 bam_pool = optarg; 780 break; 781 case 'R': 782 if (bam_root) { 783 error = 1; 784 bam_error( 785 _("duplicate options specified: -%c\n"), c); 786 break; 787 } else if (realpath(optarg, rootbuf) == NULL) { 788 error = 1; 789 bam_error(_("cannot resolve path %s: %s\n"), 790 optarg, strerror(errno)); 791 break; 792 } 793 bam_alt_root = 1; 794 bam_root = rootbuf; 795 bam_rootlen = strlen(rootbuf); 796 break; 797 case 'p': 798 bam_alt_platform = 1; 799 bam_platform = optarg; 800 if ((strcmp(bam_platform, "i86pc") != 0) && 801 (strcmp(bam_platform, "sun4u") != 0) && 802 (strcmp(bam_platform, "sun4v") != 0)) { 803 error = 1; 804 bam_error(_("invalid platform %s - must be " 805 "one of sun4u, sun4v or i86pc\n"), 806 bam_platform); 807 } 808 break; 809 case 'X': 810 bam_is_hv = BAM_HV_PRESENT; 811 break; 812 case 'Z': 813 bam_zfs = 1; 814 break; 815 case 'e': 816 bam_extend = 1; 817 break; 818 case '?': 819 error = 1; 820 bam_error(_("invalid option or missing option " 821 "argument: -%c\n"), optopt); 822 break; 823 default : 824 error = 1; 825 bam_error(_("invalid option or missing option " 826 "argument: -%c\n"), c); 827 break; 828 } 829 } 830 831 /* 832 * An alternate platform requires an alternate root 833 */ 834 if (bam_alt_platform && bam_alt_root == 0) { 835 usage(); 836 bam_exit(0); 837 } 838 839 /* 840 * A command option must be specfied 841 */ 842 if (!bam_cmd) { 843 if (bam_opt && strcmp(bam_opt, "all") == 0) { 844 usage(); 845 bam_exit(0); 846 } 847 bam_error(_("a command option must be specified\n")); 848 error = 1; 849 } 850 851 if (error) { 852 usage(); 853 bam_exit(1); 854 } 855 856 if (optind > argc) { 857 bam_error(_("Internal error: %s\n"), "parse_args"); 858 bam_exit(1); 859 } else if (optind < argc) { 860 bam_argv = &argv[optind]; 861 bam_argc = argc - optind; 862 } 863 864 /* 865 * mbr and pool are options for install_bootloader 866 */ 867 if (bam_cmd != BAM_INSTALL && (bam_mbr || bam_pool != NULL)) { 868 usage(); 869 bam_exit(0); 870 } 871 872 /* 873 * -n implies verbose mode 874 */ 875 if (bam_check) 876 bam_verbose = 1; 877 } 878 879 error_t 880 check_subcmd_and_options( 881 char *subcmd, 882 char *opt, 883 subcmd_defn_t *table, 884 error_t (**fp)()) 885 { 886 int i; 887 888 if (subcmd == NULL) { 889 bam_error(_("this command requires a sub-command\n")); 890 return (BAM_ERROR); 891 } 892 893 if (strcmp(subcmd, "set_option") == 0) { 894 if (bam_argc == 0 || bam_argv == NULL || bam_argv[0] == NULL) { 895 bam_error(_("missing argument for sub-command\n")); 896 usage(); 897 return (BAM_ERROR); 898 } else if (bam_argc > 1 || bam_argv[1] != NULL) { 899 bam_error(_("invalid trailing arguments\n")); 900 usage(); 901 return (BAM_ERROR); 902 } 903 } else if (strcmp(subcmd, "update_all") == 0) { 904 /* 905 * The only option we accept for the "update_all" 906 * subcmd is "fastboot". 907 */ 908 if (bam_argc > 1 || (bam_argc == 1 && 909 strcmp(bam_argv[0], "fastboot") != 0)) { 910 bam_error(_("invalid trailing arguments\n")); 911 usage(); 912 return (BAM_ERROR); 913 } 914 if (bam_argc == 1) 915 sync_menu = 0; 916 } else if (((strcmp(subcmd, "enable_hypervisor") != 0) && 917 (strcmp(subcmd, "list_setting") != 0)) && (bam_argc || bam_argv)) { 918 /* 919 * Of the remaining subcommands, only "enable_hypervisor" and 920 * "list_setting" take trailing arguments. 921 */ 922 bam_error(_("invalid trailing arguments\n")); 923 usage(); 924 return (BAM_ERROR); 925 } 926 927 if (bam_root == NULL) { 928 bam_root = rootbuf; 929 bam_rootlen = 1; 930 } 931 932 /* verify that subcmd is valid */ 933 for (i = 0; table[i].subcmd != NULL; i++) { 934 if (strcmp(table[i].subcmd, subcmd) == 0) 935 break; 936 } 937 938 if (table[i].subcmd == NULL) { 939 bam_error(_("invalid sub-command specified: %s\n"), subcmd); 940 return (BAM_ERROR); 941 } 942 943 if (table[i].unpriv == 0 && geteuid() != 0) { 944 bam_error(_("you must be root to run this command\n")); 945 return (BAM_ERROR); 946 } 947 948 /* 949 * Currently only privileged commands need a lock 950 */ 951 if (table[i].unpriv == 0) 952 bam_lock(); 953 954 /* subcmd verifies that opt is appropriate */ 955 if (table[i].option != OPT_OPTIONAL) { 956 if ((table[i].option == OPT_REQ) ^ (opt != NULL)) { 957 if (opt) 958 bam_error(_("this sub-command (%s) does not " 959 "take options\n"), subcmd); 960 else 961 bam_error(_("an option is required for this " 962 "sub-command: %s\n"), subcmd); 963 return (BAM_ERROR); 964 } 965 } 966 967 *fp = table[i].handler; 968 969 return (BAM_SUCCESS); 970 } 971 972 /* 973 * NOTE: A single "/" is also considered a trailing slash and will 974 * be deleted. 975 */ 976 void 977 elide_trailing_slash(const char *src, char *dst, size_t dstsize) 978 { 979 size_t dstlen; 980 981 assert(src); 982 assert(dst); 983 984 (void) strlcpy(dst, src, dstsize); 985 986 dstlen = strlen(dst); 987 if (dst[dstlen - 1] == '/') { 988 dst[dstlen - 1] = '\0'; 989 } 990 } 991 992 static int 993 is_safe_exec(char *path) 994 { 995 struct stat sb; 996 997 if (lstat(path, &sb) != 0) { 998 bam_error(_("stat of file failed: %s: %s\n"), path, 999 strerror(errno)); 1000 return (BAM_ERROR); 1001 } 1002 1003 if (!S_ISREG(sb.st_mode)) { 1004 bam_error(_("%s is not a regular file, skipping\n"), path); 1005 return (BAM_ERROR); 1006 } 1007 1008 if (sb.st_uid != getuid()) { 1009 bam_error(_("%s is not owned by %d, skipping\n"), 1010 path, getuid()); 1011 return (BAM_ERROR); 1012 } 1013 1014 if (sb.st_mode & S_IWOTH || sb.st_mode & S_IWGRP) { 1015 bam_error(_("%s is others or group writable, skipping\n"), 1016 path); 1017 return (BAM_ERROR); 1018 } 1019 1020 return (BAM_SUCCESS); 1021 } 1022 1023 static error_t 1024 list_setting(menu_t *mp, char *which, char *setting) 1025 { 1026 line_t *lp; 1027 entry_t *ent; 1028 1029 char *p = which; 1030 int entry; 1031 1032 int found; 1033 1034 assert(which); 1035 assert(setting); 1036 1037 if (*which != '\0') { 1038 /* 1039 * If "which" is not a number, assume it's a setting we want 1040 * to look for and so set up the routine to look for "which" 1041 * in the default entry. 1042 */ 1043 while (*p != '\0') 1044 if (!(isdigit((int)*p++))) { 1045 setting = which; 1046 which = mp->curdefault->arg; 1047 break; 1048 } 1049 } else { 1050 which = mp->curdefault->arg; 1051 } 1052 1053 entry = atoi(which); 1054 1055 for (ent = mp->entries; ((ent != NULL) && (ent->entryNum != entry)); 1056 ent = ent->next) 1057 ; 1058 1059 if (!ent) { 1060 bam_error(_("no matching entry found\n")); 1061 return (BAM_ERROR); 1062 } 1063 1064 found = (*setting == '\0'); 1065 1066 for (lp = ent->start; lp != NULL; lp = lp->next) { 1067 if ((*setting == '\0') && (lp->flags != BAM_COMMENT)) 1068 bam_print("%s\n", lp->line); 1069 else if (lp->cmd != NULL && strcmp(setting, lp->cmd) == 0) { 1070 bam_print("%s\n", lp->arg); 1071 found = 1; 1072 } 1073 1074 if (lp == ent->end) 1075 break; 1076 } 1077 1078 if (!found) { 1079 bam_error(_("no matching entry found\n")); 1080 return (BAM_ERROR); 1081 } 1082 1083 return (BAM_SUCCESS); 1084 } 1085 1086 static error_t 1087 install_bootloader(void) 1088 { 1089 nvlist_t *nvl; 1090 uint16_t flags = 0; 1091 int found = 0; 1092 struct extmnttab mnt; 1093 struct stat statbuf = {0}; 1094 be_node_list_t *be_nodes, *node; 1095 FILE *fp; 1096 char *root_ds = NULL; 1097 int ret = BAM_ERROR; 1098 1099 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { 1100 bam_error(_("out of memory\n")); 1101 return (ret); 1102 } 1103 1104 /* 1105 * if bam_alt_root is set, the stage files are used from alt root. 1106 * if pool is set, the target devices are pool devices, stage files 1107 * are read from pool bootfs unless alt root is set. 1108 * 1109 * use arguments as targets, stage files are from alt or current root 1110 * if no arguments and no pool, install on current boot pool. 1111 */ 1112 1113 if (bam_alt_root) { 1114 if (stat(bam_root, &statbuf) != 0) { 1115 bam_error(_("stat of file failed: %s: %s\n"), bam_root, 1116 strerror(errno)); 1117 goto done; 1118 } 1119 if ((fp = fopen(MNTTAB, "r")) == NULL) { 1120 bam_error(_("failed to open file: %s: %s\n"), 1121 MNTTAB, strerror(errno)); 1122 goto done; 1123 } 1124 resetmnttab(fp); 1125 while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 1126 if (mnt.mnt_major == major(statbuf.st_dev) && 1127 mnt.mnt_minor == minor(statbuf.st_dev)) { 1128 found = 1; 1129 root_ds = strdup(mnt.mnt_special); 1130 break; 1131 } 1132 } 1133 (void) fclose(fp); 1134 1135 if (found == 0) { 1136 bam_error(_("alternate root %s not in mnttab\n"), 1137 bam_root); 1138 goto done; 1139 } 1140 if (root_ds == NULL) { 1141 bam_error(_("out of memory\n")); 1142 goto done; 1143 } 1144 1145 if (be_list(NULL, &be_nodes, BE_LIST_DEFAULT) != BE_SUCCESS) { 1146 bam_error(_("No BE's found\n")); 1147 goto done; 1148 } 1149 for (node = be_nodes; node != NULL; node = node->be_next_node) 1150 if (strcmp(root_ds, node->be_root_ds) == 0) 1151 break; 1152 1153 if (node == NULL) 1154 bam_error(_("BE (%s) does not exist\n"), root_ds); 1155 1156 free(root_ds); 1157 root_ds = NULL; 1158 if (node == NULL) { 1159 be_free_list(be_nodes); 1160 goto done; 1161 } 1162 ret = nvlist_add_string(nvl, BE_ATTR_ORIG_BE_NAME, 1163 node->be_node_name); 1164 ret |= nvlist_add_string(nvl, BE_ATTR_ORIG_BE_ROOT, 1165 node->be_root_ds); 1166 be_free_list(be_nodes); 1167 if (ret != 0) { 1168 ret = BAM_ERROR; 1169 goto done; 1170 } 1171 } 1172 1173 if (bam_force) 1174 flags |= BE_INSTALLBOOT_FLAG_FORCE; 1175 if (bam_mbr) 1176 flags |= BE_INSTALLBOOT_FLAG_MBR; 1177 if (bam_verbose) 1178 flags |= BE_INSTALLBOOT_FLAG_VERBOSE; 1179 1180 if (nvlist_add_uint16(nvl, BE_ATTR_INSTALL_FLAGS, flags) != 0) { 1181 bam_error(_("out of memory\n")); 1182 ret = BAM_ERROR; 1183 goto done; 1184 } 1185 1186 /* 1187 * if altroot was set, we got be name and be root, only need 1188 * to set pool name as target. 1189 * if no altroot, need to find be name and root from pool. 1190 */ 1191 if (bam_pool != NULL) { 1192 ret = nvlist_add_string(nvl, BE_ATTR_ORIG_BE_POOL, bam_pool); 1193 if (ret != 0) { 1194 ret = BAM_ERROR; 1195 goto done; 1196 } 1197 if (found) { 1198 ret = be_installboot(nvl); 1199 if (ret != 0) 1200 ret = BAM_ERROR; 1201 goto done; 1202 } 1203 } 1204 1205 if (be_list(NULL, &be_nodes, BE_LIST_DEFAULT) != BE_SUCCESS) { 1206 bam_error(_("No BE's found\n")); 1207 ret = BAM_ERROR; 1208 goto done; 1209 } 1210 1211 if (bam_pool != NULL) { 1212 /* 1213 * find active be_node in bam_pool 1214 */ 1215 for (node = be_nodes; node != NULL; node = node->be_next_node) { 1216 if (strcmp(bam_pool, node->be_rpool) != 0) 1217 continue; 1218 if (node->be_active_on_boot) 1219 break; 1220 } 1221 if (node == NULL) { 1222 bam_error(_("No active BE in %s\n"), bam_pool); 1223 be_free_list(be_nodes); 1224 ret = BAM_ERROR; 1225 goto done; 1226 } 1227 ret = nvlist_add_string(nvl, BE_ATTR_ORIG_BE_NAME, 1228 node->be_node_name); 1229 ret |= nvlist_add_string(nvl, BE_ATTR_ORIG_BE_ROOT, 1230 node->be_root_ds); 1231 be_free_list(be_nodes); 1232 if (ret != 0) { 1233 ret = BAM_ERROR; 1234 goto done; 1235 } 1236 ret = be_installboot(nvl); 1237 if (ret != 0) 1238 ret = BAM_ERROR; 1239 goto done; 1240 } 1241 1242 /* 1243 * get dataset for "/" and fill up the args. 1244 */ 1245 if ((fp = fopen(MNTTAB, "r")) == NULL) { 1246 bam_error(_("failed to open file: %s: %s\n"), 1247 MNTTAB, strerror(errno)); 1248 ret = BAM_ERROR; 1249 be_free_list(be_nodes); 1250 goto done; 1251 } 1252 resetmnttab(fp); 1253 found = 0; 1254 while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 1255 if (strcmp(mnt.mnt_mountp, "/") == 0) { 1256 found = 1; 1257 root_ds = strdup(mnt.mnt_special); 1258 break; 1259 } 1260 } 1261 (void) fclose(fp); 1262 1263 if (found == 0) { 1264 bam_error(_("alternate root %s not in mnttab\n"), "/"); 1265 ret = BAM_ERROR; 1266 be_free_list(be_nodes); 1267 goto done; 1268 } 1269 if (root_ds == NULL) { 1270 bam_error(_("out of memory\n")); 1271 ret = BAM_ERROR; 1272 be_free_list(be_nodes); 1273 goto done; 1274 } 1275 1276 for (node = be_nodes; node != NULL; node = node->be_next_node) { 1277 if (strcmp(root_ds, node->be_root_ds) == 0) 1278 break; 1279 } 1280 1281 if (node == NULL) { 1282 bam_error(_("No such BE: %s\n"), root_ds); 1283 free(root_ds); 1284 be_free_list(be_nodes); 1285 ret = BAM_ERROR; 1286 goto done; 1287 } 1288 free(root_ds); 1289 1290 ret = nvlist_add_string(nvl, BE_ATTR_ORIG_BE_NAME, node->be_node_name); 1291 ret |= nvlist_add_string(nvl, BE_ATTR_ORIG_BE_ROOT, node->be_root_ds); 1292 ret |= nvlist_add_string(nvl, BE_ATTR_ORIG_BE_POOL, node->be_rpool); 1293 be_free_list(be_nodes); 1294 1295 if (ret != 0) 1296 ret = BAM_ERROR; 1297 else 1298 ret = be_installboot(nvl) ? BAM_ERROR : 0; 1299 done: 1300 nvlist_free(nvl); 1301 1302 return (ret); 1303 } 1304 1305 static error_t 1306 bam_install(char *subcmd, char *opt) 1307 { 1308 error_t (*f)(void); 1309 1310 /* 1311 * Check arguments 1312 */ 1313 if (check_subcmd_and_options(subcmd, opt, inst_subcmds, &f) == 1314 BAM_ERROR) 1315 return (BAM_ERROR); 1316 1317 return (f()); 1318 } 1319 1320 static error_t 1321 bam_menu(char *subcmd, char *opt, int largc, char *largv[]) 1322 { 1323 error_t ret; 1324 char menu_path[PATH_MAX]; 1325 char clean_menu_root[PATH_MAX]; 1326 char path[PATH_MAX]; 1327 menu_t *menu; 1328 char menu_root[PATH_MAX]; 1329 struct stat sb; 1330 error_t (*f)(menu_t *mp, char *menu_path, char *opt); 1331 char *special = NULL; 1332 char *pool = NULL; 1333 zfs_mnted_t zmnted; 1334 char *zmntpt = NULL; 1335 char *osdev; 1336 char *osroot; 1337 const char *fcn = "bam_menu()"; 1338 1339 /* 1340 * Menu sub-command only applies to GRUB (i.e. x86) 1341 */ 1342 if (!is_grub(bam_alt_root ? bam_root : "/")) { 1343 bam_error(_("not a GRUB 0.97 based Illumos instance. " 1344 "Operation not supported\n")); 1345 return (BAM_ERROR); 1346 } 1347 1348 /* 1349 * Check arguments 1350 */ 1351 ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f); 1352 if (ret == BAM_ERROR) { 1353 return (BAM_ERROR); 1354 } 1355 1356 assert(bam_root); 1357 1358 (void) strlcpy(menu_root, bam_root, sizeof (menu_root)); 1359 osdev = osroot = NULL; 1360 1361 if (strcmp(subcmd, "update_entry") == 0) { 1362 assert(opt); 1363 1364 osdev = strtok(opt, ","); 1365 assert(osdev); 1366 osroot = strtok(NULL, ","); 1367 if (osroot) { 1368 /* fixup bam_root so that it points at osroot */ 1369 if (realpath(osroot, rootbuf) == NULL) { 1370 bam_error(_("cannot resolve path %s: %s\n"), 1371 osroot, strerror(errno)); 1372 return (BAM_ERROR); 1373 } 1374 bam_alt_root = 1; 1375 bam_root = rootbuf; 1376 bam_rootlen = strlen(rootbuf); 1377 } 1378 } 1379 1380 /* 1381 * We support menu on PCFS (under certain conditions), but 1382 * not the OS root 1383 */ 1384 if (is_pcfs(bam_root)) { 1385 bam_error(_("root <%s> on PCFS is not supported\n"), bam_root); 1386 return (BAM_ERROR); 1387 } 1388 1389 if (stat(menu_root, &sb) == -1) { 1390 bam_error(_("cannot find GRUB menu\n")); 1391 return (BAM_ERROR); 1392 } 1393 1394 BAM_DPRINTF(("%s: menu root is %s\n", fcn, menu_root)); 1395 1396 /* 1397 * We no longer use the GRUB slice file. If it exists, then 1398 * the user is doing something that is unsupported (such as 1399 * standard upgrading an old Live Upgrade BE). If that 1400 * happens, mimic existing behavior i.e. pretend that it is 1401 * not a BE. Emit a warning though. 1402 */ 1403 if (bam_alt_root) { 1404 (void) snprintf(path, sizeof (path), "%s%s", bam_root, 1405 GRUB_slice); 1406 } else { 1407 (void) snprintf(path, sizeof (path), "%s", GRUB_slice); 1408 } 1409 1410 if (bam_verbose && stat(path, &sb) == 0) 1411 bam_error(_("unsupported GRUB slice file (%s) exists - " 1412 "ignoring.\n"), path); 1413 1414 if (is_zfs(menu_root)) { 1415 assert(strcmp(menu_root, bam_root) == 0); 1416 special = get_special(menu_root); 1417 INJECT_ERROR1("Z_MENU_GET_SPECIAL", special = NULL); 1418 if (special == NULL) { 1419 bam_error(_("cant find special file for " 1420 "mount-point %s\n"), menu_root); 1421 return (BAM_ERROR); 1422 } 1423 pool = strtok(special, "/"); 1424 INJECT_ERROR1("Z_MENU_GET_POOL", pool = NULL); 1425 if (pool == NULL) { 1426 free(special); 1427 bam_error(_("cant find pool for mount-point %s\n"), 1428 menu_root); 1429 return (BAM_ERROR); 1430 } 1431 BAM_DPRINTF(("%s: derived pool=%s from special\n", fcn, pool)); 1432 1433 zmntpt = mount_top_dataset(pool, &zmnted); 1434 INJECT_ERROR1("Z_MENU_MOUNT_TOP_DATASET", zmntpt = NULL); 1435 if (zmntpt == NULL) { 1436 bam_error(_("cannot mount pool dataset for pool: %s\n"), 1437 pool); 1438 free(special); 1439 return (BAM_ERROR); 1440 } 1441 BAM_DPRINTF(("%s: top dataset mountpoint=%s\n", fcn, zmntpt)); 1442 1443 (void) strlcpy(menu_root, zmntpt, sizeof (menu_root)); 1444 BAM_DPRINTF(("%s: zfs menu_root=%s\n", fcn, menu_root)); 1445 } 1446 1447 elide_trailing_slash(menu_root, clean_menu_root, 1448 sizeof (clean_menu_root)); 1449 1450 BAM_DPRINTF(("%s: cleaned menu root is <%s>\n", fcn, clean_menu_root)); 1451 1452 (void) strlcpy(menu_path, clean_menu_root, sizeof (menu_path)); 1453 (void) strlcat(menu_path, GRUB_MENU, sizeof (menu_path)); 1454 1455 BAM_DPRINTF(("%s: menu path is: %s\n", fcn, menu_path)); 1456 1457 /* 1458 * If listing the menu, display the menu location 1459 */ 1460 if (strcmp(subcmd, "list_entry") == 0) 1461 bam_print(_("the location for the active GRUB menu is: %s\n"), 1462 menu_path); 1463 1464 if ((menu = menu_read(menu_path)) == NULL) { 1465 bam_error(_("cannot find GRUB menu file: %s\n"), menu_path); 1466 free(special); 1467 1468 return (BAM_ERROR); 1469 } 1470 1471 /* 1472 * We already checked the following case in 1473 * check_subcmd_and_suboptions() above. Complete the 1474 * final step now. 1475 */ 1476 if (strcmp(subcmd, "set_option") == 0) { 1477 assert(largc == 1 && largv[0] && largv[1] == NULL); 1478 opt = largv[0]; 1479 } else if ((strcmp(subcmd, "enable_hypervisor") != 0) && 1480 (strcmp(subcmd, "list_setting") != 0)) { 1481 assert(largc == 0 && largv == NULL); 1482 } 1483 1484 ret = get_boot_cap(bam_root); 1485 if (ret != BAM_SUCCESS) { 1486 BAM_DPRINTF(("%s: Failed to get boot capability\n", fcn)); 1487 goto out; 1488 } 1489 1490 /* 1491 * Once the sub-cmd handler has run 1492 * only the line field is guaranteed to have valid values 1493 */ 1494 if (strcmp(subcmd, "update_entry") == 0) { 1495 ret = f(menu, menu_root, osdev); 1496 } else if (strcmp(subcmd, "upgrade") == 0) { 1497 ret = f(menu, bam_root, menu_root); 1498 } else if (strcmp(subcmd, "list_entry") == 0) { 1499 ret = f(menu, menu_path, opt); 1500 } else if (strcmp(subcmd, "list_setting") == 0) { 1501 ret = f(menu, ((largc > 0) ? largv[0] : ""), 1502 ((largc > 1) ? largv[1] : "")); 1503 } else if (strcmp(subcmd, "disable_hypervisor") == 0) { 1504 if (is_sparc()) { 1505 bam_error(_("%s operation unsupported on SPARC " 1506 "machines\n"), subcmd); 1507 ret = BAM_ERROR; 1508 } else { 1509 ret = f(menu, bam_root, NULL); 1510 } 1511 } else if (strcmp(subcmd, "enable_hypervisor") == 0) { 1512 if (is_sparc()) { 1513 bam_error(_("%s operation unsupported on SPARC " 1514 "machines\n"), subcmd); 1515 ret = BAM_ERROR; 1516 } else { 1517 char *extra_args = NULL; 1518 1519 /* 1520 * Compress all arguments passed in the largv[] array 1521 * into one string that can then be appended to the 1522 * end of the kernel$ string the routine to enable the 1523 * hypervisor will build. 1524 * 1525 * This allows the caller to supply arbitrary unparsed 1526 * arguments, such as dom0 memory settings or APIC 1527 * options. 1528 * 1529 * This concatenation will be done without ANY syntax 1530 * checking whatsoever, so it's the responsibility of 1531 * the caller to make sure the arguments are valid and 1532 * do not duplicate arguments the conversion routines 1533 * may create. 1534 */ 1535 if (largc > 0) { 1536 int extra_len, i; 1537 1538 for (extra_len = 0, i = 0; i < largc; i++) 1539 extra_len += strlen(largv[i]); 1540 1541 /* 1542 * Allocate space for argument strings, 1543 * intervening spaces and terminating NULL. 1544 */ 1545 extra_args = alloca(extra_len + largc); 1546 1547 (void) strcpy(extra_args, largv[0]); 1548 1549 for (i = 1; i < largc; i++) { 1550 (void) strcat(extra_args, " "); 1551 (void) strcat(extra_args, largv[i]); 1552 } 1553 } 1554 1555 ret = f(menu, bam_root, extra_args); 1556 } 1557 } else 1558 ret = f(menu, NULL, opt); 1559 1560 if (ret == BAM_WRITE) { 1561 BAM_DPRINTF(("%s: writing menu to clean-menu-root: <%s>\n", 1562 fcn, clean_menu_root)); 1563 ret = menu_write(clean_menu_root, menu); 1564 } 1565 1566 out: 1567 INJECT_ERROR1("POOL_SET", pool = "/pooldata"); 1568 assert((is_zfs(menu_root)) ^ (pool == NULL)); 1569 if (pool) { 1570 (void) umount_top_dataset(pool, zmnted, zmntpt); 1571 free(special); 1572 } 1573 menu_free(menu); 1574 return (ret); 1575 } 1576 1577 1578 static error_t 1579 bam_archive( 1580 char *subcmd, 1581 char *opt) 1582 { 1583 error_t ret; 1584 error_t (*f)(char *root, char *opt); 1585 const char *fcn = "bam_archive()"; 1586 1587 /* 1588 * Add trailing / for archive subcommands 1589 */ 1590 if (rootbuf[strlen(rootbuf) - 1] != '/') 1591 (void) strcat(rootbuf, "/"); 1592 bam_rootlen = strlen(rootbuf); 1593 1594 /* 1595 * Check arguments 1596 */ 1597 ret = check_subcmd_and_options(subcmd, opt, arch_subcmds, &f); 1598 if (ret != BAM_SUCCESS) { 1599 return (BAM_ERROR); 1600 } 1601 1602 ret = get_boot_cap(rootbuf); 1603 if (ret != BAM_SUCCESS) { 1604 BAM_DPRINTF(("%s: Failed to get boot capability\n", fcn)); 1605 return (ret); 1606 } 1607 1608 /* 1609 * Check archive not supported with update_all 1610 * since it is awkward to display out-of-sync 1611 * information for each BE. 1612 */ 1613 if (bam_check && strcmp(subcmd, "update_all") == 0) { 1614 bam_error(_("the check option is not supported with " 1615 "subcmd: %s\n"), subcmd); 1616 return (BAM_ERROR); 1617 } 1618 1619 if (strcmp(subcmd, "update_all") == 0) 1620 bam_update_all = 1; 1621 1622 #if !defined(_OBP) 1623 ucode_install(bam_root); 1624 #endif 1625 1626 ret = f(bam_root, opt); 1627 1628 bam_update_all = 0; 1629 1630 return (ret); 1631 } 1632 1633 /*PRINTFLIKE1*/ 1634 void 1635 bam_error(char *format, ...) 1636 { 1637 va_list ap; 1638 1639 va_start(ap, format); 1640 (void) fprintf(stderr, "%s: ", prog); 1641 (void) vfprintf(stderr, format, ap); 1642 va_end(ap); 1643 } 1644 1645 /*PRINTFLIKE1*/ 1646 void 1647 bam_derror(char *format, ...) 1648 { 1649 va_list ap; 1650 1651 assert(bam_debug); 1652 1653 va_start(ap, format); 1654 (void) fprintf(stderr, "DEBUG: "); 1655 (void) vfprintf(stderr, format, ap); 1656 va_end(ap); 1657 } 1658 1659 /*PRINTFLIKE1*/ 1660 void 1661 bam_print(char *format, ...) 1662 { 1663 va_list ap; 1664 1665 va_start(ap, format); 1666 (void) vfprintf(stdout, format, ap); 1667 va_end(ap); 1668 } 1669 1670 /*PRINTFLIKE1*/ 1671 void 1672 bam_print_stderr(char *format, ...) 1673 { 1674 va_list ap; 1675 1676 va_start(ap, format); 1677 (void) vfprintf(stderr, format, ap); 1678 va_end(ap); 1679 } 1680 1681 void 1682 bam_exit(int excode) 1683 { 1684 restore_env(); 1685 bam_unlock(); 1686 exit(excode); 1687 } 1688 1689 static void 1690 bam_lock(void) 1691 { 1692 struct flock lock; 1693 pid_t pid; 1694 1695 if (bam_skip_lock) 1696 return; 1697 1698 bam_lock_fd = open(BAM_LOCK_FILE, O_CREAT|O_RDWR, LOCK_FILE_PERMS); 1699 if (bam_lock_fd < 0) { 1700 /* 1701 * We may be invoked early in boot for archive verification. 1702 * In this case, root is readonly and /var/run may not exist. 1703 * Proceed without the lock 1704 */ 1705 if (errno == EROFS || errno == ENOENT) { 1706 bam_root_readonly = 1; 1707 return; 1708 } 1709 1710 bam_error(_("failed to open file: %s: %s\n"), 1711 BAM_LOCK_FILE, strerror(errno)); 1712 bam_exit(1); 1713 } 1714 1715 lock.l_type = F_WRLCK; 1716 lock.l_whence = SEEK_SET; 1717 lock.l_start = 0; 1718 lock.l_len = 0; 1719 1720 if (fcntl(bam_lock_fd, F_SETLK, &lock) == -1) { 1721 if (errno != EACCES && errno != EAGAIN) { 1722 bam_error(_("failed to lock file: %s: %s\n"), 1723 BAM_LOCK_FILE, strerror(errno)); 1724 (void) close(bam_lock_fd); 1725 bam_lock_fd = -1; 1726 bam_exit(1); 1727 } 1728 pid = 0; 1729 (void) pread(bam_lock_fd, &pid, sizeof (pid_t), 0); 1730 bam_print( 1731 _("another instance of bootadm (pid %lu) is running\n"), 1732 pid); 1733 1734 lock.l_type = F_WRLCK; 1735 lock.l_whence = SEEK_SET; 1736 lock.l_start = 0; 1737 lock.l_len = 0; 1738 if (fcntl(bam_lock_fd, F_SETLKW, &lock) == -1) { 1739 bam_error(_("failed to lock file: %s: %s\n"), 1740 BAM_LOCK_FILE, strerror(errno)); 1741 (void) close(bam_lock_fd); 1742 bam_lock_fd = -1; 1743 bam_exit(1); 1744 } 1745 } 1746 1747 /* We own the lock now */ 1748 pid = getpid(); 1749 (void) write(bam_lock_fd, &pid, sizeof (pid)); 1750 } 1751 1752 static void 1753 bam_unlock(void) 1754 { 1755 struct flock unlock; 1756 1757 if (bam_skip_lock) 1758 return; 1759 1760 /* 1761 * NOP if we don't hold the lock 1762 */ 1763 if (bam_lock_fd < 0) { 1764 return; 1765 } 1766 1767 unlock.l_type = F_UNLCK; 1768 unlock.l_whence = SEEK_SET; 1769 unlock.l_start = 0; 1770 unlock.l_len = 0; 1771 1772 if (fcntl(bam_lock_fd, F_SETLK, &unlock) == -1) { 1773 bam_error(_("failed to unlock file: %s: %s\n"), 1774 BAM_LOCK_FILE, strerror(errno)); 1775 } 1776 1777 if (close(bam_lock_fd) == -1) { 1778 bam_error(_("failed to close file: %s: %s\n"), 1779 BAM_LOCK_FILE, strerror(errno)); 1780 } 1781 bam_lock_fd = -1; 1782 } 1783 1784 static error_t 1785 list_archive(char *root, char *opt) 1786 { 1787 filelist_t flist; 1788 filelist_t *flistp = &flist; 1789 line_t *lp; 1790 1791 assert(root); 1792 assert(opt == NULL); 1793 1794 flistp->head = flistp->tail = NULL; 1795 if (read_list(root, flistp) != BAM_SUCCESS) { 1796 return (BAM_ERROR); 1797 } 1798 assert(flistp->head && flistp->tail); 1799 1800 for (lp = flistp->head; lp; lp = lp->next) { 1801 bam_print(_("%s\n"), lp->line); 1802 } 1803 1804 filelist_free(flistp); 1805 1806 return (BAM_SUCCESS); 1807 } 1808 1809 /* 1810 * This routine writes a list of lines to a file. 1811 * The list is *not* freed 1812 */ 1813 static error_t 1814 list2file(char *root, char *tmp, char *final, line_t *start) 1815 { 1816 char tmpfile[PATH_MAX]; 1817 char path[PATH_MAX]; 1818 FILE *fp; 1819 int ret; 1820 struct stat sb; 1821 mode_t mode; 1822 uid_t root_uid; 1823 gid_t sys_gid; 1824 struct passwd *pw; 1825 struct group *gp; 1826 const char *fcn = "list2file()"; 1827 1828 (void) snprintf(path, sizeof (path), "%s%s", root, final); 1829 1830 if (start == NULL) { 1831 /* Empty GRUB menu */ 1832 if (stat(path, &sb) != -1) { 1833 bam_print(_("file is empty, deleting file: %s\n"), 1834 path); 1835 if (unlink(path) != 0) { 1836 bam_error(_("failed to unlink file: %s: %s\n"), 1837 path, strerror(errno)); 1838 return (BAM_ERROR); 1839 } else { 1840 return (BAM_SUCCESS); 1841 } 1842 } 1843 return (BAM_SUCCESS); 1844 } 1845 1846 /* 1847 * Preserve attributes of existing file if possible, 1848 * otherwise ask the system for uid/gid of root/sys. 1849 * If all fails, fall back on hard-coded defaults. 1850 */ 1851 if (stat(path, &sb) != -1) { 1852 mode = sb.st_mode; 1853 root_uid = sb.st_uid; 1854 sys_gid = sb.st_gid; 1855 } else { 1856 mode = DEFAULT_DEV_MODE; 1857 if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) { 1858 root_uid = pw->pw_uid; 1859 } else { 1860 bam_error(_("getpwnam: uid for %s failed, " 1861 "defaulting to %d\n"), 1862 DEFAULT_DEV_USER, DEFAULT_DEV_UID); 1863 root_uid = (uid_t)DEFAULT_DEV_UID; 1864 } 1865 if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) { 1866 sys_gid = gp->gr_gid; 1867 } else { 1868 bam_error(_("getgrnam: gid for %s failed, " 1869 "defaulting to %d\n"), 1870 DEFAULT_DEV_GROUP, DEFAULT_DEV_GID); 1871 sys_gid = (gid_t)DEFAULT_DEV_GID; 1872 } 1873 } 1874 1875 (void) snprintf(tmpfile, sizeof (tmpfile), "%s%s", root, tmp); 1876 1877 /* Truncate tmpfile first */ 1878 fp = fopen(tmpfile, "w"); 1879 if (fp == NULL) { 1880 bam_error(_("failed to open file: %s: %s\n"), tmpfile, 1881 strerror(errno)); 1882 return (BAM_ERROR); 1883 } 1884 ret = fclose(fp); 1885 INJECT_ERROR1("LIST2FILE_TRUNC_FCLOSE", ret = EOF); 1886 if (ret == EOF) { 1887 bam_error(_("failed to close file: %s: %s\n"), 1888 tmpfile, strerror(errno)); 1889 return (BAM_ERROR); 1890 } 1891 1892 /* Now open it in append mode */ 1893 fp = fopen(tmpfile, "a"); 1894 if (fp == NULL) { 1895 bam_error(_("failed to open file: %s: %s\n"), tmpfile, 1896 strerror(errno)); 1897 return (BAM_ERROR); 1898 } 1899 1900 for (; start; start = start->next) { 1901 ret = s_fputs(start->line, fp); 1902 INJECT_ERROR1("LIST2FILE_FPUTS", ret = EOF); 1903 if (ret == EOF) { 1904 bam_error(_("write to file failed: %s: %s\n"), 1905 tmpfile, strerror(errno)); 1906 (void) fclose(fp); 1907 return (BAM_ERROR); 1908 } 1909 } 1910 1911 ret = fclose(fp); 1912 INJECT_ERROR1("LIST2FILE_APPEND_FCLOSE", ret = EOF); 1913 if (ret == EOF) { 1914 bam_error(_("failed to close file: %s: %s\n"), 1915 tmpfile, strerror(errno)); 1916 return (BAM_ERROR); 1917 } 1918 1919 /* 1920 * Set up desired attributes. Ignore failures on filesystems 1921 * not supporting these operations - pcfs reports unsupported 1922 * operations as EINVAL. 1923 */ 1924 ret = chmod(tmpfile, mode); 1925 if (ret == -1 && 1926 errno != EINVAL && errno != ENOTSUP) { 1927 bam_error(_("chmod operation on %s failed - %s\n"), 1928 tmpfile, strerror(errno)); 1929 return (BAM_ERROR); 1930 } 1931 1932 ret = chown(tmpfile, root_uid, sys_gid); 1933 if (ret == -1 && 1934 errno != EINVAL && errno != ENOTSUP) { 1935 bam_error(_("chgrp operation on %s failed - %s\n"), 1936 tmpfile, strerror(errno)); 1937 return (BAM_ERROR); 1938 } 1939 1940 /* 1941 * Do an atomic rename 1942 */ 1943 ret = rename(tmpfile, path); 1944 INJECT_ERROR1("LIST2FILE_RENAME", ret = -1); 1945 if (ret != 0) { 1946 bam_error(_("rename to file failed: %s: %s\n"), path, 1947 strerror(errno)); 1948 return (BAM_ERROR); 1949 } 1950 1951 BAM_DPRINTF(("%s: wrote file successfully: %s\n", fcn, path)); 1952 return (BAM_SUCCESS); 1953 } 1954 1955 /* 1956 * Checks if the path specified (without the file name at the end) exists 1957 * and creates it if not. If the path exists and is not a directory, an attempt 1958 * to unlink is made. 1959 */ 1960 static int 1961 setup_path(char *path) 1962 { 1963 char *p; 1964 int ret; 1965 struct stat sb; 1966 1967 p = strrchr(path, '/'); 1968 if (p != NULL) { 1969 *p = '\0'; 1970 if (stat(path, &sb) != 0 || !(S_ISDIR(sb.st_mode))) { 1971 /* best effort attempt, mkdirp will catch the error */ 1972 (void) unlink(path); 1973 if (bam_verbose) 1974 bam_print(_("need to create directory " 1975 "path for %s\n"), path); 1976 ret = mkdirp(path, DIR_PERMS); 1977 if (ret == -1) { 1978 bam_error(_("mkdir of %s failed: %s\n"), 1979 path, strerror(errno)); 1980 *p = '/'; 1981 return (BAM_ERROR); 1982 } 1983 } 1984 *p = '/'; 1985 return (BAM_SUCCESS); 1986 } 1987 return (BAM_SUCCESS); 1988 } 1989 1990 typedef union { 1991 gzFile gzfile; 1992 int fdfile; 1993 } outfile; 1994 1995 typedef struct { 1996 char path[PATH_MAX]; 1997 outfile out; 1998 } cachefile; 1999 2000 static int 2001 setup_file(char *base, const char *path, cachefile *cf) 2002 { 2003 int ret; 2004 char *strip; 2005 2006 /* init gzfile or fdfile in case we fail before opening */ 2007 if (bam_direct == BAM_DIRECT_DBOOT) 2008 cf->out.gzfile = NULL; 2009 else 2010 cf->out.fdfile = -1; 2011 2012 /* strip the trailing altroot path */ 2013 strip = (char *)path + strlen(rootbuf); 2014 2015 ret = snprintf(cf->path, sizeof (cf->path), "%s/%s", base, strip); 2016 if (ret >= sizeof (cf->path)) { 2017 bam_error(_("unable to create path on mountpoint %s, " 2018 "path too long\n"), rootbuf); 2019 return (BAM_ERROR); 2020 } 2021 2022 /* Check if path is present in the archive cache directory */ 2023 if (setup_path(cf->path) == BAM_ERROR) 2024 return (BAM_ERROR); 2025 2026 if (bam_direct == BAM_DIRECT_DBOOT) { 2027 if ((cf->out.gzfile = gzopen(cf->path, "wb")) == NULL) { 2028 bam_error(_("failed to open file: %s: %s\n"), 2029 cf->path, strerror(errno)); 2030 return (BAM_ERROR); 2031 } 2032 (void) gzsetparams(cf->out.gzfile, Z_BEST_SPEED, 2033 Z_DEFAULT_STRATEGY); 2034 } else { 2035 if ((cf->out.fdfile = open(cf->path, O_WRONLY | O_CREAT, 0644)) 2036 == -1) { 2037 bam_error(_("failed to open file: %s: %s\n"), 2038 cf->path, strerror(errno)); 2039 return (BAM_ERROR); 2040 } 2041 } 2042 2043 return (BAM_SUCCESS); 2044 } 2045 2046 static int 2047 cache_write(cachefile cf, char *buf, int size) 2048 { 2049 int err; 2050 2051 if (bam_direct == BAM_DIRECT_DBOOT) { 2052 if (gzwrite(cf.out.gzfile, buf, size) < 1) { 2053 bam_error(_("failed to write to %s\n"), 2054 gzerror(cf.out.gzfile, &err)); 2055 if (err == Z_ERRNO && bam_verbose) { 2056 bam_error(_("write to file failed: %s: %s\n"), 2057 cf.path, strerror(errno)); 2058 } 2059 return (BAM_ERROR); 2060 } 2061 } else { 2062 if (write(cf.out.fdfile, buf, size) < 1) { 2063 bam_error(_("write to file failed: %s: %s\n"), 2064 cf.path, strerror(errno)); 2065 return (BAM_ERROR); 2066 } 2067 } 2068 return (BAM_SUCCESS); 2069 } 2070 2071 static int 2072 cache_close(cachefile cf) 2073 { 2074 int ret; 2075 2076 if (bam_direct == BAM_DIRECT_DBOOT) { 2077 if (cf.out.gzfile) { 2078 ret = gzclose(cf.out.gzfile); 2079 if (ret != Z_OK) { 2080 bam_error(_("failed to close file: %s: %s\n"), 2081 cf.path, strerror(errno)); 2082 return (BAM_ERROR); 2083 } 2084 } 2085 } else { 2086 if (cf.out.fdfile != -1) { 2087 ret = close(cf.out.fdfile); 2088 if (ret != 0) { 2089 bam_error(_("failed to close file: %s: %s\n"), 2090 cf.path, strerror(errno)); 2091 return (BAM_ERROR); 2092 } 2093 } 2094 } 2095 2096 return (BAM_SUCCESS); 2097 } 2098 2099 static int 2100 dircache_updatefile(const char *path) 2101 { 2102 int ret, exitcode; 2103 char buf[4096 * 4]; 2104 FILE *infile; 2105 cachefile outfile, outupdt; 2106 2107 if (bam_nowrite()) { 2108 set_dir_flag(NEED_UPDATE); 2109 return (BAM_SUCCESS); 2110 } 2111 2112 if (!has_cachedir()) 2113 return (BAM_SUCCESS); 2114 2115 if ((infile = fopen(path, "rb")) == NULL) { 2116 bam_error(_("failed to open file: %s: %s\n"), path, 2117 strerror(errno)); 2118 return (BAM_ERROR); 2119 } 2120 2121 ret = setup_file(get_cachedir(), path, &outfile); 2122 if (ret == BAM_ERROR) { 2123 exitcode = BAM_ERROR; 2124 goto out; 2125 } 2126 if (!is_dir_flag_on(NO_EXTEND)) { 2127 ret = setup_file(get_updatedir(), path, &outupdt); 2128 if (ret == BAM_ERROR) 2129 set_dir_flag(NO_EXTEND); 2130 } 2131 2132 while ((ret = fread(buf, 1, sizeof (buf), infile)) > 0) { 2133 if (cache_write(outfile, buf, ret) == BAM_ERROR) { 2134 exitcode = BAM_ERROR; 2135 goto out; 2136 } 2137 if (!is_dir_flag_on(NO_EXTEND)) 2138 if (cache_write(outupdt, buf, ret) == BAM_ERROR) 2139 set_dir_flag(NO_EXTEND); 2140 } 2141 2142 set_dir_flag(NEED_UPDATE); 2143 get_count()++; 2144 if (get_count() > COUNT_MAX) 2145 set_dir_flag(NO_EXTEND); 2146 exitcode = BAM_SUCCESS; 2147 out: 2148 (void) fclose(infile); 2149 if (cache_close(outfile) == BAM_ERROR) 2150 exitcode = BAM_ERROR; 2151 if (!is_dir_flag_on(NO_EXTEND) && 2152 cache_close(outupdt) == BAM_ERROR) 2153 exitcode = BAM_ERROR; 2154 if (exitcode == BAM_ERROR) 2155 set_flag(UPDATE_ERROR); 2156 return (exitcode); 2157 } 2158 2159 static int 2160 dircache_updatedir(const char *path, int updt) 2161 { 2162 int ret; 2163 char dpath[PATH_MAX]; 2164 char *strip; 2165 struct stat sb; 2166 2167 strip = (char *)path + strlen(rootbuf); 2168 2169 ret = snprintf(dpath, sizeof (dpath), "%s/%s", updt ? 2170 get_updatedir() : get_cachedir(), strip); 2171 2172 if (ret >= sizeof (dpath)) { 2173 bam_error(_("unable to create path on mountpoint %s, " 2174 "path too long\n"), rootbuf); 2175 set_flag(UPDATE_ERROR); 2176 return (BAM_ERROR); 2177 } 2178 2179 if (stat(dpath, &sb) == 0 && S_ISDIR(sb.st_mode)) 2180 return (BAM_SUCCESS); 2181 2182 if (updt) { 2183 if (!is_dir_flag_on(NO_EXTEND)) 2184 if (!bam_nowrite() && mkdirp(dpath, DIR_PERMS) == -1) 2185 set_dir_flag(NO_EXTEND); 2186 } else { 2187 if (!bam_nowrite() && mkdirp(dpath, DIR_PERMS) == -1) { 2188 set_flag(UPDATE_ERROR); 2189 return (BAM_ERROR); 2190 } 2191 } 2192 2193 set_dir_flag(NEED_UPDATE); 2194 return (BAM_SUCCESS); 2195 } 2196 2197 #define DO_CACHE_DIR 0 2198 #define DO_UPDATE_DIR 1 2199 2200 #if defined(_LP64) || defined(_LONGLONG_TYPE) 2201 typedef Elf64_Ehdr _elfhdr; 2202 #else 2203 typedef Elf32_Ehdr _elfhdr; 2204 #endif 2205 2206 /* 2207 * This routine updates the contents of the cache directory 2208 */ 2209 static int 2210 update_dircache(const char *path, int flags) 2211 { 2212 int rc = BAM_SUCCESS; 2213 2214 switch (flags) { 2215 case FTW_F: 2216 { 2217 int fd; 2218 _elfhdr elf; 2219 2220 if ((fd = open(path, O_RDONLY)) < 0) { 2221 bam_error(_("failed to open file: %s: %s\n"), 2222 path, strerror(errno)); 2223 set_flag(UPDATE_ERROR); 2224 rc = BAM_ERROR; 2225 break; 2226 } 2227 2228 /* 2229 * libelf and gelf would be a cleaner and easier way to handle 2230 * this, but libelf fails compilation if _ILP32 is defined && 2231 * _FILE_OFFSET_BITS is != 32 ... 2232 */ 2233 if (read(fd, (void *)&elf, sizeof (_elfhdr)) < 0) { 2234 bam_error(_("read failed for file: %s: %s\n"), 2235 path, strerror(errno)); 2236 set_flag(UPDATE_ERROR); 2237 (void) close(fd); 2238 rc = BAM_ERROR; 2239 break; 2240 } 2241 (void) close(fd); 2242 2243 if (memcmp(elf.e_ident, ELFMAG, 4) != 0) { 2244 /* Not an ELF file, include in archive */ 2245 rc = dircache_updatefile(path); 2246 } else { 2247 /* Include 64-bit ELF files only */ 2248 switch (elf.e_ident[EI_CLASS]) { 2249 case ELFCLASS32: 2250 bam_print(_("WARNING: ELF file %s is 32-bit " 2251 "and will be excluded\n"), path); 2252 break; 2253 case ELFCLASS64: 2254 rc = dircache_updatefile(path); 2255 break; 2256 default: 2257 bam_print(_("WARNING: ELF file %s is neither " 2258 "32-bit nor 64-bit\n"), path); 2259 break; 2260 } 2261 } 2262 break; 2263 } 2264 case FTW_D: 2265 if (strstr(path, "/amd64") != NULL) { 2266 if (has_cachedir()) { 2267 rc = dircache_updatedir(path, DO_UPDATE_DIR); 2268 if (rc == BAM_SUCCESS) 2269 rc = dircache_updatedir(path, 2270 DO_CACHE_DIR); 2271 } 2272 } 2273 break; 2274 default: 2275 rc = BAM_ERROR; 2276 break; 2277 } 2278 2279 return (rc); 2280 } 2281 2282 /*ARGSUSED*/ 2283 static int 2284 cmpstat( 2285 const char *file, 2286 const struct stat *st, 2287 int flags, 2288 struct FTW *ftw) 2289 { 2290 uint_t sz; 2291 uint64_t *value; 2292 uint64_t filestat[2]; 2293 int error, ret, status; 2294 2295 struct safefile *safefilep; 2296 FILE *fp; 2297 struct stat sb; 2298 regex_t re; 2299 2300 /* 2301 * On SPARC we create/update links too. 2302 */ 2303 if (flags != FTW_F && flags != FTW_D && (flags == FTW_SL && 2304 !is_flag_on(IS_SPARC_TARGET))) 2305 return (0); 2306 2307 /* 2308 * Ignore broken links 2309 */ 2310 if (flags == FTW_SL && stat(file, &sb) < 0) 2311 return (0); 2312 2313 /* 2314 * new_nvlp may be NULL if there were errors earlier 2315 * but this is not fatal to update determination. 2316 */ 2317 if (walk_arg.new_nvlp) { 2318 filestat[0] = st->st_size; 2319 filestat[1] = st->st_mtime; 2320 error = nvlist_add_uint64_array(walk_arg.new_nvlp, 2321 file + bam_rootlen, filestat, 2); 2322 if (error) 2323 bam_error(_("failed to update stat data for: %s: %s\n"), 2324 file, strerror(error)); 2325 } 2326 2327 /* 2328 * If we are invoked as part of system/filesystem/boot-archive, then 2329 * there are a number of things we should not worry about 2330 */ 2331 if (bam_smf_check) { 2332 /* ignore amd64 modules unless we are booted amd64. */ 2333 if (!is_amd64() && strstr(file, "/amd64/") != 0) 2334 return (0); 2335 2336 /* read in list of safe files */ 2337 if (safefiles == NULL) { 2338 fp = fopen("/boot/solaris/filelist.safe", "r"); 2339 if (fp != NULL) { 2340 safefiles = s_calloc(1, 2341 sizeof (struct safefile)); 2342 safefilep = safefiles; 2343 safefilep->name = s_calloc(1, MAXPATHLEN + 2344 MAXNAMELEN); 2345 safefilep->next = NULL; 2346 while (s_fgets(safefilep->name, MAXPATHLEN + 2347 MAXNAMELEN, fp) != NULL) { 2348 safefilep->next = s_calloc(1, 2349 sizeof (struct safefile)); 2350 safefilep = safefilep->next; 2351 safefilep->name = s_calloc(1, 2352 MAXPATHLEN + MAXNAMELEN); 2353 safefilep->next = NULL; 2354 } 2355 (void) fclose(fp); 2356 } 2357 } 2358 } 2359 2360 /* 2361 * On SPARC we create a -path-list file for mkisofs 2362 */ 2363 if (is_flag_on(IS_SPARC_TARGET) && !bam_nowrite()) { 2364 if (flags != FTW_D) { 2365 char *strip; 2366 2367 strip = (char *)file + strlen(rootbuf); 2368 (void) fprintf(walk_arg.sparcfile, "/%s=%s\n", strip, 2369 file); 2370 } 2371 } 2372 2373 /* 2374 * We are transitioning from the old model to the dircache or the cache 2375 * directory was removed: create the entry without further checkings. 2376 */ 2377 if (is_flag_on(NEED_CACHE_DIR)) { 2378 if (bam_verbose) 2379 bam_print(_(" new %s\n"), file); 2380 2381 if (is_flag_on(IS_SPARC_TARGET)) { 2382 set_dir_flag(NEED_UPDATE); 2383 return (0); 2384 } 2385 2386 ret = update_dircache(file, flags); 2387 if (ret == BAM_ERROR) { 2388 bam_error(_("directory cache update failed for %s\n"), 2389 file); 2390 return (-1); 2391 } 2392 2393 return (0); 2394 } 2395 2396 /* 2397 * We need an update if file doesn't exist in old archive 2398 */ 2399 if (walk_arg.old_nvlp == NULL || 2400 nvlist_lookup_uint64_array(walk_arg.old_nvlp, 2401 file + bam_rootlen, &value, &sz) != 0) { 2402 if (bam_smf_check) /* ignore new during smf check */ 2403 return (0); 2404 2405 if (is_flag_on(IS_SPARC_TARGET)) { 2406 set_dir_flag(NEED_UPDATE); 2407 } else { 2408 ret = update_dircache(file, flags); 2409 if (ret == BAM_ERROR) { 2410 bam_error(_("directory cache update " 2411 "failed for %s\n"), file); 2412 return (-1); 2413 } 2414 } 2415 2416 if (bam_verbose) 2417 bam_print(_(" new %s\n"), file); 2418 return (0); 2419 } 2420 2421 /* 2422 * If we got there, the file is already listed as to be included in the 2423 * iso image. We just need to know if we are going to rebuild it or not 2424 */ 2425 if (is_flag_on(IS_SPARC_TARGET) && 2426 is_dir_flag_on(NEED_UPDATE) && !bam_nowrite()) 2427 return (0); 2428 /* 2429 * File exists in old archive. Check if file has changed 2430 */ 2431 assert(sz == 2); 2432 bcopy(value, filestat, sizeof (filestat)); 2433 2434 if (flags != FTW_D && (filestat[0] != st->st_size || 2435 filestat[1] != st->st_mtime)) { 2436 if (bam_smf_check) { 2437 safefilep = safefiles; 2438 while (safefilep != NULL && 2439 safefilep->name[0] != '\0') { 2440 if (regcomp(&re, safefilep->name, 2441 REG_EXTENDED|REG_NOSUB) == 0) { 2442 status = regexec(&re, 2443 file + bam_rootlen, 0, NULL, 0); 2444 regfree(&re); 2445 if (status == 0) { 2446 (void) creat( 2447 NEED_UPDATE_SAFE_FILE, 2448 0644); 2449 return (0); 2450 } 2451 } 2452 safefilep = safefilep->next; 2453 } 2454 } 2455 2456 if (is_flag_on(IS_SPARC_TARGET)) { 2457 set_dir_flag(NEED_UPDATE); 2458 } else { 2459 ret = update_dircache(file, flags); 2460 if (ret == BAM_ERROR) { 2461 bam_error(_("directory cache update failed " 2462 "for %s\n"), file); 2463 return (-1); 2464 } 2465 } 2466 2467 /* 2468 * Update self-assembly file if there are changes in 2469 * /etc/system.d directory 2470 */ 2471 if (strstr(file, ETC_SYSTEM_DIR)) { 2472 ret = update_dircache(self_assembly, flags); 2473 if (ret == BAM_ERROR) { 2474 bam_error(_("directory cache update failed " 2475 "for %s\n"), file); 2476 return (-1); 2477 } 2478 } 2479 2480 if (bam_verbose) { 2481 if (bam_smf_check) 2482 bam_print(" %s\n", file); 2483 else 2484 bam_print(_(" changed %s\n"), file); 2485 } 2486 } 2487 2488 return (0); 2489 } 2490 2491 /* 2492 * Remove a directory path recursively 2493 */ 2494 static int 2495 rmdir_r(char *path) 2496 { 2497 struct dirent *d = NULL; 2498 DIR *dir = NULL; 2499 char tpath[PATH_MAX]; 2500 struct stat sb; 2501 2502 if ((dir = opendir(path)) == NULL) 2503 return (-1); 2504 2505 while ((d = readdir(dir)) != NULL) { 2506 if ((strcmp(d->d_name, ".") != 0) && 2507 (strcmp(d->d_name, "..") != 0)) { 2508 (void) snprintf(tpath, sizeof (tpath), "%s/%s", 2509 path, d->d_name); 2510 if (stat(tpath, &sb) == 0) { 2511 if (sb.st_mode & S_IFDIR) 2512 (void) rmdir_r(tpath); 2513 else 2514 (void) remove(tpath); 2515 } 2516 } 2517 } 2518 return (remove(path)); 2519 } 2520 2521 /* 2522 * Check if cache directory exists and, if not, create it and update flags 2523 * accordingly. If the path exists, but it's not a directory, a best effort 2524 * attempt to remove and recreate it is made. 2525 * If the user requested a 'purge', always recreate the directory from scratch. 2526 */ 2527 static int 2528 set_cache_dir(char *root) 2529 { 2530 struct stat sb; 2531 int ret = 0; 2532 2533 ret = build_path(get_cachedir(), sizeof (get_cachedir()), 2534 root, ARCHIVE_PREFIX, CACHEDIR_SUFFIX); 2535 2536 if (ret >= sizeof (get_cachedir())) { 2537 bam_error(_("unable to create path on mountpoint %s, " 2538 "path too long\n"), rootbuf); 2539 return (BAM_ERROR); 2540 } 2541 2542 if (bam_purge || is_flag_on(INVALIDATE_CACHE)) 2543 (void) rmdir_r(get_cachedir()); 2544 2545 if (stat(get_cachedir(), &sb) != 0 || !(S_ISDIR(sb.st_mode))) { 2546 /* best effort unlink attempt, mkdir will catch errors */ 2547 (void) unlink(get_cachedir()); 2548 2549 if (bam_verbose) 2550 bam_print(_("archive cache directory not found: %s\n"), 2551 get_cachedir()); 2552 ret = mkdir(get_cachedir(), DIR_PERMS); 2553 if (ret < 0) { 2554 bam_error(_("mkdir of %s failed: %s\n"), 2555 get_cachedir(), strerror(errno)); 2556 get_cachedir()[0] = '\0'; 2557 return (ret); 2558 } 2559 set_flag(NEED_CACHE_DIR); 2560 set_dir_flag(NO_EXTEND); 2561 } 2562 2563 return (BAM_SUCCESS); 2564 } 2565 2566 static int 2567 set_update_dir(char *root) 2568 { 2569 struct stat sb; 2570 int ret; 2571 2572 if (is_dir_flag_on(NO_EXTEND)) 2573 return (BAM_SUCCESS); 2574 2575 if (!bam_extend) { 2576 set_dir_flag(NO_EXTEND); 2577 return (BAM_SUCCESS); 2578 } 2579 2580 ret = build_path(get_updatedir(), sizeof (get_updatedir()), 2581 root, ARCHIVE_PREFIX, UPDATEDIR_SUFFIX); 2582 2583 if (ret >= sizeof (get_updatedir())) { 2584 bam_error(_("unable to create path on mountpoint %s, " 2585 "path too long\n"), rootbuf); 2586 return (BAM_ERROR); 2587 } 2588 2589 if (stat(get_updatedir(), &sb) == 0) { 2590 if (S_ISDIR(sb.st_mode)) 2591 ret = rmdir_r(get_updatedir()); 2592 else 2593 ret = unlink(get_updatedir()); 2594 2595 if (ret != 0) 2596 set_dir_flag(NO_EXTEND); 2597 } 2598 2599 if (mkdir(get_updatedir(), DIR_PERMS) < 0) 2600 set_dir_flag(NO_EXTEND); 2601 2602 return (BAM_SUCCESS); 2603 } 2604 2605 static int 2606 is_valid_archive(char *root) 2607 { 2608 char archive_path[PATH_MAX]; 2609 char timestamp_path[PATH_MAX]; 2610 struct stat sb, timestamp; 2611 int ret; 2612 2613 ret = build_path(archive_path, sizeof (archive_path), 2614 root, ARCHIVE_PREFIX, ARCHIVE_SUFFIX); 2615 2616 if (ret >= sizeof (archive_path)) { 2617 bam_error(_("unable to create path on mountpoint %s, " 2618 "path too long\n"), rootbuf); 2619 return (BAM_ERROR); 2620 } 2621 2622 if (stat(archive_path, &sb) != 0) { 2623 if (bam_verbose && !bam_check) 2624 bam_print(_("archive not found: %s\n"), archive_path); 2625 set_dir_flag(NEED_UPDATE | NO_EXTEND); 2626 return (BAM_SUCCESS); 2627 } 2628 2629 /* 2630 * The timestamp file is used to prevent stale files in the archive 2631 * cache. 2632 * Stale files can happen if the system is booted back and forth across 2633 * the transition from bootadm-before-the-cache to 2634 * bootadm-after-the-cache, since older versions of bootadm don't know 2635 * about the existence of the archive cache. 2636 * 2637 * Since only bootadm-after-the-cache versions know about about this 2638 * file, we require that the boot archive be older than this file. 2639 */ 2640 ret = snprintf(timestamp_path, sizeof (timestamp_path), "%s%s", root, 2641 FILE_STAT_TIMESTAMP); 2642 2643 if (ret >= sizeof (timestamp_path)) { 2644 bam_error(_("unable to create path on mountpoint %s, " 2645 "path too long\n"), rootbuf); 2646 return (BAM_ERROR); 2647 } 2648 2649 if (stat(timestamp_path, ×tamp) != 0 || 2650 sb.st_mtime > timestamp.st_mtime) { 2651 if (bam_verbose && !bam_check) 2652 bam_print( 2653 _("archive cache is out of sync. Rebuilding.\n")); 2654 /* 2655 * Don't generate a false positive for the boot-archive service 2656 * but trigger an update of the archive cache in 2657 * boot-archive-update. 2658 */ 2659 if (bam_smf_check) { 2660 (void) creat(NEED_UPDATE_FILE, 0644); 2661 return (BAM_SUCCESS); 2662 } 2663 2664 set_flag(INVALIDATE_CACHE); 2665 set_dir_flag(NEED_UPDATE | NO_EXTEND); 2666 return (BAM_SUCCESS); 2667 } 2668 2669 if (is_flag_on(IS_SPARC_TARGET)) 2670 return (BAM_SUCCESS); 2671 2672 if (bam_extend && sb.st_size > BA_SIZE_MAX) { 2673 if (bam_verbose && !bam_check) 2674 bam_print(_("archive %s is bigger than %d bytes and " 2675 "will be rebuilt\n"), archive_path, BA_SIZE_MAX); 2676 set_dir_flag(NO_EXTEND); 2677 } 2678 2679 return (BAM_SUCCESS); 2680 } 2681 2682 /* 2683 * Check flags and presence of required files and directories. 2684 * The force flag and/or absence of files should 2685 * trigger an update. 2686 * Suppress stdout output if check (-n) option is set 2687 * (as -n should only produce parseable output.) 2688 */ 2689 static int 2690 check_flags_and_files(char *root) 2691 { 2692 2693 struct stat sb; 2694 int ret; 2695 2696 /* 2697 * If archive is missing, create archive 2698 */ 2699 ret = is_valid_archive(root); 2700 if (ret == BAM_ERROR) 2701 return (BAM_ERROR); 2702 2703 if (bam_nowrite()) 2704 return (BAM_SUCCESS); 2705 2706 /* 2707 * check if cache directories exist on x86. 2708 * check (and always open) the cache file on SPARC. 2709 */ 2710 if (is_sparc()) { 2711 ret = snprintf(get_cachedir(), 2712 sizeof (get_cachedir()), "%s%s%s/%s", root, 2713 ARCHIVE_PREFIX, get_machine(), CACHEDIR_SUFFIX); 2714 2715 if (ret >= sizeof (get_cachedir())) { 2716 bam_error(_("unable to create path on mountpoint %s, " 2717 "path too long\n"), rootbuf); 2718 return (BAM_ERROR); 2719 } 2720 2721 if (stat(get_cachedir(), &sb) != 0) { 2722 set_flag(NEED_CACHE_DIR); 2723 set_dir_flag(NEED_UPDATE); 2724 } 2725 2726 walk_arg.sparcfile = fopen(get_cachedir(), "w"); 2727 if (walk_arg.sparcfile == NULL) { 2728 bam_error(_("failed to open file: %s: %s\n"), 2729 get_cachedir(), strerror(errno)); 2730 return (BAM_ERROR); 2731 } 2732 2733 set_dir_present(); 2734 } else { 2735 if (set_cache_dir(root) != 0) 2736 return (BAM_ERROR); 2737 2738 set_dir_present(); 2739 2740 if (set_update_dir(root) != 0) 2741 return (BAM_ERROR); 2742 } 2743 2744 /* 2745 * if force, create archive unconditionally 2746 */ 2747 if (bam_force) { 2748 set_dir_flag(NEED_UPDATE); 2749 if (bam_verbose) 2750 bam_print(_("forced update of archive requested\n")); 2751 return (BAM_SUCCESS); 2752 } 2753 2754 return (BAM_SUCCESS); 2755 } 2756 2757 static error_t 2758 read_one_list(char *root, filelist_t *flistp, char *filelist) 2759 { 2760 char path[PATH_MAX]; 2761 FILE *fp; 2762 char buf[BAM_MAXLINE]; 2763 const char *fcn = "read_one_list()"; 2764 2765 (void) snprintf(path, sizeof (path), "%s%s", root, filelist); 2766 2767 fp = fopen(path, "r"); 2768 if (fp == NULL) { 2769 BAM_DPRINTF(("%s: failed to open archive filelist: %s: %s\n", 2770 fcn, path, strerror(errno))); 2771 return (BAM_ERROR); 2772 } 2773 while (s_fgets(buf, sizeof (buf), fp) != NULL) { 2774 /* skip blank lines */ 2775 if (strspn(buf, " \t") == strlen(buf)) 2776 continue; 2777 append_to_flist(flistp, buf); 2778 } 2779 if (fclose(fp) != 0) { 2780 bam_error(_("failed to close file: %s: %s\n"), 2781 path, strerror(errno)); 2782 return (BAM_ERROR); 2783 } 2784 return (BAM_SUCCESS); 2785 } 2786 2787 static error_t 2788 read_list(char *root, filelist_t *flistp) 2789 { 2790 char path[PATH_MAX]; 2791 char cmd[PATH_MAX]; 2792 struct stat sb; 2793 int n, rval; 2794 const char *fcn = "read_list()"; 2795 2796 flistp->head = flistp->tail = NULL; 2797 2798 /* 2799 * build and check path to extract_boot_filelist.ksh 2800 */ 2801 n = snprintf(path, sizeof (path), "%s%s", root, EXTRACT_BOOT_FILELIST); 2802 if (n >= sizeof (path)) { 2803 bam_error(_("archive filelist is empty\n")); 2804 return (BAM_ERROR); 2805 } 2806 2807 if (is_safe_exec(path) == BAM_ERROR) 2808 return (BAM_ERROR); 2809 2810 /* 2811 * If extract_boot_filelist is present, exec it, otherwise read 2812 * the filelists directly, for compatibility with older images. 2813 */ 2814 if (stat(path, &sb) == 0) { 2815 /* 2816 * build arguments to exec extract_boot_filelist.ksh 2817 */ 2818 char *rootarg, *platarg; 2819 int platarglen = 1, rootarglen = 1; 2820 if (strlen(root) > 1) 2821 rootarglen += strlen(root) + strlen("-R "); 2822 if (bam_alt_platform) 2823 platarglen += strlen(bam_platform) + strlen("-p "); 2824 platarg = s_calloc(1, platarglen); 2825 rootarg = s_calloc(1, rootarglen); 2826 *platarg = 0; 2827 *rootarg = 0; 2828 2829 if (strlen(root) > 1) { 2830 (void) snprintf(rootarg, rootarglen, 2831 "-R %s", root); 2832 } 2833 if (bam_alt_platform) { 2834 (void) snprintf(platarg, platarglen, 2835 "-p %s", bam_platform); 2836 } 2837 n = snprintf(cmd, sizeof (cmd), "%s %s %s /%s /%s", 2838 path, rootarg, platarg, BOOT_FILE_LIST, ETC_FILE_LIST); 2839 free(platarg); 2840 free(rootarg); 2841 if (n >= sizeof (cmd)) { 2842 bam_error(_("archive filelist is empty\n")); 2843 return (BAM_ERROR); 2844 } 2845 if (exec_cmd(cmd, flistp) != 0) { 2846 BAM_DPRINTF(("%s: failed to open archive " 2847 "filelist: %s: %s\n", fcn, path, strerror(errno))); 2848 return (BAM_ERROR); 2849 } 2850 } else { 2851 /* 2852 * Read current lists of files - only the first is mandatory 2853 */ 2854 rval = read_one_list(root, flistp, BOOT_FILE_LIST); 2855 if (rval != BAM_SUCCESS) 2856 return (rval); 2857 (void) read_one_list(root, flistp, ETC_FILE_LIST); 2858 } 2859 2860 if (flistp->head == NULL) { 2861 bam_error(_("archive filelist is empty\n")); 2862 return (BAM_ERROR); 2863 } 2864 2865 return (BAM_SUCCESS); 2866 } 2867 2868 static void 2869 getoldstat(char *root) 2870 { 2871 char path[PATH_MAX]; 2872 int fd, error; 2873 struct stat sb; 2874 char *ostat; 2875 2876 (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 2877 fd = open(path, O_RDONLY); 2878 if (fd == -1) { 2879 if (bam_verbose) 2880 bam_print(_("failed to open file: %s: %s\n"), 2881 path, strerror(errno)); 2882 goto out_err; 2883 } 2884 2885 if (fstat(fd, &sb) != 0) { 2886 bam_error(_("stat of file failed: %s: %s\n"), path, 2887 strerror(errno)); 2888 goto out_err; 2889 } 2890 2891 ostat = s_calloc(1, sb.st_size); 2892 2893 if (read(fd, ostat, sb.st_size) != sb.st_size) { 2894 bam_error(_("read failed for file: %s: %s\n"), path, 2895 strerror(errno)); 2896 free(ostat); 2897 goto out_err; 2898 } 2899 2900 (void) close(fd); 2901 fd = -1; 2902 2903 walk_arg.old_nvlp = NULL; 2904 error = nvlist_unpack(ostat, sb.st_size, &walk_arg.old_nvlp, 0); 2905 2906 free(ostat); 2907 2908 if (error) { 2909 bam_error(_("failed to unpack stat data: %s: %s\n"), 2910 path, strerror(error)); 2911 walk_arg.old_nvlp = NULL; 2912 goto out_err; 2913 } else { 2914 return; 2915 } 2916 2917 out_err: 2918 if (fd != -1) 2919 (void) close(fd); 2920 set_dir_flag(NEED_UPDATE); 2921 } 2922 2923 /* Best effort stale entry removal */ 2924 static void 2925 delete_stale(char *file) 2926 { 2927 char path[PATH_MAX]; 2928 struct stat sb; 2929 2930 (void) snprintf(path, sizeof (path), "%s/%s", get_cachedir(), file); 2931 if (!bam_check && stat(path, &sb) == 0) { 2932 if (sb.st_mode & S_IFDIR) 2933 (void) rmdir_r(path); 2934 else 2935 (void) unlink(path); 2936 2937 set_dir_flag(NEED_UPDATE | NO_EXTEND); 2938 } 2939 } 2940 2941 /* 2942 * Checks if a file in the current (old) archive has 2943 * been deleted from the root filesystem. This is needed for 2944 * software like Trusted Extensions (TX) that switch early 2945 * in boot based on presence/absence of a kernel module. 2946 */ 2947 static void 2948 check4stale(char *root) 2949 { 2950 nvpair_t *nvp; 2951 nvlist_t *nvlp; 2952 char *file; 2953 char path[PATH_MAX]; 2954 2955 /* 2956 * Skip stale file check during smf check 2957 */ 2958 if (bam_smf_check) 2959 return; 2960 2961 /* 2962 * If we need to (re)create the cache, there's no need to check for 2963 * stale files 2964 */ 2965 if (is_flag_on(NEED_CACHE_DIR)) 2966 return; 2967 2968 /* Nothing to do if no old stats */ 2969 if ((nvlp = walk_arg.old_nvlp) == NULL) 2970 return; 2971 2972 for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp; 2973 nvp = nvlist_next_nvpair(nvlp, nvp)) { 2974 file = nvpair_name(nvp); 2975 if (file == NULL) 2976 continue; 2977 (void) snprintf(path, sizeof (path), "%s/%s", 2978 root, file); 2979 if (access(path, F_OK) < 0) { 2980 if (bam_verbose) 2981 bam_print(_(" stale %s\n"), path); 2982 2983 if (is_flag_on(IS_SPARC_TARGET)) { 2984 set_dir_flag(NEED_UPDATE); 2985 } else { 2986 if (has_cachedir()) 2987 delete_stale(file); 2988 } 2989 } 2990 } 2991 } 2992 2993 static void 2994 create_newstat(void) 2995 { 2996 int error; 2997 2998 error = nvlist_alloc(&walk_arg.new_nvlp, NV_UNIQUE_NAME, 0); 2999 if (error) { 3000 /* 3001 * Not fatal - we can still create archive 3002 */ 3003 walk_arg.new_nvlp = NULL; 3004 bam_error(_("failed to create stat data: %s\n"), 3005 strerror(error)); 3006 } 3007 } 3008 3009 static int 3010 walk_list(char *root, filelist_t *flistp) 3011 { 3012 char path[PATH_MAX]; 3013 line_t *lp; 3014 3015 for (lp = flistp->head; lp; lp = lp->next) { 3016 /* 3017 * Don't follow symlinks. A symlink must refer to 3018 * a file that would appear in the archive through 3019 * a direct reference. This matches the archive 3020 * construction behavior. 3021 */ 3022 (void) snprintf(path, sizeof (path), "%s%s", root, lp->line); 3023 if (nftw(path, cmpstat, 20, FTW_PHYS) == -1) { 3024 if (is_flag_on(UPDATE_ERROR)) 3025 return (BAM_ERROR); 3026 /* 3027 * Some files may not exist. 3028 * For example: etc/rtc_config on a x86 diskless system 3029 * Emit verbose message only 3030 */ 3031 if (bam_verbose) 3032 bam_print(_("cannot find: %s: %s\n"), 3033 path, strerror(errno)); 3034 } 3035 } 3036 3037 return (BAM_SUCCESS); 3038 } 3039 3040 /* 3041 * Update the timestamp file. 3042 */ 3043 static void 3044 update_timestamp(char *root) 3045 { 3046 char timestamp_path[PATH_MAX]; 3047 3048 /* this path length has already been checked in check_flags_and_files */ 3049 (void) snprintf(timestamp_path, sizeof (timestamp_path), "%s%s", root, 3050 FILE_STAT_TIMESTAMP); 3051 3052 /* 3053 * recreate the timestamp file. Since an outdated or absent timestamp 3054 * file translates in a complete rebuild of the archive cache, notify 3055 * the user of the performance issue. 3056 */ 3057 if (creat(timestamp_path, FILE_STAT_MODE) < 0) { 3058 bam_error(_("failed to open file: %s: %s\n"), timestamp_path, 3059 strerror(errno)); 3060 bam_error(_("failed to update the timestamp file, next" 3061 " archive update may experience reduced performance\n")); 3062 } 3063 } 3064 3065 3066 static void 3067 savenew(char *root) 3068 { 3069 char path[PATH_MAX]; 3070 char path2[PATH_MAX]; 3071 size_t sz; 3072 char *nstat; 3073 int fd, wrote, error; 3074 3075 nstat = NULL; 3076 sz = 0; 3077 error = nvlist_pack(walk_arg.new_nvlp, &nstat, &sz, 3078 NV_ENCODE_XDR, 0); 3079 if (error) { 3080 bam_error(_("failed to pack stat data: %s\n"), 3081 strerror(error)); 3082 return; 3083 } 3084 3085 (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT_TMP); 3086 fd = open(path, O_RDWR|O_CREAT|O_TRUNC, FILE_STAT_MODE); 3087 if (fd == -1) { 3088 bam_error(_("failed to open file: %s: %s\n"), path, 3089 strerror(errno)); 3090 free(nstat); 3091 return; 3092 } 3093 wrote = write(fd, nstat, sz); 3094 if (wrote != sz) { 3095 bam_error(_("write to file failed: %s: %s\n"), path, 3096 strerror(errno)); 3097 (void) close(fd); 3098 free(nstat); 3099 return; 3100 } 3101 (void) close(fd); 3102 free(nstat); 3103 3104 (void) snprintf(path2, sizeof (path2), "%s%s", root, FILE_STAT); 3105 if (rename(path, path2) != 0) { 3106 bam_error(_("rename to file failed: %s: %s\n"), path2, 3107 strerror(errno)); 3108 } 3109 } 3110 3111 #define init_walk_args() bzero(&walk_arg, sizeof (walk_arg)) 3112 3113 static void 3114 clear_walk_args(void) 3115 { 3116 nvlist_free(walk_arg.old_nvlp); 3117 nvlist_free(walk_arg.new_nvlp); 3118 if (walk_arg.sparcfile) 3119 (void) fclose(walk_arg.sparcfile); 3120 walk_arg.old_nvlp = NULL; 3121 walk_arg.new_nvlp = NULL; 3122 walk_arg.sparcfile = NULL; 3123 } 3124 3125 /* 3126 * Returns: 3127 * 0 - no update necessary 3128 * 1 - update required. 3129 * BAM_ERROR (-1) - An error occurred 3130 * 3131 * Special handling for check (-n): 3132 * ================================ 3133 * The check (-n) option produces parseable output. 3134 * To do this, we suppress all stdout messages unrelated 3135 * to out of sync files. 3136 * All stderr messages are still printed though. 3137 * 3138 */ 3139 static int 3140 update_required(char *root) 3141 { 3142 struct stat sb; 3143 char path[PATH_MAX]; 3144 filelist_t flist; 3145 filelist_t *flistp = &flist; 3146 int ret; 3147 3148 flistp->head = flistp->tail = NULL; 3149 3150 if (is_sparc()) 3151 set_flag(IS_SPARC_TARGET); 3152 3153 /* 3154 * Check if cache directories and archives are present 3155 */ 3156 3157 ret = check_flags_and_files(root); 3158 if (ret < 0) 3159 return (BAM_ERROR); 3160 3161 /* 3162 * In certain deployment scenarios, filestat may not 3163 * exist. Do not stop the boot process, but trigger an update 3164 * of the archives (which will recreate filestat.ramdisk). 3165 */ 3166 if (bam_smf_check) { 3167 (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 3168 if (stat(path, &sb) != 0) { 3169 (void) creat(NEED_UPDATE_FILE, 0644); 3170 return (0); 3171 } 3172 } 3173 3174 getoldstat(root); 3175 3176 /* 3177 * Check if the archive contains files that are no longer 3178 * present on the root filesystem. 3179 */ 3180 check4stale(root); 3181 3182 /* 3183 * read list of files 3184 */ 3185 if (read_list(root, flistp) != BAM_SUCCESS) { 3186 clear_walk_args(); 3187 return (BAM_ERROR); 3188 } 3189 3190 assert(flistp->head && flistp->tail); 3191 3192 /* 3193 * At this point either the update is required 3194 * or the decision is pending. In either case 3195 * we need to create new stat nvlist 3196 */ 3197 create_newstat(); 3198 /* 3199 * This walk does 2 things: 3200 * - gets new stat data for every file 3201 * - (optional) compare old and new stat data 3202 */ 3203 ret = walk_list(root, &flist); 3204 3205 /* done with the file list */ 3206 filelist_free(flistp); 3207 3208 /* something went wrong */ 3209 3210 if (ret == BAM_ERROR) { 3211 bam_error(_("Failed to gather cache files, archives " 3212 "generation aborted\n")); 3213 return (BAM_ERROR); 3214 } 3215 3216 if (walk_arg.new_nvlp == NULL) { 3217 if (walk_arg.sparcfile != NULL) 3218 (void) fclose(walk_arg.sparcfile); 3219 bam_error(_("cannot create new stat data\n")); 3220 } 3221 3222 /* If nothing was updated, discard newstat. */ 3223 3224 if (!is_dir_flag_on(NEED_UPDATE)) { 3225 clear_walk_args(); 3226 return (0); 3227 } 3228 3229 if (walk_arg.sparcfile != NULL) 3230 (void) fclose(walk_arg.sparcfile); 3231 3232 return (1); 3233 } 3234 3235 static int 3236 flushfs(char *root) 3237 { 3238 char cmd[PATH_MAX + 30]; 3239 3240 (void) snprintf(cmd, sizeof (cmd), "%s -f \"%s\" 2>/dev/null", 3241 LOCKFS_PATH, root); 3242 3243 return (exec_cmd(cmd, NULL)); 3244 } 3245 3246 static int 3247 do_archive_copy(char *source, char *dest) 3248 { 3249 3250 sync(); 3251 3252 /* the equivalent of mv archive-new-$pid boot_archive */ 3253 if (rename(source, dest) != 0) { 3254 (void) unlink(source); 3255 return (BAM_ERROR); 3256 } 3257 3258 if (flushfs(bam_root) != 0) 3259 sync(); 3260 3261 return (BAM_SUCCESS); 3262 } 3263 3264 static int 3265 check_cmdline(filelist_t flist) 3266 { 3267 line_t *lp; 3268 3269 for (lp = flist.head; lp; lp = lp->next) { 3270 if (strstr(lp->line, "Error:") != NULL || 3271 strstr(lp->line, "Inode number overflow") != NULL) { 3272 (void) fprintf(stderr, "%s\n", lp->line); 3273 return (BAM_ERROR); 3274 } 3275 } 3276 3277 return (BAM_SUCCESS); 3278 } 3279 3280 static void 3281 dump_errormsg(filelist_t flist) 3282 { 3283 line_t *lp; 3284 3285 for (lp = flist.head; lp; lp = lp->next) 3286 (void) fprintf(stderr, "%s\n", lp->line); 3287 } 3288 3289 static int 3290 check_archive(char *dest) 3291 { 3292 struct stat sb; 3293 3294 if (stat(dest, &sb) != 0 || !S_ISREG(sb.st_mode) || 3295 sb.st_size < 10000) { 3296 bam_error(_("archive file %s not generated correctly\n"), dest); 3297 (void) unlink(dest); 3298 return (BAM_ERROR); 3299 } 3300 3301 return (BAM_SUCCESS); 3302 } 3303 3304 static boolean_t 3305 is_be(char *root) 3306 { 3307 zfs_handle_t *zhp; 3308 libzfs_handle_t *hdl; 3309 be_node_list_t *be_nodes = NULL; 3310 be_node_list_t *cur_be; 3311 boolean_t be_exist = B_FALSE; 3312 char ds_path[ZFS_MAX_DATASET_NAME_LEN]; 3313 3314 if (!is_zfs(root)) 3315 return (B_FALSE); 3316 /* 3317 * Get dataset for mountpoint 3318 */ 3319 if ((hdl = libzfs_init()) == NULL) 3320 return (B_FALSE); 3321 3322 if ((zhp = zfs_path_to_zhandle(hdl, root, 3323 ZFS_TYPE_FILESYSTEM)) == NULL) { 3324 libzfs_fini(hdl); 3325 return (B_FALSE); 3326 } 3327 3328 (void) strlcpy(ds_path, zfs_get_name(zhp), sizeof (ds_path)); 3329 3330 /* 3331 * Check if the current dataset is BE 3332 */ 3333 if (be_list(NULL, &be_nodes, BE_LIST_DEFAULT) == BE_SUCCESS) { 3334 for (cur_be = be_nodes; cur_be != NULL; 3335 cur_be = cur_be->be_next_node) { 3336 3337 /* 3338 * Because we guarantee that cur_be->be_root_ds 3339 * is null-terminated by internal data structure, 3340 * we can safely use strcmp() 3341 */ 3342 if (strcmp(ds_path, cur_be->be_root_ds) == 0) { 3343 be_exist = B_TRUE; 3344 break; 3345 } 3346 } 3347 be_free_list(be_nodes); 3348 } 3349 zfs_close(zhp); 3350 libzfs_fini(hdl); 3351 3352 return (be_exist); 3353 } 3354 3355 /* 3356 * Returns B_TRUE if mkiso is in the expected PATH and should be used, 3357 * B_FALSE otherwise 3358 */ 3359 static boolean_t 3360 use_mkisofs() 3361 { 3362 scf_simple_prop_t *prop; 3363 char *format = NULL; 3364 boolean_t ret; 3365 3366 /* Check whether the mkisofs binary is in the expected location */ 3367 if (access(MKISOFS_PATH, X_OK) != 0) { 3368 if (bam_verbose) 3369 bam_print("mkisofs not found\n"); 3370 return (B_FALSE); 3371 } 3372 3373 if (bam_format == BAM_FORMAT_HSFS) { 3374 if (bam_verbose) 3375 bam_print("-F specified HSFS"); 3376 return (B_TRUE); 3377 } 3378 3379 /* If working on an alt-root, do not use HSFS unless asked via -F */ 3380 if (bam_alt_root) 3381 return (B_FALSE); 3382 3383 /* 3384 * Then check that the system/boot-archive config/format property 3385 * is "hsfs" or empty. 3386 */ 3387 if ((prop = scf_simple_prop_get(NULL, BOOT_ARCHIVE_FMRI, SCF_PG_CONFIG, 3388 SCF_PROPERTY_FORMAT)) == NULL) { 3389 /* Could not find property, use mkisofs */ 3390 if (bam_verbose) { 3391 bam_print( 3392 "%s does not have %s/%s property, using mkisofs\n", 3393 BOOT_ARCHIVE_FMRI, SCF_PG_CONFIG, 3394 SCF_PROPERTY_FORMAT); 3395 } 3396 return (B_TRUE); 3397 } 3398 if (scf_simple_prop_numvalues(prop) < 0 || 3399 (format = scf_simple_prop_next_astring(prop)) == NULL) 3400 ret = B_TRUE; 3401 else 3402 ret = strcmp(format, "hsfs") == 0 ? B_TRUE : B_FALSE; 3403 if (bam_verbose) { 3404 if (ret) 3405 bam_print("Creating hsfs boot archive\n"); 3406 else 3407 bam_print("Creating %s boot archive\n", format); 3408 } 3409 scf_simple_prop_free(prop); 3410 return (ret); 3411 } 3412 3413 #define MKISO_PARAMS " -quiet -graft-points -dlrDJN -relaxed-filenames " 3414 3415 static int 3416 create_sparc_archive(char *archive, char *tempname, char *bootblk, char *list) 3417 { 3418 int ret; 3419 char cmdline[3 * PATH_MAX + 64]; 3420 filelist_t flist = {0}; 3421 const char *func = "create_sparc_archive()"; 3422 3423 if (access(bootblk, R_OK) == 1) { 3424 bam_error(_("unable to access bootblk file : %s\n"), bootblk); 3425 return (BAM_ERROR); 3426 } 3427 3428 /* 3429 * Prepare mkisofs command line and execute it 3430 */ 3431 (void) snprintf(cmdline, sizeof (cmdline), "%s %s -G %s -o \"%s\" " 3432 "-path-list \"%s\" 2>&1", MKISOFS_PATH, MKISO_PARAMS, bootblk, 3433 tempname, list); 3434 3435 BAM_DPRINTF(("%s: executing: %s\n", func, cmdline)); 3436 3437 ret = exec_cmd(cmdline, &flist); 3438 if (ret != 0 || check_cmdline(flist) == BAM_ERROR) { 3439 dump_errormsg(flist); 3440 goto out_err; 3441 } 3442 3443 filelist_free(&flist); 3444 3445 /* 3446 * Prepare dd command line to copy the bootblk on the new archive and 3447 * execute it 3448 */ 3449 (void) snprintf(cmdline, sizeof (cmdline), "%s if=\"%s\" of=\"%s\"" 3450 " bs=1b oseek=1 count=15 conv=notrunc conv=sync 2>&1", DD_PATH_USR, 3451 bootblk, tempname); 3452 3453 BAM_DPRINTF(("%s: executing: %s\n", func, cmdline)); 3454 3455 ret = exec_cmd(cmdline, &flist); 3456 if (ret != 0 || check_cmdline(flist) == BAM_ERROR) 3457 goto out_err; 3458 3459 filelist_free(&flist); 3460 3461 /* Did we get a valid archive ? */ 3462 if (check_archive(tempname) == BAM_ERROR) 3463 return (BAM_ERROR); 3464 3465 return (do_archive_copy(tempname, archive)); 3466 3467 out_err: 3468 filelist_free(&flist); 3469 bam_error(_("boot-archive creation FAILED, command: '%s'\n"), cmdline); 3470 (void) unlink(tempname); 3471 return (BAM_ERROR); 3472 } 3473 3474 static unsigned int 3475 from_733(unsigned char *s) 3476 { 3477 int i; 3478 unsigned int ret = 0; 3479 3480 for (i = 0; i < 4; i++) 3481 ret |= s[i] << (8 * i); 3482 3483 return (ret); 3484 } 3485 3486 static void 3487 to_733(unsigned char *s, unsigned int val) 3488 { 3489 int i; 3490 3491 for (i = 0; i < 4; i++) 3492 s[i] = s[7-i] = (val >> (8 * i)) & 0xFF; 3493 } 3494 3495 /* 3496 * creates sha1 hash of archive 3497 */ 3498 static int 3499 digest_archive(const char *archive) 3500 { 3501 char *archive_hash; 3502 char *hash; 3503 int ret; 3504 FILE *fp; 3505 3506 (void) asprintf(&archive_hash, "%s.hash", archive); 3507 if (archive_hash == NULL) 3508 return (BAM_ERROR); 3509 3510 if ((ret = bootadm_digest(archive, &hash)) == BAM_ERROR) { 3511 free(archive_hash); 3512 return (ret); 3513 } 3514 3515 fp = fopen(archive_hash, "w"); 3516 if (fp == NULL) { 3517 free(archive_hash); 3518 free(hash); 3519 return (BAM_ERROR); 3520 } 3521 3522 (void) fprintf(fp, "%s\n", hash); 3523 (void) fclose(fp); 3524 free(hash); 3525 free(archive_hash); 3526 return (BAM_SUCCESS); 3527 } 3528 3529 /* 3530 * Extends the current boot archive without recreating it from scratch 3531 */ 3532 static int 3533 extend_iso_archive(char *archive, char *tempname, char *update_dir) 3534 { 3535 int fd = -1, newfd = -1, ret, i; 3536 int next_session = 0, new_size = 0; 3537 char cmdline[3 * PATH_MAX + 64]; 3538 const char *func = "extend_iso_archive()"; 3539 filelist_t flist = {0}; 3540 struct iso_pdesc saved_desc[MAX_IVDs]; 3541 3542 fd = open(archive, O_RDWR); 3543 if (fd == -1) { 3544 if (bam_verbose) 3545 bam_error(_("failed to open file: %s: %s\n"), 3546 archive, strerror(errno)); 3547 goto out_err; 3548 } 3549 3550 /* 3551 * A partial read is likely due to a corrupted file 3552 */ 3553 ret = pread64(fd, saved_desc, sizeof (saved_desc), 3554 VOLDESC_OFF * CD_BLOCK); 3555 if (ret != sizeof (saved_desc)) { 3556 if (bam_verbose) 3557 bam_error(_("read failed for file: %s: %s\n"), 3558 archive, strerror(errno)); 3559 goto out_err; 3560 } 3561 3562 if (memcmp(saved_desc[0].type, "\1CD001", 6)) { 3563 if (bam_verbose) 3564 bam_error(_("iso descriptor signature for %s is " 3565 "invalid\n"), archive); 3566 goto out_err; 3567 } 3568 3569 /* 3570 * Read primary descriptor and locate next_session offset (it should 3571 * point to the end of the archive) 3572 */ 3573 next_session = P2ROUNDUP(from_733(saved_desc[0].volume_space_size), 16); 3574 3575 (void) snprintf(cmdline, sizeof (cmdline), "%s -C 16,%d -M %s %s -o \"" 3576 "%s\" \"%s\" 2>&1", MKISOFS_PATH, next_session, archive, 3577 MKISO_PARAMS, tempname, update_dir); 3578 3579 BAM_DPRINTF(("%s: executing: %s\n", func, cmdline)); 3580 3581 ret = exec_cmd(cmdline, &flist); 3582 if (ret != 0 || check_cmdline(flist) == BAM_ERROR) { 3583 if (bam_verbose) { 3584 bam_error(_("Command '%s' failed while generating " 3585 "multisession archive\n"), cmdline); 3586 dump_errormsg(flist); 3587 } 3588 goto out_flist_err; 3589 } 3590 filelist_free(&flist); 3591 3592 newfd = open(tempname, O_RDONLY); 3593 if (newfd == -1) { 3594 if (bam_verbose) 3595 bam_error(_("failed to open file: %s: %s\n"), 3596 archive, strerror(errno)); 3597 goto out_err; 3598 } 3599 3600 ret = pread64(newfd, saved_desc, sizeof (saved_desc), 3601 VOLDESC_OFF * CD_BLOCK); 3602 if (ret != sizeof (saved_desc)) { 3603 if (bam_verbose) 3604 bam_error(_("read failed for file: %s: %s\n"), 3605 archive, strerror(errno)); 3606 goto out_err; 3607 } 3608 3609 if (memcmp(saved_desc[0].type, "\1CD001", 6)) { 3610 if (bam_verbose) 3611 bam_error(_("iso descriptor signature for %s is " 3612 "invalid\n"), archive); 3613 goto out_err; 3614 } 3615 3616 new_size = from_733(saved_desc[0].volume_space_size) + next_session; 3617 to_733(saved_desc[0].volume_space_size, new_size); 3618 3619 for (i = 1; i < MAX_IVDs; i++) { 3620 if (saved_desc[i].type[0] == (unsigned char)255) 3621 break; 3622 if (memcmp(saved_desc[i].id, "CD001", 5)) 3623 break; 3624 3625 if (bam_verbose) 3626 bam_print("%s: Updating descriptor entry [%d]\n", func, 3627 i); 3628 3629 to_733(saved_desc[i].volume_space_size, new_size); 3630 } 3631 3632 ret = pwrite64(fd, saved_desc, DVD_BLOCK, VOLDESC_OFF*CD_BLOCK); 3633 if (ret != DVD_BLOCK) { 3634 if (bam_verbose) 3635 bam_error(_("write to file failed: %s: %s\n"), 3636 archive, strerror(errno)); 3637 goto out_err; 3638 } 3639 (void) close(newfd); 3640 newfd = -1; 3641 3642 ret = fsync(fd); 3643 if (ret != 0) 3644 sync(); 3645 3646 ret = close(fd); 3647 if (ret != 0) { 3648 if (bam_verbose) 3649 bam_error(_("failed to close file: %s: %s\n"), 3650 archive, strerror(errno)); 3651 return (BAM_ERROR); 3652 } 3653 fd = -1; 3654 3655 (void) snprintf(cmdline, sizeof (cmdline), "%s if=%s of=%s bs=32k " 3656 "seek=%d conv=sync 2>&1", DD_PATH_USR, tempname, archive, 3657 (next_session/16)); 3658 3659 BAM_DPRINTF(("%s: executing: %s\n", func, cmdline)); 3660 3661 ret = exec_cmd(cmdline, &flist); 3662 if (ret != 0 || check_cmdline(flist) == BAM_ERROR) { 3663 if (bam_verbose) 3664 bam_error(_("Command '%s' failed while generating " 3665 "multisession archive\n"), cmdline); 3666 goto out_flist_err; 3667 } 3668 filelist_free(&flist); 3669 3670 (void) unlink(tempname); 3671 3672 if (digest_archive(archive) == BAM_ERROR && bam_verbose) 3673 bam_print("boot archive hashing failed\n"); 3674 3675 if (flushfs(bam_root) != 0) 3676 sync(); 3677 3678 if (bam_verbose) 3679 bam_print("boot archive updated successfully\n"); 3680 3681 return (BAM_SUCCESS); 3682 3683 out_flist_err: 3684 filelist_free(&flist); 3685 out_err: 3686 if (fd != -1) 3687 (void) close(fd); 3688 if (newfd != -1) 3689 (void) close(newfd); 3690 return (BAM_ERROR); 3691 } 3692 3693 static int 3694 create_x86_archive(char *archive, char *tempname, char *update_dir) 3695 { 3696 int ret; 3697 char cmdline[3 * PATH_MAX + 64]; 3698 filelist_t flist = {0}; 3699 const char *func = "create_x86_archive()"; 3700 3701 (void) snprintf(cmdline, sizeof (cmdline), "%s %s -o \"%s\" \"%s\" " 3702 "2>&1", MKISOFS_PATH, MKISO_PARAMS, tempname, update_dir); 3703 3704 BAM_DPRINTF(("%s: executing: %s\n", func, cmdline)); 3705 3706 ret = exec_cmd(cmdline, &flist); 3707 if (ret != 0 || check_cmdline(flist) == BAM_ERROR) { 3708 bam_error(_("boot-archive creation FAILED, command: '%s'\n"), 3709 cmdline); 3710 dump_errormsg(flist); 3711 filelist_free(&flist); 3712 (void) unlink(tempname); 3713 return (BAM_ERROR); 3714 } 3715 3716 filelist_free(&flist); 3717 3718 if (check_archive(tempname) == BAM_ERROR) 3719 return (BAM_ERROR); 3720 3721 return (do_archive_copy(tempname, archive)); 3722 } 3723 3724 static int 3725 mkisofs_archive(char *root) 3726 { 3727 int ret; 3728 char suffix[20]; 3729 char temp[PATH_MAX]; 3730 char bootblk[PATH_MAX]; 3731 char boot_archive[PATH_MAX]; 3732 3733 ret = snprintf(suffix, sizeof (suffix), "/archive-new-%d", getpid()); 3734 if (ret >= sizeof (suffix)) 3735 goto out_path_err; 3736 3737 ret = build_path(temp, sizeof (temp), root, ARCHIVE_PREFIX, suffix); 3738 3739 if (ret >= sizeof (temp)) 3740 goto out_path_err; 3741 3742 ret = build_path(boot_archive, sizeof (boot_archive), root, 3743 ARCHIVE_PREFIX, ARCHIVE_SUFFIX); 3744 3745 if (ret >= sizeof (boot_archive)) 3746 goto out_path_err; 3747 3748 bam_print("updating %s (HSFS)\n", 3749 boot_archive[1] == '/' ? boot_archive + 1 : boot_archive); 3750 3751 if (is_flag_on(IS_SPARC_TARGET)) { 3752 ret = snprintf(bootblk, sizeof (bootblk), 3753 "%s/platform/%s/lib/fs/hsfs/bootblk", root, get_machine()); 3754 if (ret >= sizeof (bootblk)) 3755 goto out_path_err; 3756 3757 ret = create_sparc_archive(boot_archive, temp, bootblk, 3758 get_cachedir()); 3759 } else { 3760 if (!is_dir_flag_on(NO_EXTEND)) { 3761 if (bam_verbose) 3762 bam_print("Attempting to extend x86 archive: " 3763 "%s\n", boot_archive); 3764 3765 ret = extend_iso_archive(boot_archive, temp, 3766 get_updatedir()); 3767 if (ret == BAM_SUCCESS) { 3768 if (bam_verbose) 3769 bam_print("Successfully extended %s\n", 3770 boot_archive); 3771 3772 (void) rmdir_r(get_updatedir()); 3773 return (BAM_SUCCESS); 3774 } 3775 } 3776 /* 3777 * The boot archive will be recreated from scratch. We get here 3778 * if at least one of these conditions is true: 3779 * - bootadm was called without the -e switch 3780 * - the archive (or the archive cache) doesn't exist 3781 * - archive size is bigger than BA_SIZE_MAX 3782 * - more than COUNT_MAX files need to be updated 3783 * - an error occourred either populating the /updates directory 3784 * or extend_iso_archive() failed 3785 */ 3786 if (bam_verbose) 3787 bam_print("Unable to extend %s... rebuilding archive\n", 3788 boot_archive); 3789 3790 if (get_updatedir()[0] != '\0') 3791 (void) rmdir_r(get_updatedir()); 3792 3793 3794 ret = create_x86_archive(boot_archive, temp, 3795 get_cachedir()); 3796 } 3797 3798 if (digest_archive(boot_archive) == BAM_ERROR && bam_verbose) 3799 bam_print("boot archive hashing failed\n"); 3800 3801 if (ret == BAM_SUCCESS && bam_verbose) 3802 bam_print("Successfully created %s\n", boot_archive); 3803 3804 return (ret); 3805 3806 out_path_err: 3807 bam_error(_("unable to create path on mountpoint %s, path too long\n"), 3808 root); 3809 return (BAM_ERROR); 3810 } 3811 3812 static int 3813 assemble_systemfile(char *infilename, char *outfilename) 3814 { 3815 char buf[BUFSIZ]; 3816 FILE *infile, *outfile; 3817 size_t n; 3818 3819 if ((infile = fopen(infilename, "r")) == NULL) { 3820 bam_error(_("failed to open file: %s: %s\n"), infilename, 3821 strerror(errno)); 3822 return (BAM_ERROR); 3823 } 3824 3825 if ((outfile = fopen(outfilename, "a")) == NULL) { 3826 bam_error(_("failed to open file: %s: %s\n"), outfilename, 3827 strerror(errno)); 3828 (void) fclose(infile); 3829 return (BAM_ERROR); 3830 } 3831 3832 while ((n = fread(buf, 1, sizeof (buf), infile)) > 0) { 3833 if (fwrite(buf, 1, n, outfile) != n) { 3834 bam_error(_("failed to write file: %s: %s\n"), 3835 outfilename, strerror(errno)); 3836 (void) fclose(infile); 3837 (void) fclose(outfile); 3838 return (BAM_ERROR); 3839 } 3840 } 3841 3842 (void) fclose(infile); 3843 (void) fclose(outfile); 3844 3845 return (BAM_SUCCESS); 3846 } 3847 3848 /* 3849 * Concatenate all files (except those starting with a dot) 3850 * from /etc/system.d directory into a single /etc/system.d/.self-assembly 3851 * file. The kernel reads it before /etc/system file. 3852 */ 3853 static error_t 3854 build_etc_system_dir(char *root) 3855 { 3856 struct dirent **filelist; 3857 char path[PATH_MAX], tmpfile[PATH_MAX]; 3858 int i, files, sysfiles = 0; 3859 int ret = BAM_SUCCESS; 3860 struct stat st; 3861 timespec_t times[2]; 3862 3863 (void) snprintf(path, sizeof (path), "%s/%s", root, ETC_SYSTEM_DIR); 3864 (void) snprintf(self_assembly, sizeof (self_assembly), 3865 "%s%s", root, SELF_ASSEMBLY); 3866 (void) snprintf(tmpfile, sizeof (tmpfile), "%s.%ld", 3867 self_assembly, (long)getpid()); 3868 3869 if (stat(self_assembly, &st) >= 0 && (st.st_mode & S_IFMT) == S_IFREG) { 3870 times[0] = times[1] = st.st_mtim; 3871 } else { 3872 times[1].tv_nsec = 0; 3873 } 3874 3875 if ((files = scandir(path, &filelist, NULL, alphasort)) < 0) { 3876 /* Don't fail the update if <ROOT>/etc/system.d doesn't exist */ 3877 if (errno == ENOENT) 3878 return (BAM_SUCCESS); 3879 bam_error(_("can't read %s: %s\n"), path, strerror(errno)); 3880 return (BAM_ERROR); 3881 } 3882 3883 (void) unlink(tmpfile); 3884 3885 for (i = 0; i < files; i++) { 3886 char filepath[PATH_MAX]; 3887 char *fname; 3888 3889 fname = filelist[i]->d_name; 3890 3891 /* skip anything that starts with a dot */ 3892 if (strncmp(fname, ".", 1) == 0) { 3893 free(filelist[i]); 3894 continue; 3895 } 3896 3897 if (bam_verbose) 3898 bam_print(_("/etc/system.d adding %s/%s\n"), 3899 path, fname); 3900 3901 (void) snprintf(filepath, sizeof (filepath), "%s/%s", 3902 path, fname); 3903 3904 if ((assemble_systemfile(filepath, tmpfile)) < 0) { 3905 bam_error(_("failed to append file: %s: %s\n"), 3906 filepath, strerror(errno)); 3907 ret = BAM_ERROR; 3908 break; 3909 } 3910 sysfiles++; 3911 } 3912 3913 if (sysfiles > 0) { 3914 if (rename(tmpfile, self_assembly) < 0) { 3915 bam_error(_("failed to rename file: %s: %s\n"), tmpfile, 3916 strerror(errno)); 3917 return (BAM_ERROR); 3918 } 3919 3920 /* 3921 * Use previous attribute times to avoid 3922 * boot archive recreation. 3923 */ 3924 if (times[1].tv_nsec != 0 && 3925 utimensat(AT_FDCWD, self_assembly, times, 0) != 0) { 3926 bam_error(_("failed to change times: %s\n"), 3927 strerror(errno)); 3928 return (BAM_ERROR); 3929 } 3930 } else { 3931 (void) unlink(tmpfile); 3932 (void) unlink(self_assembly); 3933 } 3934 return (ret); 3935 } 3936 3937 static error_t 3938 create_ramdisk(char *root) 3939 { 3940 char *cmdline, path[PATH_MAX]; 3941 size_t len; 3942 struct stat sb; 3943 int ret, status = BAM_SUCCESS; 3944 3945 /* If mkisofs should be used, use it to create the required archives */ 3946 if (use_mkisofs()) { 3947 if (has_cachedir() && is_dir_flag_on(NEED_UPDATE)) { 3948 ret = mkisofs_archive(root); 3949 if (ret != 0) 3950 status = BAM_ERROR; 3951 } 3952 return (status); 3953 } else if (bam_format == BAM_FORMAT_HSFS) { 3954 bam_error(_("cannot create hsfs archive\n")); 3955 return (BAM_ERROR); 3956 } 3957 3958 /* 3959 * Else setup command args for create_ramdisk.ksh for the archive 3960 * Note: we will not create hash here, CREATE_RAMDISK should create it. 3961 */ 3962 3963 (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 3964 if (stat(path, &sb) != 0) { 3965 bam_error(_("archive creation file not found: %s: %s\n"), 3966 path, strerror(errno)); 3967 return (BAM_ERROR); 3968 } 3969 3970 if (is_safe_exec(path) == BAM_ERROR) 3971 return (BAM_ERROR); 3972 3973 len = strlen(path) + strlen(root) + 10; /* room for space + -R */ 3974 if (bam_alt_platform) 3975 len += strlen(bam_platform) + strlen(" -p "); 3976 if (bam_format != BAM_FORMAT_UNSET) 3977 len += strlen(bam_formats[bam_format]) + strlen(" -f "); 3978 cmdline = s_calloc(1, len); 3979 3980 if (bam_alt_platform) { 3981 assert(strlen(root) > 1); 3982 (void) snprintf(cmdline, len, "%s -p %s -R %s", 3983 path, bam_platform, root); 3984 /* chop off / at the end */ 3985 cmdline[strlen(cmdline) - 1] = '\0'; 3986 } else if (strlen(root) > 1) { 3987 (void) snprintf(cmdline, len, "%s -R %s", path, root); 3988 /* chop off / at the end */ 3989 cmdline[strlen(cmdline) - 1] = '\0'; 3990 } else 3991 (void) snprintf(cmdline, len, "%s", path); 3992 3993 if (bam_format != BAM_FORMAT_UNSET) { 3994 if (strlcat(cmdline, " -f ", len) >= len || 3995 strlcat(cmdline, bam_formats[bam_format], len) >= len) { 3996 bam_error(_("boot-archive command line too long\n")); 3997 free(cmdline); 3998 return (BAM_ERROR); 3999 } 4000 } 4001 4002 if (exec_cmd(cmdline, NULL) != 0) { 4003 bam_error(_("boot-archive creation FAILED, command: '%s'\n"), 4004 cmdline); 4005 free(cmdline); 4006 return (BAM_ERROR); 4007 } 4008 free(cmdline); 4009 /* 4010 * The existence of the expected archives used to be 4011 * verified here. This check is done in create_ramdisk as 4012 * it needs to be in sync with the altroot operated upon. 4013 */ 4014 return (BAM_SUCCESS); 4015 } 4016 4017 /* 4018 * Checks if target filesystem is on a ramdisk 4019 * 1 - is miniroot 4020 * 0 - is not 4021 * When in doubt assume it is not a ramdisk. 4022 */ 4023 static int 4024 is_ramdisk(char *root) 4025 { 4026 struct extmnttab mnt; 4027 FILE *fp; 4028 int found; 4029 char mntpt[PATH_MAX]; 4030 char *cp; 4031 4032 /* 4033 * There are 3 situations where creating archive is 4034 * of dubious value: 4035 * - create boot_archive on a lofi-mounted boot_archive 4036 * - create it on a ramdisk which is the root filesystem 4037 * - create it on a ramdisk mounted somewhere else 4038 * The first is not easy to detect and checking for it is not 4039 * worth it. 4040 * The other two conditions are handled here 4041 */ 4042 fp = fopen(MNTTAB, "r"); 4043 if (fp == NULL) { 4044 bam_error(_("failed to open file: %s: %s\n"), 4045 MNTTAB, strerror(errno)); 4046 return (0); 4047 } 4048 4049 resetmnttab(fp); 4050 4051 /* 4052 * Remove any trailing / from the mount point 4053 */ 4054 (void) strlcpy(mntpt, root, sizeof (mntpt)); 4055 if (strcmp(root, "/") != 0) { 4056 cp = mntpt + strlen(mntpt) - 1; 4057 if (*cp == '/') 4058 *cp = '\0'; 4059 } 4060 found = 0; 4061 while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 4062 if (strcmp(mnt.mnt_mountp, mntpt) == 0) { 4063 found = 1; 4064 break; 4065 } 4066 } 4067 4068 if (!found) { 4069 if (bam_verbose) 4070 bam_error(_("alternate root %s not in mnttab\n"), 4071 mntpt); 4072 (void) fclose(fp); 4073 return (0); 4074 } 4075 4076 if (strncmp(mnt.mnt_special, RAMDISK_SPECIAL, 4077 strlen(RAMDISK_SPECIAL)) == 0) { 4078 if (bam_verbose) 4079 bam_error(_("%s is on a ramdisk device\n"), bam_root); 4080 (void) fclose(fp); 4081 return (1); 4082 } 4083 4084 (void) fclose(fp); 4085 4086 return (0); 4087 } 4088 4089 static int 4090 is_boot_archive(char *root) 4091 { 4092 char path[PATH_MAX]; 4093 struct stat sb; 4094 int error; 4095 const char *fcn = "is_boot_archive()"; 4096 4097 /* 4098 * We can't create an archive without the create_ramdisk script 4099 */ 4100 (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 4101 error = stat(path, &sb); 4102 INJECT_ERROR1("NOT_ARCHIVE_BASED", error = -1); 4103 if (error == -1) { 4104 if (bam_verbose) 4105 bam_print(_("file not found: %s\n"), path); 4106 BAM_DPRINTF(("%s: not a boot archive based Solaris " 4107 "instance: %s\n", fcn, root)); 4108 return (0); 4109 } 4110 4111 BAM_DPRINTF(("%s: *IS* a boot archive based Solaris instance: %s\n", 4112 fcn, root)); 4113 return (1); 4114 } 4115 4116 /* 4117 * Need to call this for anything that operates on the GRUB menu 4118 * In the x86 live upgrade case the directory /boot/grub may be present 4119 * even on pre-newboot BEs. The authoritative way to check for a GRUB target 4120 * is to check for the presence of the stage2 binary which is present 4121 * only on GRUB targets (even on x86 boot partitions). Checking for the 4122 * presence of the multiboot binary is not correct as it is not present 4123 * on x86 boot partitions. 4124 */ 4125 int 4126 is_grub(const char *root) 4127 { 4128 char path[PATH_MAX]; 4129 struct stat sb; 4130 void *defp; 4131 boolean_t grub = B_FALSE; 4132 const char *res = NULL; 4133 const char *fcn = "is_grub()"; 4134 4135 /* grub is disabled by default */ 4136 if ((defp = defopen_r(BE_DEFAULTS)) == NULL) { 4137 return (0); 4138 } else { 4139 res = defread_r(BE_DFLT_BE_HAS_GRUB, defp); 4140 if (res != NULL && res[0] != '\0') { 4141 if (strcasecmp(res, "true") == 0) 4142 grub = B_TRUE; 4143 } 4144 defclose_r(defp); 4145 } 4146 4147 if (grub == B_TRUE) { 4148 (void) snprintf(path, sizeof (path), "%s%s", root, GRUB_STAGE2); 4149 if (stat(path, &sb) == -1) { 4150 BAM_DPRINTF(("%s: Missing GRUB directory: %s\n", 4151 fcn, path)); 4152 return (0); 4153 } else 4154 return (1); 4155 } 4156 4157 return (0); 4158 } 4159 4160 int 4161 is_zfs(char *root) 4162 { 4163 struct statvfs vfs; 4164 int ret; 4165 const char *fcn = "is_zfs()"; 4166 4167 ret = statvfs(root, &vfs); 4168 INJECT_ERROR1("STATVFS_ZFS", ret = 1); 4169 if (ret != 0) { 4170 bam_error(_("statvfs failed for %s: %s\n"), root, 4171 strerror(errno)); 4172 return (0); 4173 } 4174 4175 if (strncmp(vfs.f_basetype, "zfs", strlen("zfs")) == 0) { 4176 BAM_DPRINTF(("%s: is a ZFS filesystem: %s\n", fcn, root)); 4177 return (1); 4178 } else { 4179 BAM_DPRINTF(("%s: is *NOT* a ZFS filesystem: %s\n", fcn, root)); 4180 return (0); 4181 } 4182 } 4183 4184 int 4185 is_pcfs(char *root) 4186 { 4187 struct statvfs vfs; 4188 int ret; 4189 const char *fcn = "is_pcfs()"; 4190 4191 ret = statvfs(root, &vfs); 4192 INJECT_ERROR1("STATVFS_PCFS", ret = 1); 4193 if (ret != 0) { 4194 bam_error(_("statvfs failed for %s: %s\n"), root, 4195 strerror(errno)); 4196 return (0); 4197 } 4198 4199 if (strncmp(vfs.f_basetype, "pcfs", strlen("pcfs")) == 0) { 4200 BAM_DPRINTF(("%s: is a PCFS filesystem: %s\n", fcn, root)); 4201 return (1); 4202 } else { 4203 BAM_DPRINTF(("%s: is *NOT* a PCFS filesystem: %s\n", 4204 fcn, root)); 4205 return (0); 4206 } 4207 } 4208 4209 static int 4210 is_readonly(char *root) 4211 { 4212 int fd; 4213 int error; 4214 char testfile[PATH_MAX]; 4215 const char *fcn = "is_readonly()"; 4216 4217 /* 4218 * Using statvfs() to check for a read-only filesystem is not 4219 * reliable. The only way to reliably test is to attempt to 4220 * create a file 4221 */ 4222 (void) snprintf(testfile, sizeof (testfile), "%s/%s.%d", 4223 root, BOOTADM_RDONLY_TEST, getpid()); 4224 4225 (void) unlink(testfile); 4226 4227 errno = 0; 4228 fd = open(testfile, O_RDWR|O_CREAT|O_EXCL, 0644); 4229 error = errno; 4230 INJECT_ERROR2("RDONLY_TEST_ERROR", fd = -1, error = EACCES); 4231 if (fd == -1 && error == EROFS) { 4232 BAM_DPRINTF(("%s: is a READONLY filesystem: %s\n", fcn, root)); 4233 return (1); 4234 } else if (fd == -1) { 4235 bam_error(_("error during read-only test on %s: %s\n"), 4236 root, strerror(error)); 4237 } 4238 4239 (void) close(fd); 4240 (void) unlink(testfile); 4241 4242 BAM_DPRINTF(("%s: is a RDWR filesystem: %s\n", fcn, root)); 4243 return (0); 4244 } 4245 4246 static error_t 4247 update_archive(char *root, char *opt) 4248 { 4249 error_t ret; 4250 4251 assert(root); 4252 assert(opt == NULL); 4253 4254 init_walk_args(); 4255 (void) umask(022); 4256 4257 /* 4258 * Never update non-BE root in update_all 4259 */ 4260 if (bam_update_all && !is_be(root)) 4261 return (BAM_SUCCESS); 4262 /* 4263 * root must belong to a boot archive based OS, 4264 */ 4265 if (!is_boot_archive(root)) { 4266 /* 4267 * Emit message only if not in context of update_all. 4268 * If in update_all, emit only if verbose flag is set. 4269 */ 4270 if (!bam_update_all || bam_verbose) 4271 bam_print(_("%s: not a boot archive based Solaris " 4272 "instance\n"), root); 4273 return (BAM_ERROR); 4274 } 4275 4276 /* 4277 * If smf check is requested when / is writable (can happen 4278 * on first reboot following an upgrade because service 4279 * dependency is messed up), skip the check. 4280 */ 4281 if (bam_smf_check && !bam_root_readonly && !is_zfs(root)) 4282 return (BAM_SUCCESS); 4283 4284 /* 4285 * Don't generate archive on ramdisk. 4286 */ 4287 if (is_ramdisk(root)) 4288 return (BAM_SUCCESS); 4289 4290 /* 4291 * root must be writable. This check applies to alternate 4292 * root (-R option); bam_root_readonly applies to '/' only. 4293 * The behaviour translates into being the one of a 'check'. 4294 */ 4295 if (!bam_smf_check && !bam_check && is_readonly(root)) { 4296 set_flag(RDONLY_FSCHK); 4297 bam_check = 1; 4298 } 4299 4300 /* 4301 * Process the /etc/system.d/.self-assembly file. 4302 */ 4303 if (build_etc_system_dir(bam_root) == BAM_ERROR) 4304 return (BAM_ERROR); 4305 4306 /* 4307 * Now check if an update is really needed. 4308 */ 4309 ret = update_required(root); 4310 4311 /* 4312 * The check command (-n) is *not* a dry run. 4313 * It only checks if the archive is in sync. 4314 * A readonly filesystem has to be considered an error only if an update 4315 * is required. 4316 */ 4317 if (bam_nowrite()) { 4318 if (is_flag_on(RDONLY_FSCHK)) { 4319 bam_check = bam_saved_check; 4320 if (ret > 0) 4321 bam_error(_("%s filesystem is read-only, " 4322 "skipping archives update\n"), root); 4323 if (bam_update_all) 4324 return ((ret != 0) ? BAM_ERROR : BAM_SUCCESS); 4325 } 4326 4327 bam_exit((ret != 0) ? 1 : 0); 4328 } 4329 4330 if (ret == 1) { 4331 /* create the ramdisk */ 4332 ret = create_ramdisk(root); 4333 } 4334 4335 /* 4336 * if the archive is updated, save the new stat data and update the 4337 * timestamp file 4338 */ 4339 if (ret == 0 && walk_arg.new_nvlp != NULL) { 4340 savenew(root); 4341 update_timestamp(root); 4342 } 4343 4344 clear_walk_args(); 4345 4346 return (ret); 4347 } 4348 4349 static char * 4350 find_root_pool() 4351 { 4352 char *special = get_special("/"); 4353 char *p; 4354 4355 if (special == NULL) 4356 return (NULL); 4357 4358 if (*special == '/') { 4359 free(special); 4360 return (NULL); 4361 } 4362 4363 if ((p = strchr(special, '/')) != NULL) 4364 *p = '\0'; 4365 4366 return (special); 4367 } 4368 4369 static error_t 4370 synchronize_BE_menu(void) 4371 { 4372 struct stat sb; 4373 char cmdline[PATH_MAX]; 4374 char cksum_line[PATH_MAX]; 4375 filelist_t flist = {0}; 4376 char *old_cksum_str; 4377 char *old_size_str; 4378 char *old_file; 4379 char *curr_cksum_str; 4380 char *curr_size_str; 4381 char *curr_file; 4382 char *pool = NULL; 4383 char *mntpt = NULL; 4384 zfs_mnted_t mnted; 4385 FILE *cfp; 4386 int found; 4387 int ret; 4388 const char *fcn = "synchronize_BE_menu()"; 4389 4390 BAM_DPRINTF(("%s: entered. No args\n", fcn)); 4391 4392 /* Check if findroot enabled LU BE */ 4393 if (stat(FINDROOT_INSTALLGRUB, &sb) != 0) { 4394 BAM_DPRINTF(("%s: not a Live Upgrade BE\n", fcn)); 4395 return (BAM_SUCCESS); 4396 } 4397 4398 if (stat(LU_MENU_CKSUM, &sb) != 0) { 4399 BAM_DPRINTF(("%s: checksum file absent: %s\n", 4400 fcn, LU_MENU_CKSUM)); 4401 goto menu_sync; 4402 } 4403 4404 cfp = fopen(LU_MENU_CKSUM, "r"); 4405 INJECT_ERROR1("CKSUM_FILE_MISSING", cfp = NULL); 4406 if (cfp == NULL) { 4407 bam_error(_("failed to read GRUB menu checksum file: %s\n"), 4408 LU_MENU_CKSUM); 4409 goto menu_sync; 4410 } 4411 BAM_DPRINTF(("%s: opened checksum file: %s\n", fcn, LU_MENU_CKSUM)); 4412 4413 found = 0; 4414 while (s_fgets(cksum_line, sizeof (cksum_line), cfp) != NULL) { 4415 INJECT_ERROR1("MULTIPLE_CKSUM", found = 1); 4416 if (found) { 4417 bam_error(_("multiple checksums for GRUB menu in " 4418 "checksum file: %s\n"), LU_MENU_CKSUM); 4419 (void) fclose(cfp); 4420 goto menu_sync; 4421 } 4422 found = 1; 4423 } 4424 BAM_DPRINTF(("%s: read checksum file: %s\n", fcn, LU_MENU_CKSUM)); 4425 4426 4427 old_cksum_str = strtok(cksum_line, " \t"); 4428 old_size_str = strtok(NULL, " \t"); 4429 old_file = strtok(NULL, " \t"); 4430 4431 INJECT_ERROR1("OLD_CKSUM_NULL", old_cksum_str = NULL); 4432 INJECT_ERROR1("OLD_SIZE_NULL", old_size_str = NULL); 4433 INJECT_ERROR1("OLD_FILE_NULL", old_file = NULL); 4434 if (old_cksum_str == NULL || old_size_str == NULL || old_file == NULL) { 4435 bam_error(_("error parsing GRUB menu checksum file: %s\n"), 4436 LU_MENU_CKSUM); 4437 goto menu_sync; 4438 } 4439 BAM_DPRINTF(("%s: parsed checksum file: %s\n", fcn, LU_MENU_CKSUM)); 4440 4441 /* Get checksum of current menu */ 4442 pool = find_root_pool(); 4443 if (pool) { 4444 mntpt = mount_top_dataset(pool, &mnted); 4445 if (mntpt == NULL) { 4446 bam_error(_("failed to mount top dataset for %s\n"), 4447 pool); 4448 free(pool); 4449 return (BAM_ERROR); 4450 } 4451 (void) snprintf(cmdline, sizeof (cmdline), "%s %s%s", 4452 CKSUM, mntpt, GRUB_MENU); 4453 } else { 4454 (void) snprintf(cmdline, sizeof (cmdline), "%s %s", 4455 CKSUM, GRUB_MENU); 4456 } 4457 ret = exec_cmd(cmdline, &flist); 4458 if (pool) { 4459 (void) umount_top_dataset(pool, mnted, mntpt); 4460 free(pool); 4461 } 4462 INJECT_ERROR1("GET_CURR_CKSUM", ret = 1); 4463 if (ret != 0) { 4464 bam_error(_("error generating checksum of GRUB menu\n")); 4465 return (BAM_ERROR); 4466 } 4467 BAM_DPRINTF(("%s: successfully generated checksum\n", fcn)); 4468 4469 INJECT_ERROR1("GET_CURR_CKSUM_OUTPUT", flist.head = NULL); 4470 if ((flist.head == NULL) || (flist.head != flist.tail)) { 4471 bam_error(_("bad checksum generated for GRUB menu\n")); 4472 filelist_free(&flist); 4473 return (BAM_ERROR); 4474 } 4475 BAM_DPRINTF(("%s: generated checksum output valid\n", fcn)); 4476 4477 curr_cksum_str = strtok(flist.head->line, " \t"); 4478 curr_size_str = strtok(NULL, " \t"); 4479 curr_file = strtok(NULL, " \t"); 4480 4481 INJECT_ERROR1("CURR_CKSUM_NULL", curr_cksum_str = NULL); 4482 INJECT_ERROR1("CURR_SIZE_NULL", curr_size_str = NULL); 4483 INJECT_ERROR1("CURR_FILE_NULL", curr_file = NULL); 4484 if (curr_cksum_str == NULL || curr_size_str == NULL || 4485 curr_file == NULL) { 4486 bam_error(_("error parsing checksum generated " 4487 "for GRUB menu\n")); 4488 filelist_free(&flist); 4489 return (BAM_ERROR); 4490 } 4491 BAM_DPRINTF(("%s: successfully parsed generated checksum\n", fcn)); 4492 4493 if (strcmp(old_cksum_str, curr_cksum_str) == 0 && 4494 strcmp(old_size_str, curr_size_str) == 0 && 4495 strcmp(old_file, curr_file) == 0) { 4496 filelist_free(&flist); 4497 BAM_DPRINTF(("%s: no change in checksum of GRUB menu\n", fcn)); 4498 return (BAM_SUCCESS); 4499 } 4500 4501 filelist_free(&flist); 4502 4503 /* cksum doesn't match - the menu has changed */ 4504 BAM_DPRINTF(("%s: checksum of GRUB menu has changed\n", fcn)); 4505 4506 menu_sync: 4507 bam_print(_("propagating updated GRUB menu\n")); 4508 4509 (void) snprintf(cmdline, sizeof (cmdline), 4510 "/bin/sh -c '. %s > /dev/null; %s %s yes > /dev/null'", 4511 LULIB, LULIB_PROPAGATE_FILE, GRUB_MENU); 4512 ret = exec_cmd(cmdline, NULL); 4513 INJECT_ERROR1("PROPAGATE_MENU", ret = 1); 4514 if (ret != 0) { 4515 bam_error(_("error propagating updated GRUB menu\n")); 4516 return (BAM_ERROR); 4517 } 4518 BAM_DPRINTF(("%s: successfully propagated GRUB menu\n", fcn)); 4519 4520 (void) snprintf(cmdline, sizeof (cmdline), "/bin/cp %s %s > /dev/null", 4521 GRUB_MENU, GRUB_BACKUP_MENU); 4522 ret = exec_cmd(cmdline, NULL); 4523 INJECT_ERROR1("CREATE_BACKUP", ret = 1); 4524 if (ret != 0) { 4525 bam_error(_("failed to create backup for GRUB menu: %s\n"), 4526 GRUB_BACKUP_MENU); 4527 return (BAM_ERROR); 4528 } 4529 BAM_DPRINTF(("%s: successfully created backup GRUB menu: %s\n", 4530 fcn, GRUB_BACKUP_MENU)); 4531 4532 (void) snprintf(cmdline, sizeof (cmdline), 4533 "/bin/sh -c '. %s > /dev/null; %s %s no > /dev/null'", 4534 LULIB, LULIB_PROPAGATE_FILE, GRUB_BACKUP_MENU); 4535 ret = exec_cmd(cmdline, NULL); 4536 INJECT_ERROR1("PROPAGATE_BACKUP", ret = 1); 4537 if (ret != 0) { 4538 bam_error(_("error propagating backup GRUB menu: %s\n"), 4539 GRUB_BACKUP_MENU); 4540 return (BAM_ERROR); 4541 } 4542 BAM_DPRINTF(("%s: successfully propagated backup GRUB menu: %s\n", 4543 fcn, GRUB_BACKUP_MENU)); 4544 4545 (void) snprintf(cmdline, sizeof (cmdline), "%s %s > %s", 4546 CKSUM, GRUB_MENU, LU_MENU_CKSUM); 4547 ret = exec_cmd(cmdline, NULL); 4548 INJECT_ERROR1("CREATE_CKSUM_FILE", ret = 1); 4549 if (ret != 0) { 4550 bam_error(_("failed to write GRUB menu checksum file: %s\n"), 4551 LU_MENU_CKSUM); 4552 return (BAM_ERROR); 4553 } 4554 BAM_DPRINTF(("%s: successfully created checksum file: %s\n", 4555 fcn, LU_MENU_CKSUM)); 4556 4557 (void) snprintf(cmdline, sizeof (cmdline), 4558 "/bin/sh -c '. %s > /dev/null; %s %s no > /dev/null'", 4559 LULIB, LULIB_PROPAGATE_FILE, LU_MENU_CKSUM); 4560 ret = exec_cmd(cmdline, NULL); 4561 INJECT_ERROR1("PROPAGATE_MENU_CKSUM_FILE", ret = 1); 4562 if (ret != 0) { 4563 bam_error(_("error propagating GRUB menu checksum file: %s\n"), 4564 LU_MENU_CKSUM); 4565 return (BAM_ERROR); 4566 } 4567 BAM_DPRINTF(("%s: successfully propagated checksum file: %s\n", 4568 fcn, LU_MENU_CKSUM)); 4569 4570 return (BAM_SUCCESS); 4571 } 4572 4573 static error_t 4574 update_all(char *root, char *opt) 4575 { 4576 struct extmnttab mnt; 4577 struct stat sb; 4578 FILE *fp; 4579 char multibt[PATH_MAX]; 4580 char creatram[PATH_MAX]; 4581 error_t ret = BAM_SUCCESS; 4582 4583 assert(root); 4584 assert(opt == NULL); 4585 4586 if (bam_rootlen != 1 || *root != '/') { 4587 elide_trailing_slash(root, multibt, sizeof (multibt)); 4588 bam_error(_("an alternate root (%s) cannot be used with this " 4589 "sub-command\n"), multibt); 4590 return (BAM_ERROR); 4591 } 4592 4593 /* 4594 * First update archive for current root 4595 */ 4596 if (update_archive(root, opt) != BAM_SUCCESS) 4597 ret = BAM_ERROR; 4598 4599 if (ret == BAM_ERROR) 4600 goto out; 4601 4602 /* 4603 * Now walk the mount table, performing archive update 4604 * for all mounted Newboot root filesystems 4605 */ 4606 fp = fopen(MNTTAB, "r"); 4607 if (fp == NULL) { 4608 bam_error(_("failed to open file: %s: %s\n"), 4609 MNTTAB, strerror(errno)); 4610 ret = BAM_ERROR; 4611 goto out; 4612 } 4613 4614 resetmnttab(fp); 4615 4616 while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 4617 if (mnt.mnt_special == NULL) 4618 continue; 4619 if ((strcmp(mnt.mnt_fstype, MNTTYPE_ZFS) != 0) && 4620 (strncmp(mnt.mnt_special, "/dev/", strlen("/dev/")) != 0)) 4621 continue; 4622 if (strcmp(mnt.mnt_mountp, "/") == 0) 4623 continue; 4624 4625 (void) snprintf(creatram, sizeof (creatram), "%s/%s", 4626 mnt.mnt_mountp, CREATE_RAMDISK); 4627 4628 if (stat(creatram, &sb) == -1) 4629 continue; 4630 4631 /* 4632 * We put a trailing slash to be consistent with root = "/" 4633 * case, such that we don't have to print // in some cases. 4634 */ 4635 (void) snprintf(rootbuf, sizeof (rootbuf), "%s/", 4636 mnt.mnt_mountp); 4637 bam_rootlen = strlen(rootbuf); 4638 4639 /* 4640 * It's possible that other mounts may be an alternate boot 4641 * architecture, so check it again. 4642 */ 4643 if ((get_boot_cap(rootbuf) != BAM_SUCCESS) || 4644 (update_archive(rootbuf, opt) != BAM_SUCCESS)) 4645 ret = BAM_ERROR; 4646 } 4647 4648 (void) fclose(fp); 4649 4650 out: 4651 /* 4652 * We no longer use biosdev for Live Upgrade. Hence 4653 * there is no need to defer (to shutdown time) any fdisk 4654 * updates 4655 */ 4656 if (stat(GRUB_fdisk, &sb) == 0 || stat(GRUB_fdisk_target, &sb) == 0) { 4657 bam_error(_("Deferred FDISK update file(s) found: %s, %s. " 4658 "Not supported.\n"), GRUB_fdisk, GRUB_fdisk_target); 4659 } 4660 4661 /* 4662 * If user has updated menu in current BE, propagate the 4663 * updates to all BEs. 4664 */ 4665 if (sync_menu && synchronize_BE_menu() != BAM_SUCCESS) 4666 ret = BAM_ERROR; 4667 4668 return (ret); 4669 } 4670 4671 static void 4672 append_line(menu_t *mp, line_t *lp) 4673 { 4674 if (mp->start == NULL) { 4675 mp->start = lp; 4676 } else { 4677 mp->end->next = lp; 4678 lp->prev = mp->end; 4679 } 4680 mp->end = lp; 4681 } 4682 4683 void 4684 unlink_line(menu_t *mp, line_t *lp) 4685 { 4686 /* unlink from list */ 4687 if (lp->prev) 4688 lp->prev->next = lp->next; 4689 else 4690 mp->start = lp->next; 4691 if (lp->next) 4692 lp->next->prev = lp->prev; 4693 else 4694 mp->end = lp->prev; 4695 } 4696 4697 static entry_t * 4698 boot_entry_new(menu_t *mp, line_t *start, line_t *end) 4699 { 4700 entry_t *ent, *prev; 4701 const char *fcn = "boot_entry_new()"; 4702 4703 assert(mp); 4704 assert(start); 4705 assert(end); 4706 4707 ent = s_calloc(1, sizeof (entry_t)); 4708 BAM_DPRINTF(("%s: new boot entry alloced\n", fcn)); 4709 ent->start = start; 4710 ent->end = end; 4711 4712 if (mp->entries == NULL) { 4713 mp->entries = ent; 4714 BAM_DPRINTF(("%s: (first) new boot entry created\n", fcn)); 4715 return (ent); 4716 } 4717 4718 prev = mp->entries; 4719 while (prev->next) 4720 prev = prev->next; 4721 prev->next = ent; 4722 ent->prev = prev; 4723 BAM_DPRINTF(("%s: new boot entry linked in\n", fcn)); 4724 return (ent); 4725 } 4726 4727 static void 4728 boot_entry_addline(entry_t *ent, line_t *lp) 4729 { 4730 if (ent) 4731 ent->end = lp; 4732 } 4733 4734 /* 4735 * Check whether cmd matches the one indexed by which, and whether arg matches 4736 * str. which must be either KERNEL_CMD or MODULE_CMD, and a match to the 4737 * respective *_DOLLAR_CMD is also acceptable. The arg is searched using 4738 * strstr(), so it can be a partial match. 4739 */ 4740 static int 4741 check_cmd(const char *cmd, const int which, const char *arg, const char *str) 4742 { 4743 int ret; 4744 const char *fcn = "check_cmd()"; 4745 4746 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, arg, str)); 4747 4748 if (cmd != NULL) { 4749 if ((strcmp(cmd, menu_cmds[which]) != 0) && 4750 (strcmp(cmd, menu_cmds[which + 1]) != 0)) { 4751 BAM_DPRINTF(("%s: command %s does not match %s\n", 4752 fcn, cmd, menu_cmds[which])); 4753 return (0); 4754 } 4755 ret = (strstr(arg, str) != NULL); 4756 } else 4757 ret = 0; 4758 4759 if (ret) { 4760 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 4761 } else { 4762 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 4763 } 4764 4765 return (ret); 4766 } 4767 4768 static error_t 4769 kernel_parser(entry_t *entry, char *cmd, char *arg, int linenum) 4770 { 4771 const char *fcn = "kernel_parser()"; 4772 4773 assert(entry); 4774 assert(cmd); 4775 assert(arg); 4776 4777 if (strcmp(cmd, menu_cmds[KERNEL_CMD]) != 0 && 4778 strcmp(cmd, menu_cmds[KERNEL_DOLLAR_CMD]) != 0) { 4779 BAM_DPRINTF(("%s: not a kernel command: %s\n", fcn, cmd)); 4780 return (BAM_ERROR); 4781 } 4782 4783 if (strncmp(arg, DIRECT_BOOT_32, sizeof (DIRECT_BOOT_32) - 1) == 0) { 4784 BAM_DPRINTF(("%s: setting DBOOT|DBOOT_32 flag: %s\n", 4785 fcn, arg)); 4786 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_32BIT; 4787 } else if (strncmp(arg, DIRECT_BOOT_KERNEL, 4788 sizeof (DIRECT_BOOT_KERNEL) - 1) == 0) { 4789 BAM_DPRINTF(("%s: setting DBOOT flag: %s\n", fcn, arg)); 4790 entry->flags |= BAM_ENTRY_DBOOT; 4791 } else if (strncmp(arg, DIRECT_BOOT_64, 4792 sizeof (DIRECT_BOOT_64) - 1) == 0) { 4793 BAM_DPRINTF(("%s: setting DBOOT|DBOOT_64 flag: %s\n", 4794 fcn, arg)); 4795 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_64BIT; 4796 } else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_KERNEL, 4797 sizeof (DIRECT_BOOT_FAILSAFE_KERNEL) - 1) == 0) { 4798 BAM_DPRINTF(("%s: setting DBOOT|DBOOT_FAILSAFE flag: %s\n", 4799 fcn, arg)); 4800 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE; 4801 } else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_32, 4802 sizeof (DIRECT_BOOT_FAILSAFE_32) - 1) == 0) { 4803 BAM_DPRINTF(("%s: setting DBOOT|DBOOT_FAILSAFE|DBOOT_32 " 4804 "flag: %s\n", fcn, arg)); 4805 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE 4806 | BAM_ENTRY_32BIT; 4807 } else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_64, 4808 sizeof (DIRECT_BOOT_FAILSAFE_64) - 1) == 0) { 4809 BAM_DPRINTF(("%s: setting DBOOT|DBOOT_FAILSAFE|DBOOT_64 " 4810 "flag: %s\n", fcn, arg)); 4811 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE 4812 | BAM_ENTRY_64BIT; 4813 } else if (strncmp(arg, MULTI_BOOT, sizeof (MULTI_BOOT) - 1) == 0) { 4814 BAM_DPRINTF(("%s: setting MULTIBOOT flag: %s\n", fcn, arg)); 4815 entry->flags |= BAM_ENTRY_MULTIBOOT; 4816 } else if (strncmp(arg, MULTI_BOOT_FAILSAFE, 4817 sizeof (MULTI_BOOT_FAILSAFE) - 1) == 0) { 4818 BAM_DPRINTF(("%s: setting MULTIBOOT|MULTIBOOT_FAILSAFE " 4819 "flag: %s\n", fcn, arg)); 4820 entry->flags |= BAM_ENTRY_MULTIBOOT | BAM_ENTRY_FAILSAFE; 4821 } else if (strstr(arg, XEN_KERNEL_SUBSTR)) { 4822 BAM_DPRINTF(("%s: setting XEN HV flag: %s\n", fcn, arg)); 4823 entry->flags |= BAM_ENTRY_HV; 4824 } else if (!(entry->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU))) { 4825 BAM_DPRINTF(("%s: is HAND kernel flag: %s\n", fcn, arg)); 4826 return (BAM_ERROR); 4827 } else if (strncmp(arg, KERNEL_PREFIX, strlen(KERNEL_PREFIX)) == 0 && 4828 strstr(arg, UNIX_SPACE)) { 4829 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_32BIT; 4830 } else if (strncmp(arg, KERNEL_PREFIX, strlen(KERNEL_PREFIX)) == 0 && 4831 strstr(arg, AMD_UNIX_SPACE)) { 4832 entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_64BIT; 4833 } else { 4834 BAM_DPRINTF(("%s: is UNKNOWN kernel entry: %s\n", fcn, arg)); 4835 bam_error(_("kernel command on line %d not recognized.\n"), 4836 linenum); 4837 return (BAM_ERROR); 4838 } 4839 4840 return (BAM_SUCCESS); 4841 } 4842 4843 static error_t 4844 module_parser(entry_t *entry, char *cmd, char *arg, int linenum) 4845 { 4846 const char *fcn = "module_parser()"; 4847 4848 assert(entry); 4849 assert(cmd); 4850 assert(arg); 4851 4852 if (strcmp(cmd, menu_cmds[MODULE_CMD]) != 0 && 4853 strcmp(cmd, menu_cmds[MODULE_DOLLAR_CMD]) != 0) { 4854 BAM_DPRINTF(("%s: not module cmd: %s\n", fcn, cmd)); 4855 return (BAM_ERROR); 4856 } 4857 4858 if (strcmp(arg, DIRECT_BOOT_ARCHIVE) == 0 || 4859 strcmp(arg, DIRECT_BOOT_ARCHIVE_32) == 0 || 4860 strcmp(arg, DIRECT_BOOT_ARCHIVE_64) == 0 || 4861 strcmp(arg, MULTIBOOT_ARCHIVE) == 0 || 4862 strcmp(arg, FAILSAFE_ARCHIVE) == 0 || 4863 strcmp(arg, FAILSAFE_ARCHIVE_32) == 0 || 4864 strcmp(arg, FAILSAFE_ARCHIVE_64) == 0 || 4865 strcmp(arg, XEN_KERNEL_MODULE_LINE) == 0 || 4866 strcmp(arg, XEN_KERNEL_MODULE_LINE_ZFS) == 0) { 4867 BAM_DPRINTF(("%s: bootadm or LU module cmd: %s\n", fcn, arg)); 4868 return (BAM_SUCCESS); 4869 } else if (!(entry->flags & BAM_ENTRY_BOOTADM) && 4870 !(entry->flags & BAM_ENTRY_LU)) { 4871 /* don't emit warning for hand entries */ 4872 BAM_DPRINTF(("%s: is HAND module: %s\n", fcn, arg)); 4873 return (BAM_ERROR); 4874 } else { 4875 BAM_DPRINTF(("%s: is UNKNOWN module: %s\n", fcn, arg)); 4876 bam_error(_("module command on line %d not recognized.\n"), 4877 linenum); 4878 return (BAM_ERROR); 4879 } 4880 } 4881 4882 /* 4883 * A line in menu.lst looks like 4884 * [ ]*<cmd>[ \t=]*<arg>* 4885 */ 4886 static void 4887 line_parser(menu_t *mp, char *str, int *lineNum, int *entryNum) 4888 { 4889 /* 4890 * save state across calls. This is so that 4891 * header gets the right entry# after title has 4892 * been processed 4893 */ 4894 static line_t *prev = NULL; 4895 static entry_t *curr_ent = NULL; 4896 static int in_liveupgrade = 0; 4897 static int is_libbe_ent = 0; 4898 4899 line_t *lp; 4900 char *cmd, *sep, *arg; 4901 char save, *cp, *line; 4902 menu_flag_t flag = BAM_INVALID; 4903 const char *fcn = "line_parser()"; 4904 4905 cmd = NULL; 4906 if (str == NULL) { 4907 return; 4908 } 4909 4910 /* 4911 * First save a copy of the entire line. 4912 * We use this later to set the line field. 4913 */ 4914 line = s_strdup(str); 4915 4916 /* Eat up leading whitespace */ 4917 while (*str == ' ' || *str == '\t') 4918 str++; 4919 4920 if (*str == '#') { /* comment */ 4921 cmd = s_strdup("#"); 4922 sep = NULL; 4923 arg = s_strdup(str + 1); 4924 flag = BAM_COMMENT; 4925 if (strstr(arg, BAM_LU_HDR) != NULL) { 4926 in_liveupgrade = 1; 4927 } else if (strstr(arg, BAM_LU_FTR) != NULL) { 4928 in_liveupgrade = 0; 4929 } else if (strstr(arg, BAM_LIBBE_FTR) != NULL) { 4930 is_libbe_ent = 1; 4931 } 4932 } else if (*str == '\0') { /* blank line */ 4933 cmd = sep = arg = NULL; 4934 flag = BAM_EMPTY; 4935 } else { 4936 /* 4937 * '=' is not a documented separator in grub syntax. 4938 * However various development bits use '=' as a 4939 * separator. In addition, external users also 4940 * use = as a separator. So we will allow that usage. 4941 */ 4942 cp = str; 4943 while (*str != ' ' && *str != '\t' && *str != '=') { 4944 if (*str == '\0') { 4945 cmd = s_strdup(cp); 4946 sep = arg = NULL; 4947 break; 4948 } 4949 str++; 4950 } 4951 4952 if (*str != '\0') { 4953 save = *str; 4954 *str = '\0'; 4955 cmd = s_strdup(cp); 4956 *str = save; 4957 4958 str++; 4959 save = *str; 4960 *str = '\0'; 4961 sep = s_strdup(str - 1); 4962 *str = save; 4963 4964 while (*str == ' ' || *str == '\t') 4965 str++; 4966 if (*str == '\0') 4967 arg = NULL; 4968 else 4969 arg = s_strdup(str); 4970 } 4971 } 4972 4973 lp = s_calloc(1, sizeof (line_t)); 4974 4975 lp->cmd = cmd; 4976 lp->sep = sep; 4977 lp->arg = arg; 4978 lp->line = line; 4979 lp->lineNum = ++(*lineNum); 4980 if (cmd && strcmp(cmd, menu_cmds[TITLE_CMD]) == 0) { 4981 lp->entryNum = ++(*entryNum); 4982 lp->flags = BAM_TITLE; 4983 if (prev && prev->flags == BAM_COMMENT && 4984 prev->arg && strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 4985 prev->entryNum = lp->entryNum; 4986 curr_ent = boot_entry_new(mp, prev, lp); 4987 curr_ent->flags |= BAM_ENTRY_BOOTADM; 4988 BAM_DPRINTF(("%s: is bootadm(1M) entry: %s\n", 4989 fcn, arg)); 4990 } else { 4991 curr_ent = boot_entry_new(mp, lp, lp); 4992 if (in_liveupgrade) { 4993 curr_ent->flags |= BAM_ENTRY_LU; 4994 BAM_DPRINTF(("%s: is LU entry: %s\n", 4995 fcn, arg)); 4996 } 4997 } 4998 curr_ent->entryNum = *entryNum; 4999 } else if (flag != BAM_INVALID) { 5000 /* 5001 * For header comments, the entry# is "fixed up" 5002 * by the subsequent title 5003 */ 5004 lp->entryNum = *entryNum; 5005 lp->flags = flag; 5006 } else { 5007 lp->entryNum = *entryNum; 5008 5009 if (*entryNum == ENTRY_INIT) { 5010 lp->flags = BAM_GLOBAL; 5011 } else { 5012 lp->flags = BAM_ENTRY; 5013 5014 if (cmd && arg) { 5015 if (strcmp(cmd, menu_cmds[ROOT_CMD]) == 0) { 5016 BAM_DPRINTF(("%s: setting ROOT: %s\n", 5017 fcn, arg)); 5018 curr_ent->flags |= BAM_ENTRY_ROOT; 5019 } else if (strcmp(cmd, menu_cmds[FINDROOT_CMD]) 5020 == 0) { 5021 BAM_DPRINTF(("%s: setting " 5022 "FINDROOT: %s\n", fcn, arg)); 5023 curr_ent->flags |= BAM_ENTRY_FINDROOT; 5024 } else if (strcmp(cmd, 5025 menu_cmds[CHAINLOADER_CMD]) == 0) { 5026 BAM_DPRINTF(("%s: setting " 5027 "CHAINLOADER: %s\n", fcn, arg)); 5028 curr_ent->flags |= 5029 BAM_ENTRY_CHAINLOADER; 5030 } else if (kernel_parser(curr_ent, cmd, arg, 5031 lp->lineNum) != BAM_SUCCESS) { 5032 (void) module_parser(curr_ent, cmd, 5033 arg, lp->lineNum); 5034 } 5035 } 5036 } 5037 } 5038 5039 /* record default, old default, and entry line ranges */ 5040 if (lp->flags == BAM_GLOBAL && lp->cmd != NULL && 5041 strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0) { 5042 mp->curdefault = lp; 5043 } else if (lp->flags == BAM_COMMENT && 5044 strncmp(lp->arg, BAM_OLDDEF, strlen(BAM_OLDDEF)) == 0) { 5045 mp->olddefault = lp; 5046 } else if (lp->flags == BAM_COMMENT && 5047 strncmp(lp->arg, BAM_OLD_RC_DEF, strlen(BAM_OLD_RC_DEF)) == 0) { 5048 mp->old_rc_default = lp; 5049 } else if (lp->flags == BAM_ENTRY || 5050 (lp->flags == BAM_COMMENT && 5051 ((strcmp(lp->arg, BAM_BOOTADM_FTR) == 0) || is_libbe_ent))) { 5052 if (is_libbe_ent) { 5053 curr_ent->flags |= BAM_ENTRY_LIBBE; 5054 is_libbe_ent = 0; 5055 } 5056 5057 boot_entry_addline(curr_ent, lp); 5058 } 5059 append_line(mp, lp); 5060 5061 prev = lp; 5062 } 5063 5064 void 5065 update_numbering(menu_t *mp) 5066 { 5067 int lineNum; 5068 int entryNum; 5069 int old_default_value; 5070 line_t *lp, *prev, *default_lp, *default_entry; 5071 char buf[PATH_MAX]; 5072 5073 if (mp->start == NULL) { 5074 return; 5075 } 5076 5077 lineNum = LINE_INIT; 5078 entryNum = ENTRY_INIT; 5079 old_default_value = ENTRY_INIT; 5080 lp = default_lp = default_entry = NULL; 5081 5082 prev = NULL; 5083 for (lp = mp->start; lp; prev = lp, lp = lp->next) { 5084 lp->lineNum = ++lineNum; 5085 5086 /* 5087 * Get the value of the default command 5088 */ 5089 if (lp->entryNum == ENTRY_INIT && lp->cmd != NULL && 5090 strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0 && 5091 lp->arg) { 5092 old_default_value = atoi(lp->arg); 5093 default_lp = lp; 5094 } 5095 5096 /* 5097 * If not a booting entry, nothing else to fix for this 5098 * entry 5099 */ 5100 if (lp->entryNum == ENTRY_INIT) 5101 continue; 5102 5103 /* 5104 * Record the position of the default entry. 5105 * The following works because global 5106 * commands like default and timeout should precede 5107 * actual boot entries, so old_default_value 5108 * is already known (or default cmd is missing). 5109 */ 5110 if (default_entry == NULL && 5111 old_default_value != ENTRY_INIT && 5112 lp->entryNum == old_default_value) { 5113 default_entry = lp; 5114 } 5115 5116 /* 5117 * Now fixup the entry number 5118 */ 5119 if (lp->cmd != NULL && 5120 strcmp(lp->cmd, menu_cmds[TITLE_CMD]) == 0) { 5121 lp->entryNum = ++entryNum; 5122 /* fixup the bootadm header */ 5123 if (prev && prev->flags == BAM_COMMENT && 5124 prev->arg && 5125 strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 5126 prev->entryNum = lp->entryNum; 5127 } 5128 } else { 5129 lp->entryNum = entryNum; 5130 } 5131 } 5132 5133 /* 5134 * No default command in menu, simply return 5135 */ 5136 if (default_lp == NULL) { 5137 return; 5138 } 5139 5140 free(default_lp->arg); 5141 free(default_lp->line); 5142 5143 if (default_entry == NULL) { 5144 default_lp->arg = s_strdup("0"); 5145 } else { 5146 (void) snprintf(buf, sizeof (buf), "%d", 5147 default_entry->entryNum); 5148 default_lp->arg = s_strdup(buf); 5149 } 5150 5151 /* 5152 * The following is required since only the line field gets 5153 * written back to menu.lst 5154 */ 5155 (void) snprintf(buf, sizeof (buf), "%s%s%s", 5156 menu_cmds[DEFAULT_CMD], menu_cmds[SEP_CMD], default_lp->arg); 5157 default_lp->line = s_strdup(buf); 5158 } 5159 5160 5161 static menu_t * 5162 menu_read(char *menu_path) 5163 { 5164 FILE *fp; 5165 char buf[BAM_MAXLINE], *cp; 5166 menu_t *mp; 5167 int line, entry, len, n; 5168 5169 mp = s_calloc(1, sizeof (menu_t)); 5170 5171 fp = fopen(menu_path, "r"); 5172 if (fp == NULL) { /* Let the caller handle this error */ 5173 free(mp); 5174 return (NULL); 5175 } 5176 5177 /* Note: GRUB boot entry number starts with 0 */ 5178 line = LINE_INIT; 5179 entry = ENTRY_INIT; 5180 cp = buf; 5181 len = sizeof (buf); 5182 while (s_fgets(cp, len, fp) != NULL) { 5183 n = strlen(cp); 5184 if (cp[n - 1] == '\\') { 5185 len -= n - 1; 5186 assert(len >= 2); 5187 cp += n - 1; 5188 continue; 5189 } 5190 line_parser(mp, buf, &line, &entry); 5191 cp = buf; 5192 len = sizeof (buf); 5193 } 5194 5195 if (fclose(fp) == EOF) { 5196 bam_error(_("failed to close file: %s: %s\n"), menu_path, 5197 strerror(errno)); 5198 } 5199 5200 return (mp); 5201 } 5202 5203 static error_t 5204 selector(menu_t *mp, char *opt, int *entry, char **title) 5205 { 5206 char *eq; 5207 char *opt_dup; 5208 int entryNum; 5209 5210 assert(mp); 5211 assert(mp->start); 5212 assert(opt); 5213 5214 opt_dup = s_strdup(opt); 5215 5216 if (entry) 5217 *entry = ENTRY_INIT; 5218 if (title) 5219 *title = NULL; 5220 5221 eq = strchr(opt_dup, '='); 5222 if (eq == NULL) { 5223 bam_error(_("invalid option: %s\n"), opt); 5224 free(opt_dup); 5225 return (BAM_ERROR); 5226 } 5227 5228 *eq = '\0'; 5229 if (entry && strcmp(opt_dup, OPT_ENTRY_NUM) == 0) { 5230 assert(mp->end); 5231 entryNum = s_strtol(eq + 1); 5232 if (entryNum < 0 || entryNum > mp->end->entryNum) { 5233 bam_error(_("invalid boot entry number: %s\n"), eq + 1); 5234 free(opt_dup); 5235 return (BAM_ERROR); 5236 } 5237 *entry = entryNum; 5238 } else if (title && strcmp(opt_dup, menu_cmds[TITLE_CMD]) == 0) { 5239 *title = opt + (eq - opt_dup) + 1; 5240 } else { 5241 bam_error(_("invalid option: %s\n"), opt); 5242 free(opt_dup); 5243 return (BAM_ERROR); 5244 } 5245 5246 free(opt_dup); 5247 return (BAM_SUCCESS); 5248 } 5249 5250 /* 5251 * If invoked with no titles/entries (opt == NULL) 5252 * only title lines in file are printed. 5253 * 5254 * If invoked with a title or entry #, all 5255 * lines in *every* matching entry are listed 5256 */ 5257 static error_t 5258 list_entry(menu_t *mp, char *menu_path, char *opt) 5259 { 5260 line_t *lp; 5261 int entry = ENTRY_INIT; 5262 int found; 5263 char *title = NULL; 5264 5265 assert(mp); 5266 assert(menu_path); 5267 5268 /* opt is optional */ 5269 BAM_DPRINTF(("%s: entered. args: %s %s\n", "list_entry", menu_path, 5270 opt ? opt : "<NULL>")); 5271 5272 if (mp->start == NULL) { 5273 bam_error(_("menu file not found: %s\n"), menu_path); 5274 return (BAM_ERROR); 5275 } 5276 5277 if (opt != NULL) { 5278 if (selector(mp, opt, &entry, &title) != BAM_SUCCESS) { 5279 return (BAM_ERROR); 5280 } 5281 assert((entry != ENTRY_INIT) ^ (title != NULL)); 5282 } else { 5283 (void) read_globals(mp, menu_path, menu_cmds[DEFAULT_CMD], 0); 5284 (void) read_globals(mp, menu_path, menu_cmds[TIMEOUT_CMD], 0); 5285 } 5286 5287 found = 0; 5288 for (lp = mp->start; lp; lp = lp->next) { 5289 if (lp->flags == BAM_COMMENT || lp->flags == BAM_EMPTY) 5290 continue; 5291 if (opt == NULL && lp->flags == BAM_TITLE) { 5292 bam_print(_("%d %s\n"), lp->entryNum, 5293 lp->arg); 5294 found = 1; 5295 continue; 5296 } 5297 if (entry != ENTRY_INIT && lp->entryNum == entry) { 5298 bam_print(_("%s\n"), lp->line); 5299 found = 1; 5300 continue; 5301 } 5302 5303 /* 5304 * We set the entry value here so that all lines 5305 * in entry get printed. If we subsequently match 5306 * title in other entries, all lines in those 5307 * entries get printed as well. 5308 */ 5309 if (title && lp->flags == BAM_TITLE && lp->arg && 5310 strncmp(title, lp->arg, strlen(title)) == 0) { 5311 bam_print(_("%s\n"), lp->line); 5312 entry = lp->entryNum; 5313 found = 1; 5314 continue; 5315 } 5316 } 5317 5318 if (!found) { 5319 bam_error(_("no matching entry found\n")); 5320 return (BAM_ERROR); 5321 } 5322 5323 return (BAM_SUCCESS); 5324 } 5325 5326 int 5327 add_boot_entry(menu_t *mp, 5328 char *title, 5329 char *findroot, 5330 char *kernel, 5331 char *mod_kernel, 5332 char *module, 5333 char *bootfs) 5334 { 5335 int lineNum; 5336 int entryNum; 5337 char linebuf[BAM_MAXLINE]; 5338 menu_cmd_t k_cmd; 5339 menu_cmd_t m_cmd; 5340 const char *fcn = "add_boot_entry()"; 5341 5342 assert(mp); 5343 5344 INJECT_ERROR1("ADD_BOOT_ENTRY_FINDROOT_NULL", findroot = NULL); 5345 if (findroot == NULL) { 5346 bam_error(_("can't find argument for findroot command\n")); 5347 return (BAM_ERROR); 5348 } 5349 5350 if (title == NULL) { 5351 title = "Solaris"; /* default to Solaris */ 5352 } 5353 if (kernel == NULL) { 5354 bam_error(_("missing suboption: %s\n"), menu_cmds[KERNEL_CMD]); 5355 return (BAM_ERROR); 5356 } 5357 if (module == NULL) { 5358 if (bam_direct != BAM_DIRECT_DBOOT) { 5359 bam_error(_("missing suboption: %s\n"), 5360 menu_cmds[MODULE_CMD]); 5361 return (BAM_ERROR); 5362 } 5363 5364 /* Figure the commands out from the kernel line */ 5365 if (strstr(kernel, "$ISADIR") != NULL) { 5366 module = DIRECT_BOOT_ARCHIVE; 5367 } else if (strstr(kernel, "amd64") != NULL) { 5368 module = DIRECT_BOOT_ARCHIVE_64; 5369 } else { 5370 module = DIRECT_BOOT_ARCHIVE_32; 5371 } 5372 } 5373 5374 k_cmd = KERNEL_DOLLAR_CMD; 5375 m_cmd = MODULE_DOLLAR_CMD; 5376 5377 if (mp->start) { 5378 lineNum = mp->end->lineNum; 5379 entryNum = mp->end->entryNum; 5380 } else { 5381 lineNum = LINE_INIT; 5382 entryNum = ENTRY_INIT; 5383 } 5384 5385 /* 5386 * No separator for comment (HDR/FTR) commands 5387 * The syntax for comments is #<comment> 5388 */ 5389 (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 5390 menu_cmds[COMMENT_CMD], BAM_BOOTADM_HDR); 5391 line_parser(mp, linebuf, &lineNum, &entryNum); 5392 5393 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5394 menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 5395 line_parser(mp, linebuf, &lineNum, &entryNum); 5396 5397 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5398 menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot); 5399 line_parser(mp, linebuf, &lineNum, &entryNum); 5400 BAM_DPRINTF(("%s: findroot added: line#: %d: entry#: %d\n", 5401 fcn, lineNum, entryNum)); 5402 5403 if (bootfs != NULL) { 5404 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5405 menu_cmds[BOOTFS_CMD], menu_cmds[SEP_CMD], bootfs); 5406 line_parser(mp, linebuf, &lineNum, &entryNum); 5407 } 5408 5409 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5410 menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel); 5411 line_parser(mp, linebuf, &lineNum, &entryNum); 5412 5413 if (mod_kernel != NULL) { 5414 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5415 menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel); 5416 line_parser(mp, linebuf, &lineNum, &entryNum); 5417 } 5418 5419 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 5420 menu_cmds[m_cmd], menu_cmds[SEP_CMD], module); 5421 line_parser(mp, linebuf, &lineNum, &entryNum); 5422 5423 (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 5424 menu_cmds[COMMENT_CMD], BAM_BOOTADM_FTR); 5425 line_parser(mp, linebuf, &lineNum, &entryNum); 5426 5427 return (entryNum); 5428 } 5429 5430 error_t 5431 delete_boot_entry(menu_t *mp, int entryNum, int quiet) 5432 { 5433 line_t *lp; 5434 line_t *freed; 5435 entry_t *ent; 5436 entry_t *tmp; 5437 int deleted = 0; 5438 const char *fcn = "delete_boot_entry()"; 5439 5440 assert(entryNum != ENTRY_INIT); 5441 5442 tmp = NULL; 5443 5444 ent = mp->entries; 5445 while (ent) { 5446 lp = ent->start; 5447 5448 /* 5449 * Check entry number and make sure it's a modifiable entry. 5450 * 5451 * Guidelines: 5452 * + We can modify a bootadm-created entry 5453 * + We can modify a libbe-created entry 5454 */ 5455 if ((lp->flags != BAM_COMMENT && 5456 (((ent->flags & BAM_ENTRY_LIBBE) == 0) && 5457 strcmp(lp->arg, BAM_BOOTADM_HDR) != 0)) || 5458 (entryNum != ALL_ENTRIES && lp->entryNum != entryNum)) { 5459 ent = ent->next; 5460 continue; 5461 } 5462 5463 /* free the entry content */ 5464 do { 5465 freed = lp; 5466 lp = lp->next; /* prev stays the same */ 5467 BAM_DPRINTF(("%s: freeing line: %d\n", 5468 fcn, freed->lineNum)); 5469 unlink_line(mp, freed); 5470 line_free(freed); 5471 } while (freed != ent->end); 5472 5473 /* free the entry_t structure */ 5474 assert(tmp == NULL); 5475 tmp = ent; 5476 ent = ent->next; 5477 if (tmp->prev) 5478 tmp->prev->next = ent; 5479 else 5480 mp->entries = ent; 5481 if (ent) 5482 ent->prev = tmp->prev; 5483 BAM_DPRINTF(("%s: freeing entry: %d\n", fcn, tmp->entryNum)); 5484 free(tmp); 5485 tmp = NULL; 5486 deleted = 1; 5487 } 5488 5489 assert(tmp == NULL); 5490 5491 if (!deleted && entryNum != ALL_ENTRIES) { 5492 if (quiet == DBE_PRINTERR) 5493 bam_error(_("no matching bootadm entry found\n")); 5494 return (BAM_ERROR); 5495 } 5496 5497 /* 5498 * Now that we have deleted an entry, update 5499 * the entry numbering and the default cmd. 5500 */ 5501 update_numbering(mp); 5502 5503 return (BAM_SUCCESS); 5504 } 5505 5506 static error_t 5507 delete_all_entries(menu_t *mp, char *dummy, char *opt) 5508 { 5509 assert(mp); 5510 assert(dummy == NULL); 5511 assert(opt == NULL); 5512 5513 BAM_DPRINTF(("%s: entered. No args\n", "delete_all_entries")); 5514 5515 if (mp->start == NULL) { 5516 bam_print(_("the GRUB menu is empty\n")); 5517 return (BAM_SUCCESS); 5518 } 5519 5520 if (delete_boot_entry(mp, ALL_ENTRIES, DBE_PRINTERR) != BAM_SUCCESS) { 5521 return (BAM_ERROR); 5522 } 5523 5524 return (BAM_WRITE); 5525 } 5526 5527 static FILE * 5528 create_diskmap(char *osroot) 5529 { 5530 FILE *fp; 5531 char cmd[PATH_MAX + 16]; 5532 char path[PATH_MAX]; 5533 const char *fcn = "create_diskmap()"; 5534 5535 /* make sure we have a map file */ 5536 fp = fopen(GRUBDISK_MAP, "r"); 5537 if (fp == NULL) { 5538 int ret; 5539 5540 ret = snprintf(path, sizeof (path), "%s/%s", osroot, 5541 CREATE_DISKMAP); 5542 if (ret >= sizeof (path)) { 5543 bam_error(_("unable to create path on mountpoint %s, " 5544 "path too long\n"), osroot); 5545 return (NULL); 5546 } 5547 if (is_safe_exec(path) == BAM_ERROR) 5548 return (NULL); 5549 5550 (void) snprintf(cmd, sizeof (cmd), 5551 "%s/%s > /dev/null", osroot, CREATE_DISKMAP); 5552 if (exec_cmd(cmd, NULL) != 0) 5553 return (NULL); 5554 fp = fopen(GRUBDISK_MAP, "r"); 5555 INJECT_ERROR1("DISKMAP_CREATE_FAIL", fp = NULL); 5556 if (fp) { 5557 BAM_DPRINTF(("%s: created diskmap file: %s\n", 5558 fcn, GRUBDISK_MAP)); 5559 } else { 5560 BAM_DPRINTF(("%s: FAILED to create diskmap file: %s\n", 5561 fcn, GRUBDISK_MAP)); 5562 } 5563 } 5564 return (fp); 5565 } 5566 5567 #define SECTOR_SIZE 512 5568 5569 static int 5570 get_partition(char *device) 5571 { 5572 int i, fd, is_pcfs, partno = PARTNO_NOTFOUND; 5573 struct mboot *mboot; 5574 char boot_sect[SECTOR_SIZE]; 5575 char *wholedisk, *slice; 5576 #ifdef i386 5577 ext_part_t *epp; 5578 uint32_t secnum, numsec; 5579 int rval, pno, ext_partno = PARTNO_NOTFOUND; 5580 #endif 5581 5582 /* form whole disk (p0) */ 5583 slice = device + strlen(device) - 2; 5584 is_pcfs = (*slice != 's'); 5585 if (!is_pcfs) 5586 *slice = '\0'; 5587 wholedisk = s_calloc(1, strlen(device) + 3); 5588 (void) snprintf(wholedisk, strlen(device) + 3, "%sp0", device); 5589 if (!is_pcfs) 5590 *slice = 's'; 5591 5592 /* read boot sector */ 5593 fd = open(wholedisk, O_RDONLY); 5594 if (fd == -1 || read(fd, boot_sect, SECTOR_SIZE) != SECTOR_SIZE) { 5595 return (partno); 5596 } 5597 (void) close(fd); 5598 5599 #ifdef i386 5600 /* Read/Initialize extended partition information */ 5601 if ((rval = libfdisk_init(&epp, wholedisk, NULL, FDISK_READ_DISK)) 5602 != FDISK_SUCCESS) { 5603 switch (rval) { 5604 /* 5605 * FDISK_EBADLOGDRIVE and FDISK_ENOLOGDRIVE can 5606 * be considered as soft errors and hence 5607 * we do not return 5608 */ 5609 case FDISK_EBADLOGDRIVE: 5610 break; 5611 case FDISK_ENOLOGDRIVE: 5612 break; 5613 case FDISK_EBADMAGIC: 5614 /*FALLTHROUGH*/ 5615 default: 5616 free(wholedisk); 5617 libfdisk_fini(&epp); 5618 return (partno); 5619 } 5620 } 5621 #endif 5622 free(wholedisk); 5623 5624 /* parse fdisk table */ 5625 mboot = (struct mboot *)((void *)boot_sect); 5626 for (i = 0; i < FD_NUMPART; i++) { 5627 struct ipart *part = 5628 (struct ipart *)(uintptr_t)mboot->parts + i; 5629 if (is_pcfs) { /* looking for solaris boot part */ 5630 if (part->systid == 0xbe) { 5631 partno = i; 5632 break; 5633 } 5634 } else { /* look for solaris partition, old and new */ 5635 if (part->systid == EFI_PMBR) { 5636 partno = PARTNO_EFI; 5637 break; 5638 } 5639 5640 #ifdef i386 5641 if ((part->systid == SUNIXOS && 5642 (fdisk_is_linux_swap(epp, part->relsect, 5643 NULL) != 0)) || part->systid == SUNIXOS2) { 5644 #else 5645 if (part->systid == SUNIXOS || 5646 part->systid == SUNIXOS2) { 5647 #endif 5648 partno = i; 5649 break; 5650 } 5651 5652 #ifdef i386 5653 if (fdisk_is_dos_extended(part->systid)) 5654 ext_partno = i; 5655 #endif 5656 } 5657 } 5658 #ifdef i386 5659 /* If no primary solaris partition, check extended partition */ 5660 if ((partno == PARTNO_NOTFOUND) && (ext_partno != PARTNO_NOTFOUND)) { 5661 rval = fdisk_get_solaris_part(epp, &pno, &secnum, &numsec); 5662 if (rval == FDISK_SUCCESS) { 5663 partno = pno - 1; 5664 } 5665 } 5666 libfdisk_fini(&epp); 5667 #endif 5668 return (partno); 5669 } 5670 5671 char * 5672 get_grubroot(char *osroot, char *osdev, char *menu_root) 5673 { 5674 char *grubroot; /* (hd#,#,#) */ 5675 char *slice; 5676 char *grubhd = NULL; 5677 int fdiskpart; 5678 int found = 0; 5679 char *devname; 5680 char *ctdname = strstr(osdev, "dsk/"); 5681 char linebuf[PATH_MAX]; 5682 FILE *fp; 5683 5684 INJECT_ERROR1("GRUBROOT_INVALID_OSDEV", ctdname = NULL); 5685 if (ctdname == NULL) { 5686 bam_error(_("not a /dev/[r]dsk name: %s\n"), osdev); 5687 return (NULL); 5688 } 5689 5690 if (menu_root && !menu_on_bootdisk(osroot, menu_root)) { 5691 /* menu bears no resemblance to our reality */ 5692 bam_error(_("cannot get (hd?,?,?) for menu. menu not on " 5693 "bootdisk: %s\n"), osdev); 5694 return (NULL); 5695 } 5696 5697 ctdname += strlen("dsk/"); 5698 slice = strrchr(ctdname, 's'); 5699 if (slice) 5700 *slice = '\0'; 5701 5702 fp = create_diskmap(osroot); 5703 if (fp == NULL) { 5704 bam_error(_("create_diskmap command failed for OS root: %s.\n"), 5705 osroot); 5706 return (NULL); 5707 } 5708 5709 rewind(fp); 5710 while (s_fgets(linebuf, sizeof (linebuf), fp) != NULL) { 5711 grubhd = strtok(linebuf, " \t\n"); 5712 if (grubhd) 5713 devname = strtok(NULL, " \t\n"); 5714 else 5715 devname = NULL; 5716 if (devname && strcmp(devname, ctdname) == 0) { 5717 found = 1; 5718 break; 5719 } 5720 } 5721 5722 if (slice) 5723 *slice = 's'; 5724 5725 (void) fclose(fp); 5726 fp = NULL; 5727 5728 INJECT_ERROR1("GRUBROOT_BIOSDEV_FAIL", found = 0); 5729 if (found == 0) { 5730 bam_error(_("not using biosdev command for disk: %s.\n"), 5731 osdev); 5732 return (NULL); 5733 } 5734 5735 fdiskpart = get_partition(osdev); 5736 INJECT_ERROR1("GRUBROOT_FDISK_FAIL", fdiskpart = PARTNO_NOTFOUND); 5737 if (fdiskpart == PARTNO_NOTFOUND) { 5738 bam_error(_("failed to determine fdisk partition: %s\n"), 5739 osdev); 5740 return (NULL); 5741 } 5742 5743 grubroot = s_calloc(1, 10); 5744 if (fdiskpart == PARTNO_EFI) { 5745 fdiskpart = atoi(&slice[1]); 5746 slice = NULL; 5747 } 5748 5749 if (slice) { 5750 (void) snprintf(grubroot, 10, "(hd%s,%d,%c)", 5751 grubhd, fdiskpart, slice[1] + 'a' - '0'); 5752 } else 5753 (void) snprintf(grubroot, 10, "(hd%s,%d)", 5754 grubhd, fdiskpart); 5755 5756 assert(fp == NULL); 5757 assert(strncmp(grubroot, "(hd", strlen("(hd")) == 0); 5758 return (grubroot); 5759 } 5760 5761 static char * 5762 find_primary_common(char *mntpt, char *fstype) 5763 { 5764 char signdir[PATH_MAX]; 5765 char tmpsign[MAXNAMELEN + 1]; 5766 char *lu; 5767 char *ufs; 5768 char *zfs; 5769 DIR *dirp = NULL; 5770 struct dirent *entp; 5771 struct stat sb; 5772 const char *fcn = "find_primary_common()"; 5773 5774 (void) snprintf(signdir, sizeof (signdir), "%s/%s", 5775 mntpt, GRUBSIGN_DIR); 5776 5777 if (stat(signdir, &sb) == -1) { 5778 BAM_DPRINTF(("%s: no sign dir: %s\n", fcn, signdir)); 5779 return (NULL); 5780 } 5781 5782 dirp = opendir(signdir); 5783 INJECT_ERROR1("SIGNDIR_OPENDIR_FAIL", dirp = NULL); 5784 if (dirp == NULL) { 5785 bam_error(_("opendir of %s failed: %s\n"), signdir, 5786 strerror(errno)); 5787 return (NULL); 5788 } 5789 5790 ufs = zfs = lu = NULL; 5791 5792 while ((entp = readdir(dirp)) != NULL) { 5793 if (strcmp(entp->d_name, ".") == 0 || 5794 strcmp(entp->d_name, "..") == 0) 5795 continue; 5796 5797 (void) snprintf(tmpsign, sizeof (tmpsign), "%s", entp->d_name); 5798 5799 if (lu == NULL && 5800 strncmp(tmpsign, GRUBSIGN_LU_PREFIX, 5801 strlen(GRUBSIGN_LU_PREFIX)) == 0) { 5802 lu = s_strdup(tmpsign); 5803 } 5804 5805 if (ufs == NULL && 5806 strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 5807 strlen(GRUBSIGN_UFS_PREFIX)) == 0) { 5808 ufs = s_strdup(tmpsign); 5809 } 5810 5811 if (zfs == NULL && 5812 strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX, 5813 strlen(GRUBSIGN_ZFS_PREFIX)) == 0) { 5814 zfs = s_strdup(tmpsign); 5815 } 5816 } 5817 5818 BAM_DPRINTF(("%s: existing primary signs: zfs=%s ufs=%s lu=%s\n", fcn, 5819 zfs ? zfs : "NULL", 5820 ufs ? ufs : "NULL", 5821 lu ? lu : "NULL")); 5822 5823 if (dirp) { 5824 (void) closedir(dirp); 5825 dirp = NULL; 5826 } 5827 5828 if (strcmp(fstype, "ufs") == 0 && zfs) { 5829 bam_error(_("found mismatched boot signature %s for " 5830 "filesystem type: %s.\n"), zfs, "ufs"); 5831 free(zfs); 5832 zfs = NULL; 5833 } else if (strcmp(fstype, "zfs") == 0 && ufs) { 5834 bam_error(_("found mismatched boot signature %s for " 5835 "filesystem type: %s.\n"), ufs, "zfs"); 5836 free(ufs); 5837 ufs = NULL; 5838 } 5839 5840 assert(dirp == NULL); 5841 5842 /* For now, we let Live Upgrade take care of its signature itself */ 5843 if (lu) { 5844 BAM_DPRINTF(("%s: feeing LU sign: %s\n", fcn, lu)); 5845 free(lu); 5846 lu = NULL; 5847 } 5848 5849 return (zfs ? zfs : ufs); 5850 } 5851 5852 static char * 5853 find_backup_common(char *mntpt, char *fstype) 5854 { 5855 FILE *bfp = NULL; 5856 char tmpsign[MAXNAMELEN + 1]; 5857 char backup[PATH_MAX]; 5858 char *ufs; 5859 char *zfs; 5860 char *lu; 5861 int error; 5862 const char *fcn = "find_backup_common()"; 5863 5864 /* 5865 * We didn't find it in the primary directory. 5866 * Look at the backup 5867 */ 5868 (void) snprintf(backup, sizeof (backup), "%s%s", 5869 mntpt, GRUBSIGN_BACKUP); 5870 5871 bfp = fopen(backup, "r"); 5872 if (bfp == NULL) { 5873 error = errno; 5874 if (bam_verbose) { 5875 bam_error(_("failed to open file: %s: %s\n"), 5876 backup, strerror(error)); 5877 } 5878 BAM_DPRINTF(("%s: failed to open %s: %s\n", 5879 fcn, backup, strerror(error))); 5880 return (NULL); 5881 } 5882 5883 ufs = zfs = lu = NULL; 5884 5885 while (s_fgets(tmpsign, sizeof (tmpsign), bfp) != NULL) { 5886 5887 if (lu == NULL && 5888 strncmp(tmpsign, GRUBSIGN_LU_PREFIX, 5889 strlen(GRUBSIGN_LU_PREFIX)) == 0) { 5890 lu = s_strdup(tmpsign); 5891 } 5892 5893 if (ufs == NULL && 5894 strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 5895 strlen(GRUBSIGN_UFS_PREFIX)) == 0) { 5896 ufs = s_strdup(tmpsign); 5897 } 5898 5899 if (zfs == NULL && 5900 strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX, 5901 strlen(GRUBSIGN_ZFS_PREFIX)) == 0) { 5902 zfs = s_strdup(tmpsign); 5903 } 5904 } 5905 5906 BAM_DPRINTF(("%s: existing backup signs: zfs=%s ufs=%s lu=%s\n", fcn, 5907 zfs ? zfs : "NULL", 5908 ufs ? ufs : "NULL", 5909 lu ? lu : "NULL")); 5910 5911 if (bfp) { 5912 (void) fclose(bfp); 5913 bfp = NULL; 5914 } 5915 5916 if (strcmp(fstype, "ufs") == 0 && zfs) { 5917 bam_error(_("found mismatched boot signature %s for " 5918 "filesystem type: %s.\n"), zfs, "ufs"); 5919 free(zfs); 5920 zfs = NULL; 5921 } else if (strcmp(fstype, "zfs") == 0 && ufs) { 5922 bam_error(_("found mismatched boot signature %s for " 5923 "filesystem type: %s.\n"), ufs, "zfs"); 5924 free(ufs); 5925 ufs = NULL; 5926 } 5927 5928 assert(bfp == NULL); 5929 5930 /* For now, we let Live Upgrade take care of its signature itself */ 5931 if (lu) { 5932 BAM_DPRINTF(("%s: feeing LU sign: %s\n", fcn, lu)); 5933 free(lu); 5934 lu = NULL; 5935 } 5936 5937 return (zfs ? zfs : ufs); 5938 } 5939 5940 static char * 5941 find_ufs_existing(char *osroot) 5942 { 5943 char *sign; 5944 const char *fcn = "find_ufs_existing()"; 5945 5946 sign = find_primary_common(osroot, "ufs"); 5947 if (sign == NULL) { 5948 sign = find_backup_common(osroot, "ufs"); 5949 BAM_DPRINTF(("%s: existing backup sign: %s\n", fcn, 5950 sign ? sign : "NULL")); 5951 } else { 5952 BAM_DPRINTF(("%s: existing primary sign: %s\n", fcn, sign)); 5953 } 5954 5955 return (sign); 5956 } 5957 5958 char * 5959 get_mountpoint(char *special, char *fstype) 5960 { 5961 FILE *mntfp; 5962 struct mnttab mp = {0}; 5963 struct mnttab mpref = {0}; 5964 int error; 5965 int ret; 5966 const char *fcn = "get_mountpoint()"; 5967 5968 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, special, fstype)); 5969 5970 mntfp = fopen(MNTTAB, "r"); 5971 error = errno; 5972 INJECT_ERROR1("MNTTAB_ERR_GET_MNTPT", mntfp = NULL); 5973 if (mntfp == NULL) { 5974 bam_error(_("failed to open file: %s: %s\n"), 5975 MNTTAB, strerror(error)); 5976 return (NULL); 5977 } 5978 5979 mpref.mnt_special = special; 5980 mpref.mnt_fstype = fstype; 5981 5982 ret = getmntany(mntfp, &mp, &mpref); 5983 INJECT_ERROR1("GET_MOUNTPOINT_MNTANY", ret = 1); 5984 if (ret != 0) { 5985 (void) fclose(mntfp); 5986 BAM_DPRINTF(("%s: no mount-point for special=%s and " 5987 "fstype=%s\n", fcn, special, fstype)); 5988 return (NULL); 5989 } 5990 (void) fclose(mntfp); 5991 5992 assert(mp.mnt_mountp); 5993 5994 BAM_DPRINTF(("%s: returning mount-point for special %s: %s\n", 5995 fcn, special, mp.mnt_mountp)); 5996 5997 return (s_strdup(mp.mnt_mountp)); 5998 } 5999 6000 /* 6001 * Mounts a "legacy" top dataset (if needed) 6002 * Returns: The mountpoint of the legacy top dataset or NULL on error 6003 * mnted returns one of the above values defined for zfs_mnted_t 6004 */ 6005 static char * 6006 mount_legacy_dataset(char *pool, zfs_mnted_t *mnted) 6007 { 6008 char cmd[PATH_MAX]; 6009 char tmpmnt[PATH_MAX]; 6010 filelist_t flist = {0}; 6011 char *is_mounted; 6012 struct stat sb; 6013 int ret; 6014 const char *fcn = "mount_legacy_dataset()"; 6015 6016 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, pool)); 6017 6018 *mnted = ZFS_MNT_ERROR; 6019 6020 (void) snprintf(cmd, sizeof (cmd), 6021 "/sbin/zfs get -Ho value mounted %s", 6022 pool); 6023 6024 ret = exec_cmd(cmd, &flist); 6025 INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_CMD", ret = 1); 6026 if (ret != 0) { 6027 bam_error(_("failed to determine mount status of ZFS " 6028 "pool %s\n"), pool); 6029 return (NULL); 6030 } 6031 6032 INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_OUT", flist.head = NULL); 6033 if ((flist.head == NULL) || (flist.head != flist.tail)) { 6034 bam_error(_("ZFS pool %s has bad mount status\n"), pool); 6035 filelist_free(&flist); 6036 return (NULL); 6037 } 6038 6039 is_mounted = strtok(flist.head->line, " \t\n"); 6040 INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_YES", is_mounted = "yes"); 6041 INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_NO", is_mounted = "no"); 6042 if (strcmp(is_mounted, "no") != 0) { 6043 filelist_free(&flist); 6044 *mnted = LEGACY_ALREADY; 6045 /* get_mountpoint returns a strdup'ed string */ 6046 BAM_DPRINTF(("%s: legacy pool %s already mounted\n", 6047 fcn, pool)); 6048 return (get_mountpoint(pool, "zfs")); 6049 } 6050 6051 filelist_free(&flist); 6052 6053 /* 6054 * legacy top dataset is not mounted. Mount it now 6055 * First create a mountpoint. 6056 */ 6057 (void) snprintf(tmpmnt, sizeof (tmpmnt), "%s.%d", 6058 ZFS_LEGACY_MNTPT, getpid()); 6059 6060 ret = stat(tmpmnt, &sb); 6061 if (ret == -1) { 6062 BAM_DPRINTF(("%s: legacy pool %s mount-point %s absent\n", 6063 fcn, pool, tmpmnt)); 6064 ret = mkdirp(tmpmnt, DIR_PERMS); 6065 INJECT_ERROR1("Z_MOUNT_TOP_LEG_MNTPT_MKDIRP", ret = -1); 6066 if (ret == -1) { 6067 bam_error(_("mkdir of %s failed: %s\n"), tmpmnt, 6068 strerror(errno)); 6069 return (NULL); 6070 } 6071 } else { 6072 BAM_DPRINTF(("%s: legacy pool %s mount-point %s is already " 6073 "present\n", fcn, pool, tmpmnt)); 6074 } 6075 6076 (void) snprintf(cmd, sizeof (cmd), 6077 "/sbin/mount -F zfs %s %s", 6078 pool, tmpmnt); 6079 6080 ret = exec_cmd(cmd, NULL); 6081 INJECT_ERROR1("Z_MOUNT_TOP_LEG_MOUNT_CMD", ret = 1); 6082 if (ret != 0) { 6083 bam_error(_("mount of ZFS pool %s failed\n"), pool); 6084 (void) rmdir(tmpmnt); 6085 return (NULL); 6086 } 6087 6088 *mnted = LEGACY_MOUNTED; 6089 BAM_DPRINTF(("%s: legacy pool %s successfully mounted at %s\n", 6090 fcn, pool, tmpmnt)); 6091 return (s_strdup(tmpmnt)); 6092 } 6093 6094 /* 6095 * Mounts the top dataset (if needed) 6096 * Returns: The mountpoint of the top dataset or NULL on error 6097 * mnted returns one of the above values defined for zfs_mnted_t 6098 */ 6099 char * 6100 mount_top_dataset(char *pool, zfs_mnted_t *mnted) 6101 { 6102 char cmd[PATH_MAX]; 6103 filelist_t flist = {0}; 6104 char *is_mounted; 6105 char *mntpt; 6106 char *zmntpt; 6107 int ret; 6108 const char *fcn = "mount_top_dataset()"; 6109 6110 *mnted = ZFS_MNT_ERROR; 6111 6112 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, pool)); 6113 6114 /* 6115 * First check if the top dataset is a "legacy" dataset 6116 */ 6117 (void) snprintf(cmd, sizeof (cmd), 6118 "/sbin/zfs get -Ho value mountpoint %s", 6119 pool); 6120 ret = exec_cmd(cmd, &flist); 6121 INJECT_ERROR1("Z_MOUNT_TOP_GET_MNTPT", ret = 1); 6122 if (ret != 0) { 6123 bam_error(_("failed to determine mount point of ZFS pool %s\n"), 6124 pool); 6125 return (NULL); 6126 } 6127 6128 if (flist.head && (flist.head == flist.tail)) { 6129 char *legacy = strtok(flist.head->line, " \t\n"); 6130 if (legacy && strcmp(legacy, "legacy") == 0) { 6131 filelist_free(&flist); 6132 BAM_DPRINTF(("%s: is legacy, pool=%s\n", fcn, pool)); 6133 return (mount_legacy_dataset(pool, mnted)); 6134 } 6135 } 6136 6137 filelist_free(&flist); 6138 6139 BAM_DPRINTF(("%s: is *NOT* legacy, pool=%s\n", fcn, pool)); 6140 6141 (void) snprintf(cmd, sizeof (cmd), 6142 "/sbin/zfs get -Ho value mounted %s", 6143 pool); 6144 6145 ret = exec_cmd(cmd, &flist); 6146 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED", ret = 1); 6147 if (ret != 0) { 6148 bam_error(_("failed to determine mount status of ZFS " 6149 "pool %s\n"), pool); 6150 return (NULL); 6151 } 6152 6153 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_VAL", flist.head = NULL); 6154 if ((flist.head == NULL) || (flist.head != flist.tail)) { 6155 bam_error(_("ZFS pool %s has bad mount status\n"), pool); 6156 filelist_free(&flist); 6157 return (NULL); 6158 } 6159 6160 is_mounted = strtok(flist.head->line, " \t\n"); 6161 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_YES", is_mounted = "yes"); 6162 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_NO", is_mounted = "no"); 6163 if (strcmp(is_mounted, "no") != 0) { 6164 filelist_free(&flist); 6165 *mnted = ZFS_ALREADY; 6166 BAM_DPRINTF(("%s: non-legacy pool %s mounted already\n", 6167 fcn, pool)); 6168 goto mounted; 6169 } 6170 6171 filelist_free(&flist); 6172 BAM_DPRINTF(("%s: non-legacy pool %s *NOT* already mounted\n", 6173 fcn, pool)); 6174 6175 /* top dataset is not mounted. Mount it now */ 6176 (void) snprintf(cmd, sizeof (cmd), 6177 "/sbin/zfs mount %s", pool); 6178 ret = exec_cmd(cmd, NULL); 6179 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_MOUNT_CMD", ret = 1); 6180 if (ret != 0) { 6181 bam_error(_("mount of ZFS pool %s failed\n"), pool); 6182 return (NULL); 6183 } 6184 *mnted = ZFS_MOUNTED; 6185 BAM_DPRINTF(("%s: non-legacy pool %s mounted now\n", fcn, pool)); 6186 /*FALLTHRU*/ 6187 mounted: 6188 /* 6189 * Now get the mountpoint 6190 */ 6191 (void) snprintf(cmd, sizeof (cmd), 6192 "/sbin/zfs get -Ho value mountpoint %s", 6193 pool); 6194 6195 ret = exec_cmd(cmd, &flist); 6196 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_CMD", ret = 1); 6197 if (ret != 0) { 6198 bam_error(_("failed to determine mount point of ZFS pool %s\n"), 6199 pool); 6200 goto error; 6201 } 6202 6203 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_OUT", flist.head = NULL); 6204 if ((flist.head == NULL) || (flist.head != flist.tail)) { 6205 bam_error(_("ZFS pool %s has no mount-point\n"), pool); 6206 goto error; 6207 } 6208 6209 mntpt = strtok(flist.head->line, " \t\n"); 6210 INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_STRTOK", mntpt = "foo"); 6211 if (*mntpt != '/') { 6212 bam_error(_("ZFS pool %s has bad mount-point %s\n"), 6213 pool, mntpt); 6214 goto error; 6215 } 6216 zmntpt = s_strdup(mntpt); 6217 6218 filelist_free(&flist); 6219 6220 BAM_DPRINTF(("%s: non-legacy pool %s is mounted at %s\n", 6221 fcn, pool, zmntpt)); 6222 6223 return (zmntpt); 6224 6225 error: 6226 filelist_free(&flist); 6227 (void) umount_top_dataset(pool, *mnted, NULL); 6228 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 6229 return (NULL); 6230 } 6231 6232 int 6233 umount_top_dataset(char *pool, zfs_mnted_t mnted, char *mntpt) 6234 { 6235 char cmd[PATH_MAX]; 6236 int ret; 6237 const char *fcn = "umount_top_dataset()"; 6238 6239 INJECT_ERROR1("Z_UMOUNT_TOP_INVALID_STATE", mnted = ZFS_MNT_ERROR); 6240 switch (mnted) { 6241 case LEGACY_ALREADY: 6242 case ZFS_ALREADY: 6243 /* nothing to do */ 6244 BAM_DPRINTF(("%s: pool %s was already mounted at %s, Nothing " 6245 "to umount\n", fcn, pool, mntpt ? mntpt : "NULL")); 6246 free(mntpt); 6247 return (BAM_SUCCESS); 6248 case LEGACY_MOUNTED: 6249 (void) snprintf(cmd, sizeof (cmd), 6250 "/sbin/umount %s", pool); 6251 ret = exec_cmd(cmd, NULL); 6252 INJECT_ERROR1("Z_UMOUNT_TOP_LEGACY_UMOUNT_FAIL", ret = 1); 6253 if (ret != 0) { 6254 bam_error(_("umount of %s failed\n"), pool); 6255 free(mntpt); 6256 return (BAM_ERROR); 6257 } 6258 if (mntpt) 6259 (void) rmdir(mntpt); 6260 free(mntpt); 6261 BAM_DPRINTF(("%s: legacy pool %s was mounted by us, " 6262 "successfully unmounted\n", fcn, pool)); 6263 return (BAM_SUCCESS); 6264 case ZFS_MOUNTED: 6265 free(mntpt); 6266 (void) snprintf(cmd, sizeof (cmd), 6267 "/sbin/zfs unmount %s", pool); 6268 ret = exec_cmd(cmd, NULL); 6269 INJECT_ERROR1("Z_UMOUNT_TOP_NONLEG_UMOUNT_FAIL", ret = 1); 6270 if (ret != 0) { 6271 bam_error(_("umount of %s failed\n"), pool); 6272 return (BAM_ERROR); 6273 } 6274 BAM_DPRINTF(("%s: nonleg pool %s was mounted by us, " 6275 "successfully unmounted\n", fcn, pool)); 6276 return (BAM_SUCCESS); 6277 default: 6278 bam_error(_("Internal error: bad saved mount state for " 6279 "pool %s\n"), pool); 6280 return (BAM_ERROR); 6281 } 6282 /*NOTREACHED*/ 6283 } 6284 6285 /* 6286 * For ZFS, osdev can be one of two forms 6287 * It can be a "special" file as seen in mnttab: rpool/ROOT/szboot_0402 6288 * It can be a /dev/[r]dsk special file. We handle both instances 6289 */ 6290 static char * 6291 get_pool(char *osdev) 6292 { 6293 char cmd[PATH_MAX]; 6294 char buf[PATH_MAX]; 6295 filelist_t flist = {0}; 6296 char *pool; 6297 char *cp; 6298 char *slash; 6299 int ret; 6300 const char *fcn = "get_pool()"; 6301 6302 INJECT_ERROR1("GET_POOL_OSDEV", osdev = NULL); 6303 if (osdev == NULL) { 6304 bam_error(_("NULL device: cannot determine pool name\n")); 6305 return (NULL); 6306 } 6307 6308 BAM_DPRINTF(("%s: osdev arg = %s\n", fcn, osdev)); 6309 6310 if (osdev[0] != '/') { 6311 (void) strlcpy(buf, osdev, sizeof (buf)); 6312 slash = strchr(buf, '/'); 6313 if (slash) 6314 *slash = '\0'; 6315 pool = s_strdup(buf); 6316 BAM_DPRINTF(("%s: got pool. pool = %s\n", fcn, pool)); 6317 return (pool); 6318 } else if (strncmp(osdev, "/dev/dsk/", strlen("/dev/dsk/")) != 0 && 6319 strncmp(osdev, "/dev/rdsk/", strlen("/dev/rdsk/")) != 0) { 6320 bam_error(_("invalid device %s: cannot determine pool name\n"), 6321 osdev); 6322 return (NULL); 6323 } 6324 6325 /* 6326 * Call the zfs fstyp directly since this is a zpool. This avoids 6327 * potential pcfs conflicts if the first block wasn't cleared. 6328 */ 6329 (void) snprintf(cmd, sizeof (cmd), 6330 "/usr/lib/fs/zfs/fstyp -a %s 2>/dev/null | /bin/grep '^name:'", 6331 osdev); 6332 6333 ret = exec_cmd(cmd, &flist); 6334 INJECT_ERROR1("GET_POOL_FSTYP", ret = 1); 6335 if (ret != 0) { 6336 bam_error(_("fstyp -a on device %s failed\n"), osdev); 6337 return (NULL); 6338 } 6339 6340 INJECT_ERROR1("GET_POOL_FSTYP_OUT", flist.head = NULL); 6341 if ((flist.head == NULL) || (flist.head != flist.tail)) { 6342 bam_error(_("NULL fstyp -a output for device %s\n"), osdev); 6343 filelist_free(&flist); 6344 return (NULL); 6345 } 6346 6347 (void) strtok(flist.head->line, "'"); 6348 cp = strtok(NULL, "'"); 6349 INJECT_ERROR1("GET_POOL_FSTYP_STRTOK", cp = NULL); 6350 if (cp == NULL) { 6351 bam_error(_("bad fstyp -a output for device %s\n"), osdev); 6352 filelist_free(&flist); 6353 return (NULL); 6354 } 6355 6356 pool = s_strdup(cp); 6357 6358 filelist_free(&flist); 6359 6360 BAM_DPRINTF(("%s: got pool. pool = %s\n", fcn, pool)); 6361 6362 return (pool); 6363 } 6364 6365 static char * 6366 find_zfs_existing(char *osdev) 6367 { 6368 char *pool; 6369 zfs_mnted_t mnted; 6370 char *mntpt; 6371 char *sign; 6372 const char *fcn = "find_zfs_existing()"; 6373 6374 pool = get_pool(osdev); 6375 INJECT_ERROR1("ZFS_FIND_EXIST_POOL", pool = NULL); 6376 if (pool == NULL) { 6377 bam_error(_("failed to get pool for device: %s\n"), osdev); 6378 return (NULL); 6379 } 6380 6381 mntpt = mount_top_dataset(pool, &mnted); 6382 INJECT_ERROR1("ZFS_FIND_EXIST_MOUNT_TOP", mntpt = NULL); 6383 if (mntpt == NULL) { 6384 bam_error(_("failed to mount top dataset for pool: %s\n"), 6385 pool); 6386 free(pool); 6387 return (NULL); 6388 } 6389 6390 sign = find_primary_common(mntpt, "zfs"); 6391 if (sign == NULL) { 6392 sign = find_backup_common(mntpt, "zfs"); 6393 BAM_DPRINTF(("%s: existing backup sign: %s\n", fcn, 6394 sign ? sign : "NULL")); 6395 } else { 6396 BAM_DPRINTF(("%s: existing primary sign: %s\n", fcn, sign)); 6397 } 6398 6399 (void) umount_top_dataset(pool, mnted, mntpt); 6400 6401 free(pool); 6402 6403 return (sign); 6404 } 6405 6406 static char * 6407 find_existing_sign(char *osroot, char *osdev, char *fstype) 6408 { 6409 const char *fcn = "find_existing_sign()"; 6410 6411 INJECT_ERROR1("FIND_EXIST_NOTSUP_FS", fstype = "foofs"); 6412 if (strcmp(fstype, "ufs") == 0) { 6413 BAM_DPRINTF(("%s: checking for existing UFS sign\n", fcn)); 6414 return (find_ufs_existing(osroot)); 6415 } else if (strcmp(fstype, "zfs") == 0) { 6416 BAM_DPRINTF(("%s: checking for existing ZFS sign\n", fcn)); 6417 return (find_zfs_existing(osdev)); 6418 } else { 6419 bam_error(_("boot signature not supported for fstype: %s\n"), 6420 fstype); 6421 return (NULL); 6422 } 6423 } 6424 6425 #define MH_HASH_SZ 16 6426 6427 typedef enum { 6428 MH_ERROR = -1, 6429 MH_NOMATCH, 6430 MH_MATCH 6431 } mh_search_t; 6432 6433 typedef struct mcache { 6434 char *mc_special; 6435 char *mc_mntpt; 6436 char *mc_fstype; 6437 struct mcache *mc_next; 6438 } mcache_t; 6439 6440 typedef struct mhash { 6441 mcache_t *mh_hash[MH_HASH_SZ]; 6442 } mhash_t; 6443 6444 static int 6445 mhash_fcn(char *key) 6446 { 6447 int i; 6448 uint64_t sum = 0; 6449 6450 for (i = 0; key[i] != '\0'; i++) { 6451 sum += (uchar_t)key[i]; 6452 } 6453 6454 sum %= MH_HASH_SZ; 6455 6456 assert(sum < MH_HASH_SZ); 6457 6458 return (sum); 6459 } 6460 6461 static mhash_t * 6462 cache_mnttab(void) 6463 { 6464 FILE *mfp; 6465 struct extmnttab mnt; 6466 mcache_t *mcp; 6467 mhash_t *mhp; 6468 char *ctds; 6469 int idx; 6470 int error; 6471 char *special_dup; 6472 const char *fcn = "cache_mnttab()"; 6473 6474 mfp = fopen(MNTTAB, "r"); 6475 error = errno; 6476 INJECT_ERROR1("CACHE_MNTTAB_MNTTAB_ERR", mfp = NULL); 6477 if (mfp == NULL) { 6478 bam_error(_("failed to open file: %s: %s\n"), MNTTAB, 6479 strerror(error)); 6480 return (NULL); 6481 } 6482 6483 mhp = s_calloc(1, sizeof (mhash_t)); 6484 6485 resetmnttab(mfp); 6486 6487 while (getextmntent(mfp, &mnt, sizeof (mnt)) == 0) { 6488 /* only cache ufs */ 6489 if (strcmp(mnt.mnt_fstype, "ufs") != 0) 6490 continue; 6491 6492 /* basename() modifies its arg, so dup it */ 6493 special_dup = s_strdup(mnt.mnt_special); 6494 ctds = basename(special_dup); 6495 6496 mcp = s_calloc(1, sizeof (mcache_t)); 6497 mcp->mc_special = s_strdup(ctds); 6498 mcp->mc_mntpt = s_strdup(mnt.mnt_mountp); 6499 mcp->mc_fstype = s_strdup(mnt.mnt_fstype); 6500 BAM_DPRINTF(("%s: caching mount: special=%s, mntpt=%s, " 6501 "fstype=%s\n", fcn, ctds, mnt.mnt_mountp, mnt.mnt_fstype)); 6502 idx = mhash_fcn(ctds); 6503 mcp->mc_next = mhp->mh_hash[idx]; 6504 mhp->mh_hash[idx] = mcp; 6505 free(special_dup); 6506 } 6507 6508 (void) fclose(mfp); 6509 6510 return (mhp); 6511 } 6512 6513 static void 6514 free_mnttab(mhash_t *mhp) 6515 { 6516 mcache_t *mcp; 6517 int i; 6518 6519 for (i = 0; i < MH_HASH_SZ; i++) { 6520 while ((mcp = mhp->mh_hash[i]) != NULL) { 6521 mhp->mh_hash[i] = mcp->mc_next; 6522 free(mcp->mc_special); 6523 free(mcp->mc_mntpt); 6524 free(mcp->mc_fstype); 6525 free(mcp); 6526 } 6527 } 6528 6529 for (i = 0; i < MH_HASH_SZ; i++) { 6530 assert(mhp->mh_hash[i] == NULL); 6531 } 6532 free(mhp); 6533 } 6534 6535 static mh_search_t 6536 search_hash(mhash_t *mhp, char *special, char **mntpt) 6537 { 6538 int idx; 6539 mcache_t *mcp; 6540 const char *fcn = "search_hash()"; 6541 6542 assert(mntpt); 6543 6544 *mntpt = NULL; 6545 6546 INJECT_ERROR1("SEARCH_HASH_FULL_PATH", special = "/foo"); 6547 if (strchr(special, '/')) { 6548 bam_error(_("invalid key for mnttab hash: %s\n"), special); 6549 return (MH_ERROR); 6550 } 6551 6552 idx = mhash_fcn(special); 6553 6554 for (mcp = mhp->mh_hash[idx]; mcp; mcp = mcp->mc_next) { 6555 if (strcmp(mcp->mc_special, special) == 0) 6556 break; 6557 } 6558 6559 if (mcp == NULL) { 6560 BAM_DPRINTF(("%s: no match in cache for: %s\n", fcn, special)); 6561 return (MH_NOMATCH); 6562 } 6563 6564 assert(strcmp(mcp->mc_fstype, "ufs") == 0); 6565 *mntpt = mcp->mc_mntpt; 6566 BAM_DPRINTF(("%s: *MATCH* in cache for: %s\n", fcn, special)); 6567 return (MH_MATCH); 6568 } 6569 6570 static int 6571 check_add_ufs_sign_to_list(FILE *tfp, char *mntpt) 6572 { 6573 char *sign; 6574 char *signline; 6575 char signbuf[MAXNAMELEN]; 6576 int len; 6577 int error; 6578 const char *fcn = "check_add_ufs_sign_to_list()"; 6579 6580 /* safe to specify NULL as "osdev" arg for UFS */ 6581 sign = find_existing_sign(mntpt, NULL, "ufs"); 6582 if (sign == NULL) { 6583 /* No existing signature, nothing to add to list */ 6584 BAM_DPRINTF(("%s: no sign on %s to add to signlist\n", 6585 fcn, mntpt)); 6586 return (0); 6587 } 6588 6589 (void) snprintf(signbuf, sizeof (signbuf), "%s\n", sign); 6590 signline = signbuf; 6591 6592 INJECT_ERROR1("UFS_MNTPT_SIGN_NOTUFS", signline = "pool_rpool10\n"); 6593 if (strncmp(signline, GRUBSIGN_UFS_PREFIX, 6594 strlen(GRUBSIGN_UFS_PREFIX))) { 6595 bam_error(_("invalid UFS boot signature %s\n"), sign); 6596 free(sign); 6597 /* ignore invalid signatures */ 6598 return (0); 6599 } 6600 6601 len = fputs(signline, tfp); 6602 error = errno; 6603 INJECT_ERROR1("SIGN_LIST_PUTS_ERROR", len = 0); 6604 if (len != strlen(signline)) { 6605 bam_error(_("failed to write signature %s to signature " 6606 "list: %s\n"), sign, strerror(error)); 6607 free(sign); 6608 return (-1); 6609 } 6610 6611 free(sign); 6612 6613 BAM_DPRINTF(("%s: successfully added sign on %s to signlist\n", 6614 fcn, mntpt)); 6615 return (0); 6616 } 6617 6618 /* 6619 * slice is a basename not a full pathname 6620 */ 6621 static int 6622 process_slice_common(char *slice, FILE *tfp, mhash_t *mhp, char *tmpmnt) 6623 { 6624 int ret; 6625 char cmd[PATH_MAX]; 6626 char path[PATH_MAX]; 6627 struct stat sbuf; 6628 char *mntpt; 6629 filelist_t flist = {0}; 6630 char *fstype; 6631 char blkslice[PATH_MAX]; 6632 const char *fcn = "process_slice_common()"; 6633 6634 6635 ret = search_hash(mhp, slice, &mntpt); 6636 switch (ret) { 6637 case MH_MATCH: 6638 if (check_add_ufs_sign_to_list(tfp, mntpt) == -1) 6639 return (-1); 6640 else 6641 return (0); 6642 case MH_NOMATCH: 6643 break; 6644 case MH_ERROR: 6645 default: 6646 return (-1); 6647 } 6648 6649 (void) snprintf(path, sizeof (path), "/dev/rdsk/%s", slice); 6650 if (stat(path, &sbuf) == -1) { 6651 BAM_DPRINTF(("%s: slice does not exist: %s\n", fcn, path)); 6652 return (0); 6653 } 6654 6655 /* Check if ufs. Call ufs fstyp directly to avoid pcfs conflicts. */ 6656 (void) snprintf(cmd, sizeof (cmd), 6657 "/usr/lib/fs/ufs/fstyp /dev/rdsk/%s 2>/dev/null", 6658 slice); 6659 6660 if (exec_cmd(cmd, &flist) != 0) { 6661 if (bam_verbose) 6662 bam_print(_("fstyp failed for slice: %s\n"), slice); 6663 return (0); 6664 } 6665 6666 if ((flist.head == NULL) || (flist.head != flist.tail)) { 6667 if (bam_verbose) 6668 bam_print(_("bad output from fstyp for slice: %s\n"), 6669 slice); 6670 filelist_free(&flist); 6671 return (0); 6672 } 6673 6674 fstype = strtok(flist.head->line, " \t\n"); 6675 if (fstype == NULL || strcmp(fstype, "ufs") != 0) { 6676 if (bam_verbose) 6677 bam_print(_("%s is not a ufs slice: %s\n"), 6678 slice, fstype); 6679 filelist_free(&flist); 6680 return (0); 6681 } 6682 6683 filelist_free(&flist); 6684 6685 /* 6686 * Since we are mounting the filesystem read-only, the 6687 * the last mount field of the superblock is unchanged 6688 * and does not need to be fixed up post-mount; 6689 */ 6690 6691 (void) snprintf(blkslice, sizeof (blkslice), "/dev/dsk/%s", 6692 slice); 6693 6694 (void) snprintf(cmd, sizeof (cmd), 6695 "/usr/sbin/mount -F ufs -o ro %s %s " 6696 "> /dev/null 2>&1", blkslice, tmpmnt); 6697 6698 if (exec_cmd(cmd, NULL) != 0) { 6699 if (bam_verbose) 6700 bam_print(_("mount of %s (fstype %s) failed\n"), 6701 blkslice, "ufs"); 6702 return (0); 6703 } 6704 6705 ret = check_add_ufs_sign_to_list(tfp, tmpmnt); 6706 6707 (void) snprintf(cmd, sizeof (cmd), 6708 "/usr/sbin/umount -f %s > /dev/null 2>&1", 6709 tmpmnt); 6710 6711 if (exec_cmd(cmd, NULL) != 0) { 6712 bam_print(_("umount of %s failed\n"), slice); 6713 return (0); 6714 } 6715 6716 return (ret); 6717 } 6718 6719 static int 6720 process_vtoc_slices( 6721 char *s0, 6722 struct vtoc *vtoc, 6723 FILE *tfp, 6724 mhash_t *mhp, 6725 char *tmpmnt) 6726 { 6727 int idx; 6728 char slice[PATH_MAX]; 6729 size_t len; 6730 char *cp; 6731 const char *fcn = "process_vtoc_slices()"; 6732 6733 len = strlen(s0); 6734 6735 assert(s0[len - 2] == 's' && s0[len - 1] == '0'); 6736 6737 s0[len - 1] = '\0'; 6738 6739 (void) strlcpy(slice, s0, sizeof (slice)); 6740 6741 s0[len - 1] = '0'; 6742 6743 cp = slice + len - 1; 6744 6745 for (idx = 0; idx < vtoc->v_nparts; idx++) { 6746 6747 (void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx); 6748 6749 if (vtoc->v_part[idx].p_size == 0) { 6750 BAM_DPRINTF(("%s: VTOC: skipping 0-length slice: %s\n", 6751 fcn, slice)); 6752 continue; 6753 } 6754 6755 /* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */ 6756 switch (vtoc->v_part[idx].p_tag) { 6757 case V_SWAP: 6758 case V_USR: 6759 case V_BACKUP: 6760 case V_VAR: 6761 case V_HOME: 6762 case V_ALTSCTR: 6763 BAM_DPRINTF(("%s: VTOC: unsupported tag, " 6764 "skipping: %s\n", fcn, slice)); 6765 continue; 6766 default: 6767 BAM_DPRINTF(("%s: VTOC: supported tag, checking: %s\n", 6768 fcn, slice)); 6769 break; 6770 } 6771 6772 /* skip unmountable and readonly slices */ 6773 switch (vtoc->v_part[idx].p_flag) { 6774 case V_UNMNT: 6775 case V_RONLY: 6776 BAM_DPRINTF(("%s: VTOC: non-RDWR flag, skipping: %s\n", 6777 fcn, slice)); 6778 continue; 6779 default: 6780 BAM_DPRINTF(("%s: VTOC: RDWR flag, checking: %s\n", 6781 fcn, slice)); 6782 break; 6783 } 6784 6785 if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) { 6786 return (-1); 6787 } 6788 } 6789 6790 return (0); 6791 } 6792 6793 static int 6794 process_efi_slices( 6795 char *s0, 6796 struct dk_gpt *efi, 6797 FILE *tfp, 6798 mhash_t *mhp, 6799 char *tmpmnt) 6800 { 6801 int idx; 6802 char slice[PATH_MAX]; 6803 size_t len; 6804 char *cp; 6805 const char *fcn = "process_efi_slices()"; 6806 6807 len = strlen(s0); 6808 6809 assert(s0[len - 2] == 's' && s0[len - 1] == '0'); 6810 6811 s0[len - 1] = '\0'; 6812 6813 (void) strlcpy(slice, s0, sizeof (slice)); 6814 6815 s0[len - 1] = '0'; 6816 6817 cp = slice + len - 1; 6818 6819 for (idx = 0; idx < efi->efi_nparts; idx++) { 6820 6821 (void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx); 6822 6823 if (efi->efi_parts[idx].p_size == 0) { 6824 BAM_DPRINTF(("%s: EFI: skipping 0-length slice: %s\n", 6825 fcn, slice)); 6826 continue; 6827 } 6828 6829 /* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */ 6830 switch (efi->efi_parts[idx].p_tag) { 6831 case V_SWAP: 6832 case V_USR: 6833 case V_BACKUP: 6834 case V_VAR: 6835 case V_HOME: 6836 case V_ALTSCTR: 6837 BAM_DPRINTF(("%s: EFI: unsupported tag, skipping: %s\n", 6838 fcn, slice)); 6839 continue; 6840 default: 6841 BAM_DPRINTF(("%s: EFI: supported tag, checking: %s\n", 6842 fcn, slice)); 6843 break; 6844 } 6845 6846 /* skip unmountable and readonly slices */ 6847 switch (efi->efi_parts[idx].p_flag) { 6848 case V_UNMNT: 6849 case V_RONLY: 6850 BAM_DPRINTF(("%s: EFI: non-RDWR flag, skipping: %s\n", 6851 fcn, slice)); 6852 continue; 6853 default: 6854 BAM_DPRINTF(("%s: EFI: RDWR flag, checking: %s\n", 6855 fcn, slice)); 6856 break; 6857 } 6858 6859 if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) { 6860 return (-1); 6861 } 6862 } 6863 6864 return (0); 6865 } 6866 6867 /* 6868 * s0 is a basename not a full path 6869 */ 6870 static int 6871 process_slice0(char *s0, FILE *tfp, mhash_t *mhp, char *tmpmnt) 6872 { 6873 struct vtoc vtoc; 6874 struct dk_gpt *efi; 6875 char s0path[PATH_MAX]; 6876 struct stat sbuf; 6877 int e_flag; 6878 int v_flag; 6879 int retval; 6880 int err; 6881 int fd; 6882 const char *fcn = "process_slice0()"; 6883 6884 (void) snprintf(s0path, sizeof (s0path), "/dev/rdsk/%s", s0); 6885 6886 if (stat(s0path, &sbuf) == -1) { 6887 BAM_DPRINTF(("%s: slice 0 does not exist: %s\n", fcn, s0path)); 6888 return (0); 6889 } 6890 6891 fd = open(s0path, O_NONBLOCK|O_RDONLY); 6892 if (fd == -1) { 6893 bam_error(_("failed to open file: %s: %s\n"), s0path, 6894 strerror(errno)); 6895 return (0); 6896 } 6897 6898 e_flag = v_flag = 0; 6899 retval = ((err = read_vtoc(fd, &vtoc)) >= 0) ? 0 : err; 6900 switch (retval) { 6901 case VT_EIO: 6902 BAM_DPRINTF(("%s: VTOC: failed to read: %s\n", 6903 fcn, s0path)); 6904 break; 6905 case VT_EINVAL: 6906 BAM_DPRINTF(("%s: VTOC: is INVALID: %s\n", 6907 fcn, s0path)); 6908 break; 6909 case VT_ERROR: 6910 BAM_DPRINTF(("%s: VTOC: unknown error while " 6911 "reading: %s\n", fcn, s0path)); 6912 break; 6913 case VT_ENOTSUP: 6914 e_flag = 1; 6915 BAM_DPRINTF(("%s: VTOC: not supported: %s\n", 6916 fcn, s0path)); 6917 break; 6918 case 0: 6919 v_flag = 1; 6920 BAM_DPRINTF(("%s: VTOC: SUCCESS reading: %s\n", 6921 fcn, s0path)); 6922 break; 6923 default: 6924 BAM_DPRINTF(("%s: VTOC: READ: unknown return " 6925 "code: %s\n", fcn, s0path)); 6926 break; 6927 } 6928 6929 6930 if (e_flag) { 6931 e_flag = 0; 6932 retval = ((err = efi_alloc_and_read(fd, &efi)) >= 0) ? 0 : err; 6933 switch (retval) { 6934 case VT_EIO: 6935 BAM_DPRINTF(("%s: EFI: failed to read: %s\n", 6936 fcn, s0path)); 6937 break; 6938 case VT_EINVAL: 6939 BAM_DPRINTF(("%s: EFI: is INVALID: %s\n", fcn, s0path)); 6940 break; 6941 case VT_ERROR: 6942 BAM_DPRINTF(("%s: EFI: unknown error while " 6943 "reading: %s\n", fcn, s0path)); 6944 break; 6945 case VT_ENOTSUP: 6946 BAM_DPRINTF(("%s: EFI: not supported: %s\n", 6947 fcn, s0path)); 6948 break; 6949 case 0: 6950 e_flag = 1; 6951 BAM_DPRINTF(("%s: EFI: SUCCESS reading: %s\n", 6952 fcn, s0path)); 6953 break; 6954 default: 6955 BAM_DPRINTF(("%s: EFI: READ: unknown return code: %s\n", 6956 fcn, s0path)); 6957 break; 6958 } 6959 } 6960 6961 (void) close(fd); 6962 6963 if (v_flag) { 6964 retval = process_vtoc_slices(s0, 6965 &vtoc, tfp, mhp, tmpmnt); 6966 } else if (e_flag) { 6967 retval = process_efi_slices(s0, 6968 efi, tfp, mhp, tmpmnt); 6969 } else { 6970 BAM_DPRINTF(("%s: disk has neither VTOC nor EFI: %s\n", 6971 fcn, s0path)); 6972 return (0); 6973 } 6974 6975 return (retval); 6976 } 6977 6978 /* 6979 * Find and create a list of all existing UFS boot signatures 6980 */ 6981 static int 6982 FindAllUfsSignatures(void) 6983 { 6984 mhash_t *mnttab_hash; 6985 DIR *dirp = NULL; 6986 struct dirent *dp; 6987 char tmpmnt[PATH_MAX]; 6988 char cmd[PATH_MAX]; 6989 struct stat sb; 6990 int fd; 6991 FILE *tfp; 6992 size_t len; 6993 int ret; 6994 int error; 6995 const char *fcn = "FindAllUfsSignatures()"; 6996 6997 if (stat(UFS_SIGNATURE_LIST, &sb) != -1) { 6998 bam_print(_(" - signature list %s exists\n"), 6999 UFS_SIGNATURE_LIST); 7000 return (0); 7001 } 7002 7003 fd = open(UFS_SIGNATURE_LIST".tmp", 7004 O_RDWR|O_CREAT|O_TRUNC, 0644); 7005 error = errno; 7006 INJECT_ERROR1("SIGN_LIST_TMP_TRUNC", fd = -1); 7007 if (fd == -1) { 7008 bam_error(_("failed to open file: %s: %s\n"), 7009 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7010 return (-1); 7011 } 7012 7013 ret = close(fd); 7014 error = errno; 7015 INJECT_ERROR1("SIGN_LIST_TMP_CLOSE", ret = -1); 7016 if (ret == -1) { 7017 bam_error(_("failed to close file: %s: %s\n"), 7018 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7019 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7020 return (-1); 7021 } 7022 7023 tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a"); 7024 error = errno; 7025 INJECT_ERROR1("SIGN_LIST_APPEND_FOPEN", tfp = NULL); 7026 if (tfp == NULL) { 7027 bam_error(_("failed to open file: %s: %s\n"), 7028 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7029 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7030 return (-1); 7031 } 7032 7033 mnttab_hash = cache_mnttab(); 7034 INJECT_ERROR1("CACHE_MNTTAB_ERROR", mnttab_hash = NULL); 7035 if (mnttab_hash == NULL) { 7036 (void) fclose(tfp); 7037 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7038 bam_error(_("%s: failed to cache /etc/mnttab\n"), fcn); 7039 return (-1); 7040 } 7041 7042 (void) snprintf(tmpmnt, sizeof (tmpmnt), 7043 "/tmp/bootadm_ufs_sign_mnt.%d", getpid()); 7044 (void) unlink(tmpmnt); 7045 7046 ret = mkdirp(tmpmnt, DIR_PERMS); 7047 error = errno; 7048 INJECT_ERROR1("MKDIRP_SIGN_MNT", ret = -1); 7049 if (ret == -1) { 7050 bam_error(_("mkdir of %s failed: %s\n"), tmpmnt, 7051 strerror(error)); 7052 free_mnttab(mnttab_hash); 7053 (void) fclose(tfp); 7054 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7055 return (-1); 7056 } 7057 7058 dirp = opendir("/dev/rdsk"); 7059 error = errno; 7060 INJECT_ERROR1("OPENDIR_DEV_RDSK", dirp = NULL); 7061 if (dirp == NULL) { 7062 bam_error(_("opendir of %s failed: %s\n"), "/dev/rdsk", 7063 strerror(error)); 7064 goto fail; 7065 } 7066 7067 while ((dp = readdir(dirp)) != NULL) { 7068 if (strcmp(dp->d_name, ".") == 0 || 7069 strcmp(dp->d_name, "..") == 0) 7070 continue; 7071 7072 /* 7073 * we only look for the s0 slice. This is guranteed to 7074 * have 's' at len - 2. 7075 */ 7076 len = strlen(dp->d_name); 7077 if (dp->d_name[len - 2 ] != 's' || dp->d_name[len - 1] != '0') { 7078 BAM_DPRINTF(("%s: skipping non-s0 slice: %s\n", 7079 fcn, dp->d_name)); 7080 continue; 7081 } 7082 7083 ret = process_slice0(dp->d_name, tfp, mnttab_hash, tmpmnt); 7084 INJECT_ERROR1("PROCESS_S0_FAIL", ret = -1); 7085 if (ret == -1) 7086 goto fail; 7087 } 7088 7089 (void) closedir(dirp); 7090 free_mnttab(mnttab_hash); 7091 (void) rmdir(tmpmnt); 7092 7093 ret = fclose(tfp); 7094 error = errno; 7095 INJECT_ERROR1("FCLOSE_SIGNLIST_TMP", ret = EOF); 7096 if (ret == EOF) { 7097 bam_error(_("failed to close file: %s: %s\n"), 7098 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7099 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7100 return (-1); 7101 } 7102 7103 /* We have a list of existing GRUB signatures. Sort it first */ 7104 (void) snprintf(cmd, sizeof (cmd), 7105 "/usr/bin/sort -u %s.tmp > %s.sorted", 7106 UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST); 7107 7108 ret = exec_cmd(cmd, NULL); 7109 INJECT_ERROR1("SORT_SIGN_LIST", ret = 1); 7110 if (ret != 0) { 7111 bam_error(_("error sorting GRUB UFS boot signatures\n")); 7112 (void) unlink(UFS_SIGNATURE_LIST".sorted"); 7113 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7114 return (-1); 7115 } 7116 7117 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7118 7119 ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST); 7120 error = errno; 7121 INJECT_ERROR1("RENAME_TMP_SIGNLIST", ret = -1); 7122 if (ret == -1) { 7123 bam_error(_("rename to file failed: %s: %s\n"), 7124 UFS_SIGNATURE_LIST, strerror(error)); 7125 (void) unlink(UFS_SIGNATURE_LIST".sorted"); 7126 return (-1); 7127 } 7128 7129 if (stat(UFS_SIGNATURE_LIST, &sb) == 0 && sb.st_size == 0) { 7130 BAM_DPRINTF(("%s: generated zero length signlist: %s.\n", 7131 fcn, UFS_SIGNATURE_LIST)); 7132 } 7133 7134 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7135 return (0); 7136 7137 fail: 7138 if (dirp) 7139 (void) closedir(dirp); 7140 free_mnttab(mnttab_hash); 7141 (void) rmdir(tmpmnt); 7142 (void) fclose(tfp); 7143 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7144 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7145 return (-1); 7146 } 7147 7148 static char * 7149 create_ufs_sign(void) 7150 { 7151 struct stat sb; 7152 int signnum = -1; 7153 char tmpsign[MAXNAMELEN + 1]; 7154 char *numstr; 7155 int i; 7156 FILE *tfp; 7157 int ret; 7158 int error; 7159 const char *fcn = "create_ufs_sign()"; 7160 7161 bam_print(_(" - searching for UFS boot signatures\n")); 7162 7163 ret = FindAllUfsSignatures(); 7164 INJECT_ERROR1("FIND_ALL_UFS", ret = -1); 7165 if (ret == -1) { 7166 bam_error(_("search for UFS boot signatures failed\n")); 7167 return (NULL); 7168 } 7169 7170 /* Make sure the list exists and is owned by root */ 7171 INJECT_ERROR1("SIGNLIST_NOT_CREATED", 7172 (void) unlink(UFS_SIGNATURE_LIST)); 7173 if (stat(UFS_SIGNATURE_LIST, &sb) == -1 || sb.st_uid != 0) { 7174 (void) unlink(UFS_SIGNATURE_LIST); 7175 bam_error(_("missing UFS signature list file: %s\n"), 7176 UFS_SIGNATURE_LIST); 7177 return (NULL); 7178 } 7179 7180 if (sb.st_size == 0) { 7181 bam_print(_(" - no existing UFS boot signatures\n")); 7182 i = 0; 7183 goto found; 7184 } 7185 7186 /* The signature list was sorted when it was created */ 7187 tfp = fopen(UFS_SIGNATURE_LIST, "r"); 7188 error = errno; 7189 INJECT_ERROR1("FOPEN_SIGN_LIST", tfp = NULL); 7190 if (tfp == NULL) { 7191 bam_error(_("error opening UFS boot signature list " 7192 "file %s: %s\n"), UFS_SIGNATURE_LIST, strerror(error)); 7193 (void) unlink(UFS_SIGNATURE_LIST); 7194 return (NULL); 7195 } 7196 7197 for (i = 0; s_fgets(tmpsign, sizeof (tmpsign), tfp); i++) { 7198 7199 if (strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 7200 strlen(GRUBSIGN_UFS_PREFIX)) != 0) { 7201 (void) fclose(tfp); 7202 (void) unlink(UFS_SIGNATURE_LIST); 7203 bam_error(_("bad UFS boot signature: %s\n"), tmpsign); 7204 return (NULL); 7205 } 7206 numstr = tmpsign + strlen(GRUBSIGN_UFS_PREFIX); 7207 7208 if (numstr[0] == '\0' || !isdigit(numstr[0])) { 7209 (void) fclose(tfp); 7210 (void) unlink(UFS_SIGNATURE_LIST); 7211 bam_error(_("bad UFS boot signature: %s\n"), tmpsign); 7212 return (NULL); 7213 } 7214 7215 signnum = atoi(numstr); 7216 INJECT_ERROR1("NEGATIVE_SIGN", signnum = -1); 7217 if (signnum < 0) { 7218 (void) fclose(tfp); 7219 (void) unlink(UFS_SIGNATURE_LIST); 7220 bam_error(_("bad UFS boot signature: %s\n"), tmpsign); 7221 return (NULL); 7222 } 7223 7224 if (i != signnum) { 7225 BAM_DPRINTF(("%s: found hole %d in sign list.\n", 7226 fcn, i)); 7227 break; 7228 } 7229 } 7230 7231 (void) fclose(tfp); 7232 7233 found: 7234 (void) snprintf(tmpsign, sizeof (tmpsign), "rootfs%d", i); 7235 7236 /* add the ufs signature to the /var/run list of signatures */ 7237 ret = ufs_add_to_sign_list(tmpsign); 7238 INJECT_ERROR1("UFS_ADD_TO_SIGN_LIST", ret = -1); 7239 if (ret == -1) { 7240 (void) unlink(UFS_SIGNATURE_LIST); 7241 bam_error(_("failed to add sign %s to signlist.\n"), tmpsign); 7242 return (NULL); 7243 } 7244 7245 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7246 7247 return (s_strdup(tmpsign)); 7248 } 7249 7250 static char * 7251 get_fstype(char *osroot) 7252 { 7253 FILE *mntfp; 7254 struct mnttab mp = {0}; 7255 struct mnttab mpref = {0}; 7256 int error; 7257 int ret; 7258 const char *fcn = "get_fstype()"; 7259 7260 INJECT_ERROR1("GET_FSTYPE_OSROOT", osroot = NULL); 7261 if (osroot == NULL) { 7262 bam_error(_("no OS mountpoint. Cannot determine fstype\n")); 7263 return (NULL); 7264 } 7265 7266 mntfp = fopen(MNTTAB, "r"); 7267 error = errno; 7268 INJECT_ERROR1("GET_FSTYPE_FOPEN", mntfp = NULL); 7269 if (mntfp == NULL) { 7270 bam_error(_("failed to open file: %s: %s\n"), MNTTAB, 7271 strerror(error)); 7272 return (NULL); 7273 } 7274 7275 if (*osroot == '\0') 7276 mpref.mnt_mountp = "/"; 7277 else 7278 mpref.mnt_mountp = osroot; 7279 7280 ret = getmntany(mntfp, &mp, &mpref); 7281 INJECT_ERROR1("GET_FSTYPE_GETMNTANY", ret = 1); 7282 if (ret != 0) { 7283 bam_error(_("failed to find OS mountpoint %s in %s\n"), 7284 osroot, MNTTAB); 7285 (void) fclose(mntfp); 7286 return (NULL); 7287 } 7288 (void) fclose(mntfp); 7289 7290 INJECT_ERROR1("GET_FSTYPE_NULL", mp.mnt_fstype = NULL); 7291 if (mp.mnt_fstype == NULL) { 7292 bam_error(_("NULL fstype found for OS root %s\n"), osroot); 7293 return (NULL); 7294 } 7295 7296 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7297 7298 return (s_strdup(mp.mnt_fstype)); 7299 } 7300 7301 static char * 7302 create_zfs_sign(char *osdev) 7303 { 7304 char tmpsign[PATH_MAX]; 7305 char *pool; 7306 const char *fcn = "create_zfs_sign()"; 7307 7308 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, osdev)); 7309 7310 /* 7311 * First find the pool name 7312 */ 7313 pool = get_pool(osdev); 7314 INJECT_ERROR1("CREATE_ZFS_SIGN_GET_POOL", pool = NULL); 7315 if (pool == NULL) { 7316 bam_error(_("failed to get pool name from %s\n"), osdev); 7317 return (NULL); 7318 } 7319 7320 (void) snprintf(tmpsign, sizeof (tmpsign), "pool_%s", pool); 7321 7322 BAM_DPRINTF(("%s: created ZFS sign: %s\n", fcn, tmpsign)); 7323 7324 free(pool); 7325 7326 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7327 7328 return (s_strdup(tmpsign)); 7329 } 7330 7331 static char * 7332 create_new_sign(char *osdev, char *fstype) 7333 { 7334 char *sign; 7335 const char *fcn = "create_new_sign()"; 7336 7337 INJECT_ERROR1("NEW_SIGN_FSTYPE", fstype = "foofs"); 7338 7339 if (strcmp(fstype, "zfs") == 0) { 7340 BAM_DPRINTF(("%s: created new ZFS sign\n", fcn)); 7341 sign = create_zfs_sign(osdev); 7342 } else if (strcmp(fstype, "ufs") == 0) { 7343 BAM_DPRINTF(("%s: created new UFS sign\n", fcn)); 7344 sign = create_ufs_sign(); 7345 } else { 7346 bam_error(_("boot signature not supported for fstype: %s\n"), 7347 fstype); 7348 sign = NULL; 7349 } 7350 7351 BAM_DPRINTF(("%s: created new sign: %s\n", fcn, 7352 sign ? sign : "<NULL>")); 7353 return (sign); 7354 } 7355 7356 static int 7357 set_backup_common(char *mntpt, char *sign) 7358 { 7359 FILE *bfp; 7360 char backup[PATH_MAX]; 7361 char tmpsign[PATH_MAX]; 7362 int error; 7363 char *bdir; 7364 char *backup_dup; 7365 struct stat sb; 7366 int ret; 7367 const char *fcn = "set_backup_common()"; 7368 7369 (void) snprintf(backup, sizeof (backup), "%s%s", 7370 mntpt, GRUBSIGN_BACKUP); 7371 7372 /* First read the backup */ 7373 bfp = fopen(backup, "r"); 7374 if (bfp != NULL) { 7375 while (s_fgets(tmpsign, sizeof (tmpsign), bfp)) { 7376 if (strcmp(tmpsign, sign) == 0) { 7377 BAM_DPRINTF(("%s: found sign (%s) in backup.\n", 7378 fcn, sign)); 7379 (void) fclose(bfp); 7380 return (0); 7381 } 7382 } 7383 (void) fclose(bfp); 7384 BAM_DPRINTF(("%s: backup exists but sign %s not found\n", 7385 fcn, sign)); 7386 } else { 7387 BAM_DPRINTF(("%s: no backup file (%s) found.\n", fcn, backup)); 7388 } 7389 7390 /* 7391 * Didn't find the correct signature. First create 7392 * the directory if necessary. 7393 */ 7394 7395 /* dirname() modifies its argument so dup it */ 7396 backup_dup = s_strdup(backup); 7397 bdir = dirname(backup_dup); 7398 assert(bdir); 7399 7400 ret = stat(bdir, &sb); 7401 INJECT_ERROR1("SET_BACKUP_STAT", ret = -1); 7402 if (ret == -1) { 7403 BAM_DPRINTF(("%s: backup dir (%s) does not exist.\n", 7404 fcn, bdir)); 7405 ret = mkdirp(bdir, DIR_PERMS); 7406 error = errno; 7407 INJECT_ERROR1("SET_BACKUP_MKDIRP", ret = -1); 7408 if (ret == -1) { 7409 bam_error(_("mkdirp() of backup dir failed: %s: %s\n"), 7410 GRUBSIGN_BACKUP, strerror(error)); 7411 free(backup_dup); 7412 return (-1); 7413 } 7414 } 7415 free(backup_dup); 7416 7417 /* 7418 * Open the backup in append mode to add the correct 7419 * signature; 7420 */ 7421 bfp = fopen(backup, "a"); 7422 error = errno; 7423 INJECT_ERROR1("SET_BACKUP_FOPEN_A", bfp = NULL); 7424 if (bfp == NULL) { 7425 bam_error(_("error opening boot signature backup " 7426 "file %s: %s\n"), GRUBSIGN_BACKUP, strerror(error)); 7427 return (-1); 7428 } 7429 7430 (void) snprintf(tmpsign, sizeof (tmpsign), "%s\n", sign); 7431 7432 ret = fputs(tmpsign, bfp); 7433 error = errno; 7434 INJECT_ERROR1("SET_BACKUP_FPUTS", ret = 0); 7435 if (ret != strlen(tmpsign)) { 7436 bam_error(_("error writing boot signature backup " 7437 "file %s: %s\n"), GRUBSIGN_BACKUP, strerror(error)); 7438 (void) fclose(bfp); 7439 return (-1); 7440 } 7441 7442 (void) fclose(bfp); 7443 7444 if (bam_verbose) 7445 bam_print(_("updated boot signature backup file %s\n"), 7446 GRUBSIGN_BACKUP); 7447 7448 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7449 7450 return (0); 7451 } 7452 7453 static int 7454 set_backup_ufs(char *osroot, char *sign) 7455 { 7456 const char *fcn = "set_backup_ufs()"; 7457 7458 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, sign)); 7459 return (set_backup_common(osroot, sign)); 7460 } 7461 7462 static int 7463 set_backup_zfs(char *osdev, char *sign) 7464 { 7465 char *pool; 7466 char *mntpt; 7467 zfs_mnted_t mnted; 7468 int ret; 7469 const char *fcn = "set_backup_zfs()"; 7470 7471 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osdev, sign)); 7472 7473 pool = get_pool(osdev); 7474 INJECT_ERROR1("SET_BACKUP_GET_POOL", pool = NULL); 7475 if (pool == NULL) { 7476 bam_error(_("failed to get pool name from %s\n"), osdev); 7477 return (-1); 7478 } 7479 7480 mntpt = mount_top_dataset(pool, &mnted); 7481 INJECT_ERROR1("SET_BACKUP_MOUNT_DATASET", mntpt = NULL); 7482 if (mntpt == NULL) { 7483 bam_error(_("failed to mount top dataset for %s\n"), pool); 7484 free(pool); 7485 return (-1); 7486 } 7487 7488 ret = set_backup_common(mntpt, sign); 7489 7490 (void) umount_top_dataset(pool, mnted, mntpt); 7491 7492 free(pool); 7493 7494 INJECT_ERROR1("SET_BACKUP_ZFS_FAIL", ret = 1); 7495 if (ret == 0) { 7496 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7497 } else { 7498 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7499 } 7500 7501 return (ret); 7502 } 7503 7504 static int 7505 set_backup(char *osroot, char *osdev, char *sign, char *fstype) 7506 { 7507 const char *fcn = "set_backup()"; 7508 int ret; 7509 7510 INJECT_ERROR1("SET_BACKUP_FSTYPE", fstype = "foofs"); 7511 7512 if (strcmp(fstype, "ufs") == 0) { 7513 BAM_DPRINTF(("%s: setting UFS backup sign\n", fcn)); 7514 ret = set_backup_ufs(osroot, sign); 7515 } else if (strcmp(fstype, "zfs") == 0) { 7516 BAM_DPRINTF(("%s: setting ZFS backup sign\n", fcn)); 7517 ret = set_backup_zfs(osdev, sign); 7518 } else { 7519 bam_error(_("boot signature not supported for fstype: %s\n"), 7520 fstype); 7521 ret = -1; 7522 } 7523 7524 if (ret == 0) { 7525 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7526 } else { 7527 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7528 } 7529 7530 return (ret); 7531 } 7532 7533 static int 7534 set_primary_common(char *mntpt, char *sign) 7535 { 7536 char signfile[PATH_MAX]; 7537 char signdir[PATH_MAX]; 7538 struct stat sb; 7539 int fd; 7540 int error; 7541 int ret; 7542 const char *fcn = "set_primary_common()"; 7543 7544 (void) snprintf(signfile, sizeof (signfile), "%s/%s/%s", 7545 mntpt, GRUBSIGN_DIR, sign); 7546 7547 if (stat(signfile, &sb) != -1) { 7548 if (bam_verbose) 7549 bam_print(_("primary sign %s exists\n"), sign); 7550 return (0); 7551 } else { 7552 BAM_DPRINTF(("%s: primary sign (%s) does not exist\n", 7553 fcn, signfile)); 7554 } 7555 7556 (void) snprintf(signdir, sizeof (signdir), "%s/%s", 7557 mntpt, GRUBSIGN_DIR); 7558 7559 if (stat(signdir, &sb) == -1) { 7560 BAM_DPRINTF(("%s: primary signdir (%s) does not exist\n", 7561 fcn, signdir)); 7562 ret = mkdirp(signdir, DIR_PERMS); 7563 error = errno; 7564 INJECT_ERROR1("SET_PRIMARY_MKDIRP", ret = -1); 7565 if (ret == -1) { 7566 bam_error(_("error creating boot signature " 7567 "directory %s: %s\n"), signdir, strerror(errno)); 7568 return (-1); 7569 } 7570 } 7571 7572 fd = open(signfile, O_RDWR|O_CREAT|O_TRUNC, 0444); 7573 error = errno; 7574 INJECT_ERROR1("PRIMARY_SIGN_CREAT", fd = -1); 7575 if (fd == -1) { 7576 bam_error(_("error creating primary boot signature %s: %s\n"), 7577 signfile, strerror(error)); 7578 return (-1); 7579 } 7580 7581 ret = fsync(fd); 7582 error = errno; 7583 INJECT_ERROR1("PRIMARY_FSYNC", ret = -1); 7584 if (ret != 0) { 7585 bam_error(_("error syncing primary boot signature %s: %s\n"), 7586 signfile, strerror(error)); 7587 } 7588 7589 (void) close(fd); 7590 7591 if (bam_verbose) 7592 bam_print(_("created primary GRUB boot signature: %s\n"), 7593 signfile); 7594 7595 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7596 7597 return (0); 7598 } 7599 7600 static int 7601 set_primary_ufs(char *osroot, char *sign) 7602 { 7603 const char *fcn = "set_primary_ufs()"; 7604 7605 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, sign)); 7606 return (set_primary_common(osroot, sign)); 7607 } 7608 7609 static int 7610 set_primary_zfs(char *osdev, char *sign) 7611 { 7612 char *pool; 7613 char *mntpt; 7614 zfs_mnted_t mnted; 7615 int ret; 7616 const char *fcn = "set_primary_zfs()"; 7617 7618 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osdev, sign)); 7619 7620 pool = get_pool(osdev); 7621 INJECT_ERROR1("SET_PRIMARY_ZFS_GET_POOL", pool = NULL); 7622 if (pool == NULL) { 7623 bam_error(_("failed to get pool name from %s\n"), osdev); 7624 return (-1); 7625 } 7626 7627 /* Pool name must exist in the sign */ 7628 ret = (strstr(sign, pool) != NULL); 7629 INJECT_ERROR1("SET_PRIMARY_ZFS_POOL_SIGN_INCOMPAT", ret = 0); 7630 if (ret == 0) { 7631 bam_error(_("pool name %s not present in signature %s\n"), 7632 pool, sign); 7633 free(pool); 7634 return (-1); 7635 } 7636 7637 mntpt = mount_top_dataset(pool, &mnted); 7638 INJECT_ERROR1("SET_PRIMARY_ZFS_MOUNT_DATASET", mntpt = NULL); 7639 if (mntpt == NULL) { 7640 bam_error(_("failed to mount top dataset for %s\n"), pool); 7641 free(pool); 7642 return (-1); 7643 } 7644 7645 ret = set_primary_common(mntpt, sign); 7646 7647 (void) umount_top_dataset(pool, mnted, mntpt); 7648 7649 free(pool); 7650 7651 INJECT_ERROR1("SET_PRIMARY_ZFS_FAIL", ret = 1); 7652 if (ret == 0) { 7653 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7654 } else { 7655 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7656 } 7657 7658 return (ret); 7659 } 7660 7661 static int 7662 set_primary(char *osroot, char *osdev, char *sign, char *fstype) 7663 { 7664 const char *fcn = "set_primary()"; 7665 int ret; 7666 7667 INJECT_ERROR1("SET_PRIMARY_FSTYPE", fstype = "foofs"); 7668 if (strcmp(fstype, "ufs") == 0) { 7669 BAM_DPRINTF(("%s: setting UFS primary sign\n", fcn)); 7670 ret = set_primary_ufs(osroot, sign); 7671 } else if (strcmp(fstype, "zfs") == 0) { 7672 BAM_DPRINTF(("%s: setting ZFS primary sign\n", fcn)); 7673 ret = set_primary_zfs(osdev, sign); 7674 } else { 7675 bam_error(_("boot signature not supported for fstype: %s\n"), 7676 fstype); 7677 ret = -1; 7678 } 7679 7680 if (ret == 0) { 7681 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7682 } else { 7683 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7684 } 7685 7686 return (ret); 7687 } 7688 7689 static int 7690 ufs_add_to_sign_list(char *sign) 7691 { 7692 FILE *tfp; 7693 char signline[MAXNAMELEN]; 7694 char cmd[PATH_MAX]; 7695 int ret; 7696 int error; 7697 const char *fcn = "ufs_add_to_sign_list()"; 7698 7699 INJECT_ERROR1("ADD_TO_SIGN_LIST_NOT_UFS", sign = "pool_rpool5"); 7700 if (strncmp(sign, GRUBSIGN_UFS_PREFIX, 7701 strlen(GRUBSIGN_UFS_PREFIX)) != 0) { 7702 bam_error(_("invalid UFS boot signature %s\n"), sign); 7703 (void) unlink(UFS_SIGNATURE_LIST); 7704 return (-1); 7705 } 7706 7707 /* 7708 * most failures in this routine are not a fatal error 7709 * We simply unlink the /var/run file and continue 7710 */ 7711 7712 ret = rename(UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST".tmp"); 7713 error = errno; 7714 INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME", ret = -1); 7715 if (ret == -1) { 7716 bam_error(_("rename to file failed: %s: %s\n"), 7717 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7718 (void) unlink(UFS_SIGNATURE_LIST); 7719 return (0); 7720 } 7721 7722 tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a"); 7723 error = errno; 7724 INJECT_ERROR1("ADD_TO_SIGN_LIST_FOPEN", tfp = NULL); 7725 if (tfp == NULL) { 7726 bam_error(_("failed to open file: %s: %s\n"), 7727 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7728 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7729 return (0); 7730 } 7731 7732 (void) snprintf(signline, sizeof (signline), "%s\n", sign); 7733 7734 ret = fputs(signline, tfp); 7735 error = errno; 7736 INJECT_ERROR1("ADD_TO_SIGN_LIST_FPUTS", ret = 0); 7737 if (ret != strlen(signline)) { 7738 bam_error(_("failed to write signature %s to signature " 7739 "list: %s\n"), sign, strerror(error)); 7740 (void) fclose(tfp); 7741 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7742 return (0); 7743 } 7744 7745 ret = fclose(tfp); 7746 error = errno; 7747 INJECT_ERROR1("ADD_TO_SIGN_LIST_FCLOSE", ret = EOF); 7748 if (ret == EOF) { 7749 bam_error(_("failed to close file: %s: %s\n"), 7750 UFS_SIGNATURE_LIST".tmp", strerror(error)); 7751 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7752 return (0); 7753 } 7754 7755 /* Sort the list again */ 7756 (void) snprintf(cmd, sizeof (cmd), 7757 "/usr/bin/sort -u %s.tmp > %s.sorted", 7758 UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST); 7759 7760 ret = exec_cmd(cmd, NULL); 7761 INJECT_ERROR1("ADD_TO_SIGN_LIST_SORT", ret = 1); 7762 if (ret != 0) { 7763 bam_error(_("error sorting GRUB UFS boot signatures\n")); 7764 (void) unlink(UFS_SIGNATURE_LIST".sorted"); 7765 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7766 return (0); 7767 } 7768 7769 (void) unlink(UFS_SIGNATURE_LIST".tmp"); 7770 7771 ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST); 7772 error = errno; 7773 INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME2", ret = -1); 7774 if (ret == -1) { 7775 bam_error(_("rename to file failed: %s: %s\n"), 7776 UFS_SIGNATURE_LIST, strerror(error)); 7777 (void) unlink(UFS_SIGNATURE_LIST".sorted"); 7778 return (0); 7779 } 7780 7781 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7782 7783 return (0); 7784 } 7785 7786 static int 7787 set_signature(char *osroot, char *osdev, char *sign, char *fstype) 7788 { 7789 int ret; 7790 const char *fcn = "set_signature()"; 7791 7792 BAM_DPRINTF(("%s: entered. args: %s %s %s %s\n", fcn, 7793 osroot, osdev, sign, fstype)); 7794 7795 ret = set_backup(osroot, osdev, sign, fstype); 7796 INJECT_ERROR1("SET_SIGNATURE_BACKUP", ret = -1); 7797 if (ret == -1) { 7798 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7799 bam_error(_("failed to set backup sign (%s) for %s: %s\n"), 7800 sign, osroot, osdev); 7801 return (-1); 7802 } 7803 7804 ret = set_primary(osroot, osdev, sign, fstype); 7805 INJECT_ERROR1("SET_SIGNATURE_PRIMARY", ret = -1); 7806 7807 if (ret == 0) { 7808 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7809 } else { 7810 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 7811 bam_error(_("failed to set primary sign (%s) for %s: %s\n"), 7812 sign, osroot, osdev); 7813 7814 } 7815 return (ret); 7816 } 7817 7818 char * 7819 get_grubsign(char *osroot, char *osdev) 7820 { 7821 char *grubsign; /* (<sign>,#,#) */ 7822 char *slice; 7823 int fdiskpart; 7824 char *sign; 7825 char *fstype; 7826 int ret; 7827 const char *fcn = "get_grubsign()"; 7828 7829 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, osdev)); 7830 fstype = get_fstype(osroot); 7831 INJECT_ERROR1("GET_GRUBSIGN_FSTYPE", fstype = NULL); 7832 if (fstype == NULL) { 7833 bam_error(_("failed to get fstype for %s\n"), osroot); 7834 return (NULL); 7835 } 7836 7837 sign = find_existing_sign(osroot, osdev, fstype); 7838 INJECT_ERROR1("FIND_EXISTING_SIGN", sign = NULL); 7839 if (sign == NULL) { 7840 BAM_DPRINTF(("%s: no existing grubsign for %s: %s\n", 7841 fcn, osroot, osdev)); 7842 sign = create_new_sign(osdev, fstype); 7843 INJECT_ERROR1("CREATE_NEW_SIGN", sign = NULL); 7844 if (sign == NULL) { 7845 bam_error(_("failed to create GRUB boot signature for " 7846 "device: %s\n"), osdev); 7847 free(fstype); 7848 return (NULL); 7849 } 7850 } 7851 7852 ret = set_signature(osroot, osdev, sign, fstype); 7853 INJECT_ERROR1("SET_SIGNATURE_FAIL", ret = -1); 7854 if (ret == -1) { 7855 bam_error(_("failed to write GRUB boot signature for " 7856 "device: %s\n"), osdev); 7857 free(sign); 7858 free(fstype); 7859 (void) unlink(UFS_SIGNATURE_LIST); 7860 return (NULL); 7861 } 7862 7863 free(fstype); 7864 7865 if (bam_verbose) 7866 bam_print(_("found or created GRUB signature %s for %s\n"), 7867 sign, osdev); 7868 7869 fdiskpart = get_partition(osdev); 7870 INJECT_ERROR1("GET_GRUBSIGN_FDISK", fdiskpart = PARTNO_NOTFOUND); 7871 if (fdiskpart == PARTNO_NOTFOUND) { 7872 bam_error(_("failed to determine fdisk partition: %s\n"), 7873 osdev); 7874 free(sign); 7875 return (NULL); 7876 } 7877 7878 slice = strrchr(osdev, 's'); 7879 7880 if (fdiskpart == PARTNO_EFI) { 7881 fdiskpart = atoi(&slice[1]); 7882 slice = NULL; 7883 } 7884 7885 grubsign = s_calloc(1, MAXNAMELEN + 10); 7886 if (slice) { 7887 (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d,%c)", 7888 sign, fdiskpart, slice[1] + 'a' - '0'); 7889 } else 7890 (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d)", 7891 sign, fdiskpart); 7892 7893 free(sign); 7894 7895 BAM_DPRINTF(("%s: successfully created grubsign %s\n", fcn, grubsign)); 7896 7897 return (grubsign); 7898 } 7899 7900 static char * 7901 get_title(char *rootdir) 7902 { 7903 static char title[80]; 7904 char *cp = NULL; 7905 char release[PATH_MAX]; 7906 FILE *fp; 7907 const char *fcn = "get_title()"; 7908 7909 /* open the /etc/release file */ 7910 (void) snprintf(release, sizeof (release), "%s/etc/release", rootdir); 7911 7912 fp = fopen(release, "r"); 7913 if (fp == NULL) { 7914 bam_error(_("failed to open file: %s: %s\n"), release, 7915 strerror(errno)); 7916 cp = NULL; 7917 goto out; 7918 } 7919 7920 /* grab first line of /etc/release */ 7921 cp = s_fgets(title, sizeof (title), fp); 7922 if (cp) { 7923 while (isspace(*cp)) /* remove leading spaces */ 7924 cp++; 7925 } 7926 7927 (void) fclose(fp); 7928 7929 out: 7930 cp = cp ? cp : "Oracle Solaris"; 7931 7932 BAM_DPRINTF(("%s: got title: %s\n", fcn, cp)); 7933 7934 return (cp); 7935 } 7936 7937 char * 7938 get_special(char *mountp) 7939 { 7940 FILE *mntfp; 7941 struct mnttab mp = {0}; 7942 struct mnttab mpref = {0}; 7943 int error; 7944 int ret; 7945 const char *fcn = "get_special()"; 7946 7947 INJECT_ERROR1("GET_SPECIAL_MNTPT", mountp = NULL); 7948 if (mountp == NULL) { 7949 bam_error(_("cannot get special file: NULL mount-point\n")); 7950 return (NULL); 7951 } 7952 7953 mntfp = fopen(MNTTAB, "r"); 7954 error = errno; 7955 INJECT_ERROR1("GET_SPECIAL_MNTTAB_OPEN", mntfp = NULL); 7956 if (mntfp == NULL) { 7957 bam_error(_("failed to open file: %s: %s\n"), MNTTAB, 7958 strerror(error)); 7959 return (NULL); 7960 } 7961 7962 if (*mountp == '\0') 7963 mpref.mnt_mountp = "/"; 7964 else 7965 mpref.mnt_mountp = mountp; 7966 7967 ret = getmntany(mntfp, &mp, &mpref); 7968 INJECT_ERROR1("GET_SPECIAL_MNTTAB_SEARCH", ret = 1); 7969 if (ret != 0) { 7970 (void) fclose(mntfp); 7971 BAM_DPRINTF(("%s: Cannot get special file: mount-point %s " 7972 "not in mnttab\n", fcn, mountp)); 7973 return (NULL); 7974 } 7975 (void) fclose(mntfp); 7976 7977 BAM_DPRINTF(("%s: returning special: %s\n", fcn, mp.mnt_special)); 7978 7979 return (s_strdup(mp.mnt_special)); 7980 } 7981 7982 static void 7983 free_physarray(char **physarray, int n) 7984 { 7985 int i; 7986 const char *fcn = "free_physarray()"; 7987 7988 assert(physarray); 7989 assert(n); 7990 7991 BAM_DPRINTF(("%s: entering args: %d\n", fcn, n)); 7992 7993 for (i = 0; i < n; i++) { 7994 free(physarray[i]); 7995 } 7996 free(physarray); 7997 7998 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 7999 } 8000 8001 static int 8002 zfs_get_physical(char *special, char ***physarray, int *n) 8003 { 8004 char sdup[PATH_MAX]; 8005 char cmd[PATH_MAX]; 8006 char dsk[PATH_MAX]; 8007 char *pool; 8008 filelist_t flist = {0}; 8009 line_t *lp; 8010 line_t *startlp; 8011 char *comp1; 8012 int i; 8013 int ret; 8014 const char *fcn = "zfs_get_physical()"; 8015 8016 assert(special); 8017 8018 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, special)); 8019 8020 INJECT_ERROR1("INVALID_ZFS_SPECIAL", special = "/foo"); 8021 if (special[0] == '/') { 8022 bam_error(_("invalid device for ZFS filesystem: %s\n"), 8023 special); 8024 return (-1); 8025 } 8026 8027 (void) strlcpy(sdup, special, sizeof (sdup)); 8028 8029 pool = strtok(sdup, "/"); 8030 INJECT_ERROR1("ZFS_GET_PHYS_POOL", pool = NULL); 8031 if (pool == NULL) { 8032 bam_error(_("cannot derive ZFS pool from special: %s\n"), 8033 special); 8034 return (-1); 8035 } 8036 8037 (void) snprintf(cmd, sizeof (cmd), "/sbin/zpool status %s", pool); 8038 8039 ret = exec_cmd(cmd, &flist); 8040 INJECT_ERROR1("ZFS_GET_PHYS_STATUS", ret = 1); 8041 if (ret != 0) { 8042 bam_error(_("cannot get zpool status for pool: %s\n"), pool); 8043 return (-1); 8044 } 8045 8046 INJECT_ERROR1("ZFS_GET_PHYS_STATUS_OUT", flist.head = NULL); 8047 if (flist.head == NULL) { 8048 bam_error(_("bad zpool status for pool=%s\n"), pool); 8049 filelist_free(&flist); 8050 return (-1); 8051 } 8052 8053 for (lp = flist.head; lp; lp = lp->next) { 8054 BAM_DPRINTF(("%s: strtok() zpool status line=%s\n", 8055 fcn, lp->line)); 8056 comp1 = strtok(lp->line, " \t"); 8057 if (comp1 == NULL) { 8058 free(lp->line); 8059 lp->line = NULL; 8060 } else { 8061 comp1 = s_strdup(comp1); 8062 free(lp->line); 8063 lp->line = comp1; 8064 } 8065 } 8066 8067 for (lp = flist.head; lp; lp = lp->next) { 8068 if (lp->line == NULL) 8069 continue; 8070 if (strcmp(lp->line, pool) == 0) { 8071 BAM_DPRINTF(("%s: found pool name: %s in zpool " 8072 "status\n", fcn, pool)); 8073 break; 8074 } 8075 } 8076 8077 if (lp == NULL) { 8078 bam_error(_("no pool name %s in zpool status\n"), pool); 8079 filelist_free(&flist); 8080 return (-1); 8081 } 8082 8083 startlp = lp->next; 8084 for (i = 0, lp = startlp; lp; lp = lp->next) { 8085 if (lp->line == NULL) 8086 continue; 8087 if (strcmp(lp->line, "mirror") == 0) 8088 continue; 8089 if (lp->line[0] == '\0' || strcmp(lp->line, "errors:") == 0) 8090 break; 8091 i++; 8092 BAM_DPRINTF(("%s: counting phys slices in zpool status: %d\n", 8093 fcn, i)); 8094 } 8095 8096 if (i == 0) { 8097 bam_error(_("no physical device in zpool status for pool=%s\n"), 8098 pool); 8099 filelist_free(&flist); 8100 return (-1); 8101 } 8102 8103 *n = i; 8104 *physarray = s_calloc(*n, sizeof (char *)); 8105 for (i = 0, lp = startlp; lp; lp = lp->next) { 8106 if (lp->line == NULL) 8107 continue; 8108 if (strcmp(lp->line, "mirror") == 0) 8109 continue; 8110 if (strcmp(lp->line, "errors:") == 0) 8111 break; 8112 if (strncmp(lp->line, "/dev/dsk/", strlen("/dev/dsk/")) != 0 && 8113 strncmp(lp->line, "/dev/rdsk/", 8114 strlen("/dev/rdsk/")) != 0) { 8115 (void) snprintf(dsk, sizeof (dsk), "/dev/rdsk/%s", 8116 lp->line); 8117 } else { 8118 (void) strlcpy(dsk, lp->line, sizeof (dsk)); 8119 } 8120 BAM_DPRINTF(("%s: adding phys slice=%s from pool %s status\n", 8121 fcn, dsk, pool)); 8122 (*physarray)[i++] = s_strdup(dsk); 8123 } 8124 8125 assert(i == *n); 8126 8127 filelist_free(&flist); 8128 8129 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8130 return (0); 8131 } 8132 8133 static int 8134 get_physical(char *menu_root, char ***physarray, int *n) 8135 { 8136 char *special; 8137 int ret; 8138 const char *fcn = "get_physical()"; 8139 8140 assert(menu_root); 8141 assert(physarray); 8142 assert(n); 8143 8144 *physarray = NULL; 8145 *n = 0; 8146 8147 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, menu_root)); 8148 8149 /* First get the device special file from /etc/mnttab */ 8150 special = get_special(menu_root); 8151 INJECT_ERROR1("GET_PHYSICAL_SPECIAL", special = NULL); 8152 if (special == NULL) { 8153 bam_error(_("cannot get special file for mount-point: %s\n"), 8154 menu_root); 8155 return (-1); 8156 } 8157 8158 /* If already a physical device nothing to do */ 8159 if (strncmp(special, "/dev/dsk/", strlen("/dev/dsk/")) == 0 || 8160 strncmp(special, "/dev/rdsk/", strlen("/dev/rdsk/")) == 0) { 8161 BAM_DPRINTF(("%s: got physical device already directly for " 8162 "menu_root=%s special=%s\n", fcn, menu_root, special)); 8163 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8164 *physarray = s_calloc(1, sizeof (char *)); 8165 (*physarray)[0] = special; 8166 *n = 1; 8167 return (0); 8168 } 8169 8170 if (is_zfs(menu_root)) { 8171 ret = zfs_get_physical(special, physarray, n); 8172 } else { 8173 bam_error(_("cannot derive physical device for %s (%s), " 8174 "unsupported filesystem\n"), menu_root, special); 8175 ret = -1; 8176 } 8177 8178 free(special); 8179 8180 INJECT_ERROR1("GET_PHYSICAL_RET", ret = -1); 8181 if (ret == -1) { 8182 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 8183 } else { 8184 int i; 8185 assert (*n > 0); 8186 for (i = 0; i < *n; i++) { 8187 BAM_DPRINTF(("%s: returning physical=%s\n", 8188 fcn, (*physarray)[i])); 8189 } 8190 } 8191 8192 return (ret); 8193 } 8194 8195 static int 8196 is_bootdisk(char *osroot, char *physical) 8197 { 8198 int ret; 8199 char *grubroot; 8200 char *bootp; 8201 const char *fcn = "is_bootdisk()"; 8202 8203 assert(osroot); 8204 assert(physical); 8205 8206 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, physical)); 8207 8208 bootp = strstr(physical, "p0:boot"); 8209 if (bootp) 8210 *bootp = '\0'; 8211 /* 8212 * We just want the BIOS mapping for menu disk. 8213 * Don't pass menu_root to get_grubroot() as the 8214 * check that it is used for is not relevant here. 8215 * The osroot is immaterial as well - it is only used to 8216 * to find create_diskmap script. Everything hinges on 8217 * "physical" 8218 */ 8219 grubroot = get_grubroot(osroot, physical, NULL); 8220 8221 INJECT_ERROR1("IS_BOOTDISK_GRUBROOT", grubroot = NULL); 8222 if (grubroot == NULL) { 8223 if (bam_verbose) 8224 bam_error(_("cannot determine BIOS disk ID 'hd?' for " 8225 "disk: %s\n"), physical); 8226 return (0); 8227 } 8228 ret = grubroot[3] == '0'; 8229 free(grubroot); 8230 8231 BAM_DPRINTF(("%s: returning ret = %d\n", fcn, ret)); 8232 8233 return (ret); 8234 } 8235 8236 /* 8237 * Check if menu is on the boot device 8238 * Return 0 (false) on error 8239 */ 8240 static int 8241 menu_on_bootdisk(char *osroot, char *menu_root) 8242 { 8243 char **physarray; 8244 int ret; 8245 int n; 8246 int i; 8247 int on_bootdisk; 8248 const char *fcn = "menu_on_bootdisk()"; 8249 8250 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, menu_root)); 8251 8252 ret = get_physical(menu_root, &physarray, &n); 8253 INJECT_ERROR1("MENU_ON_BOOTDISK_PHYSICAL", ret = -1); 8254 if (ret != 0) { 8255 bam_error(_("cannot get physical device special file for menu " 8256 "root: %s\n"), menu_root); 8257 return (0); 8258 } 8259 8260 assert(physarray); 8261 assert(n > 0); 8262 8263 on_bootdisk = 0; 8264 for (i = 0; i < n; i++) { 8265 assert(strncmp(physarray[i], "/dev/dsk/", 8266 strlen("/dev/dsk/")) == 0 || 8267 strncmp(physarray[i], "/dev/rdsk/", 8268 strlen("/dev/rdsk/")) == 0); 8269 8270 BAM_DPRINTF(("%s: checking if phys-device=%s is on bootdisk\n", 8271 fcn, physarray[i])); 8272 if (is_bootdisk(osroot, physarray[i])) { 8273 on_bootdisk = 1; 8274 BAM_DPRINTF(("%s: phys-device=%s *IS* on bootdisk\n", 8275 fcn, physarray[i])); 8276 } 8277 } 8278 8279 free_physarray(physarray, n); 8280 8281 INJECT_ERROR1("ON_BOOTDISK_YES", on_bootdisk = 1); 8282 INJECT_ERROR1("ON_BOOTDISK_NO", on_bootdisk = 0); 8283 if (on_bootdisk) { 8284 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8285 } else { 8286 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 8287 } 8288 8289 return (on_bootdisk); 8290 } 8291 8292 void 8293 bam_add_line(menu_t *mp, entry_t *entry, line_t *prev, line_t *lp) 8294 { 8295 const char *fcn = "bam_add_line()"; 8296 8297 assert(mp); 8298 assert(entry); 8299 assert(prev); 8300 assert(lp); 8301 8302 lp->next = prev->next; 8303 if (prev->next) { 8304 BAM_DPRINTF(("%s: previous next exists\n", fcn)); 8305 prev->next->prev = lp; 8306 } else { 8307 BAM_DPRINTF(("%s: previous next does not exist\n", fcn)); 8308 } 8309 prev->next = lp; 8310 lp->prev = prev; 8311 8312 if (entry->end == prev) { 8313 BAM_DPRINTF(("%s: last line in entry\n", fcn)); 8314 entry->end = lp; 8315 } 8316 if (mp->end == prev) { 8317 assert(lp->next == NULL); 8318 mp->end = lp; 8319 BAM_DPRINTF(("%s: last line in menu\n", fcn)); 8320 } 8321 } 8322 8323 /* 8324 * look for matching bootadm entry with specified parameters 8325 * Here are the rules (based on existing usage): 8326 * - If title is specified, match on title only 8327 * - Else, match on root/findroot, kernel, and module. 8328 * Note that, if root_opt is non-zero, the absence of 8329 * root line is considered a match. 8330 */ 8331 static entry_t * 8332 find_boot_entry( 8333 menu_t *mp, 8334 char *title, 8335 char *kernel, 8336 char *findroot, 8337 char *root, 8338 char *module, 8339 int root_opt, 8340 int *entry_num) 8341 { 8342 int i; 8343 line_t *lp; 8344 entry_t *ent; 8345 const char *fcn = "find_boot_entry()"; 8346 8347 if (entry_num) 8348 *entry_num = BAM_ERROR; 8349 8350 /* find matching entry */ 8351 for (i = 0, ent = mp->entries; ent; i++, ent = ent->next) { 8352 lp = ent->start; 8353 8354 /* first line of entry must be bootadm comment */ 8355 lp = ent->start; 8356 if (lp->flags != BAM_COMMENT || 8357 strcmp(lp->arg, BAM_BOOTADM_HDR) != 0) { 8358 continue; 8359 } 8360 8361 /* advance to title line */ 8362 lp = lp->next; 8363 if (title) { 8364 if (lp->flags == BAM_TITLE && lp->arg && 8365 strcmp(lp->arg, title) == 0) { 8366 BAM_DPRINTF(("%s: matched title: %s\n", 8367 fcn, title)); 8368 break; 8369 } 8370 BAM_DPRINTF(("%s: no match title: %s, %s\n", 8371 fcn, title, lp->arg)); 8372 continue; /* check title only */ 8373 } 8374 8375 lp = lp->next; /* advance to root line */ 8376 if (lp == NULL) { 8377 continue; 8378 } else if (lp->cmd != NULL && 8379 strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) == 0) { 8380 INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_FINDROOT", 8381 findroot = NULL); 8382 if (findroot == NULL) { 8383 BAM_DPRINTF(("%s: no match line has findroot, " 8384 "we don't: %s\n", fcn, lp->arg)); 8385 continue; 8386 } 8387 /* findroot command found, try match */ 8388 if (strcmp(lp->arg, findroot) != 0) { 8389 BAM_DPRINTF(("%s: no match findroot: %s, %s\n", 8390 fcn, findroot, lp->arg)); 8391 continue; 8392 } 8393 BAM_DPRINTF(("%s: matched findroot: %s\n", 8394 fcn, findroot)); 8395 lp = lp->next; /* advance to kernel line */ 8396 } else if (lp->cmd != NULL && 8397 strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) { 8398 INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_ROOT", root = NULL); 8399 if (root == NULL) { 8400 BAM_DPRINTF(("%s: no match, line has root, we " 8401 "don't: %s\n", fcn, lp->arg)); 8402 continue; 8403 } 8404 /* root cmd found, try match */ 8405 if (strcmp(lp->arg, root) != 0) { 8406 BAM_DPRINTF(("%s: no match root: %s, %s\n", 8407 fcn, root, lp->arg)); 8408 continue; 8409 } 8410 BAM_DPRINTF(("%s: matched root: %s\n", fcn, root)); 8411 lp = lp->next; /* advance to kernel line */ 8412 } else { 8413 INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_NO", 8414 root_opt = 0); 8415 INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_YES", 8416 root_opt = 1); 8417 /* no root command, see if root is optional */ 8418 if (root_opt == 0) { 8419 BAM_DPRINTF(("%s: root NOT optional\n", fcn)); 8420 continue; 8421 } 8422 BAM_DPRINTF(("%s: root IS optional\n", fcn)); 8423 } 8424 8425 if (lp == NULL || lp->next == NULL) { 8426 continue; 8427 } 8428 8429 if (kernel && 8430 (!check_cmd(lp->cmd, KERNEL_CMD, lp->arg, kernel))) { 8431 if (!(ent->flags & BAM_ENTRY_FAILSAFE) || 8432 !(ent->flags & BAM_ENTRY_DBOOT) || 8433 strcmp(kernel, DIRECT_BOOT_FAILSAFE_LINE) != 0) 8434 continue; 8435 8436 ent->flags |= BAM_ENTRY_UPGFSKERNEL; 8437 8438 } 8439 BAM_DPRINTF(("%s: kernel match: %s, %s\n", fcn, 8440 kernel, lp->arg)); 8441 8442 /* 8443 * Check for matching module entry (failsafe or normal). 8444 * If it fails to match, we go around the loop again. 8445 * For xpv entries, there are two module lines, so we 8446 * do the check twice. 8447 */ 8448 lp = lp->next; /* advance to module line */ 8449 if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) || 8450 (((lp = lp->next) != NULL) && 8451 check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) { 8452 /* match found */ 8453 BAM_DPRINTF(("%s: module match: %s, %s\n", fcn, 8454 module, lp->arg)); 8455 break; 8456 } 8457 8458 if (strcmp(module, FAILSAFE_ARCHIVE) == 0 && 8459 (strcmp(lp->prev->arg, FAILSAFE_ARCHIVE_32) == 0 || 8460 strcmp(lp->prev->arg, FAILSAFE_ARCHIVE_64) == 0)) { 8461 ent->flags |= BAM_ENTRY_UPGFSMODULE; 8462 break; 8463 } 8464 8465 } 8466 8467 if (ent && entry_num) { 8468 *entry_num = i; 8469 } 8470 8471 if (ent) { 8472 BAM_DPRINTF(("%s: returning ret = %d\n", fcn, i)); 8473 } else { 8474 BAM_DPRINTF(("%s: returning ret = %d\n", fcn, BAM_ERROR)); 8475 } 8476 return (ent); 8477 } 8478 8479 static int 8480 update_boot_entry(menu_t *mp, char *title, char *findroot, char *root, 8481 char *kernel, char *mod_kernel, char *module, int root_opt) 8482 { 8483 int i; 8484 int change_kernel = 0; 8485 entry_t *ent; 8486 line_t *lp; 8487 line_t *tlp; 8488 char linebuf[BAM_MAXLINE]; 8489 const char *fcn = "update_boot_entry()"; 8490 8491 /* note: don't match on title, it's updated on upgrade */ 8492 ent = find_boot_entry(mp, NULL, kernel, findroot, root, module, 8493 root_opt, &i); 8494 if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) { 8495 /* 8496 * We may be upgrading a kernel from multiboot to 8497 * directboot. Look for a multiboot entry. A multiboot 8498 * entry will not have a findroot line. 8499 */ 8500 ent = find_boot_entry(mp, NULL, "multiboot", NULL, root, 8501 MULTIBOOT_ARCHIVE, root_opt, &i); 8502 if (ent != NULL) { 8503 BAM_DPRINTF(("%s: upgrading entry from dboot to " 8504 "multiboot: root = %s\n", fcn, root)); 8505 change_kernel = 1; 8506 } 8507 } else if (ent) { 8508 BAM_DPRINTF(("%s: found entry with matching findroot: %s\n", 8509 fcn, findroot)); 8510 } 8511 8512 if (ent == NULL) { 8513 BAM_DPRINTF(("%s: boot entry not found in menu. Creating " 8514 "new entry, findroot = %s\n", fcn, findroot)); 8515 return (add_boot_entry(mp, title, findroot, 8516 kernel, mod_kernel, module, NULL)); 8517 } 8518 8519 /* replace title of existing entry and update findroot line */ 8520 lp = ent->start; 8521 lp = lp->next; /* title line */ 8522 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8523 menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 8524 free(lp->arg); 8525 free(lp->line); 8526 lp->arg = s_strdup(title); 8527 lp->line = s_strdup(linebuf); 8528 BAM_DPRINTF(("%s: changing title to: %s\n", fcn, title)); 8529 8530 tlp = lp; /* title line */ 8531 lp = lp->next; /* root line */ 8532 8533 /* if no root or findroot command, create a new line_t */ 8534 if ((lp->cmd != NULL) && (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) != 0 && 8535 strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) != 0)) { 8536 lp = s_calloc(1, sizeof (line_t)); 8537 bam_add_line(mp, ent, tlp, lp); 8538 } else { 8539 if (lp->cmd != NULL) 8540 free(lp->cmd); 8541 8542 free(lp->sep); 8543 free(lp->arg); 8544 free(lp->line); 8545 } 8546 8547 lp->cmd = s_strdup(menu_cmds[FINDROOT_CMD]); 8548 lp->sep = s_strdup(menu_cmds[SEP_CMD]); 8549 lp->arg = s_strdup(findroot); 8550 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8551 menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot); 8552 lp->line = s_strdup(linebuf); 8553 BAM_DPRINTF(("%s: adding findroot line: %s\n", fcn, findroot)); 8554 8555 /* kernel line */ 8556 lp = lp->next; 8557 8558 if (ent->flags & BAM_ENTRY_UPGFSKERNEL) { 8559 char *params = NULL; 8560 8561 params = strstr(lp->line, "-s"); 8562 if (params != NULL) 8563 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s%s", 8564 menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD], 8565 kernel, params+2); 8566 else 8567 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8568 menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD], 8569 kernel); 8570 8571 if (lp->cmd != NULL) 8572 free(lp->cmd); 8573 8574 free(lp->arg); 8575 free(lp->line); 8576 lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]); 8577 lp->arg = s_strdup(strstr(linebuf, "/")); 8578 lp->line = s_strdup(linebuf); 8579 ent->flags &= ~BAM_ENTRY_UPGFSKERNEL; 8580 BAM_DPRINTF(("%s: adding new kernel$ line: %s\n", 8581 fcn, lp->prev->cmd)); 8582 } 8583 8584 if (change_kernel) { 8585 /* 8586 * We're upgrading from multiboot to directboot. 8587 */ 8588 if (lp->cmd != NULL && 8589 strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) { 8590 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8591 menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD], 8592 kernel); 8593 free(lp->cmd); 8594 free(lp->arg); 8595 free(lp->line); 8596 lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]); 8597 lp->arg = s_strdup(kernel); 8598 lp->line = s_strdup(linebuf); 8599 lp = lp->next; 8600 BAM_DPRINTF(("%s: adding new kernel$ line: %s\n", 8601 fcn, kernel)); 8602 } 8603 if (lp->cmd != NULL && 8604 strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) { 8605 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8606 menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD], 8607 module); 8608 free(lp->cmd); 8609 free(lp->arg); 8610 free(lp->line); 8611 lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]); 8612 lp->arg = s_strdup(module); 8613 lp->line = s_strdup(linebuf); 8614 lp = lp->next; 8615 BAM_DPRINTF(("%s: adding new module$ line: %s\n", 8616 fcn, module)); 8617 } 8618 } 8619 8620 /* module line */ 8621 lp = lp->next; 8622 8623 if (ent->flags & BAM_ENTRY_UPGFSMODULE) { 8624 if (lp->cmd != NULL && 8625 strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) { 8626 (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 8627 menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD], 8628 module); 8629 free(lp->cmd); 8630 free(lp->arg); 8631 free(lp->line); 8632 lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]); 8633 lp->arg = s_strdup(module); 8634 lp->line = s_strdup(linebuf); 8635 lp = lp->next; 8636 ent->flags &= ~BAM_ENTRY_UPGFSMODULE; 8637 BAM_DPRINTF(("%s: adding new module$ line: %s\n", 8638 fcn, module)); 8639 } 8640 } 8641 8642 BAM_DPRINTF(("%s: returning ret = %d\n", fcn, i)); 8643 return (i); 8644 } 8645 8646 int 8647 root_optional(char *osroot, char *menu_root) 8648 { 8649 char *ospecial; 8650 char *mspecial; 8651 char *slash; 8652 int root_opt; 8653 int ret1; 8654 int ret2; 8655 const char *fcn = "root_optional()"; 8656 8657 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, osroot, menu_root)); 8658 8659 /* 8660 * For all filesystems except ZFS, a straight compare of osroot 8661 * and menu_root will tell us if root is optional. 8662 * For ZFS, the situation is complicated by the fact that 8663 * menu_root and osroot are always different 8664 */ 8665 ret1 = is_zfs(osroot); 8666 ret2 = is_zfs(menu_root); 8667 INJECT_ERROR1("ROOT_OPT_NOT_ZFS", ret1 = 0); 8668 if (!ret1 || !ret2) { 8669 BAM_DPRINTF(("%s: one or more non-ZFS filesystems (%s, %s)\n", 8670 fcn, osroot, menu_root)); 8671 root_opt = (strcmp(osroot, menu_root) == 0); 8672 goto out; 8673 } 8674 8675 ospecial = get_special(osroot); 8676 INJECT_ERROR1("ROOT_OPTIONAL_OSPECIAL", ospecial = NULL); 8677 if (ospecial == NULL) { 8678 bam_error(_("failed to get special file for osroot: %s\n"), 8679 osroot); 8680 return (0); 8681 } 8682 BAM_DPRINTF(("%s: ospecial=%s for osroot=%s\n", fcn, ospecial, osroot)); 8683 8684 mspecial = get_special(menu_root); 8685 INJECT_ERROR1("ROOT_OPTIONAL_MSPECIAL", mspecial = NULL); 8686 if (mspecial == NULL) { 8687 bam_error(_("failed to get special file for menu_root: %s\n"), 8688 menu_root); 8689 free(ospecial); 8690 return (0); 8691 } 8692 BAM_DPRINTF(("%s: mspecial=%s for menu_root=%s\n", 8693 fcn, mspecial, menu_root)); 8694 8695 slash = strchr(ospecial, '/'); 8696 if (slash) 8697 *slash = '\0'; 8698 BAM_DPRINTF(("%s: FIXED ospecial=%s for osroot=%s\n", 8699 fcn, ospecial, osroot)); 8700 8701 root_opt = (strcmp(ospecial, mspecial) == 0); 8702 8703 free(ospecial); 8704 free(mspecial); 8705 8706 out: 8707 INJECT_ERROR1("ROOT_OPTIONAL_NO", root_opt = 0); 8708 INJECT_ERROR1("ROOT_OPTIONAL_YES", root_opt = 1); 8709 if (root_opt) { 8710 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8711 } else { 8712 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 8713 } 8714 8715 return (root_opt); 8716 } 8717 8718 /*ARGSUSED*/ 8719 static error_t 8720 update_entry(menu_t *mp, char *menu_root, char *osdev) 8721 { 8722 int entry; 8723 char *grubsign; 8724 char *grubroot; 8725 char *title; 8726 char osroot[PATH_MAX]; 8727 char *failsafe_kernel = NULL; 8728 struct stat sbuf; 8729 char failsafe[256]; 8730 char failsafe_64[256]; 8731 int ret; 8732 const char *fcn = "update_entry()"; 8733 8734 assert(mp); 8735 assert(menu_root); 8736 assert(osdev); 8737 assert(bam_root); 8738 8739 BAM_DPRINTF(("%s: entered. args: %s %s %s\n", fcn, menu_root, osdev, 8740 bam_root)); 8741 8742 (void) strlcpy(osroot, bam_root, sizeof (osroot)); 8743 8744 title = get_title(osroot); 8745 assert(title); 8746 8747 grubsign = get_grubsign(osroot, osdev); 8748 INJECT_ERROR1("GET_GRUBSIGN_FAIL", grubsign = NULL); 8749 if (grubsign == NULL) { 8750 bam_error(_("failed to get grubsign for root: %s, device %s\n"), 8751 osroot, osdev); 8752 return (BAM_ERROR); 8753 } 8754 8755 /* 8756 * It is not a fatal error if get_grubroot() fails 8757 * We no longer rely on biosdev to populate the 8758 * menu 8759 */ 8760 grubroot = get_grubroot(osroot, osdev, menu_root); 8761 INJECT_ERROR1("GET_GRUBROOT_FAIL", grubroot = NULL); 8762 if (grubroot) { 8763 BAM_DPRINTF(("%s: get_grubroot success. osroot=%s, osdev=%s, " 8764 "menu_root=%s\n", fcn, osroot, osdev, menu_root)); 8765 } else { 8766 BAM_DPRINTF(("%s: get_grubroot failed. osroot=%s, osdev=%s, " 8767 "menu_root=%s\n", fcn, osroot, osdev, menu_root)); 8768 } 8769 8770 /* add the entry for normal Solaris */ 8771 INJECT_ERROR1("UPDATE_ENTRY_MULTIBOOT", 8772 bam_direct = BAM_DIRECT_MULTIBOOT); 8773 if (bam_direct == BAM_DIRECT_DBOOT) { 8774 entry = update_boot_entry(mp, title, grubsign, grubroot, 8775 (bam_zfs ? DIRECT_BOOT_KERNEL_ZFS : DIRECT_BOOT_KERNEL), 8776 NULL, DIRECT_BOOT_ARCHIVE, 8777 root_optional(osroot, menu_root)); 8778 BAM_DPRINTF(("%s: updated boot entry bam_zfs=%d, " 8779 "grubsign = %s\n", fcn, bam_zfs, grubsign)); 8780 if ((entry != BAM_ERROR) && (bam_is_hv == BAM_HV_PRESENT)) { 8781 (void) update_boot_entry(mp, NEW_HV_ENTRY, grubsign, 8782 grubroot, XEN_MENU, bam_zfs ? 8783 XEN_KERNEL_MODULE_LINE_ZFS : XEN_KERNEL_MODULE_LINE, 8784 DIRECT_BOOT_ARCHIVE, 8785 root_optional(osroot, menu_root)); 8786 BAM_DPRINTF(("%s: updated HV entry bam_zfs=%d, " 8787 "grubsign = %s\n", fcn, bam_zfs, grubsign)); 8788 } 8789 } else { 8790 entry = update_boot_entry(mp, title, grubsign, grubroot, 8791 MULTI_BOOT, NULL, MULTIBOOT_ARCHIVE, 8792 root_optional(osroot, menu_root)); 8793 8794 BAM_DPRINTF(("%s: updated MULTIBOOT entry grubsign = %s\n", 8795 fcn, grubsign)); 8796 } 8797 8798 /* 8799 * Add the entry for failsafe archive. On a bfu'd system, the 8800 * failsafe may be different than the installed kernel. 8801 */ 8802 (void) snprintf(failsafe, sizeof (failsafe), "%s%s", 8803 osroot, FAILSAFE_ARCHIVE_32); 8804 (void) snprintf(failsafe_64, sizeof (failsafe_64), "%s%s", 8805 osroot, FAILSAFE_ARCHIVE_64); 8806 8807 /* 8808 * Check if at least one of the two archives exists 8809 * Using $ISADIR as the default line, we have an entry which works 8810 * for both the cases. 8811 */ 8812 8813 if (stat(failsafe, &sbuf) == 0 || stat(failsafe_64, &sbuf) == 0) { 8814 8815 /* Figure out where the kernel line should point */ 8816 (void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot, 8817 DIRECT_BOOT_FAILSAFE_32); 8818 (void) snprintf(failsafe_64, sizeof (failsafe_64), "%s%s", 8819 osroot, DIRECT_BOOT_FAILSAFE_64); 8820 if (stat(failsafe, &sbuf) == 0 || 8821 stat(failsafe_64, &sbuf) == 0) { 8822 failsafe_kernel = DIRECT_BOOT_FAILSAFE_LINE; 8823 } else { 8824 (void) snprintf(failsafe, sizeof (failsafe), "%s%s", 8825 osroot, MULTI_BOOT_FAILSAFE); 8826 if (stat(failsafe, &sbuf) == 0) { 8827 failsafe_kernel = MULTI_BOOT_FAILSAFE_LINE; 8828 } 8829 } 8830 if (failsafe_kernel != NULL) { 8831 (void) update_boot_entry(mp, FAILSAFE_TITLE, grubsign, 8832 grubroot, failsafe_kernel, NULL, FAILSAFE_ARCHIVE, 8833 root_optional(osroot, menu_root)); 8834 BAM_DPRINTF(("%s: updated FAILSAFE entry " 8835 "failsafe_kernel = %s\n", fcn, failsafe_kernel)); 8836 } 8837 } 8838 free(grubroot); 8839 8840 INJECT_ERROR1("UPDATE_ENTRY_ERROR", entry = BAM_ERROR); 8841 if (entry == BAM_ERROR) { 8842 bam_error(_("failed to add boot entry with title=%s, grub " 8843 "signature=%s\n"), title, grubsign); 8844 free(grubsign); 8845 return (BAM_ERROR); 8846 } 8847 free(grubsign); 8848 8849 update_numbering(mp); 8850 ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 8851 INJECT_ERROR1("SET_DEFAULT_ERROR", ret = BAM_ERROR); 8852 if (ret == BAM_ERROR) { 8853 bam_error(_("failed to set GRUB menu default to %d\n"), entry); 8854 } 8855 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8856 return (BAM_WRITE); 8857 } 8858 8859 static void 8860 save_default_entry(menu_t *mp, const char *which) 8861 { 8862 int lineNum; 8863 int entryNum; 8864 int entry = 0; /* default is 0 */ 8865 char linebuf[BAM_MAXLINE]; 8866 line_t *lp = mp->curdefault; 8867 const char *fcn = "save_default_entry()"; 8868 8869 if (mp->start) { 8870 lineNum = mp->end->lineNum; 8871 entryNum = mp->end->entryNum; 8872 } else { 8873 lineNum = LINE_INIT; 8874 entryNum = ENTRY_INIT; 8875 } 8876 8877 if (lp) 8878 entry = s_strtol(lp->arg); 8879 8880 (void) snprintf(linebuf, sizeof (linebuf), "#%s%d", which, entry); 8881 BAM_DPRINTF(("%s: saving default to: %s\n", fcn, linebuf)); 8882 line_parser(mp, linebuf, &lineNum, &entryNum); 8883 BAM_DPRINTF(("%s: saved default to lineNum=%d, entryNum=%d\n", fcn, 8884 lineNum, entryNum)); 8885 } 8886 8887 static void 8888 restore_default_entry(menu_t *mp, const char *which, line_t *lp) 8889 { 8890 int entry; 8891 char *str; 8892 const char *fcn = "restore_default_entry()"; 8893 8894 if (lp == NULL) { 8895 BAM_DPRINTF(("%s: NULL saved default\n", fcn)); 8896 return; /* nothing to restore */ 8897 } 8898 8899 BAM_DPRINTF(("%s: saved default string: %s\n", fcn, which)); 8900 8901 str = lp->arg + strlen(which); 8902 entry = s_strtol(str); 8903 (void) set_global(mp, menu_cmds[DEFAULT_CMD], entry); 8904 8905 BAM_DPRINTF(("%s: restored default to entryNum: %d\n", fcn, entry)); 8906 8907 /* delete saved old default line */ 8908 unlink_line(mp, lp); 8909 line_free(lp); 8910 } 8911 8912 /* 8913 * This function is for supporting reboot with args. 8914 * The opt value can be: 8915 * NULL delete temp entry, if present 8916 * entry=<n> switches default entry to <n> 8917 * else treated as boot-args and setup a temperary menu entry 8918 * and make it the default 8919 * Note that we are always rebooting the current OS instance 8920 * so osroot == / always. 8921 */ 8922 #define REBOOT_TITLE "Solaris_reboot_transient" 8923 8924 /*ARGSUSED*/ 8925 static error_t 8926 update_temp(menu_t *mp, char *dummy, char *opt) 8927 { 8928 int entry; 8929 char *osdev; 8930 char *fstype; 8931 char *sign; 8932 char *opt_ptr; 8933 char *path; 8934 char kernbuf[BUFSIZ]; 8935 char args_buf[BUFSIZ]; 8936 char signbuf[PATH_MAX]; 8937 int ret; 8938 const char *fcn = "update_temp()"; 8939 8940 assert(mp); 8941 assert(dummy == NULL); 8942 8943 /* opt can be NULL */ 8944 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, opt ? opt : "<NULL>")); 8945 BAM_DPRINTF(("%s: bam_alt_root: %d, bam_root: %s\n", fcn, 8946 bam_alt_root, bam_root)); 8947 8948 if (bam_alt_root || bam_rootlen != 1 || 8949 strcmp(bam_root, "/") != 0 || 8950 strcmp(rootbuf, "/") != 0) { 8951 bam_error(_("an alternate root (%s) cannot be used with this " 8952 "sub-command\n"), bam_root); 8953 return (BAM_ERROR); 8954 } 8955 8956 /* If no option, delete exiting reboot menu entry */ 8957 if (opt == NULL) { 8958 entry_t *ent; 8959 BAM_DPRINTF(("%s: opt is NULL\n", fcn)); 8960 ent = find_boot_entry(mp, REBOOT_TITLE, NULL, NULL, 8961 NULL, NULL, 0, &entry); 8962 if (ent == NULL) { /* not found is ok */ 8963 BAM_DPRINTF(("%s: transient entry not found\n", fcn)); 8964 return (BAM_SUCCESS); 8965 } 8966 (void) delete_boot_entry(mp, entry, DBE_PRINTERR); 8967 restore_default_entry(mp, BAM_OLDDEF, mp->olddefault); 8968 mp->olddefault = NULL; 8969 BAM_DPRINTF(("%s: restored old default\n", fcn)); 8970 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 8971 return (BAM_WRITE); 8972 } 8973 8974 /* if entry= is specified, set the default entry */ 8975 if (strncmp(opt, "entry=", strlen("entry=")) == 0) { 8976 int entryNum = s_strtol(opt + strlen("entry=")); 8977 BAM_DPRINTF(("%s: opt has entry=: %s\n", fcn, opt)); 8978 if (selector(mp, opt, &entry, NULL) == BAM_SUCCESS) { 8979 /* this is entry=# option */ 8980 ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 8981 BAM_DPRINTF(("%s: default set to %d, " 8982 "set_default ret=%d\n", fcn, entry, ret)); 8983 return (ret); 8984 } else { 8985 bam_error(_("failed to set GRUB menu default to %d\n"), 8986 entryNum); 8987 return (BAM_ERROR); 8988 } 8989 } 8990 8991 /* 8992 * add a new menu entry based on opt and make it the default 8993 */ 8994 8995 fstype = get_fstype("/"); 8996 INJECT_ERROR1("REBOOT_FSTYPE_NULL", fstype = NULL); 8997 if (fstype == NULL) { 8998 bam_error(_("failed to determine filesystem type for \"/\". " 8999 "Reboot with \narguments failed.\n")); 9000 return (BAM_ERROR); 9001 } 9002 9003 osdev = get_special("/"); 9004 INJECT_ERROR1("REBOOT_SPECIAL_NULL", osdev = NULL); 9005 if (osdev == NULL) { 9006 free(fstype); 9007 bam_error(_("failed to find device special file for \"/\". " 9008 "Reboot with \narguments failed.\n")); 9009 return (BAM_ERROR); 9010 } 9011 9012 sign = find_existing_sign("/", osdev, fstype); 9013 INJECT_ERROR1("REBOOT_SIGN_NULL", sign = NULL); 9014 if (sign == NULL) { 9015 free(fstype); 9016 free(osdev); 9017 bam_error(_("failed to find boot signature. Reboot with " 9018 "arguments failed.\n")); 9019 return (BAM_ERROR); 9020 } 9021 9022 free(osdev); 9023 (void) strlcpy(signbuf, sign, sizeof (signbuf)); 9024 free(sign); 9025 9026 assert(strchr(signbuf, '(') == NULL && strchr(signbuf, ',') == NULL && 9027 strchr(signbuf, ')') == NULL); 9028 9029 /* 9030 * There is no alternate root while doing reboot with args 9031 * This version of bootadm is only delivered with a DBOOT 9032 * version of Solaris. 9033 */ 9034 INJECT_ERROR1("REBOOT_NOT_DBOOT", bam_direct = BAM_DIRECT_MULTIBOOT); 9035 if (bam_direct != BAM_DIRECT_DBOOT) { 9036 free(fstype); 9037 bam_error(_("the root filesystem is not a dboot Solaris " 9038 "instance. \nThis version of bootadm is not supported " 9039 "on this version of Solaris.\n")); 9040 return (BAM_ERROR); 9041 } 9042 9043 /* add an entry for Solaris reboot */ 9044 if (opt[0] == '-') { 9045 /* It's an option - first see if boot-file is set */ 9046 ret = get_kernel(mp, KERNEL_CMD, kernbuf, sizeof (kernbuf)); 9047 INJECT_ERROR1("REBOOT_GET_KERNEL", ret = BAM_ERROR); 9048 if (ret != BAM_SUCCESS) { 9049 free(fstype); 9050 bam_error(_("reboot with arguments: error querying " 9051 "current boot-file settings\n")); 9052 return (BAM_ERROR); 9053 } 9054 if (kernbuf[0] == '\0') 9055 (void) strlcpy(kernbuf, DIRECT_BOOT_KERNEL, 9056 sizeof (kernbuf)); 9057 /* 9058 * If this is a zfs file system and kernbuf does not 9059 * have "-B $ZFS-BOOTFS" string yet, add it. 9060 */ 9061 if (strcmp(fstype, "zfs") == 0 && !strstr(kernbuf, ZFS_BOOT)) { 9062 (void) strlcat(kernbuf, " ", sizeof (kernbuf)); 9063 (void) strlcat(kernbuf, ZFS_BOOT, sizeof (kernbuf)); 9064 } 9065 (void) strlcat(kernbuf, " ", sizeof (kernbuf)); 9066 (void) strlcat(kernbuf, opt, sizeof (kernbuf)); 9067 BAM_DPRINTF(("%s: reboot with args, option specified: " 9068 "kern=%s\n", fcn, kernbuf)); 9069 } else if (opt[0] == '/') { 9070 /* It's a full path, so write it out. */ 9071 (void) strlcpy(kernbuf, opt, sizeof (kernbuf)); 9072 9073 /* 9074 * If someone runs: 9075 * 9076 * # eeprom boot-args='-kd' 9077 * # reboot /platform/i86pc/kernel/unix 9078 * 9079 * we want to use the boot-args as part of the boot 9080 * line. On the other hand, if someone runs: 9081 * 9082 * # reboot "/platform/i86pc/kernel/unix -kd" 9083 * 9084 * we don't need to mess with boot-args. If there's 9085 * no space in the options string, assume we're in the 9086 * first case. 9087 */ 9088 if (strchr(opt, ' ') == NULL) { 9089 ret = get_kernel(mp, ARGS_CMD, args_buf, 9090 sizeof (args_buf)); 9091 INJECT_ERROR1("REBOOT_GET_ARGS", ret = BAM_ERROR); 9092 if (ret != BAM_SUCCESS) { 9093 free(fstype); 9094 bam_error(_("reboot with arguments: error " 9095 "querying current boot-args settings\n")); 9096 return (BAM_ERROR); 9097 } 9098 9099 if (args_buf[0] != '\0') { 9100 (void) strlcat(kernbuf, " ", sizeof (kernbuf)); 9101 (void) strlcat(kernbuf, args_buf, 9102 sizeof (kernbuf)); 9103 } 9104 } 9105 BAM_DPRINTF(("%s: reboot with args, abspath specified: " 9106 "kern=%s\n", fcn, kernbuf)); 9107 } else { 9108 /* 9109 * It may be a partial path, or it may be a partial 9110 * path followed by options. Assume that only options 9111 * follow a space. If someone sends us a kernel path 9112 * that includes a space, they deserve to be broken. 9113 */ 9114 opt_ptr = strchr(opt, ' '); 9115 if (opt_ptr != NULL) { 9116 *opt_ptr = '\0'; 9117 } 9118 9119 path = expand_path(opt); 9120 if (path != NULL) { 9121 (void) strlcpy(kernbuf, path, sizeof (kernbuf)); 9122 free(path); 9123 9124 /* 9125 * If there were options given, use those. 9126 * Otherwise, copy over the default options. 9127 */ 9128 if (opt_ptr != NULL) { 9129 /* Restore the space in opt string */ 9130 *opt_ptr = ' '; 9131 (void) strlcat(kernbuf, opt_ptr, 9132 sizeof (kernbuf)); 9133 } else { 9134 ret = get_kernel(mp, ARGS_CMD, args_buf, 9135 sizeof (args_buf)); 9136 INJECT_ERROR1("UPDATE_TEMP_PARTIAL_ARGS", 9137 ret = BAM_ERROR); 9138 if (ret != BAM_SUCCESS) { 9139 free(fstype); 9140 bam_error(_("reboot with arguments: " 9141 "error querying current boot-args " 9142 "settings\n")); 9143 return (BAM_ERROR); 9144 } 9145 9146 if (args_buf[0] != '\0') { 9147 (void) strlcat(kernbuf, " ", 9148 sizeof (kernbuf)); 9149 (void) strlcat(kernbuf, 9150 args_buf, sizeof (kernbuf)); 9151 } 9152 } 9153 BAM_DPRINTF(("%s: resolved partial path: %s\n", 9154 fcn, kernbuf)); 9155 } else { 9156 free(fstype); 9157 bam_error(_("unable to expand %s to a full file" 9158 " path.\n"), opt); 9159 bam_print_stderr(_("Rebooting with default kernel " 9160 "and options.\n")); 9161 return (BAM_ERROR); 9162 } 9163 } 9164 free(fstype); 9165 entry = add_boot_entry(mp, REBOOT_TITLE, signbuf, kernbuf, 9166 NULL, NULL, NULL); 9167 INJECT_ERROR1("REBOOT_ADD_BOOT_ENTRY", entry = BAM_ERROR); 9168 if (entry == BAM_ERROR) { 9169 bam_error(_("Cannot update menu. Cannot reboot with " 9170 "requested arguments\n")); 9171 return (BAM_ERROR); 9172 } 9173 9174 save_default_entry(mp, BAM_OLDDEF); 9175 ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 9176 INJECT_ERROR1("REBOOT_SET_GLOBAL", ret = BAM_ERROR); 9177 if (ret == BAM_ERROR) { 9178 bam_error(_("reboot with arguments: setting GRUB menu default " 9179 "to %d failed\n"), entry); 9180 } 9181 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9182 return (BAM_WRITE); 9183 } 9184 9185 error_t 9186 set_global(menu_t *mp, char *globalcmd, int val) 9187 { 9188 line_t *lp; 9189 line_t *found; 9190 line_t *last; 9191 char *cp; 9192 char *str; 9193 char prefix[BAM_MAXLINE]; 9194 size_t len; 9195 const char *fcn = "set_global()"; 9196 9197 assert(mp); 9198 assert(globalcmd); 9199 9200 if (strcmp(globalcmd, menu_cmds[DEFAULT_CMD]) == 0) { 9201 INJECT_ERROR1("SET_GLOBAL_VAL_NEG", val = -1); 9202 INJECT_ERROR1("SET_GLOBAL_MENU_EMPTY", mp->end = NULL); 9203 INJECT_ERROR1("SET_GLOBAL_VAL_TOO_BIG", val = 100); 9204 if (val < 0 || mp->end == NULL || val > mp->end->entryNum) { 9205 (void) snprintf(prefix, sizeof (prefix), "%d", val); 9206 bam_error(_("invalid boot entry number: %s\n"), prefix); 9207 return (BAM_ERROR); 9208 } 9209 } 9210 9211 found = last = NULL; 9212 for (lp = mp->start; lp; lp = lp->next) { 9213 if (lp->flags != BAM_GLOBAL) 9214 continue; 9215 9216 last = lp; /* track the last global found */ 9217 9218 INJECT_ERROR1("SET_GLOBAL_NULL_CMD", lp->cmd = NULL); 9219 if (lp->cmd == NULL) { 9220 bam_error(_("no command at line %d\n"), lp->lineNum); 9221 continue; 9222 } 9223 if (strcmp(globalcmd, lp->cmd) != 0) 9224 continue; 9225 9226 BAM_DPRINTF(("%s: found matching global command: %s\n", 9227 fcn, globalcmd)); 9228 9229 if (found) { 9230 bam_error(_("duplicate command %s at line %d of " 9231 "%sboot/grub/menu.lst\n"), globalcmd, 9232 lp->lineNum, bam_root); 9233 } 9234 found = lp; 9235 } 9236 9237 if (found == NULL) { 9238 lp = s_calloc(1, sizeof (line_t)); 9239 if (last == NULL) { 9240 lp->next = mp->start; 9241 mp->start = lp; 9242 mp->end = (mp->end) ? mp->end : lp; 9243 } else { 9244 lp->next = last->next; 9245 last->next = lp; 9246 if (lp->next == NULL) 9247 mp->end = lp; 9248 } 9249 lp->flags = BAM_GLOBAL; /* other fields not needed for writes */ 9250 len = strlen(globalcmd) + strlen(menu_cmds[SEP_CMD]); 9251 len += 10; /* val < 10 digits */ 9252 lp->line = s_calloc(1, len); 9253 (void) snprintf(lp->line, len, "%s%s%d", 9254 globalcmd, menu_cmds[SEP_CMD], val); 9255 BAM_DPRINTF(("%s: wrote new global line: %s\n", fcn, lp->line)); 9256 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9257 return (BAM_WRITE); 9258 } 9259 9260 /* 9261 * We are changing an existing entry. Retain any prefix whitespace, 9262 * but overwrite everything else. This preserves tabs added for 9263 * readability. 9264 */ 9265 str = found->line; 9266 cp = prefix; 9267 while (*str == ' ' || *str == '\t') 9268 *(cp++) = *(str++); 9269 *cp = '\0'; /* Terminate prefix */ 9270 len = strlen(prefix) + strlen(globalcmd); 9271 len += strlen(menu_cmds[SEP_CMD]) + 10; 9272 9273 free(found->line); 9274 found->line = s_calloc(1, len); 9275 (void) snprintf(found->line, len, 9276 "%s%s%s%d", prefix, globalcmd, menu_cmds[SEP_CMD], val); 9277 9278 BAM_DPRINTF(("%s: replaced global line with: %s\n", fcn, found->line)); 9279 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9280 return (BAM_WRITE); /* need a write to menu */ 9281 } 9282 9283 /* 9284 * partial_path may be anything like "kernel/unix" or "kmdb". Try to 9285 * expand it to a full unix path. The calling function is expected to 9286 * output a message if an error occurs and NULL is returned. 9287 */ 9288 static char * 9289 expand_path(const char *partial_path) 9290 { 9291 int new_path_len; 9292 char *new_path; 9293 char new_path2[PATH_MAX]; 9294 struct stat sb; 9295 const char *fcn = "expand_path()"; 9296 9297 new_path_len = strlen(partial_path) + 64; 9298 new_path = s_calloc(1, new_path_len); 9299 9300 /* First, try the simplest case - something like "kernel/unix" */ 9301 (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s", 9302 partial_path); 9303 if (stat(new_path, &sb) == 0) { 9304 BAM_DPRINTF(("%s: expanded path: %s\n", fcn, new_path)); 9305 return (new_path); 9306 } 9307 9308 if (strcmp(partial_path, "kmdb") == 0) { 9309 (void) snprintf(new_path, new_path_len, "%s -k", 9310 DIRECT_BOOT_KERNEL); 9311 BAM_DPRINTF(("%s: expanded path: %s\n", fcn, new_path)); 9312 return (new_path); 9313 } 9314 9315 /* 9316 * We've quickly reached unsupported usage. Try once more to 9317 * see if we were just given a glom name. 9318 */ 9319 (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s/unix", 9320 partial_path); 9321 (void) snprintf(new_path2, PATH_MAX, "/platform/i86pc/%s/amd64/unix", 9322 partial_path); 9323 if (stat(new_path, &sb) == 0) { 9324 if (stat(new_path2, &sb) == 0) { 9325 /* 9326 * We matched both, so we actually 9327 * want to write the $ISADIR version. 9328 */ 9329 (void) snprintf(new_path, new_path_len, 9330 "/platform/i86pc/kernel/%s/$ISADIR/unix", 9331 partial_path); 9332 } 9333 BAM_DPRINTF(("%s: expanded path: %s\n", fcn, new_path)); 9334 return (new_path); 9335 } 9336 9337 free(new_path); 9338 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 9339 return (NULL); 9340 } 9341 9342 /* 9343 * The kernel cmd and arg have been changed, so 9344 * check whether the archive line needs to change. 9345 */ 9346 static void 9347 set_archive_line(entry_t *entryp, line_t *kernelp) 9348 { 9349 line_t *lp = entryp->start; 9350 char *new_archive; 9351 menu_cmd_t m_cmd; 9352 const char *fcn = "set_archive_line()"; 9353 9354 for (; lp != NULL; lp = lp->next) { 9355 if (lp->cmd != NULL && strncmp(lp->cmd, menu_cmds[MODULE_CMD], 9356 sizeof (menu_cmds[MODULE_CMD]) - 1) == 0) { 9357 break; 9358 } 9359 9360 INJECT_ERROR1("SET_ARCHIVE_LINE_END_ENTRY", lp = entryp->end); 9361 if (lp == entryp->end) { 9362 BAM_DPRINTF(("%s: no module/archive line for entry: " 9363 "%d\n", fcn, entryp->entryNum)); 9364 return; 9365 } 9366 } 9367 INJECT_ERROR1("SET_ARCHIVE_LINE_END_MENU", lp = NULL); 9368 if (lp == NULL) { 9369 BAM_DPRINTF(("%s: no module/archive line for entry: %d\n", 9370 fcn, entryp->entryNum)); 9371 return; 9372 } 9373 9374 if (strstr(kernelp->arg, "$ISADIR") != NULL) { 9375 new_archive = DIRECT_BOOT_ARCHIVE; 9376 m_cmd = MODULE_DOLLAR_CMD; 9377 } else if (strstr(kernelp->arg, "amd64") != NULL) { 9378 new_archive = DIRECT_BOOT_ARCHIVE_64; 9379 m_cmd = MODULE_CMD; 9380 } else { 9381 new_archive = DIRECT_BOOT_ARCHIVE_32; 9382 m_cmd = MODULE_CMD; 9383 } 9384 9385 if (strcmp(lp->arg, new_archive) == 0) { 9386 BAM_DPRINTF(("%s: no change for line: %s\n", fcn, lp->arg)); 9387 return; 9388 } 9389 9390 if (lp->cmd != NULL && strcmp(lp->cmd, menu_cmds[m_cmd]) != 0) { 9391 free(lp->cmd); 9392 lp->cmd = s_strdup(menu_cmds[m_cmd]); 9393 } 9394 9395 free(lp->arg); 9396 lp->arg = s_strdup(new_archive); 9397 update_line(lp); 9398 BAM_DPRINTF(("%s: replaced for line: %s\n", fcn, lp->line)); 9399 } 9400 9401 /* 9402 * Title for an entry to set properties that once went in bootenv.rc. 9403 */ 9404 #define BOOTENV_RC_TITLE "Solaris bootenv rc" 9405 9406 /* 9407 * If path is NULL, return the kernel (optnum == KERNEL_CMD) or arguments 9408 * (optnum == ARGS_CMD) in the argument buf. If path is a zero-length 9409 * string, reset the value to the default. If path is a non-zero-length 9410 * string, set the kernel or arguments. 9411 */ 9412 static error_t 9413 get_set_kernel( 9414 menu_t *mp, 9415 menu_cmd_t optnum, 9416 char *path, 9417 char *buf, 9418 size_t bufsize) 9419 { 9420 int entryNum; 9421 int rv = BAM_SUCCESS; 9422 int free_new_path = 0; 9423 entry_t *entryp; 9424 line_t *ptr; 9425 line_t *kernelp; 9426 char *new_arg; 9427 char *old_args; 9428 char *space; 9429 char *new_path; 9430 char old_space; 9431 size_t old_kernel_len = 0; 9432 size_t new_str_len; 9433 char *fstype; 9434 char *osdev; 9435 char *sign; 9436 char signbuf[PATH_MAX]; 9437 int ret; 9438 const char *fcn = "get_set_kernel()"; 9439 9440 assert(bufsize > 0); 9441 9442 ptr = kernelp = NULL; 9443 new_arg = old_args = space = NULL; 9444 new_path = NULL; 9445 buf[0] = '\0'; 9446 9447 INJECT_ERROR1("GET_SET_KERNEL_NOT_DBOOT", 9448 bam_direct = BAM_DIRECT_MULTIBOOT); 9449 if (bam_direct != BAM_DIRECT_DBOOT) { 9450 bam_error(_("bootadm set-menu %s may only be run on " 9451 "directboot kernels.\n"), 9452 optnum == KERNEL_CMD ? "kernel" : "args"); 9453 return (BAM_ERROR); 9454 } 9455 9456 /* 9457 * If a user changed the default entry to a non-bootadm controlled 9458 * one, we don't want to mess with it. Just print an error and 9459 * return. 9460 */ 9461 if (mp->curdefault) { 9462 entryNum = s_strtol(mp->curdefault->arg); 9463 for (entryp = mp->entries; entryp; entryp = entryp->next) { 9464 if (entryp->entryNum == entryNum) 9465 break; 9466 } 9467 if ((entryp != NULL) && 9468 ((entryp->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU)) == 0)) { 9469 bam_error(_("Default /boot/grub/menu.lst entry is not " 9470 "controlled by bootadm. Exiting\n")); 9471 return (BAM_ERROR); 9472 } 9473 } 9474 9475 entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, NULL, 9476 0, &entryNum); 9477 9478 if (entryp != NULL) { 9479 for (ptr = entryp->start; ptr && ptr != entryp->end; 9480 ptr = ptr->next) { 9481 if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD], 9482 sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) { 9483 kernelp = ptr; 9484 break; 9485 } 9486 } 9487 if (kernelp == NULL) { 9488 bam_error(_("no kernel line found in entry %d\n"), 9489 entryNum); 9490 return (BAM_ERROR); 9491 } 9492 9493 old_kernel_len = strcspn(kernelp->arg, " \t"); 9494 space = old_args = kernelp->arg + old_kernel_len; 9495 while ((*old_args == ' ') || (*old_args == '\t')) 9496 old_args++; 9497 } 9498 9499 if (path == NULL) { 9500 if (entryp == NULL) { 9501 BAM_DPRINTF(("%s: no RC entry, nothing to report\n", 9502 fcn)); 9503 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9504 return (BAM_SUCCESS); 9505 } 9506 assert(kernelp); 9507 if (optnum == ARGS_CMD) { 9508 if (old_args[0] != '\0') { 9509 (void) strlcpy(buf, old_args, bufsize); 9510 BAM_DPRINTF(("%s: read menu boot-args: %s\n", 9511 fcn, buf)); 9512 } 9513 } else { 9514 /* 9515 * We need to print the kernel, so we just turn the 9516 * first space into a '\0' and print the beginning. 9517 * We don't print anything if it's the default kernel. 9518 */ 9519 old_space = *space; 9520 *space = '\0'; 9521 if (strcmp(kernelp->arg, DIRECT_BOOT_KERNEL) != 0) { 9522 (void) strlcpy(buf, kernelp->arg, bufsize); 9523 BAM_DPRINTF(("%s: read menu boot-file: %s\n", 9524 fcn, buf)); 9525 } 9526 *space = old_space; 9527 } 9528 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9529 return (BAM_SUCCESS); 9530 } 9531 9532 /* 9533 * First, check if we're resetting an entry to the default. 9534 */ 9535 if ((path[0] == '\0') || 9536 ((optnum == KERNEL_CMD) && 9537 (strcmp(path, DIRECT_BOOT_KERNEL) == 0))) { 9538 if ((entryp == NULL) || (kernelp == NULL)) { 9539 /* No previous entry, it's already the default */ 9540 BAM_DPRINTF(("%s: no reset, already has default\n", 9541 fcn)); 9542 return (BAM_SUCCESS); 9543 } 9544 9545 /* 9546 * Check if we can delete the entry. If we're resetting the 9547 * kernel command, and the args is already empty, or if we're 9548 * resetting the args command, and the kernel is already the 9549 * default, we can restore the old default and delete the entry. 9550 */ 9551 if (((optnum == KERNEL_CMD) && 9552 ((old_args == NULL) || (old_args[0] == '\0'))) || 9553 ((optnum == ARGS_CMD) && 9554 (strncmp(kernelp->arg, DIRECT_BOOT_KERNEL, 9555 sizeof (DIRECT_BOOT_KERNEL) - 1) == 0))) { 9556 kernelp = NULL; 9557 (void) delete_boot_entry(mp, entryNum, DBE_PRINTERR); 9558 restore_default_entry(mp, BAM_OLD_RC_DEF, 9559 mp->old_rc_default); 9560 mp->old_rc_default = NULL; 9561 rv = BAM_WRITE; 9562 BAM_DPRINTF(("%s: resetting to default\n", fcn)); 9563 goto done; 9564 } 9565 9566 if (optnum == KERNEL_CMD) { 9567 /* 9568 * At this point, we've already checked that old_args 9569 * and entryp are valid pointers. The "+ 2" is for 9570 * a space a the string termination character. 9571 */ 9572 new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) + 9573 strlen(old_args) + 2; 9574 new_arg = s_calloc(1, new_str_len); 9575 (void) snprintf(new_arg, new_str_len, "%s %s", 9576 DIRECT_BOOT_KERNEL, old_args); 9577 free(kernelp->arg); 9578 kernelp->arg = new_arg; 9579 9580 /* 9581 * We have changed the kernel line, so we may need 9582 * to update the archive line as well. 9583 */ 9584 set_archive_line(entryp, kernelp); 9585 BAM_DPRINTF(("%s: reset kernel to default, but " 9586 "retained old args: %s\n", fcn, kernelp->arg)); 9587 } else { 9588 /* 9589 * We're resetting the boot args to nothing, so 9590 * we only need to copy the kernel. We've already 9591 * checked that the kernel is not the default. 9592 */ 9593 new_arg = s_calloc(1, old_kernel_len + 1); 9594 (void) snprintf(new_arg, old_kernel_len + 1, "%s", 9595 kernelp->arg); 9596 free(kernelp->arg); 9597 kernelp->arg = new_arg; 9598 BAM_DPRINTF(("%s: reset args to default, but retained " 9599 "old kernel: %s\n", fcn, kernelp->arg)); 9600 } 9601 rv = BAM_WRITE; 9602 goto done; 9603 } 9604 9605 /* 9606 * Expand the kernel file to a full path, if necessary 9607 */ 9608 if ((optnum == KERNEL_CMD) && (path[0] != '/')) { 9609 new_path = expand_path(path); 9610 if (new_path == NULL) { 9611 bam_error(_("unable to expand %s to a full file " 9612 "path.\n"), path); 9613 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 9614 return (BAM_ERROR); 9615 } 9616 free_new_path = 1; 9617 } else { 9618 new_path = path; 9619 free_new_path = 0; 9620 } 9621 9622 /* 9623 * At this point, we know we're setting a new value. First, take care 9624 * of the case where there was no previous entry. 9625 */ 9626 if (entryp == NULL) { 9627 9628 /* Similar to code in update_temp */ 9629 fstype = get_fstype("/"); 9630 INJECT_ERROR1("GET_SET_KERNEL_FSTYPE", fstype = NULL); 9631 if (fstype == NULL) { 9632 bam_error(_("cannot determine filesystem type for " 9633 "\"/\".\nCannot generate GRUB menu entry with " 9634 "EEPROM arguments.\n")); 9635 rv = BAM_ERROR; 9636 goto done; 9637 } 9638 9639 osdev = get_special("/"); 9640 INJECT_ERROR1("GET_SET_KERNEL_SPECIAL", osdev = NULL); 9641 if (osdev == NULL) { 9642 free(fstype); 9643 bam_error(_("cannot determine device special file for " 9644 "\"/\".\nCannot generate GRUB menu entry with " 9645 "EEPROM arguments.\n")); 9646 rv = BAM_ERROR; 9647 goto done; 9648 } 9649 9650 sign = find_existing_sign("/", osdev, fstype); 9651 INJECT_ERROR1("GET_SET_KERNEL_SIGN", sign = NULL); 9652 if (sign == NULL) { 9653 free(fstype); 9654 free(osdev); 9655 bam_error(_("cannot determine boot signature for " 9656 "\"/\".\nCannot generate GRUB menu entry with " 9657 "EEPROM arguments.\n")); 9658 rv = BAM_ERROR; 9659 goto done; 9660 } 9661 9662 free(osdev); 9663 (void) strlcpy(signbuf, sign, sizeof (signbuf)); 9664 free(sign); 9665 assert(strchr(signbuf, '(') == NULL && 9666 strchr(signbuf, ',') == NULL && 9667 strchr(signbuf, ')') == NULL); 9668 9669 if (optnum == KERNEL_CMD) { 9670 if (strcmp(fstype, "zfs") == 0) { 9671 new_str_len = strlen(new_path) + 9672 strlen(ZFS_BOOT) + 8; 9673 new_arg = s_calloc(1, new_str_len); 9674 (void) snprintf(new_arg, new_str_len, "%s %s", 9675 new_path, ZFS_BOOT); 9676 BAM_DPRINTF(("%s: new kernel=%s\n", fcn, 9677 new_arg)); 9678 entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 9679 signbuf, new_arg, NULL, NULL, NULL); 9680 free(new_arg); 9681 } else { 9682 BAM_DPRINTF(("%s: new kernel=%s\n", fcn, 9683 new_path)); 9684 entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 9685 signbuf, new_path, NULL, NULL, NULL); 9686 } 9687 } else { 9688 new_str_len = strlen(path) + 8; 9689 if (strcmp(fstype, "zfs") == 0) { 9690 new_str_len += strlen(DIRECT_BOOT_KERNEL_ZFS); 9691 new_arg = s_calloc(1, new_str_len); 9692 (void) snprintf(new_arg, new_str_len, "%s %s", 9693 DIRECT_BOOT_KERNEL_ZFS, path); 9694 } else { 9695 new_str_len += strlen(DIRECT_BOOT_KERNEL); 9696 new_arg = s_calloc(1, new_str_len); 9697 (void) snprintf(new_arg, new_str_len, "%s %s", 9698 DIRECT_BOOT_KERNEL, path); 9699 } 9700 9701 BAM_DPRINTF(("%s: new args=%s\n", fcn, new_arg)); 9702 entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 9703 signbuf, new_arg, NULL, DIRECT_BOOT_ARCHIVE, NULL); 9704 free(new_arg); 9705 } 9706 free(fstype); 9707 INJECT_ERROR1("GET_SET_KERNEL_ADD_BOOT_ENTRY", 9708 entryNum = BAM_ERROR); 9709 if (entryNum == BAM_ERROR) { 9710 bam_error(_("failed to add boot entry: %s\n"), 9711 BOOTENV_RC_TITLE); 9712 rv = BAM_ERROR; 9713 goto done; 9714 } 9715 save_default_entry(mp, BAM_OLD_RC_DEF); 9716 ret = set_global(mp, menu_cmds[DEFAULT_CMD], entryNum); 9717 INJECT_ERROR1("GET_SET_KERNEL_SET_GLOBAL", ret = BAM_ERROR); 9718 if (ret == BAM_ERROR) { 9719 bam_error(_("failed to set default to: %d\n"), 9720 entryNum); 9721 } 9722 rv = BAM_WRITE; 9723 goto done; 9724 } 9725 9726 /* 9727 * There was already an bootenv entry which we need to edit. 9728 */ 9729 if (optnum == KERNEL_CMD) { 9730 new_str_len = strlen(new_path) + strlen(old_args) + 2; 9731 new_arg = s_calloc(1, new_str_len); 9732 (void) snprintf(new_arg, new_str_len, "%s %s", new_path, 9733 old_args); 9734 free(kernelp->arg); 9735 kernelp->arg = new_arg; 9736 9737 /* 9738 * If we have changed the kernel line, we may need to update 9739 * the archive line as well. 9740 */ 9741 set_archive_line(entryp, kernelp); 9742 BAM_DPRINTF(("%s: rc line exists, replaced kernel, same " 9743 "args: %s\n", fcn, kernelp->arg)); 9744 } else { 9745 new_str_len = old_kernel_len + strlen(path) + 8; 9746 new_arg = s_calloc(1, new_str_len); 9747 (void) strncpy(new_arg, kernelp->arg, old_kernel_len); 9748 (void) strlcat(new_arg, " ", new_str_len); 9749 (void) strlcat(new_arg, path, new_str_len); 9750 free(kernelp->arg); 9751 kernelp->arg = new_arg; 9752 BAM_DPRINTF(("%s: rc line exists, same kernel, but new " 9753 "args: %s\n", fcn, kernelp->arg)); 9754 } 9755 rv = BAM_WRITE; 9756 9757 done: 9758 if ((rv == BAM_WRITE) && kernelp) 9759 update_line(kernelp); 9760 if (free_new_path) 9761 free(new_path); 9762 if (rv == BAM_WRITE) { 9763 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9764 } else { 9765 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 9766 } 9767 return (rv); 9768 } 9769 9770 static error_t 9771 get_kernel(menu_t *mp, menu_cmd_t optnum, char *buf, size_t bufsize) 9772 { 9773 const char *fcn = "get_kernel()"; 9774 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, menu_cmds[optnum])); 9775 return (get_set_kernel(mp, optnum, NULL, buf, bufsize)); 9776 } 9777 9778 static error_t 9779 set_kernel(menu_t *mp, menu_cmd_t optnum, char *path, char *buf, size_t bufsize) 9780 { 9781 const char *fcn = "set_kernel()"; 9782 assert(path != NULL); 9783 BAM_DPRINTF(("%s: entered. args: %s %s\n", fcn, 9784 menu_cmds[optnum], path)); 9785 return (get_set_kernel(mp, optnum, path, buf, bufsize)); 9786 } 9787 9788 /*ARGSUSED*/ 9789 static error_t 9790 set_option(menu_t *mp, char *dummy, char *opt) 9791 { 9792 int optnum; 9793 int optval; 9794 char *val; 9795 char buf[BUFSIZ] = ""; 9796 error_t rv; 9797 const char *fcn = "set_option()"; 9798 9799 assert(mp); 9800 assert(opt); 9801 assert(dummy == NULL); 9802 9803 /* opt is set from bam_argv[0] and is always non-NULL */ 9804 BAM_DPRINTF(("%s: entered. arg: %s\n", fcn, opt)); 9805 9806 val = strchr(opt, '='); 9807 if (val != NULL) { 9808 *val = '\0'; 9809 } 9810 9811 if (strcmp(opt, "default") == 0) { 9812 optnum = DEFAULT_CMD; 9813 } else if (strcmp(opt, "timeout") == 0) { 9814 optnum = TIMEOUT_CMD; 9815 } else if (strcmp(opt, menu_cmds[KERNEL_CMD]) == 0) { 9816 optnum = KERNEL_CMD; 9817 } else if (strcmp(opt, menu_cmds[ARGS_CMD]) == 0) { 9818 optnum = ARGS_CMD; 9819 } else { 9820 bam_error(_("invalid option: %s\n"), opt); 9821 return (BAM_ERROR); 9822 } 9823 9824 /* 9825 * kernel and args are allowed without "=new_value" strings. All 9826 * others cause errors 9827 */ 9828 if ((val == NULL) && (optnum != KERNEL_CMD) && (optnum != ARGS_CMD)) { 9829 bam_error(_("option has no argument: %s\n"), opt); 9830 return (BAM_ERROR); 9831 } else if (val != NULL) { 9832 *val = '='; 9833 } 9834 9835 if ((optnum == KERNEL_CMD) || (optnum == ARGS_CMD)) { 9836 BAM_DPRINTF(("%s: setting %s option to %s\n", 9837 fcn, menu_cmds[optnum], val ? val + 1 : "NULL")); 9838 9839 if (val) 9840 rv = set_kernel(mp, optnum, val + 1, buf, sizeof (buf)); 9841 else 9842 rv = get_kernel(mp, optnum, buf, sizeof (buf)); 9843 if ((rv == BAM_SUCCESS) && (buf[0] != '\0')) 9844 (void) printf("%s\n", buf); 9845 } else { 9846 optval = s_strtol(val + 1); 9847 BAM_DPRINTF(("%s: setting %s option to %s\n", fcn, 9848 menu_cmds[optnum], val + 1)); 9849 rv = set_global(mp, menu_cmds[optnum], optval); 9850 } 9851 9852 if (rv == BAM_WRITE || rv == BAM_SUCCESS) { 9853 BAM_DPRINTF(("%s: returning SUCCESS\n", fcn)); 9854 } else { 9855 BAM_DPRINTF(("%s: returning FAILURE\n", fcn)); 9856 } 9857 9858 return (rv); 9859 } 9860 9861 /* 9862 * The quiet argument suppresses messages. This is used 9863 * when invoked in the context of other commands (e.g. list_entry) 9864 */ 9865 static error_t 9866 read_globals(menu_t *mp, char *menu_path, char *globalcmd, int quiet) 9867 { 9868 line_t *lp; 9869 char *arg; 9870 int done, ret = BAM_SUCCESS; 9871 9872 assert(mp); 9873 assert(menu_path); 9874 assert(globalcmd); 9875 9876 if (mp->start == NULL) { 9877 if (!quiet) 9878 bam_error(_("menu file not found: %s\n"), menu_path); 9879 return (BAM_ERROR); 9880 } 9881 9882 done = 0; 9883 for (lp = mp->start; lp; lp = lp->next) { 9884 if (lp->flags != BAM_GLOBAL) 9885 continue; 9886 9887 if (lp->cmd == NULL) { 9888 if (!quiet) 9889 bam_error(_("no command at line %d\n"), 9890 lp->lineNum); 9891 continue; 9892 } 9893 9894 if (strcmp(globalcmd, lp->cmd) != 0) 9895 continue; 9896 9897 /* Found global. Check for duplicates */ 9898 if (done && !quiet) { 9899 bam_error(_("duplicate command %s at line %d of " 9900 "%sboot/grub/menu.lst\n"), globalcmd, 9901 lp->lineNum, bam_root); 9902 ret = BAM_ERROR; 9903 } 9904 9905 arg = lp->arg ? lp->arg : ""; 9906 bam_print(_("%s %s\n"), globalcmd, arg); 9907 done = 1; 9908 } 9909 9910 if (!done && bam_verbose) 9911 bam_print(_("no %s entry found\n"), globalcmd); 9912 9913 return (ret); 9914 } 9915 9916 static error_t 9917 menu_write(char *root, menu_t *mp) 9918 { 9919 const char *fcn = "menu_write()"; 9920 9921 BAM_DPRINTF(("%s: entered menu_write() for root: <%s>\n", fcn, root)); 9922 return (list2file(root, MENU_TMP, GRUB_MENU, mp->start)); 9923 } 9924 9925 void 9926 line_free(line_t *lp) 9927 { 9928 if (lp == NULL) 9929 return; 9930 9931 if (lp->cmd != NULL) 9932 free(lp->cmd); 9933 if (lp->sep) 9934 free(lp->sep); 9935 if (lp->arg) 9936 free(lp->arg); 9937 if (lp->line) 9938 free(lp->line); 9939 free(lp); 9940 } 9941 9942 static void 9943 linelist_free(line_t *start) 9944 { 9945 line_t *lp; 9946 9947 while (start) { 9948 lp = start; 9949 start = start->next; 9950 line_free(lp); 9951 } 9952 } 9953 9954 static void 9955 filelist_free(filelist_t *flistp) 9956 { 9957 linelist_free(flistp->head); 9958 flistp->head = NULL; 9959 flistp->tail = NULL; 9960 } 9961 9962 static void 9963 menu_free(menu_t *mp) 9964 { 9965 entry_t *ent, *tmp; 9966 assert(mp); 9967 9968 if (mp->start) 9969 linelist_free(mp->start); 9970 ent = mp->entries; 9971 while (ent) { 9972 tmp = ent; 9973 ent = tmp->next; 9974 free(tmp); 9975 } 9976 9977 free(mp); 9978 } 9979 9980 /* 9981 * Utility routines 9982 */ 9983 9984 9985 /* 9986 * Returns 0 on success 9987 * Any other value indicates an error 9988 */ 9989 static int 9990 exec_cmd(char *cmdline, filelist_t *flistp) 9991 { 9992 char buf[BUFSIZ]; 9993 int ret; 9994 FILE *ptr; 9995 sigset_t set; 9996 void (*disp)(int); 9997 9998 /* 9999 * For security 10000 * - only absolute paths are allowed 10001 * - set IFS to space and tab 10002 */ 10003 if (*cmdline != '/') { 10004 bam_error(_("path is not absolute: %s\n"), cmdline); 10005 return (-1); 10006 } 10007 (void) putenv("IFS= \t"); 10008 10009 /* 10010 * We may have been exec'ed with SIGCHLD blocked 10011 * unblock it here 10012 */ 10013 (void) sigemptyset(&set); 10014 (void) sigaddset(&set, SIGCHLD); 10015 if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) { 10016 bam_error(_("cannot unblock SIGCHLD: %s\n"), strerror(errno)); 10017 return (-1); 10018 } 10019 10020 /* 10021 * Set SIGCHLD disposition to SIG_DFL for popen/pclose 10022 */ 10023 disp = sigset(SIGCHLD, SIG_DFL); 10024 if (disp == SIG_ERR) { 10025 bam_error(_("cannot set SIGCHLD disposition: %s\n"), 10026 strerror(errno)); 10027 return (-1); 10028 } 10029 if (disp == SIG_HOLD) { 10030 bam_error(_("SIGCHLD signal blocked. Cannot exec: %s\n"), 10031 cmdline); 10032 return (-1); 10033 } 10034 10035 ptr = popen(cmdline, "r"); 10036 if (ptr == NULL) { 10037 bam_error(_("popen failed: %s: %s\n"), cmdline, 10038 strerror(errno)); 10039 return (-1); 10040 } 10041 10042 /* 10043 * If we simply do a pclose() following a popen(), pclose() 10044 * will close the reader end of the pipe immediately even 10045 * if the child process has not started/exited. pclose() 10046 * does wait for cmd to terminate before returning though. 10047 * When the executed command writes its output to the pipe 10048 * there is no reader process and the command dies with 10049 * SIGPIPE. To avoid this we read repeatedly until read 10050 * terminates with EOF. This indicates that the command 10051 * (writer) has closed the pipe and we can safely do a 10052 * pclose(). 10053 * 10054 * Since pclose() does wait for the command to exit, 10055 * we can safely reap the exit status of the command 10056 * from the value returned by pclose() 10057 */ 10058 while (s_fgets(buf, sizeof (buf), ptr) != NULL) { 10059 if (flistp == NULL) { 10060 /* s_fgets strips newlines, so insert them at the end */ 10061 bam_print(_("%s\n"), buf); 10062 } else { 10063 append_to_flist(flistp, buf); 10064 } 10065 } 10066 10067 ret = pclose(ptr); 10068 if (ret == -1) { 10069 bam_error(_("pclose failed: %s: %s\n"), cmdline, 10070 strerror(errno)); 10071 return (-1); 10072 } 10073 10074 if (WIFEXITED(ret)) { 10075 return (WEXITSTATUS(ret)); 10076 } else { 10077 bam_error(_("command terminated abnormally: %s: %d\n"), 10078 cmdline, ret); 10079 return (-1); 10080 } 10081 } 10082 10083 /* 10084 * Since this function returns -1 on error 10085 * it cannot be used to convert -1. However, 10086 * that is sufficient for what we need. 10087 */ 10088 static long 10089 s_strtol(char *str) 10090 { 10091 long l; 10092 char *res = NULL; 10093 10094 if (str == NULL) { 10095 return (-1); 10096 } 10097 10098 errno = 0; 10099 l = strtol(str, &res, 10); 10100 if (errno || *res != '\0') { 10101 return (-1); 10102 } 10103 10104 return (l); 10105 } 10106 10107 /* 10108 * Wrapper around fputs, that adds a newline (since fputs doesn't) 10109 */ 10110 static int 10111 s_fputs(char *str, FILE *fp) 10112 { 10113 char linebuf[BAM_MAXLINE]; 10114 10115 (void) snprintf(linebuf, sizeof (linebuf), "%s\n", str); 10116 return (fputs(linebuf, fp)); 10117 } 10118 10119 /* 10120 * Wrapper around fgets, that strips newlines returned by fgets 10121 */ 10122 char * 10123 s_fgets(char *buf, int buflen, FILE *fp) 10124 { 10125 int n; 10126 10127 buf = fgets(buf, buflen, fp); 10128 if (buf) { 10129 n = strlen(buf); 10130 if (n == buflen - 1 && buf[n-1] != '\n') 10131 bam_error(_("the following line is too long " 10132 "(> %d chars)\n\t%s\n"), buflen - 1, buf); 10133 buf[n-1] = (buf[n-1] == '\n') ? '\0' : buf[n-1]; 10134 } 10135 10136 return (buf); 10137 } 10138 10139 void * 10140 s_calloc(size_t nelem, size_t sz) 10141 { 10142 void *ptr; 10143 10144 ptr = calloc(nelem, sz); 10145 if (ptr == NULL) { 10146 bam_error(_("could not allocate memory: size = %u\n"), 10147 nelem*sz); 10148 bam_exit(1); 10149 } 10150 return (ptr); 10151 } 10152 10153 void * 10154 s_realloc(void *ptr, size_t sz) 10155 { 10156 ptr = realloc(ptr, sz); 10157 if (ptr == NULL) { 10158 bam_error(_("could not allocate memory: size = %u\n"), sz); 10159 bam_exit(1); 10160 } 10161 return (ptr); 10162 } 10163 10164 char * 10165 s_strdup(char *str) 10166 { 10167 char *ptr; 10168 10169 if (str == NULL) 10170 return (NULL); 10171 10172 ptr = strdup(str); 10173 if (ptr == NULL) { 10174 bam_error(_("could not allocate memory: size = %u\n"), 10175 strlen(str) + 1); 10176 bam_exit(1); 10177 } 10178 return (ptr); 10179 } 10180 10181 /* 10182 * Returns 1 if amd64 (or sparc, for syncing x86 diskless clients) 10183 * Returns 0 otherwise 10184 */ 10185 static int 10186 is_amd64(void) 10187 { 10188 static int amd64 = -1; 10189 char isabuf[257]; /* from sysinfo(2) manpage */ 10190 10191 if (amd64 != -1) 10192 return (amd64); 10193 10194 if (bam_alt_platform) { 10195 if (strcmp(bam_platform, "i86pc") == 0) { 10196 amd64 = 1; /* diskless server */ 10197 } 10198 } else { 10199 if (sysinfo(SI_ISALIST, isabuf, sizeof (isabuf)) > 0 && 10200 strncmp(isabuf, "amd64 ", strlen("amd64 ")) == 0) { 10201 amd64 = 1; 10202 } else if (strstr(isabuf, "i386") == NULL) { 10203 amd64 = 1; /* diskless server */ 10204 } 10205 } 10206 if (amd64 == -1) 10207 amd64 = 0; 10208 10209 return (amd64); 10210 } 10211 10212 static char * 10213 get_machine(void) 10214 { 10215 static int cached = -1; 10216 static char mbuf[257]; /* from sysinfo(2) manpage */ 10217 10218 if (cached == 0) 10219 return (mbuf); 10220 10221 if (bam_alt_platform) { 10222 return (bam_platform); 10223 } else { 10224 if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0) { 10225 cached = 1; 10226 } 10227 } 10228 if (cached == -1) { 10229 mbuf[0] = '\0'; 10230 cached = 0; 10231 } 10232 10233 return (mbuf); 10234 } 10235 10236 int 10237 is_sparc(void) 10238 { 10239 static int issparc = -1; 10240 char mbuf[257]; /* from sysinfo(2) manpage */ 10241 10242 if (issparc != -1) 10243 return (issparc); 10244 10245 if (bam_alt_platform) { 10246 if (strncmp(bam_platform, "sun4", 4) == 0) { 10247 issparc = 1; 10248 } 10249 } else { 10250 if (sysinfo(SI_ARCHITECTURE, mbuf, sizeof (mbuf)) > 0 && 10251 strcmp(mbuf, "sparc") == 0) { 10252 issparc = 1; 10253 } 10254 } 10255 if (issparc == -1) 10256 issparc = 0; 10257 10258 return (issparc); 10259 } 10260 10261 static void 10262 append_to_flist(filelist_t *flistp, char *s) 10263 { 10264 line_t *lp; 10265 10266 lp = s_calloc(1, sizeof (line_t)); 10267 lp->line = s_strdup(s); 10268 if (flistp->head == NULL) 10269 flistp->head = lp; 10270 else 10271 flistp->tail->next = lp; 10272 flistp->tail = lp; 10273 } 10274 10275 #if !defined(_OBP) 10276 10277 UCODE_VENDORS; 10278 10279 /*ARGSUSED*/ 10280 static void 10281 ucode_install(char *root) 10282 { 10283 int i; 10284 10285 for (i = 0; ucode_vendors[i].filestr != NULL; i++) { 10286 int cmd_len = PATH_MAX + 256; 10287 char cmd[PATH_MAX + 256]; 10288 char file[PATH_MAX]; 10289 char timestamp[PATH_MAX]; 10290 struct stat fstatus, tstatus; 10291 struct utimbuf u_times; 10292 10293 (void) snprintf(file, PATH_MAX, "%s/%s/%s-ucode.%s", 10294 bam_root, UCODE_INSTALL_PATH, ucode_vendors[i].filestr, 10295 ucode_vendors[i].extstr); 10296 10297 if (stat(file, &fstatus) != 0 || !(S_ISREG(fstatus.st_mode))) 10298 continue; 10299 10300 (void) snprintf(timestamp, PATH_MAX, "%s.ts", file); 10301 10302 if (stat(timestamp, &tstatus) == 0 && 10303 fstatus.st_mtime <= tstatus.st_mtime) 10304 continue; 10305 10306 (void) snprintf(cmd, cmd_len, "/usr/sbin/ucodeadm -i -R " 10307 "%s/%s/%s %s > /dev/null 2>&1", bam_root, 10308 UCODE_INSTALL_PATH, ucode_vendors[i].vendorstr, file); 10309 if (system(cmd) != 0) 10310 return; 10311 10312 if (creat(timestamp, S_IRUSR | S_IWUSR) == -1) 10313 return; 10314 10315 u_times.actime = fstatus.st_atime; 10316 u_times.modtime = fstatus.st_mtime; 10317 (void) utime(timestamp, &u_times); 10318 } 10319 } 10320 #endif 10321