17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5fbac2b2bSvikram * Common Development and Distribution License (the "License"). 6fbac2b2bSvikram * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22d876c67dSjg * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate /* 297c478bd9Sstevel@tonic-gate * bootadm(1M) is a new utility for managing bootability of 307c478bd9Sstevel@tonic-gate * Solaris *Newboot* environments. It has two primary tasks: 317c478bd9Sstevel@tonic-gate * - Allow end users to manage bootability of Newboot Solaris instances 327c478bd9Sstevel@tonic-gate * - Provide services to other subsystems in Solaris (primarily Install) 337c478bd9Sstevel@tonic-gate */ 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate /* Headers */ 367c478bd9Sstevel@tonic-gate #include <stdio.h> 377c478bd9Sstevel@tonic-gate #include <errno.h> 387c478bd9Sstevel@tonic-gate #include <stdlib.h> 397c478bd9Sstevel@tonic-gate #include <string.h> 407c478bd9Sstevel@tonic-gate #include <unistd.h> 417c478bd9Sstevel@tonic-gate #include <sys/types.h> 427c478bd9Sstevel@tonic-gate #include <sys/stat.h> 437c478bd9Sstevel@tonic-gate #include <stdarg.h> 447c478bd9Sstevel@tonic-gate #include <limits.h> 457c478bd9Sstevel@tonic-gate #include <signal.h> 467c478bd9Sstevel@tonic-gate #include <sys/wait.h> 477c478bd9Sstevel@tonic-gate #include <sys/mnttab.h> 487c478bd9Sstevel@tonic-gate #include <sys/statvfs.h> 497c478bd9Sstevel@tonic-gate #include <libnvpair.h> 507c478bd9Sstevel@tonic-gate #include <ftw.h> 517c478bd9Sstevel@tonic-gate #include <fcntl.h> 527c478bd9Sstevel@tonic-gate #include <strings.h> 532449e17fSsherrym #include <utime.h> 547c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 557c478bd9Sstevel@tonic-gate #include <sys/dktp/fdisk.h> 5658091fd8Ssetje #include <sys/param.h> 57eb2bd662Svikram #include <dirent.h> 58eb2bd662Svikram #include <ctype.h> 59eb2bd662Svikram #include <libgen.h> 60e7cbe64fSgw #include <sys/sysmacros.h> 61986fd29aSsetje 62986fd29aSsetje #if !defined(_OPB) 632449e17fSsherrym #include <sys/ucode.h> 642449e17fSsherrym #endif 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate #include <pwd.h> 677c478bd9Sstevel@tonic-gate #include <grp.h> 687c478bd9Sstevel@tonic-gate #include <device_info.h> 69eb2bd662Svikram #include <sys/vtoc.h> 70eb2bd662Svikram #include <sys/efi_partition.h> 71eb2bd662Svikram 727c478bd9Sstevel@tonic-gate #include <locale.h> 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate #include "message.h" 75ae115bc7Smrj #include "bootadm.h" 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 787c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD" 797c478bd9Sstevel@tonic-gate #endif /* TEXT_DOMAIN */ 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate /* Type definitions */ 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate /* Primary subcmds */ 847c478bd9Sstevel@tonic-gate typedef enum { 857c478bd9Sstevel@tonic-gate BAM_MENU = 3, 867c478bd9Sstevel@tonic-gate BAM_ARCHIVE 877c478bd9Sstevel@tonic-gate } subcmd_t; 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate typedef enum { 907c478bd9Sstevel@tonic-gate OPT_ABSENT = 0, /* No option */ 917c478bd9Sstevel@tonic-gate OPT_REQ, /* option required */ 927c478bd9Sstevel@tonic-gate OPT_OPTIONAL /* option may or may not be present */ 937c478bd9Sstevel@tonic-gate } option_t; 947c478bd9Sstevel@tonic-gate 957c478bd9Sstevel@tonic-gate typedef struct { 967c478bd9Sstevel@tonic-gate char *subcmd; 977c478bd9Sstevel@tonic-gate option_t option; 987c478bd9Sstevel@tonic-gate error_t (*handler)(); 991a97e40eSvikram int unpriv; /* is this an unprivileged command */ 1007c478bd9Sstevel@tonic-gate } subcmd_defn_t; 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate #define LINE_INIT 0 /* lineNum initial value */ 1037c478bd9Sstevel@tonic-gate #define ENTRY_INIT -1 /* entryNum initial value */ 1047c478bd9Sstevel@tonic-gate #define ALL_ENTRIES -2 /* selects all boot entries */ 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate #define GRUB_DIR "/boot/grub" 1077c478bd9Sstevel@tonic-gate #define GRUB_MENU "/boot/grub/menu.lst" 1087c478bd9Sstevel@tonic-gate #define MENU_TMP "/boot/grub/menu.lst.tmp" 1097c478bd9Sstevel@tonic-gate #define RAMDISK_SPECIAL "/ramdisk" 11040541d5dSvikram #define STUBBOOT "/stubboot" 111eb2bd662Svikram #define MULTIBOOT "/platform/i86pc/multiboot" 112eb2bd662Svikram #define GRUBSIGN_DIR "/boot/grub/bootsign" 113eb2bd662Svikram #define GRUBSIGN_BACKUP "/etc/bootsign" 114eb2bd662Svikram #define GRUBSIGN_UFS_PREFIX "rootfs" 115eb2bd662Svikram #define GRUBSIGN_ZFS_PREFIX "pool_" 116eb2bd662Svikram #define GRUBSIGN_LU_PREFIX "BE_" 117eb2bd662Svikram #define UFS_SIGNATURE_LIST "/var/run/grub_ufs_signatures" 118eb2bd662Svikram #define ZFS_LEGACY_MNTPT "/tmp/bootadm_mnt_zfs_legacy" 119eb2bd662Svikram 120eb2bd662Svikram #define BOOTADM_RDONLY_TEST "BOOTADM_RDONLY_TEST" 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate /* lock related */ 1237c478bd9Sstevel@tonic-gate #define BAM_LOCK_FILE "/var/run/bootadm.lock" 1247c478bd9Sstevel@tonic-gate #define LOCK_FILE_PERMS (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 1257c478bd9Sstevel@tonic-gate 126986fd29aSsetje #define CREATE_RAMDISK "boot/solaris/bin/create_ramdisk" 127986fd29aSsetje #define CREATE_DISKMAP "boot/solaris/bin/create_diskmap" 128986fd29aSsetje #define EXTRACT_BOOT_FILELIST "boot/solaris/bin/extract_boot_filelist" 1297c478bd9Sstevel@tonic-gate #define GRUBDISK_MAP "/var/run/solaris_grubdisk.map" 1307c478bd9Sstevel@tonic-gate 131b610f78eSvikram #define GRUB_slice "/etc/lu/GRUB_slice" 132b610f78eSvikram #define GRUB_root "/etc/lu/GRUB_root" 133fbac2b2bSvikram #define GRUB_fdisk "/etc/lu/GRUB_fdisk" 134fbac2b2bSvikram #define GRUB_fdisk_target "/etc/lu/GRUB_fdisk_target" 135b610f78eSvikram 136b610f78eSvikram #define INSTALLGRUB "/sbin/installgrub" 137b610f78eSvikram #define STAGE1 "/boot/grub/stage1" 138b610f78eSvikram #define STAGE2 "/boot/grub/stage2" 139b610f78eSvikram 140eb2bd662Svikram typedef enum zfs_mnted { 141eb2bd662Svikram ZFS_MNT_ERROR = -1, 142eb2bd662Svikram LEGACY_MOUNTED = 1, 143eb2bd662Svikram LEGACY_ALREADY, 144eb2bd662Svikram ZFS_MOUNTED, 145eb2bd662Svikram ZFS_ALREADY 146eb2bd662Svikram } zfs_mnted_t; 147eb2bd662Svikram 148eb2bd662Svikram 149eb2bd662Svikram 150eb2bd662Svikram 15198892a30Snadkarni /* 15298892a30Snadkarni * The following two defines are used to detect and create the correct 15398892a30Snadkarni * boot archive when safemode patching is underway. LOFS_PATCH_FILE is a 15498892a30Snadkarni * contracted private interface between bootadm and the install 15598892a30Snadkarni * consolidation. It is set by pdo.c when a patch with SUNW_PATCH_SAFEMODE 15698892a30Snadkarni * is applied. 15798892a30Snadkarni */ 15898892a30Snadkarni 15998892a30Snadkarni #define LOFS_PATCH_FILE "/var/run/.patch_loopback_mode" 16098892a30Snadkarni #define LOFS_PATCH_MNT "/var/run/.patch_root_loopbackmnt" 16198892a30Snadkarni 1627c478bd9Sstevel@tonic-gate /* 1637c478bd9Sstevel@tonic-gate * Default file attributes 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_MODE 0644 /* default permissions */ 1667c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_UID 0 /* user root */ 1677c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_GID 3 /* group sys */ 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate /* 1707c478bd9Sstevel@tonic-gate * Menu related 1717c478bd9Sstevel@tonic-gate * menu_cmd_t and menu_cmds must be kept in sync 1727c478bd9Sstevel@tonic-gate */ 173ae115bc7Smrj char *menu_cmds[] = { 1747c478bd9Sstevel@tonic-gate "default", /* DEFAULT_CMD */ 1757c478bd9Sstevel@tonic-gate "timeout", /* TIMEOUT_CMD */ 1767c478bd9Sstevel@tonic-gate "title", /* TITLE_CMD */ 1777c478bd9Sstevel@tonic-gate "root", /* ROOT_CMD */ 1787c478bd9Sstevel@tonic-gate "kernel", /* KERNEL_CMD */ 179ae115bc7Smrj "kernel$", /* KERNEL_DOLLAR_CMD */ 1807c478bd9Sstevel@tonic-gate "module", /* MODULE_CMD */ 181ae115bc7Smrj "module$", /* MODULE_DOLLAR_CMD */ 1827c478bd9Sstevel@tonic-gate " ", /* SEP_CMD */ 1837c478bd9Sstevel@tonic-gate "#", /* COMMENT_CMD */ 184ae115bc7Smrj "chainloader", /* CHAINLOADER_CMD */ 185ae115bc7Smrj "args", /* ARGS_CMD */ 186eb2bd662Svikram "findroot", /* FINDROOT_CMD */ 1877c478bd9Sstevel@tonic-gate NULL 1887c478bd9Sstevel@tonic-gate }; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate #define OPT_ENTRY_NUM "entry" 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate /* 193eb2bd662Svikram * exec_cmd related 1947c478bd9Sstevel@tonic-gate */ 1957c478bd9Sstevel@tonic-gate typedef struct { 1967c478bd9Sstevel@tonic-gate line_t *head; 1977c478bd9Sstevel@tonic-gate line_t *tail; 1987c478bd9Sstevel@tonic-gate } filelist_t; 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate #define BOOT_FILE_LIST "boot/solaris/filelist.ramdisk" 2017c478bd9Sstevel@tonic-gate #define ETC_FILE_LIST "etc/boot/solaris/filelist.ramdisk" 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate #define FILE_STAT "boot/solaris/filestat.ramdisk" 2047c478bd9Sstevel@tonic-gate #define FILE_STAT_TMP "boot/solaris/filestat.ramdisk.tmp" 2057c478bd9Sstevel@tonic-gate #define DIR_PERMS (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 2067c478bd9Sstevel@tonic-gate #define FILE_STAT_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate /* Globals */ 209ae115bc7Smrj int bam_verbose; 210ae115bc7Smrj int bam_force; 211eb2bd662Svikram int bam_debug; 2127c478bd9Sstevel@tonic-gate static char *prog; 2137c478bd9Sstevel@tonic-gate static subcmd_t bam_cmd; 2147c478bd9Sstevel@tonic-gate static char *bam_root; 2157c478bd9Sstevel@tonic-gate static int bam_rootlen; 2167c478bd9Sstevel@tonic-gate static int bam_root_readonly; 21740541d5dSvikram static int bam_alt_root; 2187c478bd9Sstevel@tonic-gate static char *bam_subcmd; 2197c478bd9Sstevel@tonic-gate static char *bam_opt; 2207c478bd9Sstevel@tonic-gate static char **bam_argv; 2217c478bd9Sstevel@tonic-gate static int bam_argc; 2227c478bd9Sstevel@tonic-gate static int bam_check; 2237c478bd9Sstevel@tonic-gate static int bam_smf_check; 2247c478bd9Sstevel@tonic-gate static int bam_lock_fd = -1; 225e7cbe64fSgw static int bam_zfs; 2267c478bd9Sstevel@tonic-gate static char rootbuf[PATH_MAX] = "/"; 227b610f78eSvikram static int bam_update_all; 228d876c67dSjg static int bam_alt_platform; 229d876c67dSjg static char *bam_platform; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate /* function prototypes */ 232986fd29aSsetje static void parse_args_internal(int, char *[]); 233986fd29aSsetje static void parse_args(int, char *argv[]); 234986fd29aSsetje static error_t bam_menu(char *, char *, int, char *[]); 235986fd29aSsetje static error_t bam_archive(char *, char *); 2367c478bd9Sstevel@tonic-gate 237986fd29aSsetje static void bam_exit(int); 2387c478bd9Sstevel@tonic-gate static void bam_lock(void); 2397c478bd9Sstevel@tonic-gate static void bam_unlock(void); 2407c478bd9Sstevel@tonic-gate 241986fd29aSsetje static int exec_cmd(char *, filelist_t *); 242986fd29aSsetje static error_t read_globals(menu_t *, char *, char *, int); 243eb2bd662Svikram static int menu_on_bootdisk(char *os_root, char *menu_root); 244986fd29aSsetje static menu_t *menu_read(char *); 245986fd29aSsetje static error_t menu_write(char *, menu_t *); 246986fd29aSsetje static void linelist_free(line_t *); 247986fd29aSsetje static void menu_free(menu_t *); 248986fd29aSsetje static void filelist_free(filelist_t *); 249986fd29aSsetje static error_t list2file(char *, char *, char *, line_t *); 250986fd29aSsetje static error_t list_entry(menu_t *, char *, char *); 251986fd29aSsetje static error_t delete_all_entries(menu_t *, char *, char *); 252eb2bd662Svikram static error_t update_entry(menu_t *mp, char *menu_root, char *opt); 253eb2bd662Svikram static error_t update_temp(menu_t *mp, char *dummy, char *opt); 254986fd29aSsetje 255986fd29aSsetje static error_t update_archive(char *, char *); 256986fd29aSsetje static error_t list_archive(char *, char *); 257986fd29aSsetje static error_t update_all(char *, char *); 258986fd29aSsetje static error_t read_list(char *, filelist_t *); 259986fd29aSsetje static error_t set_global(menu_t *, char *, int); 260986fd29aSsetje static error_t set_option(menu_t *, char *, char *); 261986fd29aSsetje static error_t set_kernel(menu_t *, menu_cmd_t, char *, char *, size_t); 262eb2bd662Svikram static error_t get_kernel(menu_t *, menu_cmd_t, char *, size_t); 263986fd29aSsetje static char *expand_path(const char *); 264986fd29aSsetje 265986fd29aSsetje static long s_strtol(char *); 266986fd29aSsetje static int s_fputs(char *, FILE *); 267986fd29aSsetje 268eb2bd662Svikram static int is_zfs(char *root); 269eb2bd662Svikram static int is_ufs(char *root); 270eb2bd662Svikram static int is_pcfs(char *root); 2717c478bd9Sstevel@tonic-gate static int is_amd64(void); 272*79755401Ssetje static char *get_machine(void); 2737c478bd9Sstevel@tonic-gate static void append_to_flist(filelist_t *, char *); 274eb2bd662Svikram static char *mount_top_dataset(char *pool, zfs_mnted_t *mnted); 275eb2bd662Svikram static int umount_top_dataset(char *pool, zfs_mnted_t mnted, char *mntpt); 276eb2bd662Svikram static int ufs_add_to_sign_list(char *sign); 2777c478bd9Sstevel@tonic-gate 278986fd29aSsetje #if !defined(_OPB) 2792449e17fSsherrym static void ucode_install(); 2802449e17fSsherrym #endif 2812449e17fSsherrym 2827c478bd9Sstevel@tonic-gate /* Menu related sub commands */ 2837c478bd9Sstevel@tonic-gate static subcmd_defn_t menu_subcmds[] = { 284eb2bd662Svikram "set_option", OPT_ABSENT, set_option, 0, /* PUB */ 2851a97e40eSvikram "list_entry", OPT_OPTIONAL, list_entry, 1, /* PUB */ 2861a97e40eSvikram "delete_all_entries", OPT_ABSENT, delete_all_entries, 0, /* PVT */ 2871a97e40eSvikram "update_entry", OPT_REQ, update_entry, 0, /* menu */ 2881a97e40eSvikram "update_temp", OPT_OPTIONAL, update_temp, 0, /* reboot */ 289ae115bc7Smrj "upgrade", OPT_ABSENT, upgrade_menu, 0, /* menu */ 2901a97e40eSvikram NULL, 0, NULL, 0 /* must be last */ 2917c478bd9Sstevel@tonic-gate }; 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate /* Archive related sub commands */ 2947c478bd9Sstevel@tonic-gate static subcmd_defn_t arch_subcmds[] = { 2951a97e40eSvikram "update", OPT_ABSENT, update_archive, 0, /* PUB */ 2961a97e40eSvikram "update_all", OPT_ABSENT, update_all, 0, /* PVT */ 2971a97e40eSvikram "list", OPT_OPTIONAL, list_archive, 1, /* PUB */ 2981a97e40eSvikram NULL, 0, NULL, 0 /* must be last */ 2997c478bd9Sstevel@tonic-gate }; 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate static struct { 3027c478bd9Sstevel@tonic-gate nvlist_t *new_nvlp; 3037c478bd9Sstevel@tonic-gate nvlist_t *old_nvlp; 3047c478bd9Sstevel@tonic-gate int need_update; 3057c478bd9Sstevel@tonic-gate } walk_arg; 3067c478bd9Sstevel@tonic-gate 30758091fd8Ssetje 3089632cfadSsetje struct safefile { 30958091fd8Ssetje char *name; 31058091fd8Ssetje struct safefile *next; 31158091fd8Ssetje }; 31258091fd8Ssetje 313ae115bc7Smrj static struct safefile *safefiles = NULL; 31458091fd8Ssetje #define NEED_UPDATE_FILE "/etc/svc/volatile/boot_archive_needs_update" 31558091fd8Ssetje 3167c478bd9Sstevel@tonic-gate static void 3177c478bd9Sstevel@tonic-gate usage(void) 3187c478bd9Sstevel@tonic-gate { 3197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "USAGE:\n"); 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* archive usage */ 323d876c67dSjg (void) fprintf(stderr, 324d876c67dSjg "\t%s update-archive [-vn] [-R altroot [-p platform>]]\n", prog); 325d876c67dSjg (void) fprintf(stderr, 326d876c67dSjg "\t%s list-archive [-R altroot [-p platform>]]\n", prog); 327986fd29aSsetje #if !defined(_OPB) 3287c478bd9Sstevel@tonic-gate /* x86 only */ 3297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s set-menu [-R altroot] key=value\n", prog); 3307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s list-menu [-R altroot]\n", prog); 3317c478bd9Sstevel@tonic-gate #endif 3327c478bd9Sstevel@tonic-gate } 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate int 3357c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 3367c478bd9Sstevel@tonic-gate { 3377c478bd9Sstevel@tonic-gate error_t ret; 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 3407c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate if ((prog = strrchr(argv[0], '/')) == NULL) { 3437c478bd9Sstevel@tonic-gate prog = argv[0]; 3447c478bd9Sstevel@tonic-gate } else { 3457c478bd9Sstevel@tonic-gate prog++; 3467c478bd9Sstevel@tonic-gate } 3477c478bd9Sstevel@tonic-gate 348eb2bd662Svikram INJECT_ERROR1("ASSERT_ON", assert(0)) 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate /* 3517c478bd9Sstevel@tonic-gate * Don't depend on caller's umask 3527c478bd9Sstevel@tonic-gate */ 3537c478bd9Sstevel@tonic-gate (void) umask(0022); 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate parse_args(argc, argv); 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate switch (bam_cmd) { 3587c478bd9Sstevel@tonic-gate case BAM_MENU: 3597c478bd9Sstevel@tonic-gate ret = bam_menu(bam_subcmd, bam_opt, bam_argc, bam_argv); 3607c478bd9Sstevel@tonic-gate break; 3617c478bd9Sstevel@tonic-gate case BAM_ARCHIVE: 3627c478bd9Sstevel@tonic-gate ret = bam_archive(bam_subcmd, bam_opt); 3637c478bd9Sstevel@tonic-gate break; 3647c478bd9Sstevel@tonic-gate default: 3657c478bd9Sstevel@tonic-gate usage(); 3667c478bd9Sstevel@tonic-gate bam_exit(1); 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate if (ret != BAM_SUCCESS) 3707c478bd9Sstevel@tonic-gate bam_exit(1); 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate bam_unlock(); 3737c478bd9Sstevel@tonic-gate return (0); 3747c478bd9Sstevel@tonic-gate } 3757c478bd9Sstevel@tonic-gate 3767c478bd9Sstevel@tonic-gate /* 3777c478bd9Sstevel@tonic-gate * Equivalence of public and internal commands: 3787c478bd9Sstevel@tonic-gate * update-archive -- -a update 3797c478bd9Sstevel@tonic-gate * list-archive -- -a list 3807c478bd9Sstevel@tonic-gate * set-menu -- -m set_option 3817c478bd9Sstevel@tonic-gate * list-menu -- -m list_entry 3827c478bd9Sstevel@tonic-gate * update-menu -- -m update_entry 3837c478bd9Sstevel@tonic-gate */ 3847c478bd9Sstevel@tonic-gate static struct cmd_map { 3857c478bd9Sstevel@tonic-gate char *bam_cmdname; 3867c478bd9Sstevel@tonic-gate int bam_cmd; 3877c478bd9Sstevel@tonic-gate char *bam_subcmd; 3887c478bd9Sstevel@tonic-gate } cmd_map[] = { 3897c478bd9Sstevel@tonic-gate { "update-archive", BAM_ARCHIVE, "update"}, 3907c478bd9Sstevel@tonic-gate { "list-archive", BAM_ARCHIVE, "list"}, 3917c478bd9Sstevel@tonic-gate { "set-menu", BAM_MENU, "set_option"}, 3927c478bd9Sstevel@tonic-gate { "list-menu", BAM_MENU, "list_entry"}, 3937c478bd9Sstevel@tonic-gate { "update-menu", BAM_MENU, "update_entry"}, 3947c478bd9Sstevel@tonic-gate { NULL, 0, NULL} 3957c478bd9Sstevel@tonic-gate }; 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate /* 3987c478bd9Sstevel@tonic-gate * Commands syntax published in bootadm(1M) are parsed here 3997c478bd9Sstevel@tonic-gate */ 4007c478bd9Sstevel@tonic-gate static void 4017c478bd9Sstevel@tonic-gate parse_args(int argc, char *argv[]) 4027c478bd9Sstevel@tonic-gate { 4037c478bd9Sstevel@tonic-gate struct cmd_map *cmp = cmd_map; 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate /* command conforming to the final spec */ 4067c478bd9Sstevel@tonic-gate if (argc > 1 && argv[1][0] != '-') { 4077c478bd9Sstevel@tonic-gate /* 4087c478bd9Sstevel@tonic-gate * Map commands to internal table. 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate while (cmp->bam_cmdname) { 4117c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmp->bam_cmdname) == 0) { 4127c478bd9Sstevel@tonic-gate bam_cmd = cmp->bam_cmd; 4137c478bd9Sstevel@tonic-gate bam_subcmd = cmp->bam_subcmd; 4147c478bd9Sstevel@tonic-gate break; 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate cmp++; 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate if (cmp->bam_cmdname == NULL) { 4197c478bd9Sstevel@tonic-gate usage(); 4207c478bd9Sstevel@tonic-gate bam_exit(1); 4217c478bd9Sstevel@tonic-gate } 4227c478bd9Sstevel@tonic-gate argc--; 4237c478bd9Sstevel@tonic-gate argv++; 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate parse_args_internal(argc, argv); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate /* 4307c478bd9Sstevel@tonic-gate * A combination of public and private commands are parsed here. 4317c478bd9Sstevel@tonic-gate * The internal syntax and the corresponding functionality are: 4327c478bd9Sstevel@tonic-gate * -a update -- update-archive 4337c478bd9Sstevel@tonic-gate * -a list -- list-archive 4347c478bd9Sstevel@tonic-gate * -a update-all -- (reboot to sync all mounted OS archive) 4357c478bd9Sstevel@tonic-gate * -m update_entry -- update-menu 4367c478bd9Sstevel@tonic-gate * -m list_entry -- list-menu 4377c478bd9Sstevel@tonic-gate * -m update_temp -- (reboot -- [boot-args]) 4387c478bd9Sstevel@tonic-gate * -m delete_all_entries -- (called from install) 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate static void 4417c478bd9Sstevel@tonic-gate parse_args_internal(int argc, char *argv[]) 4427c478bd9Sstevel@tonic-gate { 4437c478bd9Sstevel@tonic-gate int c, error; 4447c478bd9Sstevel@tonic-gate extern char *optarg; 4457c478bd9Sstevel@tonic-gate extern int optind, opterr; 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate /* Suppress error message from getopt */ 4487c478bd9Sstevel@tonic-gate opterr = 0; 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate error = 0; 451e7cbe64fSgw while ((c = getopt(argc, argv, "a:d:fm:no:vCR:p:Z")) != -1) { 4527c478bd9Sstevel@tonic-gate switch (c) { 4537c478bd9Sstevel@tonic-gate case 'a': 4547c478bd9Sstevel@tonic-gate if (bam_cmd) { 4557c478bd9Sstevel@tonic-gate error = 1; 4567c478bd9Sstevel@tonic-gate bam_error(MULT_CMDS, c); 4577c478bd9Sstevel@tonic-gate } 4587c478bd9Sstevel@tonic-gate bam_cmd = BAM_ARCHIVE; 4597c478bd9Sstevel@tonic-gate bam_subcmd = optarg; 4607c478bd9Sstevel@tonic-gate break; 4617c478bd9Sstevel@tonic-gate case 'd': 4627c478bd9Sstevel@tonic-gate if (bam_debug) { 4637c478bd9Sstevel@tonic-gate error = 1; 4647c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate bam_debug = s_strtol(optarg); 4677c478bd9Sstevel@tonic-gate break; 4687c478bd9Sstevel@tonic-gate case 'f': 4697c478bd9Sstevel@tonic-gate if (bam_force) { 4707c478bd9Sstevel@tonic-gate error = 1; 4717c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate bam_force = 1; 4747c478bd9Sstevel@tonic-gate break; 4757c478bd9Sstevel@tonic-gate case 'm': 4767c478bd9Sstevel@tonic-gate if (bam_cmd) { 4777c478bd9Sstevel@tonic-gate error = 1; 4787c478bd9Sstevel@tonic-gate bam_error(MULT_CMDS, c); 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate bam_cmd = BAM_MENU; 4817c478bd9Sstevel@tonic-gate bam_subcmd = optarg; 4827c478bd9Sstevel@tonic-gate break; 4837c478bd9Sstevel@tonic-gate case 'n': 4847c478bd9Sstevel@tonic-gate if (bam_check) { 4857c478bd9Sstevel@tonic-gate error = 1; 4867c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4877c478bd9Sstevel@tonic-gate } 4887c478bd9Sstevel@tonic-gate bam_check = 1; 4897c478bd9Sstevel@tonic-gate break; 4907c478bd9Sstevel@tonic-gate case 'o': 4917c478bd9Sstevel@tonic-gate if (bam_opt) { 4927c478bd9Sstevel@tonic-gate error = 1; 4937c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4947c478bd9Sstevel@tonic-gate } 4957c478bd9Sstevel@tonic-gate bam_opt = optarg; 4967c478bd9Sstevel@tonic-gate break; 4977c478bd9Sstevel@tonic-gate case 'v': 4987c478bd9Sstevel@tonic-gate if (bam_verbose) { 4997c478bd9Sstevel@tonic-gate error = 1; 5007c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate bam_verbose = 1; 5037c478bd9Sstevel@tonic-gate break; 5048c1b6884Sszhou case 'C': 5058c1b6884Sszhou bam_smf_check = 1; 5068c1b6884Sszhou break; 5077c478bd9Sstevel@tonic-gate case 'R': 5087c478bd9Sstevel@tonic-gate if (bam_root) { 5097c478bd9Sstevel@tonic-gate error = 1; 5107c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 5117c478bd9Sstevel@tonic-gate break; 5127c478bd9Sstevel@tonic-gate } else if (realpath(optarg, rootbuf) == NULL) { 5137c478bd9Sstevel@tonic-gate error = 1; 5147c478bd9Sstevel@tonic-gate bam_error(CANT_RESOLVE, optarg, 5157c478bd9Sstevel@tonic-gate strerror(errno)); 5167c478bd9Sstevel@tonic-gate break; 5177c478bd9Sstevel@tonic-gate } 51840541d5dSvikram bam_alt_root = 1; 5197c478bd9Sstevel@tonic-gate bam_root = rootbuf; 5207c478bd9Sstevel@tonic-gate bam_rootlen = strlen(rootbuf); 5217c478bd9Sstevel@tonic-gate break; 522d876c67dSjg case 'p': 523d876c67dSjg bam_alt_platform = 1; 524d876c67dSjg bam_platform = optarg; 525d876c67dSjg if ((strcmp(bam_platform, "i86pc") != 0) && 526d876c67dSjg (strcmp(bam_platform, "sun4u") != 0) && 527d876c67dSjg (strcmp(bam_platform, "sun4v") != 0)) { 528d876c67dSjg error = 1; 529d876c67dSjg bam_error(INVALID_PLAT, bam_platform); 530d876c67dSjg } 531d876c67dSjg break; 532e7cbe64fSgw case 'Z': 533e7cbe64fSgw bam_zfs = 1; 534e7cbe64fSgw break; 5357c478bd9Sstevel@tonic-gate case '?': 5367c478bd9Sstevel@tonic-gate error = 1; 5377c478bd9Sstevel@tonic-gate bam_error(BAD_OPT, optopt); 5387c478bd9Sstevel@tonic-gate break; 5397c478bd9Sstevel@tonic-gate default : 5407c478bd9Sstevel@tonic-gate error = 1; 5417c478bd9Sstevel@tonic-gate bam_error(BAD_OPT, c); 5427c478bd9Sstevel@tonic-gate break; 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate 546d876c67dSjg /* 547d876c67dSjg * An alternate platform requires an alternate root 548d876c67dSjg */ 549d876c67dSjg if (bam_alt_platform && bam_alt_root == 0) { 550d876c67dSjg usage(); 551d876c67dSjg bam_exit(0); 552d876c67dSjg } 553d876c67dSjg 5547c478bd9Sstevel@tonic-gate /* 5557c478bd9Sstevel@tonic-gate * A command option must be specfied 5567c478bd9Sstevel@tonic-gate */ 5577c478bd9Sstevel@tonic-gate if (!bam_cmd) { 5587c478bd9Sstevel@tonic-gate if (bam_opt && strcmp(bam_opt, "all") == 0) { 5597c478bd9Sstevel@tonic-gate usage(); 5607c478bd9Sstevel@tonic-gate bam_exit(0); 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate bam_error(NEED_CMD); 5637c478bd9Sstevel@tonic-gate error = 1; 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate if (error) { 5677c478bd9Sstevel@tonic-gate usage(); 5687c478bd9Sstevel@tonic-gate bam_exit(1); 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate if (optind > argc) { 5727c478bd9Sstevel@tonic-gate bam_error(INT_ERROR, "parse_args"); 5737c478bd9Sstevel@tonic-gate bam_exit(1); 5747c478bd9Sstevel@tonic-gate } else if (optind < argc) { 5757c478bd9Sstevel@tonic-gate bam_argv = &argv[optind]; 5767c478bd9Sstevel@tonic-gate bam_argc = argc - optind; 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate /* 5807c478bd9Sstevel@tonic-gate * -n implies verbose mode 5817c478bd9Sstevel@tonic-gate */ 5827c478bd9Sstevel@tonic-gate if (bam_check) 5837c478bd9Sstevel@tonic-gate bam_verbose = 1; 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate static error_t 5877c478bd9Sstevel@tonic-gate check_subcmd_and_options( 5887c478bd9Sstevel@tonic-gate char *subcmd, 5897c478bd9Sstevel@tonic-gate char *opt, 5907c478bd9Sstevel@tonic-gate subcmd_defn_t *table, 5917c478bd9Sstevel@tonic-gate error_t (**fp)()) 5927c478bd9Sstevel@tonic-gate { 5937c478bd9Sstevel@tonic-gate int i; 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate if (subcmd == NULL) { 5967c478bd9Sstevel@tonic-gate bam_error(NEED_SUBCMD); 5977c478bd9Sstevel@tonic-gate return (BAM_ERROR); 5987c478bd9Sstevel@tonic-gate } 5997c478bd9Sstevel@tonic-gate 600eb2bd662Svikram if (strcmp(subcmd, "set_option") == 0) { 601eb2bd662Svikram if (bam_argc == 0 || bam_argv == NULL || bam_argv[0] == NULL) { 602eb2bd662Svikram bam_error(MISSING_ARG); 603eb2bd662Svikram usage(); 604eb2bd662Svikram return (BAM_ERROR); 605eb2bd662Svikram } else if (bam_argc > 1 || bam_argv[1] != NULL) { 6061a97e40eSvikram bam_error(TRAILING_ARGS); 6071a97e40eSvikram usage(); 6081a97e40eSvikram return (BAM_ERROR); 6091a97e40eSvikram } 610eb2bd662Svikram } else if (bam_argc || bam_argv) { 611eb2bd662Svikram bam_error(TRAILING_ARGS); 612eb2bd662Svikram usage(); 613eb2bd662Svikram return (BAM_ERROR); 6141a97e40eSvikram } 6151a97e40eSvikram 6167c478bd9Sstevel@tonic-gate if (bam_root == NULL) { 6177c478bd9Sstevel@tonic-gate bam_root = rootbuf; 6187c478bd9Sstevel@tonic-gate bam_rootlen = 1; 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate /* verify that subcmd is valid */ 6227c478bd9Sstevel@tonic-gate for (i = 0; table[i].subcmd != NULL; i++) { 6237c478bd9Sstevel@tonic-gate if (strcmp(table[i].subcmd, subcmd) == 0) 6247c478bd9Sstevel@tonic-gate break; 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate if (table[i].subcmd == NULL) { 6287c478bd9Sstevel@tonic-gate bam_error(INVALID_SUBCMD, subcmd); 6297c478bd9Sstevel@tonic-gate return (BAM_ERROR); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate 6321a97e40eSvikram if (table[i].unpriv == 0 && geteuid() != 0) { 6331a97e40eSvikram bam_error(MUST_BE_ROOT); 6341a97e40eSvikram return (BAM_ERROR); 6351a97e40eSvikram } 6361a97e40eSvikram 6371a97e40eSvikram /* 6381a97e40eSvikram * Currently only privileged commands need a lock 6391a97e40eSvikram */ 6401a97e40eSvikram if (table[i].unpriv == 0) 6411a97e40eSvikram bam_lock(); 6421a97e40eSvikram 6437c478bd9Sstevel@tonic-gate /* subcmd verifies that opt is appropriate */ 6447c478bd9Sstevel@tonic-gate if (table[i].option != OPT_OPTIONAL) { 6457c478bd9Sstevel@tonic-gate if ((table[i].option == OPT_REQ) ^ (opt != NULL)) { 6467c478bd9Sstevel@tonic-gate if (opt) 6477c478bd9Sstevel@tonic-gate bam_error(NO_OPT_REQ, subcmd); 6487c478bd9Sstevel@tonic-gate else 6497c478bd9Sstevel@tonic-gate bam_error(MISS_OPT, subcmd); 6507c478bd9Sstevel@tonic-gate return (BAM_ERROR); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate } 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate *fp = table[i].handler; 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 65940541d5dSvikram /* 66040541d5dSvikram * NOTE: A single "/" is also considered a trailing slash and will 66140541d5dSvikram * be deleted. 66240541d5dSvikram */ 66340541d5dSvikram static void 66440541d5dSvikram elide_trailing_slash(const char *src, char *dst, size_t dstsize) 66540541d5dSvikram { 66640541d5dSvikram size_t dstlen; 66740541d5dSvikram 66840541d5dSvikram assert(src); 66940541d5dSvikram assert(dst); 67040541d5dSvikram 67140541d5dSvikram (void) strlcpy(dst, src, dstsize); 67240541d5dSvikram 67340541d5dSvikram dstlen = strlen(dst); 67440541d5dSvikram if (dst[dstlen - 1] == '/') { 67540541d5dSvikram dst[dstlen - 1] = '\0'; 67640541d5dSvikram } 67740541d5dSvikram } 67840541d5dSvikram 6797c478bd9Sstevel@tonic-gate static error_t 6807c478bd9Sstevel@tonic-gate bam_menu(char *subcmd, char *opt, int largc, char *largv[]) 6817c478bd9Sstevel@tonic-gate { 682eb2bd662Svikram error_t ret; 683eb2bd662Svikram char menu_path[PATH_MAX]; 684eb2bd662Svikram char clean_menu_root[PATH_MAX]; 685eb2bd662Svikram char path[PATH_MAX]; 686eb2bd662Svikram menu_t *menu; 687eb2bd662Svikram char menu_root[PATH_MAX]; 688eb2bd662Svikram struct stat sb; 6897c478bd9Sstevel@tonic-gate error_t (*f)(menu_t *mp, char *menu_path, char *opt); 690eb2bd662Svikram char *special; 691eb2bd662Svikram char *pool = NULL; 692eb2bd662Svikram zfs_mnted_t zmnted; 693eb2bd662Svikram char *zmntpt; 694eb2bd662Svikram char *osdev; 695eb2bd662Svikram char *osroot; 696eb2bd662Svikram const char *fcn = "bam_menu()"; 697986fd29aSsetje 698986fd29aSsetje /* 699986fd29aSsetje * Menu sub-command only applies to GRUB (i.e. x86) 700986fd29aSsetje */ 701eb2bd662Svikram if (!is_grub(bam_alt_root ? bam_root : "/")) { 702eb2bd662Svikram bam_error(NOT_GRUB_BOOT); 703986fd29aSsetje return (BAM_ERROR); 704986fd29aSsetje } 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate /* 7077c478bd9Sstevel@tonic-gate * Check arguments 7087c478bd9Sstevel@tonic-gate */ 7097c478bd9Sstevel@tonic-gate ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f); 7107c478bd9Sstevel@tonic-gate if (ret == BAM_ERROR) { 7117c478bd9Sstevel@tonic-gate return (BAM_ERROR); 7127c478bd9Sstevel@tonic-gate } 7137c478bd9Sstevel@tonic-gate 714eb2bd662Svikram assert(bam_root); 71540541d5dSvikram 716eb2bd662Svikram (void) strlcpy(menu_root, bam_root, sizeof (menu_root)); 717eb2bd662Svikram osdev = osroot = NULL; 718eb2bd662Svikram 719eb2bd662Svikram if (strcmp(subcmd, "update_entry") == 0) { 720eb2bd662Svikram assert(opt); 721eb2bd662Svikram 722eb2bd662Svikram osdev = strtok(opt, ","); 723eb2bd662Svikram assert(osdev); 724eb2bd662Svikram osroot = strtok(NULL, ","); 725eb2bd662Svikram if (osroot) { 726eb2bd662Svikram /* fixup bam_root so that it points at osroot */ 727eb2bd662Svikram if (realpath(osroot, rootbuf) == NULL) { 728eb2bd662Svikram bam_error(CANT_RESOLVE, osroot, 729eb2bd662Svikram strerror(errno)); 730eb2bd662Svikram return (BAM_ERROR); 731eb2bd662Svikram } 732eb2bd662Svikram bam_alt_root = 1; 733eb2bd662Svikram bam_root = rootbuf; 734eb2bd662Svikram bam_rootlen = strlen(rootbuf); 735eb2bd662Svikram } 736ae115bc7Smrj } 737ae115bc7Smrj 738eb2bd662Svikram /* 739eb2bd662Svikram * We support menu on PCFS (under certain conditions), but 740eb2bd662Svikram * not the OS root 741eb2bd662Svikram */ 742eb2bd662Svikram if (is_pcfs(bam_root)) { 743eb2bd662Svikram bam_error(PCFS_ROOT_NOTSUP, bam_root); 744eb2bd662Svikram return (BAM_ERROR); 745b610f78eSvikram } 746b610f78eSvikram 747eb2bd662Svikram if (stat(menu_root, &sb) == -1) { 74840541d5dSvikram bam_error(CANNOT_LOCATE_GRUB_MENU); 74940541d5dSvikram return (BAM_ERROR); 75040541d5dSvikram } 75140541d5dSvikram 752eb2bd662Svikram BAM_DPRINTF((D_MENU_ROOT, fcn, menu_root)); 753eb2bd662Svikram 754e7cbe64fSgw /* 755eb2bd662Svikram * We no longer use the GRUB slice file. If it exists, then 756eb2bd662Svikram * the user is doing something that is unsupported (such as 757eb2bd662Svikram * standard upgrading an old Live Upgrade BE). If that 758eb2bd662Svikram * happens, mimic existing behavior i.e. pretend that it is 759eb2bd662Svikram * not a BE. Emit a warning though. 760e7cbe64fSgw */ 761eb2bd662Svikram if (bam_alt_root) { 762eb2bd662Svikram (void) snprintf(path, sizeof (path), "%s%s", bam_root, 763eb2bd662Svikram GRUB_slice); 764eb2bd662Svikram } else { 765eb2bd662Svikram (void) snprintf(path, sizeof (path), "%s", GRUB_slice); 766eb2bd662Svikram } 767eb2bd662Svikram 768eb2bd662Svikram if (stat(path, &sb) == 0) 769eb2bd662Svikram bam_error(GRUB_SLICE_FILE_EXISTS, path); 770eb2bd662Svikram 771eb2bd662Svikram if (is_zfs(menu_root)) { 772eb2bd662Svikram assert(strcmp(menu_root, bam_root) == 0); 773eb2bd662Svikram special = get_special(menu_root); 774eb2bd662Svikram INJECT_ERROR1("Z_MENU_GET_SPECIAL", special = NULL); 775eb2bd662Svikram if (special == NULL) { 776eb2bd662Svikram bam_error(CANT_FIND_SPECIAL, menu_root); 777eb2bd662Svikram return (BAM_ERROR); 778eb2bd662Svikram } 779eb2bd662Svikram pool = strtok(special, "/"); 780eb2bd662Svikram INJECT_ERROR1("Z_MENU_GET_POOL", pool = NULL); 781eb2bd662Svikram if (pool == NULL) { 782eb2bd662Svikram free(special); 783eb2bd662Svikram bam_error(CANT_FIND_POOL, menu_root); 784eb2bd662Svikram return (BAM_ERROR); 785eb2bd662Svikram } 786eb2bd662Svikram BAM_DPRINTF((D_Z_MENU_GET_POOL_FROM_SPECIAL, fcn, pool)); 787e7cbe64fSgw 788eb2bd662Svikram zmntpt = mount_top_dataset(pool, &zmnted); 789eb2bd662Svikram INJECT_ERROR1("Z_MENU_MOUNT_TOP_DATASET", zmntpt = NULL); 790eb2bd662Svikram if (zmntpt == NULL) { 791eb2bd662Svikram bam_error(CANT_MOUNT_POOL_DATASET, pool); 792eb2bd662Svikram free(special); 793eb2bd662Svikram return (BAM_ERROR); 794eb2bd662Svikram } 795eb2bd662Svikram BAM_DPRINTF((D_Z_GET_MENU_MOUNT_TOP_DATASET, fcn, zmntpt)); 796eb2bd662Svikram 797eb2bd662Svikram (void) strlcpy(menu_root, zmntpt, sizeof (menu_root)); 798eb2bd662Svikram BAM_DPRINTF((D_Z_GET_MENU_MENU_ROOT, fcn, menu_root)); 799e7cbe64fSgw } 800e7cbe64fSgw 801eb2bd662Svikram elide_trailing_slash(menu_root, clean_menu_root, 802eb2bd662Svikram sizeof (clean_menu_root)); 803eb2bd662Svikram 804eb2bd662Svikram BAM_DPRINTF((D_CLEAN_MENU_ROOT, fcn, clean_menu_root)); 805eb2bd662Svikram 806eb2bd662Svikram (void) strlcpy(menu_path, clean_menu_root, sizeof (menu_path)); 80740541d5dSvikram (void) strlcat(menu_path, GRUB_MENU, sizeof (menu_path)); 80840541d5dSvikram 809eb2bd662Svikram BAM_DPRINTF((D_MENU_PATH, fcn, menu_path)); 810eb2bd662Svikram 81140541d5dSvikram /* 812eb2bd662Svikram * If listing the menu, display the menu location 81340541d5dSvikram */ 81440541d5dSvikram if (strcmp(subcmd, "list_entry") == 0) { 815eb2bd662Svikram bam_print(GRUB_MENU_PATH, menu_path); 81640541d5dSvikram } 8177c478bd9Sstevel@tonic-gate 818eb2bd662Svikram 8197c478bd9Sstevel@tonic-gate menu = menu_read(menu_path); 8207c478bd9Sstevel@tonic-gate assert(menu); 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate /* 823eb2bd662Svikram * We already checked the following case in 824eb2bd662Svikram * check_subcmd_and_suboptions() above. Complete the 825eb2bd662Svikram * final step now. 8267c478bd9Sstevel@tonic-gate */ 8277c478bd9Sstevel@tonic-gate if (strcmp(subcmd, "set_option") == 0) { 828eb2bd662Svikram assert(largc == 1 && largv[0] && largv[1] == NULL); 8297c478bd9Sstevel@tonic-gate opt = largv[0]; 830eb2bd662Svikram } else { 831eb2bd662Svikram assert(largc == 0 && largv == NULL); 8327c478bd9Sstevel@tonic-gate } 8337c478bd9Sstevel@tonic-gate 834eb2bd662Svikram ret = get_boot_cap(bam_root); 835eb2bd662Svikram if (ret != BAM_SUCCESS) { 836eb2bd662Svikram BAM_DPRINTF((D_BOOT_GET_CAP_FAILED, fcn)); 837eb2bd662Svikram goto out; 838eb2bd662Svikram } 839ae115bc7Smrj 8407c478bd9Sstevel@tonic-gate /* 8417c478bd9Sstevel@tonic-gate * Once the sub-cmd handler has run 8427c478bd9Sstevel@tonic-gate * only the line field is guaranteed to have valid values 8437c478bd9Sstevel@tonic-gate */ 844eb2bd662Svikram if (strcmp(subcmd, "update_entry") == 0) 845eb2bd662Svikram ret = f(menu, menu_root, osdev); 846eb2bd662Svikram else if (strcmp(subcmd, "upgrade") == 0) 847eb2bd662Svikram ret = f(menu, bam_root, menu_root); 848eb2bd662Svikram else if (strcmp(subcmd, "list_entry") == 0) 8497c478bd9Sstevel@tonic-gate ret = f(menu, menu_path, opt); 850eb2bd662Svikram else 851eb2bd662Svikram ret = f(menu, NULL, opt); 852eb2bd662Svikram 8537c478bd9Sstevel@tonic-gate if (ret == BAM_WRITE) { 854eb2bd662Svikram BAM_DPRINTF((D_WRITING_MENU_ROOT, fcn, clean_menu_root)); 855eb2bd662Svikram ret = menu_write(clean_menu_root, menu); 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate 858eb2bd662Svikram out: 859eb2bd662Svikram INJECT_ERROR1("POOL_SET", pool = "/pooldata"); 860eb2bd662Svikram assert((is_zfs(menu_root)) ^ (pool == NULL)); 861eb2bd662Svikram if (pool) { 862eb2bd662Svikram (void) umount_top_dataset(pool, zmnted, zmntpt); 863eb2bd662Svikram free(special); 864eb2bd662Svikram } 8657c478bd9Sstevel@tonic-gate menu_free(menu); 8667c478bd9Sstevel@tonic-gate return (ret); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate static error_t 8717c478bd9Sstevel@tonic-gate bam_archive( 8727c478bd9Sstevel@tonic-gate char *subcmd, 8737c478bd9Sstevel@tonic-gate char *opt) 8747c478bd9Sstevel@tonic-gate { 875eb2bd662Svikram error_t ret; 876eb2bd662Svikram error_t (*f)(char *root, char *opt); 877eb2bd662Svikram const char *fcn = "bam_archive()"; 8787c478bd9Sstevel@tonic-gate 8798c1b6884Sszhou /* 8808c1b6884Sszhou * Add trailing / for archive subcommands 8818c1b6884Sszhou */ 8828c1b6884Sszhou if (rootbuf[strlen(rootbuf) - 1] != '/') 8838c1b6884Sszhou (void) strcat(rootbuf, "/"); 8848c1b6884Sszhou bam_rootlen = strlen(rootbuf); 8858c1b6884Sszhou 8867c478bd9Sstevel@tonic-gate /* 8877c478bd9Sstevel@tonic-gate * Check arguments 8887c478bd9Sstevel@tonic-gate */ 8897c478bd9Sstevel@tonic-gate ret = check_subcmd_and_options(subcmd, opt, arch_subcmds, &f); 8907c478bd9Sstevel@tonic-gate if (ret != BAM_SUCCESS) { 8917c478bd9Sstevel@tonic-gate return (BAM_ERROR); 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate 894eb2bd662Svikram ret = get_boot_cap(rootbuf); 895eb2bd662Svikram if (ret != BAM_SUCCESS) { 896eb2bd662Svikram BAM_DPRINTF((D_BOOT_GET_CAP_FAILED, fcn)); 897ae115bc7Smrj return (ret); 898eb2bd662Svikram } 899ae115bc7Smrj 9007c478bd9Sstevel@tonic-gate /* 9017c478bd9Sstevel@tonic-gate * Check archive not supported with update_all 9027c478bd9Sstevel@tonic-gate * since it is awkward to display out-of-sync 9037c478bd9Sstevel@tonic-gate * information for each BE. 9047c478bd9Sstevel@tonic-gate */ 9057c478bd9Sstevel@tonic-gate if (bam_check && strcmp(subcmd, "update_all") == 0) { 9067c478bd9Sstevel@tonic-gate bam_error(CHECK_NOT_SUPPORTED, subcmd); 9077c478bd9Sstevel@tonic-gate return (BAM_ERROR); 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 910b610f78eSvikram if (strcmp(subcmd, "update_all") == 0) 911b610f78eSvikram bam_update_all = 1; 912b610f78eSvikram 913986fd29aSsetje #if !defined(_OPB) 9142449e17fSsherrym ucode_install(bam_root); 9152449e17fSsherrym #endif 9162449e17fSsherrym 917b610f78eSvikram ret = f(bam_root, opt); 918b610f78eSvikram 919b610f78eSvikram bam_update_all = 0; 920b610f78eSvikram 921b610f78eSvikram return (ret); 9227c478bd9Sstevel@tonic-gate } 9237c478bd9Sstevel@tonic-gate 9247c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 925ae115bc7Smrj void 9267c478bd9Sstevel@tonic-gate bam_error(char *format, ...) 9277c478bd9Sstevel@tonic-gate { 9287c478bd9Sstevel@tonic-gate va_list ap; 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate va_start(ap, format); 9317c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", prog); 9327c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, format, ap); 9337c478bd9Sstevel@tonic-gate va_end(ap); 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 937eb2bd662Svikram void 938eb2bd662Svikram bam_derror(char *format, ...) 939eb2bd662Svikram { 940eb2bd662Svikram va_list ap; 941eb2bd662Svikram 942eb2bd662Svikram assert(bam_debug); 943eb2bd662Svikram 944eb2bd662Svikram va_start(ap, format); 945eb2bd662Svikram (void) fprintf(stderr, "DEBUG: "); 946eb2bd662Svikram (void) vfprintf(stderr, format, ap); 947eb2bd662Svikram va_end(ap); 948eb2bd662Svikram } 949eb2bd662Svikram 950eb2bd662Svikram /*PRINTFLIKE1*/ 951eb2bd662Svikram void 9527c478bd9Sstevel@tonic-gate bam_print(char *format, ...) 9537c478bd9Sstevel@tonic-gate { 9547c478bd9Sstevel@tonic-gate va_list ap; 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate va_start(ap, format); 9577c478bd9Sstevel@tonic-gate (void) vfprintf(stdout, format, ap); 9587c478bd9Sstevel@tonic-gate va_end(ap); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 961ae115bc7Smrj /*PRINTFLIKE1*/ 962ae115bc7Smrj void 963ae115bc7Smrj bam_print_stderr(char *format, ...) 964ae115bc7Smrj { 965ae115bc7Smrj va_list ap; 966ae115bc7Smrj 967ae115bc7Smrj va_start(ap, format); 968ae115bc7Smrj (void) vfprintf(stderr, format, ap); 969ae115bc7Smrj va_end(ap); 970ae115bc7Smrj } 971ae115bc7Smrj 9727c478bd9Sstevel@tonic-gate static void 9737c478bd9Sstevel@tonic-gate bam_exit(int excode) 9747c478bd9Sstevel@tonic-gate { 9757c478bd9Sstevel@tonic-gate bam_unlock(); 9767c478bd9Sstevel@tonic-gate exit(excode); 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate static void 9807c478bd9Sstevel@tonic-gate bam_lock(void) 9817c478bd9Sstevel@tonic-gate { 9827c478bd9Sstevel@tonic-gate struct flock lock; 9837c478bd9Sstevel@tonic-gate pid_t pid; 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate bam_lock_fd = open(BAM_LOCK_FILE, O_CREAT|O_RDWR, LOCK_FILE_PERMS); 9867c478bd9Sstevel@tonic-gate if (bam_lock_fd < 0) { 9877c478bd9Sstevel@tonic-gate /* 9887c478bd9Sstevel@tonic-gate * We may be invoked early in boot for archive verification. 9897c478bd9Sstevel@tonic-gate * In this case, root is readonly and /var/run may not exist. 9907c478bd9Sstevel@tonic-gate * Proceed without the lock 9917c478bd9Sstevel@tonic-gate */ 9927c478bd9Sstevel@tonic-gate if (errno == EROFS || errno == ENOENT) { 9937c478bd9Sstevel@tonic-gate bam_root_readonly = 1; 9947c478bd9Sstevel@tonic-gate return; 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, BAM_LOCK_FILE, strerror(errno)); 9987c478bd9Sstevel@tonic-gate bam_exit(1); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 10027c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 10037c478bd9Sstevel@tonic-gate lock.l_start = 0; 10047c478bd9Sstevel@tonic-gate lock.l_len = 0; 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLK, &lock) == -1) { 10077c478bd9Sstevel@tonic-gate if (errno != EACCES && errno != EAGAIN) { 10087c478bd9Sstevel@tonic-gate bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 10097c478bd9Sstevel@tonic-gate (void) close(bam_lock_fd); 10107c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 10117c478bd9Sstevel@tonic-gate bam_exit(1); 10127c478bd9Sstevel@tonic-gate } 10137c478bd9Sstevel@tonic-gate pid = 0; 10147c478bd9Sstevel@tonic-gate (void) pread(bam_lock_fd, &pid, sizeof (pid_t), 0); 10157c478bd9Sstevel@tonic-gate bam_print(FILE_LOCKED, pid); 10167c478bd9Sstevel@tonic-gate 10177c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 10187c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 10197c478bd9Sstevel@tonic-gate lock.l_start = 0; 10207c478bd9Sstevel@tonic-gate lock.l_len = 0; 10217c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLKW, &lock) == -1) { 10227c478bd9Sstevel@tonic-gate bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 10237c478bd9Sstevel@tonic-gate (void) close(bam_lock_fd); 10247c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 10257c478bd9Sstevel@tonic-gate bam_exit(1); 10267c478bd9Sstevel@tonic-gate } 10277c478bd9Sstevel@tonic-gate } 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate /* We own the lock now */ 10307c478bd9Sstevel@tonic-gate pid = getpid(); 10317c478bd9Sstevel@tonic-gate (void) write(bam_lock_fd, &pid, sizeof (pid)); 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate static void 10357c478bd9Sstevel@tonic-gate bam_unlock(void) 10367c478bd9Sstevel@tonic-gate { 10377c478bd9Sstevel@tonic-gate struct flock unlock; 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate /* 10407c478bd9Sstevel@tonic-gate * NOP if we don't hold the lock 10417c478bd9Sstevel@tonic-gate */ 10427c478bd9Sstevel@tonic-gate if (bam_lock_fd < 0) { 10437c478bd9Sstevel@tonic-gate return; 10447c478bd9Sstevel@tonic-gate } 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate unlock.l_type = F_UNLCK; 10477c478bd9Sstevel@tonic-gate unlock.l_whence = SEEK_SET; 10487c478bd9Sstevel@tonic-gate unlock.l_start = 0; 10497c478bd9Sstevel@tonic-gate unlock.l_len = 0; 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLK, &unlock) == -1) { 10527c478bd9Sstevel@tonic-gate bam_error(UNLOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate if (close(bam_lock_fd) == -1) { 10567c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, BAM_LOCK_FILE, strerror(errno)); 10577c478bd9Sstevel@tonic-gate } 10587c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 10597c478bd9Sstevel@tonic-gate } 10607c478bd9Sstevel@tonic-gate 10617c478bd9Sstevel@tonic-gate static error_t 10627c478bd9Sstevel@tonic-gate list_archive(char *root, char *opt) 10637c478bd9Sstevel@tonic-gate { 10647c478bd9Sstevel@tonic-gate filelist_t flist; 10657c478bd9Sstevel@tonic-gate filelist_t *flistp = &flist; 10667c478bd9Sstevel@tonic-gate line_t *lp; 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate assert(root); 10697c478bd9Sstevel@tonic-gate assert(opt == NULL); 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 10727c478bd9Sstevel@tonic-gate if (read_list(root, flistp) != BAM_SUCCESS) { 10737c478bd9Sstevel@tonic-gate return (BAM_ERROR); 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate assert(flistp->head && flistp->tail); 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate for (lp = flistp->head; lp; lp = lp->next) { 10787c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate filelist_free(flistp); 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* 10877c478bd9Sstevel@tonic-gate * This routine writes a list of lines to a file. 10887c478bd9Sstevel@tonic-gate * The list is *not* freed 10897c478bd9Sstevel@tonic-gate */ 10907c478bd9Sstevel@tonic-gate static error_t 10917c478bd9Sstevel@tonic-gate list2file(char *root, char *tmp, char *final, line_t *start) 10927c478bd9Sstevel@tonic-gate { 1093eb2bd662Svikram char tmpfile[PATH_MAX]; 1094eb2bd662Svikram char path[PATH_MAX]; 1095eb2bd662Svikram FILE *fp; 1096eb2bd662Svikram int ret; 1097eb2bd662Svikram struct stat sb; 1098eb2bd662Svikram mode_t mode; 1099eb2bd662Svikram uid_t root_uid; 1100eb2bd662Svikram gid_t sys_gid; 1101eb2bd662Svikram struct passwd *pw; 1102eb2bd662Svikram struct group *gp; 1103eb2bd662Svikram const char *fcn = "list2file()"; 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, final); 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate if (start == NULL) { 1108eb2bd662Svikram /* Empty GRUB menu */ 11097c478bd9Sstevel@tonic-gate if (stat(path, &sb) != -1) { 11107c478bd9Sstevel@tonic-gate bam_print(UNLINK_EMPTY, path); 11117c478bd9Sstevel@tonic-gate if (unlink(path) != 0) { 11127c478bd9Sstevel@tonic-gate bam_error(UNLINK_FAIL, path, strerror(errno)); 11137c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11147c478bd9Sstevel@tonic-gate } else { 11157c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 11167c478bd9Sstevel@tonic-gate } 11177c478bd9Sstevel@tonic-gate } 1118eb2bd662Svikram return (BAM_SUCCESS); 11197c478bd9Sstevel@tonic-gate } 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate /* 11227c478bd9Sstevel@tonic-gate * Preserve attributes of existing file if possible, 11237c478bd9Sstevel@tonic-gate * otherwise ask the system for uid/gid of root/sys. 11247c478bd9Sstevel@tonic-gate * If all fails, fall back on hard-coded defaults. 11257c478bd9Sstevel@tonic-gate */ 11267c478bd9Sstevel@tonic-gate if (stat(path, &sb) != -1) { 11277c478bd9Sstevel@tonic-gate mode = sb.st_mode; 11287c478bd9Sstevel@tonic-gate root_uid = sb.st_uid; 11297c478bd9Sstevel@tonic-gate sys_gid = sb.st_gid; 11307c478bd9Sstevel@tonic-gate } else { 11317c478bd9Sstevel@tonic-gate mode = DEFAULT_DEV_MODE; 11327c478bd9Sstevel@tonic-gate if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) { 11337c478bd9Sstevel@tonic-gate root_uid = pw->pw_uid; 11347c478bd9Sstevel@tonic-gate } else { 1135eb2bd662Svikram bam_error(CANT_FIND_USER, 1136eb2bd662Svikram DEFAULT_DEV_USER, DEFAULT_DEV_UID); 11377c478bd9Sstevel@tonic-gate root_uid = (uid_t)DEFAULT_DEV_UID; 11387c478bd9Sstevel@tonic-gate } 11397c478bd9Sstevel@tonic-gate if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) { 11407c478bd9Sstevel@tonic-gate sys_gid = gp->gr_gid; 11417c478bd9Sstevel@tonic-gate } else { 1142eb2bd662Svikram bam_error(CANT_FIND_GROUP, 1143eb2bd662Svikram DEFAULT_DEV_GROUP, DEFAULT_DEV_GID); 11447c478bd9Sstevel@tonic-gate sys_gid = (gid_t)DEFAULT_DEV_GID; 11457c478bd9Sstevel@tonic-gate } 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate (void) snprintf(tmpfile, sizeof (tmpfile), "%s%s", root, tmp); 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate /* Truncate tmpfile first */ 11517c478bd9Sstevel@tonic-gate fp = fopen(tmpfile, "w"); 11527c478bd9Sstevel@tonic-gate if (fp == NULL) { 11537c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, tmpfile, strerror(errno)); 11547c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11557c478bd9Sstevel@tonic-gate } 1156eb2bd662Svikram if (fclose(fp) == EOF) { 11577c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, tmpfile, strerror(errno)); 11587c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* Now open it in append mode */ 11627c478bd9Sstevel@tonic-gate fp = fopen(tmpfile, "a"); 11637c478bd9Sstevel@tonic-gate if (fp == NULL) { 11647c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, tmpfile, strerror(errno)); 11657c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate for (; start; start = start->next) { 1169eb2bd662Svikram if (s_fputs(start->line, fp) == EOF) { 11707c478bd9Sstevel@tonic-gate bam_error(WRITE_FAIL, tmpfile, strerror(errno)); 11717c478bd9Sstevel@tonic-gate (void) fclose(fp); 11727c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11737c478bd9Sstevel@tonic-gate } 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 1176eb2bd662Svikram if (fclose(fp) == EOF) { 11777c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, tmpfile, strerror(errno)); 11787c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11797c478bd9Sstevel@tonic-gate } 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate /* 1182de531be4Sjg * Set up desired attributes. Ignore failures on filesystems 1183de531be4Sjg * not supporting these operations - pcfs reports unsupported 1184de531be4Sjg * operations as EINVAL. 11857c478bd9Sstevel@tonic-gate */ 11867c478bd9Sstevel@tonic-gate ret = chmod(tmpfile, mode); 1187de531be4Sjg if (ret == -1 && 1188de531be4Sjg errno != EINVAL && errno != ENOTSUP) { 11897c478bd9Sstevel@tonic-gate bam_error(CHMOD_FAIL, tmpfile, strerror(errno)); 11907c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate ret = chown(tmpfile, root_uid, sys_gid); 1194de531be4Sjg if (ret == -1 && 1195de531be4Sjg errno != EINVAL && errno != ENOTSUP) { 11967c478bd9Sstevel@tonic-gate bam_error(CHOWN_FAIL, tmpfile, strerror(errno)); 11977c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate /* 12027c478bd9Sstevel@tonic-gate * Do an atomic rename 12037c478bd9Sstevel@tonic-gate */ 12047c478bd9Sstevel@tonic-gate ret = rename(tmpfile, path); 12057c478bd9Sstevel@tonic-gate if (ret != 0) { 12067c478bd9Sstevel@tonic-gate bam_error(RENAME_FAIL, path, strerror(errno)); 12077c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate 1210eb2bd662Svikram BAM_DPRINTF((D_WROTE_FILE, fcn, path)); 12117c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 12127c478bd9Sstevel@tonic-gate } 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * This function should always return 0 - since we want 12167c478bd9Sstevel@tonic-gate * to create stat data for *all* files in the list. 12177c478bd9Sstevel@tonic-gate */ 12187c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12197c478bd9Sstevel@tonic-gate static int 12207c478bd9Sstevel@tonic-gate cmpstat( 12217c478bd9Sstevel@tonic-gate const char *file, 12227c478bd9Sstevel@tonic-gate const struct stat *stat, 12237c478bd9Sstevel@tonic-gate int flags, 12247c478bd9Sstevel@tonic-gate struct FTW *ftw) 12257c478bd9Sstevel@tonic-gate { 12267c478bd9Sstevel@tonic-gate uint_t sz; 12277c478bd9Sstevel@tonic-gate uint64_t *value; 12287c478bd9Sstevel@tonic-gate uint64_t filestat[2]; 12297c478bd9Sstevel@tonic-gate int error; 12307c478bd9Sstevel@tonic-gate 123158091fd8Ssetje struct safefile *safefilep; 123258091fd8Ssetje FILE *fp; 123358091fd8Ssetje 12347c478bd9Sstevel@tonic-gate /* 12357c478bd9Sstevel@tonic-gate * We only want regular files 12367c478bd9Sstevel@tonic-gate */ 12377c478bd9Sstevel@tonic-gate if (!S_ISREG(stat->st_mode)) 12387c478bd9Sstevel@tonic-gate return (0); 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate /* 12417c478bd9Sstevel@tonic-gate * new_nvlp may be NULL if there were errors earlier 12427c478bd9Sstevel@tonic-gate * but this is not fatal to update determination. 12437c478bd9Sstevel@tonic-gate */ 12447c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp) { 12457c478bd9Sstevel@tonic-gate filestat[0] = stat->st_size; 12467c478bd9Sstevel@tonic-gate filestat[1] = stat->st_mtime; 12477c478bd9Sstevel@tonic-gate error = nvlist_add_uint64_array(walk_arg.new_nvlp, 12487c478bd9Sstevel@tonic-gate file + bam_rootlen, filestat, 2); 12497c478bd9Sstevel@tonic-gate if (error) 12507c478bd9Sstevel@tonic-gate bam_error(NVADD_FAIL, file, strerror(error)); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate /* 12547c478bd9Sstevel@tonic-gate * The remaining steps are only required if we haven't made a 12557c478bd9Sstevel@tonic-gate * decision about update or if we are checking (-n) 12567c478bd9Sstevel@tonic-gate */ 12577c478bd9Sstevel@tonic-gate if (walk_arg.need_update && !bam_check) 12587c478bd9Sstevel@tonic-gate return (0); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate /* 1261d876c67dSjg * If we are invoked as part of system/filesystem/boot-archive, then 126258091fd8Ssetje * there are a number of things we should not worry about 12637c478bd9Sstevel@tonic-gate */ 126458091fd8Ssetje if (bam_smf_check) { 126558091fd8Ssetje /* ignore amd64 modules unless we are booted amd64. */ 126658091fd8Ssetje if (!is_amd64() && strstr(file, "/amd64/") != 0) 126758091fd8Ssetje return (0); 126858091fd8Ssetje 126958091fd8Ssetje /* read in list of safe files */ 127058091fd8Ssetje if (safefiles == NULL) 127158091fd8Ssetje if (fp = fopen("/boot/solaris/filelist.safe", "r")) { 127258091fd8Ssetje safefiles = s_calloc(1, 127358091fd8Ssetje sizeof (struct safefile)); 127458091fd8Ssetje safefilep = safefiles; 127558091fd8Ssetje safefilep->name = s_calloc(1, MAXPATHLEN + 127658091fd8Ssetje MAXNAMELEN); 127758091fd8Ssetje safefilep->next = NULL; 127858091fd8Ssetje while (s_fgets(safefilep->name, MAXPATHLEN + 127958091fd8Ssetje MAXNAMELEN, fp) != NULL) { 128058091fd8Ssetje safefilep->next = s_calloc(1, 128158091fd8Ssetje sizeof (struct safefile)); 128258091fd8Ssetje safefilep = safefilep->next; 128358091fd8Ssetje safefilep->name = s_calloc(1, 128458091fd8Ssetje MAXPATHLEN + MAXNAMELEN); 128558091fd8Ssetje safefilep->next = NULL; 128658091fd8Ssetje } 128758091fd8Ssetje (void) fclose(fp); 128858091fd8Ssetje } 128958091fd8Ssetje } 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate /* 12927c478bd9Sstevel@tonic-gate * We need an update if file doesn't exist in old archive 12937c478bd9Sstevel@tonic-gate */ 12947c478bd9Sstevel@tonic-gate if (walk_arg.old_nvlp == NULL || 12957c478bd9Sstevel@tonic-gate nvlist_lookup_uint64_array(walk_arg.old_nvlp, 12967c478bd9Sstevel@tonic-gate file + bam_rootlen, &value, &sz) != 0) { 12977c478bd9Sstevel@tonic-gate if (bam_smf_check) /* ignore new during smf check */ 12987c478bd9Sstevel@tonic-gate return (0); 12997c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 13007c478bd9Sstevel@tonic-gate if (bam_verbose) 13017c478bd9Sstevel@tonic-gate bam_print(PARSEABLE_NEW_FILE, file); 13027c478bd9Sstevel@tonic-gate return (0); 13037c478bd9Sstevel@tonic-gate } 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate /* 13067c478bd9Sstevel@tonic-gate * File exists in old archive. Check if file has changed 13077c478bd9Sstevel@tonic-gate */ 13087c478bd9Sstevel@tonic-gate assert(sz == 2); 13097c478bd9Sstevel@tonic-gate bcopy(value, filestat, sizeof (filestat)); 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate if (filestat[0] != stat->st_size || 13127c478bd9Sstevel@tonic-gate filestat[1] != stat->st_mtime) { 13137c609327Ssetje if (bam_smf_check) { 13147c609327Ssetje safefilep = safefiles; 13157c609327Ssetje while (safefilep != NULL) { 13167c609327Ssetje if (strcmp(file + bam_rootlen, 13177c609327Ssetje safefilep->name) == 0) { 13187c609327Ssetje (void) creat(NEED_UPDATE_FILE, 0644); 13197c609327Ssetje return (0); 13207c609327Ssetje } 13217c609327Ssetje safefilep = safefilep->next; 13227c609327Ssetje } 13237c609327Ssetje } 13247c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 13257c478bd9Sstevel@tonic-gate if (bam_verbose) 13267c478bd9Sstevel@tonic-gate if (bam_smf_check) 13277c478bd9Sstevel@tonic-gate bam_print(" %s\n", file); 13287c478bd9Sstevel@tonic-gate else 13297c478bd9Sstevel@tonic-gate bam_print(PARSEABLE_OUT_DATE, file); 13307c478bd9Sstevel@tonic-gate } 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate return (0); 13337c478bd9Sstevel@tonic-gate } 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate /* 13367c478bd9Sstevel@tonic-gate * Check flags and presence of required files. 13377c478bd9Sstevel@tonic-gate * The force flag and/or absence of files should 13387c478bd9Sstevel@tonic-gate * trigger an update. 13397c478bd9Sstevel@tonic-gate * Suppress stdout output if check (-n) option is set 13407c478bd9Sstevel@tonic-gate * (as -n should only produce parseable output.) 13417c478bd9Sstevel@tonic-gate */ 13427c478bd9Sstevel@tonic-gate static void 13437c478bd9Sstevel@tonic-gate check_flags_and_files(char *root) 13447c478bd9Sstevel@tonic-gate { 13457c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 13467c478bd9Sstevel@tonic-gate struct stat sb; 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate /* 13497c478bd9Sstevel@tonic-gate * if force, create archive unconditionally 13507c478bd9Sstevel@tonic-gate */ 13517c478bd9Sstevel@tonic-gate if (bam_force) { 13527c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 13537c478bd9Sstevel@tonic-gate if (bam_verbose && !bam_check) 13547c478bd9Sstevel@tonic-gate bam_print(UPDATE_FORCE); 13557c478bd9Sstevel@tonic-gate return; 13567c478bd9Sstevel@tonic-gate } 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate /* 13597c478bd9Sstevel@tonic-gate * If archive is missing, create archive 13607c478bd9Sstevel@tonic-gate */ 1361*79755401Ssetje if (is_sparc()) { 1362*79755401Ssetje (void) snprintf(path, sizeof (path), "%s%s%s%s", root, 1363*79755401Ssetje ARCHIVE_PREFIX, get_machine(), ARCHIVE_SUFFIX); 1364d876c67dSjg } else { 1365986fd29aSsetje if (bam_direct == BAM_DIRECT_DBOOT) { 1366986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1367986fd29aSsetje DIRECT_BOOT_ARCHIVE_64); 1368986fd29aSsetje if (stat(path, &sb) != 0) { 1369986fd29aSsetje if (bam_verbose && !bam_check) 1370986fd29aSsetje bam_print(UPDATE_ARCH_MISS, path); 1371986fd29aSsetje walk_arg.need_update = 1; 1372986fd29aSsetje return; 1373986fd29aSsetje } 1374986fd29aSsetje } 1375986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1376986fd29aSsetje DIRECT_BOOT_ARCHIVE_32); 1377986fd29aSsetje } 1378986fd29aSsetje 13797c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) { 13807c478bd9Sstevel@tonic-gate if (bam_verbose && !bam_check) 13817c478bd9Sstevel@tonic-gate bam_print(UPDATE_ARCH_MISS, path); 13827c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 13837c478bd9Sstevel@tonic-gate return; 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate static error_t 13887c478bd9Sstevel@tonic-gate read_one_list(char *root, filelist_t *flistp, char *filelist) 13897c478bd9Sstevel@tonic-gate { 13907c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 13917c478bd9Sstevel@tonic-gate FILE *fp; 13927c478bd9Sstevel@tonic-gate char buf[BAM_MAXLINE]; 1393eb2bd662Svikram const char *fcn = "read_one_list()"; 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, filelist); 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate fp = fopen(path, "r"); 13987c478bd9Sstevel@tonic-gate if (fp == NULL) { 1399eb2bd662Svikram BAM_DPRINTF((D_FLIST_FAIL, fcn, path, strerror(errno))); 14007c478bd9Sstevel@tonic-gate return (BAM_ERROR); 14017c478bd9Sstevel@tonic-gate } 14027c478bd9Sstevel@tonic-gate while (s_fgets(buf, sizeof (buf), fp) != NULL) { 1403b610f78eSvikram /* skip blank lines */ 1404b610f78eSvikram if (strspn(buf, " \t") == strlen(buf)) 1405b610f78eSvikram continue; 14067c478bd9Sstevel@tonic-gate append_to_flist(flistp, buf); 14077c478bd9Sstevel@tonic-gate } 14087c478bd9Sstevel@tonic-gate if (fclose(fp) != 0) { 14097c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, path, strerror(errno)); 14107c478bd9Sstevel@tonic-gate return (BAM_ERROR); 14117c478bd9Sstevel@tonic-gate } 14127c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 14137c478bd9Sstevel@tonic-gate } 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate static error_t 14167c478bd9Sstevel@tonic-gate read_list(char *root, filelist_t *flistp) 14177c478bd9Sstevel@tonic-gate { 1418986fd29aSsetje char path[PATH_MAX]; 1419986fd29aSsetje char cmd[PATH_MAX]; 1420986fd29aSsetje struct stat sb; 1421986fd29aSsetje int n, rval; 1422eb2bd662Svikram const char *fcn = "read_list()"; 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate /* 1427986fd29aSsetje * build and check path to extract_boot_filelist.ksh 14287c478bd9Sstevel@tonic-gate */ 1429986fd29aSsetje n = snprintf(path, sizeof (path), "%s%s", root, EXTRACT_BOOT_FILELIST); 1430986fd29aSsetje if (n >= sizeof (path)) { 1431986fd29aSsetje bam_error(NO_FLIST); 1432986fd29aSsetje return (BAM_ERROR); 1433986fd29aSsetje } 1434986fd29aSsetje 1435986fd29aSsetje /* 1436986fd29aSsetje * If extract_boot_filelist is present, exec it, otherwise read 1437986fd29aSsetje * the filelists directly, for compatibility with older images. 1438986fd29aSsetje */ 1439986fd29aSsetje if (stat(path, &sb) == 0) { 1440986fd29aSsetje /* 1441986fd29aSsetje * build arguments to exec extract_boot_filelist.ksh 1442986fd29aSsetje */ 1443d876c67dSjg char *rootarg, *platarg; 1444d876c67dSjg int platarglen = 1, rootarglen = 1; 1445d876c67dSjg if (strlen(root) > 1) 1446d876c67dSjg rootarglen += strlen(root) + strlen("-R "); 1447d876c67dSjg if (bam_alt_platform) 1448d876c67dSjg platarglen += strlen(bam_platform) + strlen("-p "); 1449d876c67dSjg platarg = s_calloc(1, platarglen); 1450d876c67dSjg rootarg = s_calloc(1, rootarglen); 1451d876c67dSjg *platarg = 0; 1452d876c67dSjg *rootarg = 0; 1453d876c67dSjg 1454986fd29aSsetje if (strlen(root) > 1) { 1455d876c67dSjg (void) snprintf(rootarg, rootarglen, 1456d876c67dSjg "-R %s", root); 1457986fd29aSsetje } 1458d876c67dSjg if (bam_alt_platform) { 1459d876c67dSjg (void) snprintf(platarg, platarglen, 1460d876c67dSjg "-p %s", bam_platform); 1461d876c67dSjg } 1462d876c67dSjg n = snprintf(cmd, sizeof (cmd), "%s %s %s /%s /%s", 1463d876c67dSjg path, rootarg, platarg, BOOT_FILE_LIST, ETC_FILE_LIST); 1464d876c67dSjg free(platarg); 1465d876c67dSjg free(rootarg); 1466986fd29aSsetje if (n >= sizeof (cmd)) { 1467986fd29aSsetje bam_error(NO_FLIST); 1468986fd29aSsetje return (BAM_ERROR); 1469986fd29aSsetje } 1470986fd29aSsetje if (exec_cmd(cmd, flistp) != 0) { 1471eb2bd662Svikram BAM_DPRINTF((D_FLIST_FAIL, fcn, path, strerror(errno))); 1472986fd29aSsetje return (BAM_ERROR); 1473986fd29aSsetje } 1474986fd29aSsetje } else { 1475986fd29aSsetje /* 1476986fd29aSsetje * Read current lists of files - only the first is mandatory 1477986fd29aSsetje */ 1478986fd29aSsetje rval = read_one_list(root, flistp, BOOT_FILE_LIST); 1479986fd29aSsetje if (rval != BAM_SUCCESS) 1480986fd29aSsetje return (rval); 1481986fd29aSsetje (void) read_one_list(root, flistp, ETC_FILE_LIST); 1482986fd29aSsetje } 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate if (flistp->head == NULL) { 14857c478bd9Sstevel@tonic-gate bam_error(NO_FLIST); 14867c478bd9Sstevel@tonic-gate return (BAM_ERROR); 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 14907c478bd9Sstevel@tonic-gate } 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate static void 14937c478bd9Sstevel@tonic-gate getoldstat(char *root) 14947c478bd9Sstevel@tonic-gate { 14957c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 14967c478bd9Sstevel@tonic-gate int fd, error; 14977c478bd9Sstevel@tonic-gate struct stat sb; 14987c478bd9Sstevel@tonic-gate char *ostat; 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 15017c478bd9Sstevel@tonic-gate fd = open(path, O_RDONLY); 15027c478bd9Sstevel@tonic-gate if (fd == -1) { 15037c478bd9Sstevel@tonic-gate if (bam_verbose) 15047c478bd9Sstevel@tonic-gate bam_print(OPEN_FAIL, path, strerror(errno)); 15057c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 15067c478bd9Sstevel@tonic-gate return; 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate if (fstat(fd, &sb) != 0) { 15107c478bd9Sstevel@tonic-gate bam_error(STAT_FAIL, path, strerror(errno)); 15117c478bd9Sstevel@tonic-gate (void) close(fd); 15127c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 15137c478bd9Sstevel@tonic-gate return; 15147c478bd9Sstevel@tonic-gate } 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate ostat = s_calloc(1, sb.st_size); 15177c478bd9Sstevel@tonic-gate 15187c478bd9Sstevel@tonic-gate if (read(fd, ostat, sb.st_size) != sb.st_size) { 15197c478bd9Sstevel@tonic-gate bam_error(READ_FAIL, path, strerror(errno)); 15207c478bd9Sstevel@tonic-gate (void) close(fd); 15217c478bd9Sstevel@tonic-gate free(ostat); 15227c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 15237c478bd9Sstevel@tonic-gate return; 15247c478bd9Sstevel@tonic-gate } 15257c478bd9Sstevel@tonic-gate 15267c478bd9Sstevel@tonic-gate (void) close(fd); 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 15297c478bd9Sstevel@tonic-gate error = nvlist_unpack(ostat, sb.st_size, &walk_arg.old_nvlp, 0); 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate free(ostat); 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate if (error) { 15347c478bd9Sstevel@tonic-gate bam_error(UNPACK_FAIL, path, strerror(error)); 15357c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 15367c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 15377c478bd9Sstevel@tonic-gate return; 15387c478bd9Sstevel@tonic-gate } 15397c478bd9Sstevel@tonic-gate } 15407c478bd9Sstevel@tonic-gate 1541a28d77b8Svikram /* 1542a28d77b8Svikram * Checks if a file in the current (old) archive has 1543a28d77b8Svikram * been deleted from the root filesystem. This is needed for 1544a28d77b8Svikram * software like Trusted Extensions (TX) that switch early 1545a28d77b8Svikram * in boot based on presence/absence of a kernel module. 1546a28d77b8Svikram */ 1547a28d77b8Svikram static void 1548a28d77b8Svikram check4stale(char *root) 1549a28d77b8Svikram { 1550a28d77b8Svikram nvpair_t *nvp; 1551a28d77b8Svikram nvlist_t *nvlp; 1552a28d77b8Svikram char *file; 1553a28d77b8Svikram char path[PATH_MAX]; 1554a28d77b8Svikram struct stat sb; 1555a28d77b8Svikram 1556a28d77b8Svikram /* 1557a28d77b8Svikram * Skip stale file check during smf check 1558a28d77b8Svikram */ 1559a28d77b8Svikram if (bam_smf_check) 1560a28d77b8Svikram return; 1561a28d77b8Svikram 1562a28d77b8Svikram /* Nothing to do if no old stats */ 1563a28d77b8Svikram if ((nvlp = walk_arg.old_nvlp) == NULL) 1564a28d77b8Svikram return; 1565a28d77b8Svikram 1566a28d77b8Svikram for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp; 1567a28d77b8Svikram nvp = nvlist_next_nvpair(nvlp, nvp)) { 1568a28d77b8Svikram file = nvpair_name(nvp); 1569a28d77b8Svikram if (file == NULL) 1570a28d77b8Svikram continue; 1571a28d77b8Svikram (void) snprintf(path, sizeof (path), "%s/%s", 1572a28d77b8Svikram root, file); 1573a28d77b8Svikram if (stat(path, &sb) == -1) { 1574a28d77b8Svikram walk_arg.need_update = 1; 1575a28d77b8Svikram if (bam_verbose) 1576a28d77b8Svikram bam_print(PARSEABLE_STALE_FILE, path); 1577a28d77b8Svikram } 1578a28d77b8Svikram } 1579a28d77b8Svikram } 1580a28d77b8Svikram 15817c478bd9Sstevel@tonic-gate static void 15827c478bd9Sstevel@tonic-gate create_newstat(void) 15837c478bd9Sstevel@tonic-gate { 15847c478bd9Sstevel@tonic-gate int error; 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate error = nvlist_alloc(&walk_arg.new_nvlp, NV_UNIQUE_NAME, 0); 15877c478bd9Sstevel@tonic-gate if (error) { 15887c478bd9Sstevel@tonic-gate /* 15897c478bd9Sstevel@tonic-gate * Not fatal - we can still create archive 15907c478bd9Sstevel@tonic-gate */ 15917c478bd9Sstevel@tonic-gate walk_arg.new_nvlp = NULL; 15927c478bd9Sstevel@tonic-gate bam_error(NVALLOC_FAIL, strerror(error)); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate 15967c478bd9Sstevel@tonic-gate static void 15977c478bd9Sstevel@tonic-gate walk_list(char *root, filelist_t *flistp) 15987c478bd9Sstevel@tonic-gate { 15997c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 16007c478bd9Sstevel@tonic-gate line_t *lp; 16017c478bd9Sstevel@tonic-gate 16027c478bd9Sstevel@tonic-gate for (lp = flistp->head; lp; lp = lp->next) { 1603986fd29aSsetje /* 1604986fd29aSsetje * Don't follow symlinks. A symlink must refer to 1605986fd29aSsetje * a file that would appear in the archive through 1606986fd29aSsetje * a direct reference. This matches the archive 1607986fd29aSsetje * construction behavior. 1608986fd29aSsetje */ 16097c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, lp->line); 1610986fd29aSsetje if (nftw(path, cmpstat, 20, FTW_PHYS) == -1) { 16117c478bd9Sstevel@tonic-gate /* 16127c478bd9Sstevel@tonic-gate * Some files may not exist. 16137c478bd9Sstevel@tonic-gate * For example: etc/rtc_config on a x86 diskless system 16147c478bd9Sstevel@tonic-gate * Emit verbose message only 16157c478bd9Sstevel@tonic-gate */ 16167c478bd9Sstevel@tonic-gate if (bam_verbose) 16177c478bd9Sstevel@tonic-gate bam_print(NFTW_FAIL, path, strerror(errno)); 16187c478bd9Sstevel@tonic-gate } 16197c478bd9Sstevel@tonic-gate } 16207c478bd9Sstevel@tonic-gate } 16217c478bd9Sstevel@tonic-gate 16227c478bd9Sstevel@tonic-gate static void 16237c478bd9Sstevel@tonic-gate savenew(char *root) 16247c478bd9Sstevel@tonic-gate { 16257c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 16267c478bd9Sstevel@tonic-gate char path2[PATH_MAX]; 16277c478bd9Sstevel@tonic-gate size_t sz; 16287c478bd9Sstevel@tonic-gate char *nstat; 16297c478bd9Sstevel@tonic-gate int fd, wrote, error; 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate nstat = NULL; 16327c478bd9Sstevel@tonic-gate sz = 0; 16337c478bd9Sstevel@tonic-gate error = nvlist_pack(walk_arg.new_nvlp, &nstat, &sz, 16347c478bd9Sstevel@tonic-gate NV_ENCODE_XDR, 0); 16357c478bd9Sstevel@tonic-gate if (error) { 16367c478bd9Sstevel@tonic-gate bam_error(PACK_FAIL, strerror(error)); 16377c478bd9Sstevel@tonic-gate return; 16387c478bd9Sstevel@tonic-gate } 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT_TMP); 16417c478bd9Sstevel@tonic-gate fd = open(path, O_RDWR|O_CREAT|O_TRUNC, FILE_STAT_MODE); 16427c478bd9Sstevel@tonic-gate if (fd == -1) { 16437c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, path, strerror(errno)); 16447c478bd9Sstevel@tonic-gate free(nstat); 16457c478bd9Sstevel@tonic-gate return; 16467c478bd9Sstevel@tonic-gate } 16477c478bd9Sstevel@tonic-gate wrote = write(fd, nstat, sz); 16487c478bd9Sstevel@tonic-gate if (wrote != sz) { 16497c478bd9Sstevel@tonic-gate bam_error(WRITE_FAIL, path, strerror(errno)); 16507c478bd9Sstevel@tonic-gate (void) close(fd); 16517c478bd9Sstevel@tonic-gate free(nstat); 16527c478bd9Sstevel@tonic-gate return; 16537c478bd9Sstevel@tonic-gate } 16547c478bd9Sstevel@tonic-gate (void) close(fd); 16557c478bd9Sstevel@tonic-gate free(nstat); 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate (void) snprintf(path2, sizeof (path2), "%s%s", root, FILE_STAT); 16587c478bd9Sstevel@tonic-gate if (rename(path, path2) != 0) { 16597c478bd9Sstevel@tonic-gate bam_error(RENAME_FAIL, path2, strerror(errno)); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate } 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate static void 16647c478bd9Sstevel@tonic-gate clear_walk_args(void) 16657c478bd9Sstevel@tonic-gate { 16667c478bd9Sstevel@tonic-gate if (walk_arg.old_nvlp) 16677c478bd9Sstevel@tonic-gate nvlist_free(walk_arg.old_nvlp); 16687c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp) 16697c478bd9Sstevel@tonic-gate nvlist_free(walk_arg.new_nvlp); 16707c478bd9Sstevel@tonic-gate walk_arg.need_update = 0; 16717c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 16727c478bd9Sstevel@tonic-gate walk_arg.new_nvlp = NULL; 16737c478bd9Sstevel@tonic-gate } 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate /* 16767c478bd9Sstevel@tonic-gate * Returns: 16777c478bd9Sstevel@tonic-gate * 0 - no update necessary 16787c478bd9Sstevel@tonic-gate * 1 - update required. 16797c478bd9Sstevel@tonic-gate * BAM_ERROR (-1) - An error occurred 16807c478bd9Sstevel@tonic-gate * 16817c478bd9Sstevel@tonic-gate * Special handling for check (-n): 16827c478bd9Sstevel@tonic-gate * ================================ 16837c478bd9Sstevel@tonic-gate * The check (-n) option produces parseable output. 16847c478bd9Sstevel@tonic-gate * To do this, we suppress all stdout messages unrelated 16857c478bd9Sstevel@tonic-gate * to out of sync files. 16867c478bd9Sstevel@tonic-gate * All stderr messages are still printed though. 16877c478bd9Sstevel@tonic-gate * 16887c478bd9Sstevel@tonic-gate */ 16897c478bd9Sstevel@tonic-gate static int 16907c478bd9Sstevel@tonic-gate update_required(char *root) 16917c478bd9Sstevel@tonic-gate { 16927c478bd9Sstevel@tonic-gate struct stat sb; 16937c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 16947c478bd9Sstevel@tonic-gate filelist_t flist; 16957c478bd9Sstevel@tonic-gate filelist_t *flistp = &flist; 16967c478bd9Sstevel@tonic-gate int need_update; 16977c478bd9Sstevel@tonic-gate 16987c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 16997c478bd9Sstevel@tonic-gate 17007c478bd9Sstevel@tonic-gate walk_arg.need_update = 0; 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate /* 17037c478bd9Sstevel@tonic-gate * Without consulting stat data, check if we need update 17047c478bd9Sstevel@tonic-gate */ 17057c478bd9Sstevel@tonic-gate check_flags_and_files(root); 17067c478bd9Sstevel@tonic-gate 17077c478bd9Sstevel@tonic-gate /* 17087c478bd9Sstevel@tonic-gate * In certain deployment scenarios, filestat may not 17097c478bd9Sstevel@tonic-gate * exist. Ignore it during boot-archive SMF check. 17107c478bd9Sstevel@tonic-gate */ 17117c478bd9Sstevel@tonic-gate if (bam_smf_check) { 17127c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 17137c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) 17147c478bd9Sstevel@tonic-gate return (0); 17157c478bd9Sstevel@tonic-gate } 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate /* 17187c478bd9Sstevel@tonic-gate * consult stat data only if we haven't made a decision 17197c478bd9Sstevel@tonic-gate * about update. If checking (-n) however, we always 17207c478bd9Sstevel@tonic-gate * need stat data (since we want to compare old and new) 17217c478bd9Sstevel@tonic-gate */ 17227c478bd9Sstevel@tonic-gate if (!walk_arg.need_update || bam_check) 17237c478bd9Sstevel@tonic-gate getoldstat(root); 17247c478bd9Sstevel@tonic-gate 1725a28d77b8Svikram /* 1726a28d77b8Svikram * Check if the archive contains files that are no longer 1727a28d77b8Svikram * present on the root filesystem. 1728a28d77b8Svikram */ 1729a28d77b8Svikram if (!walk_arg.need_update || bam_check) 1730a28d77b8Svikram check4stale(root); 1731a28d77b8Svikram 17327c478bd9Sstevel@tonic-gate /* 17337c478bd9Sstevel@tonic-gate * read list of files 17347c478bd9Sstevel@tonic-gate */ 17357c478bd9Sstevel@tonic-gate if (read_list(root, flistp) != BAM_SUCCESS) { 17367c478bd9Sstevel@tonic-gate clear_walk_args(); 17377c478bd9Sstevel@tonic-gate return (BAM_ERROR); 17387c478bd9Sstevel@tonic-gate } 17397c478bd9Sstevel@tonic-gate 17407c478bd9Sstevel@tonic-gate assert(flistp->head && flistp->tail); 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate /* 17437c478bd9Sstevel@tonic-gate * At this point either the update is required 17447c478bd9Sstevel@tonic-gate * or the decision is pending. In either case 17457c478bd9Sstevel@tonic-gate * we need to create new stat nvlist 17467c478bd9Sstevel@tonic-gate */ 17477c478bd9Sstevel@tonic-gate create_newstat(); 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate /* 17507c478bd9Sstevel@tonic-gate * This walk does 2 things: 17517c478bd9Sstevel@tonic-gate * - gets new stat data for every file 17527c478bd9Sstevel@tonic-gate * - (optional) compare old and new stat data 17537c478bd9Sstevel@tonic-gate */ 17547c478bd9Sstevel@tonic-gate walk_list(root, &flist); 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate /* done with the file list */ 17577c478bd9Sstevel@tonic-gate filelist_free(flistp); 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate /* 17607c478bd9Sstevel@tonic-gate * if we didn't succeed in creating new stat data above 17617c478bd9Sstevel@tonic-gate * just return result of update check so that archive is built. 17627c478bd9Sstevel@tonic-gate */ 17637c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp == NULL) { 17647c478bd9Sstevel@tonic-gate bam_error(NO_NEW_STAT); 17657c478bd9Sstevel@tonic-gate need_update = walk_arg.need_update; 17667c478bd9Sstevel@tonic-gate clear_walk_args(); 17677c478bd9Sstevel@tonic-gate return (need_update ? 1 : 0); 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate /* 17727c478bd9Sstevel@tonic-gate * If no update required, discard newstat 17737c478bd9Sstevel@tonic-gate */ 17747c478bd9Sstevel@tonic-gate if (!walk_arg.need_update) { 17757c478bd9Sstevel@tonic-gate clear_walk_args(); 17767c478bd9Sstevel@tonic-gate return (0); 17777c478bd9Sstevel@tonic-gate } 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate return (1); 17807c478bd9Sstevel@tonic-gate } 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate static error_t 17837c478bd9Sstevel@tonic-gate create_ramdisk(char *root) 17847c478bd9Sstevel@tonic-gate { 17857c478bd9Sstevel@tonic-gate char *cmdline, path[PATH_MAX]; 17867c478bd9Sstevel@tonic-gate size_t len; 17877c478bd9Sstevel@tonic-gate struct stat sb; 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate /* 17907c478bd9Sstevel@tonic-gate * Setup command args for create_ramdisk.ksh 17917c478bd9Sstevel@tonic-gate */ 1792986fd29aSsetje (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 17937c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) { 17947c478bd9Sstevel@tonic-gate bam_error(ARCH_EXEC_MISS, path, strerror(errno)); 17957c478bd9Sstevel@tonic-gate return (BAM_ERROR); 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate len = strlen(path) + strlen(root) + 10; /* room for space + -R */ 1799d876c67dSjg if (bam_alt_platform) 1800d876c67dSjg len += strlen(bam_platform) + strlen("-p "); 18017c478bd9Sstevel@tonic-gate cmdline = s_calloc(1, len); 18027c478bd9Sstevel@tonic-gate 1803d876c67dSjg if (bam_alt_platform) { 1804d876c67dSjg assert(strlen(root) > 1); 1805d876c67dSjg (void) snprintf(cmdline, len, "%s -p %s -R %s", 1806d876c67dSjg path, bam_platform, root); 1807d876c67dSjg /* chop off / at the end */ 1808d876c67dSjg cmdline[strlen(cmdline) - 1] = '\0'; 1809d876c67dSjg } else if (strlen(root) > 1) { 18107c478bd9Sstevel@tonic-gate (void) snprintf(cmdline, len, "%s -R %s", path, root); 18117c478bd9Sstevel@tonic-gate /* chop off / at the end */ 18127c478bd9Sstevel@tonic-gate cmdline[strlen(cmdline) - 1] = '\0'; 18137c478bd9Sstevel@tonic-gate } else 18147c478bd9Sstevel@tonic-gate (void) snprintf(cmdline, len, "%s", path); 18157c478bd9Sstevel@tonic-gate 1816986fd29aSsetje if (exec_cmd(cmdline, NULL) != 0) { 18177c478bd9Sstevel@tonic-gate bam_error(ARCHIVE_FAIL, cmdline); 18187c478bd9Sstevel@tonic-gate free(cmdline); 18197c478bd9Sstevel@tonic-gate return (BAM_ERROR); 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate free(cmdline); 18227c478bd9Sstevel@tonic-gate 18237c478bd9Sstevel@tonic-gate /* 1824986fd29aSsetje * The existence of the expected archives used to be 1825986fd29aSsetje * verified here. This check is done in create_ramdisk as 1826986fd29aSsetje * it needs to be in sync with the altroot operated upon. 18277c478bd9Sstevel@tonic-gate */ 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate /* 18337c478bd9Sstevel@tonic-gate * Checks if target filesystem is on a ramdisk 18347c478bd9Sstevel@tonic-gate * 1 - is miniroot 18357c478bd9Sstevel@tonic-gate * 0 - is not 18367c478bd9Sstevel@tonic-gate * When in doubt assume it is not a ramdisk. 18377c478bd9Sstevel@tonic-gate */ 18387c478bd9Sstevel@tonic-gate static int 18397c478bd9Sstevel@tonic-gate is_ramdisk(char *root) 18407c478bd9Sstevel@tonic-gate { 18417c478bd9Sstevel@tonic-gate struct extmnttab mnt; 18427c478bd9Sstevel@tonic-gate FILE *fp; 18437c478bd9Sstevel@tonic-gate int found; 1844b610f78eSvikram char mntpt[PATH_MAX]; 1845b610f78eSvikram char *cp; 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate /* 18487c478bd9Sstevel@tonic-gate * There are 3 situations where creating archive is 18497c478bd9Sstevel@tonic-gate * of dubious value: 1850b610f78eSvikram * - create boot_archive on a lofi-mounted boot_archive 18517c478bd9Sstevel@tonic-gate * - create it on a ramdisk which is the root filesystem 18527c478bd9Sstevel@tonic-gate * - create it on a ramdisk mounted somewhere else 18537c478bd9Sstevel@tonic-gate * The first is not easy to detect and checking for it is not 18547c478bd9Sstevel@tonic-gate * worth it. 18557c478bd9Sstevel@tonic-gate * The other two conditions are handled here 18567c478bd9Sstevel@tonic-gate */ 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate fp = fopen(MNTTAB, "r"); 18597c478bd9Sstevel@tonic-gate if (fp == NULL) { 18607c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 18617c478bd9Sstevel@tonic-gate return (0); 18627c478bd9Sstevel@tonic-gate } 18637c478bd9Sstevel@tonic-gate 18647c478bd9Sstevel@tonic-gate resetmnttab(fp); 18657c478bd9Sstevel@tonic-gate 1866b610f78eSvikram /* 1867b610f78eSvikram * Remove any trailing / from the mount point 1868b610f78eSvikram */ 1869b610f78eSvikram (void) strlcpy(mntpt, root, sizeof (mntpt)); 1870b610f78eSvikram if (strcmp(root, "/") != 0) { 1871b610f78eSvikram cp = mntpt + strlen(mntpt) - 1; 1872b610f78eSvikram if (*cp == '/') 1873b610f78eSvikram *cp = '\0'; 1874b610f78eSvikram } 18757c478bd9Sstevel@tonic-gate found = 0; 18767c478bd9Sstevel@tonic-gate while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 1877b610f78eSvikram if (strcmp(mnt.mnt_mountp, mntpt) == 0) { 18787c478bd9Sstevel@tonic-gate found = 1; 18797c478bd9Sstevel@tonic-gate break; 18807c478bd9Sstevel@tonic-gate } 18817c478bd9Sstevel@tonic-gate } 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate if (!found) { 18847c478bd9Sstevel@tonic-gate if (bam_verbose) 1885b610f78eSvikram bam_error(NOT_IN_MNTTAB, mntpt); 18867c478bd9Sstevel@tonic-gate (void) fclose(fp); 18877c478bd9Sstevel@tonic-gate return (0); 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate 18907c478bd9Sstevel@tonic-gate if (strstr(mnt.mnt_special, RAMDISK_SPECIAL) != NULL) { 18917c478bd9Sstevel@tonic-gate if (bam_verbose) 18927c478bd9Sstevel@tonic-gate bam_error(IS_RAMDISK, bam_root); 18937c478bd9Sstevel@tonic-gate (void) fclose(fp); 18947c478bd9Sstevel@tonic-gate return (1); 18957c478bd9Sstevel@tonic-gate } 18967c478bd9Sstevel@tonic-gate 18977c478bd9Sstevel@tonic-gate (void) fclose(fp); 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate return (0); 19007c478bd9Sstevel@tonic-gate } 19017c478bd9Sstevel@tonic-gate 19027c478bd9Sstevel@tonic-gate static int 1903986fd29aSsetje is_boot_archive(char *root) 19047c478bd9Sstevel@tonic-gate { 1905eb2bd662Svikram char path[PATH_MAX]; 1906eb2bd662Svikram struct stat sb; 1907eb2bd662Svikram int error; 1908eb2bd662Svikram const char *fcn = "is_boot_archive()"; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate /* 1911986fd29aSsetje * We can't create an archive without the create_ramdisk script 19127c478bd9Sstevel@tonic-gate */ 1913986fd29aSsetje (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 1914eb2bd662Svikram error = stat(path, &sb); 1915eb2bd662Svikram INJECT_ERROR1("NOT_ARCHIVE_BASED", error = -1); 1916eb2bd662Svikram if (error == -1) { 19177c478bd9Sstevel@tonic-gate if (bam_verbose) 19187c478bd9Sstevel@tonic-gate bam_print(FILE_MISS, path); 1919eb2bd662Svikram BAM_DPRINTF((D_NOT_ARCHIVE_BOOT, fcn, root)); 19207c478bd9Sstevel@tonic-gate return (0); 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 1923eb2bd662Svikram BAM_DPRINTF((D_IS_ARCHIVE_BOOT, fcn, root)); 1924986fd29aSsetje return (1); 1925986fd29aSsetje } 1926986fd29aSsetje 1927986fd29aSsetje /* 1928986fd29aSsetje * Need to call this for anything that operates on the GRUB menu 1929986fd29aSsetje */ 1930986fd29aSsetje int 1931986fd29aSsetje is_grub(const char *root) 1932986fd29aSsetje { 1933986fd29aSsetje char path[PATH_MAX]; 1934986fd29aSsetje struct stat sb; 1935eb2bd662Svikram const char *fcn = "is_grub()"; 1936986fd29aSsetje 19377c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, GRUB_DIR); 19387c478bd9Sstevel@tonic-gate if (stat(path, &sb) == -1) { 1939eb2bd662Svikram BAM_DPRINTF((D_NO_GRUB_DIR, fcn, path)); 19407c478bd9Sstevel@tonic-gate return (0); 19417c478bd9Sstevel@tonic-gate } 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate return (1); 19447c478bd9Sstevel@tonic-gate } 19457c478bd9Sstevel@tonic-gate 19467c478bd9Sstevel@tonic-gate static int 1947eb2bd662Svikram is_zfs(char *root) 19487c478bd9Sstevel@tonic-gate { 1949eb2bd662Svikram struct statvfs vfs; 1950eb2bd662Svikram int ret; 1951eb2bd662Svikram const char *fcn = "is_zfs()"; 19527c478bd9Sstevel@tonic-gate 1953eb2bd662Svikram ret = statvfs(root, &vfs); 1954eb2bd662Svikram INJECT_ERROR1("STATVFS_ZFS", ret = 1); 1955eb2bd662Svikram if (ret != 0) { 1956eb2bd662Svikram bam_error(STATVFS_FAIL, root, strerror(errno)); 19577c478bd9Sstevel@tonic-gate return (0); 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate 1960eb2bd662Svikram if (strncmp(vfs.f_basetype, "zfs", strlen("zfs")) == 0) { 1961eb2bd662Svikram BAM_DPRINTF((D_IS_ZFS, fcn, root)); 19627c478bd9Sstevel@tonic-gate return (1); 1963eb2bd662Svikram } else { 1964eb2bd662Svikram BAM_DPRINTF((D_IS_NOT_ZFS, fcn, root)); 1965eb2bd662Svikram return (0); 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate } 19687c478bd9Sstevel@tonic-gate 1969e7cbe64fSgw static int 1970eb2bd662Svikram is_ufs(char *root) 1971e7cbe64fSgw { 1972eb2bd662Svikram struct statvfs vfs; 1973eb2bd662Svikram int ret; 1974eb2bd662Svikram const char *fcn = "is_ufs()"; 1975e7cbe64fSgw 1976eb2bd662Svikram ret = statvfs(root, &vfs); 1977eb2bd662Svikram INJECT_ERROR1("STATVFS_UFS", ret = 1); 1978eb2bd662Svikram if (ret != 0) { 1979eb2bd662Svikram bam_error(STATVFS_FAIL, root, strerror(errno)); 1980eb2bd662Svikram return (0); 1981eb2bd662Svikram } 1982e7cbe64fSgw 1983eb2bd662Svikram if (strncmp(vfs.f_basetype, "ufs", strlen("ufs")) == 0) { 1984eb2bd662Svikram BAM_DPRINTF((D_IS_UFS, fcn, root)); 1985eb2bd662Svikram return (1); 1986eb2bd662Svikram } else { 1987eb2bd662Svikram BAM_DPRINTF((D_IS_NOT_UFS, fcn, root)); 1988e7cbe64fSgw return (0); 1989e7cbe64fSgw } 1990eb2bd662Svikram } 1991eb2bd662Svikram 1992eb2bd662Svikram static int 1993eb2bd662Svikram is_pcfs(char *root) 1994eb2bd662Svikram { 1995eb2bd662Svikram struct statvfs vfs; 1996eb2bd662Svikram int ret; 1997eb2bd662Svikram const char *fcn = "is_pcfs()"; 1998e7cbe64fSgw 1999eb2bd662Svikram ret = statvfs(root, &vfs); 2000eb2bd662Svikram INJECT_ERROR1("STATVFS_PCFS", ret = 1); 2001eb2bd662Svikram if (ret != 0) { 2002eb2bd662Svikram bam_error(STATVFS_FAIL, root, strerror(errno)); 2003e7cbe64fSgw return (0); 2004eb2bd662Svikram } 2005e7cbe64fSgw 2006eb2bd662Svikram if (strncmp(vfs.f_basetype, "pcfs", strlen("pcfs")) == 0) { 2007eb2bd662Svikram BAM_DPRINTF((D_IS_PCFS, fcn, root)); 2008e7cbe64fSgw return (1); 2009eb2bd662Svikram } else { 2010eb2bd662Svikram BAM_DPRINTF((D_IS_NOT_PCFS, fcn, root)); 2011e7cbe64fSgw return (0); 2012e7cbe64fSgw } 2013eb2bd662Svikram } 2014e7cbe64fSgw 2015eb2bd662Svikram static int 2016eb2bd662Svikram is_readonly(char *root) 2017eb2bd662Svikram { 2018eb2bd662Svikram int fd; 2019eb2bd662Svikram int error; 2020eb2bd662Svikram char testfile[PATH_MAX]; 2021eb2bd662Svikram const char *fcn = "is_readonly()"; 2022e7cbe64fSgw 2023eb2bd662Svikram /* 2024eb2bd662Svikram * Using statvfs() to check for a read-only filesystem is not 2025eb2bd662Svikram * reliable. The only way to reliably test is to attempt to 2026eb2bd662Svikram * create a file 2027eb2bd662Svikram */ 2028eb2bd662Svikram (void) snprintf(testfile, sizeof (testfile), "%s/%s.%d", 2029eb2bd662Svikram root, BOOTADM_RDONLY_TEST, getpid()); 2030e7cbe64fSgw 2031eb2bd662Svikram (void) unlink(testfile); 2032e7cbe64fSgw 2033eb2bd662Svikram errno = 0; 2034eb2bd662Svikram fd = open(testfile, O_RDWR|O_CREAT|O_EXCL, 0644); 2035eb2bd662Svikram error = errno; 2036eb2bd662Svikram INJECT_ERROR2("RDONLY_TEST_ERROR", fd = -1, error = EACCES); 2037eb2bd662Svikram if (fd == -1 && error == EROFS) { 2038eb2bd662Svikram BAM_DPRINTF((D_RDONLY_FS, fcn, root)); 2039e7cbe64fSgw return (1); 2040eb2bd662Svikram } else if (fd == -1) { 2041eb2bd662Svikram bam_error(RDONLY_TEST_ERROR, root, strerror(error)); 2042e7cbe64fSgw } 2043e7cbe64fSgw 2044eb2bd662Svikram (void) close(fd); 2045eb2bd662Svikram (void) unlink(testfile); 2046eb2bd662Svikram 2047eb2bd662Svikram BAM_DPRINTF((D_RDWR_FS, fcn, root)); 2048e7cbe64fSgw return (0); 2049e7cbe64fSgw } 2050e7cbe64fSgw 20517c478bd9Sstevel@tonic-gate static error_t 20527c478bd9Sstevel@tonic-gate update_archive(char *root, char *opt) 20537c478bd9Sstevel@tonic-gate { 20547c478bd9Sstevel@tonic-gate error_t ret; 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate assert(root); 20577c478bd9Sstevel@tonic-gate assert(opt == NULL); 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate /* 2060eb2bd662Svikram * root must belong to a boot archive based OS, 20617c478bd9Sstevel@tonic-gate */ 2062986fd29aSsetje if (!is_boot_archive(root)) { 2063b610f78eSvikram /* 2064b610f78eSvikram * Emit message only if not in context of update_all. 2065b610f78eSvikram * If in update_all, emit only if verbose flag is set. 2066b610f78eSvikram */ 2067b610f78eSvikram if (!bam_update_all || bam_verbose) 2068eb2bd662Svikram bam_print(NOT_ARCHIVE_BOOT, root); 20697c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 20707c478bd9Sstevel@tonic-gate } 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate /* 20738c1b6884Sszhou * If smf check is requested when / is writable (can happen 20748c1b6884Sszhou * on first reboot following an upgrade because service 20758c1b6884Sszhou * dependency is messed up), skip the check. 20768c1b6884Sszhou */ 20778c1b6884Sszhou if (bam_smf_check && !bam_root_readonly) 20788c1b6884Sszhou return (BAM_SUCCESS); 20798c1b6884Sszhou 20808c1b6884Sszhou /* 20818c1b6884Sszhou * root must be writable. This check applies to alternate 20828c1b6884Sszhou * root (-R option); bam_root_readonly applies to '/' only. 20837c478bd9Sstevel@tonic-gate */ 208461cb17bdSsetje if (!bam_smf_check && !bam_check && is_readonly(root)) { 20858c1b6884Sszhou if (bam_verbose) 20867c478bd9Sstevel@tonic-gate bam_print(RDONLY_FS, root); 20877c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 20887c478bd9Sstevel@tonic-gate } 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate /* 20917c478bd9Sstevel@tonic-gate * Don't generate archive on ramdisk 20927c478bd9Sstevel@tonic-gate */ 20937c478bd9Sstevel@tonic-gate if (is_ramdisk(root)) { 20947c478bd9Sstevel@tonic-gate if (bam_verbose) 20957c478bd9Sstevel@tonic-gate bam_print(SKIP_RAMDISK); 20967c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 20977c478bd9Sstevel@tonic-gate } 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate /* 21007c478bd9Sstevel@tonic-gate * Now check if updated is really needed 21017c478bd9Sstevel@tonic-gate */ 21027c478bd9Sstevel@tonic-gate ret = update_required(root); 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate /* 21057c478bd9Sstevel@tonic-gate * The check command (-n) is *not* a dry run 21067c478bd9Sstevel@tonic-gate * It only checks if the archive is in sync. 21077c478bd9Sstevel@tonic-gate */ 21087c478bd9Sstevel@tonic-gate if (bam_check) { 21097c478bd9Sstevel@tonic-gate bam_exit((ret != 0) ? 1 : 0); 21107c478bd9Sstevel@tonic-gate } 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate if (ret == 1) { 21137c478bd9Sstevel@tonic-gate /* create the ramdisk */ 21147c478bd9Sstevel@tonic-gate ret = create_ramdisk(root); 21157c478bd9Sstevel@tonic-gate } 2116986fd29aSsetje 2117986fd29aSsetje /* if the archive is updated, save the new stat data */ 2118986fd29aSsetje if (ret == 0 && walk_arg.new_nvlp != NULL) { 2119986fd29aSsetje savenew(root); 2120986fd29aSsetje } 2121986fd29aSsetje 2122986fd29aSsetje clear_walk_args(); 2123986fd29aSsetje 21247c478bd9Sstevel@tonic-gate return (ret); 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate 2127fbac2b2bSvikram static void 2128fbac2b2bSvikram update_fdisk(void) 2129fbac2b2bSvikram { 2130fbac2b2bSvikram struct stat sb; 2131fbac2b2bSvikram char cmd[PATH_MAX]; 2132fbac2b2bSvikram int ret1, ret2; 2133fbac2b2bSvikram 2134fbac2b2bSvikram assert(stat(GRUB_fdisk, &sb) == 0); 2135fbac2b2bSvikram assert(stat(GRUB_fdisk_target, &sb) == 0); 2136fbac2b2bSvikram 2137fbac2b2bSvikram (void) snprintf(cmd, sizeof (cmd), "/sbin/fdisk -F %s `/bin/cat %s`", 2138fbac2b2bSvikram GRUB_fdisk, GRUB_fdisk_target); 2139fbac2b2bSvikram 2140fbac2b2bSvikram bam_print(UPDATING_FDISK); 2141986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 2142fbac2b2bSvikram bam_error(FDISK_UPDATE_FAILED); 2143fbac2b2bSvikram } 2144fbac2b2bSvikram 2145fbac2b2bSvikram /* 2146fbac2b2bSvikram * We are done, remove the files. 2147fbac2b2bSvikram */ 2148fbac2b2bSvikram ret1 = unlink(GRUB_fdisk); 2149fbac2b2bSvikram ret2 = unlink(GRUB_fdisk_target); 2150fbac2b2bSvikram if (ret1 != 0 || ret2 != 0) { 2151fbac2b2bSvikram bam_error(FILE_REMOVE_FAILED, GRUB_fdisk, GRUB_fdisk_target); 2152fbac2b2bSvikram } 2153fbac2b2bSvikram } 2154fbac2b2bSvikram 21557c478bd9Sstevel@tonic-gate static error_t 21567c478bd9Sstevel@tonic-gate update_all(char *root, char *opt) 21577c478bd9Sstevel@tonic-gate { 21587c478bd9Sstevel@tonic-gate struct extmnttab mnt; 21597c478bd9Sstevel@tonic-gate struct stat sb; 21607c478bd9Sstevel@tonic-gate FILE *fp; 21617c478bd9Sstevel@tonic-gate char multibt[PATH_MAX]; 2162986fd29aSsetje char creatram[PATH_MAX]; 21637c478bd9Sstevel@tonic-gate error_t ret = BAM_SUCCESS; 2164fbac2b2bSvikram int ret1, ret2; 21657c478bd9Sstevel@tonic-gate 216640541d5dSvikram assert(root); 21677c478bd9Sstevel@tonic-gate assert(opt == NULL); 21687c478bd9Sstevel@tonic-gate 216940541d5dSvikram if (bam_rootlen != 1 || *root != '/') { 217040541d5dSvikram elide_trailing_slash(root, multibt, sizeof (multibt)); 217140541d5dSvikram bam_error(ALT_ROOT_INVALID, multibt); 217240541d5dSvikram return (BAM_ERROR); 217340541d5dSvikram } 217440541d5dSvikram 21757c478bd9Sstevel@tonic-gate /* 217698892a30Snadkarni * Check to see if we are in the midst of safemode patching 217798892a30Snadkarni * If so skip building the archive for /. Instead build it 217898892a30Snadkarni * against the latest bits obtained by creating a fresh lofs 217998892a30Snadkarni * mount of root. 21807c478bd9Sstevel@tonic-gate */ 218198892a30Snadkarni if (stat(LOFS_PATCH_FILE, &sb) == 0) { 218298892a30Snadkarni if (mkdir(LOFS_PATCH_MNT, 0755) == -1 && 218398892a30Snadkarni errno != EEXIST) { 218498892a30Snadkarni bam_error(MKDIR_FAILED, "%s", LOFS_PATCH_MNT, 218598892a30Snadkarni strerror(errno)); 218698892a30Snadkarni ret = BAM_ERROR; 218798892a30Snadkarni goto out; 218898892a30Snadkarni } 218998892a30Snadkarni (void) snprintf(multibt, sizeof (multibt), 219098892a30Snadkarni "/sbin/mount -F lofs -o nosub / %s", LOFS_PATCH_MNT); 2191986fd29aSsetje if (exec_cmd(multibt, NULL) != 0) { 219298892a30Snadkarni bam_error(MOUNT_FAILED, LOFS_PATCH_MNT, "lofs"); 219398892a30Snadkarni ret = BAM_ERROR; 219498892a30Snadkarni } 219598892a30Snadkarni if (ret != BAM_ERROR) { 219698892a30Snadkarni (void) snprintf(rootbuf, sizeof (rootbuf), "%s/", 219798892a30Snadkarni LOFS_PATCH_MNT); 219898892a30Snadkarni bam_rootlen = strlen(rootbuf); 219998892a30Snadkarni if (update_archive(rootbuf, opt) != BAM_SUCCESS) 220098892a30Snadkarni ret = BAM_ERROR; 220195b1e0e9Snadkarni /* 220295b1e0e9Snadkarni * unmount the lofs mount since there could be 220395b1e0e9Snadkarni * multiple invocations of bootadm -a update_all 220495b1e0e9Snadkarni */ 220595b1e0e9Snadkarni (void) snprintf(multibt, sizeof (multibt), 220695b1e0e9Snadkarni "/sbin/umount %s", LOFS_PATCH_MNT); 2207986fd29aSsetje if (exec_cmd(multibt, NULL) != 0) { 220895b1e0e9Snadkarni bam_error(UMOUNT_FAILED, LOFS_PATCH_MNT); 220995b1e0e9Snadkarni ret = BAM_ERROR; 221095b1e0e9Snadkarni } 221198892a30Snadkarni } 221298892a30Snadkarni } else { 221398892a30Snadkarni /* 221498892a30Snadkarni * First update archive for current root 221598892a30Snadkarni */ 221698892a30Snadkarni if (update_archive(root, opt) != BAM_SUCCESS) 221798892a30Snadkarni ret = BAM_ERROR; 221898892a30Snadkarni } 221998892a30Snadkarni 222098892a30Snadkarni if (ret == BAM_ERROR) 222198892a30Snadkarni goto out; 22227c478bd9Sstevel@tonic-gate 22237c478bd9Sstevel@tonic-gate /* 22247c478bd9Sstevel@tonic-gate * Now walk the mount table, performing archive update 22257c478bd9Sstevel@tonic-gate * for all mounted Newboot root filesystems 22267c478bd9Sstevel@tonic-gate */ 22277c478bd9Sstevel@tonic-gate fp = fopen(MNTTAB, "r"); 22287c478bd9Sstevel@tonic-gate if (fp == NULL) { 22297c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 2230b610f78eSvikram ret = BAM_ERROR; 2231b610f78eSvikram goto out; 22327c478bd9Sstevel@tonic-gate } 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate resetmnttab(fp); 22357c478bd9Sstevel@tonic-gate 22367c478bd9Sstevel@tonic-gate while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 22377c478bd9Sstevel@tonic-gate if (mnt.mnt_special == NULL) 22387c478bd9Sstevel@tonic-gate continue; 22397c478bd9Sstevel@tonic-gate if (strncmp(mnt.mnt_special, "/dev/", strlen("/dev/")) != 0) 22407c478bd9Sstevel@tonic-gate continue; 22417c478bd9Sstevel@tonic-gate if (strcmp(mnt.mnt_mountp, "/") == 0) 22427c478bd9Sstevel@tonic-gate continue; 22437c478bd9Sstevel@tonic-gate 2244986fd29aSsetje (void) snprintf(creatram, sizeof (creatram), "%s/%s", 2245986fd29aSsetje mnt.mnt_mountp, CREATE_RAMDISK); 22467c478bd9Sstevel@tonic-gate 2247986fd29aSsetje if (stat(creatram, &sb) == -1) 22487c478bd9Sstevel@tonic-gate continue; 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate /* 22517c478bd9Sstevel@tonic-gate * We put a trailing slash to be consistent with root = "/" 22527c478bd9Sstevel@tonic-gate * case, such that we don't have to print // in some cases. 22537c478bd9Sstevel@tonic-gate */ 22547c478bd9Sstevel@tonic-gate (void) snprintf(rootbuf, sizeof (rootbuf), "%s/", 22557c478bd9Sstevel@tonic-gate mnt.mnt_mountp); 22567c478bd9Sstevel@tonic-gate bam_rootlen = strlen(rootbuf); 2257ae115bc7Smrj 2258ae115bc7Smrj /* 2259ae115bc7Smrj * It's possible that other mounts may be an alternate boot 2260ae115bc7Smrj * architecture, so check it again. 2261ae115bc7Smrj */ 2262eb2bd662Svikram if ((get_boot_cap(rootbuf) != BAM_SUCCESS) || 2263ae115bc7Smrj (update_archive(rootbuf, opt) != BAM_SUCCESS)) 22647c478bd9Sstevel@tonic-gate ret = BAM_ERROR; 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate 22677c478bd9Sstevel@tonic-gate (void) fclose(fp); 22687c478bd9Sstevel@tonic-gate 2269b610f78eSvikram out: 2270fbac2b2bSvikram /* 2271fbac2b2bSvikram * Update fdisk table as we go down. Updating it when 2272fbac2b2bSvikram * the system is running will confuse biosdev. 2273fbac2b2bSvikram */ 2274fbac2b2bSvikram ret1 = stat(GRUB_fdisk, &sb); 2275fbac2b2bSvikram ret2 = stat(GRUB_fdisk_target, &sb); 2276fbac2b2bSvikram if ((ret1 == 0) && (ret2 == 0)) { 2277fbac2b2bSvikram update_fdisk(); 2278fbac2b2bSvikram } else if ((ret1 == 0) ^ (ret2 == 0)) { 2279fbac2b2bSvikram /* 2280fbac2b2bSvikram * It is an error for one file to be 2281fbac2b2bSvikram * present and the other absent. 2282fbac2b2bSvikram * It is normal for both files to be 2283fbac2b2bSvikram * absent - it indicates that no fdisk 2284fbac2b2bSvikram * update is required. 2285fbac2b2bSvikram */ 2286fbac2b2bSvikram bam_error(MISSING_FDISK_FILE, 2287fbac2b2bSvikram ret1 ? GRUB_fdisk : GRUB_fdisk_target); 2288fbac2b2bSvikram ret = BAM_ERROR; 2289fbac2b2bSvikram } 2290fbac2b2bSvikram 22917c478bd9Sstevel@tonic-gate return (ret); 22927c478bd9Sstevel@tonic-gate } 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate static void 22957c478bd9Sstevel@tonic-gate append_line(menu_t *mp, line_t *lp) 22967c478bd9Sstevel@tonic-gate { 22977c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 22987c478bd9Sstevel@tonic-gate mp->start = lp; 22997c478bd9Sstevel@tonic-gate } else { 23007c478bd9Sstevel@tonic-gate mp->end->next = lp; 23018c1b6884Sszhou lp->prev = mp->end; 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate mp->end = lp; 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate 2306eb2bd662Svikram void 23078c1b6884Sszhou unlink_line(menu_t *mp, line_t *lp) 23088c1b6884Sszhou { 23098c1b6884Sszhou /* unlink from list */ 23108c1b6884Sszhou if (lp->prev) 23118c1b6884Sszhou lp->prev->next = lp->next; 23128c1b6884Sszhou else 23138c1b6884Sszhou mp->start = lp->next; 23148c1b6884Sszhou if (lp->next) 23158c1b6884Sszhou lp->next->prev = lp->prev; 23168c1b6884Sszhou else 23178c1b6884Sszhou mp->end = lp->prev; 23188c1b6884Sszhou } 23198c1b6884Sszhou 23208c1b6884Sszhou static entry_t * 23218c1b6884Sszhou boot_entry_new(menu_t *mp, line_t *start, line_t *end) 23228c1b6884Sszhou { 23238c1b6884Sszhou entry_t *ent, *prev; 2324eb2bd662Svikram const char *fcn = "boot_entry_new()"; 2325eb2bd662Svikram 2326eb2bd662Svikram assert(mp); 2327eb2bd662Svikram assert(start); 2328eb2bd662Svikram assert(end); 23298c1b6884Sszhou 23308c1b6884Sszhou ent = s_calloc(1, sizeof (entry_t)); 2331eb2bd662Svikram BAM_DPRINTF((D_ENTRY_NEW, fcn)); 23328c1b6884Sszhou ent->start = start; 23338c1b6884Sszhou ent->end = end; 23348c1b6884Sszhou 23358c1b6884Sszhou if (mp->entries == NULL) { 23368c1b6884Sszhou mp->entries = ent; 2337eb2bd662Svikram BAM_DPRINTF((D_ENTRY_NEW_FIRST, fcn)); 23388c1b6884Sszhou return (ent); 23398c1b6884Sszhou } 23408c1b6884Sszhou 23418c1b6884Sszhou prev = mp->entries; 23428c1b6884Sszhou while (prev->next) 2343eb2bd662Svikram prev = prev->next; 23448c1b6884Sszhou prev->next = ent; 23458c1b6884Sszhou ent->prev = prev; 2346eb2bd662Svikram BAM_DPRINTF((D_ENTRY_NEW_LINKED, fcn)); 23478c1b6884Sszhou return (ent); 23488c1b6884Sszhou } 23498c1b6884Sszhou 23508c1b6884Sszhou static void 23518c1b6884Sszhou boot_entry_addline(entry_t *ent, line_t *lp) 23528c1b6884Sszhou { 23538c1b6884Sszhou if (ent) 23548c1b6884Sszhou ent->end = lp; 23558c1b6884Sszhou } 23568c1b6884Sszhou 2357843e1988Sjohnlev /* 2358843e1988Sjohnlev * Check whether cmd matches the one indexed by which, and whether arg matches 2359843e1988Sjohnlev * str. which must be either KERNEL_CMD or MODULE_CMD, and a match to the 2360843e1988Sjohnlev * respective *_DOLLAR_CMD is also acceptable. The arg is searched using 2361843e1988Sjohnlev * strstr(), so it can be a partial match. 2362843e1988Sjohnlev */ 2363843e1988Sjohnlev static int 2364843e1988Sjohnlev check_cmd(const char *cmd, const int which, const char *arg, const char *str) 2365843e1988Sjohnlev { 2366eb2bd662Svikram int ret; 2367eb2bd662Svikram const char *fcn = "check_cmd()"; 2368eb2bd662Svikram 2369eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, arg, str)); 2370eb2bd662Svikram 2371843e1988Sjohnlev if ((strcmp(cmd, menu_cmds[which]) != 0) && 2372843e1988Sjohnlev (strcmp(cmd, menu_cmds[which + 1]) != 0)) { 2373eb2bd662Svikram BAM_DPRINTF((D_CHECK_CMD_CMD_NOMATCH, 2374eb2bd662Svikram fcn, cmd, menu_cmds[which])); 2375843e1988Sjohnlev return (0); 2376843e1988Sjohnlev } 2377eb2bd662Svikram ret = (strstr(arg, str) != NULL); 2378eb2bd662Svikram 2379eb2bd662Svikram if (ret) { 2380eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 2381eb2bd662Svikram } else { 2382eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 2383eb2bd662Svikram } 2384eb2bd662Svikram 2385eb2bd662Svikram return (ret); 2386eb2bd662Svikram } 2387eb2bd662Svikram 2388eb2bd662Svikram static error_t 2389eb2bd662Svikram kernel_parser(entry_t *entry, char *cmd, char *arg, int linenum) 2390eb2bd662Svikram { 2391eb2bd662Svikram const char *fcn = "kernel_parser()"; 2392eb2bd662Svikram 2393eb2bd662Svikram assert(entry); 2394eb2bd662Svikram assert(cmd); 2395eb2bd662Svikram assert(arg); 2396eb2bd662Svikram 2397eb2bd662Svikram if (strcmp(cmd, menu_cmds[KERNEL_CMD]) != 0 && 2398eb2bd662Svikram strcmp(cmd, menu_cmds[KERNEL_DOLLAR_CMD]) != 0) { 2399eb2bd662Svikram BAM_DPRINTF((D_NOT_KERNEL_CMD, fcn, cmd)); 2400eb2bd662Svikram return (BAM_ERROR); 2401eb2bd662Svikram } 2402eb2bd662Svikram 2403eb2bd662Svikram if (strncmp(arg, DIRECT_BOOT_32, sizeof (DIRECT_BOOT_32) - 1) == 0) { 2404eb2bd662Svikram BAM_DPRINTF((D_SET_DBOOT_32, fcn, arg)); 2405eb2bd662Svikram entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_32BIT; 2406eb2bd662Svikram } else if (strncmp(arg, DIRECT_BOOT_KERNEL, 2407eb2bd662Svikram sizeof (DIRECT_BOOT_KERNEL) - 1) == 0) { 2408eb2bd662Svikram BAM_DPRINTF((D_SET_DBOOT, fcn, arg)); 2409eb2bd662Svikram entry->flags |= BAM_ENTRY_DBOOT; 2410eb2bd662Svikram } else if (strncmp(arg, DIRECT_BOOT_64, 2411eb2bd662Svikram sizeof (DIRECT_BOOT_64) - 1) == 0) { 2412eb2bd662Svikram BAM_DPRINTF((D_SET_DBOOT_64, fcn, arg)); 2413eb2bd662Svikram entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_64BIT; 2414eb2bd662Svikram } else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_KERNEL, 2415eb2bd662Svikram sizeof (DIRECT_BOOT_FAILSAFE_KERNEL) - 1) == 0) { 2416eb2bd662Svikram BAM_DPRINTF((D_SET_DBOOT_FAILSAFE, fcn, arg)); 2417eb2bd662Svikram entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE; 2418eb2bd662Svikram } else if (strncmp(arg, MULTI_BOOT, sizeof (MULTI_BOOT) - 1) == 0) { 2419eb2bd662Svikram BAM_DPRINTF((D_SET_MULTIBOOT, fcn, arg)); 2420eb2bd662Svikram entry->flags |= BAM_ENTRY_MULTIBOOT; 2421eb2bd662Svikram } else if (strncmp(arg, MULTI_BOOT_FAILSAFE, 2422eb2bd662Svikram sizeof (MULTI_BOOT_FAILSAFE) - 1) == 0) { 2423eb2bd662Svikram BAM_DPRINTF((D_SET_MULTIBOOT_FAILSAFE, fcn, arg)); 2424eb2bd662Svikram entry->flags |= BAM_ENTRY_MULTIBOOT | BAM_ENTRY_FAILSAFE; 2425eb2bd662Svikram } else if (strstr(arg, XEN_KERNEL_SUBSTR)) { 2426eb2bd662Svikram BAM_DPRINTF((D_SET_HV, fcn, arg)); 2427eb2bd662Svikram entry->flags |= BAM_ENTRY_HV; 2428eb2bd662Svikram } else if (!(entry->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU))) { 2429eb2bd662Svikram BAM_DPRINTF((D_SET_HAND_KERNEL, fcn, arg)); 2430eb2bd662Svikram return (BAM_ERROR); 2431eb2bd662Svikram } else { 2432eb2bd662Svikram BAM_DPRINTF((D_IS_UNKNOWN_KERNEL, fcn, arg)); 2433eb2bd662Svikram bam_error(UNKNOWN_KERNEL_LINE, linenum); 2434eb2bd662Svikram return (BAM_ERROR); 2435eb2bd662Svikram } 2436eb2bd662Svikram 2437eb2bd662Svikram return (BAM_SUCCESS); 2438eb2bd662Svikram } 2439eb2bd662Svikram 2440eb2bd662Svikram static error_t 2441eb2bd662Svikram module_parser(entry_t *entry, char *cmd, char *arg, int linenum) 2442eb2bd662Svikram { 2443eb2bd662Svikram const char *fcn = "module_parser()"; 2444eb2bd662Svikram 2445eb2bd662Svikram assert(entry); 2446eb2bd662Svikram assert(cmd); 2447eb2bd662Svikram assert(arg); 2448eb2bd662Svikram 2449eb2bd662Svikram if (strcmp(cmd, menu_cmds[MODULE_CMD]) != 0 && 2450eb2bd662Svikram strcmp(cmd, menu_cmds[MODULE_DOLLAR_CMD]) != 0) { 2451eb2bd662Svikram BAM_DPRINTF((D_NOT_MODULE_CMD, fcn, cmd)); 2452eb2bd662Svikram return (BAM_ERROR); 2453eb2bd662Svikram } 2454eb2bd662Svikram 2455eb2bd662Svikram if (strcmp(arg, DIRECT_BOOT_ARCHIVE) == 0 || 2456eb2bd662Svikram strcmp(arg, DIRECT_BOOT_ARCHIVE_32) == 0 || 2457eb2bd662Svikram strcmp(arg, DIRECT_BOOT_ARCHIVE_64) == 0 || 2458eb2bd662Svikram strcmp(arg, MULTIBOOT_ARCHIVE) == 0 || 2459eb2bd662Svikram strcmp(arg, FAILSAFE_ARCHIVE) == 0 || 2460eb2bd662Svikram strcmp(arg, XEN_KERNEL_MODULE_LINE) == 0 || 2461eb2bd662Svikram strcmp(arg, XEN_KERNEL_MODULE_LINE_ZFS) == 0) { 2462eb2bd662Svikram BAM_DPRINTF((D_BOOTADM_LU_MODULE, fcn, arg)); 2463eb2bd662Svikram return (BAM_SUCCESS); 2464eb2bd662Svikram } else if (!(entry->flags & BAM_ENTRY_BOOTADM) && 2465eb2bd662Svikram !(entry->flags & BAM_ENTRY_LU)) { 2466eb2bd662Svikram /* don't emit warning for hand entries */ 2467eb2bd662Svikram BAM_DPRINTF((D_IS_HAND_MODULE, fcn, arg)); 2468eb2bd662Svikram return (BAM_ERROR); 2469eb2bd662Svikram } else { 2470eb2bd662Svikram BAM_DPRINTF((D_IS_UNKNOWN_MODULE, fcn, arg)); 2471eb2bd662Svikram bam_error(UNKNOWN_MODULE_LINE, linenum); 2472eb2bd662Svikram return (BAM_ERROR); 2473eb2bd662Svikram } 2474843e1988Sjohnlev } 2475843e1988Sjohnlev 24767c478bd9Sstevel@tonic-gate /* 24777c478bd9Sstevel@tonic-gate * A line in menu.lst looks like 24787c478bd9Sstevel@tonic-gate * [ ]*<cmd>[ \t=]*<arg>* 24797c478bd9Sstevel@tonic-gate */ 24807c478bd9Sstevel@tonic-gate static void 24817c478bd9Sstevel@tonic-gate line_parser(menu_t *mp, char *str, int *lineNum, int *entryNum) 24827c478bd9Sstevel@tonic-gate { 24837c478bd9Sstevel@tonic-gate /* 24847c478bd9Sstevel@tonic-gate * save state across calls. This is so that 24857c478bd9Sstevel@tonic-gate * header gets the right entry# after title has 24867c478bd9Sstevel@tonic-gate * been processed 24877c478bd9Sstevel@tonic-gate */ 24888c1b6884Sszhou static line_t *prev = NULL; 24898c1b6884Sszhou static entry_t *curr_ent = NULL; 2490ae115bc7Smrj static int in_liveupgrade = 0; 24917c478bd9Sstevel@tonic-gate 24927c478bd9Sstevel@tonic-gate line_t *lp; 24937c478bd9Sstevel@tonic-gate char *cmd, *sep, *arg; 24947c478bd9Sstevel@tonic-gate char save, *cp, *line; 24957c478bd9Sstevel@tonic-gate menu_flag_t flag = BAM_INVALID; 2496eb2bd662Svikram const char *fcn = "line_parser()"; 24977c478bd9Sstevel@tonic-gate 24987c478bd9Sstevel@tonic-gate if (str == NULL) { 24997c478bd9Sstevel@tonic-gate return; 25007c478bd9Sstevel@tonic-gate } 25017c478bd9Sstevel@tonic-gate 25027c478bd9Sstevel@tonic-gate /* 25037c478bd9Sstevel@tonic-gate * First save a copy of the entire line. 25047c478bd9Sstevel@tonic-gate * We use this later to set the line field. 25057c478bd9Sstevel@tonic-gate */ 25067c478bd9Sstevel@tonic-gate line = s_strdup(str); 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate /* Eat up leading whitespace */ 25097c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 25107c478bd9Sstevel@tonic-gate str++; 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate if (*str == '#') { /* comment */ 25137c478bd9Sstevel@tonic-gate cmd = s_strdup("#"); 25147c478bd9Sstevel@tonic-gate sep = NULL; 25157c478bd9Sstevel@tonic-gate arg = s_strdup(str + 1); 25167c478bd9Sstevel@tonic-gate flag = BAM_COMMENT; 2517ae115bc7Smrj if (strstr(arg, BAM_LU_HDR) != NULL) { 2518ae115bc7Smrj in_liveupgrade = 1; 2519ae115bc7Smrj } else if (strstr(arg, BAM_LU_FTR) != NULL) { 2520ae115bc7Smrj in_liveupgrade = 0; 2521ae115bc7Smrj } 25227c478bd9Sstevel@tonic-gate } else if (*str == '\0') { /* blank line */ 25237c478bd9Sstevel@tonic-gate cmd = sep = arg = NULL; 25247c478bd9Sstevel@tonic-gate flag = BAM_EMPTY; 25257c478bd9Sstevel@tonic-gate } else { 25267c478bd9Sstevel@tonic-gate /* 25277c478bd9Sstevel@tonic-gate * '=' is not a documented separator in grub syntax. 25287c478bd9Sstevel@tonic-gate * However various development bits use '=' as a 25297c478bd9Sstevel@tonic-gate * separator. In addition, external users also 25307c478bd9Sstevel@tonic-gate * use = as a separator. So we will allow that usage. 25317c478bd9Sstevel@tonic-gate */ 25327c478bd9Sstevel@tonic-gate cp = str; 25337c478bd9Sstevel@tonic-gate while (*str != ' ' && *str != '\t' && *str != '=') { 25347c478bd9Sstevel@tonic-gate if (*str == '\0') { 25357c478bd9Sstevel@tonic-gate cmd = s_strdup(cp); 25367c478bd9Sstevel@tonic-gate sep = arg = NULL; 25377c478bd9Sstevel@tonic-gate break; 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate str++; 25407c478bd9Sstevel@tonic-gate } 25417c478bd9Sstevel@tonic-gate 25427c478bd9Sstevel@tonic-gate if (*str != '\0') { 25437c478bd9Sstevel@tonic-gate save = *str; 25447c478bd9Sstevel@tonic-gate *str = '\0'; 25457c478bd9Sstevel@tonic-gate cmd = s_strdup(cp); 25467c478bd9Sstevel@tonic-gate *str = save; 25477c478bd9Sstevel@tonic-gate 25487c478bd9Sstevel@tonic-gate str++; 25497c478bd9Sstevel@tonic-gate save = *str; 25507c478bd9Sstevel@tonic-gate *str = '\0'; 25517c478bd9Sstevel@tonic-gate sep = s_strdup(str - 1); 25527c478bd9Sstevel@tonic-gate *str = save; 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 25557c478bd9Sstevel@tonic-gate str++; 25567c478bd9Sstevel@tonic-gate if (*str == '\0') 25577c478bd9Sstevel@tonic-gate arg = NULL; 25587c478bd9Sstevel@tonic-gate else 25597c478bd9Sstevel@tonic-gate arg = s_strdup(str); 25607c478bd9Sstevel@tonic-gate } 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate 25637c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 25647c478bd9Sstevel@tonic-gate 25657c478bd9Sstevel@tonic-gate lp->cmd = cmd; 25667c478bd9Sstevel@tonic-gate lp->sep = sep; 25677c478bd9Sstevel@tonic-gate lp->arg = arg; 25687c478bd9Sstevel@tonic-gate lp->line = line; 25697c478bd9Sstevel@tonic-gate lp->lineNum = ++(*lineNum); 25707c478bd9Sstevel@tonic-gate if (cmd && strcmp(cmd, menu_cmds[TITLE_CMD]) == 0) { 25717c478bd9Sstevel@tonic-gate lp->entryNum = ++(*entryNum); 25727c478bd9Sstevel@tonic-gate lp->flags = BAM_TITLE; 25737c478bd9Sstevel@tonic-gate if (prev && prev->flags == BAM_COMMENT && 2574ae115bc7Smrj prev->arg && strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 25757c478bd9Sstevel@tonic-gate prev->entryNum = lp->entryNum; 25768c1b6884Sszhou curr_ent = boot_entry_new(mp, prev, lp); 2577eb2bd662Svikram curr_ent->flags |= BAM_ENTRY_BOOTADM; 2578eb2bd662Svikram BAM_DPRINTF((D_IS_BOOTADM_ENTRY, fcn, arg)); 25798c1b6884Sszhou } else { 25808c1b6884Sszhou curr_ent = boot_entry_new(mp, lp, lp); 2581ae115bc7Smrj if (in_liveupgrade) { 2582eb2bd662Svikram curr_ent->flags |= BAM_ENTRY_LU; 2583eb2bd662Svikram BAM_DPRINTF((D_IS_LU_ENTRY, fcn, arg)); 2584ae115bc7Smrj } 25858c1b6884Sszhou } 2586ae115bc7Smrj curr_ent->entryNum = *entryNum; 25877c478bd9Sstevel@tonic-gate } else if (flag != BAM_INVALID) { 25887c478bd9Sstevel@tonic-gate /* 25897c478bd9Sstevel@tonic-gate * For header comments, the entry# is "fixed up" 25907c478bd9Sstevel@tonic-gate * by the subsequent title 25917c478bd9Sstevel@tonic-gate */ 25927c478bd9Sstevel@tonic-gate lp->entryNum = *entryNum; 25937c478bd9Sstevel@tonic-gate lp->flags = flag; 25947c478bd9Sstevel@tonic-gate } else { 25957c478bd9Sstevel@tonic-gate lp->entryNum = *entryNum; 2596ae115bc7Smrj 2597ae115bc7Smrj if (*entryNum == ENTRY_INIT) { 2598ae115bc7Smrj lp->flags = BAM_GLOBAL; 2599ae115bc7Smrj } else { 2600ae115bc7Smrj lp->flags = BAM_ENTRY; 2601ae115bc7Smrj 2602ae115bc7Smrj if (cmd && arg) { 2603eb2bd662Svikram if (strcmp(cmd, menu_cmds[ROOT_CMD]) == 0) { 2604eb2bd662Svikram BAM_DPRINTF((D_IS_ROOT_CMD, fcn, arg)); 2605ae115bc7Smrj curr_ent->flags |= BAM_ENTRY_ROOT; 2606eb2bd662Svikram } else if (strcmp(cmd, menu_cmds[FINDROOT_CMD]) 2607eb2bd662Svikram == 0) { 2608eb2bd662Svikram BAM_DPRINTF((D_IS_FINDROOT_CMD, fcn, 2609eb2bd662Svikram arg)); 2610eb2bd662Svikram curr_ent->flags |= BAM_ENTRY_FINDROOT; 2611eb2bd662Svikram } else if (strcmp(cmd, 2612eb2bd662Svikram menu_cmds[CHAINLOADER_CMD]) == 0) { 2613eb2bd662Svikram BAM_DPRINTF((D_IS_CHAINLOADER_CMD, fcn, 2614eb2bd662Svikram arg)); 2615ae115bc7Smrj curr_ent->flags |= 2616ae115bc7Smrj BAM_ENTRY_CHAINLOADER; 2617eb2bd662Svikram } else if (kernel_parser(curr_ent, cmd, arg, 2618eb2bd662Svikram lp->lineNum) != BAM_SUCCESS) { 2619eb2bd662Svikram (void) module_parser(curr_ent, cmd, 2620eb2bd662Svikram arg, lp->lineNum); 2621eb2bd662Svikram } 2622ae115bc7Smrj } 2623ae115bc7Smrj } 26247c478bd9Sstevel@tonic-gate } 26257c478bd9Sstevel@tonic-gate 26268c1b6884Sszhou /* record default, old default, and entry line ranges */ 26278c1b6884Sszhou if (lp->flags == BAM_GLOBAL && 26288c1b6884Sszhou strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0) { 26298c1b6884Sszhou mp->curdefault = lp; 26308c1b6884Sszhou } else if (lp->flags == BAM_COMMENT && 26318c1b6884Sszhou strncmp(lp->arg, BAM_OLDDEF, strlen(BAM_OLDDEF)) == 0) { 26328c1b6884Sszhou mp->olddefault = lp; 2633ae115bc7Smrj } else if (lp->flags == BAM_COMMENT && 2634ae115bc7Smrj strncmp(lp->arg, BAM_OLD_RC_DEF, strlen(BAM_OLD_RC_DEF)) == 0) { 2635ae115bc7Smrj mp->old_rc_default = lp; 26368c1b6884Sszhou } else if (lp->flags == BAM_ENTRY || 2637ae115bc7Smrj (lp->flags == BAM_COMMENT && 2638ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_FTR) == 0)) { 26398c1b6884Sszhou boot_entry_addline(curr_ent, lp); 26408c1b6884Sszhou } 26417c478bd9Sstevel@tonic-gate append_line(mp, lp); 26427c478bd9Sstevel@tonic-gate 26437c478bd9Sstevel@tonic-gate prev = lp; 26447c478bd9Sstevel@tonic-gate } 26457c478bd9Sstevel@tonic-gate 2646eb2bd662Svikram void 264740541d5dSvikram update_numbering(menu_t *mp) 264840541d5dSvikram { 264940541d5dSvikram int lineNum; 265040541d5dSvikram int entryNum; 265140541d5dSvikram int old_default_value; 265240541d5dSvikram line_t *lp, *prev, *default_lp, *default_entry; 265340541d5dSvikram char buf[PATH_MAX]; 265440541d5dSvikram 265540541d5dSvikram if (mp->start == NULL) { 265640541d5dSvikram return; 265740541d5dSvikram } 265840541d5dSvikram 265940541d5dSvikram lineNum = LINE_INIT; 266040541d5dSvikram entryNum = ENTRY_INIT; 266140541d5dSvikram old_default_value = ENTRY_INIT; 266240541d5dSvikram lp = default_lp = default_entry = NULL; 266340541d5dSvikram 266440541d5dSvikram prev = NULL; 266540541d5dSvikram for (lp = mp->start; lp; prev = lp, lp = lp->next) { 266640541d5dSvikram lp->lineNum = ++lineNum; 266740541d5dSvikram 266840541d5dSvikram /* 266940541d5dSvikram * Get the value of the default command 267040541d5dSvikram */ 267140541d5dSvikram if (lp->entryNum == ENTRY_INIT && lp->cmd && 267240541d5dSvikram strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0 && 267340541d5dSvikram lp->arg) { 267440541d5dSvikram old_default_value = atoi(lp->arg); 267540541d5dSvikram default_lp = lp; 267640541d5dSvikram } 267740541d5dSvikram 267840541d5dSvikram /* 2679eb2bd662Svikram * If not a booting entry, nothing else to fix for this 268040541d5dSvikram * entry 268140541d5dSvikram */ 268240541d5dSvikram if (lp->entryNum == ENTRY_INIT) 268340541d5dSvikram continue; 268440541d5dSvikram 268540541d5dSvikram /* 268640541d5dSvikram * Record the position of the default entry. 268740541d5dSvikram * The following works because global 268840541d5dSvikram * commands like default and timeout should precede 268940541d5dSvikram * actual boot entries, so old_default_value 269040541d5dSvikram * is already known (or default cmd is missing). 269140541d5dSvikram */ 269240541d5dSvikram if (default_entry == NULL && 269340541d5dSvikram old_default_value != ENTRY_INIT && 269440541d5dSvikram lp->entryNum == old_default_value) { 269540541d5dSvikram default_entry = lp; 269640541d5dSvikram } 269740541d5dSvikram 269840541d5dSvikram /* 269940541d5dSvikram * Now fixup the entry number 270040541d5dSvikram */ 270140541d5dSvikram if (lp->cmd && strcmp(lp->cmd, menu_cmds[TITLE_CMD]) == 0) { 270240541d5dSvikram lp->entryNum = ++entryNum; 270340541d5dSvikram /* fixup the bootadm header */ 270440541d5dSvikram if (prev && prev->flags == BAM_COMMENT && 2705ae115bc7Smrj prev->arg && 2706ae115bc7Smrj strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 270740541d5dSvikram prev->entryNum = lp->entryNum; 270840541d5dSvikram } 270940541d5dSvikram } else { 271040541d5dSvikram lp->entryNum = entryNum; 271140541d5dSvikram } 271240541d5dSvikram } 271340541d5dSvikram 271440541d5dSvikram /* 271540541d5dSvikram * No default command in menu, simply return 271640541d5dSvikram */ 271740541d5dSvikram if (default_lp == NULL) { 271840541d5dSvikram return; 271940541d5dSvikram } 272040541d5dSvikram 272140541d5dSvikram free(default_lp->arg); 272240541d5dSvikram free(default_lp->line); 272340541d5dSvikram 272440541d5dSvikram if (default_entry == NULL) { 272540541d5dSvikram default_lp->arg = s_strdup("0"); 272640541d5dSvikram } else { 272740541d5dSvikram (void) snprintf(buf, sizeof (buf), "%d", 272840541d5dSvikram default_entry->entryNum); 272940541d5dSvikram default_lp->arg = s_strdup(buf); 273040541d5dSvikram } 273140541d5dSvikram 273240541d5dSvikram /* 273340541d5dSvikram * The following is required since only the line field gets 273440541d5dSvikram * written back to menu.lst 273540541d5dSvikram */ 273640541d5dSvikram (void) snprintf(buf, sizeof (buf), "%s%s%s", 273740541d5dSvikram menu_cmds[DEFAULT_CMD], menu_cmds[SEP_CMD], default_lp->arg); 273840541d5dSvikram default_lp->line = s_strdup(buf); 273940541d5dSvikram } 274040541d5dSvikram 274140541d5dSvikram 27427c478bd9Sstevel@tonic-gate static menu_t * 27437c478bd9Sstevel@tonic-gate menu_read(char *menu_path) 27447c478bd9Sstevel@tonic-gate { 27457c478bd9Sstevel@tonic-gate FILE *fp; 27467c478bd9Sstevel@tonic-gate char buf[BAM_MAXLINE], *cp; 27477c478bd9Sstevel@tonic-gate menu_t *mp; 27487c478bd9Sstevel@tonic-gate int line, entry, len, n; 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate mp = s_calloc(1, sizeof (menu_t)); 27517c478bd9Sstevel@tonic-gate 27527c478bd9Sstevel@tonic-gate fp = fopen(menu_path, "r"); 27537c478bd9Sstevel@tonic-gate if (fp == NULL) { /* Let the caller handle this error */ 27547c478bd9Sstevel@tonic-gate return (mp); 27557c478bd9Sstevel@tonic-gate } 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate 27587c478bd9Sstevel@tonic-gate /* Note: GRUB boot entry number starts with 0 */ 27597c478bd9Sstevel@tonic-gate line = LINE_INIT; 27607c478bd9Sstevel@tonic-gate entry = ENTRY_INIT; 27617c478bd9Sstevel@tonic-gate cp = buf; 27627c478bd9Sstevel@tonic-gate len = sizeof (buf); 27637c478bd9Sstevel@tonic-gate while (s_fgets(cp, len, fp) != NULL) { 27647c478bd9Sstevel@tonic-gate n = strlen(cp); 27657c478bd9Sstevel@tonic-gate if (cp[n - 1] == '\\') { 27667c478bd9Sstevel@tonic-gate len -= n - 1; 27677c478bd9Sstevel@tonic-gate assert(len >= 2); 27687c478bd9Sstevel@tonic-gate cp += n - 1; 27697c478bd9Sstevel@tonic-gate continue; 27707c478bd9Sstevel@tonic-gate } 27717c478bd9Sstevel@tonic-gate line_parser(mp, buf, &line, &entry); 27727c478bd9Sstevel@tonic-gate cp = buf; 27737c478bd9Sstevel@tonic-gate len = sizeof (buf); 27747c478bd9Sstevel@tonic-gate } 27757c478bd9Sstevel@tonic-gate 27767c478bd9Sstevel@tonic-gate if (fclose(fp) == EOF) { 27777c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, menu_path, strerror(errno)); 27787c478bd9Sstevel@tonic-gate } 27797c478bd9Sstevel@tonic-gate 27807c478bd9Sstevel@tonic-gate return (mp); 27817c478bd9Sstevel@tonic-gate } 27827c478bd9Sstevel@tonic-gate 27837c478bd9Sstevel@tonic-gate static error_t 27847c478bd9Sstevel@tonic-gate selector(menu_t *mp, char *opt, int *entry, char **title) 27857c478bd9Sstevel@tonic-gate { 27867c478bd9Sstevel@tonic-gate char *eq; 27877c478bd9Sstevel@tonic-gate char *opt_dup; 27887c478bd9Sstevel@tonic-gate int entryNum; 27897c478bd9Sstevel@tonic-gate 27907c478bd9Sstevel@tonic-gate assert(mp); 27917c478bd9Sstevel@tonic-gate assert(mp->start); 27927c478bd9Sstevel@tonic-gate assert(opt); 27937c478bd9Sstevel@tonic-gate 27947c478bd9Sstevel@tonic-gate opt_dup = s_strdup(opt); 27957c478bd9Sstevel@tonic-gate 27967c478bd9Sstevel@tonic-gate if (entry) 27977c478bd9Sstevel@tonic-gate *entry = ENTRY_INIT; 27987c478bd9Sstevel@tonic-gate if (title) 27997c478bd9Sstevel@tonic-gate *title = NULL; 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate eq = strchr(opt_dup, '='); 28027c478bd9Sstevel@tonic-gate if (eq == NULL) { 28037c478bd9Sstevel@tonic-gate bam_error(INVALID_OPT, opt); 28047c478bd9Sstevel@tonic-gate free(opt_dup); 28057c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28067c478bd9Sstevel@tonic-gate } 28077c478bd9Sstevel@tonic-gate 28087c478bd9Sstevel@tonic-gate *eq = '\0'; 28097c478bd9Sstevel@tonic-gate if (entry && strcmp(opt_dup, OPT_ENTRY_NUM) == 0) { 28107c478bd9Sstevel@tonic-gate assert(mp->end); 28117c478bd9Sstevel@tonic-gate entryNum = s_strtol(eq + 1); 28127c478bd9Sstevel@tonic-gate if (entryNum < 0 || entryNum > mp->end->entryNum) { 28137c478bd9Sstevel@tonic-gate bam_error(INVALID_ENTRY, eq + 1); 28147c478bd9Sstevel@tonic-gate free(opt_dup); 28157c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate *entry = entryNum; 28187c478bd9Sstevel@tonic-gate } else if (title && strcmp(opt_dup, menu_cmds[TITLE_CMD]) == 0) { 28197c478bd9Sstevel@tonic-gate *title = opt + (eq - opt_dup) + 1; 28207c478bd9Sstevel@tonic-gate } else { 28217c478bd9Sstevel@tonic-gate bam_error(INVALID_OPT, opt); 28227c478bd9Sstevel@tonic-gate free(opt_dup); 28237c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28247c478bd9Sstevel@tonic-gate } 28257c478bd9Sstevel@tonic-gate 28267c478bd9Sstevel@tonic-gate free(opt_dup); 28277c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 28287c478bd9Sstevel@tonic-gate } 28297c478bd9Sstevel@tonic-gate 28307c478bd9Sstevel@tonic-gate /* 28317c478bd9Sstevel@tonic-gate * If invoked with no titles/entries (opt == NULL) 28327c478bd9Sstevel@tonic-gate * only title lines in file are printed. 28337c478bd9Sstevel@tonic-gate * 28347c478bd9Sstevel@tonic-gate * If invoked with a title or entry #, all 28357c478bd9Sstevel@tonic-gate * lines in *every* matching entry are listed 28367c478bd9Sstevel@tonic-gate */ 28377c478bd9Sstevel@tonic-gate static error_t 28387c478bd9Sstevel@tonic-gate list_entry(menu_t *mp, char *menu_path, char *opt) 28397c478bd9Sstevel@tonic-gate { 28407c478bd9Sstevel@tonic-gate line_t *lp; 28417c478bd9Sstevel@tonic-gate int entry = ENTRY_INIT; 28427c478bd9Sstevel@tonic-gate int found; 28437c478bd9Sstevel@tonic-gate char *title = NULL; 28447c478bd9Sstevel@tonic-gate 28457c478bd9Sstevel@tonic-gate assert(mp); 28467c478bd9Sstevel@tonic-gate assert(menu_path); 28477c478bd9Sstevel@tonic-gate 2848eb2bd662Svikram /* opt is optional */ 2849eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, "list_entry", menu_path, 2850eb2bd662Svikram opt ? opt : "<NULL>")); 2851eb2bd662Svikram 28527c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 28537c478bd9Sstevel@tonic-gate bam_error(NO_MENU, menu_path); 28547c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28557c478bd9Sstevel@tonic-gate } 28567c478bd9Sstevel@tonic-gate 28577c478bd9Sstevel@tonic-gate if (opt != NULL) { 28587c478bd9Sstevel@tonic-gate if (selector(mp, opt, &entry, &title) != BAM_SUCCESS) { 28597c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28607c478bd9Sstevel@tonic-gate } 28617c478bd9Sstevel@tonic-gate assert((entry != ENTRY_INIT) ^ (title != NULL)); 28627c478bd9Sstevel@tonic-gate } else { 28637c478bd9Sstevel@tonic-gate (void) read_globals(mp, menu_path, menu_cmds[DEFAULT_CMD], 0); 28647c478bd9Sstevel@tonic-gate (void) read_globals(mp, menu_path, menu_cmds[TIMEOUT_CMD], 0); 28657c478bd9Sstevel@tonic-gate } 28667c478bd9Sstevel@tonic-gate 28677c478bd9Sstevel@tonic-gate found = 0; 28687c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 28697c478bd9Sstevel@tonic-gate if (lp->flags == BAM_COMMENT || lp->flags == BAM_EMPTY) 28707c478bd9Sstevel@tonic-gate continue; 28717c478bd9Sstevel@tonic-gate if (opt == NULL && lp->flags == BAM_TITLE) { 28727c478bd9Sstevel@tonic-gate bam_print(PRINT_TITLE, lp->entryNum, 28737c478bd9Sstevel@tonic-gate lp->arg); 28747c478bd9Sstevel@tonic-gate found = 1; 28757c478bd9Sstevel@tonic-gate continue; 28767c478bd9Sstevel@tonic-gate } 28777c478bd9Sstevel@tonic-gate if (entry != ENTRY_INIT && lp->entryNum == entry) { 28787c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 28797c478bd9Sstevel@tonic-gate found = 1; 28807c478bd9Sstevel@tonic-gate continue; 28817c478bd9Sstevel@tonic-gate } 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate /* 28847c478bd9Sstevel@tonic-gate * We set the entry value here so that all lines 28857c478bd9Sstevel@tonic-gate * in entry get printed. If we subsequently match 28867c478bd9Sstevel@tonic-gate * title in other entries, all lines in those 28877c478bd9Sstevel@tonic-gate * entries get printed as well. 28887c478bd9Sstevel@tonic-gate */ 28897c478bd9Sstevel@tonic-gate if (title && lp->flags == BAM_TITLE && lp->arg && 28907c478bd9Sstevel@tonic-gate strncmp(title, lp->arg, strlen(title)) == 0) { 28917c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 28927c478bd9Sstevel@tonic-gate entry = lp->entryNum; 28937c478bd9Sstevel@tonic-gate found = 1; 28947c478bd9Sstevel@tonic-gate continue; 28957c478bd9Sstevel@tonic-gate } 28967c478bd9Sstevel@tonic-gate } 28977c478bd9Sstevel@tonic-gate 28987c478bd9Sstevel@tonic-gate if (!found) { 28997c478bd9Sstevel@tonic-gate bam_error(NO_MATCH_ENTRY); 29007c478bd9Sstevel@tonic-gate return (BAM_ERROR); 29017c478bd9Sstevel@tonic-gate } 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 29047c478bd9Sstevel@tonic-gate } 29057c478bd9Sstevel@tonic-gate 2906843e1988Sjohnlev int 29077c478bd9Sstevel@tonic-gate add_boot_entry(menu_t *mp, 29087c478bd9Sstevel@tonic-gate char *title, 2909eb2bd662Svikram char *findroot, 29107c478bd9Sstevel@tonic-gate char *kernel, 2911843e1988Sjohnlev char *mod_kernel, 29127c478bd9Sstevel@tonic-gate char *module) 29137c478bd9Sstevel@tonic-gate { 2914eb2bd662Svikram int lineNum; 2915eb2bd662Svikram int entryNum; 2916eb2bd662Svikram char linebuf[BAM_MAXLINE]; 2917eb2bd662Svikram menu_cmd_t k_cmd; 2918eb2bd662Svikram menu_cmd_t m_cmd; 2919eb2bd662Svikram const char *fcn = "add_boot_entry()"; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate assert(mp); 29227c478bd9Sstevel@tonic-gate 2923eb2bd662Svikram INJECT_ERROR1("ADD_BOOT_ENTRY_FINDROOT_NULL", findroot = NULL); 2924eb2bd662Svikram if (findroot == NULL) { 2925eb2bd662Svikram bam_error(NULL_FINDROOT); 2926eb2bd662Svikram return (BAM_ERROR); 2927eb2bd662Svikram } 2928eb2bd662Svikram 29297c478bd9Sstevel@tonic-gate if (title == NULL) { 2930ee3b8144Sszhou title = "Solaris"; /* default to Solaris */ 29317c478bd9Sstevel@tonic-gate } 29327c478bd9Sstevel@tonic-gate if (kernel == NULL) { 29337c478bd9Sstevel@tonic-gate bam_error(SUBOPT_MISS, menu_cmds[KERNEL_CMD]); 29347c478bd9Sstevel@tonic-gate return (BAM_ERROR); 29357c478bd9Sstevel@tonic-gate } 29367c478bd9Sstevel@tonic-gate if (module == NULL) { 2937ae115bc7Smrj if (bam_direct != BAM_DIRECT_DBOOT) { 2938ae115bc7Smrj bam_error(SUBOPT_MISS, menu_cmds[MODULE_CMD]); 2939ae115bc7Smrj return (BAM_ERROR); 2940ae115bc7Smrj } 2941ae115bc7Smrj 2942ae115bc7Smrj /* Figure the commands out from the kernel line */ 2943ae115bc7Smrj if (strstr(kernel, "$ISADIR") != NULL) { 2944ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE; 2945ae115bc7Smrj k_cmd = KERNEL_DOLLAR_CMD; 2946ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 2947ae115bc7Smrj } else if (strstr(kernel, "amd64") != NULL) { 2948ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE_64; 2949ae115bc7Smrj k_cmd = KERNEL_CMD; 2950ae115bc7Smrj m_cmd = MODULE_CMD; 2951ae115bc7Smrj } else { 2952ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE_32; 2953ae115bc7Smrj k_cmd = KERNEL_CMD; 2954ae115bc7Smrj m_cmd = MODULE_CMD; 2955ae115bc7Smrj } 2956ae115bc7Smrj } else if ((bam_direct == BAM_DIRECT_DBOOT) && 2957ae115bc7Smrj (strstr(kernel, "$ISADIR") != NULL)) { 2958ae115bc7Smrj /* 2959ae115bc7Smrj * If it's a non-failsafe dboot kernel, use the "kernel$" 2960ae115bc7Smrj * command. Otherwise, use "kernel". 2961ae115bc7Smrj */ 2962ae115bc7Smrj k_cmd = KERNEL_DOLLAR_CMD; 2963ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 2964ae115bc7Smrj } else { 2965ae115bc7Smrj k_cmd = KERNEL_CMD; 2966ae115bc7Smrj m_cmd = MODULE_CMD; 29677c478bd9Sstevel@tonic-gate } 29687c478bd9Sstevel@tonic-gate 29697c478bd9Sstevel@tonic-gate if (mp->start) { 29707c478bd9Sstevel@tonic-gate lineNum = mp->end->lineNum; 29717c478bd9Sstevel@tonic-gate entryNum = mp->end->entryNum; 29727c478bd9Sstevel@tonic-gate } else { 29737c478bd9Sstevel@tonic-gate lineNum = LINE_INIT; 29747c478bd9Sstevel@tonic-gate entryNum = ENTRY_INIT; 29757c478bd9Sstevel@tonic-gate } 29767c478bd9Sstevel@tonic-gate 29777c478bd9Sstevel@tonic-gate /* 29787c478bd9Sstevel@tonic-gate * No separator for comment (HDR/FTR) commands 29797c478bd9Sstevel@tonic-gate * The syntax for comments is #<comment> 29807c478bd9Sstevel@tonic-gate */ 29817c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 2982ae115bc7Smrj menu_cmds[COMMENT_CMD], BAM_BOOTADM_HDR); 29838c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29847c478bd9Sstevel@tonic-gate 29857c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 29867c478bd9Sstevel@tonic-gate menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 29878c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29887c478bd9Sstevel@tonic-gate 2989eb2bd662Svikram (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 2990eb2bd662Svikram menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot); 2991eb2bd662Svikram line_parser(mp, linebuf, &lineNum, &entryNum); 2992eb2bd662Svikram BAM_DPRINTF((D_ADD_FINDROOT_NUM, fcn, lineNum, entryNum)); 29937c478bd9Sstevel@tonic-gate 29947c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 2995ae115bc7Smrj menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel); 29968c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29977c478bd9Sstevel@tonic-gate 2998843e1988Sjohnlev if (mod_kernel != NULL) { 2999843e1988Sjohnlev (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 3000843e1988Sjohnlev menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel); 3001843e1988Sjohnlev line_parser(mp, linebuf, &lineNum, &entryNum); 3002843e1988Sjohnlev } 3003843e1988Sjohnlev 30047c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 3005ae115bc7Smrj menu_cmds[m_cmd], menu_cmds[SEP_CMD], module); 30068c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 30077c478bd9Sstevel@tonic-gate 30087c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 3009ae115bc7Smrj menu_cmds[COMMENT_CMD], BAM_BOOTADM_FTR); 30108c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate return (entryNum); 30137c478bd9Sstevel@tonic-gate } 30147c478bd9Sstevel@tonic-gate 30157c478bd9Sstevel@tonic-gate static error_t 30167c478bd9Sstevel@tonic-gate do_delete(menu_t *mp, int entryNum) 30177c478bd9Sstevel@tonic-gate { 3018eb2bd662Svikram line_t *lp; 3019eb2bd662Svikram line_t *freed; 3020eb2bd662Svikram entry_t *ent; 3021eb2bd662Svikram entry_t *tmp; 3022eb2bd662Svikram int deleted; 3023eb2bd662Svikram const char *fcn = "do_delete()"; 30247c478bd9Sstevel@tonic-gate 30257c478bd9Sstevel@tonic-gate assert(entryNum != ENTRY_INIT); 30267c478bd9Sstevel@tonic-gate 3027eb2bd662Svikram tmp = NULL; 3028eb2bd662Svikram 30298c1b6884Sszhou ent = mp->entries; 30308c1b6884Sszhou while (ent) { 30318c1b6884Sszhou lp = ent->start; 30328c1b6884Sszhou /* check entry number and make sure it's a bootadm entry */ 30338c1b6884Sszhou if (lp->flags != BAM_COMMENT || 3034ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_HDR) != 0 || 30358c1b6884Sszhou (entryNum != ALL_ENTRIES && lp->entryNum != entryNum)) { 30368c1b6884Sszhou ent = ent->next; 30377c478bd9Sstevel@tonic-gate continue; 30387c478bd9Sstevel@tonic-gate } 30397c478bd9Sstevel@tonic-gate 30408c1b6884Sszhou /* free the entry content */ 30418c1b6884Sszhou do { 30428c1b6884Sszhou freed = lp; 30438c1b6884Sszhou lp = lp->next; /* prev stays the same */ 3044eb2bd662Svikram BAM_DPRINTF((D_FREEING_LINE, fcn, freed->lineNum)); 30458c1b6884Sszhou unlink_line(mp, freed); 30468c1b6884Sszhou line_free(freed); 30478c1b6884Sszhou } while (freed != ent->end); 30488c1b6884Sszhou 30498c1b6884Sszhou /* free the entry_t structure */ 3050eb2bd662Svikram assert(tmp == NULL); 30518c1b6884Sszhou tmp = ent; 30528c1b6884Sszhou ent = ent->next; 30538c1b6884Sszhou if (tmp->prev) 30548c1b6884Sszhou tmp->prev->next = ent; 30557c478bd9Sstevel@tonic-gate else 30568c1b6884Sszhou mp->entries = ent; 30578c1b6884Sszhou if (ent) 30588c1b6884Sszhou ent->prev = tmp->prev; 3059eb2bd662Svikram BAM_DPRINTF((D_FREEING_ENTRY, fcn, tmp->entryNum)); 3060eb2bd662Svikram free(tmp); 3061eb2bd662Svikram tmp = NULL; 30627c478bd9Sstevel@tonic-gate deleted = 1; 30637c478bd9Sstevel@tonic-gate } 30647c478bd9Sstevel@tonic-gate 3065eb2bd662Svikram assert(tmp == NULL); 3066eb2bd662Svikram 30677c478bd9Sstevel@tonic-gate if (!deleted && entryNum != ALL_ENTRIES) { 30687c478bd9Sstevel@tonic-gate bam_error(NO_BOOTADM_MATCH); 30697c478bd9Sstevel@tonic-gate return (BAM_ERROR); 30707c478bd9Sstevel@tonic-gate } 30717c478bd9Sstevel@tonic-gate 307240541d5dSvikram /* 307340541d5dSvikram * Now that we have deleted an entry, update 307440541d5dSvikram * the entry numbering and the default cmd. 307540541d5dSvikram */ 307640541d5dSvikram update_numbering(mp); 307740541d5dSvikram 30787c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 30797c478bd9Sstevel@tonic-gate } 30807c478bd9Sstevel@tonic-gate 30817c478bd9Sstevel@tonic-gate static error_t 3082eb2bd662Svikram delete_all_entries(menu_t *mp, char *dummy, char *opt) 30837c478bd9Sstevel@tonic-gate { 30847c478bd9Sstevel@tonic-gate assert(mp); 3085eb2bd662Svikram assert(dummy == NULL); 30867c478bd9Sstevel@tonic-gate assert(opt == NULL); 30877c478bd9Sstevel@tonic-gate 3088eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY0, "delete_all_entries")); 3089eb2bd662Svikram 30907c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 3091eb2bd662Svikram bam_print(EMPTY_MENU); 30927c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 30937c478bd9Sstevel@tonic-gate } 30947c478bd9Sstevel@tonic-gate 30957c478bd9Sstevel@tonic-gate if (do_delete(mp, ALL_ENTRIES) != BAM_SUCCESS) { 30967c478bd9Sstevel@tonic-gate return (BAM_ERROR); 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate 30997c478bd9Sstevel@tonic-gate return (BAM_WRITE); 31007c478bd9Sstevel@tonic-gate } 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate static FILE * 3103eb2bd662Svikram create_diskmap(char *osroot) 31047c478bd9Sstevel@tonic-gate { 31057c478bd9Sstevel@tonic-gate FILE *fp; 31067c478bd9Sstevel@tonic-gate char cmd[PATH_MAX]; 3107eb2bd662Svikram const char *fcn = "create_diskmap()"; 31087c478bd9Sstevel@tonic-gate 31097c478bd9Sstevel@tonic-gate /* make sure we have a map file */ 31107c478bd9Sstevel@tonic-gate fp = fopen(GRUBDISK_MAP, "r"); 31117c478bd9Sstevel@tonic-gate if (fp == NULL) { 31127c478bd9Sstevel@tonic-gate (void) snprintf(cmd, sizeof (cmd), 3113eb2bd662Svikram "%s/%s > /dev/null", osroot, CREATE_DISKMAP); 3114eb2bd662Svikram if (exec_cmd(cmd, NULL) != 0) 3115eb2bd662Svikram return (NULL); 31167c478bd9Sstevel@tonic-gate fp = fopen(GRUBDISK_MAP, "r"); 3117eb2bd662Svikram INJECT_ERROR1("DISKMAP_CREATE_FAIL", fp = NULL); 3118eb2bd662Svikram if (fp) { 3119eb2bd662Svikram BAM_DPRINTF((D_CREATED_DISKMAP, fcn, GRUBDISK_MAP)); 3120eb2bd662Svikram } else { 3121eb2bd662Svikram BAM_DPRINTF((D_CREATE_DISKMAP_FAIL, fcn, GRUBDISK_MAP)); 3122eb2bd662Svikram } 31237c478bd9Sstevel@tonic-gate } 31247c478bd9Sstevel@tonic-gate return (fp); 31257c478bd9Sstevel@tonic-gate } 31267c478bd9Sstevel@tonic-gate 31277c478bd9Sstevel@tonic-gate #define SECTOR_SIZE 512 31287c478bd9Sstevel@tonic-gate 31297c478bd9Sstevel@tonic-gate static int 31307c478bd9Sstevel@tonic-gate get_partition(char *device) 31317c478bd9Sstevel@tonic-gate { 31327c478bd9Sstevel@tonic-gate int i, fd, is_pcfs, partno = -1; 31337c478bd9Sstevel@tonic-gate struct mboot *mboot; 31347c478bd9Sstevel@tonic-gate char boot_sect[SECTOR_SIZE]; 31357c478bd9Sstevel@tonic-gate char *wholedisk, *slice; 31367c478bd9Sstevel@tonic-gate 31377c478bd9Sstevel@tonic-gate /* form whole disk (p0) */ 31387c478bd9Sstevel@tonic-gate slice = device + strlen(device) - 2; 31397c478bd9Sstevel@tonic-gate is_pcfs = (*slice != 's'); 31407c478bd9Sstevel@tonic-gate if (!is_pcfs) 31417c478bd9Sstevel@tonic-gate *slice = '\0'; 31427c478bd9Sstevel@tonic-gate wholedisk = s_calloc(1, strlen(device) + 3); 31437c478bd9Sstevel@tonic-gate (void) snprintf(wholedisk, strlen(device) + 3, "%sp0", device); 31447c478bd9Sstevel@tonic-gate if (!is_pcfs) 31457c478bd9Sstevel@tonic-gate *slice = 's'; 31467c478bd9Sstevel@tonic-gate 31477c478bd9Sstevel@tonic-gate /* read boot sector */ 31487c478bd9Sstevel@tonic-gate fd = open(wholedisk, O_RDONLY); 31497c478bd9Sstevel@tonic-gate free(wholedisk); 31507c478bd9Sstevel@tonic-gate if (fd == -1 || read(fd, boot_sect, SECTOR_SIZE) != SECTOR_SIZE) { 31517c478bd9Sstevel@tonic-gate return (partno); 31527c478bd9Sstevel@tonic-gate } 31537c478bd9Sstevel@tonic-gate (void) close(fd); 31547c478bd9Sstevel@tonic-gate 31557c478bd9Sstevel@tonic-gate /* parse fdisk table */ 31567c478bd9Sstevel@tonic-gate mboot = (struct mboot *)((void *)boot_sect); 31577c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 31587c478bd9Sstevel@tonic-gate struct ipart *part = 31597c478bd9Sstevel@tonic-gate (struct ipart *)(uintptr_t)mboot->parts + i; 31607c478bd9Sstevel@tonic-gate if (is_pcfs) { /* looking for solaris boot part */ 31617c478bd9Sstevel@tonic-gate if (part->systid == 0xbe) { 31627c478bd9Sstevel@tonic-gate partno = i; 31637c478bd9Sstevel@tonic-gate break; 31647c478bd9Sstevel@tonic-gate } 31657c478bd9Sstevel@tonic-gate } else { /* look for solaris partition, old and new */ 31667c478bd9Sstevel@tonic-gate if (part->systid == SUNIXOS || 31677c478bd9Sstevel@tonic-gate part->systid == SUNIXOS2) { 31687c478bd9Sstevel@tonic-gate partno = i; 31697c478bd9Sstevel@tonic-gate break; 31707c478bd9Sstevel@tonic-gate } 31717c478bd9Sstevel@tonic-gate } 31727c478bd9Sstevel@tonic-gate } 31737c478bd9Sstevel@tonic-gate return (partno); 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate 3176eb2bd662Svikram char * 3177eb2bd662Svikram get_grubroot(char *osroot, char *osdev, char *menu_root) 31787c478bd9Sstevel@tonic-gate { 3179eb2bd662Svikram char *grubroot; /* (hd#,#,#) */ 3180eb2bd662Svikram char *slice; 3181eb2bd662Svikram char *grubhd; 3182eb2bd662Svikram int fdiskpart; 3183eb2bd662Svikram int found = 0; 3184eb2bd662Svikram char *devname; 3185eb2bd662Svikram char *ctdname = strstr(osdev, "dsk/"); 3186eb2bd662Svikram char linebuf[PATH_MAX]; 3187eb2bd662Svikram FILE *fp; 3188eb2bd662Svikram const char *fcn = "get_grubroot()"; 3189eb2bd662Svikram 3190eb2bd662Svikram INJECT_ERROR1("GRUBROOT_INVALID_OSDEV", ctdname = NULL); 3191eb2bd662Svikram if (ctdname == NULL) { 3192eb2bd662Svikram bam_error(INVALID_DEV_DSK, osdev); 3193eb2bd662Svikram return (NULL); 3194eb2bd662Svikram } 31957c478bd9Sstevel@tonic-gate 3196eb2bd662Svikram if (menu_root && !menu_on_bootdisk(osroot, menu_root)) { 3197eb2bd662Svikram /* menu bears no resemblance to our reality */ 3198eb2bd662Svikram bam_error(CANNOT_GRUBROOT_BOOTDISK, fcn, osdev); 31997c478bd9Sstevel@tonic-gate return (NULL); 3200eb2bd662Svikram } 32017c478bd9Sstevel@tonic-gate 32027c478bd9Sstevel@tonic-gate ctdname += strlen("dsk/"); 32037c478bd9Sstevel@tonic-gate slice = strrchr(ctdname, 's'); 32047c478bd9Sstevel@tonic-gate if (slice) 32057c478bd9Sstevel@tonic-gate *slice = '\0'; 32067c478bd9Sstevel@tonic-gate 3207eb2bd662Svikram fp = create_diskmap(osroot); 3208eb2bd662Svikram if (fp == NULL) { 3209eb2bd662Svikram bam_error(DISKMAP_FAIL, osroot); 3210eb2bd662Svikram return (NULL); 3211eb2bd662Svikram } 3212eb2bd662Svikram 32137c478bd9Sstevel@tonic-gate rewind(fp); 32147c478bd9Sstevel@tonic-gate while (s_fgets(linebuf, sizeof (linebuf), fp) != NULL) { 32157c478bd9Sstevel@tonic-gate grubhd = strtok(linebuf, " \t\n"); 32167c478bd9Sstevel@tonic-gate if (grubhd) 32177c478bd9Sstevel@tonic-gate devname = strtok(NULL, " \t\n"); 32187c478bd9Sstevel@tonic-gate else 32197c478bd9Sstevel@tonic-gate devname = NULL; 32207c478bd9Sstevel@tonic-gate if (devname && strcmp(devname, ctdname) == 0) { 32217c478bd9Sstevel@tonic-gate found = 1; 32227c478bd9Sstevel@tonic-gate break; 32237c478bd9Sstevel@tonic-gate } 32247c478bd9Sstevel@tonic-gate } 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate if (slice) 32277c478bd9Sstevel@tonic-gate *slice = 's'; 32287c478bd9Sstevel@tonic-gate 3229eb2bd662Svikram (void) fclose(fp); 3230eb2bd662Svikram fp = NULL; 3231eb2bd662Svikram 3232eb2bd662Svikram INJECT_ERROR1("GRUBROOT_BIOSDEV_FAIL", found = 0); 32337c478bd9Sstevel@tonic-gate if (found == 0) { 3234eb2bd662Svikram bam_error(BIOSDEV_FAIL, osdev); 3235eb2bd662Svikram return (NULL); 32367c478bd9Sstevel@tonic-gate } 32377c478bd9Sstevel@tonic-gate 3238eb2bd662Svikram fdiskpart = get_partition(osdev); 3239eb2bd662Svikram INJECT_ERROR1("GRUBROOT_FDISK_FAIL", fdiskpart = -1); 3240eb2bd662Svikram if (fdiskpart == -1) { 3241eb2bd662Svikram bam_error(FDISKPART_FAIL, osdev); 32427c478bd9Sstevel@tonic-gate return (NULL); 3243eb2bd662Svikram } 32447c478bd9Sstevel@tonic-gate 3245eb2bd662Svikram grubroot = s_calloc(1, 10); 32467c478bd9Sstevel@tonic-gate if (slice) { 3247eb2bd662Svikram (void) snprintf(grubroot, 10, "(hd%s,%d,%c)", 32487c478bd9Sstevel@tonic-gate grubhd, fdiskpart, slice[1] + 'a' - '0'); 32497c478bd9Sstevel@tonic-gate } else 3250eb2bd662Svikram (void) snprintf(grubroot, 10, "(hd%s,%d)", 32517c478bd9Sstevel@tonic-gate grubhd, fdiskpart); 32527c478bd9Sstevel@tonic-gate 3253eb2bd662Svikram assert(fp == NULL); 3254eb2bd662Svikram assert(strncmp(grubroot, "(hd", strlen("(hd")) == 0); 3255eb2bd662Svikram return (grubroot); 32567c478bd9Sstevel@tonic-gate } 32577c478bd9Sstevel@tonic-gate 3258ee3b8144Sszhou static char * 3259eb2bd662Svikram find_primary_common(char *mntpt, char *fstype) 32607c478bd9Sstevel@tonic-gate { 3261eb2bd662Svikram char signdir[PATH_MAX]; 3262eb2bd662Svikram char tmpsign[MAXNAMELEN + 1]; 3263eb2bd662Svikram char *lu; 3264eb2bd662Svikram char *ufs; 3265eb2bd662Svikram char *zfs; 3266eb2bd662Svikram DIR *dirp = NULL; 3267eb2bd662Svikram struct dirent *entp; 3268eb2bd662Svikram struct stat sb; 3269eb2bd662Svikram const char *fcn = "find_primary_common()"; 32707c478bd9Sstevel@tonic-gate 3271eb2bd662Svikram (void) snprintf(signdir, sizeof (signdir), "%s/%s", 3272eb2bd662Svikram mntpt, GRUBSIGN_DIR); 32737c478bd9Sstevel@tonic-gate 3274eb2bd662Svikram if (stat(signdir, &sb) == -1) { 3275eb2bd662Svikram BAM_DPRINTF((D_NO_SIGNDIR, fcn, signdir)); 3276ee3b8144Sszhou return (NULL); 3277eb2bd662Svikram } 32787c478bd9Sstevel@tonic-gate 3279eb2bd662Svikram dirp = opendir(signdir); 3280eb2bd662Svikram INJECT_ERROR1("SIGNDIR_OPENDIR_FAIL", dirp = NULL); 3281eb2bd662Svikram if (dirp == NULL) { 3282eb2bd662Svikram bam_error(OPENDIR_FAILED, signdir, strerror(errno)); 3283eb2bd662Svikram return (NULL); 32847c478bd9Sstevel@tonic-gate } 3285eb2bd662Svikram 3286eb2bd662Svikram ufs = zfs = lu = NULL; 3287eb2bd662Svikram 3288eb2bd662Svikram while (entp = readdir(dirp)) { 3289eb2bd662Svikram if (strcmp(entp->d_name, ".") == 0 || 3290eb2bd662Svikram strcmp(entp->d_name, "..") == 0) 3291eb2bd662Svikram continue; 3292eb2bd662Svikram 3293eb2bd662Svikram (void) snprintf(tmpsign, sizeof (tmpsign), "%s", entp->d_name); 3294eb2bd662Svikram 3295eb2bd662Svikram if (lu == NULL && 3296eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_LU_PREFIX, 3297eb2bd662Svikram strlen(GRUBSIGN_LU_PREFIX)) == 0) { 3298eb2bd662Svikram lu = s_strdup(tmpsign); 3299eb2bd662Svikram } 3300eb2bd662Svikram 3301eb2bd662Svikram if (ufs == NULL && 3302eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 3303eb2bd662Svikram strlen(GRUBSIGN_UFS_PREFIX)) == 0) { 3304eb2bd662Svikram ufs = s_strdup(tmpsign); 3305eb2bd662Svikram } 3306eb2bd662Svikram 3307eb2bd662Svikram if (zfs == NULL && 3308eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX, 3309eb2bd662Svikram strlen(GRUBSIGN_ZFS_PREFIX)) == 0) { 3310eb2bd662Svikram zfs = s_strdup(tmpsign); 3311eb2bd662Svikram } 3312eb2bd662Svikram } 3313eb2bd662Svikram 3314eb2bd662Svikram BAM_DPRINTF((D_EXIST_PRIMARY_SIGNS, fcn, 3315eb2bd662Svikram zfs ? zfs : "NULL", 3316eb2bd662Svikram ufs ? ufs : "NULL", 3317eb2bd662Svikram lu ? lu : "NULL")); 3318eb2bd662Svikram 3319eb2bd662Svikram if (dirp) { 3320eb2bd662Svikram (void) closedir(dirp); 3321eb2bd662Svikram dirp = NULL; 3322eb2bd662Svikram } 3323eb2bd662Svikram 3324eb2bd662Svikram if (strcmp(fstype, "ufs") == 0 && zfs) { 3325eb2bd662Svikram bam_error(SIGN_FSTYPE_MISMATCH, zfs, "ufs"); 3326eb2bd662Svikram free(zfs); 3327eb2bd662Svikram zfs = NULL; 3328eb2bd662Svikram } else if (strcmp(fstype, "zfs") == 0 && ufs) { 3329eb2bd662Svikram bam_error(SIGN_FSTYPE_MISMATCH, ufs, "zfs"); 3330eb2bd662Svikram free(ufs); 3331eb2bd662Svikram ufs = NULL; 3332eb2bd662Svikram } 3333eb2bd662Svikram 3334eb2bd662Svikram assert(dirp == NULL); 3335eb2bd662Svikram 3336eb2bd662Svikram /* For now, we let Live Upgrade take care of its signature itself */ 3337eb2bd662Svikram if (lu) { 3338eb2bd662Svikram BAM_DPRINTF((D_FREEING_LU_SIGNS, fcn, lu)); 3339eb2bd662Svikram free(lu); 3340eb2bd662Svikram lu = NULL; 3341eb2bd662Svikram } 3342eb2bd662Svikram 3343eb2bd662Svikram return (zfs ? zfs : ufs); 3344eb2bd662Svikram } 3345eb2bd662Svikram 3346eb2bd662Svikram static char * 3347eb2bd662Svikram find_backup_common(char *mntpt, char *fstype) 3348eb2bd662Svikram { 3349eb2bd662Svikram FILE *bfp = NULL; 3350eb2bd662Svikram char tmpsign[MAXNAMELEN + 1]; 3351eb2bd662Svikram char backup[PATH_MAX]; 3352eb2bd662Svikram char *ufs; 3353eb2bd662Svikram char *zfs; 3354eb2bd662Svikram char *lu; 3355eb2bd662Svikram int error; 3356eb2bd662Svikram const char *fcn = "find_backup_common()"; 3357eb2bd662Svikram 3358eb2bd662Svikram /* 3359eb2bd662Svikram * We didn't find it in the primary directory. 3360eb2bd662Svikram * Look at the backup 3361eb2bd662Svikram */ 3362eb2bd662Svikram (void) snprintf(backup, sizeof (backup), "%s%s", 3363eb2bd662Svikram mntpt, GRUBSIGN_BACKUP); 3364eb2bd662Svikram 3365eb2bd662Svikram bfp = fopen(backup, "r"); 3366eb2bd662Svikram if (bfp == NULL) { 3367eb2bd662Svikram error = errno; 3368eb2bd662Svikram if (bam_verbose) { 3369eb2bd662Svikram bam_error(OPEN_FAIL, backup, strerror(error)); 3370eb2bd662Svikram } 3371eb2bd662Svikram BAM_DPRINTF((D_OPEN_FAIL, fcn, backup, strerror(error))); 3372eb2bd662Svikram return (NULL); 3373eb2bd662Svikram } 3374eb2bd662Svikram 3375eb2bd662Svikram ufs = zfs = lu = NULL; 3376eb2bd662Svikram 3377eb2bd662Svikram while (s_fgets(tmpsign, sizeof (tmpsign), bfp) != NULL) { 3378eb2bd662Svikram 3379eb2bd662Svikram if (lu == NULL && 3380eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_LU_PREFIX, 3381eb2bd662Svikram strlen(GRUBSIGN_LU_PREFIX)) == 0) { 3382eb2bd662Svikram lu = s_strdup(tmpsign); 3383eb2bd662Svikram } 3384eb2bd662Svikram 3385eb2bd662Svikram if (ufs == NULL && 3386eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 3387eb2bd662Svikram strlen(GRUBSIGN_UFS_PREFIX)) == 0) { 3388eb2bd662Svikram ufs = s_strdup(tmpsign); 3389eb2bd662Svikram } 3390eb2bd662Svikram 3391eb2bd662Svikram if (zfs == NULL && 3392eb2bd662Svikram strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX, 3393eb2bd662Svikram strlen(GRUBSIGN_ZFS_PREFIX)) == 0) { 3394eb2bd662Svikram zfs = s_strdup(tmpsign); 3395eb2bd662Svikram } 3396eb2bd662Svikram } 3397eb2bd662Svikram 3398eb2bd662Svikram BAM_DPRINTF((D_EXIST_BACKUP_SIGNS, fcn, 3399eb2bd662Svikram zfs ? zfs : "NULL", 3400eb2bd662Svikram ufs ? ufs : "NULL", 3401eb2bd662Svikram lu ? lu : "NULL")); 3402eb2bd662Svikram 3403eb2bd662Svikram if (bfp) { 3404eb2bd662Svikram (void) fclose(bfp); 3405eb2bd662Svikram bfp = NULL; 3406eb2bd662Svikram } 3407eb2bd662Svikram 3408eb2bd662Svikram if (strcmp(fstype, "ufs") == 0 && zfs) { 3409eb2bd662Svikram bam_error(SIGN_FSTYPE_MISMATCH, zfs, "ufs"); 3410eb2bd662Svikram free(zfs); 3411eb2bd662Svikram zfs = NULL; 3412eb2bd662Svikram } else if (strcmp(fstype, "zfs") == 0 && ufs) { 3413eb2bd662Svikram bam_error(SIGN_FSTYPE_MISMATCH, ufs, "zfs"); 3414eb2bd662Svikram free(ufs); 3415eb2bd662Svikram ufs = NULL; 3416eb2bd662Svikram } 3417eb2bd662Svikram 3418eb2bd662Svikram assert(bfp == NULL); 3419eb2bd662Svikram 3420eb2bd662Svikram /* For now, we let Live Upgrade take care of its signature itself */ 3421eb2bd662Svikram if (lu) { 3422eb2bd662Svikram BAM_DPRINTF((D_FREEING_LU_SIGNS, fcn, lu)); 3423eb2bd662Svikram free(lu); 3424eb2bd662Svikram lu = NULL; 3425eb2bd662Svikram } 3426eb2bd662Svikram 3427eb2bd662Svikram return (zfs ? zfs : ufs); 3428eb2bd662Svikram } 3429eb2bd662Svikram 3430eb2bd662Svikram static char * 3431eb2bd662Svikram find_ufs_existing(char *osroot) 3432eb2bd662Svikram { 3433eb2bd662Svikram char *sign; 3434eb2bd662Svikram const char *fcn = "find_ufs_existing()"; 3435eb2bd662Svikram 3436eb2bd662Svikram sign = find_primary_common(osroot, "ufs"); 3437eb2bd662Svikram if (sign == NULL) { 3438eb2bd662Svikram sign = find_backup_common(osroot, "ufs"); 3439eb2bd662Svikram BAM_DPRINTF((D_EXIST_BACKUP_SIGN, fcn, sign ? sign : "NULL")); 3440eb2bd662Svikram } else { 3441eb2bd662Svikram BAM_DPRINTF((D_EXIST_PRIMARY_SIGN, fcn, sign)); 3442eb2bd662Svikram } 3443eb2bd662Svikram 3444eb2bd662Svikram return (sign); 34457c478bd9Sstevel@tonic-gate } 34467c478bd9Sstevel@tonic-gate 3447ae115bc7Smrj char * 3448eb2bd662Svikram get_mountpoint(char *special, char *fstype) 34497c478bd9Sstevel@tonic-gate { 3450eb2bd662Svikram FILE *mntfp; 3451eb2bd662Svikram struct mnttab mp = {0}; 3452eb2bd662Svikram struct mnttab mpref = {0}; 3453eb2bd662Svikram int error; 3454eb2bd662Svikram int ret; 3455eb2bd662Svikram const char *fcn = "get_mountpoint()"; 3456eb2bd662Svikram 3457eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, special, fstype)); 34587c478bd9Sstevel@tonic-gate 34597c478bd9Sstevel@tonic-gate mntfp = fopen(MNTTAB, "r"); 3460eb2bd662Svikram error = errno; 3461eb2bd662Svikram INJECT_ERROR1("MNTTAB_ERR_GET_MNTPT", mntfp = NULL); 34627c478bd9Sstevel@tonic-gate if (mntfp == NULL) { 3463eb2bd662Svikram bam_error(OPEN_FAIL, MNTTAB, strerror(error)); 3464eb2bd662Svikram return (NULL); 34657c478bd9Sstevel@tonic-gate } 34667c478bd9Sstevel@tonic-gate 3467eb2bd662Svikram mpref.mnt_special = special; 3468eb2bd662Svikram mpref.mnt_fstype = fstype; 3469eb2bd662Svikram 3470eb2bd662Svikram ret = getmntany(mntfp, &mp, &mpref); 3471eb2bd662Svikram INJECT_ERROR1("GET_MOUNTPOINT_MNTANY", ret = 1); 3472eb2bd662Svikram if (ret != 0) { 34737c478bd9Sstevel@tonic-gate (void) fclose(mntfp); 3474eb2bd662Svikram BAM_DPRINTF((D_NO_MNTPT, fcn, special, fstype)); 34757c478bd9Sstevel@tonic-gate return (NULL); 34767c478bd9Sstevel@tonic-gate } 34777c478bd9Sstevel@tonic-gate (void) fclose(mntfp); 34787c478bd9Sstevel@tonic-gate 3479eb2bd662Svikram assert(mp.mnt_mountp); 3480eb2bd662Svikram 3481eb2bd662Svikram BAM_DPRINTF((D_GET_MOUNTPOINT_RET, fcn, special, mp.mnt_mountp)); 3482eb2bd662Svikram 3483eb2bd662Svikram return (s_strdup(mp.mnt_mountp)); 34847c478bd9Sstevel@tonic-gate } 34857c478bd9Sstevel@tonic-gate 3486eb2bd662Svikram /* 3487eb2bd662Svikram * Mounts a "legacy" top dataset (if needed) 3488eb2bd662Svikram * Returns: The mountpoint of the legacy top dataset or NULL on error 3489eb2bd662Svikram * mnted returns one of the above values defined for zfs_mnted_t 3490eb2bd662Svikram */ 3491eb2bd662Svikram static char * 3492eb2bd662Svikram mount_legacy_dataset(char *pool, zfs_mnted_t *mnted) 34937c478bd9Sstevel@tonic-gate { 3494eb2bd662Svikram char cmd[PATH_MAX]; 3495eb2bd662Svikram char tmpmnt[PATH_MAX]; 3496eb2bd662Svikram filelist_t flist = {0}; 3497eb2bd662Svikram char *is_mounted; 3498eb2bd662Svikram struct stat sb; 3499eb2bd662Svikram int ret; 3500eb2bd662Svikram const char *fcn = "mount_legacy_dataset()"; 35017c478bd9Sstevel@tonic-gate 3502eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, pool)); 3503eb2bd662Svikram 3504eb2bd662Svikram *mnted = ZFS_MNT_ERROR; 3505eb2bd662Svikram 3506eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3507eb2bd662Svikram "/sbin/zfs get -Ho value mounted %s", 3508eb2bd662Svikram pool); 3509eb2bd662Svikram 3510eb2bd662Svikram ret = exec_cmd(cmd, &flist); 3511eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_CMD", ret = 1); 3512eb2bd662Svikram if (ret != 0) { 3513eb2bd662Svikram bam_error(ZFS_MNTED_FAILED, pool); 3514eb2bd662Svikram return (NULL); 3515eb2bd662Svikram } 3516eb2bd662Svikram 3517eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_OUT", flist.head = NULL); 3518eb2bd662Svikram if ((flist.head == NULL) || (flist.head != flist.tail)) { 3519eb2bd662Svikram bam_error(BAD_ZFS_MNTED, pool); 3520eb2bd662Svikram filelist_free(&flist); 35217c478bd9Sstevel@tonic-gate return (NULL); 35227c478bd9Sstevel@tonic-gate } 3523eb2bd662Svikram 3524eb2bd662Svikram is_mounted = strtok(flist.head->line, " \t\n"); 3525eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_YES", is_mounted = "yes"); 3526eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_NO", is_mounted = "no"); 3527eb2bd662Svikram if (strcmp(is_mounted, "no") != 0) { 3528eb2bd662Svikram filelist_free(&flist); 3529eb2bd662Svikram *mnted = LEGACY_ALREADY; 3530eb2bd662Svikram /* get_mountpoint returns a strdup'ed string */ 3531eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_ALREADY, fcn, pool)); 3532eb2bd662Svikram return (get_mountpoint(pool, "zfs")); 3533eb2bd662Svikram } 3534eb2bd662Svikram 3535eb2bd662Svikram filelist_free(&flist); 3536eb2bd662Svikram 3537eb2bd662Svikram /* 3538eb2bd662Svikram * legacy top dataset is not mounted. Mount it now 3539eb2bd662Svikram * First create a mountpoint. 3540eb2bd662Svikram */ 3541eb2bd662Svikram (void) snprintf(tmpmnt, sizeof (tmpmnt), "%s.%d", 3542eb2bd662Svikram ZFS_LEGACY_MNTPT, getpid()); 3543eb2bd662Svikram 3544eb2bd662Svikram ret = stat(tmpmnt, &sb); 3545eb2bd662Svikram if (ret == -1) { 3546eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MNTPT_ABS, fcn, pool, tmpmnt)); 3547eb2bd662Svikram ret = mkdirp(tmpmnt, 0755); 3548eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_LEG_MNTPT_MKDIRP", ret = -1); 3549eb2bd662Svikram if (ret == -1) { 3550eb2bd662Svikram bam_error(MKDIR_FAILED, tmpmnt, strerror(errno)); 3551eb2bd662Svikram return (NULL); 3552eb2bd662Svikram } 3553eb2bd662Svikram } else { 3554eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MNTPT_PRES, fcn, pool, tmpmnt)); 3555eb2bd662Svikram } 3556eb2bd662Svikram 3557eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3558eb2bd662Svikram "/sbin/mount -F zfs %s %s", 3559eb2bd662Svikram pool, tmpmnt); 3560eb2bd662Svikram 3561eb2bd662Svikram ret = exec_cmd(cmd, NULL); 3562eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_LEG_MOUNT_CMD", ret = 1); 3563eb2bd662Svikram if (ret != 0) { 3564eb2bd662Svikram bam_error(ZFS_MOUNT_FAILED, pool); 3565eb2bd662Svikram (void) rmdir(tmpmnt); 3566eb2bd662Svikram return (NULL); 3567eb2bd662Svikram } 3568eb2bd662Svikram 3569eb2bd662Svikram *mnted = LEGACY_MOUNTED; 3570eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MOUNTED, fcn, pool, tmpmnt)); 3571eb2bd662Svikram return (s_strdup(tmpmnt)); 3572eb2bd662Svikram } 3573eb2bd662Svikram 3574eb2bd662Svikram /* 3575eb2bd662Svikram * Mounts the top dataset (if needed) 3576eb2bd662Svikram * Returns: The mountpoint of the top dataset or NULL on error 3577eb2bd662Svikram * mnted returns one of the above values defined for zfs_mnted_t 3578eb2bd662Svikram */ 3579eb2bd662Svikram static char * 3580eb2bd662Svikram mount_top_dataset(char *pool, zfs_mnted_t *mnted) 3581eb2bd662Svikram { 3582eb2bd662Svikram char cmd[PATH_MAX]; 3583eb2bd662Svikram filelist_t flist = {0}; 3584eb2bd662Svikram char *is_mounted; 3585eb2bd662Svikram char *mntpt; 3586eb2bd662Svikram char *zmntpt; 3587eb2bd662Svikram int ret; 3588eb2bd662Svikram const char *fcn = "mount_top_dataset()"; 3589eb2bd662Svikram 3590eb2bd662Svikram *mnted = ZFS_MNT_ERROR; 3591eb2bd662Svikram 3592eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, pool)); 3593eb2bd662Svikram 3594eb2bd662Svikram /* 3595eb2bd662Svikram * First check if the top dataset is a "legacy" dataset 3596eb2bd662Svikram */ 3597eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3598eb2bd662Svikram "/sbin/zfs get -Ho value mountpoint %s", 3599eb2bd662Svikram pool); 3600eb2bd662Svikram ret = exec_cmd(cmd, &flist); 3601eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_GET_MNTPT", ret = 1); 3602eb2bd662Svikram if (ret != 0) { 3603eb2bd662Svikram bam_error(ZFS_MNTPT_FAILED, pool); 3604eb2bd662Svikram return (NULL); 3605eb2bd662Svikram } 3606eb2bd662Svikram 3607eb2bd662Svikram if (flist.head && (flist.head == flist.tail)) { 3608eb2bd662Svikram char *legacy = strtok(flist.head->line, " \t\n"); 3609eb2bd662Svikram if (legacy && strcmp(legacy, "legacy") == 0) { 3610eb2bd662Svikram filelist_free(&flist); 3611eb2bd662Svikram BAM_DPRINTF((D_Z_IS_LEGACY, fcn, pool)); 3612eb2bd662Svikram return (mount_legacy_dataset(pool, mnted)); 3613eb2bd662Svikram } 3614eb2bd662Svikram } 3615eb2bd662Svikram 3616eb2bd662Svikram filelist_free(&flist); 3617eb2bd662Svikram 3618eb2bd662Svikram BAM_DPRINTF((D_Z_IS_NOT_LEGACY, fcn, pool)); 3619eb2bd662Svikram 3620eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3621eb2bd662Svikram "/sbin/zfs get -Ho value mounted %s", 3622eb2bd662Svikram pool); 3623eb2bd662Svikram 3624eb2bd662Svikram ret = exec_cmd(cmd, &flist); 3625eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED", ret = 1); 3626eb2bd662Svikram if (ret != 0) { 3627eb2bd662Svikram bam_error(ZFS_MNTED_FAILED, pool); 3628eb2bd662Svikram return (NULL); 3629eb2bd662Svikram } 3630eb2bd662Svikram 3631eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_VAL", flist.head = NULL); 3632eb2bd662Svikram if ((flist.head == NULL) || (flist.head != flist.tail)) { 3633eb2bd662Svikram bam_error(BAD_ZFS_MNTED, pool); 3634eb2bd662Svikram filelist_free(&flist); 3635eb2bd662Svikram return (NULL); 3636eb2bd662Svikram } 3637eb2bd662Svikram 3638eb2bd662Svikram is_mounted = strtok(flist.head->line, " \t\n"); 3639eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_YES", is_mounted = "yes"); 3640eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_NO", is_mounted = "no"); 3641eb2bd662Svikram if (strcmp(is_mounted, "no") != 0) { 3642eb2bd662Svikram filelist_free(&flist); 3643eb2bd662Svikram *mnted = ZFS_ALREADY; 3644eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_ALREADY, fcn, pool)); 3645eb2bd662Svikram goto mounted; 3646eb2bd662Svikram } 3647eb2bd662Svikram 3648eb2bd662Svikram filelist_free(&flist); 3649eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_NOT_ALREADY, fcn, pool)); 3650eb2bd662Svikram 3651eb2bd662Svikram /* top dataset is not mounted. Mount it now */ 3652eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3653eb2bd662Svikram "/sbin/zfs mount %s", pool); 3654eb2bd662Svikram ret = exec_cmd(cmd, NULL); 3655eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_MOUNT_CMD", ret = 1); 3656eb2bd662Svikram if (ret != 0) { 3657eb2bd662Svikram bam_error(ZFS_MOUNT_FAILED, pool); 3658eb2bd662Svikram return (NULL); 3659eb2bd662Svikram } 3660eb2bd662Svikram *mnted = ZFS_MOUNTED; 3661eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_NOW, fcn, pool)); 3662eb2bd662Svikram /*FALLTHRU*/ 3663eb2bd662Svikram mounted: 3664eb2bd662Svikram /* 3665eb2bd662Svikram * Now get the mountpoint 3666eb2bd662Svikram */ 3667eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3668eb2bd662Svikram "/sbin/zfs get -Ho value mountpoint %s", 3669eb2bd662Svikram pool); 3670eb2bd662Svikram 3671eb2bd662Svikram ret = exec_cmd(cmd, &flist); 3672eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_CMD", ret = 1); 3673eb2bd662Svikram if (ret != 0) { 3674eb2bd662Svikram bam_error(ZFS_MNTPT_FAILED, pool); 3675eb2bd662Svikram goto error; 3676eb2bd662Svikram } 3677eb2bd662Svikram 3678eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_OUT", flist.head = NULL); 3679eb2bd662Svikram if ((flist.head == NULL) || (flist.head != flist.tail)) { 3680eb2bd662Svikram bam_error(NULL_ZFS_MNTPT, pool); 3681eb2bd662Svikram goto error; 3682eb2bd662Svikram } 3683eb2bd662Svikram 3684eb2bd662Svikram mntpt = strtok(flist.head->line, " \t\n"); 3685eb2bd662Svikram INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_STRTOK", mntpt = "foo"); 3686eb2bd662Svikram if (*mntpt != '/') { 3687eb2bd662Svikram bam_error(BAD_ZFS_MNTPT, pool, mntpt); 3688eb2bd662Svikram goto error; 3689eb2bd662Svikram } 3690eb2bd662Svikram zmntpt = s_strdup(mntpt); 3691eb2bd662Svikram 3692eb2bd662Svikram filelist_free(&flist); 3693eb2bd662Svikram 3694eb2bd662Svikram BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MNTPT, fcn, pool, zmntpt)); 3695eb2bd662Svikram 3696eb2bd662Svikram return (zmntpt); 3697eb2bd662Svikram 3698eb2bd662Svikram error: 3699eb2bd662Svikram filelist_free(&flist); 3700eb2bd662Svikram (void) umount_top_dataset(pool, *mnted, NULL); 3701eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 3702eb2bd662Svikram return (NULL); 3703eb2bd662Svikram } 3704eb2bd662Svikram 3705eb2bd662Svikram static int 3706eb2bd662Svikram umount_top_dataset(char *pool, zfs_mnted_t mnted, char *mntpt) 3707eb2bd662Svikram { 3708eb2bd662Svikram char cmd[PATH_MAX]; 3709eb2bd662Svikram int ret; 3710eb2bd662Svikram const char *fcn = "umount_top_dataset()"; 3711eb2bd662Svikram 3712eb2bd662Svikram INJECT_ERROR1("Z_UMOUNT_TOP_INVALID_STATE", mnted = ZFS_MNT_ERROR); 3713eb2bd662Svikram switch (mnted) { 3714eb2bd662Svikram case LEGACY_ALREADY: 3715eb2bd662Svikram case ZFS_ALREADY: 3716eb2bd662Svikram /* nothing to do */ 3717eb2bd662Svikram BAM_DPRINTF((D_Z_UMOUNT_TOP_ALREADY_NOP, fcn, pool, 3718eb2bd662Svikram mntpt ? mntpt : "NULL")); 3719eb2bd662Svikram free(mntpt); 3720eb2bd662Svikram return (BAM_SUCCESS); 3721eb2bd662Svikram case LEGACY_MOUNTED: 3722eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3723eb2bd662Svikram "/sbin/umount %s", pool); 3724eb2bd662Svikram ret = exec_cmd(cmd, NULL); 3725eb2bd662Svikram INJECT_ERROR1("Z_UMOUNT_TOP_LEGACY_UMOUNT_FAIL", ret = 1); 3726eb2bd662Svikram if (ret != 0) { 3727eb2bd662Svikram bam_error(UMOUNT_FAILED, pool); 3728eb2bd662Svikram free(mntpt); 3729eb2bd662Svikram return (BAM_ERROR); 3730eb2bd662Svikram } 3731eb2bd662Svikram if (mntpt) 3732eb2bd662Svikram (void) rmdir(mntpt); 3733eb2bd662Svikram free(mntpt); 3734eb2bd662Svikram BAM_DPRINTF((D_Z_UMOUNT_TOP_LEGACY, fcn, pool)); 3735eb2bd662Svikram return (BAM_SUCCESS); 3736eb2bd662Svikram case ZFS_MOUNTED: 3737eb2bd662Svikram free(mntpt); 3738eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3739eb2bd662Svikram "/sbin/zfs unmount %s", pool); 3740eb2bd662Svikram ret = exec_cmd(cmd, NULL); 3741eb2bd662Svikram INJECT_ERROR1("Z_UMOUNT_TOP_NONLEG_UMOUNT_FAIL", ret = 1); 3742eb2bd662Svikram if (ret != 0) { 3743eb2bd662Svikram bam_error(UMOUNT_FAILED, pool); 3744eb2bd662Svikram return (BAM_ERROR); 3745eb2bd662Svikram } 3746eb2bd662Svikram BAM_DPRINTF((D_Z_UMOUNT_TOP_NONLEG, fcn, pool)); 3747eb2bd662Svikram return (BAM_SUCCESS); 3748eb2bd662Svikram default: 3749eb2bd662Svikram bam_error(INT_BAD_MNTSTATE, pool); 3750eb2bd662Svikram return (BAM_ERROR); 3751eb2bd662Svikram } 3752eb2bd662Svikram /*NOTREACHED*/ 3753eb2bd662Svikram } 3754eb2bd662Svikram 3755eb2bd662Svikram /* 3756eb2bd662Svikram * For ZFS, osdev can be one of two forms 3757eb2bd662Svikram * It can be a "special" file as seen in mnttab: rpool/ROOT/szboot_0402 3758eb2bd662Svikram * It can be a /dev/[r]dsk special file. We handle both instances 3759eb2bd662Svikram */ 3760eb2bd662Svikram static char * 3761eb2bd662Svikram get_pool(char *osdev) 3762eb2bd662Svikram { 3763eb2bd662Svikram char cmd[PATH_MAX]; 3764eb2bd662Svikram char buf[PATH_MAX]; 3765eb2bd662Svikram filelist_t flist = {0}; 3766eb2bd662Svikram char *pool; 3767eb2bd662Svikram char *cp; 3768eb2bd662Svikram char *slash; 3769eb2bd662Svikram int ret; 3770eb2bd662Svikram const char *fcn = "get_pool()"; 3771eb2bd662Svikram 3772eb2bd662Svikram INJECT_ERROR1("GET_POOL_OSDEV", osdev = NULL); 3773eb2bd662Svikram if (osdev == NULL) { 3774eb2bd662Svikram bam_error(GET_POOL_OSDEV_NULL); 3775eb2bd662Svikram return (NULL); 3776eb2bd662Svikram } 3777eb2bd662Svikram 3778eb2bd662Svikram BAM_DPRINTF((D_GET_POOL_OSDEV, fcn, osdev)); 3779eb2bd662Svikram 3780eb2bd662Svikram if (osdev[0] != '/') { 3781eb2bd662Svikram (void) strlcpy(buf, osdev, sizeof (buf)); 3782eb2bd662Svikram slash = strchr(buf, '/'); 3783eb2bd662Svikram if (slash) 3784eb2bd662Svikram *slash = '\0'; 3785eb2bd662Svikram pool = s_strdup(buf); 3786eb2bd662Svikram BAM_DPRINTF((D_GET_POOL_RET, fcn, pool)); 3787eb2bd662Svikram return (pool); 3788eb2bd662Svikram } else if (strncmp(osdev, "/dev/dsk/", strlen("/dev/dsk/")) != 0 && 3789eb2bd662Svikram strncmp(osdev, "/dev/rdsk/", strlen("/dev/rdsk/")) != 0) { 3790eb2bd662Svikram bam_error(GET_POOL_BAD_OSDEV, osdev); 3791eb2bd662Svikram return (NULL); 3792eb2bd662Svikram } 3793eb2bd662Svikram 3794eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 3795eb2bd662Svikram "/usr/sbin/fstyp -a %s 2>/dev/null | /bin/grep '^name:'", 3796eb2bd662Svikram osdev); 3797eb2bd662Svikram 3798eb2bd662Svikram ret = exec_cmd(cmd, &flist); 3799eb2bd662Svikram INJECT_ERROR1("GET_POOL_FSTYP", ret = 1); 3800eb2bd662Svikram if (ret != 0) { 3801eb2bd662Svikram bam_error(FSTYP_A_FAILED, osdev); 3802eb2bd662Svikram return (NULL); 3803eb2bd662Svikram } 3804eb2bd662Svikram 3805eb2bd662Svikram INJECT_ERROR1("GET_POOL_FSTYP_OUT", flist.head = NULL); 3806eb2bd662Svikram if ((flist.head == NULL) || (flist.head != flist.tail)) { 3807eb2bd662Svikram bam_error(NULL_FSTYP_A, osdev); 3808eb2bd662Svikram filelist_free(&flist); 3809eb2bd662Svikram return (NULL); 3810eb2bd662Svikram } 3811eb2bd662Svikram 3812eb2bd662Svikram (void) strtok(flist.head->line, "'"); 3813eb2bd662Svikram cp = strtok(NULL, "'"); 3814eb2bd662Svikram INJECT_ERROR1("GET_POOL_FSTYP_STRTOK", cp = NULL); 3815eb2bd662Svikram if (cp == NULL) { 3816eb2bd662Svikram bam_error(BAD_FSTYP_A, osdev); 3817eb2bd662Svikram filelist_free(&flist); 3818eb2bd662Svikram return (NULL); 3819eb2bd662Svikram } 3820eb2bd662Svikram 3821eb2bd662Svikram pool = s_strdup(cp); 3822eb2bd662Svikram 3823eb2bd662Svikram filelist_free(&flist); 3824eb2bd662Svikram 3825eb2bd662Svikram BAM_DPRINTF((D_GET_POOL_RET, fcn, pool)); 3826eb2bd662Svikram 3827eb2bd662Svikram return (pool); 3828eb2bd662Svikram } 3829eb2bd662Svikram 3830eb2bd662Svikram static char * 3831eb2bd662Svikram find_zfs_existing(char *osdev) 3832eb2bd662Svikram { 3833eb2bd662Svikram char *pool; 3834eb2bd662Svikram zfs_mnted_t mnted; 3835eb2bd662Svikram char *mntpt; 3836eb2bd662Svikram char *sign; 3837eb2bd662Svikram const char *fcn = "find_zfs_existing()"; 3838eb2bd662Svikram 3839eb2bd662Svikram pool = get_pool(osdev); 3840eb2bd662Svikram INJECT_ERROR1("ZFS_FIND_EXIST_POOL", pool = NULL); 3841eb2bd662Svikram if (pool == NULL) { 3842eb2bd662Svikram bam_error(ZFS_GET_POOL_FAILED, osdev); 3843eb2bd662Svikram return (NULL); 3844eb2bd662Svikram } 3845eb2bd662Svikram 3846eb2bd662Svikram mntpt = mount_top_dataset(pool, &mnted); 3847eb2bd662Svikram INJECT_ERROR1("ZFS_FIND_EXIST_MOUNT_TOP", mntpt = NULL); 3848eb2bd662Svikram if (mntpt == NULL) { 3849eb2bd662Svikram bam_error(ZFS_MOUNT_TOP_DATASET_FAILED, pool); 3850eb2bd662Svikram free(pool); 3851eb2bd662Svikram return (NULL); 3852eb2bd662Svikram } 3853eb2bd662Svikram 3854eb2bd662Svikram sign = find_primary_common(mntpt, "zfs"); 3855eb2bd662Svikram if (sign == NULL) { 3856eb2bd662Svikram sign = find_backup_common(mntpt, "zfs"); 3857eb2bd662Svikram BAM_DPRINTF((D_EXIST_BACKUP_SIGN, fcn, sign ? sign : "NULL")); 3858eb2bd662Svikram } else { 3859eb2bd662Svikram BAM_DPRINTF((D_EXIST_PRIMARY_SIGN, fcn, sign)); 3860eb2bd662Svikram } 3861eb2bd662Svikram 3862eb2bd662Svikram (void) umount_top_dataset(pool, mnted, mntpt); 3863eb2bd662Svikram 3864eb2bd662Svikram free(pool); 3865eb2bd662Svikram 3866eb2bd662Svikram return (sign); 3867eb2bd662Svikram } 3868eb2bd662Svikram 3869eb2bd662Svikram static char * 3870eb2bd662Svikram find_existing_sign(char *osroot, char *osdev, char *fstype) 3871eb2bd662Svikram { 3872eb2bd662Svikram const char *fcn = "find_existing_sign()"; 3873eb2bd662Svikram 3874eb2bd662Svikram INJECT_ERROR1("FIND_EXIST_NOTSUP_FS", fstype = "foofs"); 3875eb2bd662Svikram if (strcmp(fstype, "ufs") == 0) { 3876eb2bd662Svikram BAM_DPRINTF((D_CHECK_UFS_EXIST_SIGN, fcn)); 3877eb2bd662Svikram return (find_ufs_existing(osroot)); 3878eb2bd662Svikram } else if (strcmp(fstype, "zfs") == 0) { 3879eb2bd662Svikram BAM_DPRINTF((D_CHECK_ZFS_EXIST_SIGN, fcn)); 3880eb2bd662Svikram return (find_zfs_existing(osdev)); 3881eb2bd662Svikram } else { 3882eb2bd662Svikram bam_error(GRUBSIGN_NOTSUP, fstype); 3883eb2bd662Svikram return (NULL); 3884eb2bd662Svikram } 3885eb2bd662Svikram } 3886eb2bd662Svikram 3887eb2bd662Svikram #define MH_HASH_SZ 16 3888eb2bd662Svikram 3889eb2bd662Svikram typedef enum { 3890eb2bd662Svikram MH_ERROR = -1, 3891eb2bd662Svikram MH_NOMATCH, 3892eb2bd662Svikram MH_MATCH 3893eb2bd662Svikram } mh_search_t; 3894eb2bd662Svikram 3895eb2bd662Svikram typedef struct mcache { 3896eb2bd662Svikram char *mc_special; 3897eb2bd662Svikram char *mc_mntpt; 3898eb2bd662Svikram char *mc_fstype; 3899eb2bd662Svikram struct mcache *mc_next; 3900eb2bd662Svikram } mcache_t; 3901eb2bd662Svikram 3902eb2bd662Svikram typedef struct mhash { 3903eb2bd662Svikram mcache_t *mh_hash[MH_HASH_SZ]; 3904eb2bd662Svikram } mhash_t; 3905eb2bd662Svikram 3906eb2bd662Svikram static int 3907eb2bd662Svikram mhash_fcn(char *key) 3908eb2bd662Svikram { 3909eb2bd662Svikram int i; 3910eb2bd662Svikram uint64_t sum = 0; 3911eb2bd662Svikram 3912eb2bd662Svikram for (i = 0; key[i] != '\0'; i++) { 3913eb2bd662Svikram sum += (uchar_t)key[i]; 3914eb2bd662Svikram } 3915eb2bd662Svikram 3916eb2bd662Svikram sum %= MH_HASH_SZ; 3917eb2bd662Svikram 3918eb2bd662Svikram assert(sum < MH_HASH_SZ); 3919eb2bd662Svikram 3920eb2bd662Svikram return (sum); 3921eb2bd662Svikram } 3922eb2bd662Svikram 3923eb2bd662Svikram static mhash_t * 3924eb2bd662Svikram cache_mnttab(void) 3925eb2bd662Svikram { 3926eb2bd662Svikram FILE *mfp; 3927eb2bd662Svikram struct extmnttab mnt; 3928eb2bd662Svikram mcache_t *mcp; 3929eb2bd662Svikram mhash_t *mhp; 3930eb2bd662Svikram char *ctds; 3931eb2bd662Svikram int idx; 3932eb2bd662Svikram int error; 3933eb2bd662Svikram char *special_dup; 3934eb2bd662Svikram const char *fcn = "cache_mnttab()"; 3935eb2bd662Svikram 3936eb2bd662Svikram mfp = fopen(MNTTAB, "r"); 3937eb2bd662Svikram error = errno; 3938eb2bd662Svikram INJECT_ERROR1("CACHE_MNTTAB_MNTTAB_ERR", mfp = NULL); 3939eb2bd662Svikram if (mfp == NULL) { 3940eb2bd662Svikram bam_error(OPEN_FAIL, MNTTAB, strerror(error)); 3941eb2bd662Svikram return (NULL); 3942eb2bd662Svikram } 3943eb2bd662Svikram 3944eb2bd662Svikram mhp = s_calloc(1, sizeof (mhash_t)); 3945eb2bd662Svikram 3946eb2bd662Svikram resetmnttab(mfp); 3947eb2bd662Svikram 3948eb2bd662Svikram while (getextmntent(mfp, &mnt, sizeof (mnt)) == 0) { 3949eb2bd662Svikram /* only cache ufs */ 3950eb2bd662Svikram if (strcmp(mnt.mnt_fstype, "ufs") != 0) 3951eb2bd662Svikram continue; 3952eb2bd662Svikram 3953eb2bd662Svikram /* basename() modifies its arg, so dup it */ 3954eb2bd662Svikram special_dup = s_strdup(mnt.mnt_special); 3955eb2bd662Svikram ctds = basename(special_dup); 3956eb2bd662Svikram 3957eb2bd662Svikram mcp = s_calloc(1, sizeof (mcache_t)); 3958eb2bd662Svikram mcp->mc_special = s_strdup(ctds); 3959eb2bd662Svikram mcp->mc_mntpt = s_strdup(mnt.mnt_mountp); 3960eb2bd662Svikram mcp->mc_fstype = s_strdup(mnt.mnt_fstype); 3961eb2bd662Svikram BAM_DPRINTF((D_CACHE_MNTS, fcn, ctds, 3962eb2bd662Svikram mnt.mnt_mountp, mnt.mnt_fstype)); 3963eb2bd662Svikram idx = mhash_fcn(ctds); 3964eb2bd662Svikram mcp->mc_next = mhp->mh_hash[idx]; 3965eb2bd662Svikram mhp->mh_hash[idx] = mcp; 3966eb2bd662Svikram free(special_dup); 3967eb2bd662Svikram } 3968eb2bd662Svikram 3969eb2bd662Svikram (void) fclose(mfp); 3970eb2bd662Svikram 3971eb2bd662Svikram return (mhp); 3972eb2bd662Svikram } 3973eb2bd662Svikram 3974eb2bd662Svikram static void 3975eb2bd662Svikram free_mnttab(mhash_t *mhp) 3976eb2bd662Svikram { 3977eb2bd662Svikram mcache_t *mcp; 3978eb2bd662Svikram int i; 3979eb2bd662Svikram 3980eb2bd662Svikram for (i = 0; i < MH_HASH_SZ; i++) { 3981eb2bd662Svikram /*LINTED*/ 3982eb2bd662Svikram while (mcp = mhp->mh_hash[i]) { 3983eb2bd662Svikram mhp->mh_hash[i] = mcp->mc_next; 3984eb2bd662Svikram free(mcp->mc_special); 3985eb2bd662Svikram free(mcp->mc_mntpt); 3986eb2bd662Svikram free(mcp->mc_fstype); 3987eb2bd662Svikram free(mcp); 3988eb2bd662Svikram } 3989eb2bd662Svikram } 3990eb2bd662Svikram 3991eb2bd662Svikram for (i = 0; i < MH_HASH_SZ; i++) { 3992eb2bd662Svikram assert(mhp->mh_hash[i] == NULL); 3993eb2bd662Svikram } 3994eb2bd662Svikram free(mhp); 3995eb2bd662Svikram } 3996eb2bd662Svikram 3997eb2bd662Svikram static mh_search_t 3998eb2bd662Svikram search_hash(mhash_t *mhp, char *special, char **mntpt) 3999eb2bd662Svikram { 4000eb2bd662Svikram int idx; 4001eb2bd662Svikram mcache_t *mcp; 4002eb2bd662Svikram const char *fcn = "search_hash()"; 4003eb2bd662Svikram 4004eb2bd662Svikram assert(mntpt); 4005eb2bd662Svikram 4006eb2bd662Svikram *mntpt = NULL; 4007eb2bd662Svikram 4008eb2bd662Svikram INJECT_ERROR1("SEARCH_HASH_FULL_PATH", special = "/foo"); 4009eb2bd662Svikram if (strchr(special, '/')) { 4010eb2bd662Svikram bam_error(INVALID_MHASH_KEY, special); 4011eb2bd662Svikram return (MH_ERROR); 4012eb2bd662Svikram } 4013eb2bd662Svikram 4014eb2bd662Svikram idx = mhash_fcn(special); 4015eb2bd662Svikram 4016eb2bd662Svikram for (mcp = mhp->mh_hash[idx]; mcp; mcp = mcp->mc_next) { 4017eb2bd662Svikram if (strcmp(mcp->mc_special, special) == 0) 4018eb2bd662Svikram break; 4019eb2bd662Svikram } 4020eb2bd662Svikram 4021eb2bd662Svikram if (mcp == NULL) { 4022eb2bd662Svikram BAM_DPRINTF((D_MNTTAB_HASH_NOMATCH, fcn, special)); 4023eb2bd662Svikram return (MH_NOMATCH); 4024eb2bd662Svikram } 4025eb2bd662Svikram 4026eb2bd662Svikram assert(strcmp(mcp->mc_fstype, "ufs") == 0); 4027eb2bd662Svikram *mntpt = mcp->mc_mntpt; 4028eb2bd662Svikram BAM_DPRINTF((D_MNTTAB_HASH_MATCH, fcn, special)); 4029eb2bd662Svikram return (MH_MATCH); 4030eb2bd662Svikram } 4031eb2bd662Svikram 4032eb2bd662Svikram static int 4033eb2bd662Svikram check_add_ufs_sign_to_list(FILE *tfp, char *mntpt) 4034eb2bd662Svikram { 4035eb2bd662Svikram char *sign; 4036eb2bd662Svikram char *signline; 4037eb2bd662Svikram char signbuf[MAXNAMELEN]; 4038eb2bd662Svikram int len; 4039eb2bd662Svikram int error; 4040eb2bd662Svikram const char *fcn = "check_add_ufs_sign_to_list()"; 4041eb2bd662Svikram 4042eb2bd662Svikram /* safe to specify NULL as "osdev" arg for UFS */ 4043eb2bd662Svikram sign = find_existing_sign(mntpt, NULL, "ufs"); 4044eb2bd662Svikram if (sign == NULL) { 4045eb2bd662Svikram /* No existing signature, nothing to add to list */ 4046eb2bd662Svikram BAM_DPRINTF((D_NO_SIGN_TO_LIST, fcn, mntpt)); 4047eb2bd662Svikram return (0); 4048eb2bd662Svikram } 4049eb2bd662Svikram 4050eb2bd662Svikram (void) snprintf(signbuf, sizeof (signbuf), "%s\n", sign); 4051eb2bd662Svikram signline = signbuf; 4052eb2bd662Svikram 4053eb2bd662Svikram INJECT_ERROR1("UFS_MNTPT_SIGN_NOTUFS", signline = "pool_rpool10\n"); 4054eb2bd662Svikram if (strncmp(signline, GRUBSIGN_UFS_PREFIX, 4055eb2bd662Svikram strlen(GRUBSIGN_UFS_PREFIX))) { 4056eb2bd662Svikram bam_error(INVALID_UFS_SIGNATURE, sign); 4057eb2bd662Svikram free(sign); 4058eb2bd662Svikram /* ignore invalid signatures */ 4059eb2bd662Svikram return (0); 4060eb2bd662Svikram } 4061eb2bd662Svikram 4062eb2bd662Svikram len = fputs(signline, tfp); 4063eb2bd662Svikram error = errno; 4064eb2bd662Svikram INJECT_ERROR1("SIGN_LIST_PUTS_ERROR", len = 0); 4065eb2bd662Svikram if (len != strlen(signline)) { 4066eb2bd662Svikram bam_error(SIGN_LIST_FPUTS_ERR, sign, strerror(error)); 4067eb2bd662Svikram free(sign); 4068eb2bd662Svikram return (-1); 4069eb2bd662Svikram } 4070eb2bd662Svikram 4071eb2bd662Svikram free(sign); 4072eb2bd662Svikram 4073eb2bd662Svikram BAM_DPRINTF((D_SIGN_LIST_PUTS_DONE, fcn, mntpt)); 4074eb2bd662Svikram return (0); 4075eb2bd662Svikram } 4076eb2bd662Svikram 4077eb2bd662Svikram /* 4078eb2bd662Svikram * slice is a basename not a full pathname 4079eb2bd662Svikram */ 4080eb2bd662Svikram static int 4081eb2bd662Svikram process_slice_common(char *slice, FILE *tfp, mhash_t *mhp, char *tmpmnt) 4082eb2bd662Svikram { 4083eb2bd662Svikram int ret; 4084eb2bd662Svikram char cmd[PATH_MAX]; 4085eb2bd662Svikram char path[PATH_MAX]; 4086eb2bd662Svikram struct stat sbuf; 4087eb2bd662Svikram char *mntpt; 4088eb2bd662Svikram filelist_t flist = {0}; 4089eb2bd662Svikram char *fstype; 4090eb2bd662Svikram char blkslice[PATH_MAX]; 4091eb2bd662Svikram const char *fcn = "process_slice_common()"; 4092eb2bd662Svikram 4093eb2bd662Svikram 4094eb2bd662Svikram ret = search_hash(mhp, slice, &mntpt); 4095eb2bd662Svikram switch (ret) { 4096eb2bd662Svikram case MH_MATCH: 4097eb2bd662Svikram if (check_add_ufs_sign_to_list(tfp, mntpt) == -1) 4098eb2bd662Svikram return (-1); 4099eb2bd662Svikram else 4100eb2bd662Svikram return (0); 4101eb2bd662Svikram case MH_NOMATCH: 4102eb2bd662Svikram break; 4103eb2bd662Svikram case MH_ERROR: 4104eb2bd662Svikram default: 4105eb2bd662Svikram return (-1); 4106eb2bd662Svikram } 4107eb2bd662Svikram 4108eb2bd662Svikram (void) snprintf(path, sizeof (path), "/dev/rdsk/%s", slice); 4109eb2bd662Svikram if (stat(path, &sbuf) == -1) { 4110eb2bd662Svikram BAM_DPRINTF((D_SLICE_ENOENT, fcn, path)); 4111eb2bd662Svikram return (0); 4112eb2bd662Svikram } 4113eb2bd662Svikram 4114eb2bd662Svikram /* Check if ufs */ 4115eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 4116eb2bd662Svikram "/usr/sbin/fstyp /dev/rdsk/%s 2>/dev/null", 4117eb2bd662Svikram slice); 4118eb2bd662Svikram 4119eb2bd662Svikram if (exec_cmd(cmd, &flist) != 0) { 4120eb2bd662Svikram if (bam_verbose) 4121eb2bd662Svikram bam_print(FSTYP_FAILED, slice); 4122eb2bd662Svikram return (0); 4123eb2bd662Svikram } 4124eb2bd662Svikram 4125eb2bd662Svikram if ((flist.head == NULL) || (flist.head != flist.tail)) { 4126eb2bd662Svikram if (bam_verbose) 4127eb2bd662Svikram bam_print(FSTYP_BAD, slice); 4128eb2bd662Svikram filelist_free(&flist); 4129eb2bd662Svikram return (0); 4130eb2bd662Svikram } 4131eb2bd662Svikram 4132eb2bd662Svikram fstype = strtok(flist.head->line, " \t\n"); 4133eb2bd662Svikram if (fstype == NULL || strcmp(fstype, "ufs") != 0) { 4134eb2bd662Svikram if (bam_verbose) 4135eb2bd662Svikram bam_print(NOT_UFS_SLICE, slice, fstype); 4136eb2bd662Svikram filelist_free(&flist); 4137eb2bd662Svikram return (0); 4138eb2bd662Svikram } 4139eb2bd662Svikram 4140eb2bd662Svikram filelist_free(&flist); 4141eb2bd662Svikram 4142eb2bd662Svikram /* 4143eb2bd662Svikram * Since we are mounting the filesystem read-only, the 4144eb2bd662Svikram * the last mount field of the superblock is unchanged 4145eb2bd662Svikram * and does not need to be fixed up post-mount; 4146eb2bd662Svikram */ 4147eb2bd662Svikram 4148eb2bd662Svikram (void) snprintf(blkslice, sizeof (blkslice), "/dev/dsk/%s", 4149eb2bd662Svikram slice); 4150eb2bd662Svikram 4151eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 4152eb2bd662Svikram "/usr/sbin/mount -F ufs -o ro %s %s " 4153eb2bd662Svikram "> /dev/null 2>&1", blkslice, tmpmnt); 4154eb2bd662Svikram 4155eb2bd662Svikram if (exec_cmd(cmd, NULL) != 0) { 4156eb2bd662Svikram if (bam_verbose) 4157eb2bd662Svikram bam_print(MOUNT_FAILED, blkslice, "ufs"); 4158eb2bd662Svikram return (0); 4159eb2bd662Svikram } 4160eb2bd662Svikram 4161eb2bd662Svikram ret = check_add_ufs_sign_to_list(tfp, tmpmnt); 4162eb2bd662Svikram 4163eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 4164eb2bd662Svikram "/usr/sbin/umount -f %s > /dev/null 2>&1", 4165eb2bd662Svikram tmpmnt); 4166eb2bd662Svikram 4167eb2bd662Svikram if (exec_cmd(cmd, NULL) != 0) { 4168eb2bd662Svikram bam_print(UMOUNT_FAILED, slice); 4169eb2bd662Svikram return (0); 4170eb2bd662Svikram } 4171eb2bd662Svikram 4172eb2bd662Svikram return (ret); 4173eb2bd662Svikram } 4174eb2bd662Svikram 4175eb2bd662Svikram static int 4176eb2bd662Svikram process_vtoc_slices( 4177eb2bd662Svikram char *s0, 4178eb2bd662Svikram struct vtoc *vtoc, 4179eb2bd662Svikram FILE *tfp, 4180eb2bd662Svikram mhash_t *mhp, 4181eb2bd662Svikram char *tmpmnt) 4182eb2bd662Svikram { 4183eb2bd662Svikram int idx; 4184eb2bd662Svikram char slice[PATH_MAX]; 4185eb2bd662Svikram size_t len; 4186eb2bd662Svikram char *cp; 4187eb2bd662Svikram const char *fcn = "process_vtoc_slices()"; 4188eb2bd662Svikram 4189eb2bd662Svikram len = strlen(s0); 4190eb2bd662Svikram 4191eb2bd662Svikram assert(s0[len - 2] == 's' && s0[len - 1] == '0'); 4192eb2bd662Svikram 4193eb2bd662Svikram s0[len - 1] = '\0'; 4194eb2bd662Svikram 4195eb2bd662Svikram (void) strlcpy(slice, s0, sizeof (slice)); 4196eb2bd662Svikram 4197eb2bd662Svikram s0[len - 1] = '0'; 4198eb2bd662Svikram 4199eb2bd662Svikram cp = slice + len - 1; 4200eb2bd662Svikram 4201eb2bd662Svikram for (idx = 0; idx < vtoc->v_nparts; idx++) { 4202eb2bd662Svikram 4203eb2bd662Svikram (void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx); 4204eb2bd662Svikram 4205eb2bd662Svikram if (vtoc->v_part[idx].p_size == 0) { 4206eb2bd662Svikram BAM_DPRINTF((D_VTOC_SIZE_ZERO, fcn, slice)); 4207eb2bd662Svikram continue; 4208eb2bd662Svikram } 4209eb2bd662Svikram 4210eb2bd662Svikram /* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */ 4211eb2bd662Svikram switch (vtoc->v_part[idx].p_tag) { 4212eb2bd662Svikram case V_SWAP: 4213eb2bd662Svikram case V_USR: 4214eb2bd662Svikram case V_BACKUP: 4215eb2bd662Svikram case V_VAR: 4216eb2bd662Svikram case V_HOME: 4217eb2bd662Svikram case V_ALTSCTR: 4218eb2bd662Svikram BAM_DPRINTF((D_VTOC_NOT_ROOT_TAG, fcn, slice)); 4219eb2bd662Svikram continue; 4220eb2bd662Svikram default: 4221eb2bd662Svikram BAM_DPRINTF((D_VTOC_ROOT_TAG, fcn, slice)); 4222eb2bd662Svikram break; 4223eb2bd662Svikram } 4224eb2bd662Svikram 4225eb2bd662Svikram /* skip unmountable and readonly slices */ 4226eb2bd662Svikram switch (vtoc->v_part[idx].p_flag) { 4227eb2bd662Svikram case V_UNMNT: 4228eb2bd662Svikram case V_RONLY: 4229eb2bd662Svikram BAM_DPRINTF((D_VTOC_NOT_RDWR_FLAG, fcn, slice)); 4230eb2bd662Svikram continue; 4231eb2bd662Svikram default: 4232eb2bd662Svikram BAM_DPRINTF((D_VTOC_RDWR_FLAG, fcn, slice)); 4233eb2bd662Svikram break; 4234eb2bd662Svikram } 4235eb2bd662Svikram 4236eb2bd662Svikram if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) { 4237eb2bd662Svikram return (-1); 4238eb2bd662Svikram } 4239eb2bd662Svikram } 4240eb2bd662Svikram 4241eb2bd662Svikram return (0); 4242eb2bd662Svikram } 4243eb2bd662Svikram 4244eb2bd662Svikram static int 4245eb2bd662Svikram process_efi_slices( 4246eb2bd662Svikram char *s0, 4247eb2bd662Svikram struct dk_gpt *efi, 4248eb2bd662Svikram FILE *tfp, 4249eb2bd662Svikram mhash_t *mhp, 4250eb2bd662Svikram char *tmpmnt) 4251eb2bd662Svikram { 4252eb2bd662Svikram int idx; 4253eb2bd662Svikram char slice[PATH_MAX]; 4254eb2bd662Svikram size_t len; 4255eb2bd662Svikram char *cp; 4256eb2bd662Svikram const char *fcn = "process_efi_slices()"; 4257eb2bd662Svikram 4258eb2bd662Svikram len = strlen(s0); 4259eb2bd662Svikram 4260eb2bd662Svikram assert(s0[len - 2] == 's' && s0[len - 1] == '0'); 4261eb2bd662Svikram 4262eb2bd662Svikram s0[len - 1] = '\0'; 4263eb2bd662Svikram 4264eb2bd662Svikram (void) strlcpy(slice, s0, sizeof (slice)); 4265eb2bd662Svikram 4266eb2bd662Svikram s0[len - 1] = '0'; 4267eb2bd662Svikram 4268eb2bd662Svikram cp = slice + len - 1; 4269eb2bd662Svikram 4270eb2bd662Svikram for (idx = 0; idx < efi->efi_nparts; idx++) { 4271eb2bd662Svikram 4272eb2bd662Svikram (void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx); 4273eb2bd662Svikram 4274eb2bd662Svikram if (efi->efi_parts[idx].p_size == 0) { 4275eb2bd662Svikram BAM_DPRINTF((D_EFI_SIZE_ZERO, fcn, slice)); 4276eb2bd662Svikram continue; 4277eb2bd662Svikram } 4278eb2bd662Svikram 4279eb2bd662Svikram /* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */ 4280eb2bd662Svikram switch (efi->efi_parts[idx].p_tag) { 4281eb2bd662Svikram case V_SWAP: 4282eb2bd662Svikram case V_USR: 4283eb2bd662Svikram case V_BACKUP: 4284eb2bd662Svikram case V_VAR: 4285eb2bd662Svikram case V_HOME: 4286eb2bd662Svikram case V_ALTSCTR: 4287eb2bd662Svikram BAM_DPRINTF((D_EFI_NOT_ROOT_TAG, fcn, slice)); 4288eb2bd662Svikram continue; 4289eb2bd662Svikram default: 4290eb2bd662Svikram BAM_DPRINTF((D_EFI_ROOT_TAG, fcn, slice)); 4291eb2bd662Svikram break; 4292eb2bd662Svikram } 4293eb2bd662Svikram 4294eb2bd662Svikram /* skip unmountable and readonly slices */ 4295eb2bd662Svikram switch (efi->efi_parts[idx].p_flag) { 4296eb2bd662Svikram case V_UNMNT: 4297eb2bd662Svikram case V_RONLY: 4298eb2bd662Svikram BAM_DPRINTF((D_EFI_NOT_RDWR_FLAG, fcn, slice)); 4299eb2bd662Svikram continue; 4300eb2bd662Svikram default: 4301eb2bd662Svikram BAM_DPRINTF((D_EFI_RDWR_FLAG, fcn, slice)); 4302eb2bd662Svikram break; 4303eb2bd662Svikram } 4304eb2bd662Svikram 4305eb2bd662Svikram if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) { 4306eb2bd662Svikram return (-1); 4307eb2bd662Svikram } 4308eb2bd662Svikram } 4309eb2bd662Svikram 4310eb2bd662Svikram return (0); 4311eb2bd662Svikram } 4312eb2bd662Svikram 4313eb2bd662Svikram /* 4314eb2bd662Svikram * s0 is a basename not a full path 4315eb2bd662Svikram */ 4316eb2bd662Svikram static int 4317eb2bd662Svikram process_slice0(char *s0, FILE *tfp, mhash_t *mhp, char *tmpmnt) 4318eb2bd662Svikram { 4319eb2bd662Svikram struct vtoc vtoc; 4320eb2bd662Svikram struct dk_gpt *efi; 4321eb2bd662Svikram char s0path[PATH_MAX]; 4322eb2bd662Svikram struct stat sbuf; 4323eb2bd662Svikram int e_flag; 4324eb2bd662Svikram int v_flag; 4325eb2bd662Svikram int retval; 4326eb2bd662Svikram int err; 4327eb2bd662Svikram int fd; 4328eb2bd662Svikram const char *fcn = "process_slice0()"; 4329eb2bd662Svikram 4330eb2bd662Svikram (void) snprintf(s0path, sizeof (s0path), "/dev/rdsk/%s", s0); 4331eb2bd662Svikram 4332eb2bd662Svikram if (stat(s0path, &sbuf) == -1) { 4333eb2bd662Svikram BAM_DPRINTF((D_SLICE0_ENOENT, fcn, s0path)); 4334eb2bd662Svikram return (0); 4335eb2bd662Svikram } 4336eb2bd662Svikram 4337eb2bd662Svikram fd = open(s0path, O_NONBLOCK|O_RDONLY); 4338eb2bd662Svikram if (fd == -1) { 4339eb2bd662Svikram bam_error(OPEN_FAIL, s0path, strerror(errno)); 4340eb2bd662Svikram return (0); 4341eb2bd662Svikram } 4342eb2bd662Svikram 4343eb2bd662Svikram e_flag = v_flag = 0; 4344eb2bd662Svikram retval = ((err = read_vtoc(fd, &vtoc)) >= 0) ? 0 : err; 4345eb2bd662Svikram switch (retval) { 4346eb2bd662Svikram case VT_EIO: 4347eb2bd662Svikram BAM_DPRINTF((D_VTOC_READ_FAIL, fcn, s0path)); 4348eb2bd662Svikram break; 4349eb2bd662Svikram case VT_EINVAL: 4350eb2bd662Svikram BAM_DPRINTF((D_VTOC_INVALID, fcn, s0path)); 4351eb2bd662Svikram break; 4352eb2bd662Svikram case VT_ERROR: 4353eb2bd662Svikram BAM_DPRINTF((D_VTOC_UNKNOWN_ERR, fcn, s0path)); 4354eb2bd662Svikram break; 4355eb2bd662Svikram case VT_ENOTSUP: 4356eb2bd662Svikram e_flag = 1; 4357eb2bd662Svikram BAM_DPRINTF((D_VTOC_NOTSUP, fcn, s0path)); 4358eb2bd662Svikram break; 4359eb2bd662Svikram case 0: 4360eb2bd662Svikram v_flag = 1; 4361eb2bd662Svikram BAM_DPRINTF((D_VTOC_READ_SUCCESS, fcn, s0path)); 4362eb2bd662Svikram break; 4363eb2bd662Svikram default: 4364eb2bd662Svikram BAM_DPRINTF((D_VTOC_UNKNOWN_RETCODE, fcn, s0path)); 4365eb2bd662Svikram break; 4366eb2bd662Svikram } 4367eb2bd662Svikram 4368eb2bd662Svikram 4369eb2bd662Svikram if (e_flag) { 4370eb2bd662Svikram e_flag = 0; 4371eb2bd662Svikram retval = ((err = efi_alloc_and_read(fd, &efi)) >= 0) ? 0 : err; 4372eb2bd662Svikram switch (retval) { 4373eb2bd662Svikram case VT_EIO: 4374eb2bd662Svikram BAM_DPRINTF((D_EFI_READ_FAIL, fcn, s0path)); 4375eb2bd662Svikram break; 4376eb2bd662Svikram case VT_EINVAL: 4377eb2bd662Svikram BAM_DPRINTF((D_EFI_INVALID, fcn, s0path)); 4378eb2bd662Svikram break; 4379eb2bd662Svikram case VT_ERROR: 4380eb2bd662Svikram BAM_DPRINTF((D_EFI_UNKNOWN_ERR, fcn, s0path)); 4381eb2bd662Svikram break; 4382eb2bd662Svikram case VT_ENOTSUP: 4383eb2bd662Svikram BAM_DPRINTF((D_EFI_NOTSUP, fcn, s0path)); 4384eb2bd662Svikram break; 4385eb2bd662Svikram case 0: 4386eb2bd662Svikram e_flag = 1; 4387eb2bd662Svikram BAM_DPRINTF((D_EFI_READ_SUCCESS, fcn, s0path)); 4388eb2bd662Svikram break; 4389eb2bd662Svikram default: 4390eb2bd662Svikram BAM_DPRINTF((D_EFI_UNKNOWN_RETCODE, fcn, s0path)); 4391eb2bd662Svikram break; 4392eb2bd662Svikram } 4393eb2bd662Svikram } 4394eb2bd662Svikram 4395eb2bd662Svikram (void) close(fd); 4396eb2bd662Svikram 4397eb2bd662Svikram if (v_flag) { 4398eb2bd662Svikram retval = process_vtoc_slices(s0, 4399eb2bd662Svikram &vtoc, tfp, mhp, tmpmnt); 4400eb2bd662Svikram } else if (e_flag) { 4401eb2bd662Svikram retval = process_efi_slices(s0, 4402eb2bd662Svikram efi, tfp, mhp, tmpmnt); 4403eb2bd662Svikram } else { 4404eb2bd662Svikram BAM_DPRINTF((D_NOT_VTOC_OR_EFI, fcn, s0path)); 4405eb2bd662Svikram return (0); 4406eb2bd662Svikram } 4407eb2bd662Svikram 4408eb2bd662Svikram return (retval); 4409eb2bd662Svikram } 4410eb2bd662Svikram 4411eb2bd662Svikram /* 4412eb2bd662Svikram * Find and create a list of all existing UFS boot signatures 4413eb2bd662Svikram */ 4414eb2bd662Svikram static int 4415eb2bd662Svikram FindAllUfsSignatures(void) 4416eb2bd662Svikram { 4417eb2bd662Svikram mhash_t *mnttab_hash; 4418eb2bd662Svikram DIR *dirp = NULL; 4419eb2bd662Svikram struct dirent *dp; 4420eb2bd662Svikram char tmpmnt[PATH_MAX]; 4421eb2bd662Svikram char cmd[PATH_MAX]; 4422eb2bd662Svikram struct stat sb; 4423eb2bd662Svikram int fd; 4424eb2bd662Svikram FILE *tfp; 4425eb2bd662Svikram size_t len; 4426eb2bd662Svikram int ret; 4427eb2bd662Svikram int error; 4428eb2bd662Svikram const char *fcn = "FindAllUfsSignatures()"; 4429eb2bd662Svikram 4430eb2bd662Svikram if (stat(UFS_SIGNATURE_LIST, &sb) != -1) { 4431eb2bd662Svikram bam_print(SIGNATURE_LIST_EXISTS, UFS_SIGNATURE_LIST); 4432eb2bd662Svikram return (0); 4433eb2bd662Svikram } 4434eb2bd662Svikram 4435eb2bd662Svikram fd = open(UFS_SIGNATURE_LIST".tmp", 4436eb2bd662Svikram O_RDWR|O_CREAT|O_TRUNC, 0644); 4437eb2bd662Svikram error = errno; 4438eb2bd662Svikram INJECT_ERROR1("SIGN_LIST_TMP_TRUNC", fd = -1); 4439eb2bd662Svikram if (fd == -1) { 4440eb2bd662Svikram bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error)); 4441eb2bd662Svikram return (-1); 4442eb2bd662Svikram } 4443eb2bd662Svikram 4444eb2bd662Svikram ret = close(fd); 4445eb2bd662Svikram error = errno; 4446eb2bd662Svikram INJECT_ERROR1("SIGN_LIST_TMP_CLOSE", ret = -1); 4447eb2bd662Svikram if (ret == -1) { 4448eb2bd662Svikram bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp", 4449eb2bd662Svikram strerror(error)); 4450eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4451eb2bd662Svikram return (-1); 4452eb2bd662Svikram } 4453eb2bd662Svikram 4454eb2bd662Svikram tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a"); 4455eb2bd662Svikram error = errno; 4456eb2bd662Svikram INJECT_ERROR1("SIGN_LIST_APPEND_FOPEN", tfp = NULL); 4457eb2bd662Svikram if (tfp == NULL) { 4458eb2bd662Svikram bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error)); 4459eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4460eb2bd662Svikram return (-1); 4461eb2bd662Svikram } 4462eb2bd662Svikram 4463eb2bd662Svikram mnttab_hash = cache_mnttab(); 4464eb2bd662Svikram INJECT_ERROR1("CACHE_MNTTAB_ERROR", mnttab_hash = NULL); 4465eb2bd662Svikram if (mnttab_hash == NULL) { 4466eb2bd662Svikram (void) fclose(tfp); 4467eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4468eb2bd662Svikram bam_error(CACHE_MNTTAB_FAIL, fcn); 4469eb2bd662Svikram return (-1); 4470eb2bd662Svikram } 4471eb2bd662Svikram 4472eb2bd662Svikram (void) snprintf(tmpmnt, sizeof (tmpmnt), 4473eb2bd662Svikram "/tmp/bootadm_ufs_sign_mnt.%d", getpid()); 4474eb2bd662Svikram (void) unlink(tmpmnt); 4475eb2bd662Svikram 4476eb2bd662Svikram ret = mkdirp(tmpmnt, 0755); 4477eb2bd662Svikram error = errno; 4478eb2bd662Svikram INJECT_ERROR1("MKDIRP_SIGN_MNT", ret = -1); 4479eb2bd662Svikram if (ret == -1) { 4480eb2bd662Svikram bam_error(MKDIR_FAILED, tmpmnt, strerror(error)); 4481eb2bd662Svikram free_mnttab(mnttab_hash); 4482eb2bd662Svikram (void) fclose(tfp); 4483eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4484eb2bd662Svikram return (-1); 4485eb2bd662Svikram } 4486eb2bd662Svikram 4487eb2bd662Svikram dirp = opendir("/dev/rdsk"); 4488eb2bd662Svikram error = errno; 4489eb2bd662Svikram INJECT_ERROR1("OPENDIR_DEV_RDSK", dirp = NULL); 4490eb2bd662Svikram if (dirp == NULL) { 4491eb2bd662Svikram bam_error(OPENDIR_FAILED, "/dev/rdsk", strerror(error)); 4492eb2bd662Svikram goto fail; 4493eb2bd662Svikram } 4494eb2bd662Svikram 4495eb2bd662Svikram while (dp = readdir(dirp)) { 4496eb2bd662Svikram if (strcmp(dp->d_name, ".") == 0 || 4497eb2bd662Svikram strcmp(dp->d_name, "..") == 0) 4498eb2bd662Svikram continue; 4499eb2bd662Svikram 4500eb2bd662Svikram /* 4501eb2bd662Svikram * we only look for the s0 slice. This is guranteed to 4502eb2bd662Svikram * have 's' at len - 2. 4503eb2bd662Svikram */ 4504eb2bd662Svikram len = strlen(dp->d_name); 4505eb2bd662Svikram if (dp->d_name[len - 2 ] != 's' || dp->d_name[len - 1] != '0') { 4506eb2bd662Svikram BAM_DPRINTF((D_SKIP_SLICE_NOTZERO, fcn, dp->d_name)); 4507eb2bd662Svikram continue; 4508eb2bd662Svikram } 4509eb2bd662Svikram 4510eb2bd662Svikram ret = process_slice0(dp->d_name, tfp, mnttab_hash, tmpmnt); 4511eb2bd662Svikram INJECT_ERROR1("PROCESS_S0_FAIL", ret = -1); 4512eb2bd662Svikram if (ret == -1) 4513eb2bd662Svikram goto fail; 4514eb2bd662Svikram } 4515eb2bd662Svikram 4516eb2bd662Svikram (void) closedir(dirp); 4517eb2bd662Svikram free_mnttab(mnttab_hash); 4518eb2bd662Svikram (void) rmdir(tmpmnt); 4519eb2bd662Svikram 4520eb2bd662Svikram ret = fclose(tfp); 4521eb2bd662Svikram error = errno; 4522eb2bd662Svikram INJECT_ERROR1("FCLOSE_SIGNLIST_TMP", ret = EOF); 4523eb2bd662Svikram if (ret == EOF) { 4524eb2bd662Svikram bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp", 4525eb2bd662Svikram strerror(error)); 4526eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4527eb2bd662Svikram return (-1); 4528eb2bd662Svikram } 4529eb2bd662Svikram 4530eb2bd662Svikram /* We have a list of existing GRUB signatures. Sort it first */ 4531eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 4532eb2bd662Svikram "/usr/bin/sort -u %s.tmp > %s.sorted", 4533eb2bd662Svikram UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST); 4534eb2bd662Svikram 4535eb2bd662Svikram ret = exec_cmd(cmd, NULL); 4536eb2bd662Svikram INJECT_ERROR1("SORT_SIGN_LIST", ret = 1); 4537eb2bd662Svikram if (ret != 0) { 4538eb2bd662Svikram bam_error(GRUBSIGN_SORT_FAILED); 4539eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".sorted"); 4540eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4541eb2bd662Svikram return (-1); 4542eb2bd662Svikram } 4543eb2bd662Svikram 4544eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4545eb2bd662Svikram 4546eb2bd662Svikram ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST); 4547eb2bd662Svikram error = errno; 4548eb2bd662Svikram INJECT_ERROR1("RENAME_TMP_SIGNLIST", ret = -1); 4549eb2bd662Svikram if (ret == -1) { 4550eb2bd662Svikram bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST, strerror(error)); 4551eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".sorted"); 4552eb2bd662Svikram return (-1); 4553eb2bd662Svikram } 4554eb2bd662Svikram 4555eb2bd662Svikram if (stat(UFS_SIGNATURE_LIST, &sb) == 0 && sb.st_size == 0) { 4556eb2bd662Svikram BAM_DPRINTF((D_ZERO_LEN_SIGNLIST, fcn, UFS_SIGNATURE_LIST)); 4557eb2bd662Svikram } 4558eb2bd662Svikram 4559eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4560eb2bd662Svikram return (0); 4561eb2bd662Svikram 4562eb2bd662Svikram fail: 4563eb2bd662Svikram if (dirp) 4564eb2bd662Svikram (void) closedir(dirp); 4565eb2bd662Svikram free_mnttab(mnttab_hash); 4566eb2bd662Svikram (void) rmdir(tmpmnt); 4567eb2bd662Svikram (void) fclose(tfp); 4568eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 4569eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 4570eb2bd662Svikram return (-1); 4571eb2bd662Svikram } 4572eb2bd662Svikram 4573eb2bd662Svikram static char * 4574eb2bd662Svikram create_ufs_sign(void) 4575eb2bd662Svikram { 4576eb2bd662Svikram struct stat sb; 4577eb2bd662Svikram int signnum = -1; 4578eb2bd662Svikram char tmpsign[MAXNAMELEN + 1]; 4579eb2bd662Svikram char *numstr; 4580eb2bd662Svikram int i; 4581eb2bd662Svikram FILE *tfp; 4582eb2bd662Svikram int ret; 4583eb2bd662Svikram int error; 4584eb2bd662Svikram const char *fcn = "create_ufs_sign()"; 4585eb2bd662Svikram 4586eb2bd662Svikram bam_print(SEARCHING_UFS_SIGN); 4587eb2bd662Svikram 4588eb2bd662Svikram ret = FindAllUfsSignatures(); 4589eb2bd662Svikram INJECT_ERROR1("FIND_ALL_UFS", ret = -1); 4590eb2bd662Svikram if (ret == -1) { 4591eb2bd662Svikram bam_error(ERR_FIND_UFS_SIGN); 4592eb2bd662Svikram return (NULL); 4593eb2bd662Svikram } 4594eb2bd662Svikram 4595eb2bd662Svikram /* Make sure the list exists and is owned by root */ 4596eb2bd662Svikram INJECT_ERROR1("SIGNLIST_NOT_CREATED", 4597eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST)); 4598eb2bd662Svikram if (stat(UFS_SIGNATURE_LIST, &sb) == -1 || sb.st_uid != 0) { 4599eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4600eb2bd662Svikram bam_error(UFS_SIGNATURE_LIST_MISS, UFS_SIGNATURE_LIST); 4601eb2bd662Svikram return (NULL); 4602eb2bd662Svikram } 4603eb2bd662Svikram 4604eb2bd662Svikram if (sb.st_size == 0) { 4605eb2bd662Svikram bam_print(GRUBSIGN_UFS_NONE); 4606eb2bd662Svikram i = 0; 4607eb2bd662Svikram goto found; 4608eb2bd662Svikram } 4609eb2bd662Svikram 4610eb2bd662Svikram /* The signature list was sorted when it was created */ 4611eb2bd662Svikram tfp = fopen(UFS_SIGNATURE_LIST, "r"); 4612eb2bd662Svikram error = errno; 4613eb2bd662Svikram INJECT_ERROR1("FOPEN_SIGN_LIST", tfp = NULL); 4614eb2bd662Svikram if (tfp == NULL) { 4615eb2bd662Svikram bam_error(UFS_SIGNATURE_LIST_OPENERR, 4616eb2bd662Svikram UFS_SIGNATURE_LIST, strerror(error)); 4617eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4618eb2bd662Svikram return (NULL); 4619eb2bd662Svikram } 4620eb2bd662Svikram 4621eb2bd662Svikram for (i = 0; s_fgets(tmpsign, sizeof (tmpsign), tfp); i++) { 4622eb2bd662Svikram 4623eb2bd662Svikram if (strncmp(tmpsign, GRUBSIGN_UFS_PREFIX, 4624eb2bd662Svikram strlen(GRUBSIGN_UFS_PREFIX)) != 0) { 4625eb2bd662Svikram (void) fclose(tfp); 4626eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4627eb2bd662Svikram bam_error(UFS_BADSIGN, tmpsign); 4628eb2bd662Svikram return (NULL); 4629eb2bd662Svikram } 4630eb2bd662Svikram numstr = tmpsign + strlen(GRUBSIGN_UFS_PREFIX); 4631eb2bd662Svikram 4632eb2bd662Svikram if (numstr[0] == '\0' || !isdigit(numstr[0])) { 4633eb2bd662Svikram (void) fclose(tfp); 4634eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4635eb2bd662Svikram bam_error(UFS_BADSIGN, tmpsign); 4636eb2bd662Svikram return (NULL); 4637eb2bd662Svikram } 4638eb2bd662Svikram 4639eb2bd662Svikram signnum = atoi(numstr); 4640eb2bd662Svikram INJECT_ERROR1("NEGATIVE_SIGN", signnum = -1); 4641eb2bd662Svikram if (signnum < 0) { 4642eb2bd662Svikram (void) fclose(tfp); 4643eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4644eb2bd662Svikram bam_error(UFS_BADSIGN, tmpsign); 4645eb2bd662Svikram return (NULL); 4646eb2bd662Svikram } 4647eb2bd662Svikram 4648eb2bd662Svikram if (i != signnum) { 4649eb2bd662Svikram BAM_DPRINTF((D_FOUND_HOLE_SIGNLIST, fcn, i)); 4650eb2bd662Svikram break; 4651eb2bd662Svikram } 4652eb2bd662Svikram } 4653eb2bd662Svikram 4654eb2bd662Svikram (void) fclose(tfp); 4655eb2bd662Svikram 4656eb2bd662Svikram found: 4657eb2bd662Svikram (void) snprintf(tmpsign, sizeof (tmpsign), "rootfs%d", i); 4658eb2bd662Svikram 4659eb2bd662Svikram /* add the ufs signature to the /var/run list of signatures */ 4660eb2bd662Svikram ret = ufs_add_to_sign_list(tmpsign); 4661eb2bd662Svikram INJECT_ERROR1("UFS_ADD_TO_SIGN_LIST", ret = -1); 4662eb2bd662Svikram if (ret == -1) { 4663eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 4664eb2bd662Svikram bam_error(FAILED_ADD_SIGNLIST, tmpsign); 4665eb2bd662Svikram return (NULL); 4666eb2bd662Svikram } 4667eb2bd662Svikram 4668eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4669eb2bd662Svikram 4670eb2bd662Svikram return (s_strdup(tmpsign)); 4671eb2bd662Svikram } 4672eb2bd662Svikram 4673eb2bd662Svikram static char * 4674eb2bd662Svikram get_fstype(char *osroot) 4675eb2bd662Svikram { 4676eb2bd662Svikram FILE *mntfp; 4677eb2bd662Svikram struct mnttab mp = {0}; 4678eb2bd662Svikram struct mnttab mpref = {0}; 4679eb2bd662Svikram int error; 4680eb2bd662Svikram int ret; 4681eb2bd662Svikram const char *fcn = "get_fstype()"; 4682eb2bd662Svikram 4683eb2bd662Svikram INJECT_ERROR1("GET_FSTYPE_OSROOT", osroot = NULL); 4684eb2bd662Svikram if (osroot == NULL) { 4685eb2bd662Svikram bam_error(GET_FSTYPE_ARGS); 4686eb2bd662Svikram return (NULL); 4687eb2bd662Svikram } 4688eb2bd662Svikram 4689eb2bd662Svikram mntfp = fopen(MNTTAB, "r"); 4690eb2bd662Svikram error = errno; 4691eb2bd662Svikram INJECT_ERROR1("GET_FSTYPE_FOPEN", mntfp = NULL); 4692eb2bd662Svikram if (mntfp == NULL) { 4693eb2bd662Svikram bam_error(OPEN_FAIL, MNTTAB, strerror(error)); 4694eb2bd662Svikram return (NULL); 4695eb2bd662Svikram } 4696eb2bd662Svikram 4697eb2bd662Svikram if (*osroot == '\0') 4698eb2bd662Svikram mpref.mnt_mountp = "/"; 4699eb2bd662Svikram else 4700eb2bd662Svikram mpref.mnt_mountp = osroot; 4701eb2bd662Svikram 4702eb2bd662Svikram ret = getmntany(mntfp, &mp, &mpref); 4703eb2bd662Svikram INJECT_ERROR1("GET_FSTYPE_GETMNTANY", ret = 1); 4704eb2bd662Svikram if (ret != 0) { 4705eb2bd662Svikram bam_error(MNTTAB_MNTPT_NOT_FOUND, osroot, MNTTAB); 4706eb2bd662Svikram (void) fclose(mntfp); 4707eb2bd662Svikram return (NULL); 4708eb2bd662Svikram } 4709eb2bd662Svikram (void) fclose(mntfp); 4710eb2bd662Svikram 4711eb2bd662Svikram INJECT_ERROR1("GET_FSTYPE_NULL", mp.mnt_fstype = NULL); 4712eb2bd662Svikram if (mp.mnt_fstype == NULL) { 4713eb2bd662Svikram bam_error(MNTTAB_FSTYPE_NULL, osroot); 4714eb2bd662Svikram return (NULL); 4715eb2bd662Svikram } 4716eb2bd662Svikram 4717eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4718eb2bd662Svikram 4719eb2bd662Svikram return (s_strdup(mp.mnt_fstype)); 4720eb2bd662Svikram } 4721eb2bd662Svikram 4722eb2bd662Svikram static char * 4723eb2bd662Svikram create_zfs_sign(char *osdev) 4724eb2bd662Svikram { 4725eb2bd662Svikram char tmpsign[PATH_MAX]; 4726eb2bd662Svikram char *pool; 4727eb2bd662Svikram const char *fcn = "create_zfs_sign()"; 4728eb2bd662Svikram 4729eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, osdev)); 4730eb2bd662Svikram 4731eb2bd662Svikram /* 4732eb2bd662Svikram * First find the pool name 4733eb2bd662Svikram */ 4734eb2bd662Svikram pool = get_pool(osdev); 4735eb2bd662Svikram INJECT_ERROR1("CREATE_ZFS_SIGN_GET_POOL", pool = NULL); 4736eb2bd662Svikram if (pool == NULL) { 4737eb2bd662Svikram bam_error(GET_POOL_FAILED, osdev); 4738eb2bd662Svikram return (NULL); 4739eb2bd662Svikram } 4740eb2bd662Svikram 4741eb2bd662Svikram (void) snprintf(tmpsign, sizeof (tmpsign), "pool_%s", pool); 4742eb2bd662Svikram 4743eb2bd662Svikram BAM_DPRINTF((D_CREATED_ZFS_SIGN, fcn, tmpsign)); 4744eb2bd662Svikram 4745eb2bd662Svikram free(pool); 4746eb2bd662Svikram 4747eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4748eb2bd662Svikram 4749eb2bd662Svikram return (s_strdup(tmpsign)); 4750eb2bd662Svikram } 4751eb2bd662Svikram 4752eb2bd662Svikram static char * 4753eb2bd662Svikram create_new_sign(char *osdev, char *fstype) 4754eb2bd662Svikram { 4755eb2bd662Svikram char *sign; 4756eb2bd662Svikram const char *fcn = "create_new_sign()"; 4757eb2bd662Svikram 4758eb2bd662Svikram INJECT_ERROR1("NEW_SIGN_FSTYPE", fstype = "foofs"); 4759eb2bd662Svikram 4760eb2bd662Svikram if (strcmp(fstype, "zfs") == 0) { 4761eb2bd662Svikram BAM_DPRINTF((D_CREATE_NEW_ZFS, fcn)); 4762eb2bd662Svikram sign = create_zfs_sign(osdev); 4763eb2bd662Svikram } else if (strcmp(fstype, "ufs") == 0) { 4764eb2bd662Svikram BAM_DPRINTF((D_CREATE_NEW_UFS, fcn)); 4765eb2bd662Svikram sign = create_ufs_sign(); 4766eb2bd662Svikram } else { 4767eb2bd662Svikram bam_error(GRUBSIGN_NOTSUP, fstype); 4768eb2bd662Svikram sign = NULL; 4769eb2bd662Svikram } 4770eb2bd662Svikram 4771eb2bd662Svikram BAM_DPRINTF((D_CREATED_NEW_SIGN, fcn, sign ? sign : "<NULL>")); 4772eb2bd662Svikram return (sign); 4773eb2bd662Svikram } 4774eb2bd662Svikram 4775eb2bd662Svikram static int 4776eb2bd662Svikram set_backup_common(char *mntpt, char *sign) 4777eb2bd662Svikram { 4778eb2bd662Svikram FILE *bfp; 4779eb2bd662Svikram char backup[PATH_MAX]; 4780eb2bd662Svikram char tmpsign[PATH_MAX]; 4781eb2bd662Svikram int error; 4782eb2bd662Svikram char *bdir; 4783eb2bd662Svikram char *backup_dup; 4784eb2bd662Svikram struct stat sb; 4785eb2bd662Svikram int ret; 4786eb2bd662Svikram const char *fcn = "set_backup_common()"; 4787eb2bd662Svikram 4788eb2bd662Svikram (void) snprintf(backup, sizeof (backup), "%s%s", 4789eb2bd662Svikram mntpt, GRUBSIGN_BACKUP); 4790eb2bd662Svikram 4791eb2bd662Svikram /* First read the backup */ 4792eb2bd662Svikram bfp = fopen(backup, "r"); 4793eb2bd662Svikram if (bfp != NULL) { 4794eb2bd662Svikram while (s_fgets(tmpsign, sizeof (tmpsign), bfp)) { 4795eb2bd662Svikram if (strcmp(tmpsign, sign) == 0) { 4796eb2bd662Svikram BAM_DPRINTF((D_FOUND_IN_BACKUP, fcn, sign)); 4797eb2bd662Svikram (void) fclose(bfp); 4798eb2bd662Svikram return (0); 4799eb2bd662Svikram } 4800eb2bd662Svikram } 4801eb2bd662Svikram (void) fclose(bfp); 4802eb2bd662Svikram BAM_DPRINTF((D_NOT_FOUND_IN_EXIST_BACKUP, fcn, sign)); 4803eb2bd662Svikram } else { 4804eb2bd662Svikram BAM_DPRINTF((D_BACKUP_NOT_EXIST, fcn, backup)); 4805eb2bd662Svikram } 4806eb2bd662Svikram 4807eb2bd662Svikram /* 4808eb2bd662Svikram * Didn't find the correct signature. First create 4809eb2bd662Svikram * the directory if necessary. 4810eb2bd662Svikram */ 4811eb2bd662Svikram 4812eb2bd662Svikram /* dirname() modifies its argument so dup it */ 4813eb2bd662Svikram backup_dup = s_strdup(backup); 4814eb2bd662Svikram bdir = dirname(backup_dup); 4815eb2bd662Svikram assert(bdir); 4816eb2bd662Svikram 4817eb2bd662Svikram ret = stat(bdir, &sb); 4818eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_STAT", ret = -1); 4819eb2bd662Svikram if (ret == -1) { 4820eb2bd662Svikram BAM_DPRINTF((D_BACKUP_DIR_NOEXIST, fcn, bdir)); 4821eb2bd662Svikram ret = mkdirp(bdir, 0755); 4822eb2bd662Svikram error = errno; 4823eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_MKDIRP", ret = -1); 4824eb2bd662Svikram if (ret == -1) { 4825eb2bd662Svikram bam_error(GRUBSIGN_BACKUP_MKDIRERR, 4826eb2bd662Svikram GRUBSIGN_BACKUP, strerror(error)); 4827eb2bd662Svikram free(backup_dup); 4828eb2bd662Svikram return (-1); 4829eb2bd662Svikram } 4830eb2bd662Svikram } 4831eb2bd662Svikram free(backup_dup); 4832eb2bd662Svikram 4833eb2bd662Svikram /* 4834eb2bd662Svikram * Open the backup in append mode to add the correct 4835eb2bd662Svikram * signature; 4836eb2bd662Svikram */ 4837eb2bd662Svikram bfp = fopen(backup, "a"); 4838eb2bd662Svikram error = errno; 4839eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_FOPEN_A", bfp = NULL); 4840eb2bd662Svikram if (bfp == NULL) { 4841eb2bd662Svikram bam_error(GRUBSIGN_BACKUP_OPENERR, 4842eb2bd662Svikram GRUBSIGN_BACKUP, strerror(error)); 4843eb2bd662Svikram return (-1); 4844eb2bd662Svikram } 4845eb2bd662Svikram 4846eb2bd662Svikram (void) snprintf(tmpsign, sizeof (tmpsign), "%s\n", sign); 4847eb2bd662Svikram 4848eb2bd662Svikram ret = fputs(tmpsign, bfp); 4849eb2bd662Svikram error = errno; 4850eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_FPUTS", ret = 0); 4851eb2bd662Svikram if (ret != strlen(tmpsign)) { 4852eb2bd662Svikram bam_error(GRUBSIGN_BACKUP_WRITEERR, 4853eb2bd662Svikram GRUBSIGN_BACKUP, strerror(error)); 4854eb2bd662Svikram (void) fclose(bfp); 4855eb2bd662Svikram return (-1); 4856eb2bd662Svikram } 4857eb2bd662Svikram 4858eb2bd662Svikram (void) fclose(bfp); 4859eb2bd662Svikram 4860eb2bd662Svikram if (bam_verbose) 4861eb2bd662Svikram bam_print(GRUBSIGN_BACKUP_UPDATED, GRUBSIGN_BACKUP); 4862eb2bd662Svikram 4863eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4864eb2bd662Svikram 4865eb2bd662Svikram return (0); 4866eb2bd662Svikram } 4867eb2bd662Svikram 4868eb2bd662Svikram static int 4869eb2bd662Svikram set_backup_ufs(char *osroot, char *sign) 4870eb2bd662Svikram { 4871eb2bd662Svikram const char *fcn = "set_backup_ufs()"; 4872eb2bd662Svikram 4873eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, sign)); 4874eb2bd662Svikram return (set_backup_common(osroot, sign)); 4875eb2bd662Svikram } 4876eb2bd662Svikram 4877eb2bd662Svikram static int 4878eb2bd662Svikram set_backup_zfs(char *osdev, char *sign) 4879eb2bd662Svikram { 4880eb2bd662Svikram char *pool; 4881eb2bd662Svikram char *mntpt; 4882eb2bd662Svikram zfs_mnted_t mnted; 4883eb2bd662Svikram int ret; 4884eb2bd662Svikram const char *fcn = "set_backup_zfs()"; 4885eb2bd662Svikram 4886eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osdev, sign)); 4887eb2bd662Svikram 4888eb2bd662Svikram pool = get_pool(osdev); 4889eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_GET_POOL", pool = NULL); 4890eb2bd662Svikram if (pool == NULL) { 4891eb2bd662Svikram bam_error(GET_POOL_FAILED, osdev); 4892eb2bd662Svikram return (-1); 4893eb2bd662Svikram } 4894eb2bd662Svikram 4895eb2bd662Svikram mntpt = mount_top_dataset(pool, &mnted); 4896eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_MOUNT_DATASET", mntpt = NULL); 4897eb2bd662Svikram if (mntpt == NULL) { 4898eb2bd662Svikram bam_error(FAIL_MNT_TOP_DATASET, pool); 4899eb2bd662Svikram free(pool); 4900eb2bd662Svikram return (-1); 4901eb2bd662Svikram } 4902eb2bd662Svikram 4903eb2bd662Svikram ret = set_backup_common(mntpt, sign); 4904eb2bd662Svikram 4905eb2bd662Svikram (void) umount_top_dataset(pool, mnted, mntpt); 4906eb2bd662Svikram 4907eb2bd662Svikram free(pool); 4908eb2bd662Svikram 4909eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_ZFS_FAIL", ret = 1); 4910eb2bd662Svikram if (ret == 0) { 4911eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4912eb2bd662Svikram } else { 4913eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 4914eb2bd662Svikram } 4915eb2bd662Svikram 4916eb2bd662Svikram return (ret); 4917eb2bd662Svikram } 4918eb2bd662Svikram 4919eb2bd662Svikram static int 4920eb2bd662Svikram set_backup(char *osroot, char *osdev, char *sign, char *fstype) 4921eb2bd662Svikram { 4922eb2bd662Svikram const char *fcn = "set_backup()"; 4923eb2bd662Svikram int ret; 4924eb2bd662Svikram 4925eb2bd662Svikram INJECT_ERROR1("SET_BACKUP_FSTYPE", fstype = "foofs"); 4926eb2bd662Svikram 4927eb2bd662Svikram if (strcmp(fstype, "ufs") == 0) { 4928eb2bd662Svikram BAM_DPRINTF((D_SET_BACKUP_UFS, fcn)); 4929eb2bd662Svikram ret = set_backup_ufs(osroot, sign); 4930eb2bd662Svikram } else if (strcmp(fstype, "zfs") == 0) { 4931eb2bd662Svikram BAM_DPRINTF((D_SET_BACKUP_ZFS, fcn)); 4932eb2bd662Svikram ret = set_backup_zfs(osdev, sign); 4933eb2bd662Svikram } else { 4934eb2bd662Svikram bam_error(GRUBSIGN_NOTSUP, fstype); 4935eb2bd662Svikram ret = -1; 4936eb2bd662Svikram } 4937eb2bd662Svikram 4938eb2bd662Svikram if (ret == 0) { 4939eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 4940eb2bd662Svikram } else { 4941eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 4942eb2bd662Svikram } 4943eb2bd662Svikram 4944eb2bd662Svikram return (ret); 4945eb2bd662Svikram } 4946eb2bd662Svikram 4947eb2bd662Svikram static int 4948eb2bd662Svikram set_primary_common(char *mntpt, char *sign) 4949eb2bd662Svikram { 4950eb2bd662Svikram char signfile[PATH_MAX]; 4951eb2bd662Svikram char signdir[PATH_MAX]; 4952eb2bd662Svikram struct stat sb; 4953eb2bd662Svikram int fd; 4954eb2bd662Svikram int error; 4955eb2bd662Svikram int ret; 4956eb2bd662Svikram const char *fcn = "set_primary_common()"; 4957eb2bd662Svikram 4958eb2bd662Svikram (void) snprintf(signfile, sizeof (signfile), "%s/%s/%s", 4959eb2bd662Svikram mntpt, GRUBSIGN_DIR, sign); 4960eb2bd662Svikram 4961eb2bd662Svikram if (stat(signfile, &sb) != -1) { 4962eb2bd662Svikram if (bam_verbose) 4963eb2bd662Svikram bam_print(PRIMARY_SIGN_EXISTS, sign); 4964eb2bd662Svikram return (0); 4965eb2bd662Svikram } else { 4966eb2bd662Svikram BAM_DPRINTF((D_PRIMARY_NOT_EXIST, fcn, signfile)); 4967eb2bd662Svikram } 4968eb2bd662Svikram 4969eb2bd662Svikram (void) snprintf(signdir, sizeof (signdir), "%s/%s", 4970eb2bd662Svikram mntpt, GRUBSIGN_DIR); 4971eb2bd662Svikram 4972eb2bd662Svikram if (stat(signdir, &sb) == -1) { 4973eb2bd662Svikram BAM_DPRINTF((D_PRIMARY_DIR_NOEXIST, fcn, signdir)); 4974eb2bd662Svikram ret = mkdirp(signdir, 0755); 4975eb2bd662Svikram error = errno; 4976eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_MKDIRP", ret = -1); 4977eb2bd662Svikram if (ret == -1) { 4978eb2bd662Svikram bam_error(GRUBSIGN_MKDIR_ERR, signdir, strerror(errno)); 4979eb2bd662Svikram return (-1); 4980eb2bd662Svikram } 4981eb2bd662Svikram } 4982eb2bd662Svikram 4983eb2bd662Svikram fd = open(signfile, O_RDWR|O_CREAT|O_TRUNC, 0444); 4984eb2bd662Svikram error = errno; 4985eb2bd662Svikram INJECT_ERROR1("PRIMARY_SIGN_CREAT", fd = -1); 4986eb2bd662Svikram if (fd == -1) { 4987eb2bd662Svikram bam_error(GRUBSIGN_PRIMARY_CREATERR, signfile, strerror(error)); 4988eb2bd662Svikram return (-1); 4989eb2bd662Svikram } 4990eb2bd662Svikram 4991eb2bd662Svikram ret = fsync(fd); 4992eb2bd662Svikram error = errno; 4993eb2bd662Svikram INJECT_ERROR1("PRIMARY_FSYNC", ret = -1); 4994eb2bd662Svikram if (ret != 0) { 4995eb2bd662Svikram bam_error(GRUBSIGN_PRIMARY_SYNCERR, signfile, strerror(error)); 4996eb2bd662Svikram } 4997eb2bd662Svikram 4998eb2bd662Svikram (void) close(fd); 4999eb2bd662Svikram 5000eb2bd662Svikram if (bam_verbose) 5001eb2bd662Svikram bam_print(GRUBSIGN_CREATED_PRIMARY, signfile); 5002eb2bd662Svikram 5003eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5004eb2bd662Svikram 5005eb2bd662Svikram return (0); 5006eb2bd662Svikram } 5007eb2bd662Svikram 5008eb2bd662Svikram static int 5009eb2bd662Svikram set_primary_ufs(char *osroot, char *sign) 5010eb2bd662Svikram { 5011eb2bd662Svikram const char *fcn = "set_primary_ufs()"; 5012eb2bd662Svikram 5013eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, sign)); 5014eb2bd662Svikram return (set_primary_common(osroot, sign)); 5015eb2bd662Svikram } 5016eb2bd662Svikram 5017eb2bd662Svikram static int 5018eb2bd662Svikram set_primary_zfs(char *osdev, char *sign) 5019eb2bd662Svikram { 5020eb2bd662Svikram char *pool; 5021eb2bd662Svikram char *mntpt; 5022eb2bd662Svikram zfs_mnted_t mnted; 5023eb2bd662Svikram int ret; 5024eb2bd662Svikram const char *fcn = "set_primary_zfs()"; 5025eb2bd662Svikram 5026eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osdev, sign)); 5027eb2bd662Svikram 5028eb2bd662Svikram pool = get_pool(osdev); 5029eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_ZFS_GET_POOL", pool = NULL); 5030eb2bd662Svikram if (pool == NULL) { 5031eb2bd662Svikram bam_error(GET_POOL_FAILED, osdev); 5032eb2bd662Svikram return (-1); 5033eb2bd662Svikram } 5034eb2bd662Svikram 5035eb2bd662Svikram /* Pool name must exist in the sign */ 5036eb2bd662Svikram ret = (strstr(sign, pool) != NULL); 5037eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_ZFS_POOL_SIGN_INCOMPAT", ret = 0); 5038eb2bd662Svikram if (ret == 0) { 5039eb2bd662Svikram bam_error(POOL_SIGN_INCOMPAT, pool, sign); 5040eb2bd662Svikram free(pool); 5041eb2bd662Svikram return (-1); 5042eb2bd662Svikram } 5043eb2bd662Svikram 5044eb2bd662Svikram mntpt = mount_top_dataset(pool, &mnted); 5045eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_ZFS_MOUNT_DATASET", mntpt = NULL); 5046eb2bd662Svikram if (mntpt == NULL) { 5047eb2bd662Svikram bam_error(FAIL_MNT_TOP_DATASET, pool); 5048eb2bd662Svikram free(pool); 5049eb2bd662Svikram return (-1); 5050eb2bd662Svikram } 5051eb2bd662Svikram 5052eb2bd662Svikram ret = set_primary_common(mntpt, sign); 5053eb2bd662Svikram 5054eb2bd662Svikram (void) umount_top_dataset(pool, mnted, mntpt); 5055eb2bd662Svikram 5056eb2bd662Svikram free(pool); 5057eb2bd662Svikram 5058eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_ZFS_FAIL", ret = 1); 5059eb2bd662Svikram if (ret == 0) { 5060eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5061eb2bd662Svikram } else { 5062eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5063eb2bd662Svikram } 5064eb2bd662Svikram 5065eb2bd662Svikram return (ret); 5066eb2bd662Svikram } 5067eb2bd662Svikram 5068eb2bd662Svikram static int 5069eb2bd662Svikram set_primary(char *osroot, char *osdev, char *sign, char *fstype) 5070eb2bd662Svikram { 5071eb2bd662Svikram const char *fcn = "set_primary()"; 5072eb2bd662Svikram int ret; 5073eb2bd662Svikram 5074eb2bd662Svikram INJECT_ERROR1("SET_PRIMARY_FSTYPE", fstype = "foofs"); 5075eb2bd662Svikram if (strcmp(fstype, "ufs") == 0) { 5076eb2bd662Svikram BAM_DPRINTF((D_SET_PRIMARY_UFS, fcn)); 5077eb2bd662Svikram ret = set_primary_ufs(osroot, sign); 5078eb2bd662Svikram } else if (strcmp(fstype, "zfs") == 0) { 5079eb2bd662Svikram BAM_DPRINTF((D_SET_PRIMARY_ZFS, fcn)); 5080eb2bd662Svikram ret = set_primary_zfs(osdev, sign); 5081eb2bd662Svikram } else { 5082eb2bd662Svikram bam_error(GRUBSIGN_NOTSUP, fstype); 5083eb2bd662Svikram ret = -1; 5084eb2bd662Svikram } 5085eb2bd662Svikram 5086eb2bd662Svikram if (ret == 0) { 5087eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5088eb2bd662Svikram } else { 5089eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5090eb2bd662Svikram } 5091eb2bd662Svikram 5092eb2bd662Svikram return (ret); 5093eb2bd662Svikram } 5094eb2bd662Svikram 5095eb2bd662Svikram static int 5096eb2bd662Svikram ufs_add_to_sign_list(char *sign) 5097eb2bd662Svikram { 5098eb2bd662Svikram FILE *tfp; 5099eb2bd662Svikram char signline[MAXNAMELEN]; 5100eb2bd662Svikram char cmd[PATH_MAX]; 5101eb2bd662Svikram int ret; 5102eb2bd662Svikram int error; 5103eb2bd662Svikram const char *fcn = "ufs_add_to_sign_list()"; 5104eb2bd662Svikram 5105eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_NOT_UFS", sign = "pool_rpool5"); 5106eb2bd662Svikram if (strncmp(sign, GRUBSIGN_UFS_PREFIX, 5107eb2bd662Svikram strlen(GRUBSIGN_UFS_PREFIX)) != 0) { 5108eb2bd662Svikram bam_error(INVALID_UFS_SIGN, sign); 5109eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 5110eb2bd662Svikram return (-1); 5111eb2bd662Svikram } 5112eb2bd662Svikram 5113eb2bd662Svikram /* 5114eb2bd662Svikram * most failures in this routine are not a fatal error 5115eb2bd662Svikram * We simply unlink the /var/run file and continue 5116eb2bd662Svikram */ 5117eb2bd662Svikram 5118eb2bd662Svikram ret = rename(UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST".tmp"); 5119eb2bd662Svikram error = errno; 5120eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME", ret = -1); 5121eb2bd662Svikram if (ret == -1) { 5122eb2bd662Svikram bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST".tmp", 5123eb2bd662Svikram strerror(error)); 5124eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 5125eb2bd662Svikram return (0); 5126eb2bd662Svikram } 5127eb2bd662Svikram 5128eb2bd662Svikram tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a"); 5129eb2bd662Svikram error = errno; 5130eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_FOPEN", tfp = NULL); 5131eb2bd662Svikram if (tfp == NULL) { 5132eb2bd662Svikram bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error)); 5133eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 5134eb2bd662Svikram return (0); 5135eb2bd662Svikram } 5136eb2bd662Svikram 5137eb2bd662Svikram (void) snprintf(signline, sizeof (signline), "%s\n", sign); 5138eb2bd662Svikram 5139eb2bd662Svikram ret = fputs(signline, tfp); 5140eb2bd662Svikram error = errno; 5141eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_FPUTS", ret = 0); 5142eb2bd662Svikram if (ret != strlen(signline)) { 5143eb2bd662Svikram bam_error(SIGN_LIST_FPUTS_ERR, sign, strerror(error)); 5144eb2bd662Svikram (void) fclose(tfp); 5145eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 5146eb2bd662Svikram return (0); 5147eb2bd662Svikram } 5148eb2bd662Svikram 5149eb2bd662Svikram ret = fclose(tfp); 5150eb2bd662Svikram error = errno; 5151eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_FCLOSE", ret = EOF); 5152eb2bd662Svikram if (ret == EOF) { 5153eb2bd662Svikram bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp", 5154eb2bd662Svikram strerror(error)); 5155eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 5156eb2bd662Svikram return (0); 5157eb2bd662Svikram } 5158eb2bd662Svikram 5159eb2bd662Svikram /* Sort the list again */ 5160eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), 5161eb2bd662Svikram "/usr/bin/sort -u %s.tmp > %s.sorted", 5162eb2bd662Svikram UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST); 5163eb2bd662Svikram 5164eb2bd662Svikram ret = exec_cmd(cmd, NULL); 5165eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_SORT", ret = 1); 5166eb2bd662Svikram if (ret != 0) { 5167eb2bd662Svikram bam_error(GRUBSIGN_SORT_FAILED); 5168eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".sorted"); 5169eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 5170eb2bd662Svikram return (0); 5171eb2bd662Svikram } 5172eb2bd662Svikram 5173eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".tmp"); 5174eb2bd662Svikram 5175eb2bd662Svikram ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST); 5176eb2bd662Svikram error = errno; 5177eb2bd662Svikram INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME2", ret = -1); 5178eb2bd662Svikram if (ret == -1) { 5179eb2bd662Svikram bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST, strerror(error)); 5180eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST".sorted"); 5181eb2bd662Svikram return (0); 5182eb2bd662Svikram } 5183eb2bd662Svikram 5184eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5185eb2bd662Svikram 5186eb2bd662Svikram return (0); 5187eb2bd662Svikram } 5188eb2bd662Svikram 5189eb2bd662Svikram static int 5190eb2bd662Svikram set_signature(char *osroot, char *osdev, char *sign, char *fstype) 5191eb2bd662Svikram { 5192eb2bd662Svikram int ret; 5193eb2bd662Svikram const char *fcn = "set_signature()"; 5194eb2bd662Svikram 5195eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY4, fcn, osroot, osdev, sign, fstype)); 5196eb2bd662Svikram 5197eb2bd662Svikram ret = set_backup(osroot, osdev, sign, fstype); 5198eb2bd662Svikram INJECT_ERROR1("SET_SIGNATURE_BACKUP", ret = -1); 5199eb2bd662Svikram if (ret == -1) { 5200eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5201eb2bd662Svikram bam_error(SET_BACKUP_FAILED, sign, osroot, osdev); 5202eb2bd662Svikram return (-1); 5203eb2bd662Svikram } 5204eb2bd662Svikram 5205eb2bd662Svikram ret = set_primary(osroot, osdev, sign, fstype); 5206eb2bd662Svikram INJECT_ERROR1("SET_SIGNATURE_PRIMARY", ret = -1); 5207eb2bd662Svikram 5208eb2bd662Svikram if (ret == 0) { 5209eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5210eb2bd662Svikram } else { 5211eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5212eb2bd662Svikram bam_error(SET_PRIMARY_FAILED, sign, osroot, osdev); 5213eb2bd662Svikram 5214eb2bd662Svikram } 5215eb2bd662Svikram return (ret); 5216eb2bd662Svikram } 5217eb2bd662Svikram 5218eb2bd662Svikram char * 5219eb2bd662Svikram get_grubsign(char *osroot, char *osdev) 5220eb2bd662Svikram { 5221eb2bd662Svikram char *grubsign; /* (<sign>,#,#) */ 5222eb2bd662Svikram char *slice; 5223eb2bd662Svikram int fdiskpart; 5224eb2bd662Svikram char *sign; 5225eb2bd662Svikram char *fstype; 5226eb2bd662Svikram int ret; 5227eb2bd662Svikram const char *fcn = "get_grubsign()"; 5228eb2bd662Svikram 5229eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, osdev)); 5230eb2bd662Svikram 5231eb2bd662Svikram fstype = get_fstype(osroot); 5232eb2bd662Svikram INJECT_ERROR1("GET_GRUBSIGN_FSTYPE", fstype = NULL); 5233eb2bd662Svikram if (fstype == NULL) { 5234eb2bd662Svikram bam_error(GET_FSTYPE_FAILED, osroot); 5235eb2bd662Svikram return (NULL); 5236eb2bd662Svikram } 5237eb2bd662Svikram 5238eb2bd662Svikram sign = find_existing_sign(osroot, osdev, fstype); 5239eb2bd662Svikram INJECT_ERROR1("FIND_EXISTING_SIGN", sign = NULL); 5240eb2bd662Svikram if (sign == NULL) { 5241eb2bd662Svikram BAM_DPRINTF((D_GET_GRUBSIGN_NO_EXISTING, fcn, osroot, osdev)); 5242eb2bd662Svikram sign = create_new_sign(osdev, fstype); 5243eb2bd662Svikram INJECT_ERROR1("CREATE_NEW_SIGN", sign = NULL); 5244eb2bd662Svikram if (sign == NULL) { 5245eb2bd662Svikram bam_error(GRUBSIGN_CREATE_FAIL, osdev); 5246eb2bd662Svikram free(fstype); 5247eb2bd662Svikram return (NULL); 5248eb2bd662Svikram } 5249eb2bd662Svikram } 5250eb2bd662Svikram 5251eb2bd662Svikram ret = set_signature(osroot, osdev, sign, fstype); 5252eb2bd662Svikram INJECT_ERROR1("SET_SIGNATURE_FAIL", ret = -1); 5253eb2bd662Svikram if (ret == -1) { 5254eb2bd662Svikram bam_error(GRUBSIGN_WRITE_FAIL, osdev); 5255eb2bd662Svikram free(sign); 5256eb2bd662Svikram free(fstype); 5257eb2bd662Svikram (void) unlink(UFS_SIGNATURE_LIST); 5258eb2bd662Svikram return (NULL); 5259eb2bd662Svikram } 5260eb2bd662Svikram 5261eb2bd662Svikram free(fstype); 5262eb2bd662Svikram 5263eb2bd662Svikram if (bam_verbose) 5264eb2bd662Svikram bam_print(GRUBSIGN_FOUND_OR_CREATED, sign, osdev); 5265eb2bd662Svikram 5266eb2bd662Svikram fdiskpart = get_partition(osdev); 5267eb2bd662Svikram INJECT_ERROR1("GET_GRUBSIGN_FDISK", fdiskpart = -1); 5268eb2bd662Svikram if (fdiskpart == -1) { 5269eb2bd662Svikram bam_error(FDISKPART_FAIL, osdev); 5270eb2bd662Svikram free(sign); 5271eb2bd662Svikram return (NULL); 5272eb2bd662Svikram } 5273eb2bd662Svikram 5274eb2bd662Svikram slice = strrchr(osdev, 's'); 5275eb2bd662Svikram 5276eb2bd662Svikram grubsign = s_calloc(1, MAXNAMELEN + 10); 5277eb2bd662Svikram if (slice) { 5278eb2bd662Svikram (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d,%c)", 5279eb2bd662Svikram sign, fdiskpart, slice[1] + 'a' - '0'); 5280eb2bd662Svikram } else 5281eb2bd662Svikram (void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d)", 5282eb2bd662Svikram sign, fdiskpart); 5283eb2bd662Svikram 5284eb2bd662Svikram free(sign); 5285eb2bd662Svikram 5286eb2bd662Svikram BAM_DPRINTF((D_GET_GRUBSIGN_SUCCESS, fcn, grubsign)); 5287eb2bd662Svikram 5288eb2bd662Svikram return (grubsign); 5289eb2bd662Svikram } 5290eb2bd662Svikram 5291eb2bd662Svikram static char * 5292eb2bd662Svikram get_title(char *rootdir) 5293eb2bd662Svikram { 5294eb2bd662Svikram static char title[80]; 5295eb2bd662Svikram char *cp = NULL; 5296eb2bd662Svikram char release[PATH_MAX]; 5297eb2bd662Svikram FILE *fp; 5298eb2bd662Svikram const char *fcn = "get_title()"; 5299eb2bd662Svikram 5300eb2bd662Svikram /* open the /etc/release file */ 5301eb2bd662Svikram (void) snprintf(release, sizeof (release), "%s/etc/release", rootdir); 5302eb2bd662Svikram 5303eb2bd662Svikram fp = fopen(release, "r"); 5304eb2bd662Svikram if (fp == NULL) { 5305eb2bd662Svikram bam_error(OPEN_FAIL, release, strerror(errno)); 5306eb2bd662Svikram cp = NULL; 5307eb2bd662Svikram goto out; 5308eb2bd662Svikram } 5309eb2bd662Svikram 5310eb2bd662Svikram while (s_fgets(title, sizeof (title), fp) != NULL) { 5311eb2bd662Svikram cp = strstr(title, "Solaris"); 5312eb2bd662Svikram if (cp) 5313eb2bd662Svikram break; 5314eb2bd662Svikram } 5315eb2bd662Svikram (void) fclose(fp); 5316eb2bd662Svikram 5317eb2bd662Svikram out: 5318eb2bd662Svikram cp = cp ? cp : "Solaris"; 5319eb2bd662Svikram 5320eb2bd662Svikram BAM_DPRINTF((D_GET_TITLE, fcn, cp)); 5321eb2bd662Svikram 5322eb2bd662Svikram return (cp); 5323eb2bd662Svikram } 5324eb2bd662Svikram 5325eb2bd662Svikram char * 5326eb2bd662Svikram get_special(char *mountp) 5327eb2bd662Svikram { 5328eb2bd662Svikram FILE *mntfp; 5329eb2bd662Svikram struct mnttab mp = {0}; 5330eb2bd662Svikram struct mnttab mpref = {0}; 5331eb2bd662Svikram int error; 5332eb2bd662Svikram int ret; 5333eb2bd662Svikram const char *fcn = "get_special()"; 5334eb2bd662Svikram 5335eb2bd662Svikram INJECT_ERROR1("GET_SPECIAL_MNTPT", mountp = NULL); 5336eb2bd662Svikram if (mountp == NULL) { 5337eb2bd662Svikram bam_error(GET_SPECIAL_NULL_MNTPT); 5338eb2bd662Svikram return (NULL); 5339eb2bd662Svikram } 5340eb2bd662Svikram 5341eb2bd662Svikram mntfp = fopen(MNTTAB, "r"); 5342eb2bd662Svikram error = errno; 5343eb2bd662Svikram INJECT_ERROR1("GET_SPECIAL_MNTTAB_OPEN", mntfp = NULL); 5344eb2bd662Svikram if (mntfp == NULL) { 5345eb2bd662Svikram bam_error(OPEN_FAIL, MNTTAB, strerror(error)); 5346eb2bd662Svikram return (NULL); 5347eb2bd662Svikram } 5348eb2bd662Svikram 5349eb2bd662Svikram if (*mountp == '\0') 5350eb2bd662Svikram mpref.mnt_mountp = "/"; 5351eb2bd662Svikram else 5352eb2bd662Svikram mpref.mnt_mountp = mountp; 5353eb2bd662Svikram 5354eb2bd662Svikram ret = getmntany(mntfp, &mp, &mpref); 5355eb2bd662Svikram INJECT_ERROR1("GET_SPECIAL_MNTTAB_SEARCH", ret = 1); 5356eb2bd662Svikram if (ret != 0) { 5357eb2bd662Svikram (void) fclose(mntfp); 5358eb2bd662Svikram BAM_DPRINTF((D_GET_SPECIAL_NOT_IN_MNTTAB, fcn, mountp)); 5359eb2bd662Svikram return (NULL); 5360eb2bd662Svikram } 5361eb2bd662Svikram (void) fclose(mntfp); 5362eb2bd662Svikram 5363eb2bd662Svikram BAM_DPRINTF((D_GET_SPECIAL, fcn, mp.mnt_special)); 5364eb2bd662Svikram 5365eb2bd662Svikram return (s_strdup(mp.mnt_special)); 5366eb2bd662Svikram } 5367eb2bd662Svikram 5368eb2bd662Svikram static void 5369eb2bd662Svikram free_physarray(char **physarray, int n) 5370eb2bd662Svikram { 5371eb2bd662Svikram int i; 5372eb2bd662Svikram const char *fcn = "free_physarray()"; 5373eb2bd662Svikram 5374eb2bd662Svikram assert(physarray); 5375eb2bd662Svikram assert(n); 5376eb2bd662Svikram 5377eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY_N1, fcn, n)); 5378eb2bd662Svikram 5379eb2bd662Svikram for (i = 0; i < n; i++) { 5380eb2bd662Svikram free(physarray[i]); 5381eb2bd662Svikram } 5382eb2bd662Svikram free(physarray); 5383eb2bd662Svikram 5384eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5385eb2bd662Svikram } 5386eb2bd662Svikram 5387eb2bd662Svikram static int 5388eb2bd662Svikram zfs_get_physical(char *special, char ***physarray, int *n) 5389eb2bd662Svikram { 5390eb2bd662Svikram char sdup[PATH_MAX]; 5391eb2bd662Svikram char cmd[PATH_MAX]; 5392eb2bd662Svikram char dsk[PATH_MAX]; 5393eb2bd662Svikram char *pool; 5394eb2bd662Svikram filelist_t flist = {0}; 5395eb2bd662Svikram line_t *lp; 5396eb2bd662Svikram line_t *startlp; 5397eb2bd662Svikram char *comp1; 5398eb2bd662Svikram int i; 5399eb2bd662Svikram int ret; 5400eb2bd662Svikram const char *fcn = "zfs_get_physical()"; 5401eb2bd662Svikram 5402eb2bd662Svikram assert(special); 5403eb2bd662Svikram 5404eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, special)); 5405eb2bd662Svikram 5406eb2bd662Svikram INJECT_ERROR1("INVALID_ZFS_SPECIAL", special = "/foo"); 5407eb2bd662Svikram if (special[0] == '/') { 5408eb2bd662Svikram bam_error(INVALID_ZFS_SPECIAL, special); 5409eb2bd662Svikram return (-1); 5410eb2bd662Svikram } 5411eb2bd662Svikram 5412eb2bd662Svikram (void) strlcpy(sdup, special, sizeof (sdup)); 5413eb2bd662Svikram 5414eb2bd662Svikram pool = strtok(sdup, "/"); 5415eb2bd662Svikram INJECT_ERROR1("ZFS_GET_PHYS_POOL", pool = NULL); 5416eb2bd662Svikram if (pool == NULL) { 5417eb2bd662Svikram bam_error(CANT_FIND_POOL_FROM_SPECIAL, special); 5418eb2bd662Svikram return (-1); 5419eb2bd662Svikram } 5420eb2bd662Svikram 5421eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), "/sbin/zpool status %s", pool); 5422eb2bd662Svikram 5423eb2bd662Svikram ret = exec_cmd(cmd, &flist); 5424eb2bd662Svikram INJECT_ERROR1("ZFS_GET_PHYS_STATUS", ret = 1); 5425eb2bd662Svikram if (ret != 0) { 5426eb2bd662Svikram bam_error(ZFS_GET_POOL_STATUS, pool); 5427eb2bd662Svikram return (-1); 5428eb2bd662Svikram } 5429eb2bd662Svikram 5430eb2bd662Svikram INJECT_ERROR1("ZFS_GET_PHYS_STATUS_OUT", flist.head = NULL); 5431eb2bd662Svikram if (flist.head == NULL) { 5432eb2bd662Svikram bam_error(BAD_ZPOOL_STATUS, pool); 5433eb2bd662Svikram filelist_free(&flist); 5434eb2bd662Svikram return (-1); 5435eb2bd662Svikram } 5436eb2bd662Svikram 5437eb2bd662Svikram for (lp = flist.head; lp; lp = lp->next) { 5438eb2bd662Svikram BAM_DPRINTF((D_STRTOK_ZPOOL_STATUS, fcn, lp->line)); 5439eb2bd662Svikram comp1 = strtok(lp->line, " \t"); 5440eb2bd662Svikram if (comp1 == NULL) { 5441eb2bd662Svikram free(lp->line); 5442eb2bd662Svikram lp->line = NULL; 5443eb2bd662Svikram } else { 5444eb2bd662Svikram comp1 = s_strdup(comp1); 5445eb2bd662Svikram free(lp->line); 5446eb2bd662Svikram lp->line = comp1; 5447eb2bd662Svikram } 5448eb2bd662Svikram } 5449eb2bd662Svikram 5450eb2bd662Svikram for (lp = flist.head; lp; lp = lp->next) { 5451eb2bd662Svikram if (lp->line == NULL) 5452eb2bd662Svikram continue; 5453eb2bd662Svikram if (strcmp(lp->line, pool) == 0) { 5454eb2bd662Svikram BAM_DPRINTF((D_FOUND_POOL_IN_ZPOOL_STATUS, fcn, pool)); 5455eb2bd662Svikram break; 5456eb2bd662Svikram } 5457eb2bd662Svikram } 5458eb2bd662Svikram 5459eb2bd662Svikram if (lp == NULL) { 5460eb2bd662Svikram bam_error(NO_POOL_IN_ZPOOL_STATUS, pool); 5461eb2bd662Svikram filelist_free(&flist); 5462eb2bd662Svikram return (-1); 5463eb2bd662Svikram } 5464eb2bd662Svikram 5465eb2bd662Svikram startlp = lp->next; 5466eb2bd662Svikram for (i = 0, lp = startlp; lp; lp = lp->next) { 5467eb2bd662Svikram if (lp->line == NULL) 5468eb2bd662Svikram continue; 5469eb2bd662Svikram if (strcmp(lp->line, "mirror") == 0) 5470eb2bd662Svikram continue; 5471eb2bd662Svikram if (lp->line[0] == '\0' || strcmp(lp->line, "errors:") == 0) 5472eb2bd662Svikram break; 5473eb2bd662Svikram i++; 5474eb2bd662Svikram BAM_DPRINTF((D_COUNTING_ZFS_PHYS, fcn, i)); 5475eb2bd662Svikram } 5476eb2bd662Svikram 5477eb2bd662Svikram if (i == 0) { 5478eb2bd662Svikram bam_error(NO_PHYS_IN_ZPOOL_STATUS, pool); 5479eb2bd662Svikram filelist_free(&flist); 5480eb2bd662Svikram return (-1); 5481eb2bd662Svikram } 5482eb2bd662Svikram 5483eb2bd662Svikram *n = i; 5484eb2bd662Svikram *physarray = s_calloc(*n, sizeof (char *)); 5485eb2bd662Svikram for (i = 0, lp = startlp; lp; lp = lp->next) { 5486eb2bd662Svikram if (lp->line == NULL) 5487eb2bd662Svikram continue; 5488eb2bd662Svikram if (strcmp(lp->line, "mirror") == 0) 5489eb2bd662Svikram continue; 5490eb2bd662Svikram if (strcmp(lp->line, "errors:") == 0) 5491eb2bd662Svikram break; 5492eb2bd662Svikram if (strncmp(lp->line, "/dev/dsk/", strlen("/dev/dsk/")) != 0 && 5493eb2bd662Svikram strncmp(lp->line, "/dev/rdsk/", 5494eb2bd662Svikram strlen("/dev/rdsk/")) != 0) { 5495eb2bd662Svikram (void) snprintf(dsk, sizeof (dsk), "/dev/dsk/%s", 5496eb2bd662Svikram lp->line); 5497eb2bd662Svikram } else { 5498eb2bd662Svikram (void) strlcpy(dsk, lp->line, sizeof (dsk)); 5499eb2bd662Svikram } 5500eb2bd662Svikram BAM_DPRINTF((D_ADDING_ZFS_PHYS, fcn, dsk, pool)); 5501eb2bd662Svikram (*physarray)[i++] = s_strdup(dsk); 5502eb2bd662Svikram } 5503eb2bd662Svikram 5504eb2bd662Svikram assert(i == *n); 5505eb2bd662Svikram 5506eb2bd662Svikram filelist_free(&flist); 5507eb2bd662Svikram 5508eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5509eb2bd662Svikram return (0); 5510eb2bd662Svikram } 5511eb2bd662Svikram 5512eb2bd662Svikram static int 5513eb2bd662Svikram ufs_get_physical(char *special, char ***physarray, int *n) 5514eb2bd662Svikram { 5515eb2bd662Svikram char cmd[PATH_MAX]; 5516eb2bd662Svikram char *shortname; 5517eb2bd662Svikram filelist_t flist = {0}; 5518eb2bd662Svikram char *meta; 5519eb2bd662Svikram char *type; 5520eb2bd662Svikram char *comp1; 5521eb2bd662Svikram char *comp2; 5522eb2bd662Svikram char *comp3; 5523eb2bd662Svikram char *comp4; 5524eb2bd662Svikram int i; 5525eb2bd662Svikram line_t *lp; 5526eb2bd662Svikram int ret; 5527eb2bd662Svikram const char *fcn = "ufs_get_physical()"; 5528eb2bd662Svikram 5529eb2bd662Svikram assert(special); 5530eb2bd662Svikram 5531eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, special)); 5532eb2bd662Svikram 5533eb2bd662Svikram if (strncmp(special, "/dev/md/", strlen("/dev/md/")) != 0) { 5534eb2bd662Svikram bam_error(UFS_GET_PHYS_NOT_SVM, special); 5535eb2bd662Svikram return (-1); 5536eb2bd662Svikram } 5537eb2bd662Svikram 5538eb2bd662Svikram if (strncmp(special, "/dev/md/dsk/", strlen("/dev/md/dsk/")) == 0) { 5539eb2bd662Svikram shortname = special + strlen("/dev/md/dsk/"); 5540eb2bd662Svikram } else if (strncmp(special, "/dev/md/rdsk/", 5541eb2bd662Svikram strlen("/dev/md/rdsk/")) == 0) { 5542eb2bd662Svikram shortname = special + strlen("/dev/md/rdsk"); 5543eb2bd662Svikram } else { 5544eb2bd662Svikram bam_error(UFS_GET_PHYS_INVALID_SVM, special); 5545eb2bd662Svikram return (-1); 5546eb2bd662Svikram } 5547eb2bd662Svikram 5548eb2bd662Svikram BAM_DPRINTF((D_UFS_SVM_SHORT, fcn, special, shortname)); 5549eb2bd662Svikram 5550eb2bd662Svikram (void) snprintf(cmd, sizeof (cmd), "/sbin/metastat -p %s", shortname); 5551eb2bd662Svikram 5552eb2bd662Svikram ret = exec_cmd(cmd, &flist); 5553eb2bd662Svikram INJECT_ERROR1("UFS_SVM_METASTAT", ret = 1); 5554eb2bd662Svikram if (ret != 0) { 5555eb2bd662Svikram bam_error(UFS_SVM_METASTAT_ERR, shortname); 5556eb2bd662Svikram return (-1); 5557eb2bd662Svikram } 5558eb2bd662Svikram 5559eb2bd662Svikram INJECT_ERROR1("UFS_SVM_METASTAT_OUT", flist.head = NULL); 5560eb2bd662Svikram if (flist.head == NULL) { 5561eb2bd662Svikram bam_error(BAD_UFS_SVM_METASTAT, shortname); 5562eb2bd662Svikram filelist_free(&flist); 5563eb2bd662Svikram return (-1); 5564eb2bd662Svikram } 5565eb2bd662Svikram 5566eb2bd662Svikram /* 5567eb2bd662Svikram * Check if not a mirror. We only parse a single metadevice 5568eb2bd662Svikram * if not a mirror 5569eb2bd662Svikram */ 5570eb2bd662Svikram meta = strtok(flist.head->line, " \t"); 5571eb2bd662Svikram type = strtok(NULL, " \t"); 5572eb2bd662Svikram if (meta == NULL || type == NULL) { 5573eb2bd662Svikram bam_error(ERROR_PARSE_UFS_SVM_METASTAT, shortname); 5574eb2bd662Svikram filelist_free(&flist); 5575eb2bd662Svikram return (-1); 5576eb2bd662Svikram } 5577eb2bd662Svikram if (strcmp(type, "-m") != 0) { 5578eb2bd662Svikram comp1 = strtok(NULL, " \t"); 5579eb2bd662Svikram comp2 = strtok(NULL, " \t"); 5580eb2bd662Svikram if (comp1 == NULL || comp2 != NULL) { 5581eb2bd662Svikram bam_error(INVALID_UFS_SVM_METASTAT, shortname); 5582eb2bd662Svikram filelist_free(&flist); 5583eb2bd662Svikram return (-1); 5584eb2bd662Svikram } 5585eb2bd662Svikram BAM_DPRINTF((D_UFS_SVM_ONE_COMP, fcn, comp1, shortname)); 5586eb2bd662Svikram *physarray = s_calloc(1, sizeof (char *)); 5587eb2bd662Svikram (*physarray)[0] = s_strdup(comp1); 5588eb2bd662Svikram *n = 1; 5589eb2bd662Svikram filelist_free(&flist); 5590eb2bd662Svikram return (0); 5591eb2bd662Svikram } 5592eb2bd662Svikram 5593eb2bd662Svikram /* 5594eb2bd662Svikram * Okay we have a mirror. Everything after the first line 5595eb2bd662Svikram * is a submirror 5596eb2bd662Svikram */ 5597eb2bd662Svikram for (i = 0, lp = flist.head->next; lp; lp = lp->next) { 5598eb2bd662Svikram if (strstr(lp->line, "/dev/dsk/") == NULL && 5599eb2bd662Svikram strstr(lp->line, "/dev/rdsk/") == NULL) { 5600eb2bd662Svikram bam_error(CANNOT_PARSE_UFS_SVM_METASTAT, shortname); 5601eb2bd662Svikram filelist_free(&flist); 5602eb2bd662Svikram return (-1); 5603eb2bd662Svikram } 5604eb2bd662Svikram i++; 5605eb2bd662Svikram } 5606eb2bd662Svikram 5607eb2bd662Svikram *physarray = s_calloc(i, sizeof (char *)); 5608eb2bd662Svikram *n = i; 5609eb2bd662Svikram 5610eb2bd662Svikram for (i = 0, lp = flist.head->next; lp; lp = lp->next) { 5611eb2bd662Svikram comp1 = strtok(lp->line, " \t"); 5612eb2bd662Svikram comp2 = strtok(NULL, " \t"); 5613eb2bd662Svikram comp3 = strtok(NULL, " \t"); 5614eb2bd662Svikram comp4 = strtok(NULL, " \t"); 5615eb2bd662Svikram 5616eb2bd662Svikram if (comp3 == NULL || comp4 == NULL || 5617eb2bd662Svikram (strncmp(comp4, "/dev/dsk/", strlen("/dev/dsk/")) != 0 && 5618eb2bd662Svikram strncmp(comp4, "/dev/rdsk/", strlen("/dev/rdsk/")) != 0)) { 5619eb2bd662Svikram bam_error(CANNOT_PARSE_UFS_SVM_SUBMIRROR, shortname); 5620eb2bd662Svikram filelist_free(&flist); 5621eb2bd662Svikram free_physarray(*physarray, *n); 5622eb2bd662Svikram return (-1); 5623eb2bd662Svikram } 5624eb2bd662Svikram 5625eb2bd662Svikram (*physarray)[i++] = s_strdup(comp4); 5626eb2bd662Svikram } 5627eb2bd662Svikram 5628eb2bd662Svikram assert(i == *n); 5629eb2bd662Svikram 5630eb2bd662Svikram filelist_free(&flist); 5631eb2bd662Svikram 5632eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5633eb2bd662Svikram return (0); 5634eb2bd662Svikram } 5635eb2bd662Svikram 5636eb2bd662Svikram static int 5637eb2bd662Svikram get_physical(char *menu_root, char ***physarray, int *n) 5638eb2bd662Svikram { 5639eb2bd662Svikram char *special; 5640eb2bd662Svikram int ret; 5641eb2bd662Svikram const char *fcn = "get_physical()"; 5642eb2bd662Svikram 5643eb2bd662Svikram assert(menu_root); 5644eb2bd662Svikram assert(physarray); 5645eb2bd662Svikram assert(n); 5646eb2bd662Svikram 5647eb2bd662Svikram *physarray = NULL; 5648eb2bd662Svikram *n = 0; 5649eb2bd662Svikram 5650eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, menu_root)); 5651eb2bd662Svikram 5652eb2bd662Svikram /* First get the device special file from /etc/mnttab */ 5653eb2bd662Svikram special = get_special(menu_root); 5654eb2bd662Svikram INJECT_ERROR1("GET_PHYSICAL_SPECIAL", special = NULL); 5655eb2bd662Svikram if (special == NULL) { 5656eb2bd662Svikram bam_error(GET_SPECIAL_NULL, menu_root); 5657eb2bd662Svikram return (-1); 5658eb2bd662Svikram } 5659eb2bd662Svikram 5660eb2bd662Svikram /* If already a physical device nothing to do */ 5661eb2bd662Svikram if (strncmp(special, "/dev/dsk/", strlen("/dev/dsk/")) == 0 || 5662eb2bd662Svikram strncmp(special, "/dev/rdsk/", strlen("/dev/rdsk/")) == 0) { 5663eb2bd662Svikram BAM_DPRINTF((D_GET_PHYSICAL_ALREADY, fcn, menu_root, special)); 5664eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5665eb2bd662Svikram *physarray = s_calloc(1, sizeof (char *)); 5666eb2bd662Svikram (*physarray)[0] = special; 5667eb2bd662Svikram *n = 1; 5668eb2bd662Svikram return (0); 5669eb2bd662Svikram } 5670eb2bd662Svikram 5671eb2bd662Svikram if (is_zfs(menu_root)) { 5672eb2bd662Svikram ret = zfs_get_physical(special, physarray, n); 5673eb2bd662Svikram } else if (is_ufs(menu_root)) { 5674eb2bd662Svikram ret = ufs_get_physical(special, physarray, n); 5675eb2bd662Svikram } else { 5676eb2bd662Svikram bam_error(GET_PHYSICAL_NOTSUP_FSTYPE, menu_root, special); 5677eb2bd662Svikram ret = -1; 5678eb2bd662Svikram } 5679eb2bd662Svikram 5680eb2bd662Svikram free(special); 5681eb2bd662Svikram 5682eb2bd662Svikram INJECT_ERROR1("GET_PHYSICAL_RET", ret = -1); 5683eb2bd662Svikram if (ret == -1) { 5684eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5685eb2bd662Svikram } else { 5686eb2bd662Svikram int i; 5687eb2bd662Svikram assert (*n > 0); 5688eb2bd662Svikram for (i = 0; i < *n; i++) { 5689eb2bd662Svikram BAM_DPRINTF((D_GET_PHYSICAL_RET, fcn, (*physarray)[i])); 5690eb2bd662Svikram } 5691eb2bd662Svikram } 5692eb2bd662Svikram 5693eb2bd662Svikram return (ret); 5694eb2bd662Svikram } 5695eb2bd662Svikram 5696eb2bd662Svikram static int 5697eb2bd662Svikram is_bootdisk(char *osroot, char *physical) 5698eb2bd662Svikram { 5699eb2bd662Svikram int ret; 5700eb2bd662Svikram char *grubroot; 5701eb2bd662Svikram char *bootp; 5702eb2bd662Svikram const char *fcn = "is_bootdisk()"; 5703eb2bd662Svikram 5704eb2bd662Svikram assert(osroot); 5705eb2bd662Svikram assert(physical); 5706eb2bd662Svikram 5707eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, physical)); 5708eb2bd662Svikram 5709eb2bd662Svikram bootp = strstr(physical, "p0:boot"); 5710eb2bd662Svikram if (bootp) 5711eb2bd662Svikram *bootp = '\0'; 5712eb2bd662Svikram /* 5713eb2bd662Svikram * We just want the BIOS mapping for menu disk. 5714eb2bd662Svikram * Don't pass menu_root to get_grubroot() as the 5715eb2bd662Svikram * check that it is used for is not relevant here. 5716eb2bd662Svikram * The osroot is immaterial as well - it is only used to 5717eb2bd662Svikram * to find create_diskmap script. Everything hinges on 5718eb2bd662Svikram * "physical" 5719eb2bd662Svikram */ 5720eb2bd662Svikram grubroot = get_grubroot(osroot, physical, NULL); 5721eb2bd662Svikram 5722eb2bd662Svikram INJECT_ERROR1("IS_BOOTDISK_GRUBROOT", grubroot = NULL); 5723eb2bd662Svikram if (grubroot == NULL) { 5724eb2bd662Svikram bam_error(NO_GRUBROOT_FOR_DISK, fcn, physical); 5725eb2bd662Svikram return (0); 5726eb2bd662Svikram } 5727eb2bd662Svikram ret = grubroot[3] == '0'; 5728eb2bd662Svikram free(grubroot); 5729eb2bd662Svikram 5730eb2bd662Svikram BAM_DPRINTF((D_RETURN_RET, fcn, ret)); 5731eb2bd662Svikram 5732eb2bd662Svikram return (ret); 5733eb2bd662Svikram } 5734eb2bd662Svikram 5735eb2bd662Svikram /* 5736eb2bd662Svikram * Check if menu is on the boot device 5737eb2bd662Svikram * Return 0 (false) on error 5738eb2bd662Svikram */ 5739eb2bd662Svikram static int 5740eb2bd662Svikram menu_on_bootdisk(char *osroot, char *menu_root) 5741eb2bd662Svikram { 5742eb2bd662Svikram char **physarray; 5743eb2bd662Svikram int ret; 5744eb2bd662Svikram int n; 5745eb2bd662Svikram int i; 5746eb2bd662Svikram int on_bootdisk; 5747eb2bd662Svikram const char *fcn = "menu_on_bootdisk()"; 5748eb2bd662Svikram 5749eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, menu_root)); 5750eb2bd662Svikram 5751eb2bd662Svikram ret = get_physical(menu_root, &physarray, &n); 5752eb2bd662Svikram INJECT_ERROR1("MENU_ON_BOOTDISK_PHYSICAL", ret = -1); 5753eb2bd662Svikram if (ret != 0) { 5754eb2bd662Svikram bam_error(GET_PHYSICAL_MENU_NULL, menu_root); 5755eb2bd662Svikram return (0); 5756eb2bd662Svikram } 5757eb2bd662Svikram 5758eb2bd662Svikram assert(physarray); 5759eb2bd662Svikram assert(n > 0); 5760eb2bd662Svikram 5761eb2bd662Svikram on_bootdisk = 0; 5762eb2bd662Svikram for (i = 0; i < n; i++) { 5763eb2bd662Svikram assert(strncmp(physarray[i], "/dev/dsk/", 5764eb2bd662Svikram strlen("/dev/dsk/")) == 0 || 5765eb2bd662Svikram strncmp(physarray[i], "/dev/rdsk/", 5766eb2bd662Svikram strlen("/dev/rdsk/")) == 0); 5767eb2bd662Svikram 5768eb2bd662Svikram BAM_DPRINTF((D_CHECK_ON_BOOTDISK, fcn, physarray[i])); 5769eb2bd662Svikram if (is_bootdisk(osroot, physarray[i])) { 5770eb2bd662Svikram on_bootdisk = 1; 5771eb2bd662Svikram BAM_DPRINTF((D_IS_ON_BOOTDISK, fcn, physarray[i])); 5772eb2bd662Svikram } 5773eb2bd662Svikram } 5774eb2bd662Svikram 5775eb2bd662Svikram free_physarray(physarray, n); 5776eb2bd662Svikram 5777eb2bd662Svikram INJECT_ERROR1("ON_BOOTDISK_YES", on_bootdisk = 1); 5778eb2bd662Svikram INJECT_ERROR1("ON_BOOTDISK_NO", on_bootdisk = 0); 5779eb2bd662Svikram if (on_bootdisk) { 5780eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 5781eb2bd662Svikram } else { 5782eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 5783eb2bd662Svikram } 5784eb2bd662Svikram 5785eb2bd662Svikram return (on_bootdisk); 57867c478bd9Sstevel@tonic-gate } 57877c478bd9Sstevel@tonic-gate 5788eb2bd662Svikram void 5789eb2bd662Svikram bam_add_line(menu_t *mp, entry_t *entry, line_t *prev, line_t *lp) 57907c478bd9Sstevel@tonic-gate { 5791eb2bd662Svikram const char *fcn = "bam_add_line()"; 57927c478bd9Sstevel@tonic-gate 5793eb2bd662Svikram assert(mp); 5794eb2bd662Svikram assert(entry); 5795eb2bd662Svikram assert(prev); 5796eb2bd662Svikram assert(lp); 5797eb2bd662Svikram 5798eb2bd662Svikram lp->next = prev->next; 5799eb2bd662Svikram if (prev->next) { 5800eb2bd662Svikram BAM_DPRINTF((D_ADD_LINE_PREV_NEXT, fcn)); 5801eb2bd662Svikram prev->next->prev = lp; 5802eb2bd662Svikram } else { 5803eb2bd662Svikram BAM_DPRINTF((D_ADD_LINE_NOT_PREV_NEXT, fcn)); 5804eb2bd662Svikram } 5805eb2bd662Svikram prev->next = lp; 5806eb2bd662Svikram lp->prev = prev; 58077c478bd9Sstevel@tonic-gate 5808eb2bd662Svikram if (entry->end == prev) { 5809eb2bd662Svikram BAM_DPRINTF((D_ADD_LINE_LAST_LINE_IN_ENTRY, fcn)); 5810eb2bd662Svikram entry->end = lp; 5811eb2bd662Svikram } 5812eb2bd662Svikram if (mp->end == prev) { 5813eb2bd662Svikram assert(lp->next == NULL); 5814eb2bd662Svikram mp->end = lp; 5815eb2bd662Svikram BAM_DPRINTF((D_ADD_LINE_LAST_LINE_IN_MENU, fcn)); 5816eb2bd662Svikram } 58177c478bd9Sstevel@tonic-gate } 58187c478bd9Sstevel@tonic-gate 58198c1b6884Sszhou /* 58208c1b6884Sszhou * look for matching bootadm entry with specified parameters 58218c1b6884Sszhou * Here are the rules (based on existing usage): 58228c1b6884Sszhou * - If title is specified, match on title only 5823eb2bd662Svikram * - Else, match on root/findroot, kernel, and module. 5824eb2bd662Svikram * Note that, if root_opt is non-zero, the absence of 5825eb2bd662Svikram * root line is considered a match. 58268c1b6884Sszhou */ 58278c1b6884Sszhou static entry_t * 5828eb2bd662Svikram find_boot_entry( 5829eb2bd662Svikram menu_t *mp, 5830eb2bd662Svikram char *title, 5831eb2bd662Svikram char *kernel, 5832eb2bd662Svikram char *findroot, 5833eb2bd662Svikram char *root, 5834eb2bd662Svikram char *module, 5835eb2bd662Svikram int root_opt, 5836eb2bd662Svikram int *entry_num) 58378c1b6884Sszhou { 5838eb2bd662Svikram int i; 5839eb2bd662Svikram line_t *lp; 5840eb2bd662Svikram entry_t *ent; 5841eb2bd662Svikram const char *fcn = "find_boot_entry()"; 5842eb2bd662Svikram 5843eb2bd662Svikram if (entry_num) 5844eb2bd662Svikram *entry_num = BAM_ERROR; 58458c1b6884Sszhou 58468c1b6884Sszhou /* find matching entry */ 58478c1b6884Sszhou for (i = 0, ent = mp->entries; ent; i++, ent = ent->next) { 58488c1b6884Sszhou lp = ent->start; 58498c1b6884Sszhou 58508c1b6884Sszhou /* first line of entry must be bootadm comment */ 58518c1b6884Sszhou lp = ent->start; 5852ae115bc7Smrj if (lp->flags != BAM_COMMENT || 5853ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_HDR) != 0) { 58548c1b6884Sszhou continue; 58558c1b6884Sszhou } 58568c1b6884Sszhou 58578c1b6884Sszhou /* advance to title line */ 58588c1b6884Sszhou lp = lp->next; 58598c1b6884Sszhou if (title) { 58608c1b6884Sszhou if (lp->flags == BAM_TITLE && lp->arg && 5861eb2bd662Svikram strcmp(lp->arg, title) == 0) { 5862eb2bd662Svikram BAM_DPRINTF((D_MATCHED_TITLE, fcn, title)); 58638c1b6884Sszhou break; 5864eb2bd662Svikram } 5865eb2bd662Svikram BAM_DPRINTF((D_NOMATCH_TITLE, fcn, title, lp->arg)); 58668c1b6884Sszhou continue; /* check title only */ 58678c1b6884Sszhou } 58688c1b6884Sszhou 58698c1b6884Sszhou lp = lp->next; /* advance to root line */ 5870843e1988Sjohnlev if (lp == NULL) { 5871843e1988Sjohnlev continue; 5872eb2bd662Svikram } else if (strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) == 0) { 5873eb2bd662Svikram INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_FINDROOT", 5874eb2bd662Svikram findroot = NULL); 5875eb2bd662Svikram if (findroot == NULL) { 5876eb2bd662Svikram BAM_DPRINTF((D_NOMATCH_FINDROOT_NULL, 5877eb2bd662Svikram fcn, lp->arg)); 5878eb2bd662Svikram continue; 5879eb2bd662Svikram } 5880eb2bd662Svikram /* findroot command found, try match */ 5881eb2bd662Svikram if (strcmp(lp->arg, findroot) != 0) { 5882eb2bd662Svikram BAM_DPRINTF((D_NOMATCH_FINDROOT, 5883eb2bd662Svikram fcn, findroot, lp->arg)); 5884eb2bd662Svikram continue; 5885eb2bd662Svikram } 5886eb2bd662Svikram BAM_DPRINTF((D_MATCHED_FINDROOT, fcn, findroot)); 5887eb2bd662Svikram lp = lp->next; /* advance to kernel line */ 5888843e1988Sjohnlev } else if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) { 5889eb2bd662Svikram INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_ROOT", root = NULL); 5890eb2bd662Svikram if (root == NULL) { 5891eb2bd662Svikram BAM_DPRINTF((D_NOMATCH_ROOT_NULL, 5892eb2bd662Svikram fcn, lp->arg)); 5893eb2bd662Svikram continue; 5894eb2bd662Svikram } 5895eb2bd662Svikram /* root cmd found, try match */ 58968c1b6884Sszhou if (strcmp(lp->arg, root) != 0) { 5897eb2bd662Svikram BAM_DPRINTF((D_NOMATCH_ROOT, 5898eb2bd662Svikram fcn, root, lp->arg)); 58998c1b6884Sszhou continue; 59008c1b6884Sszhou } 5901eb2bd662Svikram BAM_DPRINTF((D_MATCHED_ROOT, fcn, root)); 59028c1b6884Sszhou lp = lp->next; /* advance to kernel line */ 59038c1b6884Sszhou } else { 5904eb2bd662Svikram INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_NO", 5905eb2bd662Svikram root_opt = 0); 5906eb2bd662Svikram INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_YES", 5907eb2bd662Svikram root_opt = 1); 59088c1b6884Sszhou /* no root command, see if root is optional */ 59098c1b6884Sszhou if (root_opt == 0) { 5910eb2bd662Svikram BAM_DPRINTF((D_NO_ROOT_OPT, fcn)); 59118c1b6884Sszhou continue; 59128c1b6884Sszhou } 5913eb2bd662Svikram BAM_DPRINTF((D_ROOT_OPT, fcn)); 59148c1b6884Sszhou } 59158c1b6884Sszhou 59168c1b6884Sszhou if (lp == NULL || lp->next == NULL) { 59178c1b6884Sszhou continue; 59188c1b6884Sszhou } 59198c1b6884Sszhou 5920843e1988Sjohnlev if (kernel && 5921843e1988Sjohnlev (!check_cmd(lp->cmd, KERNEL_CMD, lp->arg, kernel))) { 5922843e1988Sjohnlev continue; 5923843e1988Sjohnlev } 5924eb2bd662Svikram BAM_DPRINTF((D_KERNEL_MATCH, fcn, kernel, lp->arg)); 5925843e1988Sjohnlev 59260d69385cSrscott /* 5927843e1988Sjohnlev * Check for matching module entry (failsafe or normal). 5928843e1988Sjohnlev * If it fails to match, we go around the loop again. 5929843e1988Sjohnlev * For xpv entries, there are two module lines, so we 5930843e1988Sjohnlev * do the check twice. 59310d69385cSrscott */ 59328c1b6884Sszhou lp = lp->next; /* advance to module line */ 5933843e1988Sjohnlev if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) || 5934843e1988Sjohnlev (((lp = lp->next) != NULL) && 5935843e1988Sjohnlev check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) { 5936843e1988Sjohnlev /* match found */ 5937eb2bd662Svikram BAM_DPRINTF((D_MODULE_MATCH, fcn, module, lp->arg)); 5938843e1988Sjohnlev break; 59398c1b6884Sszhou } 59408c1b6884Sszhou } 59418c1b6884Sszhou 5942eb2bd662Svikram if (ent && entry_num) { 5943843e1988Sjohnlev *entry_num = i; 5944843e1988Sjohnlev } 5945eb2bd662Svikram 5946eb2bd662Svikram if (ent) { 5947eb2bd662Svikram BAM_DPRINTF((D_RETURN_RET, fcn, i)); 5948eb2bd662Svikram } else { 5949eb2bd662Svikram BAM_DPRINTF((D_RETURN_RET, fcn, BAM_ERROR)); 5950eb2bd662Svikram } 59518c1b6884Sszhou return (ent); 59528c1b6884Sszhou } 59538c1b6884Sszhou 59548c1b6884Sszhou static int 5955eb2bd662Svikram update_boot_entry(menu_t *mp, char *title, char *findroot, char *root, 5956eb2bd662Svikram char *kernel, char *mod_kernel, char *module, int root_opt) 59578c1b6884Sszhou { 5958eb2bd662Svikram int i; 5959eb2bd662Svikram int change_kernel = 0; 5960eb2bd662Svikram entry_t *ent; 5961eb2bd662Svikram line_t *lp; 5962eb2bd662Svikram line_t *tlp; 5963eb2bd662Svikram char linebuf[BAM_MAXLINE]; 5964eb2bd662Svikram const char *fcn = "update_boot_entry()"; 59658c1b6884Sszhou 59668c1b6884Sszhou /* note: don't match on title, it's updated on upgrade */ 5967eb2bd662Svikram ent = find_boot_entry(mp, NULL, kernel, findroot, root, module, 5968eb2bd662Svikram root_opt, &i); 5969ae115bc7Smrj if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) { 5970ae115bc7Smrj /* 5971ae115bc7Smrj * We may be upgrading a kernel from multiboot to 5972eb2bd662Svikram * directboot. Look for a multiboot entry. A multiboot 5973eb2bd662Svikram * entry will not have a findroot line. 5974ae115bc7Smrj */ 5975eb2bd662Svikram ent = find_boot_entry(mp, NULL, "multiboot", NULL, root, 5976eb2bd662Svikram MULTIBOOT_ARCHIVE, root_opt, &i); 5977ae115bc7Smrj if (ent != NULL) { 5978eb2bd662Svikram BAM_DPRINTF((D_UPGRADE_FROM_MULTIBOOT, fcn, root)); 5979ae115bc7Smrj change_kernel = 1; 5980ae115bc7Smrj } 5981eb2bd662Svikram } else if (ent) { 5982eb2bd662Svikram BAM_DPRINTF((D_FOUND_FINDROOT, fcn, findroot)); 5983ae115bc7Smrj } 5984eb2bd662Svikram 5985eb2bd662Svikram if (ent == NULL) { 5986eb2bd662Svikram BAM_DPRINTF((D_ENTRY_NOT_FOUND_CREATING, fcn, findroot)); 5987eb2bd662Svikram return (add_boot_entry(mp, title, findroot, 5988843e1988Sjohnlev kernel, mod_kernel, module)); 5989eb2bd662Svikram } 59908c1b6884Sszhou 5991eb2bd662Svikram /* replace title of existing entry and update findroot line */ 59928c1b6884Sszhou lp = ent->start; 59938c1b6884Sszhou lp = lp->next; /* title line */ 59948c1b6884Sszhou (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 59958c1b6884Sszhou menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 59968c1b6884Sszhou free(lp->arg); 59978c1b6884Sszhou free(lp->line); 59988c1b6884Sszhou lp->arg = s_strdup(title); 59998c1b6884Sszhou lp->line = s_strdup(linebuf); 6000eb2bd662Svikram BAM_DPRINTF((D_CHANGING_TITLE, fcn, title)); 60018c1b6884Sszhou 6002eb2bd662Svikram tlp = lp; /* title line */ 60038c1b6884Sszhou lp = lp->next; /* root line */ 6004eb2bd662Svikram 6005eb2bd662Svikram /* if no root or findroot command, create a new line_t */ 6006eb2bd662Svikram if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) != 0 && 6007eb2bd662Svikram strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) != 0) { 6008eb2bd662Svikram lp = s_calloc(1, sizeof (line_t)); 6009eb2bd662Svikram bam_add_line(mp, ent, tlp, lp); 6010eb2bd662Svikram } else { 6011eb2bd662Svikram free(lp->cmd); 6012eb2bd662Svikram free(lp->sep); 6013eb2bd662Svikram free(lp->arg); 6014eb2bd662Svikram free(lp->line); 60158c1b6884Sszhou } 6016ae115bc7Smrj 6017eb2bd662Svikram lp->cmd = s_strdup(menu_cmds[FINDROOT_CMD]); 6018eb2bd662Svikram lp->sep = s_strdup(menu_cmds[SEP_CMD]); 6019eb2bd662Svikram lp->arg = s_strdup(findroot); 6020eb2bd662Svikram (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 6021eb2bd662Svikram menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot); 6022eb2bd662Svikram lp->line = s_strdup(linebuf); 6023eb2bd662Svikram BAM_DPRINTF((D_ADDING_FINDROOT_LINE, fcn, findroot)); 6024eb2bd662Svikram 6025eb2bd662Svikram /* kernel line */ 6026eb2bd662Svikram lp = lp->next; 6027eb2bd662Svikram 6028ae115bc7Smrj if (change_kernel) { 6029ae115bc7Smrj /* 6030ae115bc7Smrj * We're upgrading from multiboot to directboot. 6031ae115bc7Smrj */ 6032ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) { 6033ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 6034ae115bc7Smrj menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD], 6035ae115bc7Smrj kernel); 6036eb2bd662Svikram free(lp->cmd); 6037ae115bc7Smrj free(lp->arg); 6038ae115bc7Smrj free(lp->line); 6039eb2bd662Svikram lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]); 6040ae115bc7Smrj lp->arg = s_strdup(kernel); 6041ae115bc7Smrj lp->line = s_strdup(linebuf); 6042ae115bc7Smrj lp = lp->next; 6043eb2bd662Svikram BAM_DPRINTF((D_ADDING_KERNEL_DOLLAR, fcn, kernel)); 6044ae115bc7Smrj } 6045ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) { 6046ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 6047ae115bc7Smrj menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD], 6048ae115bc7Smrj module); 6049eb2bd662Svikram free(lp->cmd); 6050ae115bc7Smrj free(lp->arg); 6051ae115bc7Smrj free(lp->line); 6052eb2bd662Svikram lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]); 6053ae115bc7Smrj lp->arg = s_strdup(module); 6054ae115bc7Smrj lp->line = s_strdup(linebuf); 6055ae115bc7Smrj lp = lp->next; 6056eb2bd662Svikram BAM_DPRINTF((D_ADDING_MODULE_DOLLAR, fcn, module)); 6057ae115bc7Smrj } 6058ae115bc7Smrj } 6059eb2bd662Svikram BAM_DPRINTF((D_RETURN_RET, fcn, i)); 60608c1b6884Sszhou return (i); 60618c1b6884Sszhou } 60628c1b6884Sszhou 6063eb2bd662Svikram int 6064eb2bd662Svikram root_optional(char *osroot, char *menu_root) 6065eb2bd662Svikram { 6066eb2bd662Svikram char *ospecial; 6067eb2bd662Svikram char *mspecial; 6068eb2bd662Svikram char *slash; 6069eb2bd662Svikram int root_opt; 6070eb2bd662Svikram int ret1; 6071eb2bd662Svikram int ret2; 6072eb2bd662Svikram const char *fcn = "root_optional()"; 6073eb2bd662Svikram 6074eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, menu_root)); 6075eb2bd662Svikram 6076eb2bd662Svikram /* 6077eb2bd662Svikram * For all filesystems except ZFS, a straight compare of osroot 6078eb2bd662Svikram * and menu_root will tell us if root is optional. 6079eb2bd662Svikram * For ZFS, the situation is complicated by the fact that 6080eb2bd662Svikram * menu_root and osroot are always different 6081eb2bd662Svikram */ 6082eb2bd662Svikram ret1 = is_zfs(osroot); 6083eb2bd662Svikram ret2 = is_zfs(menu_root); 6084eb2bd662Svikram INJECT_ERROR1("ROOT_OPT_NOT_ZFS", ret1 = 0); 6085eb2bd662Svikram if (!ret1 || !ret2) { 6086eb2bd662Svikram BAM_DPRINTF((D_ROOT_OPT_NOT_ZFS, fcn, osroot, menu_root)); 6087eb2bd662Svikram root_opt = (strcmp(osroot, menu_root) == 0); 6088eb2bd662Svikram goto out; 6089eb2bd662Svikram } 6090eb2bd662Svikram 6091eb2bd662Svikram ospecial = get_special(osroot); 6092eb2bd662Svikram INJECT_ERROR1("ROOT_OPTIONAL_OSPECIAL", ospecial = NULL); 6093eb2bd662Svikram if (ospecial == NULL) { 6094eb2bd662Svikram bam_error(GET_OSROOT_SPECIAL_ERR, osroot); 6095eb2bd662Svikram return (0); 6096eb2bd662Svikram } 6097eb2bd662Svikram BAM_DPRINTF((D_ROOT_OPTIONAL_OSPECIAL, fcn, ospecial, osroot)); 6098eb2bd662Svikram 6099eb2bd662Svikram mspecial = get_special(menu_root); 6100eb2bd662Svikram INJECT_ERROR1("ROOT_OPTIONAL_MSPECIAL", mspecial = NULL); 6101eb2bd662Svikram if (mspecial == NULL) { 6102eb2bd662Svikram bam_error(GET_MENU_ROOT_SPECIAL_ERR, menu_root); 6103eb2bd662Svikram free(ospecial); 6104eb2bd662Svikram return (0); 6105eb2bd662Svikram } 6106eb2bd662Svikram BAM_DPRINTF((D_ROOT_OPTIONAL_MSPECIAL, fcn, mspecial, menu_root)); 6107eb2bd662Svikram 6108eb2bd662Svikram slash = strchr(ospecial, '/'); 6109eb2bd662Svikram if (slash) 6110eb2bd662Svikram *slash = '\0'; 6111eb2bd662Svikram BAM_DPRINTF((D_ROOT_OPTIONAL_FIXED_OSPECIAL, fcn, ospecial, osroot)); 6112eb2bd662Svikram 6113eb2bd662Svikram root_opt = (strcmp(ospecial, mspecial) == 0); 6114eb2bd662Svikram 6115eb2bd662Svikram free(ospecial); 6116eb2bd662Svikram free(mspecial); 6117eb2bd662Svikram 6118eb2bd662Svikram out: 6119eb2bd662Svikram INJECT_ERROR1("ROOT_OPTIONAL_NO", root_opt = 0); 6120eb2bd662Svikram INJECT_ERROR1("ROOT_OPTIONAL_YES", root_opt = 1); 6121eb2bd662Svikram if (root_opt) { 6122eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 6123eb2bd662Svikram } else { 6124eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 6125eb2bd662Svikram } 6126eb2bd662Svikram 6127eb2bd662Svikram return (root_opt); 6128eb2bd662Svikram } 6129eb2bd662Svikram 61307c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 61317c478bd9Sstevel@tonic-gate static error_t 6132eb2bd662Svikram update_entry(menu_t *mp, char *menu_root, char *osdev) 61337c478bd9Sstevel@tonic-gate { 6134eb2bd662Svikram int entry; 6135eb2bd662Svikram char *grubsign; 6136eb2bd662Svikram char *grubroot; 6137eb2bd662Svikram char *title; 6138eb2bd662Svikram char osroot[PATH_MAX]; 6139eb2bd662Svikram char *failsafe_kernel = NULL; 6140eb2bd662Svikram struct stat sbuf; 6141eb2bd662Svikram char failsafe[256]; 6142eb2bd662Svikram int ret; 6143eb2bd662Svikram const char *fcn = "update_entry()"; 61447c478bd9Sstevel@tonic-gate 61457c478bd9Sstevel@tonic-gate assert(mp); 6146eb2bd662Svikram assert(menu_root); 6147eb2bd662Svikram assert(osdev); 6148eb2bd662Svikram assert(bam_root); 6149eb2bd662Svikram 6150eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY3, fcn, menu_root, osdev, bam_root)); 6151eb2bd662Svikram 6152eb2bd662Svikram (void) strlcpy(osroot, bam_root, sizeof (osroot)); 61537c478bd9Sstevel@tonic-gate 61547c478bd9Sstevel@tonic-gate title = get_title(osroot); 6155eb2bd662Svikram assert(title); 61567c478bd9Sstevel@tonic-gate 6157eb2bd662Svikram grubsign = get_grubsign(osroot, osdev); 6158eb2bd662Svikram INJECT_ERROR1("GET_GRUBSIGN_FAIL", grubsign = NULL); 6159eb2bd662Svikram if (grubsign == NULL) { 6160eb2bd662Svikram bam_error(GET_GRUBSIGN_ERROR, osroot, osdev); 61617c478bd9Sstevel@tonic-gate return (BAM_ERROR); 61627c478bd9Sstevel@tonic-gate } 6163eb2bd662Svikram 6164eb2bd662Svikram /* 6165eb2bd662Svikram * It is not a fatal error if get_grubroot() fails 6166eb2bd662Svikram * We no longer rely on biosdev to populate the 6167eb2bd662Svikram * menu 6168eb2bd662Svikram */ 6169eb2bd662Svikram grubroot = get_grubroot(osroot, osdev, menu_root); 6170eb2bd662Svikram INJECT_ERROR1("GET_GRUBROOT_FAIL", grubroot = NULL); 6171eb2bd662Svikram if (grubroot) { 6172eb2bd662Svikram BAM_DPRINTF((D_GET_GRUBROOT_SUCCESS, 6173eb2bd662Svikram fcn, osroot, osdev, menu_root)); 6174eb2bd662Svikram } else { 6175eb2bd662Svikram BAM_DPRINTF((D_GET_GRUBROOT_FAILURE, 6176eb2bd662Svikram fcn, osroot, osdev, menu_root)); 61777c478bd9Sstevel@tonic-gate } 61787c478bd9Sstevel@tonic-gate 61797c478bd9Sstevel@tonic-gate /* add the entry for normal Solaris */ 6180eb2bd662Svikram INJECT_ERROR1("UPDATE_ENTRY_MULTIBOOT", 6181eb2bd662Svikram bam_direct = BAM_DIRECT_MULTIBOOT); 6182ae115bc7Smrj if (bam_direct == BAM_DIRECT_DBOOT) { 6183eb2bd662Svikram entry = update_boot_entry(mp, title, grubsign, grubroot, 6184e7cbe64fSgw (bam_zfs ? DIRECT_BOOT_KERNEL_ZFS : DIRECT_BOOT_KERNEL), 6185eb2bd662Svikram NULL, DIRECT_BOOT_ARCHIVE, 6186eb2bd662Svikram root_optional(osroot, menu_root)); 6187eb2bd662Svikram BAM_DPRINTF((D_UPDATED_BOOT_ENTRY, fcn, bam_zfs, grubsign)); 6188843e1988Sjohnlev if ((entry != BAM_ERROR) && (bam_is_hv == BAM_HV_PRESENT)) { 6189eb2bd662Svikram (void) update_boot_entry(mp, NEW_HV_ENTRY, grubsign, 6190eb2bd662Svikram grubroot, XEN_MENU, bam_zfs ? 6191eb2bd662Svikram XEN_KERNEL_MODULE_LINE_ZFS : XEN_KERNEL_MODULE_LINE, 6192eb2bd662Svikram DIRECT_BOOT_ARCHIVE, 6193eb2bd662Svikram root_optional(osroot, menu_root)); 6194eb2bd662Svikram BAM_DPRINTF((D_UPDATED_HV_ENTRY, 6195eb2bd662Svikram fcn, bam_zfs, grubsign)); 6196843e1988Sjohnlev } 6197ae115bc7Smrj } else { 6198eb2bd662Svikram entry = update_boot_entry(mp, title, grubsign, grubroot, 6199eb2bd662Svikram MULTI_BOOT, NULL, MULTIBOOT_ARCHIVE, 6200eb2bd662Svikram root_optional(osroot, menu_root)); 6201eb2bd662Svikram 6202eb2bd662Svikram BAM_DPRINTF((D_UPDATED_MULTIBOOT_ENTRY, fcn, grubsign)); 6203ae115bc7Smrj } 62047c478bd9Sstevel@tonic-gate 6205843e1988Sjohnlev /* 6206843e1988Sjohnlev * Add the entry for failsafe archive. On a bfu'd system, the 6207843e1988Sjohnlev * failsafe may be different than the installed kernel. 6208843e1988Sjohnlev */ 6209eb2bd662Svikram (void) snprintf(failsafe, sizeof (failsafe), "%s%s", 6210eb2bd662Svikram osroot, FAILSAFE_ARCHIVE); 6211ae115bc7Smrj if (stat(failsafe, &sbuf) == 0) { 621260d0a590Srscott 621360d0a590Srscott /* Figure out where the kernel line should point */ 621460d0a590Srscott (void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot, 621560d0a590Srscott DIRECT_BOOT_FAILSAFE_KERNEL); 621660d0a590Srscott if (stat(failsafe, &sbuf) == 0) { 6217e7cbe64fSgw failsafe_kernel = 6218e7cbe64fSgw (bam_zfs ? DIRECT_BOOT_FAILSAFE_LINE_ZFS : 6219e7cbe64fSgw DIRECT_BOOT_FAILSAFE_LINE); 622060d0a590Srscott } else { 622160d0a590Srscott (void) snprintf(failsafe, sizeof (failsafe), "%s%s", 622260d0a590Srscott osroot, MULTI_BOOT_FAILSAFE); 622360d0a590Srscott if (stat(failsafe, &sbuf) == 0) { 622460d0a590Srscott failsafe_kernel = MULTI_BOOT_FAILSAFE_LINE; 622560d0a590Srscott } 622660d0a590Srscott } 622760d0a590Srscott if (failsafe_kernel != NULL) { 6228eb2bd662Svikram (void) update_boot_entry(mp, FAILSAFE_TITLE, grubsign, 6229eb2bd662Svikram grubroot, failsafe_kernel, NULL, FAILSAFE_ARCHIVE, 6230eb2bd662Svikram root_optional(osroot, menu_root)); 6231eb2bd662Svikram BAM_DPRINTF((D_UPDATED_FAILSAFE_ENTRY, fcn, 6232eb2bd662Svikram failsafe_kernel)); 623360d0a590Srscott } 6234ae115bc7Smrj } 6235eb2bd662Svikram free(grubroot); 62367c478bd9Sstevel@tonic-gate 6237eb2bd662Svikram INJECT_ERROR1("UPDATE_ENTRY_ERROR", entry = BAM_ERROR); 62387c478bd9Sstevel@tonic-gate if (entry == BAM_ERROR) { 6239eb2bd662Svikram bam_error(FAILED_TO_ADD_BOOT_ENTRY, title, grubsign); 6240eb2bd662Svikram free(grubsign); 62417c478bd9Sstevel@tonic-gate return (BAM_ERROR); 62427c478bd9Sstevel@tonic-gate } 6243eb2bd662Svikram free(grubsign); 6244b610f78eSvikram 6245eb2bd662Svikram update_numbering(mp); 6246eb2bd662Svikram ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 6247eb2bd662Svikram INJECT_ERROR1("SET_DEFAULT_ERROR", ret = BAM_ERROR); 6248eb2bd662Svikram if (ret == BAM_ERROR) { 6249eb2bd662Svikram bam_error(SET_DEFAULT_FAILED, entry); 6250b610f78eSvikram } 6251eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 6252eb2bd662Svikram return (BAM_WRITE); 6253b610f78eSvikram } 6254b610f78eSvikram 62558c1b6884Sszhou static void 6256ae115bc7Smrj save_default_entry(menu_t *mp, const char *which) 62578c1b6884Sszhou { 6258eb2bd662Svikram int lineNum; 6259eb2bd662Svikram int entryNum; 6260eb2bd662Svikram int entry = 0; /* default is 0 */ 6261eb2bd662Svikram char linebuf[BAM_MAXLINE]; 6262eb2bd662Svikram line_t *lp = mp->curdefault; 6263eb2bd662Svikram const char *fcn = "save_default_entry()"; 62648c1b6884Sszhou 6265bff269d0Svikram if (mp->start) { 6266bff269d0Svikram lineNum = mp->end->lineNum; 6267bff269d0Svikram entryNum = mp->end->entryNum; 6268bff269d0Svikram } else { 6269bff269d0Svikram lineNum = LINE_INIT; 6270bff269d0Svikram entryNum = ENTRY_INIT; 6271bff269d0Svikram } 6272bff269d0Svikram 62738c1b6884Sszhou if (lp) 62748c1b6884Sszhou entry = s_strtol(lp->arg); 62758c1b6884Sszhou 6276ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "#%s%d", which, entry); 6277eb2bd662Svikram BAM_DPRINTF((D_SAVING_DEFAULT_TO, fcn, linebuf)); 62788c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 6279eb2bd662Svikram BAM_DPRINTF((D_SAVED_DEFAULT_TO, fcn, lineNum, entryNum)); 62808c1b6884Sszhou } 62818c1b6884Sszhou 62828c1b6884Sszhou static void 6283ae115bc7Smrj restore_default_entry(menu_t *mp, const char *which, line_t *lp) 62848c1b6884Sszhou { 6285eb2bd662Svikram int entry; 6286eb2bd662Svikram char *str; 6287eb2bd662Svikram const char *fcn = "restore_default_entry()"; 62888c1b6884Sszhou 6289eb2bd662Svikram if (lp == NULL) { 6290eb2bd662Svikram BAM_DPRINTF((D_RESTORE_DEFAULT_NULL, fcn)); 62918c1b6884Sszhou return; /* nothing to restore */ 6292eb2bd662Svikram } 6293eb2bd662Svikram 6294eb2bd662Svikram BAM_DPRINTF((D_RESTORE_DEFAULT_STR, fcn, which)); 62958c1b6884Sszhou 6296ae115bc7Smrj str = lp->arg + strlen(which); 62978c1b6884Sszhou entry = s_strtol(str); 62988c1b6884Sszhou (void) set_global(mp, menu_cmds[DEFAULT_CMD], entry); 62998c1b6884Sszhou 6300eb2bd662Svikram BAM_DPRINTF((D_RESTORED_DEFAULT_TO, fcn, entry)); 6301eb2bd662Svikram 63028c1b6884Sszhou /* delete saved old default line */ 63038c1b6884Sszhou unlink_line(mp, lp); 63048c1b6884Sszhou line_free(lp); 63058c1b6884Sszhou } 63068c1b6884Sszhou 63077c478bd9Sstevel@tonic-gate /* 63087c478bd9Sstevel@tonic-gate * This function is for supporting reboot with args. 63097c478bd9Sstevel@tonic-gate * The opt value can be: 63107c478bd9Sstevel@tonic-gate * NULL delete temp entry, if present 6311eb2bd662Svikram * entry=<n> switches default entry to <n> 63127c478bd9Sstevel@tonic-gate * else treated as boot-args and setup a temperary menu entry 63137c478bd9Sstevel@tonic-gate * and make it the default 6314eb2bd662Svikram * Note that we are always rebooting the current OS instance 6315eb2bd662Svikram * so osroot == / always. 63167c478bd9Sstevel@tonic-gate */ 63177c478bd9Sstevel@tonic-gate #define REBOOT_TITLE "Solaris_reboot_transient" 63187c478bd9Sstevel@tonic-gate 63198c1b6884Sszhou /*ARGSUSED*/ 63207c478bd9Sstevel@tonic-gate static error_t 6321eb2bd662Svikram update_temp(menu_t *mp, char *dummy, char *opt) 63227c478bd9Sstevel@tonic-gate { 6323eb2bd662Svikram int entry; 6324eb2bd662Svikram char *osdev; 6325eb2bd662Svikram char *fstype; 6326eb2bd662Svikram char *sign; 6327eb2bd662Svikram char *opt_ptr; 6328eb2bd662Svikram char *path; 6329eb2bd662Svikram char kernbuf[BUFSIZ]; 6330eb2bd662Svikram char args_buf[BUFSIZ]; 6331eb2bd662Svikram char signbuf[PATH_MAX]; 6332eb2bd662Svikram int ret; 6333eb2bd662Svikram const char *fcn = "update_temp()"; 63347c478bd9Sstevel@tonic-gate 63357c478bd9Sstevel@tonic-gate assert(mp); 6336eb2bd662Svikram assert(dummy == NULL); 6337eb2bd662Svikram 6338eb2bd662Svikram /* opt can be NULL */ 6339eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, opt ? opt : "<NULL>")); 6340eb2bd662Svikram BAM_DPRINTF((D_BAM_ROOT, fcn, bam_alt_root, bam_root)); 6341eb2bd662Svikram 6342eb2bd662Svikram if (bam_alt_root || bam_rootlen != 1 || 6343eb2bd662Svikram strcmp(bam_root, "/") != 0 || 6344eb2bd662Svikram strcmp(rootbuf, "/") != 0) { 6345eb2bd662Svikram bam_error(ALT_ROOT_INVALID, bam_root); 6346eb2bd662Svikram return (BAM_ERROR); 6347eb2bd662Svikram } 63487c478bd9Sstevel@tonic-gate 63498c1b6884Sszhou /* If no option, delete exiting reboot menu entry */ 63508c1b6884Sszhou if (opt == NULL) { 6351eb2bd662Svikram entry_t *ent; 6352eb2bd662Svikram BAM_DPRINTF((D_OPT_NULL, fcn)); 6353eb2bd662Svikram ent = find_boot_entry(mp, REBOOT_TITLE, NULL, NULL, 6354eb2bd662Svikram NULL, NULL, 0, &entry); 6355eb2bd662Svikram if (ent == NULL) { /* not found is ok */ 6356eb2bd662Svikram BAM_DPRINTF((D_TRANSIENT_NOTFOUND, fcn)); 63578c1b6884Sszhou return (BAM_SUCCESS); 6358eb2bd662Svikram } 63598c1b6884Sszhou (void) do_delete(mp, entry); 6360ae115bc7Smrj restore_default_entry(mp, BAM_OLDDEF, mp->olddefault); 6361ae115bc7Smrj mp->olddefault = NULL; 6362eb2bd662Svikram BAM_DPRINTF((D_RESTORED_DEFAULT, fcn)); 6363eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 63648c1b6884Sszhou return (BAM_WRITE); 63658c1b6884Sszhou } 63668c1b6884Sszhou 63678c1b6884Sszhou /* if entry= is specified, set the default entry */ 6368eb2bd662Svikram if (strncmp(opt, "entry=", strlen("entry=")) == 0) { 6369eb2bd662Svikram int entryNum = s_strtol(opt + strlen("entry=")); 6370eb2bd662Svikram BAM_DPRINTF((D_ENTRY_EQUALS, fcn, opt)); 6371eb2bd662Svikram if (selector(mp, opt, &entry, NULL) == BAM_SUCCESS) { 6372eb2bd662Svikram /* this is entry=# option */ 6373eb2bd662Svikram ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 6374eb2bd662Svikram BAM_DPRINTF((D_ENTRY_SET_IS, fcn, entry, ret)); 6375eb2bd662Svikram return (ret); 6376eb2bd662Svikram } else { 6377eb2bd662Svikram bam_error(SET_DEFAULT_FAILED, entryNum); 6378eb2bd662Svikram return (BAM_ERROR); 6379eb2bd662Svikram } 6380eb2bd662Svikram } 6381eb2bd662Svikram 6382eb2bd662Svikram /* 6383eb2bd662Svikram * add a new menu entry based on opt and make it the default 6384eb2bd662Svikram */ 6385eb2bd662Svikram 6386eb2bd662Svikram fstype = get_fstype("/"); 6387eb2bd662Svikram INJECT_ERROR1("REBOOT_FSTYPE_NULL", fstype = NULL); 6388eb2bd662Svikram if (fstype == NULL) { 6389eb2bd662Svikram bam_error(REBOOT_FSTYPE_FAILED); 6390eb2bd662Svikram return (BAM_ERROR); 63917c478bd9Sstevel@tonic-gate } 63927c478bd9Sstevel@tonic-gate 6393eb2bd662Svikram osdev = get_special("/"); 6394eb2bd662Svikram INJECT_ERROR1("REBOOT_SPECIAL_NULL", osdev = NULL); 6395eb2bd662Svikram if (osdev == NULL) { 6396eb2bd662Svikram free(fstype); 6397eb2bd662Svikram bam_error(REBOOT_SPECIAL_FAILED); 6398eb2bd662Svikram return (BAM_ERROR); 6399eb2bd662Svikram } 6400eb2bd662Svikram 6401eb2bd662Svikram sign = find_existing_sign("/", osdev, fstype); 6402eb2bd662Svikram INJECT_ERROR1("REBOOT_SIGN_NULL", sign = NULL); 6403eb2bd662Svikram if (sign == NULL) { 6404eb2bd662Svikram free(fstype); 6405eb2bd662Svikram free(osdev); 6406eb2bd662Svikram bam_error(REBOOT_SIGN_FAILED); 6407eb2bd662Svikram return (BAM_ERROR); 6408eb2bd662Svikram } 6409eb2bd662Svikram 6410eb2bd662Svikram free(fstype); 6411eb2bd662Svikram free(osdev); 6412eb2bd662Svikram (void) strlcpy(signbuf, sign, sizeof (signbuf)); 6413eb2bd662Svikram free(sign); 6414eb2bd662Svikram 6415eb2bd662Svikram assert(strchr(signbuf, '(') == NULL && strchr(signbuf, ',') == NULL && 6416eb2bd662Svikram strchr(signbuf, ')') == NULL); 6417eb2bd662Svikram 64187c478bd9Sstevel@tonic-gate /* 6419eb2bd662Svikram * There is no alternate root while doing reboot with args 6420eb2bd662Svikram * This version of bootadm is only delivered with a DBOOT 6421eb2bd662Svikram * version of Solaris. 64227c478bd9Sstevel@tonic-gate */ 6423eb2bd662Svikram INJECT_ERROR1("REBOOT_NOT_DBOOT", bam_direct = BAM_DIRECT_MULTIBOOT); 6424eb2bd662Svikram if (bam_direct != BAM_DIRECT_DBOOT) { 6425eb2bd662Svikram bam_error(REBOOT_DIRECT_FAILED); 6426eb2bd662Svikram return (BAM_ERROR); 6427eb2bd662Svikram } 6428eb2bd662Svikram 6429eb2bd662Svikram /* add an entry for Solaris reboot */ 6430eb2bd662Svikram if (opt[0] == '-') { 6431eb2bd662Svikram /* It's an option - first see if boot-file is set */ 6432eb2bd662Svikram ret = get_kernel(mp, KERNEL_CMD, kernbuf, sizeof (kernbuf)); 6433eb2bd662Svikram INJECT_ERROR1("REBOOT_GET_KERNEL", ret = BAM_ERROR); 6434eb2bd662Svikram if (ret != BAM_SUCCESS) { 6435eb2bd662Svikram bam_error(REBOOT_GET_KERNEL_FAILED); 6436eb2bd662Svikram return (BAM_ERROR); 6437eb2bd662Svikram } 6438eb2bd662Svikram if (kernbuf[0] == '\0') 6439eb2bd662Svikram (void) strlcpy(kernbuf, DIRECT_BOOT_KERNEL, 6440eb2bd662Svikram sizeof (kernbuf)); 6441eb2bd662Svikram (void) strlcat(kernbuf, " ", sizeof (kernbuf)); 6442eb2bd662Svikram (void) strlcat(kernbuf, opt, sizeof (kernbuf)); 6443eb2bd662Svikram BAM_DPRINTF((D_REBOOT_OPTION, fcn, kernbuf)); 6444eb2bd662Svikram } else if (opt[0] == '/') { 6445eb2bd662Svikram /* It's a full path, so write it out. */ 6446eb2bd662Svikram (void) strlcpy(kernbuf, opt, sizeof (kernbuf)); 6447eb2bd662Svikram 6448b610f78eSvikram /* 6449eb2bd662Svikram * If someone runs: 6450eb2bd662Svikram * 6451eb2bd662Svikram * # eeprom boot-args='-kd' 6452eb2bd662Svikram * # reboot /platform/i86pc/kernel/unix 6453eb2bd662Svikram * 6454eb2bd662Svikram * we want to use the boot-args as part of the boot 6455eb2bd662Svikram * line. On the other hand, if someone runs: 6456eb2bd662Svikram * 6457eb2bd662Svikram * # reboot "/platform/i86pc/kernel/unix -kd" 6458eb2bd662Svikram * 6459eb2bd662Svikram * we don't need to mess with boot-args. If there's 6460eb2bd662Svikram * no space in the options string, assume we're in the 6461eb2bd662Svikram * first case. 6462b610f78eSvikram */ 6463eb2bd662Svikram if (strchr(opt, ' ') == NULL) { 6464eb2bd662Svikram ret = get_kernel(mp, ARGS_CMD, args_buf, 6465eb2bd662Svikram sizeof (args_buf)); 6466eb2bd662Svikram INJECT_ERROR1("REBOOT_GET_ARGS", ret = BAM_ERROR); 6467eb2bd662Svikram if (ret != BAM_SUCCESS) { 6468eb2bd662Svikram bam_error(REBOOT_GET_ARGS_FAILED); 6469eb2bd662Svikram return (BAM_ERROR); 6470eb2bd662Svikram } 6471eb2bd662Svikram 6472eb2bd662Svikram if (args_buf[0] != '\0') { 6473eb2bd662Svikram (void) strlcat(kernbuf, " ", sizeof (kernbuf)); 6474eb2bd662Svikram (void) strlcat(kernbuf, args_buf, 6475eb2bd662Svikram sizeof (kernbuf)); 6476eb2bd662Svikram } 6477b610f78eSvikram } 6478eb2bd662Svikram BAM_DPRINTF((D_REBOOT_ABSPATH, fcn, kernbuf)); 6479b610f78eSvikram } else { 6480b610f78eSvikram /* 6481eb2bd662Svikram * It may be a partial path, or it may be a partial 6482eb2bd662Svikram * path followed by options. Assume that only options 6483eb2bd662Svikram * follow a space. If someone sends us a kernel path 6484eb2bd662Svikram * that includes a space, they deserve to be broken. 6485b610f78eSvikram */ 6486eb2bd662Svikram opt_ptr = strchr(opt, ' '); 6487eb2bd662Svikram if (opt_ptr != NULL) { 6488eb2bd662Svikram *opt_ptr = '\0'; 6489eb2bd662Svikram } 64907c478bd9Sstevel@tonic-gate 6491eb2bd662Svikram path = expand_path(opt); 6492eb2bd662Svikram if (path != NULL) { 6493eb2bd662Svikram (void) strlcpy(kernbuf, path, sizeof (kernbuf)); 6494eb2bd662Svikram free(path); 6495455710d3Srscott 6496455710d3Srscott /* 6497eb2bd662Svikram * If there were options given, use those. 6498eb2bd662Svikram * Otherwise, copy over the default options. 6499455710d3Srscott */ 6500eb2bd662Svikram if (opt_ptr != NULL) { 6501eb2bd662Svikram /* Restore the space in opt string */ 6502eb2bd662Svikram *opt_ptr = ' '; 6503eb2bd662Svikram (void) strlcat(kernbuf, opt_ptr, 6504eb2bd662Svikram sizeof (kernbuf)); 6505eb2bd662Svikram } else { 6506eb2bd662Svikram ret = get_kernel(mp, ARGS_CMD, args_buf, 6507eb2bd662Svikram sizeof (args_buf)); 6508eb2bd662Svikram INJECT_ERROR1("UPDATE_TEMP_PARTIAL_ARGS", 6509eb2bd662Svikram ret = BAM_ERROR); 6510eb2bd662Svikram if (ret != BAM_SUCCESS) { 6511eb2bd662Svikram bam_error(REBOOT_GET_ARGS_FAILED); 6512455710d3Srscott return (BAM_ERROR); 6513eb2bd662Svikram } 6514455710d3Srscott 6515455710d3Srscott if (args_buf[0] != '\0') { 6516eb2bd662Svikram (void) strlcat(kernbuf, " ", 6517eb2bd662Svikram sizeof (kernbuf)); 6518eb2bd662Svikram (void) strlcat(kernbuf, 6519eb2bd662Svikram args_buf, sizeof (kernbuf)); 6520455710d3Srscott } 6521455710d3Srscott } 6522eb2bd662Svikram BAM_DPRINTF((D_REBOOT_RESOLVED_PARTIAL, fcn, kernbuf)); 6523ae115bc7Smrj } else { 6524eb2bd662Svikram bam_error(UNKNOWN_KERNEL, opt); 6525eb2bd662Svikram bam_print_stderr(UNKNOWN_KERNEL_REBOOT); 6526eb2bd662Svikram return (BAM_ERROR); 6527ae115bc7Smrj } 6528ae115bc7Smrj } 6529eb2bd662Svikram entry = add_boot_entry(mp, REBOOT_TITLE, signbuf, kernbuf, 6530eb2bd662Svikram NULL, NULL); 6531eb2bd662Svikram INJECT_ERROR1("REBOOT_ADD_BOOT_ENTRY", entry = BAM_ERROR); 65327c478bd9Sstevel@tonic-gate if (entry == BAM_ERROR) { 6533eb2bd662Svikram bam_error(REBOOT_WITH_ARGS_ADD_ENTRY_FAILED); 65347c478bd9Sstevel@tonic-gate return (BAM_ERROR); 65357c478bd9Sstevel@tonic-gate } 65368c1b6884Sszhou 6537ae115bc7Smrj save_default_entry(mp, BAM_OLDDEF); 6538eb2bd662Svikram ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry); 6539eb2bd662Svikram INJECT_ERROR1("REBOOT_SET_GLOBAL", ret = BAM_ERROR); 6540eb2bd662Svikram if (ret == BAM_ERROR) { 6541eb2bd662Svikram bam_error(REBOOT_SET_DEFAULT_FAILED, entry); 6542eb2bd662Svikram } 6543eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 65447c478bd9Sstevel@tonic-gate return (BAM_WRITE); 65457c478bd9Sstevel@tonic-gate } 65467c478bd9Sstevel@tonic-gate 65477c478bd9Sstevel@tonic-gate static error_t 65487c478bd9Sstevel@tonic-gate set_global(menu_t *mp, char *globalcmd, int val) 65497c478bd9Sstevel@tonic-gate { 6550eb2bd662Svikram line_t *lp; 6551eb2bd662Svikram line_t *found; 6552eb2bd662Svikram line_t *last; 6553eb2bd662Svikram char *cp; 6554eb2bd662Svikram char *str; 6555eb2bd662Svikram char prefix[BAM_MAXLINE]; 6556eb2bd662Svikram size_t len; 6557eb2bd662Svikram const char *fcn = "set_global()"; 65587c478bd9Sstevel@tonic-gate 65597c478bd9Sstevel@tonic-gate assert(mp); 65607c478bd9Sstevel@tonic-gate assert(globalcmd); 65617c478bd9Sstevel@tonic-gate 6562b610f78eSvikram if (strcmp(globalcmd, menu_cmds[DEFAULT_CMD]) == 0) { 6563eb2bd662Svikram INJECT_ERROR1("SET_GLOBAL_VAL_NEG", val = -1); 6564eb2bd662Svikram INJECT_ERROR1("SET_GLOBAL_MENU_EMPTY", mp->end = NULL); 6565eb2bd662Svikram INJECT_ERROR1("SET_GLOBAL_VAL_TOO_BIG", val = 100); 6566b610f78eSvikram if (val < 0 || mp->end == NULL || val > mp->end->entryNum) { 6567b610f78eSvikram (void) snprintf(prefix, sizeof (prefix), "%d", val); 6568b610f78eSvikram bam_error(INVALID_ENTRY, prefix); 6569b610f78eSvikram return (BAM_ERROR); 6570b610f78eSvikram } 6571b610f78eSvikram } 6572b610f78eSvikram 65737c478bd9Sstevel@tonic-gate found = last = NULL; 65747c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 65757c478bd9Sstevel@tonic-gate if (lp->flags != BAM_GLOBAL) 65767c478bd9Sstevel@tonic-gate continue; 65777c478bd9Sstevel@tonic-gate 65787c478bd9Sstevel@tonic-gate last = lp; /* track the last global found */ 65797c478bd9Sstevel@tonic-gate 6580eb2bd662Svikram INJECT_ERROR1("SET_GLOBAL_NULL_CMD", lp->cmd = NULL); 65817c478bd9Sstevel@tonic-gate if (lp->cmd == NULL) { 65827c478bd9Sstevel@tonic-gate bam_error(NO_CMD, lp->lineNum); 65837c478bd9Sstevel@tonic-gate continue; 65847c478bd9Sstevel@tonic-gate } 65857c478bd9Sstevel@tonic-gate if (strcmp(globalcmd, lp->cmd) != 0) 65867c478bd9Sstevel@tonic-gate continue; 65877c478bd9Sstevel@tonic-gate 6588eb2bd662Svikram BAM_DPRINTF((D_FOUND_GLOBAL, fcn, globalcmd)); 6589eb2bd662Svikram 65907c478bd9Sstevel@tonic-gate if (found) { 65917c478bd9Sstevel@tonic-gate bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root); 65927c478bd9Sstevel@tonic-gate } 65937c478bd9Sstevel@tonic-gate found = lp; 65947c478bd9Sstevel@tonic-gate } 65957c478bd9Sstevel@tonic-gate 65967c478bd9Sstevel@tonic-gate if (found == NULL) { 65977c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 65987c478bd9Sstevel@tonic-gate if (last == NULL) { 65997c478bd9Sstevel@tonic-gate lp->next = mp->start; 66007c478bd9Sstevel@tonic-gate mp->start = lp; 66017c478bd9Sstevel@tonic-gate mp->end = (mp->end) ? mp->end : lp; 66027c478bd9Sstevel@tonic-gate } else { 66037c478bd9Sstevel@tonic-gate lp->next = last->next; 66047c478bd9Sstevel@tonic-gate last->next = lp; 66057c478bd9Sstevel@tonic-gate if (lp->next == NULL) 66067c478bd9Sstevel@tonic-gate mp->end = lp; 66077c478bd9Sstevel@tonic-gate } 66087c478bd9Sstevel@tonic-gate lp->flags = BAM_GLOBAL; /* other fields not needed for writes */ 66097c478bd9Sstevel@tonic-gate len = strlen(globalcmd) + strlen(menu_cmds[SEP_CMD]); 66107c478bd9Sstevel@tonic-gate len += 10; /* val < 10 digits */ 66117c478bd9Sstevel@tonic-gate lp->line = s_calloc(1, len); 66127c478bd9Sstevel@tonic-gate (void) snprintf(lp->line, len, "%s%s%d", 66137c478bd9Sstevel@tonic-gate globalcmd, menu_cmds[SEP_CMD], val); 6614eb2bd662Svikram BAM_DPRINTF((D_SET_GLOBAL_WROTE_NEW, fcn, lp->line)); 6615eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 66167c478bd9Sstevel@tonic-gate return (BAM_WRITE); 66177c478bd9Sstevel@tonic-gate } 66187c478bd9Sstevel@tonic-gate 66197c478bd9Sstevel@tonic-gate /* 66207c478bd9Sstevel@tonic-gate * We are changing an existing entry. Retain any prefix whitespace, 66217c478bd9Sstevel@tonic-gate * but overwrite everything else. This preserves tabs added for 66227c478bd9Sstevel@tonic-gate * readability. 66237c478bd9Sstevel@tonic-gate */ 66247c478bd9Sstevel@tonic-gate str = found->line; 66257c478bd9Sstevel@tonic-gate cp = prefix; 66267c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 66277c478bd9Sstevel@tonic-gate *(cp++) = *(str++); 66287c478bd9Sstevel@tonic-gate *cp = '\0'; /* Terminate prefix */ 66297c478bd9Sstevel@tonic-gate len = strlen(prefix) + strlen(globalcmd); 66307c478bd9Sstevel@tonic-gate len += strlen(menu_cmds[SEP_CMD]) + 10; 66317c478bd9Sstevel@tonic-gate 66327c478bd9Sstevel@tonic-gate free(found->line); 66337c478bd9Sstevel@tonic-gate found->line = s_calloc(1, len); 66347c478bd9Sstevel@tonic-gate (void) snprintf(found->line, len, 6635455710d3Srscott "%s%s%s%d", prefix, globalcmd, menu_cmds[SEP_CMD], val); 66367c478bd9Sstevel@tonic-gate 6637eb2bd662Svikram BAM_DPRINTF((D_SET_GLOBAL_REPLACED, fcn, found->line)); 6638eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 66397c478bd9Sstevel@tonic-gate return (BAM_WRITE); /* need a write to menu */ 66407c478bd9Sstevel@tonic-gate } 66417c478bd9Sstevel@tonic-gate 6642ae115bc7Smrj /* 6643ae115bc7Smrj * partial_path may be anything like "kernel/unix" or "kmdb". Try to 6644455710d3Srscott * expand it to a full unix path. The calling function is expected to 6645455710d3Srscott * output a message if an error occurs and NULL is returned. 6646ae115bc7Smrj */ 6647ae115bc7Smrj static char * 6648ae115bc7Smrj expand_path(const char *partial_path) 6649ae115bc7Smrj { 6650eb2bd662Svikram int new_path_len; 6651eb2bd662Svikram char *new_path; 6652eb2bd662Svikram char new_path2[PATH_MAX]; 6653eb2bd662Svikram struct stat sb; 6654eb2bd662Svikram const char *fcn = "expand_path()"; 6655ae115bc7Smrj 6656ae115bc7Smrj new_path_len = strlen(partial_path) + 64; 6657ae115bc7Smrj new_path = s_calloc(1, new_path_len); 6658ae115bc7Smrj 6659ae115bc7Smrj /* First, try the simplest case - something like "kernel/unix" */ 6660ae115bc7Smrj (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s", 6661ae115bc7Smrj partial_path); 6662ae115bc7Smrj if (stat(new_path, &sb) == 0) { 6663eb2bd662Svikram BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path)); 6664ae115bc7Smrj return (new_path); 6665ae115bc7Smrj } 6666ae115bc7Smrj 6667ae115bc7Smrj if (strcmp(partial_path, "kmdb") == 0) { 6668ae115bc7Smrj (void) snprintf(new_path, new_path_len, "%s -k", 6669ae115bc7Smrj DIRECT_BOOT_KERNEL); 6670eb2bd662Svikram BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path)); 6671ae115bc7Smrj return (new_path); 6672ae115bc7Smrj } 6673ae115bc7Smrj 6674ae115bc7Smrj /* 6675ae115bc7Smrj * We've quickly reached unsupported usage. Try once more to 6676ae115bc7Smrj * see if we were just given a glom name. 6677ae115bc7Smrj */ 6678ae115bc7Smrj (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s/unix", 6679ae115bc7Smrj partial_path); 6680ae115bc7Smrj (void) snprintf(new_path2, PATH_MAX, "/platform/i86pc/%s/amd64/unix", 6681ae115bc7Smrj partial_path); 6682ae115bc7Smrj if (stat(new_path, &sb) == 0) { 6683ae115bc7Smrj if (stat(new_path2, &sb) == 0) { 6684ae115bc7Smrj /* 6685ae115bc7Smrj * We matched both, so we actually 6686ae115bc7Smrj * want to write the $ISADIR version. 6687ae115bc7Smrj */ 6688ae115bc7Smrj (void) snprintf(new_path, new_path_len, 6689ae115bc7Smrj "/platform/i86pc/kernel/%s/$ISADIR/unix", 6690ae115bc7Smrj partial_path); 6691ae115bc7Smrj } 6692eb2bd662Svikram BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path)); 6693ae115bc7Smrj return (new_path); 6694ae115bc7Smrj } 6695ae115bc7Smrj 6696ae115bc7Smrj free(new_path); 6697eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 6698ae115bc7Smrj return (NULL); 6699ae115bc7Smrj } 6700ae115bc7Smrj 6701ae115bc7Smrj /* 6702ae115bc7Smrj * The kernel cmd and arg have been changed, so 6703ae115bc7Smrj * check whether the archive line needs to change. 6704ae115bc7Smrj */ 6705ae115bc7Smrj static void 6706ae115bc7Smrj set_archive_line(entry_t *entryp, line_t *kernelp) 6707ae115bc7Smrj { 6708eb2bd662Svikram line_t *lp = entryp->start; 6709eb2bd662Svikram char *new_archive; 6710eb2bd662Svikram menu_cmd_t m_cmd; 6711eb2bd662Svikram const char *fcn = "set_archive_line()"; 6712ae115bc7Smrj 6713ae115bc7Smrj for (; lp != NULL; lp = lp->next) { 6714ae115bc7Smrj if (strncmp(lp->cmd, menu_cmds[MODULE_CMD], 6715ae115bc7Smrj sizeof (menu_cmds[MODULE_CMD]) - 1) == 0) { 6716ae115bc7Smrj break; 6717ae115bc7Smrj } 6718eb2bd662Svikram 6719eb2bd662Svikram INJECT_ERROR1("SET_ARCHIVE_LINE_END_ENTRY", lp = entryp->end); 6720eb2bd662Svikram if (lp == entryp->end) { 6721eb2bd662Svikram BAM_DPRINTF((D_ARCHIVE_LINE_NONE, fcn, 6722eb2bd662Svikram entryp->entryNum)); 6723ae115bc7Smrj return; 6724eb2bd662Svikram } 6725ae115bc7Smrj } 6726eb2bd662Svikram INJECT_ERROR1("SET_ARCHIVE_LINE_END_MENU", lp = NULL); 6727eb2bd662Svikram if (lp == NULL) { 6728eb2bd662Svikram BAM_DPRINTF((D_ARCHIVE_LINE_NONE, fcn, entryp->entryNum)); 6729ae115bc7Smrj return; 6730eb2bd662Svikram } 6731ae115bc7Smrj 6732ae115bc7Smrj if (strstr(kernelp->arg, "$ISADIR") != NULL) { 6733ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE; 6734ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 6735ae115bc7Smrj } else if (strstr(kernelp->arg, "amd64") != NULL) { 6736ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE_64; 6737ae115bc7Smrj m_cmd = MODULE_CMD; 6738ae115bc7Smrj } else { 6739ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE_32; 6740ae115bc7Smrj m_cmd = MODULE_CMD; 6741ae115bc7Smrj } 6742ae115bc7Smrj 6743eb2bd662Svikram if (strcmp(lp->arg, new_archive) == 0) { 6744eb2bd662Svikram BAM_DPRINTF((D_ARCHIVE_LINE_NOCHANGE, fcn, lp->arg)); 6745ae115bc7Smrj return; 6746eb2bd662Svikram } 6747ae115bc7Smrj 6748ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[m_cmd]) != 0) { 6749ae115bc7Smrj free(lp->cmd); 6750ae115bc7Smrj lp->cmd = s_strdup(menu_cmds[m_cmd]); 6751ae115bc7Smrj } 6752ae115bc7Smrj 6753ae115bc7Smrj free(lp->arg); 6754ae115bc7Smrj lp->arg = s_strdup(new_archive); 6755ae115bc7Smrj update_line(lp); 6756eb2bd662Svikram BAM_DPRINTF((D_ARCHIVE_LINE_REPLACED, fcn, lp->line)); 6757ae115bc7Smrj } 6758ae115bc7Smrj 6759ae115bc7Smrj /* 6760ae115bc7Smrj * Title for an entry to set properties that once went in bootenv.rc. 6761ae115bc7Smrj */ 6762ae115bc7Smrj #define BOOTENV_RC_TITLE "Solaris bootenv rc" 6763ae115bc7Smrj 6764ae115bc7Smrj /* 6765ae115bc7Smrj * If path is NULL, return the kernel (optnum == KERNEL_CMD) or arguments 6766ae115bc7Smrj * (optnum == ARGS_CMD) in the argument buf. If path is a zero-length 6767ae115bc7Smrj * string, reset the value to the default. If path is a non-zero-length 6768ae115bc7Smrj * string, set the kernel or arguments. 6769ae115bc7Smrj */ 6770ae115bc7Smrj static error_t 6771eb2bd662Svikram get_set_kernel( 6772eb2bd662Svikram menu_t *mp, 6773eb2bd662Svikram menu_cmd_t optnum, 6774eb2bd662Svikram char *path, 6775eb2bd662Svikram char *buf, 6776eb2bd662Svikram size_t bufsize) 6777ae115bc7Smrj { 6778eb2bd662Svikram int entryNum; 6779eb2bd662Svikram int rv = BAM_SUCCESS; 6780eb2bd662Svikram int free_new_path = 0; 6781eb2bd662Svikram entry_t *entryp; 6782eb2bd662Svikram line_t *ptr; 6783eb2bd662Svikram line_t *kernelp; 6784eb2bd662Svikram char *new_arg; 6785eb2bd662Svikram char *old_args; 6786eb2bd662Svikram char *space; 6787eb2bd662Svikram char *new_path; 6788eb2bd662Svikram char old_space; 6789eb2bd662Svikram size_t old_kernel_len; 6790eb2bd662Svikram size_t new_str_len; 6791eb2bd662Svikram char *fstype; 6792eb2bd662Svikram char *osdev; 6793eb2bd662Svikram char *sign; 6794eb2bd662Svikram char signbuf[PATH_MAX]; 6795eb2bd662Svikram int ret; 6796eb2bd662Svikram const char *fcn = "get_set_kernel()"; 6797ae115bc7Smrj 6798ae115bc7Smrj assert(bufsize > 0); 6799ae115bc7Smrj 6800ae115bc7Smrj ptr = kernelp = NULL; 6801ae115bc7Smrj new_arg = old_args = space = NULL; 6802eb2bd662Svikram new_path = NULL; 6803ae115bc7Smrj buf[0] = '\0'; 6804ae115bc7Smrj 6805eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_NOT_DBOOT", 6806eb2bd662Svikram bam_direct = BAM_DIRECT_MULTIBOOT); 6807ae115bc7Smrj if (bam_direct != BAM_DIRECT_DBOOT) { 6808ae115bc7Smrj bam_error(NOT_DBOOT, optnum == KERNEL_CMD ? "kernel" : "args"); 6809ae115bc7Smrj return (BAM_ERROR); 6810ae115bc7Smrj } 6811ae115bc7Smrj 6812ae115bc7Smrj /* 6813ae115bc7Smrj * If a user changed the default entry to a non-bootadm controlled 6814ae115bc7Smrj * one, we don't want to mess with it. Just print an error and 6815ae115bc7Smrj * return. 6816ae115bc7Smrj */ 6817ae115bc7Smrj if (mp->curdefault) { 6818ae115bc7Smrj entryNum = s_strtol(mp->curdefault->arg); 6819ae115bc7Smrj for (entryp = mp->entries; entryp; entryp = entryp->next) { 6820ae115bc7Smrj if (entryp->entryNum == entryNum) 6821ae115bc7Smrj break; 6822ae115bc7Smrj } 6823ae115bc7Smrj if ((entryp != NULL) && 6824ae115bc7Smrj ((entryp->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU)) == 0)) { 6825ae115bc7Smrj bam_error(DEFAULT_NOT_BAM); 6826ae115bc7Smrj return (BAM_ERROR); 6827ae115bc7Smrj } 6828ae115bc7Smrj } 6829ae115bc7Smrj 6830eb2bd662Svikram entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, NULL, 6831eb2bd662Svikram 0, &entryNum); 6832ae115bc7Smrj 6833ae115bc7Smrj if (entryp != NULL) { 6834ae115bc7Smrj for (ptr = entryp->start; ptr && ptr != entryp->end; 6835ae115bc7Smrj ptr = ptr->next) { 6836ae115bc7Smrj if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD], 6837ae115bc7Smrj sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) { 6838ae115bc7Smrj kernelp = ptr; 6839ae115bc7Smrj break; 6840ae115bc7Smrj } 6841ae115bc7Smrj } 6842ae115bc7Smrj if (kernelp == NULL) { 6843ae115bc7Smrj bam_error(NO_KERNEL, entryNum); 6844ae115bc7Smrj return (BAM_ERROR); 6845ae115bc7Smrj } 6846ae115bc7Smrj 6847ae115bc7Smrj old_kernel_len = strcspn(kernelp->arg, " \t"); 6848ae115bc7Smrj space = old_args = kernelp->arg + old_kernel_len; 6849ae115bc7Smrj while ((*old_args == ' ') || (*old_args == '\t')) 6850ae115bc7Smrj old_args++; 6851ae115bc7Smrj } 6852ae115bc7Smrj 6853ae115bc7Smrj if (path == NULL) { 6854eb2bd662Svikram if (entryp == NULL) { 6855eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_NO_RC, fcn)); 6856eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 6857ae115bc7Smrj return (BAM_SUCCESS); 6858eb2bd662Svikram } 6859eb2bd662Svikram assert(kernelp); 6860ae115bc7Smrj if (optnum == ARGS_CMD) { 6861eb2bd662Svikram if (old_args[0] != '\0') { 6862ae115bc7Smrj (void) strlcpy(buf, old_args, bufsize); 6863eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_ARGS, fcn, buf)); 6864eb2bd662Svikram } 6865ae115bc7Smrj } else { 6866ae115bc7Smrj /* 6867ae115bc7Smrj * We need to print the kernel, so we just turn the 6868ae115bc7Smrj * first space into a '\0' and print the beginning. 6869ae115bc7Smrj * We don't print anything if it's the default kernel. 6870ae115bc7Smrj */ 6871ae115bc7Smrj old_space = *space; 6872ae115bc7Smrj *space = '\0'; 6873eb2bd662Svikram if (strcmp(kernelp->arg, DIRECT_BOOT_KERNEL) != 0) { 6874ae115bc7Smrj (void) strlcpy(buf, kernelp->arg, bufsize); 6875eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_KERN, fcn, buf)); 6876eb2bd662Svikram } 6877ae115bc7Smrj *space = old_space; 6878ae115bc7Smrj } 6879eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 6880ae115bc7Smrj return (BAM_SUCCESS); 6881ae115bc7Smrj } 6882ae115bc7Smrj 6883ae115bc7Smrj /* 6884ae115bc7Smrj * First, check if we're resetting an entry to the default. 6885ae115bc7Smrj */ 6886ae115bc7Smrj if ((path[0] == '\0') || 6887ae115bc7Smrj ((optnum == KERNEL_CMD) && 6888ae115bc7Smrj (strcmp(path, DIRECT_BOOT_KERNEL) == 0))) { 6889ae115bc7Smrj if ((entryp == NULL) || (kernelp == NULL)) { 6890ae115bc7Smrj /* No previous entry, it's already the default */ 6891eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_ALREADY, fcn)); 6892ae115bc7Smrj return (BAM_SUCCESS); 6893ae115bc7Smrj } 6894ae115bc7Smrj 6895ae115bc7Smrj /* 6896ae115bc7Smrj * Check if we can delete the entry. If we're resetting the 6897ae115bc7Smrj * kernel command, and the args is already empty, or if we're 6898ae115bc7Smrj * resetting the args command, and the kernel is already the 6899ae115bc7Smrj * default, we can restore the old default and delete the entry. 6900ae115bc7Smrj */ 6901ae115bc7Smrj if (((optnum == KERNEL_CMD) && 6902ae115bc7Smrj ((old_args == NULL) || (old_args[0] == '\0'))) || 6903ae115bc7Smrj ((optnum == ARGS_CMD) && 6904ae115bc7Smrj (strncmp(kernelp->arg, DIRECT_BOOT_KERNEL, 6905ae115bc7Smrj sizeof (DIRECT_BOOT_KERNEL) - 1) == 0))) { 6906ae115bc7Smrj kernelp = NULL; 6907ae115bc7Smrj (void) do_delete(mp, entryNum); 6908ae115bc7Smrj restore_default_entry(mp, BAM_OLD_RC_DEF, 6909ae115bc7Smrj mp->old_rc_default); 6910ae115bc7Smrj mp->old_rc_default = NULL; 6911ae115bc7Smrj rv = BAM_WRITE; 6912eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_RESTORE_DEFAULT, fcn)); 6913ae115bc7Smrj goto done; 6914ae115bc7Smrj } 6915ae115bc7Smrj 6916ae115bc7Smrj if (optnum == KERNEL_CMD) { 6917ae115bc7Smrj /* 6918ae115bc7Smrj * At this point, we've already checked that old_args 6919ae115bc7Smrj * and entryp are valid pointers. The "+ 2" is for 6920ae115bc7Smrj * a space a the string termination character. 6921ae115bc7Smrj */ 6922ae115bc7Smrj new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) + 6923ae115bc7Smrj strlen(old_args) + 2; 6924ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 6925ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", 6926ae115bc7Smrj DIRECT_BOOT_KERNEL, old_args); 6927ae115bc7Smrj free(kernelp->arg); 6928ae115bc7Smrj kernelp->arg = new_arg; 6929ae115bc7Smrj 6930ae115bc7Smrj /* 6931ae115bc7Smrj * We have changed the kernel line, so we may need 6932ae115bc7Smrj * to update the archive line as well. 6933ae115bc7Smrj */ 6934ae115bc7Smrj set_archive_line(entryp, kernelp); 6935eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_RESET_KERNEL_SET_ARG, 6936eb2bd662Svikram fcn, kernelp->arg)); 6937ae115bc7Smrj } else { 6938ae115bc7Smrj /* 6939ae115bc7Smrj * We're resetting the boot args to nothing, so 6940ae115bc7Smrj * we only need to copy the kernel. We've already 6941ae115bc7Smrj * checked that the kernel is not the default. 6942ae115bc7Smrj */ 6943ae115bc7Smrj new_arg = s_calloc(1, old_kernel_len + 1); 6944ae115bc7Smrj (void) snprintf(new_arg, old_kernel_len + 1, "%s", 6945ae115bc7Smrj kernelp->arg); 6946ae115bc7Smrj free(kernelp->arg); 6947ae115bc7Smrj kernelp->arg = new_arg; 6948eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_RESET_ARG_SET_KERNEL, 6949eb2bd662Svikram fcn, kernelp->arg)); 6950ae115bc7Smrj } 6951ae115bc7Smrj rv = BAM_WRITE; 6952ae115bc7Smrj goto done; 6953ae115bc7Smrj } 6954ae115bc7Smrj 6955ae115bc7Smrj /* 6956ae115bc7Smrj * Expand the kernel file to a full path, if necessary 6957ae115bc7Smrj */ 6958ae115bc7Smrj if ((optnum == KERNEL_CMD) && (path[0] != '/')) { 6959ae115bc7Smrj new_path = expand_path(path); 6960ae115bc7Smrj if (new_path == NULL) { 6961455710d3Srscott bam_error(UNKNOWN_KERNEL, path); 6962eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 6963ae115bc7Smrj return (BAM_ERROR); 6964ae115bc7Smrj } 6965ae115bc7Smrj free_new_path = 1; 6966ae115bc7Smrj } else { 6967ae115bc7Smrj new_path = path; 6968ae115bc7Smrj free_new_path = 0; 6969ae115bc7Smrj } 6970ae115bc7Smrj 6971ae115bc7Smrj /* 6972ae115bc7Smrj * At this point, we know we're setting a new value. First, take care 6973ae115bc7Smrj * of the case where there was no previous entry. 6974ae115bc7Smrj */ 6975ae115bc7Smrj if (entryp == NULL) { 6976eb2bd662Svikram 6977ae115bc7Smrj /* Similar to code in update_temp */ 6978eb2bd662Svikram fstype = get_fstype("/"); 6979eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_FSTYPE", fstype = NULL); 6980eb2bd662Svikram if (fstype == NULL) { 6981eb2bd662Svikram bam_error(BOOTENV_FSTYPE_FAILED); 6982eb2bd662Svikram rv = BAM_ERROR; 6983eb2bd662Svikram goto done; 6984eb2bd662Svikram } 6985eb2bd662Svikram 6986eb2bd662Svikram osdev = get_special("/"); 6987eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_SPECIAL", osdev = NULL); 6988eb2bd662Svikram if (osdev == NULL) { 6989eb2bd662Svikram free(fstype); 6990eb2bd662Svikram bam_error(BOOTENV_SPECIAL_FAILED); 6991eb2bd662Svikram rv = BAM_ERROR; 6992eb2bd662Svikram goto done; 6993ae115bc7Smrj } 6994eb2bd662Svikram 6995eb2bd662Svikram sign = find_existing_sign("/", osdev, fstype); 6996eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_SIGN", sign = NULL); 6997eb2bd662Svikram if (sign == NULL) { 6998eb2bd662Svikram free(fstype); 6999eb2bd662Svikram free(osdev); 7000eb2bd662Svikram bam_error(BOOTENV_SIGN_FAILED); 7001ae115bc7Smrj rv = BAM_ERROR; 7002ae115bc7Smrj goto done; 7003ae115bc7Smrj } 7004eb2bd662Svikram 7005eb2bd662Svikram free(fstype); 7006eb2bd662Svikram free(osdev); 7007eb2bd662Svikram (void) strlcpy(signbuf, sign, sizeof (signbuf)); 7008eb2bd662Svikram free(sign); 7009eb2bd662Svikram assert(strchr(signbuf, '(') == NULL && 7010eb2bd662Svikram strchr(signbuf, ',') == NULL && 7011eb2bd662Svikram strchr(signbuf, ')') == NULL); 7012eb2bd662Svikram 7013ae115bc7Smrj if (optnum == KERNEL_CMD) { 7014eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_NEW_KERN, fcn, new_path)); 7015ae115bc7Smrj entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 7016eb2bd662Svikram signbuf, new_path, NULL, NULL); 7017ae115bc7Smrj } else { 7018ae115bc7Smrj new_str_len = strlen(DIRECT_BOOT_KERNEL) + 7019ae115bc7Smrj strlen(path) + 8; 7020ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 7021ae115bc7Smrj 7022ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", 7023ae115bc7Smrj DIRECT_BOOT_KERNEL, path); 7024eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_NEW_ARG, fcn, new_arg)); 7025ae115bc7Smrj entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 7026eb2bd662Svikram signbuf, new_arg, NULL, DIRECT_BOOT_ARCHIVE); 7027eb2bd662Svikram free(new_arg); 7028eb2bd662Svikram } 7029eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_ADD_BOOT_ENTRY", 7030eb2bd662Svikram entryNum = BAM_ERROR); 7031eb2bd662Svikram if (entryNum == BAM_ERROR) { 7032eb2bd662Svikram bam_error(GET_SET_KERNEL_ADD_BOOT_ENTRY, 7033eb2bd662Svikram BOOTENV_RC_TITLE); 7034eb2bd662Svikram rv = BAM_ERROR; 7035eb2bd662Svikram goto done; 7036ae115bc7Smrj } 7037ae115bc7Smrj save_default_entry(mp, BAM_OLD_RC_DEF); 7038eb2bd662Svikram ret = set_global(mp, menu_cmds[DEFAULT_CMD], entryNum); 7039eb2bd662Svikram INJECT_ERROR1("GET_SET_KERNEL_SET_GLOBAL", ret = BAM_ERROR); 7040eb2bd662Svikram if (ret == BAM_ERROR) { 7041eb2bd662Svikram bam_error(GET_SET_KERNEL_SET_GLOBAL, entryNum); 7042eb2bd662Svikram } 7043ae115bc7Smrj rv = BAM_WRITE; 7044ae115bc7Smrj goto done; 7045ae115bc7Smrj } 7046ae115bc7Smrj 7047ae115bc7Smrj /* 7048ae115bc7Smrj * There was already an bootenv entry which we need to edit. 7049ae115bc7Smrj */ 7050ae115bc7Smrj if (optnum == KERNEL_CMD) { 7051ae115bc7Smrj new_str_len = strlen(new_path) + strlen(old_args) + 2; 7052ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 7053ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", new_path, 7054ae115bc7Smrj old_args); 7055ae115bc7Smrj free(kernelp->arg); 7056ae115bc7Smrj kernelp->arg = new_arg; 7057ae115bc7Smrj 7058ae115bc7Smrj /* 7059ae115bc7Smrj * If we have changed the kernel line, we may need to update 7060ae115bc7Smrj * the archive line as well. 7061ae115bc7Smrj */ 7062ae115bc7Smrj set_archive_line(entryp, kernelp); 7063eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_REPLACED_KERNEL_SAME_ARG, fcn, 7064eb2bd662Svikram kernelp->arg)); 7065ae115bc7Smrj } else { 7066ae115bc7Smrj new_str_len = old_kernel_len + strlen(path) + 8; 7067ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 7068ae115bc7Smrj (void) strncpy(new_arg, kernelp->arg, old_kernel_len); 7069ae115bc7Smrj (void) strlcat(new_arg, " ", new_str_len); 7070ae115bc7Smrj (void) strlcat(new_arg, path, new_str_len); 7071ae115bc7Smrj free(kernelp->arg); 7072ae115bc7Smrj kernelp->arg = new_arg; 7073eb2bd662Svikram BAM_DPRINTF((D_GET_SET_KERNEL_SAME_KERNEL_REPLACED_ARG, fcn, 7074eb2bd662Svikram kernelp->arg)); 7075ae115bc7Smrj } 7076ae115bc7Smrj rv = BAM_WRITE; 7077ae115bc7Smrj 7078ae115bc7Smrj done: 7079ae115bc7Smrj if ((rv == BAM_WRITE) && kernelp) 7080ae115bc7Smrj update_line(kernelp); 7081ae115bc7Smrj if (free_new_path) 7082ae115bc7Smrj free(new_path); 7083eb2bd662Svikram if (rv == BAM_WRITE) { 7084eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 7085eb2bd662Svikram } else { 7086eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 7087eb2bd662Svikram } 7088ae115bc7Smrj return (rv); 7089ae115bc7Smrj } 7090ae115bc7Smrj 7091eb2bd662Svikram static error_t 7092eb2bd662Svikram get_kernel(menu_t *mp, menu_cmd_t optnum, char *buf, size_t bufsize) 7093eb2bd662Svikram { 7094eb2bd662Svikram const char *fcn = "get_kernel()"; 7095eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, menu_cmds[optnum])); 7096eb2bd662Svikram return (get_set_kernel(mp, optnum, NULL, buf, bufsize)); 7097eb2bd662Svikram } 7098eb2bd662Svikram 7099eb2bd662Svikram static error_t 7100eb2bd662Svikram set_kernel(menu_t *mp, menu_cmd_t optnum, char *path, char *buf, size_t bufsize) 7101eb2bd662Svikram { 7102eb2bd662Svikram const char *fcn = "set_kernel()"; 7103eb2bd662Svikram assert(path != NULL); 7104eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY2, fcn, menu_cmds[optnum], path)); 7105eb2bd662Svikram return (get_set_kernel(mp, optnum, path, buf, bufsize)); 7106eb2bd662Svikram } 7107eb2bd662Svikram 71087c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 71097c478bd9Sstevel@tonic-gate static error_t 7110eb2bd662Svikram set_option(menu_t *mp, char *dummy, char *opt) 71117c478bd9Sstevel@tonic-gate { 7112eb2bd662Svikram int optnum; 7113eb2bd662Svikram int optval; 7114eb2bd662Svikram char *val; 7115eb2bd662Svikram char buf[BUFSIZ] = ""; 7116eb2bd662Svikram error_t rv; 7117eb2bd662Svikram const char *fcn = "set_option()"; 71187c478bd9Sstevel@tonic-gate 71197c478bd9Sstevel@tonic-gate assert(mp); 71207c478bd9Sstevel@tonic-gate assert(opt); 7121eb2bd662Svikram assert(dummy == NULL); 7122eb2bd662Svikram 7123eb2bd662Svikram /* opt is set from bam_argv[0] and is always non-NULL */ 7124eb2bd662Svikram BAM_DPRINTF((D_FUNC_ENTRY1, fcn, opt)); 71257c478bd9Sstevel@tonic-gate 71267c478bd9Sstevel@tonic-gate val = strchr(opt, '='); 7127ae115bc7Smrj if (val != NULL) { 7128ae115bc7Smrj *val = '\0'; 71297c478bd9Sstevel@tonic-gate } 71307c478bd9Sstevel@tonic-gate 71317c478bd9Sstevel@tonic-gate if (strcmp(opt, "default") == 0) { 71327c478bd9Sstevel@tonic-gate optnum = DEFAULT_CMD; 71337c478bd9Sstevel@tonic-gate } else if (strcmp(opt, "timeout") == 0) { 71347c478bd9Sstevel@tonic-gate optnum = TIMEOUT_CMD; 7135ae115bc7Smrj } else if (strcmp(opt, menu_cmds[KERNEL_CMD]) == 0) { 7136ae115bc7Smrj optnum = KERNEL_CMD; 7137ae115bc7Smrj } else if (strcmp(opt, menu_cmds[ARGS_CMD]) == 0) { 7138ae115bc7Smrj optnum = ARGS_CMD; 71397c478bd9Sstevel@tonic-gate } else { 7140eb2bd662Svikram bam_error(INVALID_OPTION, opt); 71417c478bd9Sstevel@tonic-gate return (BAM_ERROR); 71427c478bd9Sstevel@tonic-gate } 71437c478bd9Sstevel@tonic-gate 7144ae115bc7Smrj /* 7145ae115bc7Smrj * kernel and args are allowed without "=new_value" strings. All 7146ae115bc7Smrj * others cause errors 7147ae115bc7Smrj */ 7148ae115bc7Smrj if ((val == NULL) && (optnum != KERNEL_CMD) && (optnum != ARGS_CMD)) { 7149eb2bd662Svikram bam_error(NO_OPTION_ARG, opt); 7150ae115bc7Smrj return (BAM_ERROR); 7151ae115bc7Smrj } else if (val != NULL) { 7152ae115bc7Smrj *val = '='; 7153ae115bc7Smrj } 7154ae115bc7Smrj 7155ae115bc7Smrj if ((optnum == KERNEL_CMD) || (optnum == ARGS_CMD)) { 7156eb2bd662Svikram BAM_DPRINTF((D_SET_OPTION, fcn, menu_cmds[optnum], 7157eb2bd662Svikram val ? val + 1 : "NULL")); 7158eb2bd662Svikram 7159eb2bd662Svikram if (val) 7160eb2bd662Svikram rv = set_kernel(mp, optnum, val + 1, buf, sizeof (buf)); 7161eb2bd662Svikram else 7162eb2bd662Svikram rv = get_kernel(mp, optnum, buf, sizeof (buf)); 7163ae115bc7Smrj if ((rv == BAM_SUCCESS) && (buf[0] != '\0')) 7164ae115bc7Smrj (void) printf("%s\n", buf); 7165ae115bc7Smrj } else { 7166ae115bc7Smrj optval = s_strtol(val + 1); 7167eb2bd662Svikram BAM_DPRINTF((D_SET_OPTION, fcn, menu_cmds[optnum], val + 1)); 7168eb2bd662Svikram rv = set_global(mp, menu_cmds[optnum], optval); 7169eb2bd662Svikram } 7170eb2bd662Svikram 7171eb2bd662Svikram if (rv == BAM_WRITE || rv == BAM_SUCCESS) { 7172eb2bd662Svikram BAM_DPRINTF((D_RETURN_SUCCESS, fcn)); 7173eb2bd662Svikram } else { 7174eb2bd662Svikram BAM_DPRINTF((D_RETURN_FAILURE, fcn)); 7175ae115bc7Smrj } 7176eb2bd662Svikram 7177eb2bd662Svikram return (rv); 71787c478bd9Sstevel@tonic-gate } 71797c478bd9Sstevel@tonic-gate 71807c478bd9Sstevel@tonic-gate /* 71817c478bd9Sstevel@tonic-gate * The quiet argument suppresses messages. This is used 71827c478bd9Sstevel@tonic-gate * when invoked in the context of other commands (e.g. list_entry) 71837c478bd9Sstevel@tonic-gate */ 71847c478bd9Sstevel@tonic-gate static error_t 71857c478bd9Sstevel@tonic-gate read_globals(menu_t *mp, char *menu_path, char *globalcmd, int quiet) 71867c478bd9Sstevel@tonic-gate { 71877c478bd9Sstevel@tonic-gate line_t *lp; 71887c478bd9Sstevel@tonic-gate char *arg; 71897c478bd9Sstevel@tonic-gate int done, ret = BAM_SUCCESS; 71907c478bd9Sstevel@tonic-gate 71917c478bd9Sstevel@tonic-gate assert(mp); 71927c478bd9Sstevel@tonic-gate assert(menu_path); 71937c478bd9Sstevel@tonic-gate assert(globalcmd); 71947c478bd9Sstevel@tonic-gate 71957c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 71967c478bd9Sstevel@tonic-gate if (!quiet) 71977c478bd9Sstevel@tonic-gate bam_error(NO_MENU, menu_path); 71987c478bd9Sstevel@tonic-gate return (BAM_ERROR); 71997c478bd9Sstevel@tonic-gate } 72007c478bd9Sstevel@tonic-gate 72017c478bd9Sstevel@tonic-gate done = 0; 72027c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 72037c478bd9Sstevel@tonic-gate if (lp->flags != BAM_GLOBAL) 72047c478bd9Sstevel@tonic-gate continue; 72057c478bd9Sstevel@tonic-gate 72067c478bd9Sstevel@tonic-gate if (lp->cmd == NULL) { 72077c478bd9Sstevel@tonic-gate if (!quiet) 72087c478bd9Sstevel@tonic-gate bam_error(NO_CMD, lp->lineNum); 72097c478bd9Sstevel@tonic-gate continue; 72107c478bd9Sstevel@tonic-gate } 72117c478bd9Sstevel@tonic-gate 72127c478bd9Sstevel@tonic-gate if (strcmp(globalcmd, lp->cmd) != 0) 72137c478bd9Sstevel@tonic-gate continue; 72147c478bd9Sstevel@tonic-gate 72157c478bd9Sstevel@tonic-gate /* Found global. Check for duplicates */ 72167c478bd9Sstevel@tonic-gate if (done && !quiet) { 72177c478bd9Sstevel@tonic-gate bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root); 72187c478bd9Sstevel@tonic-gate ret = BAM_ERROR; 72197c478bd9Sstevel@tonic-gate } 72207c478bd9Sstevel@tonic-gate 72217c478bd9Sstevel@tonic-gate arg = lp->arg ? lp->arg : ""; 72227c478bd9Sstevel@tonic-gate bam_print(GLOBAL_CMD, globalcmd, arg); 72237c478bd9Sstevel@tonic-gate done = 1; 72247c478bd9Sstevel@tonic-gate } 72257c478bd9Sstevel@tonic-gate 72267c478bd9Sstevel@tonic-gate if (!done && bam_verbose) 72277c478bd9Sstevel@tonic-gate bam_print(NO_ENTRY, globalcmd); 72287c478bd9Sstevel@tonic-gate 72297c478bd9Sstevel@tonic-gate return (ret); 72307c478bd9Sstevel@tonic-gate } 72317c478bd9Sstevel@tonic-gate 72327c478bd9Sstevel@tonic-gate static error_t 72337c478bd9Sstevel@tonic-gate menu_write(char *root, menu_t *mp) 72347c478bd9Sstevel@tonic-gate { 7235eb2bd662Svikram const char *fcn = "menu_write()"; 7236eb2bd662Svikram 7237eb2bd662Svikram BAM_DPRINTF((D_MENU_WRITE_ENTER, fcn, root)); 72387c478bd9Sstevel@tonic-gate return (list2file(root, MENU_TMP, GRUB_MENU, mp->start)); 72397c478bd9Sstevel@tonic-gate } 72407c478bd9Sstevel@tonic-gate 7241eb2bd662Svikram void 72427c478bd9Sstevel@tonic-gate line_free(line_t *lp) 72437c478bd9Sstevel@tonic-gate { 72447c478bd9Sstevel@tonic-gate if (lp == NULL) 72457c478bd9Sstevel@tonic-gate return; 72467c478bd9Sstevel@tonic-gate 72477c478bd9Sstevel@tonic-gate if (lp->cmd) 72487c478bd9Sstevel@tonic-gate free(lp->cmd); 72497c478bd9Sstevel@tonic-gate if (lp->sep) 72507c478bd9Sstevel@tonic-gate free(lp->sep); 72517c478bd9Sstevel@tonic-gate if (lp->arg) 72527c478bd9Sstevel@tonic-gate free(lp->arg); 72537c478bd9Sstevel@tonic-gate if (lp->line) 72547c478bd9Sstevel@tonic-gate free(lp->line); 72557c478bd9Sstevel@tonic-gate free(lp); 72567c478bd9Sstevel@tonic-gate } 72577c478bd9Sstevel@tonic-gate 72587c478bd9Sstevel@tonic-gate static void 72597c478bd9Sstevel@tonic-gate linelist_free(line_t *start) 72607c478bd9Sstevel@tonic-gate { 72617c478bd9Sstevel@tonic-gate line_t *lp; 72627c478bd9Sstevel@tonic-gate 72637c478bd9Sstevel@tonic-gate while (start) { 72647c478bd9Sstevel@tonic-gate lp = start; 72657c478bd9Sstevel@tonic-gate start = start->next; 72667c478bd9Sstevel@tonic-gate line_free(lp); 72677c478bd9Sstevel@tonic-gate } 72687c478bd9Sstevel@tonic-gate } 72697c478bd9Sstevel@tonic-gate 72707c478bd9Sstevel@tonic-gate static void 72717c478bd9Sstevel@tonic-gate filelist_free(filelist_t *flistp) 72727c478bd9Sstevel@tonic-gate { 72737c478bd9Sstevel@tonic-gate linelist_free(flistp->head); 72747c478bd9Sstevel@tonic-gate flistp->head = NULL; 72757c478bd9Sstevel@tonic-gate flistp->tail = NULL; 72767c478bd9Sstevel@tonic-gate } 72777c478bd9Sstevel@tonic-gate 72787c478bd9Sstevel@tonic-gate static void 72797c478bd9Sstevel@tonic-gate menu_free(menu_t *mp) 72807c478bd9Sstevel@tonic-gate { 72818c1b6884Sszhou entry_t *ent, *tmp; 72827c478bd9Sstevel@tonic-gate assert(mp); 72837c478bd9Sstevel@tonic-gate 72847c478bd9Sstevel@tonic-gate if (mp->start) 72857c478bd9Sstevel@tonic-gate linelist_free(mp->start); 72868c1b6884Sszhou ent = mp->entries; 72878c1b6884Sszhou while (ent) { 72888c1b6884Sszhou tmp = ent; 72898c1b6884Sszhou ent = tmp->next; 72908c1b6884Sszhou free(tmp); 72918c1b6884Sszhou } 72927c478bd9Sstevel@tonic-gate 72938c1b6884Sszhou free(mp); 72947c478bd9Sstevel@tonic-gate } 72957c478bd9Sstevel@tonic-gate 72967c478bd9Sstevel@tonic-gate /* 72977c478bd9Sstevel@tonic-gate * Utility routines 72987c478bd9Sstevel@tonic-gate */ 72997c478bd9Sstevel@tonic-gate 73007c478bd9Sstevel@tonic-gate 73017c478bd9Sstevel@tonic-gate /* 73027c478bd9Sstevel@tonic-gate * Returns 0 on success 73037c478bd9Sstevel@tonic-gate * Any other value indicates an error 73047c478bd9Sstevel@tonic-gate */ 73057c478bd9Sstevel@tonic-gate static int 7306986fd29aSsetje exec_cmd(char *cmdline, filelist_t *flistp) 73077c478bd9Sstevel@tonic-gate { 73087c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 73097c478bd9Sstevel@tonic-gate int ret; 73107c478bd9Sstevel@tonic-gate FILE *ptr; 73117c478bd9Sstevel@tonic-gate sigset_t set; 73127c478bd9Sstevel@tonic-gate void (*disp)(int); 73137c478bd9Sstevel@tonic-gate 73147c478bd9Sstevel@tonic-gate /* 73157c478bd9Sstevel@tonic-gate * For security 73167c478bd9Sstevel@tonic-gate * - only absolute paths are allowed 73177c478bd9Sstevel@tonic-gate * - set IFS to space and tab 73187c478bd9Sstevel@tonic-gate */ 73197c478bd9Sstevel@tonic-gate if (*cmdline != '/') { 73207c478bd9Sstevel@tonic-gate bam_error(ABS_PATH_REQ, cmdline); 73217c478bd9Sstevel@tonic-gate return (-1); 73227c478bd9Sstevel@tonic-gate } 73237c478bd9Sstevel@tonic-gate (void) putenv("IFS= \t"); 73247c478bd9Sstevel@tonic-gate 73257c478bd9Sstevel@tonic-gate /* 73267c478bd9Sstevel@tonic-gate * We may have been exec'ed with SIGCHLD blocked 73277c478bd9Sstevel@tonic-gate * unblock it here 73287c478bd9Sstevel@tonic-gate */ 73297c478bd9Sstevel@tonic-gate (void) sigemptyset(&set); 73307c478bd9Sstevel@tonic-gate (void) sigaddset(&set, SIGCHLD); 73317c478bd9Sstevel@tonic-gate if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) { 73327c478bd9Sstevel@tonic-gate bam_error(CANT_UNBLOCK_SIGCHLD, strerror(errno)); 73337c478bd9Sstevel@tonic-gate return (-1); 73347c478bd9Sstevel@tonic-gate } 73357c478bd9Sstevel@tonic-gate 73367c478bd9Sstevel@tonic-gate /* 73377c478bd9Sstevel@tonic-gate * Set SIGCHLD disposition to SIG_DFL for popen/pclose 73387c478bd9Sstevel@tonic-gate */ 73397c478bd9Sstevel@tonic-gate disp = sigset(SIGCHLD, SIG_DFL); 73407c478bd9Sstevel@tonic-gate if (disp == SIG_ERR) { 73417c478bd9Sstevel@tonic-gate bam_error(FAILED_SIG, strerror(errno)); 73427c478bd9Sstevel@tonic-gate return (-1); 73437c478bd9Sstevel@tonic-gate } 73447c478bd9Sstevel@tonic-gate if (disp == SIG_HOLD) { 73457c478bd9Sstevel@tonic-gate bam_error(BLOCKED_SIG, cmdline); 73467c478bd9Sstevel@tonic-gate return (-1); 73477c478bd9Sstevel@tonic-gate } 73487c478bd9Sstevel@tonic-gate 73497c478bd9Sstevel@tonic-gate ptr = popen(cmdline, "r"); 73507c478bd9Sstevel@tonic-gate if (ptr == NULL) { 73517c478bd9Sstevel@tonic-gate bam_error(POPEN_FAIL, cmdline, strerror(errno)); 73527c478bd9Sstevel@tonic-gate return (-1); 73537c478bd9Sstevel@tonic-gate } 73547c478bd9Sstevel@tonic-gate 73557c478bd9Sstevel@tonic-gate /* 73567c478bd9Sstevel@tonic-gate * If we simply do a pclose() following a popen(), pclose() 73577c478bd9Sstevel@tonic-gate * will close the reader end of the pipe immediately even 73587c478bd9Sstevel@tonic-gate * if the child process has not started/exited. pclose() 73597c478bd9Sstevel@tonic-gate * does wait for cmd to terminate before returning though. 73607c478bd9Sstevel@tonic-gate * When the executed command writes its output to the pipe 73617c478bd9Sstevel@tonic-gate * there is no reader process and the command dies with 73627c478bd9Sstevel@tonic-gate * SIGPIPE. To avoid this we read repeatedly until read 73637c478bd9Sstevel@tonic-gate * terminates with EOF. This indicates that the command 73647c478bd9Sstevel@tonic-gate * (writer) has closed the pipe and we can safely do a 73657c478bd9Sstevel@tonic-gate * pclose(). 73667c478bd9Sstevel@tonic-gate * 73677c478bd9Sstevel@tonic-gate * Since pclose() does wait for the command to exit, 73687c478bd9Sstevel@tonic-gate * we can safely reap the exit status of the command 73697c478bd9Sstevel@tonic-gate * from the value returned by pclose() 73707c478bd9Sstevel@tonic-gate */ 7371986fd29aSsetje while (s_fgets(buf, sizeof (buf), ptr) != NULL) { 7372986fd29aSsetje if (flistp == NULL) { 7373986fd29aSsetje /* s_fgets strips newlines, so insert them at the end */ 7374986fd29aSsetje bam_print(PRINT, buf); 7375986fd29aSsetje } else { 7376986fd29aSsetje append_to_flist(flistp, buf); 73777c478bd9Sstevel@tonic-gate } 73787c478bd9Sstevel@tonic-gate } 73797c478bd9Sstevel@tonic-gate 73807c478bd9Sstevel@tonic-gate ret = pclose(ptr); 73817c478bd9Sstevel@tonic-gate if (ret == -1) { 73827c478bd9Sstevel@tonic-gate bam_error(PCLOSE_FAIL, cmdline, strerror(errno)); 73837c478bd9Sstevel@tonic-gate return (-1); 73847c478bd9Sstevel@tonic-gate } 73857c478bd9Sstevel@tonic-gate 73867c478bd9Sstevel@tonic-gate if (WIFEXITED(ret)) { 73877c478bd9Sstevel@tonic-gate return (WEXITSTATUS(ret)); 73887c478bd9Sstevel@tonic-gate } else { 73897c478bd9Sstevel@tonic-gate bam_error(EXEC_FAIL, cmdline, ret); 73907c478bd9Sstevel@tonic-gate return (-1); 73917c478bd9Sstevel@tonic-gate } 73927c478bd9Sstevel@tonic-gate } 73937c478bd9Sstevel@tonic-gate 73947c478bd9Sstevel@tonic-gate /* 73957c478bd9Sstevel@tonic-gate * Since this function returns -1 on error 73967c478bd9Sstevel@tonic-gate * it cannot be used to convert -1. However, 73977c478bd9Sstevel@tonic-gate * that is sufficient for what we need. 73987c478bd9Sstevel@tonic-gate */ 73997c478bd9Sstevel@tonic-gate static long 74007c478bd9Sstevel@tonic-gate s_strtol(char *str) 74017c478bd9Sstevel@tonic-gate { 74027c478bd9Sstevel@tonic-gate long l; 74037c478bd9Sstevel@tonic-gate char *res = NULL; 74047c478bd9Sstevel@tonic-gate 74057c478bd9Sstevel@tonic-gate if (str == NULL) { 74067c478bd9Sstevel@tonic-gate return (-1); 74077c478bd9Sstevel@tonic-gate } 74087c478bd9Sstevel@tonic-gate 74097c478bd9Sstevel@tonic-gate errno = 0; 74107c478bd9Sstevel@tonic-gate l = strtol(str, &res, 10); 74117c478bd9Sstevel@tonic-gate if (errno || *res != '\0') { 74127c478bd9Sstevel@tonic-gate return (-1); 74137c478bd9Sstevel@tonic-gate } 74147c478bd9Sstevel@tonic-gate 74157c478bd9Sstevel@tonic-gate return (l); 74167c478bd9Sstevel@tonic-gate } 74177c478bd9Sstevel@tonic-gate 74187c478bd9Sstevel@tonic-gate /* 74197c478bd9Sstevel@tonic-gate * Wrapper around fputs, that adds a newline (since fputs doesn't) 74207c478bd9Sstevel@tonic-gate */ 74217c478bd9Sstevel@tonic-gate static int 74227c478bd9Sstevel@tonic-gate s_fputs(char *str, FILE *fp) 74237c478bd9Sstevel@tonic-gate { 74247c478bd9Sstevel@tonic-gate char linebuf[BAM_MAXLINE]; 74257c478bd9Sstevel@tonic-gate 74267c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s\n", str); 74277c478bd9Sstevel@tonic-gate return (fputs(linebuf, fp)); 74287c478bd9Sstevel@tonic-gate } 74297c478bd9Sstevel@tonic-gate 74307c478bd9Sstevel@tonic-gate /* 74317c478bd9Sstevel@tonic-gate * Wrapper around fgets, that strips newlines returned by fgets 74327c478bd9Sstevel@tonic-gate */ 7433ae115bc7Smrj char * 74347c478bd9Sstevel@tonic-gate s_fgets(char *buf, int buflen, FILE *fp) 74357c478bd9Sstevel@tonic-gate { 74367c478bd9Sstevel@tonic-gate int n; 74377c478bd9Sstevel@tonic-gate 74387c478bd9Sstevel@tonic-gate buf = fgets(buf, buflen, fp); 74397c478bd9Sstevel@tonic-gate if (buf) { 74407c478bd9Sstevel@tonic-gate n = strlen(buf); 74417c478bd9Sstevel@tonic-gate if (n == buflen - 1 && buf[n-1] != '\n') 74427c478bd9Sstevel@tonic-gate bam_error(TOO_LONG, buflen - 1, buf); 74437c478bd9Sstevel@tonic-gate buf[n-1] = (buf[n-1] == '\n') ? '\0' : buf[n-1]; 74447c478bd9Sstevel@tonic-gate } 74457c478bd9Sstevel@tonic-gate 74467c478bd9Sstevel@tonic-gate return (buf); 74477c478bd9Sstevel@tonic-gate } 74487c478bd9Sstevel@tonic-gate 7449ae115bc7Smrj void * 74507c478bd9Sstevel@tonic-gate s_calloc(size_t nelem, size_t sz) 74517c478bd9Sstevel@tonic-gate { 74527c478bd9Sstevel@tonic-gate void *ptr; 74537c478bd9Sstevel@tonic-gate 74547c478bd9Sstevel@tonic-gate ptr = calloc(nelem, sz); 74557c478bd9Sstevel@tonic-gate if (ptr == NULL) { 74567c478bd9Sstevel@tonic-gate bam_error(NO_MEM, nelem*sz); 74577c478bd9Sstevel@tonic-gate bam_exit(1); 74587c478bd9Sstevel@tonic-gate } 74597c478bd9Sstevel@tonic-gate return (ptr); 74607c478bd9Sstevel@tonic-gate } 74617c478bd9Sstevel@tonic-gate 7462ae115bc7Smrj void * 7463ae115bc7Smrj s_realloc(void *ptr, size_t sz) 7464ae115bc7Smrj { 7465ae115bc7Smrj ptr = realloc(ptr, sz); 7466ae115bc7Smrj if (ptr == NULL) { 7467ae115bc7Smrj bam_error(NO_MEM, sz); 7468ae115bc7Smrj bam_exit(1); 7469ae115bc7Smrj } 7470ae115bc7Smrj return (ptr); 7471ae115bc7Smrj } 7472ae115bc7Smrj 7473eb2bd662Svikram char * 74747c478bd9Sstevel@tonic-gate s_strdup(char *str) 74757c478bd9Sstevel@tonic-gate { 74767c478bd9Sstevel@tonic-gate char *ptr; 74777c478bd9Sstevel@tonic-gate 74787c478bd9Sstevel@tonic-gate if (str == NULL) 74797c478bd9Sstevel@tonic-gate return (NULL); 74807c478bd9Sstevel@tonic-gate 74817c478bd9Sstevel@tonic-gate ptr = strdup(str); 74827c478bd9Sstevel@tonic-gate if (ptr == NULL) { 74837c478bd9Sstevel@tonic-gate bam_error(NO_MEM, strlen(str) + 1); 74847c478bd9Sstevel@tonic-gate bam_exit(1); 74857c478bd9Sstevel@tonic-gate } 74867c478bd9Sstevel@tonic-gate return (ptr); 74877c478bd9Sstevel@tonic-gate } 74887c478bd9Sstevel@tonic-gate 74897c478bd9Sstevel@tonic-gate /* 74907c478bd9Sstevel@tonic-gate * Returns 1 if amd64 (or sparc, for syncing x86 diskless clients) 74917c478bd9Sstevel@tonic-gate * Returns 0 otherwise 74927c478bd9Sstevel@tonic-gate */ 74937c478bd9Sstevel@tonic-gate static int 74947c478bd9Sstevel@tonic-gate is_amd64(void) 74957c478bd9Sstevel@tonic-gate { 74967c478bd9Sstevel@tonic-gate static int amd64 = -1; 74977c478bd9Sstevel@tonic-gate char isabuf[257]; /* from sysinfo(2) manpage */ 74987c478bd9Sstevel@tonic-gate 74997c478bd9Sstevel@tonic-gate if (amd64 != -1) 75007c478bd9Sstevel@tonic-gate return (amd64); 75017c478bd9Sstevel@tonic-gate 7502d876c67dSjg if (bam_alt_platform) { 7503d876c67dSjg if (strcmp(bam_platform, "i86pc") == 0) { 7504d876c67dSjg amd64 = 1; /* diskless server */ 7505d876c67dSjg } 7506d876c67dSjg } else { 7507d876c67dSjg if (sysinfo(SI_ISALIST, isabuf, sizeof (isabuf)) > 0 && 7508d876c67dSjg strncmp(isabuf, "amd64 ", strlen("amd64 ")) == 0) { 7509d876c67dSjg amd64 = 1; 7510d876c67dSjg } else if (strstr(isabuf, "i386") == NULL) { 7511d876c67dSjg amd64 = 1; /* diskless server */ 7512d876c67dSjg } 7513d876c67dSjg } 7514d876c67dSjg if (amd64 == -1) 75157c478bd9Sstevel@tonic-gate amd64 = 0; 75167c478bd9Sstevel@tonic-gate 75177c478bd9Sstevel@tonic-gate return (amd64); 75187c478bd9Sstevel@tonic-gate } 75197c478bd9Sstevel@tonic-gate 7520*79755401Ssetje static char * 7521*79755401Ssetje get_machine(void) 7522986fd29aSsetje { 7523*79755401Ssetje static int cached = -1; 7524*79755401Ssetje static char mbuf[257]; /* from sysinfo(2) manpage */ 7525986fd29aSsetje 7526*79755401Ssetje if (cached == 0) 7527*79755401Ssetje return (mbuf); 7528d876c67dSjg 7529d876c67dSjg if (bam_alt_platform) { 7530*79755401Ssetje return (bam_platform); 7531d876c67dSjg } else { 7532*79755401Ssetje if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0) { 7533*79755401Ssetje cached = 1; 7534d876c67dSjg } 7535d876c67dSjg } 7536*79755401Ssetje if (cached == -1) { 7537*79755401Ssetje mbuf[0] = '\0'; 7538*79755401Ssetje cached = 0; 7539*79755401Ssetje } 7540986fd29aSsetje 7541*79755401Ssetje return (mbuf); 7542986fd29aSsetje } 7543986fd29aSsetje 7544*79755401Ssetje int 7545*79755401Ssetje is_sparc(void) 7546986fd29aSsetje { 7547*79755401Ssetje static int issparc = -1; 7548986fd29aSsetje char mbuf[257]; /* from sysinfo(2) manpage */ 7549986fd29aSsetje 7550*79755401Ssetje if (issparc != -1) 7551*79755401Ssetje return (issparc); 7552d876c67dSjg 7553d876c67dSjg if (bam_alt_platform) { 7554*79755401Ssetje if (strncmp(bam_platform, "sun4", 4) == 0) { 7555*79755401Ssetje issparc = 1; 7556d876c67dSjg } 7557d876c67dSjg } else { 7558*79755401Ssetje if (sysinfo(SI_ARCHITECTURE, mbuf, sizeof (mbuf)) > 0 && 7559*79755401Ssetje strcmp(mbuf, "sparc") == 0) 7560*79755401Ssetje issparc = 1; 7561*79755401Ssetje else 7562*79755401Ssetje issparc = 0; 7563d876c67dSjg } 7564986fd29aSsetje 7565*79755401Ssetje return (issparc); 7566eb2bd662Svikram } 7567986fd29aSsetje 75687c478bd9Sstevel@tonic-gate static void 75697c478bd9Sstevel@tonic-gate append_to_flist(filelist_t *flistp, char *s) 75707c478bd9Sstevel@tonic-gate { 75717c478bd9Sstevel@tonic-gate line_t *lp; 75727c478bd9Sstevel@tonic-gate 75737c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 75747c478bd9Sstevel@tonic-gate lp->line = s_strdup(s); 75757c478bd9Sstevel@tonic-gate if (flistp->head == NULL) 75767c478bd9Sstevel@tonic-gate flistp->head = lp; 75777c478bd9Sstevel@tonic-gate else 75787c478bd9Sstevel@tonic-gate flistp->tail->next = lp; 75797c478bd9Sstevel@tonic-gate flistp->tail = lp; 75807c478bd9Sstevel@tonic-gate } 75812449e17fSsherrym 7582986fd29aSsetje #if !defined(_OPB) 75832449e17fSsherrym 75842449e17fSsherrym UCODE_VENDORS; 75852449e17fSsherrym 75862449e17fSsherrym /*ARGSUSED*/ 75872449e17fSsherrym static void 75882449e17fSsherrym ucode_install(char *root) 75892449e17fSsherrym { 75902449e17fSsherrym int i; 75912449e17fSsherrym 75922449e17fSsherrym for (i = 0; ucode_vendors[i].filestr != NULL; i++) { 75932449e17fSsherrym int cmd_len = PATH_MAX + 256; 75942449e17fSsherrym char cmd[PATH_MAX + 256]; 75952449e17fSsherrym char file[PATH_MAX]; 75962449e17fSsherrym char timestamp[PATH_MAX]; 75972449e17fSsherrym struct stat fstatus, tstatus; 75982449e17fSsherrym struct utimbuf u_times; 75992449e17fSsherrym 76002449e17fSsherrym (void) snprintf(file, PATH_MAX, "%s/%s/%s-ucode.txt", 76012449e17fSsherrym bam_root, UCODE_INSTALL_PATH, ucode_vendors[i].filestr); 76022449e17fSsherrym 76032449e17fSsherrym if (stat(file, &fstatus) != 0 || !(S_ISREG(fstatus.st_mode))) 76042449e17fSsherrym continue; 76052449e17fSsherrym 76062449e17fSsherrym (void) snprintf(timestamp, PATH_MAX, "%s.ts", file); 76072449e17fSsherrym 76082449e17fSsherrym if (stat(timestamp, &tstatus) == 0 && 76092449e17fSsherrym fstatus.st_mtime <= tstatus.st_mtime) 76102449e17fSsherrym continue; 76112449e17fSsherrym 76122449e17fSsherrym (void) snprintf(cmd, cmd_len, "/usr/sbin/ucodeadm -i -R " 76132449e17fSsherrym "%s/%s/%s %s > /dev/null 2>&1", bam_root, 76142449e17fSsherrym UCODE_INSTALL_PATH, ucode_vendors[i].vendorstr, file); 76152449e17fSsherrym if (system(cmd) != 0) 76162449e17fSsherrym return; 76172449e17fSsherrym 76182449e17fSsherrym if (creat(timestamp, S_IRUSR | S_IWUSR) == -1) 76192449e17fSsherrym return; 76202449e17fSsherrym 76212449e17fSsherrym u_times.actime = fstatus.st_atime; 76222449e17fSsherrym u_times.modtime = fstatus.st_mtime; 76232449e17fSsherrym (void) utime(timestamp, &u_times); 76242449e17fSsherrym } 76252449e17fSsherrym } 76262449e17fSsherrym #endif 7627