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 /* 22bff269d0Svikram * Copyright 2007 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> 57*986fd29aSsetje 58*986fd29aSsetje #if !defined(_OPB) 592449e17fSsherrym #include <sys/ucode.h> 602449e17fSsherrym #endif 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate #include <pwd.h> 637c478bd9Sstevel@tonic-gate #include <grp.h> 647c478bd9Sstevel@tonic-gate #include <device_info.h> 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate #include <locale.h> 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate #include <assert.h> 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate #include "message.h" 71ae115bc7Smrj #include "bootadm.h" 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 747c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD" 757c478bd9Sstevel@tonic-gate #endif /* TEXT_DOMAIN */ 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate /* Type definitions */ 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate /* Primary subcmds */ 807c478bd9Sstevel@tonic-gate typedef enum { 817c478bd9Sstevel@tonic-gate BAM_MENU = 3, 827c478bd9Sstevel@tonic-gate BAM_ARCHIVE 837c478bd9Sstevel@tonic-gate } subcmd_t; 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate typedef enum { 867c478bd9Sstevel@tonic-gate OPT_ABSENT = 0, /* No option */ 877c478bd9Sstevel@tonic-gate OPT_REQ, /* option required */ 887c478bd9Sstevel@tonic-gate OPT_OPTIONAL /* option may or may not be present */ 897c478bd9Sstevel@tonic-gate } option_t; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate typedef struct { 927c478bd9Sstevel@tonic-gate char *subcmd; 937c478bd9Sstevel@tonic-gate option_t option; 947c478bd9Sstevel@tonic-gate error_t (*handler)(); 951a97e40eSvikram int unpriv; /* is this an unprivileged command */ 967c478bd9Sstevel@tonic-gate } subcmd_defn_t; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate #define LINE_INIT 0 /* lineNum initial value */ 997c478bd9Sstevel@tonic-gate #define ENTRY_INIT -1 /* entryNum initial value */ 1007c478bd9Sstevel@tonic-gate #define ALL_ENTRIES -2 /* selects all boot entries */ 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate #define GRUB_DIR "/boot/grub" 1037c478bd9Sstevel@tonic-gate #define GRUB_MENU "/boot/grub/menu.lst" 1047c478bd9Sstevel@tonic-gate #define MENU_TMP "/boot/grub/menu.lst.tmp" 1057c478bd9Sstevel@tonic-gate #define RAMDISK_SPECIAL "/ramdisk" 10640541d5dSvikram #define STUBBOOT "/stubboot" 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate /* lock related */ 1097c478bd9Sstevel@tonic-gate #define BAM_LOCK_FILE "/var/run/bootadm.lock" 1107c478bd9Sstevel@tonic-gate #define LOCK_FILE_PERMS (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 1117c478bd9Sstevel@tonic-gate 112*986fd29aSsetje #define CREATE_RAMDISK "boot/solaris/bin/create_ramdisk" 113*986fd29aSsetje #define CREATE_DISKMAP "boot/solaris/bin/create_diskmap" 114*986fd29aSsetje #define EXTRACT_BOOT_FILELIST "boot/solaris/bin/extract_boot_filelist" 1157c478bd9Sstevel@tonic-gate #define GRUBDISK_MAP "/var/run/solaris_grubdisk.map" 1167c478bd9Sstevel@tonic-gate 117b610f78eSvikram #define GRUB_slice "/etc/lu/GRUB_slice" 118b610f78eSvikram #define GRUB_root "/etc/lu/GRUB_root" 119b610f78eSvikram #define GRUB_backup_menu "/etc/lu/GRUB_backup_menu" 120b610f78eSvikram #define GRUB_slice_mntpt "/tmp/GRUB_slice_mntpt" 121b610f78eSvikram #define LU_ACTIVATE_FILE "/etc/lu/DelayUpdate/activate.sh" 122fbac2b2bSvikram #define GRUB_fdisk "/etc/lu/GRUB_fdisk" 123fbac2b2bSvikram #define GRUB_fdisk_target "/etc/lu/GRUB_fdisk_target" 124b610f78eSvikram 125b610f78eSvikram #define INSTALLGRUB "/sbin/installgrub" 126b610f78eSvikram #define STAGE1 "/boot/grub/stage1" 127b610f78eSvikram #define STAGE2 "/boot/grub/stage2" 128b610f78eSvikram 12998892a30Snadkarni /* 13098892a30Snadkarni * The following two defines are used to detect and create the correct 13198892a30Snadkarni * boot archive when safemode patching is underway. LOFS_PATCH_FILE is a 13298892a30Snadkarni * contracted private interface between bootadm and the install 13398892a30Snadkarni * consolidation. It is set by pdo.c when a patch with SUNW_PATCH_SAFEMODE 13498892a30Snadkarni * is applied. 13598892a30Snadkarni */ 13698892a30Snadkarni 13798892a30Snadkarni #define LOFS_PATCH_FILE "/var/run/.patch_loopback_mode" 13898892a30Snadkarni #define LOFS_PATCH_MNT "/var/run/.patch_root_loopbackmnt" 13998892a30Snadkarni 1407c478bd9Sstevel@tonic-gate /* 1417c478bd9Sstevel@tonic-gate * Default file attributes 1427c478bd9Sstevel@tonic-gate */ 1437c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_MODE 0644 /* default permissions */ 1447c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_UID 0 /* user root */ 1457c478bd9Sstevel@tonic-gate #define DEFAULT_DEV_GID 3 /* group sys */ 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate /* 1487c478bd9Sstevel@tonic-gate * Menu related 1497c478bd9Sstevel@tonic-gate * menu_cmd_t and menu_cmds must be kept in sync 1507c478bd9Sstevel@tonic-gate */ 151ae115bc7Smrj char *menu_cmds[] = { 1527c478bd9Sstevel@tonic-gate "default", /* DEFAULT_CMD */ 1537c478bd9Sstevel@tonic-gate "timeout", /* TIMEOUT_CMD */ 1547c478bd9Sstevel@tonic-gate "title", /* TITLE_CMD */ 1557c478bd9Sstevel@tonic-gate "root", /* ROOT_CMD */ 1567c478bd9Sstevel@tonic-gate "kernel", /* KERNEL_CMD */ 157ae115bc7Smrj "kernel$", /* KERNEL_DOLLAR_CMD */ 1587c478bd9Sstevel@tonic-gate "module", /* MODULE_CMD */ 159ae115bc7Smrj "module$", /* MODULE_DOLLAR_CMD */ 1607c478bd9Sstevel@tonic-gate " ", /* SEP_CMD */ 1617c478bd9Sstevel@tonic-gate "#", /* COMMENT_CMD */ 162ae115bc7Smrj "chainloader", /* CHAINLOADER_CMD */ 163ae115bc7Smrj "args", /* ARGS_CMD */ 1647c478bd9Sstevel@tonic-gate NULL 1657c478bd9Sstevel@tonic-gate }; 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate #define OPT_ENTRY_NUM "entry" 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate /* 1707c478bd9Sstevel@tonic-gate * archive related 1717c478bd9Sstevel@tonic-gate */ 1727c478bd9Sstevel@tonic-gate typedef struct { 1737c478bd9Sstevel@tonic-gate line_t *head; 1747c478bd9Sstevel@tonic-gate line_t *tail; 1757c478bd9Sstevel@tonic-gate } filelist_t; 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate #define BOOT_FILE_LIST "boot/solaris/filelist.ramdisk" 1787c478bd9Sstevel@tonic-gate #define ETC_FILE_LIST "etc/boot/solaris/filelist.ramdisk" 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate #define FILE_STAT "boot/solaris/filestat.ramdisk" 1817c478bd9Sstevel@tonic-gate #define FILE_STAT_TMP "boot/solaris/filestat.ramdisk.tmp" 1827c478bd9Sstevel@tonic-gate #define DIR_PERMS (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 1837c478bd9Sstevel@tonic-gate #define FILE_STAT_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate /* Globals */ 186ae115bc7Smrj int bam_verbose; 187ae115bc7Smrj int bam_force; 1887c478bd9Sstevel@tonic-gate static char *prog; 1897c478bd9Sstevel@tonic-gate static subcmd_t bam_cmd; 1907c478bd9Sstevel@tonic-gate static char *bam_root; 1917c478bd9Sstevel@tonic-gate static int bam_rootlen; 1927c478bd9Sstevel@tonic-gate static int bam_root_readonly; 19340541d5dSvikram static int bam_alt_root; 1947c478bd9Sstevel@tonic-gate static char *bam_subcmd; 1957c478bd9Sstevel@tonic-gate static char *bam_opt; 1967c478bd9Sstevel@tonic-gate static int bam_debug; 1977c478bd9Sstevel@tonic-gate static char **bam_argv; 1987c478bd9Sstevel@tonic-gate static int bam_argc; 1997c478bd9Sstevel@tonic-gate static int bam_check; 2007c478bd9Sstevel@tonic-gate static int bam_smf_check; 2017c478bd9Sstevel@tonic-gate static int bam_lock_fd = -1; 2027c478bd9Sstevel@tonic-gate static char rootbuf[PATH_MAX] = "/"; 203b610f78eSvikram static int bam_update_all; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate /* function prototypes */ 206*986fd29aSsetje static void parse_args_internal(int, char *[]); 207*986fd29aSsetje static void parse_args(int, char *argv[]); 208*986fd29aSsetje static error_t bam_menu(char *, char *, int, char *[]); 209*986fd29aSsetje static error_t bam_archive(char *, char *); 2107c478bd9Sstevel@tonic-gate 211*986fd29aSsetje static void bam_print(char *, ...); 212*986fd29aSsetje static void bam_exit(int); 2137c478bd9Sstevel@tonic-gate static void bam_lock(void); 2147c478bd9Sstevel@tonic-gate static void bam_unlock(void); 2157c478bd9Sstevel@tonic-gate 216*986fd29aSsetje static int exec_cmd(char *, filelist_t *); 217*986fd29aSsetje static error_t read_globals(menu_t *, char *, char *, int); 218*986fd29aSsetje 219*986fd29aSsetje static menu_t *menu_read(char *); 220*986fd29aSsetje static error_t menu_write(char *, menu_t *); 221*986fd29aSsetje static void linelist_free(line_t *); 222*986fd29aSsetje static void menu_free(menu_t *); 223*986fd29aSsetje static void line_free(line_t *); 224*986fd29aSsetje static void filelist_free(filelist_t *); 225*986fd29aSsetje static error_t list2file(char *, char *, char *, line_t *); 226*986fd29aSsetje static error_t list_entry(menu_t *, char *, char *); 227*986fd29aSsetje static error_t delete_all_entries(menu_t *, char *, char *); 228*986fd29aSsetje static error_t update_entry(menu_t *, char *, char *); 229*986fd29aSsetje static error_t update_temp(menu_t *, char *, char *); 230*986fd29aSsetje 231*986fd29aSsetje static error_t update_archive(char *, char *); 232*986fd29aSsetje static error_t list_archive(char *, char *); 233*986fd29aSsetje static error_t update_all(char *, char *); 234*986fd29aSsetje static error_t read_list(char *, filelist_t *); 235*986fd29aSsetje static error_t set_global(menu_t *, char *, int); 236*986fd29aSsetje static error_t set_option(menu_t *, char *, char *); 237*986fd29aSsetje static error_t set_kernel(menu_t *, menu_cmd_t, char *, char *, size_t); 238*986fd29aSsetje static char *expand_path(const char *); 239*986fd29aSsetje 240*986fd29aSsetje static long s_strtol(char *); 241*986fd29aSsetje static int s_fputs(char *, FILE *); 242*986fd29aSsetje 243*986fd29aSsetje static char *s_strdup(char *); 2447c478bd9Sstevel@tonic-gate static int is_readonly(char *); 2457c478bd9Sstevel@tonic-gate static int is_amd64(void); 246*986fd29aSsetje static int is_sun4u(void); 247*986fd29aSsetje static int is_sun4v(void); 2487c478bd9Sstevel@tonic-gate static void append_to_flist(filelist_t *, char *); 2497c478bd9Sstevel@tonic-gate 250*986fd29aSsetje #if !defined(_OPB) 2512449e17fSsherrym static void ucode_install(); 2522449e17fSsherrym #endif 2532449e17fSsherrym 2547c478bd9Sstevel@tonic-gate /* Menu related sub commands */ 2557c478bd9Sstevel@tonic-gate static subcmd_defn_t menu_subcmds[] = { 2561a97e40eSvikram "set_option", OPT_OPTIONAL, set_option, 0, /* PUB */ 2571a97e40eSvikram "list_entry", OPT_OPTIONAL, list_entry, 1, /* PUB */ 2581a97e40eSvikram "delete_all_entries", OPT_ABSENT, delete_all_entries, 0, /* PVT */ 2591a97e40eSvikram "update_entry", OPT_REQ, update_entry, 0, /* menu */ 2601a97e40eSvikram "update_temp", OPT_OPTIONAL, update_temp, 0, /* reboot */ 261ae115bc7Smrj "upgrade", OPT_ABSENT, upgrade_menu, 0, /* menu */ 2621a97e40eSvikram NULL, 0, NULL, 0 /* must be last */ 2637c478bd9Sstevel@tonic-gate }; 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate /* Archive related sub commands */ 2667c478bd9Sstevel@tonic-gate static subcmd_defn_t arch_subcmds[] = { 2671a97e40eSvikram "update", OPT_ABSENT, update_archive, 0, /* PUB */ 2681a97e40eSvikram "update_all", OPT_ABSENT, update_all, 0, /* PVT */ 2691a97e40eSvikram "list", OPT_OPTIONAL, list_archive, 1, /* PUB */ 2701a97e40eSvikram NULL, 0, NULL, 0 /* must be last */ 2717c478bd9Sstevel@tonic-gate }; 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate static struct { 2747c478bd9Sstevel@tonic-gate nvlist_t *new_nvlp; 2757c478bd9Sstevel@tonic-gate nvlist_t *old_nvlp; 2767c478bd9Sstevel@tonic-gate int need_update; 2777c478bd9Sstevel@tonic-gate } walk_arg; 2787c478bd9Sstevel@tonic-gate 27958091fd8Ssetje 2809632cfadSsetje struct safefile { 28158091fd8Ssetje char *name; 28258091fd8Ssetje struct safefile *next; 28358091fd8Ssetje }; 28458091fd8Ssetje 285ae115bc7Smrj static struct safefile *safefiles = NULL; 28658091fd8Ssetje #define NEED_UPDATE_FILE "/etc/svc/volatile/boot_archive_needs_update" 28758091fd8Ssetje 2887c478bd9Sstevel@tonic-gate static void 2897c478bd9Sstevel@tonic-gate usage(void) 2907c478bd9Sstevel@tonic-gate { 2917c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "USAGE:\n"); 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate /* archive usage */ 2957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s update-archive [-vn] [-R altroot]\n", 2967c478bd9Sstevel@tonic-gate prog); 2977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s list-archive [-R altroot]\n", prog); 298*986fd29aSsetje #if !defined(_OPB) 2997c478bd9Sstevel@tonic-gate /* x86 only */ 3007c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s set-menu [-R altroot] key=value\n", prog); 3017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s list-menu [-R altroot]\n", prog); 3027c478bd9Sstevel@tonic-gate #endif 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate int 3067c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 3077c478bd9Sstevel@tonic-gate { 3087c478bd9Sstevel@tonic-gate error_t ret; 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 3117c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate if ((prog = strrchr(argv[0], '/')) == NULL) { 3147c478bd9Sstevel@tonic-gate prog = argv[0]; 3157c478bd9Sstevel@tonic-gate } else { 3167c478bd9Sstevel@tonic-gate prog++; 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate /* 3217c478bd9Sstevel@tonic-gate * Don't depend on caller's umask 3227c478bd9Sstevel@tonic-gate */ 3237c478bd9Sstevel@tonic-gate (void) umask(0022); 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate parse_args(argc, argv); 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate switch (bam_cmd) { 3287c478bd9Sstevel@tonic-gate case BAM_MENU: 3297c478bd9Sstevel@tonic-gate ret = bam_menu(bam_subcmd, bam_opt, bam_argc, bam_argv); 3307c478bd9Sstevel@tonic-gate break; 3317c478bd9Sstevel@tonic-gate case BAM_ARCHIVE: 3327c478bd9Sstevel@tonic-gate ret = bam_archive(bam_subcmd, bam_opt); 3337c478bd9Sstevel@tonic-gate break; 3347c478bd9Sstevel@tonic-gate default: 3357c478bd9Sstevel@tonic-gate usage(); 3367c478bd9Sstevel@tonic-gate bam_exit(1); 3377c478bd9Sstevel@tonic-gate } 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate if (ret != BAM_SUCCESS) 3407c478bd9Sstevel@tonic-gate bam_exit(1); 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate bam_unlock(); 3437c478bd9Sstevel@tonic-gate return (0); 3447c478bd9Sstevel@tonic-gate } 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate /* 3477c478bd9Sstevel@tonic-gate * Equivalence of public and internal commands: 3487c478bd9Sstevel@tonic-gate * update-archive -- -a update 3497c478bd9Sstevel@tonic-gate * list-archive -- -a list 3507c478bd9Sstevel@tonic-gate * set-menu -- -m set_option 3517c478bd9Sstevel@tonic-gate * list-menu -- -m list_entry 3527c478bd9Sstevel@tonic-gate * update-menu -- -m update_entry 3537c478bd9Sstevel@tonic-gate */ 3547c478bd9Sstevel@tonic-gate static struct cmd_map { 3557c478bd9Sstevel@tonic-gate char *bam_cmdname; 3567c478bd9Sstevel@tonic-gate int bam_cmd; 3577c478bd9Sstevel@tonic-gate char *bam_subcmd; 3587c478bd9Sstevel@tonic-gate } cmd_map[] = { 3597c478bd9Sstevel@tonic-gate { "update-archive", BAM_ARCHIVE, "update"}, 3607c478bd9Sstevel@tonic-gate { "list-archive", BAM_ARCHIVE, "list"}, 3617c478bd9Sstevel@tonic-gate { "set-menu", BAM_MENU, "set_option"}, 3627c478bd9Sstevel@tonic-gate { "list-menu", BAM_MENU, "list_entry"}, 3637c478bd9Sstevel@tonic-gate { "update-menu", BAM_MENU, "update_entry"}, 3647c478bd9Sstevel@tonic-gate { NULL, 0, NULL} 3657c478bd9Sstevel@tonic-gate }; 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate /* 3687c478bd9Sstevel@tonic-gate * Commands syntax published in bootadm(1M) are parsed here 3697c478bd9Sstevel@tonic-gate */ 3707c478bd9Sstevel@tonic-gate static void 3717c478bd9Sstevel@tonic-gate parse_args(int argc, char *argv[]) 3727c478bd9Sstevel@tonic-gate { 3737c478bd9Sstevel@tonic-gate struct cmd_map *cmp = cmd_map; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate /* command conforming to the final spec */ 3767c478bd9Sstevel@tonic-gate if (argc > 1 && argv[1][0] != '-') { 3777c478bd9Sstevel@tonic-gate /* 3787c478bd9Sstevel@tonic-gate * Map commands to internal table. 3797c478bd9Sstevel@tonic-gate */ 3807c478bd9Sstevel@tonic-gate while (cmp->bam_cmdname) { 3817c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmp->bam_cmdname) == 0) { 3827c478bd9Sstevel@tonic-gate bam_cmd = cmp->bam_cmd; 3837c478bd9Sstevel@tonic-gate bam_subcmd = cmp->bam_subcmd; 3847c478bd9Sstevel@tonic-gate break; 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate cmp++; 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate if (cmp->bam_cmdname == NULL) { 3897c478bd9Sstevel@tonic-gate usage(); 3907c478bd9Sstevel@tonic-gate bam_exit(1); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate argc--; 3937c478bd9Sstevel@tonic-gate argv++; 3947c478bd9Sstevel@tonic-gate } 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate parse_args_internal(argc, argv); 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate /* 4007c478bd9Sstevel@tonic-gate * A combination of public and private commands are parsed here. 4017c478bd9Sstevel@tonic-gate * The internal syntax and the corresponding functionality are: 4027c478bd9Sstevel@tonic-gate * -a update -- update-archive 4037c478bd9Sstevel@tonic-gate * -a list -- list-archive 4047c478bd9Sstevel@tonic-gate * -a update-all -- (reboot to sync all mounted OS archive) 4057c478bd9Sstevel@tonic-gate * -m update_entry -- update-menu 4067c478bd9Sstevel@tonic-gate * -m list_entry -- list-menu 4077c478bd9Sstevel@tonic-gate * -m update_temp -- (reboot -- [boot-args]) 4087c478bd9Sstevel@tonic-gate * -m delete_all_entries -- (called from install) 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate static void 4117c478bd9Sstevel@tonic-gate parse_args_internal(int argc, char *argv[]) 4127c478bd9Sstevel@tonic-gate { 4137c478bd9Sstevel@tonic-gate int c, error; 4147c478bd9Sstevel@tonic-gate extern char *optarg; 4157c478bd9Sstevel@tonic-gate extern int optind, opterr; 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate /* Suppress error message from getopt */ 4187c478bd9Sstevel@tonic-gate opterr = 0; 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate error = 0; 4210d69385cSrscott while ((c = getopt(argc, argv, "a:d:fm:no:vCR:")) != -1) { 4227c478bd9Sstevel@tonic-gate switch (c) { 4237c478bd9Sstevel@tonic-gate case 'a': 4247c478bd9Sstevel@tonic-gate if (bam_cmd) { 4257c478bd9Sstevel@tonic-gate error = 1; 4267c478bd9Sstevel@tonic-gate bam_error(MULT_CMDS, c); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate bam_cmd = BAM_ARCHIVE; 4297c478bd9Sstevel@tonic-gate bam_subcmd = optarg; 4307c478bd9Sstevel@tonic-gate break; 4317c478bd9Sstevel@tonic-gate case 'd': 4327c478bd9Sstevel@tonic-gate if (bam_debug) { 4337c478bd9Sstevel@tonic-gate error = 1; 4347c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate bam_debug = s_strtol(optarg); 4377c478bd9Sstevel@tonic-gate break; 4387c478bd9Sstevel@tonic-gate case 'f': 4397c478bd9Sstevel@tonic-gate if (bam_force) { 4407c478bd9Sstevel@tonic-gate error = 1; 4417c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate bam_force = 1; 4447c478bd9Sstevel@tonic-gate break; 4457c478bd9Sstevel@tonic-gate case 'm': 4467c478bd9Sstevel@tonic-gate if (bam_cmd) { 4477c478bd9Sstevel@tonic-gate error = 1; 4487c478bd9Sstevel@tonic-gate bam_error(MULT_CMDS, c); 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate bam_cmd = BAM_MENU; 4517c478bd9Sstevel@tonic-gate bam_subcmd = optarg; 4527c478bd9Sstevel@tonic-gate break; 4537c478bd9Sstevel@tonic-gate case 'n': 4547c478bd9Sstevel@tonic-gate if (bam_check) { 4557c478bd9Sstevel@tonic-gate error = 1; 4567c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4577c478bd9Sstevel@tonic-gate } 4587c478bd9Sstevel@tonic-gate bam_check = 1; 4597c478bd9Sstevel@tonic-gate break; 4607c478bd9Sstevel@tonic-gate case 'o': 4617c478bd9Sstevel@tonic-gate if (bam_opt) { 4627c478bd9Sstevel@tonic-gate error = 1; 4637c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate bam_opt = optarg; 4667c478bd9Sstevel@tonic-gate break; 4677c478bd9Sstevel@tonic-gate case 'v': 4687c478bd9Sstevel@tonic-gate if (bam_verbose) { 4697c478bd9Sstevel@tonic-gate error = 1; 4707c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4717c478bd9Sstevel@tonic-gate } 4727c478bd9Sstevel@tonic-gate bam_verbose = 1; 4737c478bd9Sstevel@tonic-gate break; 4748c1b6884Sszhou case 'C': 4758c1b6884Sszhou bam_smf_check = 1; 4768c1b6884Sszhou break; 4777c478bd9Sstevel@tonic-gate case 'R': 4787c478bd9Sstevel@tonic-gate if (bam_root) { 4797c478bd9Sstevel@tonic-gate error = 1; 4807c478bd9Sstevel@tonic-gate bam_error(DUP_OPT, c); 4817c478bd9Sstevel@tonic-gate break; 4827c478bd9Sstevel@tonic-gate } else if (realpath(optarg, rootbuf) == NULL) { 4837c478bd9Sstevel@tonic-gate error = 1; 4847c478bd9Sstevel@tonic-gate bam_error(CANT_RESOLVE, optarg, 4857c478bd9Sstevel@tonic-gate strerror(errno)); 4867c478bd9Sstevel@tonic-gate break; 4877c478bd9Sstevel@tonic-gate } 48840541d5dSvikram bam_alt_root = 1; 4897c478bd9Sstevel@tonic-gate bam_root = rootbuf; 4907c478bd9Sstevel@tonic-gate bam_rootlen = strlen(rootbuf); 4917c478bd9Sstevel@tonic-gate break; 4927c478bd9Sstevel@tonic-gate case '?': 4937c478bd9Sstevel@tonic-gate error = 1; 4947c478bd9Sstevel@tonic-gate bam_error(BAD_OPT, optopt); 4957c478bd9Sstevel@tonic-gate break; 4967c478bd9Sstevel@tonic-gate default : 4977c478bd9Sstevel@tonic-gate error = 1; 4987c478bd9Sstevel@tonic-gate bam_error(BAD_OPT, c); 4997c478bd9Sstevel@tonic-gate break; 5007c478bd9Sstevel@tonic-gate } 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* 5047c478bd9Sstevel@tonic-gate * A command option must be specfied 5057c478bd9Sstevel@tonic-gate */ 5067c478bd9Sstevel@tonic-gate if (!bam_cmd) { 5077c478bd9Sstevel@tonic-gate if (bam_opt && strcmp(bam_opt, "all") == 0) { 5087c478bd9Sstevel@tonic-gate usage(); 5097c478bd9Sstevel@tonic-gate bam_exit(0); 5107c478bd9Sstevel@tonic-gate } 5117c478bd9Sstevel@tonic-gate bam_error(NEED_CMD); 5127c478bd9Sstevel@tonic-gate error = 1; 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate if (error) { 5167c478bd9Sstevel@tonic-gate usage(); 5177c478bd9Sstevel@tonic-gate bam_exit(1); 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate if (optind > argc) { 5217c478bd9Sstevel@tonic-gate bam_error(INT_ERROR, "parse_args"); 5227c478bd9Sstevel@tonic-gate bam_exit(1); 5237c478bd9Sstevel@tonic-gate } else if (optind < argc) { 5247c478bd9Sstevel@tonic-gate bam_argv = &argv[optind]; 5257c478bd9Sstevel@tonic-gate bam_argc = argc - optind; 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate /* 5297c478bd9Sstevel@tonic-gate * -n implies verbose mode 5307c478bd9Sstevel@tonic-gate */ 5317c478bd9Sstevel@tonic-gate if (bam_check) 5327c478bd9Sstevel@tonic-gate bam_verbose = 1; 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate static error_t 5367c478bd9Sstevel@tonic-gate check_subcmd_and_options( 5377c478bd9Sstevel@tonic-gate char *subcmd, 5387c478bd9Sstevel@tonic-gate char *opt, 5397c478bd9Sstevel@tonic-gate subcmd_defn_t *table, 5407c478bd9Sstevel@tonic-gate error_t (**fp)()) 5417c478bd9Sstevel@tonic-gate { 5427c478bd9Sstevel@tonic-gate int i; 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate if (subcmd == NULL) { 5457c478bd9Sstevel@tonic-gate bam_error(NEED_SUBCMD); 5467c478bd9Sstevel@tonic-gate return (BAM_ERROR); 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate 5491a97e40eSvikram if (bam_argc != 0 || bam_argv) { 5501a97e40eSvikram if (strcmp(subcmd, "set_option") != 0 || bam_argc != 1) { 5511a97e40eSvikram bam_error(TRAILING_ARGS); 5521a97e40eSvikram usage(); 5531a97e40eSvikram return (BAM_ERROR); 5541a97e40eSvikram } 5551a97e40eSvikram } 5561a97e40eSvikram 5577c478bd9Sstevel@tonic-gate if (bam_root == NULL) { 5587c478bd9Sstevel@tonic-gate bam_root = rootbuf; 5597c478bd9Sstevel@tonic-gate bam_rootlen = 1; 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate /* verify that subcmd is valid */ 5637c478bd9Sstevel@tonic-gate for (i = 0; table[i].subcmd != NULL; i++) { 5647c478bd9Sstevel@tonic-gate if (strcmp(table[i].subcmd, subcmd) == 0) 5657c478bd9Sstevel@tonic-gate break; 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate if (table[i].subcmd == NULL) { 5697c478bd9Sstevel@tonic-gate bam_error(INVALID_SUBCMD, subcmd); 5707c478bd9Sstevel@tonic-gate return (BAM_ERROR); 5717c478bd9Sstevel@tonic-gate } 5727c478bd9Sstevel@tonic-gate 5731a97e40eSvikram if (table[i].unpriv == 0 && geteuid() != 0) { 5741a97e40eSvikram bam_error(MUST_BE_ROOT); 5751a97e40eSvikram return (BAM_ERROR); 5761a97e40eSvikram } 5771a97e40eSvikram 5781a97e40eSvikram /* 5791a97e40eSvikram * Currently only privileged commands need a lock 5801a97e40eSvikram */ 5811a97e40eSvikram if (table[i].unpriv == 0) 5821a97e40eSvikram bam_lock(); 5831a97e40eSvikram 5847c478bd9Sstevel@tonic-gate /* subcmd verifies that opt is appropriate */ 5857c478bd9Sstevel@tonic-gate if (table[i].option != OPT_OPTIONAL) { 5867c478bd9Sstevel@tonic-gate if ((table[i].option == OPT_REQ) ^ (opt != NULL)) { 5877c478bd9Sstevel@tonic-gate if (opt) 5887c478bd9Sstevel@tonic-gate bam_error(NO_OPT_REQ, subcmd); 5897c478bd9Sstevel@tonic-gate else 5907c478bd9Sstevel@tonic-gate bam_error(MISS_OPT, subcmd); 5917c478bd9Sstevel@tonic-gate return (BAM_ERROR); 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate } 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate *fp = table[i].handler; 5967c478bd9Sstevel@tonic-gate 5977c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 5987c478bd9Sstevel@tonic-gate } 5997c478bd9Sstevel@tonic-gate 600b610f78eSvikram 601b610f78eSvikram static char * 60240541d5dSvikram mount_grub_slice(int *mnted, char **physlice, char **logslice, char **fs_type) 603b610f78eSvikram { 604b610f78eSvikram struct extmnttab mnt; 605b610f78eSvikram struct stat sb; 606b610f78eSvikram char buf[BAM_MAXLINE], dev[PATH_MAX], phys[PATH_MAX], fstype[32]; 607f0f2c544Svikram char cmd[PATH_MAX]; 608b610f78eSvikram char *mntpt; 609b610f78eSvikram int p, l, f; 610b610f78eSvikram FILE *fp; 611b610f78eSvikram 612b610f78eSvikram assert(mnted); 613b610f78eSvikram *mnted = 0; 614b610f78eSvikram 615b610f78eSvikram /* 61640541d5dSvikram * physlice, logslice, fs_type args may be NULL 617b610f78eSvikram */ 618b610f78eSvikram if (physlice) 619b610f78eSvikram *physlice = NULL; 62040541d5dSvikram if (logslice) 62140541d5dSvikram *logslice = NULL; 62240541d5dSvikram if (fs_type) 62340541d5dSvikram *fs_type = NULL; 624b610f78eSvikram 625b610f78eSvikram if (stat(GRUB_slice, &sb) != 0) { 626b610f78eSvikram bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno)); 627b610f78eSvikram return (NULL); 628b610f78eSvikram } 629b610f78eSvikram 630b610f78eSvikram fp = fopen(GRUB_slice, "r"); 631b610f78eSvikram if (fp == NULL) { 632b610f78eSvikram bam_error(OPEN_FAIL, GRUB_slice, strerror(errno)); 633b610f78eSvikram return (NULL); 634b610f78eSvikram } 635b610f78eSvikram 636b610f78eSvikram dev[0] = fstype[0] = phys[0] = '\0'; 637b610f78eSvikram p = sizeof ("PHYS_SLICE=") - 1; 638b610f78eSvikram l = sizeof ("LOG_SLICE=") - 1; 639b610f78eSvikram f = sizeof ("LOG_FSTYP=") - 1; 640b610f78eSvikram while (s_fgets(buf, sizeof (buf), fp) != NULL) { 641b610f78eSvikram if (strncmp(buf, "PHYS_SLICE=", p) == 0) { 642b610f78eSvikram (void) strlcpy(phys, buf + p, sizeof (phys)); 643b610f78eSvikram continue; 644b610f78eSvikram } 645b610f78eSvikram if (strncmp(buf, "LOG_SLICE=", l) == 0) { 646b610f78eSvikram (void) strlcpy(dev, buf + l, sizeof (dev)); 647b610f78eSvikram continue; 648b610f78eSvikram } 649b610f78eSvikram if (strncmp(buf, "LOG_FSTYP=", f) == 0) { 650b610f78eSvikram (void) strlcpy(fstype, buf + f, sizeof (fstype)); 651b610f78eSvikram continue; 652b610f78eSvikram } 653b610f78eSvikram } 654b610f78eSvikram (void) fclose(fp); 655b610f78eSvikram 656b610f78eSvikram if (dev[0] == '\0' || fstype[0] == '\0' || phys[0] == '\0') { 657b610f78eSvikram bam_error(BAD_SLICE_FILE, GRUB_slice); 658b610f78eSvikram return (NULL); 659b610f78eSvikram } 660b610f78eSvikram 661b610f78eSvikram if (physlice) { 662b610f78eSvikram *physlice = s_strdup(phys); 663b610f78eSvikram } 66440541d5dSvikram if (logslice) { 66540541d5dSvikram *logslice = s_strdup(dev); 66640541d5dSvikram } 66740541d5dSvikram if (fs_type) { 66840541d5dSvikram *fs_type = s_strdup(fstype); 66940541d5dSvikram } 670b610f78eSvikram 671b610f78eSvikram /* 672b610f78eSvikram * Check if the slice is already mounted 673b610f78eSvikram */ 674b610f78eSvikram fp = fopen(MNTTAB, "r"); 675b610f78eSvikram if (fp == NULL) { 676b610f78eSvikram bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 67740541d5dSvikram goto error; 678b610f78eSvikram } 679b610f78eSvikram 680b610f78eSvikram resetmnttab(fp); 681b610f78eSvikram 682b610f78eSvikram mntpt = NULL; 683b610f78eSvikram while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 684b610f78eSvikram if (strcmp(mnt.mnt_special, dev) == 0) { 685b610f78eSvikram mntpt = s_strdup(mnt.mnt_mountp); 686b610f78eSvikram break; 687b610f78eSvikram } 688b610f78eSvikram } 689b610f78eSvikram 690b610f78eSvikram (void) fclose(fp); 691b610f78eSvikram 692b610f78eSvikram if (mntpt) { 693b610f78eSvikram return (mntpt); 694b610f78eSvikram } 695b610f78eSvikram 696b610f78eSvikram 697b610f78eSvikram /* 698b610f78eSvikram * GRUB slice is not mounted, we need to mount it now. 699b610f78eSvikram * First create the mountpoint 700b610f78eSvikram */ 701b610f78eSvikram mntpt = s_calloc(1, PATH_MAX); 702b610f78eSvikram (void) snprintf(mntpt, PATH_MAX, "%s.%d", GRUB_slice_mntpt, getpid()); 703b610f78eSvikram if (mkdir(mntpt, 0755) == -1 && errno != EEXIST) { 704b610f78eSvikram bam_error(MKDIR_FAILED, mntpt, strerror(errno)); 705b610f78eSvikram free(mntpt); 70640541d5dSvikram goto error; 707b610f78eSvikram } 708b610f78eSvikram 709f0f2c544Svikram (void) snprintf(cmd, sizeof (cmd), "/sbin/mount -F %s %s %s", 710f0f2c544Svikram fstype, dev, mntpt); 711f0f2c544Svikram 712*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 71340541d5dSvikram bam_error(MOUNT_FAILED, dev, fstype); 714b610f78eSvikram if (rmdir(mntpt) != 0) { 715b610f78eSvikram bam_error(RMDIR_FAILED, mntpt, strerror(errno)); 716b610f78eSvikram } 717b610f78eSvikram free(mntpt); 71840541d5dSvikram goto error; 719b610f78eSvikram } 720b610f78eSvikram 721b610f78eSvikram *mnted = 1; 722b610f78eSvikram return (mntpt); 72340541d5dSvikram 72440541d5dSvikram error: 72540541d5dSvikram if (physlice) { 72640541d5dSvikram free(*physlice); 72740541d5dSvikram *physlice = NULL; 72840541d5dSvikram } 72940541d5dSvikram if (logslice) { 73040541d5dSvikram free(*logslice); 73140541d5dSvikram *logslice = NULL; 73240541d5dSvikram } 73340541d5dSvikram if (fs_type) { 73440541d5dSvikram free(*fs_type); 73540541d5dSvikram *fs_type = NULL; 73640541d5dSvikram } 73740541d5dSvikram return (NULL); 738b610f78eSvikram } 739b610f78eSvikram 740b610f78eSvikram static void 74140541d5dSvikram umount_grub_slice( 74240541d5dSvikram int mnted, 74340541d5dSvikram char *mntpt, 74440541d5dSvikram char *physlice, 74540541d5dSvikram char *logslice, 74640541d5dSvikram char *fs_type) 747b610f78eSvikram { 748f0f2c544Svikram char cmd[PATH_MAX]; 749f0f2c544Svikram 750b610f78eSvikram /* 751b610f78eSvikram * If we have not dealt with GRUB slice 752b610f78eSvikram * we have nothing to do - just return. 753b610f78eSvikram */ 754b610f78eSvikram if (mntpt == NULL) 755b610f78eSvikram return; 756b610f78eSvikram 757b610f78eSvikram 758b610f78eSvikram /* 759b610f78eSvikram * If we mounted the filesystem earlier in mount_grub_slice() 760b610f78eSvikram * unmount it now. 761b610f78eSvikram */ 762b610f78eSvikram if (mnted) { 763f0f2c544Svikram (void) snprintf(cmd, sizeof (cmd), "/sbin/umount %s", 764f0f2c544Svikram mntpt); 765*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 766f0f2c544Svikram bam_error(UMOUNT_FAILED, mntpt); 767b610f78eSvikram } 768b610f78eSvikram if (rmdir(mntpt) != 0) { 769b610f78eSvikram bam_error(RMDIR_FAILED, mntpt, strerror(errno)); 770b610f78eSvikram } 771b610f78eSvikram } 77240541d5dSvikram 773b610f78eSvikram if (physlice) 774b610f78eSvikram free(physlice); 77540541d5dSvikram if (logslice) 77640541d5dSvikram free(logslice); 77740541d5dSvikram if (fs_type) 77840541d5dSvikram free(fs_type); 77940541d5dSvikram 780b610f78eSvikram free(mntpt); 781b610f78eSvikram } 782b610f78eSvikram 78340541d5dSvikram static char * 78440541d5dSvikram use_stubboot(void) 78540541d5dSvikram { 78640541d5dSvikram int mnted; 78740541d5dSvikram struct stat sb; 78840541d5dSvikram struct extmnttab mnt; 78940541d5dSvikram FILE *fp; 79040541d5dSvikram char cmd[PATH_MAX]; 79140541d5dSvikram 79240541d5dSvikram if (stat(STUBBOOT, &sb) != 0) { 79340541d5dSvikram bam_error(STUBBOOT_DIR_NOT_FOUND); 79440541d5dSvikram return (NULL); 79540541d5dSvikram } 79640541d5dSvikram 79740541d5dSvikram /* 79840541d5dSvikram * Check if stubboot is mounted. If not, mount it 79940541d5dSvikram */ 80040541d5dSvikram fp = fopen(MNTTAB, "r"); 80140541d5dSvikram if (fp == NULL) { 80240541d5dSvikram bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 80340541d5dSvikram return (NULL); 80440541d5dSvikram } 80540541d5dSvikram 80640541d5dSvikram resetmnttab(fp); 80740541d5dSvikram 80840541d5dSvikram mnted = 0; 80940541d5dSvikram while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 81040541d5dSvikram if (strcmp(mnt.mnt_mountp, STUBBOOT) == 0) { 81140541d5dSvikram mnted = 1; 81240541d5dSvikram break; 81340541d5dSvikram } 81440541d5dSvikram } 81540541d5dSvikram 81640541d5dSvikram (void) fclose(fp); 81740541d5dSvikram 81840541d5dSvikram if (mnted) 81940541d5dSvikram return (STUBBOOT); 82040541d5dSvikram 82140541d5dSvikram /* 82240541d5dSvikram * Stubboot is not mounted, mount it now. 82340541d5dSvikram * It should exist in /etc/vfstab 82440541d5dSvikram */ 82540541d5dSvikram (void) snprintf(cmd, sizeof (cmd), "/sbin/mount %s", 82640541d5dSvikram STUBBOOT); 827*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 82840541d5dSvikram bam_error(MOUNT_MNTPT_FAILED, STUBBOOT); 82940541d5dSvikram return (NULL); 83040541d5dSvikram } 83140541d5dSvikram 83240541d5dSvikram return (STUBBOOT); 83340541d5dSvikram } 83440541d5dSvikram 83540541d5dSvikram static void 83640541d5dSvikram disp_active_menu_locn(char *menu_path, char *logslice, char *fstype, int mnted) 83740541d5dSvikram { 83840541d5dSvikram /* 83940541d5dSvikram * Check if we did a temp mount of an unmounted device. 84040541d5dSvikram * If yes, print the block device and fstype for that device 84140541d5dSvikram * else it is already mounted, so we print the path to the GRUB menu. 84240541d5dSvikram */ 84340541d5dSvikram if (mnted) { 84440541d5dSvikram bam_print(GRUB_MENU_DEVICE, logslice); 84540541d5dSvikram bam_print(GRUB_MENU_FSTYPE, fstype); 84640541d5dSvikram } else { 84740541d5dSvikram bam_print(GRUB_MENU_PATH, menu_path); 84840541d5dSvikram } 84940541d5dSvikram } 85040541d5dSvikram 85140541d5dSvikram /* 85240541d5dSvikram * NOTE: A single "/" is also considered a trailing slash and will 85340541d5dSvikram * be deleted. 85440541d5dSvikram */ 85540541d5dSvikram static void 85640541d5dSvikram elide_trailing_slash(const char *src, char *dst, size_t dstsize) 85740541d5dSvikram { 85840541d5dSvikram size_t dstlen; 85940541d5dSvikram 86040541d5dSvikram assert(src); 86140541d5dSvikram assert(dst); 86240541d5dSvikram 86340541d5dSvikram (void) strlcpy(dst, src, dstsize); 86440541d5dSvikram 86540541d5dSvikram dstlen = strlen(dst); 86640541d5dSvikram if (dst[dstlen - 1] == '/') { 86740541d5dSvikram dst[dstlen - 1] = '\0'; 86840541d5dSvikram } 86940541d5dSvikram } 87040541d5dSvikram 8717c478bd9Sstevel@tonic-gate static error_t 8727c478bd9Sstevel@tonic-gate bam_menu(char *subcmd, char *opt, int largc, char *largv[]) 8737c478bd9Sstevel@tonic-gate { 8747c478bd9Sstevel@tonic-gate error_t ret; 8757c478bd9Sstevel@tonic-gate char menu_path[PATH_MAX]; 876ae115bc7Smrj char path[PATH_MAX]; 8777c478bd9Sstevel@tonic-gate menu_t *menu; 87840541d5dSvikram char *mntpt, *menu_root, *logslice, *fstype; 879b610f78eSvikram struct stat sb; 880b610f78eSvikram int mnted; /* set if we did a mount */ 8817c478bd9Sstevel@tonic-gate error_t (*f)(menu_t *mp, char *menu_path, char *opt); 882*986fd29aSsetje char *rootpath; 883*986fd29aSsetje 884*986fd29aSsetje /* 885*986fd29aSsetje * Menu sub-command only applies to GRUB (i.e. x86) 886*986fd29aSsetje */ 887*986fd29aSsetje rootpath = (bam_alt_root) ? bam_root : "/"; 888*986fd29aSsetje if (!is_grub((const char *)rootpath)) { 889*986fd29aSsetje bam_error(NOT_ON_SPARC); 890*986fd29aSsetje return (BAM_ERROR); 891*986fd29aSsetje } 8927c478bd9Sstevel@tonic-gate 8937c478bd9Sstevel@tonic-gate /* 8947c478bd9Sstevel@tonic-gate * Check arguments 8957c478bd9Sstevel@tonic-gate */ 8967c478bd9Sstevel@tonic-gate ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f); 8977c478bd9Sstevel@tonic-gate if (ret == BAM_ERROR) { 8987c478bd9Sstevel@tonic-gate return (BAM_ERROR); 8997c478bd9Sstevel@tonic-gate } 9007c478bd9Sstevel@tonic-gate 901b610f78eSvikram mntpt = NULL; 902b610f78eSvikram mnted = 0; 90340541d5dSvikram logslice = fstype = NULL; 90440541d5dSvikram 90540541d5dSvikram /* 906ae115bc7Smrj * Check for the menu.list file: 907ae115bc7Smrj * 908ae115bc7Smrj * 1. Check for a GRUB_slice file, be it on / or 909ae115bc7Smrj * on the user-provided alternate root. 910ae115bc7Smrj * 2. Use the alternate root, if given. 911ae115bc7Smrj * 3. Check /stubboot 912ae115bc7Smrj * 4. Use / 91340541d5dSvikram */ 91440541d5dSvikram if (bam_alt_root) { 915ae115bc7Smrj (void) snprintf(path, sizeof (path), "%s%s", bam_root, 916ae115bc7Smrj GRUB_slice); 917ae115bc7Smrj } else { 918ae115bc7Smrj (void) snprintf(path, sizeof (path), "%s", GRUB_slice); 919ae115bc7Smrj } 920ae115bc7Smrj 921ae115bc7Smrj if (stat(path, &sb) == 0) { 92240541d5dSvikram mntpt = mount_grub_slice(&mnted, NULL, &logslice, &fstype); 923b610f78eSvikram menu_root = mntpt; 924ae115bc7Smrj } else if (bam_alt_root) { 925ae115bc7Smrj menu_root = bam_root; 92640541d5dSvikram } else if (stat(STUBBOOT, &sb) == 0) { 92740541d5dSvikram menu_root = use_stubboot(); 928b610f78eSvikram } else { 929b610f78eSvikram menu_root = bam_root; 930b610f78eSvikram } 931b610f78eSvikram 93240541d5dSvikram if (menu_root == NULL) { 93340541d5dSvikram bam_error(CANNOT_LOCATE_GRUB_MENU); 93440541d5dSvikram return (BAM_ERROR); 93540541d5dSvikram } 93640541d5dSvikram 93740541d5dSvikram elide_trailing_slash(menu_root, menu_path, sizeof (menu_path)); 93840541d5dSvikram (void) strlcat(menu_path, GRUB_MENU, sizeof (menu_path)); 93940541d5dSvikram 94040541d5dSvikram /* 94140541d5dSvikram * If listing the menu, display the active menu 94240541d5dSvikram * location 94340541d5dSvikram */ 94440541d5dSvikram if (strcmp(subcmd, "list_entry") == 0) { 94540541d5dSvikram disp_active_menu_locn(menu_path, logslice, fstype, mnted); 94640541d5dSvikram } 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate menu = menu_read(menu_path); 9497c478bd9Sstevel@tonic-gate assert(menu); 9507c478bd9Sstevel@tonic-gate 9517c478bd9Sstevel@tonic-gate /* 9527c478bd9Sstevel@tonic-gate * Special handling for setting timeout and default 9537c478bd9Sstevel@tonic-gate */ 9547c478bd9Sstevel@tonic-gate if (strcmp(subcmd, "set_option") == 0) { 9557c478bd9Sstevel@tonic-gate if (largc != 1 || largv[0] == NULL) { 9567c478bd9Sstevel@tonic-gate usage(); 95740541d5dSvikram menu_free(menu); 95840541d5dSvikram umount_grub_slice(mnted, mntpt, NULL, logslice, fstype); 9597c478bd9Sstevel@tonic-gate return (BAM_ERROR); 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate opt = largv[0]; 9627c478bd9Sstevel@tonic-gate } else if (largc != 0) { 9637c478bd9Sstevel@tonic-gate usage(); 96440541d5dSvikram menu_free(menu); 96540541d5dSvikram umount_grub_slice(mnted, mntpt, NULL, logslice, fstype); 9667c478bd9Sstevel@tonic-gate return (BAM_ERROR); 9677c478bd9Sstevel@tonic-gate } 9687c478bd9Sstevel@tonic-gate 969ae115bc7Smrj ret = dboot_or_multiboot(bam_root); 970ae115bc7Smrj if (ret != BAM_SUCCESS) 971ae115bc7Smrj return (ret); 972ae115bc7Smrj 9737c478bd9Sstevel@tonic-gate /* 9747c478bd9Sstevel@tonic-gate * Once the sub-cmd handler has run 9757c478bd9Sstevel@tonic-gate * only the line field is guaranteed to have valid values 9767c478bd9Sstevel@tonic-gate */ 977ae115bc7Smrj if ((strcmp(subcmd, "update_entry") == 0) || 978ae115bc7Smrj (strcmp(subcmd, "upgrade") == 0)) 9797c478bd9Sstevel@tonic-gate ret = f(menu, bam_root, opt); 9807c478bd9Sstevel@tonic-gate else 9817c478bd9Sstevel@tonic-gate ret = f(menu, menu_path, opt); 9827c478bd9Sstevel@tonic-gate if (ret == BAM_WRITE) { 983b610f78eSvikram ret = menu_write(menu_root, menu); 9847c478bd9Sstevel@tonic-gate } 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate menu_free(menu); 9877c478bd9Sstevel@tonic-gate 98840541d5dSvikram umount_grub_slice(mnted, mntpt, NULL, logslice, fstype); 989b610f78eSvikram 9907c478bd9Sstevel@tonic-gate return (ret); 9917c478bd9Sstevel@tonic-gate } 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate static error_t 9957c478bd9Sstevel@tonic-gate bam_archive( 9967c478bd9Sstevel@tonic-gate char *subcmd, 9977c478bd9Sstevel@tonic-gate char *opt) 9987c478bd9Sstevel@tonic-gate { 9997c478bd9Sstevel@tonic-gate error_t ret; 10007c478bd9Sstevel@tonic-gate error_t (*f)(char *root, char *opt); 10017c478bd9Sstevel@tonic-gate 10028c1b6884Sszhou /* 10038c1b6884Sszhou * Add trailing / for archive subcommands 10048c1b6884Sszhou */ 10058c1b6884Sszhou if (rootbuf[strlen(rootbuf) - 1] != '/') 10068c1b6884Sszhou (void) strcat(rootbuf, "/"); 10078c1b6884Sszhou bam_rootlen = strlen(rootbuf); 10088c1b6884Sszhou 10097c478bd9Sstevel@tonic-gate /* 10107c478bd9Sstevel@tonic-gate * Check arguments 10117c478bd9Sstevel@tonic-gate */ 10127c478bd9Sstevel@tonic-gate ret = check_subcmd_and_options(subcmd, opt, arch_subcmds, &f); 10137c478bd9Sstevel@tonic-gate if (ret != BAM_SUCCESS) { 10147c478bd9Sstevel@tonic-gate return (BAM_ERROR); 10157c478bd9Sstevel@tonic-gate } 10167c478bd9Sstevel@tonic-gate 1017ae115bc7Smrj ret = dboot_or_multiboot(rootbuf); 1018ae115bc7Smrj if (ret != BAM_SUCCESS) 1019ae115bc7Smrj return (ret); 1020ae115bc7Smrj 10217c478bd9Sstevel@tonic-gate /* 10227c478bd9Sstevel@tonic-gate * Check archive not supported with update_all 10237c478bd9Sstevel@tonic-gate * since it is awkward to display out-of-sync 10247c478bd9Sstevel@tonic-gate * information for each BE. 10257c478bd9Sstevel@tonic-gate */ 10267c478bd9Sstevel@tonic-gate if (bam_check && strcmp(subcmd, "update_all") == 0) { 10277c478bd9Sstevel@tonic-gate bam_error(CHECK_NOT_SUPPORTED, subcmd); 10287c478bd9Sstevel@tonic-gate return (BAM_ERROR); 10297c478bd9Sstevel@tonic-gate } 10307c478bd9Sstevel@tonic-gate 1031b610f78eSvikram if (strcmp(subcmd, "update_all") == 0) 1032b610f78eSvikram bam_update_all = 1; 1033b610f78eSvikram 1034*986fd29aSsetje #if !defined(_OPB) 10352449e17fSsherrym ucode_install(bam_root); 10362449e17fSsherrym #endif 10372449e17fSsherrym 1038b610f78eSvikram ret = f(bam_root, opt); 1039b610f78eSvikram 1040b610f78eSvikram bam_update_all = 0; 1041b610f78eSvikram 1042b610f78eSvikram return (ret); 10437c478bd9Sstevel@tonic-gate } 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 1046ae115bc7Smrj void 10477c478bd9Sstevel@tonic-gate bam_error(char *format, ...) 10487c478bd9Sstevel@tonic-gate { 10497c478bd9Sstevel@tonic-gate va_list ap; 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate va_start(ap, format); 10527c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", prog); 10537c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, format, ap); 10547c478bd9Sstevel@tonic-gate va_end(ap); 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 10587c478bd9Sstevel@tonic-gate static void 10597c478bd9Sstevel@tonic-gate bam_print(char *format, ...) 10607c478bd9Sstevel@tonic-gate { 10617c478bd9Sstevel@tonic-gate va_list ap; 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate va_start(ap, format); 10647c478bd9Sstevel@tonic-gate (void) vfprintf(stdout, format, ap); 10657c478bd9Sstevel@tonic-gate va_end(ap); 10667c478bd9Sstevel@tonic-gate } 10677c478bd9Sstevel@tonic-gate 1068ae115bc7Smrj /*PRINTFLIKE1*/ 1069ae115bc7Smrj void 1070ae115bc7Smrj bam_print_stderr(char *format, ...) 1071ae115bc7Smrj { 1072ae115bc7Smrj va_list ap; 1073ae115bc7Smrj 1074ae115bc7Smrj va_start(ap, format); 1075ae115bc7Smrj (void) vfprintf(stderr, format, ap); 1076ae115bc7Smrj va_end(ap); 1077ae115bc7Smrj } 1078ae115bc7Smrj 10797c478bd9Sstevel@tonic-gate static void 10807c478bd9Sstevel@tonic-gate bam_exit(int excode) 10817c478bd9Sstevel@tonic-gate { 10827c478bd9Sstevel@tonic-gate bam_unlock(); 10837c478bd9Sstevel@tonic-gate exit(excode); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate static void 10877c478bd9Sstevel@tonic-gate bam_lock(void) 10887c478bd9Sstevel@tonic-gate { 10897c478bd9Sstevel@tonic-gate struct flock lock; 10907c478bd9Sstevel@tonic-gate pid_t pid; 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate bam_lock_fd = open(BAM_LOCK_FILE, O_CREAT|O_RDWR, LOCK_FILE_PERMS); 10937c478bd9Sstevel@tonic-gate if (bam_lock_fd < 0) { 10947c478bd9Sstevel@tonic-gate /* 10957c478bd9Sstevel@tonic-gate * We may be invoked early in boot for archive verification. 10967c478bd9Sstevel@tonic-gate * In this case, root is readonly and /var/run may not exist. 10977c478bd9Sstevel@tonic-gate * Proceed without the lock 10987c478bd9Sstevel@tonic-gate */ 10997c478bd9Sstevel@tonic-gate if (errno == EROFS || errno == ENOENT) { 11007c478bd9Sstevel@tonic-gate bam_root_readonly = 1; 11017c478bd9Sstevel@tonic-gate return; 11027c478bd9Sstevel@tonic-gate } 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, BAM_LOCK_FILE, strerror(errno)); 11057c478bd9Sstevel@tonic-gate bam_exit(1); 11067c478bd9Sstevel@tonic-gate } 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 11097c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 11107c478bd9Sstevel@tonic-gate lock.l_start = 0; 11117c478bd9Sstevel@tonic-gate lock.l_len = 0; 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLK, &lock) == -1) { 11147c478bd9Sstevel@tonic-gate if (errno != EACCES && errno != EAGAIN) { 11157c478bd9Sstevel@tonic-gate bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 11167c478bd9Sstevel@tonic-gate (void) close(bam_lock_fd); 11177c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 11187c478bd9Sstevel@tonic-gate bam_exit(1); 11197c478bd9Sstevel@tonic-gate } 11207c478bd9Sstevel@tonic-gate pid = 0; 11217c478bd9Sstevel@tonic-gate (void) pread(bam_lock_fd, &pid, sizeof (pid_t), 0); 11227c478bd9Sstevel@tonic-gate bam_print(FILE_LOCKED, pid); 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 11257c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 11267c478bd9Sstevel@tonic-gate lock.l_start = 0; 11277c478bd9Sstevel@tonic-gate lock.l_len = 0; 11287c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLKW, &lock) == -1) { 11297c478bd9Sstevel@tonic-gate bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 11307c478bd9Sstevel@tonic-gate (void) close(bam_lock_fd); 11317c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 11327c478bd9Sstevel@tonic-gate bam_exit(1); 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate /* We own the lock now */ 11377c478bd9Sstevel@tonic-gate pid = getpid(); 11387c478bd9Sstevel@tonic-gate (void) write(bam_lock_fd, &pid, sizeof (pid)); 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate static void 11427c478bd9Sstevel@tonic-gate bam_unlock(void) 11437c478bd9Sstevel@tonic-gate { 11447c478bd9Sstevel@tonic-gate struct flock unlock; 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate /* 11477c478bd9Sstevel@tonic-gate * NOP if we don't hold the lock 11487c478bd9Sstevel@tonic-gate */ 11497c478bd9Sstevel@tonic-gate if (bam_lock_fd < 0) { 11507c478bd9Sstevel@tonic-gate return; 11517c478bd9Sstevel@tonic-gate } 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate unlock.l_type = F_UNLCK; 11547c478bd9Sstevel@tonic-gate unlock.l_whence = SEEK_SET; 11557c478bd9Sstevel@tonic-gate unlock.l_start = 0; 11567c478bd9Sstevel@tonic-gate unlock.l_len = 0; 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate if (fcntl(bam_lock_fd, F_SETLK, &unlock) == -1) { 11597c478bd9Sstevel@tonic-gate bam_error(UNLOCK_FAIL, BAM_LOCK_FILE, strerror(errno)); 11607c478bd9Sstevel@tonic-gate } 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate if (close(bam_lock_fd) == -1) { 11637c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, BAM_LOCK_FILE, strerror(errno)); 11647c478bd9Sstevel@tonic-gate } 11657c478bd9Sstevel@tonic-gate bam_lock_fd = -1; 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate static error_t 11697c478bd9Sstevel@tonic-gate list_archive(char *root, char *opt) 11707c478bd9Sstevel@tonic-gate { 11717c478bd9Sstevel@tonic-gate filelist_t flist; 11727c478bd9Sstevel@tonic-gate filelist_t *flistp = &flist; 11737c478bd9Sstevel@tonic-gate line_t *lp; 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate assert(root); 11767c478bd9Sstevel@tonic-gate assert(opt == NULL); 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 11797c478bd9Sstevel@tonic-gate if (read_list(root, flistp) != BAM_SUCCESS) { 11807c478bd9Sstevel@tonic-gate return (BAM_ERROR); 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate assert(flistp->head && flistp->tail); 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate for (lp = flistp->head; lp; lp = lp->next) { 11857c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate filelist_free(flistp); 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate /* 11947c478bd9Sstevel@tonic-gate * This routine writes a list of lines to a file. 11957c478bd9Sstevel@tonic-gate * The list is *not* freed 11967c478bd9Sstevel@tonic-gate */ 11977c478bd9Sstevel@tonic-gate static error_t 11987c478bd9Sstevel@tonic-gate list2file(char *root, char *tmp, char *final, line_t *start) 11997c478bd9Sstevel@tonic-gate { 12007c478bd9Sstevel@tonic-gate char tmpfile[PATH_MAX]; 12017c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 12027c478bd9Sstevel@tonic-gate FILE *fp; 12037c478bd9Sstevel@tonic-gate int ret; 12047c478bd9Sstevel@tonic-gate struct stat sb; 12057c478bd9Sstevel@tonic-gate mode_t mode; 12067c478bd9Sstevel@tonic-gate uid_t root_uid; 12077c478bd9Sstevel@tonic-gate gid_t sys_gid; 12087c478bd9Sstevel@tonic-gate struct passwd *pw; 12097c478bd9Sstevel@tonic-gate struct group *gp; 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, final); 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate if (start == NULL) { 12157c478bd9Sstevel@tonic-gate if (stat(path, &sb) != -1) { 12167c478bd9Sstevel@tonic-gate bam_print(UNLINK_EMPTY, path); 12177c478bd9Sstevel@tonic-gate if (unlink(path) != 0) { 12187c478bd9Sstevel@tonic-gate bam_error(UNLINK_FAIL, path, strerror(errno)); 12197c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12207c478bd9Sstevel@tonic-gate } else { 12217c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate /* 12277c478bd9Sstevel@tonic-gate * Preserve attributes of existing file if possible, 12287c478bd9Sstevel@tonic-gate * otherwise ask the system for uid/gid of root/sys. 12297c478bd9Sstevel@tonic-gate * If all fails, fall back on hard-coded defaults. 12307c478bd9Sstevel@tonic-gate */ 12317c478bd9Sstevel@tonic-gate if (stat(path, &sb) != -1) { 12327c478bd9Sstevel@tonic-gate mode = sb.st_mode; 12337c478bd9Sstevel@tonic-gate root_uid = sb.st_uid; 12347c478bd9Sstevel@tonic-gate sys_gid = sb.st_gid; 12357c478bd9Sstevel@tonic-gate } else { 12367c478bd9Sstevel@tonic-gate mode = DEFAULT_DEV_MODE; 12377c478bd9Sstevel@tonic-gate if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) { 12387c478bd9Sstevel@tonic-gate root_uid = pw->pw_uid; 12397c478bd9Sstevel@tonic-gate } else { 12407c478bd9Sstevel@tonic-gate if (bam_verbose) 12417c478bd9Sstevel@tonic-gate bam_error(CANT_FIND_USER, 12427c478bd9Sstevel@tonic-gate DEFAULT_DEV_USER, DEFAULT_DEV_UID); 12437c478bd9Sstevel@tonic-gate root_uid = (uid_t)DEFAULT_DEV_UID; 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) { 12467c478bd9Sstevel@tonic-gate sys_gid = gp->gr_gid; 12477c478bd9Sstevel@tonic-gate } else { 12487c478bd9Sstevel@tonic-gate if (bam_verbose) 12497c478bd9Sstevel@tonic-gate bam_error(CANT_FIND_GROUP, 12507c478bd9Sstevel@tonic-gate DEFAULT_DEV_GROUP, DEFAULT_DEV_GID); 12517c478bd9Sstevel@tonic-gate sys_gid = (gid_t)DEFAULT_DEV_GID; 12527c478bd9Sstevel@tonic-gate } 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate (void) snprintf(tmpfile, sizeof (tmpfile), "%s%s", root, tmp); 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate /* Truncate tmpfile first */ 12587c478bd9Sstevel@tonic-gate fp = fopen(tmpfile, "w"); 12597c478bd9Sstevel@tonic-gate if (fp == NULL) { 12607c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, tmpfile, strerror(errno)); 12617c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12627c478bd9Sstevel@tonic-gate } 12637c478bd9Sstevel@tonic-gate ret = fclose(fp); 12647c478bd9Sstevel@tonic-gate if (ret == EOF) { 12657c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, tmpfile, strerror(errno)); 12667c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate /* Now open it in append mode */ 12707c478bd9Sstevel@tonic-gate fp = fopen(tmpfile, "a"); 12717c478bd9Sstevel@tonic-gate if (fp == NULL) { 12727c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, tmpfile, strerror(errno)); 12737c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate for (; start; start = start->next) { 12777c478bd9Sstevel@tonic-gate ret = s_fputs(start->line, fp); 12787c478bd9Sstevel@tonic-gate if (ret == EOF) { 12797c478bd9Sstevel@tonic-gate bam_error(WRITE_FAIL, tmpfile, strerror(errno)); 12807c478bd9Sstevel@tonic-gate (void) fclose(fp); 12817c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate } 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate ret = fclose(fp); 12867c478bd9Sstevel@tonic-gate if (ret == EOF) { 12877c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, tmpfile, strerror(errno)); 12887c478bd9Sstevel@tonic-gate return (BAM_ERROR); 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate /* 1292de531be4Sjg * Set up desired attributes. Ignore failures on filesystems 1293de531be4Sjg * not supporting these operations - pcfs reports unsupported 1294de531be4Sjg * operations as EINVAL. 12957c478bd9Sstevel@tonic-gate */ 12967c478bd9Sstevel@tonic-gate ret = chmod(tmpfile, mode); 1297de531be4Sjg if (ret == -1 && 1298de531be4Sjg errno != EINVAL && errno != ENOTSUP) { 12997c478bd9Sstevel@tonic-gate bam_error(CHMOD_FAIL, tmpfile, strerror(errno)); 13007c478bd9Sstevel@tonic-gate return (BAM_ERROR); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate ret = chown(tmpfile, root_uid, sys_gid); 1304de531be4Sjg if (ret == -1 && 1305de531be4Sjg errno != EINVAL && errno != ENOTSUP) { 13067c478bd9Sstevel@tonic-gate bam_error(CHOWN_FAIL, tmpfile, strerror(errno)); 13077c478bd9Sstevel@tonic-gate return (BAM_ERROR); 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate /* 13127c478bd9Sstevel@tonic-gate * Do an atomic rename 13137c478bd9Sstevel@tonic-gate */ 13147c478bd9Sstevel@tonic-gate ret = rename(tmpfile, path); 13157c478bd9Sstevel@tonic-gate if (ret != 0) { 13167c478bd9Sstevel@tonic-gate bam_error(RENAME_FAIL, path, strerror(errno)); 13177c478bd9Sstevel@tonic-gate return (BAM_ERROR); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 13217c478bd9Sstevel@tonic-gate } 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate /* 13247c478bd9Sstevel@tonic-gate * This function should always return 0 - since we want 13257c478bd9Sstevel@tonic-gate * to create stat data for *all* files in the list. 13267c478bd9Sstevel@tonic-gate */ 13277c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13287c478bd9Sstevel@tonic-gate static int 13297c478bd9Sstevel@tonic-gate cmpstat( 13307c478bd9Sstevel@tonic-gate const char *file, 13317c478bd9Sstevel@tonic-gate const struct stat *stat, 13327c478bd9Sstevel@tonic-gate int flags, 13337c478bd9Sstevel@tonic-gate struct FTW *ftw) 13347c478bd9Sstevel@tonic-gate { 13357c478bd9Sstevel@tonic-gate uint_t sz; 13367c478bd9Sstevel@tonic-gate uint64_t *value; 13377c478bd9Sstevel@tonic-gate uint64_t filestat[2]; 13387c478bd9Sstevel@tonic-gate int error; 13397c478bd9Sstevel@tonic-gate 134058091fd8Ssetje struct safefile *safefilep; 134158091fd8Ssetje FILE *fp; 134258091fd8Ssetje 13437c478bd9Sstevel@tonic-gate /* 13447c478bd9Sstevel@tonic-gate * We only want regular files 13457c478bd9Sstevel@tonic-gate */ 13467c478bd9Sstevel@tonic-gate if (!S_ISREG(stat->st_mode)) 13477c478bd9Sstevel@tonic-gate return (0); 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate /* 13507c478bd9Sstevel@tonic-gate * new_nvlp may be NULL if there were errors earlier 13517c478bd9Sstevel@tonic-gate * but this is not fatal to update determination. 13527c478bd9Sstevel@tonic-gate */ 13537c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp) { 13547c478bd9Sstevel@tonic-gate filestat[0] = stat->st_size; 13557c478bd9Sstevel@tonic-gate filestat[1] = stat->st_mtime; 13567c478bd9Sstevel@tonic-gate error = nvlist_add_uint64_array(walk_arg.new_nvlp, 13577c478bd9Sstevel@tonic-gate file + bam_rootlen, filestat, 2); 13587c478bd9Sstevel@tonic-gate if (error) 13597c478bd9Sstevel@tonic-gate bam_error(NVADD_FAIL, file, strerror(error)); 13607c478bd9Sstevel@tonic-gate } 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate /* 13637c478bd9Sstevel@tonic-gate * The remaining steps are only required if we haven't made a 13647c478bd9Sstevel@tonic-gate * decision about update or if we are checking (-n) 13657c478bd9Sstevel@tonic-gate */ 13667c478bd9Sstevel@tonic-gate if (walk_arg.need_update && !bam_check) 13677c478bd9Sstevel@tonic-gate return (0); 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate /* 137058091fd8Ssetje * If we are invoked as part of system/filesyste/boot-archive, then 137158091fd8Ssetje * there are a number of things we should not worry about 13727c478bd9Sstevel@tonic-gate */ 137358091fd8Ssetje if (bam_smf_check) { 137458091fd8Ssetje /* ignore amd64 modules unless we are booted amd64. */ 137558091fd8Ssetje if (!is_amd64() && strstr(file, "/amd64/") != 0) 137658091fd8Ssetje return (0); 137758091fd8Ssetje 137858091fd8Ssetje /* read in list of safe files */ 137958091fd8Ssetje if (safefiles == NULL) 138058091fd8Ssetje if (fp = fopen("/boot/solaris/filelist.safe", "r")) { 138158091fd8Ssetje safefiles = s_calloc(1, 138258091fd8Ssetje sizeof (struct safefile)); 138358091fd8Ssetje safefilep = safefiles; 138458091fd8Ssetje safefilep->name = s_calloc(1, MAXPATHLEN + 138558091fd8Ssetje MAXNAMELEN); 138658091fd8Ssetje safefilep->next = NULL; 138758091fd8Ssetje while (s_fgets(safefilep->name, MAXPATHLEN + 138858091fd8Ssetje MAXNAMELEN, fp) != NULL) { 138958091fd8Ssetje safefilep->next = s_calloc(1, 139058091fd8Ssetje sizeof (struct safefile)); 139158091fd8Ssetje safefilep = safefilep->next; 139258091fd8Ssetje safefilep->name = s_calloc(1, 139358091fd8Ssetje MAXPATHLEN + MAXNAMELEN); 139458091fd8Ssetje safefilep->next = NULL; 139558091fd8Ssetje } 139658091fd8Ssetje (void) fclose(fp); 139758091fd8Ssetje } 139858091fd8Ssetje } 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate /* 14017c478bd9Sstevel@tonic-gate * We need an update if file doesn't exist in old archive 14027c478bd9Sstevel@tonic-gate */ 14037c478bd9Sstevel@tonic-gate if (walk_arg.old_nvlp == NULL || 14047c478bd9Sstevel@tonic-gate nvlist_lookup_uint64_array(walk_arg.old_nvlp, 14057c478bd9Sstevel@tonic-gate file + bam_rootlen, &value, &sz) != 0) { 14067c478bd9Sstevel@tonic-gate if (bam_smf_check) /* ignore new during smf check */ 14077c478bd9Sstevel@tonic-gate return (0); 14087c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 14097c478bd9Sstevel@tonic-gate if (bam_verbose) 14107c478bd9Sstevel@tonic-gate bam_print(PARSEABLE_NEW_FILE, file); 14117c478bd9Sstevel@tonic-gate return (0); 14127c478bd9Sstevel@tonic-gate } 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate /* 14157c478bd9Sstevel@tonic-gate * File exists in old archive. Check if file has changed 14167c478bd9Sstevel@tonic-gate */ 14177c478bd9Sstevel@tonic-gate assert(sz == 2); 14187c478bd9Sstevel@tonic-gate bcopy(value, filestat, sizeof (filestat)); 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate if (filestat[0] != stat->st_size || 14217c478bd9Sstevel@tonic-gate filestat[1] != stat->st_mtime) { 14227c609327Ssetje if (bam_smf_check) { 14237c609327Ssetje safefilep = safefiles; 14247c609327Ssetje while (safefilep != NULL) { 14257c609327Ssetje if (strcmp(file + bam_rootlen, 14267c609327Ssetje safefilep->name) == 0) { 14277c609327Ssetje (void) creat(NEED_UPDATE_FILE, 0644); 14287c609327Ssetje return (0); 14297c609327Ssetje } 14307c609327Ssetje safefilep = safefilep->next; 14317c609327Ssetje } 14327c609327Ssetje } 14337c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 14347c478bd9Sstevel@tonic-gate if (bam_verbose) 14357c478bd9Sstevel@tonic-gate if (bam_smf_check) 14367c478bd9Sstevel@tonic-gate bam_print(" %s\n", file); 14377c478bd9Sstevel@tonic-gate else 14387c478bd9Sstevel@tonic-gate bam_print(PARSEABLE_OUT_DATE, file); 14397c478bd9Sstevel@tonic-gate } 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate return (0); 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate /* 14457c478bd9Sstevel@tonic-gate * Check flags and presence of required files. 14467c478bd9Sstevel@tonic-gate * The force flag and/or absence of files should 14477c478bd9Sstevel@tonic-gate * trigger an update. 14487c478bd9Sstevel@tonic-gate * Suppress stdout output if check (-n) option is set 14497c478bd9Sstevel@tonic-gate * (as -n should only produce parseable output.) 14507c478bd9Sstevel@tonic-gate */ 14517c478bd9Sstevel@tonic-gate static void 14527c478bd9Sstevel@tonic-gate check_flags_and_files(char *root) 14537c478bd9Sstevel@tonic-gate { 14547c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 14557c478bd9Sstevel@tonic-gate struct stat sb; 14567c478bd9Sstevel@tonic-gate 14577c478bd9Sstevel@tonic-gate /* 14587c478bd9Sstevel@tonic-gate * if force, create archive unconditionally 14597c478bd9Sstevel@tonic-gate */ 14607c478bd9Sstevel@tonic-gate if (bam_force) { 14617c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 14627c478bd9Sstevel@tonic-gate if (bam_verbose && !bam_check) 14637c478bd9Sstevel@tonic-gate bam_print(UPDATE_FORCE); 14647c478bd9Sstevel@tonic-gate return; 14657c478bd9Sstevel@tonic-gate } 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate /* 14687c478bd9Sstevel@tonic-gate * If archive is missing, create archive 14697c478bd9Sstevel@tonic-gate */ 1470*986fd29aSsetje 1471*986fd29aSsetje if (is_sun4u()) 1472*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1473*986fd29aSsetje SUN4U__ARCHIVE); 1474*986fd29aSsetje else if (is_sun4v()) 1475*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1476*986fd29aSsetje SUN4V__ARCHIVE); 1477*986fd29aSsetje else { 1478*986fd29aSsetje if (bam_direct == BAM_DIRECT_DBOOT) { 1479*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1480*986fd29aSsetje DIRECT_BOOT_ARCHIVE_64); 1481*986fd29aSsetje if (stat(path, &sb) != 0) { 1482*986fd29aSsetje if (bam_verbose && !bam_check) 1483*986fd29aSsetje bam_print(UPDATE_ARCH_MISS, path); 1484*986fd29aSsetje walk_arg.need_update = 1; 1485*986fd29aSsetje return; 1486*986fd29aSsetje } 1487*986fd29aSsetje } 1488*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s%s", root, 1489*986fd29aSsetje DIRECT_BOOT_ARCHIVE_32); 1490*986fd29aSsetje } 1491*986fd29aSsetje 14927c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) { 14937c478bd9Sstevel@tonic-gate if (bam_verbose && !bam_check) 14947c478bd9Sstevel@tonic-gate bam_print(UPDATE_ARCH_MISS, path); 14957c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 14967c478bd9Sstevel@tonic-gate return; 14977c478bd9Sstevel@tonic-gate } 14987c478bd9Sstevel@tonic-gate } 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate static error_t 15017c478bd9Sstevel@tonic-gate read_one_list(char *root, filelist_t *flistp, char *filelist) 15027c478bd9Sstevel@tonic-gate { 15037c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 15047c478bd9Sstevel@tonic-gate FILE *fp; 15057c478bd9Sstevel@tonic-gate char buf[BAM_MAXLINE]; 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, filelist); 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate fp = fopen(path, "r"); 15107c478bd9Sstevel@tonic-gate if (fp == NULL) { 15117c478bd9Sstevel@tonic-gate if (bam_debug) 15127c478bd9Sstevel@tonic-gate bam_error(FLIST_FAIL, path, strerror(errno)); 15137c478bd9Sstevel@tonic-gate return (BAM_ERROR); 15147c478bd9Sstevel@tonic-gate } 15157c478bd9Sstevel@tonic-gate while (s_fgets(buf, sizeof (buf), fp) != NULL) { 1516b610f78eSvikram /* skip blank lines */ 1517b610f78eSvikram if (strspn(buf, " \t") == strlen(buf)) 1518b610f78eSvikram continue; 15197c478bd9Sstevel@tonic-gate append_to_flist(flistp, buf); 15207c478bd9Sstevel@tonic-gate } 15217c478bd9Sstevel@tonic-gate if (fclose(fp) != 0) { 15227c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, path, strerror(errno)); 15237c478bd9Sstevel@tonic-gate return (BAM_ERROR); 15247c478bd9Sstevel@tonic-gate } 15257c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 15267c478bd9Sstevel@tonic-gate } 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate static error_t 15297c478bd9Sstevel@tonic-gate read_list(char *root, filelist_t *flistp) 15307c478bd9Sstevel@tonic-gate { 1531*986fd29aSsetje char path[PATH_MAX]; 1532*986fd29aSsetje char cmd[PATH_MAX]; 1533*986fd29aSsetje struct stat sb; 1534*986fd29aSsetje int n, rval; 15357c478bd9Sstevel@tonic-gate 15367c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate /* 1539*986fd29aSsetje * build and check path to extract_boot_filelist.ksh 15407c478bd9Sstevel@tonic-gate */ 1541*986fd29aSsetje n = snprintf(path, sizeof (path), "%s%s", root, EXTRACT_BOOT_FILELIST); 1542*986fd29aSsetje if (n >= sizeof (path)) { 1543*986fd29aSsetje bam_error(NO_FLIST); 1544*986fd29aSsetje return (BAM_ERROR); 1545*986fd29aSsetje } 1546*986fd29aSsetje 1547*986fd29aSsetje /* 1548*986fd29aSsetje * If extract_boot_filelist is present, exec it, otherwise read 1549*986fd29aSsetje * the filelists directly, for compatibility with older images. 1550*986fd29aSsetje */ 1551*986fd29aSsetje if (stat(path, &sb) == 0) { 1552*986fd29aSsetje /* 1553*986fd29aSsetje * build arguments to exec extract_boot_filelist.ksh 1554*986fd29aSsetje */ 1555*986fd29aSsetje if (strlen(root) > 1) { 1556*986fd29aSsetje n = snprintf(cmd, sizeof (cmd), "%s -R %s /%s /%s", 1557*986fd29aSsetje path, root, BOOT_FILE_LIST, ETC_FILE_LIST); 1558*986fd29aSsetje } else { 1559*986fd29aSsetje n = snprintf(cmd, sizeof (cmd), "%s /%s /%s", 1560*986fd29aSsetje path, BOOT_FILE_LIST, ETC_FILE_LIST); 1561*986fd29aSsetje } 1562*986fd29aSsetje if (n >= sizeof (cmd)) { 1563*986fd29aSsetje bam_error(NO_FLIST); 1564*986fd29aSsetje return (BAM_ERROR); 1565*986fd29aSsetje } 1566*986fd29aSsetje if (exec_cmd(cmd, flistp) != 0) { 1567*986fd29aSsetje if (bam_debug) 1568*986fd29aSsetje bam_error(FLIST_FAIL, path, strerror(errno)); 1569*986fd29aSsetje return (BAM_ERROR); 1570*986fd29aSsetje } 1571*986fd29aSsetje } else { 1572*986fd29aSsetje /* 1573*986fd29aSsetje * Read current lists of files - only the first is mandatory 1574*986fd29aSsetje */ 1575*986fd29aSsetje rval = read_one_list(root, flistp, BOOT_FILE_LIST); 1576*986fd29aSsetje if (rval != BAM_SUCCESS) 1577*986fd29aSsetje return (rval); 1578*986fd29aSsetje (void) read_one_list(root, flistp, ETC_FILE_LIST); 1579*986fd29aSsetje } 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate if (flistp->head == NULL) { 15827c478bd9Sstevel@tonic-gate bam_error(NO_FLIST); 15837c478bd9Sstevel@tonic-gate return (BAM_ERROR); 15847c478bd9Sstevel@tonic-gate } 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate static void 15907c478bd9Sstevel@tonic-gate getoldstat(char *root) 15917c478bd9Sstevel@tonic-gate { 15927c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 15937c478bd9Sstevel@tonic-gate int fd, error; 15947c478bd9Sstevel@tonic-gate struct stat sb; 15957c478bd9Sstevel@tonic-gate char *ostat; 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 15987c478bd9Sstevel@tonic-gate fd = open(path, O_RDONLY); 15997c478bd9Sstevel@tonic-gate if (fd == -1) { 16007c478bd9Sstevel@tonic-gate if (bam_verbose) 16017c478bd9Sstevel@tonic-gate bam_print(OPEN_FAIL, path, strerror(errno)); 16027c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 16037c478bd9Sstevel@tonic-gate return; 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate if (fstat(fd, &sb) != 0) { 16077c478bd9Sstevel@tonic-gate bam_error(STAT_FAIL, path, strerror(errno)); 16087c478bd9Sstevel@tonic-gate (void) close(fd); 16097c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 16107c478bd9Sstevel@tonic-gate return; 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate ostat = s_calloc(1, sb.st_size); 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate if (read(fd, ostat, sb.st_size) != sb.st_size) { 16167c478bd9Sstevel@tonic-gate bam_error(READ_FAIL, path, strerror(errno)); 16177c478bd9Sstevel@tonic-gate (void) close(fd); 16187c478bd9Sstevel@tonic-gate free(ostat); 16197c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 16207c478bd9Sstevel@tonic-gate return; 16217c478bd9Sstevel@tonic-gate } 16227c478bd9Sstevel@tonic-gate 16237c478bd9Sstevel@tonic-gate (void) close(fd); 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 16267c478bd9Sstevel@tonic-gate error = nvlist_unpack(ostat, sb.st_size, &walk_arg.old_nvlp, 0); 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate free(ostat); 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate if (error) { 16317c478bd9Sstevel@tonic-gate bam_error(UNPACK_FAIL, path, strerror(error)); 16327c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 16337c478bd9Sstevel@tonic-gate walk_arg.need_update = 1; 16347c478bd9Sstevel@tonic-gate return; 16357c478bd9Sstevel@tonic-gate } 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate 1638a28d77b8Svikram /* 1639a28d77b8Svikram * Checks if a file in the current (old) archive has 1640a28d77b8Svikram * been deleted from the root filesystem. This is needed for 1641a28d77b8Svikram * software like Trusted Extensions (TX) that switch early 1642a28d77b8Svikram * in boot based on presence/absence of a kernel module. 1643a28d77b8Svikram */ 1644a28d77b8Svikram static void 1645a28d77b8Svikram check4stale(char *root) 1646a28d77b8Svikram { 1647a28d77b8Svikram nvpair_t *nvp; 1648a28d77b8Svikram nvlist_t *nvlp; 1649a28d77b8Svikram char *file; 1650a28d77b8Svikram char path[PATH_MAX]; 1651a28d77b8Svikram struct stat sb; 1652a28d77b8Svikram 1653a28d77b8Svikram /* 1654a28d77b8Svikram * Skip stale file check during smf check 1655a28d77b8Svikram */ 1656a28d77b8Svikram if (bam_smf_check) 1657a28d77b8Svikram return; 1658a28d77b8Svikram 1659a28d77b8Svikram /* Nothing to do if no old stats */ 1660a28d77b8Svikram if ((nvlp = walk_arg.old_nvlp) == NULL) 1661a28d77b8Svikram return; 1662a28d77b8Svikram 1663a28d77b8Svikram for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp; 1664a28d77b8Svikram nvp = nvlist_next_nvpair(nvlp, nvp)) { 1665a28d77b8Svikram file = nvpair_name(nvp); 1666a28d77b8Svikram if (file == NULL) 1667a28d77b8Svikram continue; 1668a28d77b8Svikram (void) snprintf(path, sizeof (path), "%s/%s", 1669a28d77b8Svikram root, file); 1670a28d77b8Svikram if (stat(path, &sb) == -1) { 1671a28d77b8Svikram walk_arg.need_update = 1; 1672a28d77b8Svikram if (bam_verbose) 1673a28d77b8Svikram bam_print(PARSEABLE_STALE_FILE, path); 1674a28d77b8Svikram } 1675a28d77b8Svikram } 1676a28d77b8Svikram } 1677a28d77b8Svikram 16787c478bd9Sstevel@tonic-gate static void 16797c478bd9Sstevel@tonic-gate create_newstat(void) 16807c478bd9Sstevel@tonic-gate { 16817c478bd9Sstevel@tonic-gate int error; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate error = nvlist_alloc(&walk_arg.new_nvlp, NV_UNIQUE_NAME, 0); 16847c478bd9Sstevel@tonic-gate if (error) { 16857c478bd9Sstevel@tonic-gate /* 16867c478bd9Sstevel@tonic-gate * Not fatal - we can still create archive 16877c478bd9Sstevel@tonic-gate */ 16887c478bd9Sstevel@tonic-gate walk_arg.new_nvlp = NULL; 16897c478bd9Sstevel@tonic-gate bam_error(NVALLOC_FAIL, strerror(error)); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate } 16927c478bd9Sstevel@tonic-gate 16937c478bd9Sstevel@tonic-gate static void 16947c478bd9Sstevel@tonic-gate walk_list(char *root, filelist_t *flistp) 16957c478bd9Sstevel@tonic-gate { 16967c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 16977c478bd9Sstevel@tonic-gate line_t *lp; 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate for (lp = flistp->head; lp; lp = lp->next) { 1700*986fd29aSsetje /* 1701*986fd29aSsetje * Don't follow symlinks. A symlink must refer to 1702*986fd29aSsetje * a file that would appear in the archive through 1703*986fd29aSsetje * a direct reference. This matches the archive 1704*986fd29aSsetje * construction behavior. 1705*986fd29aSsetje */ 17067c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, lp->line); 1707*986fd29aSsetje if (nftw(path, cmpstat, 20, FTW_PHYS) == -1) { 17087c478bd9Sstevel@tonic-gate /* 17097c478bd9Sstevel@tonic-gate * Some files may not exist. 17107c478bd9Sstevel@tonic-gate * For example: etc/rtc_config on a x86 diskless system 17117c478bd9Sstevel@tonic-gate * Emit verbose message only 17127c478bd9Sstevel@tonic-gate */ 17137c478bd9Sstevel@tonic-gate if (bam_verbose) 17147c478bd9Sstevel@tonic-gate bam_print(NFTW_FAIL, path, strerror(errno)); 17157c478bd9Sstevel@tonic-gate } 17167c478bd9Sstevel@tonic-gate } 17177c478bd9Sstevel@tonic-gate } 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate static void 17207c478bd9Sstevel@tonic-gate savenew(char *root) 17217c478bd9Sstevel@tonic-gate { 17227c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 17237c478bd9Sstevel@tonic-gate char path2[PATH_MAX]; 17247c478bd9Sstevel@tonic-gate size_t sz; 17257c478bd9Sstevel@tonic-gate char *nstat; 17267c478bd9Sstevel@tonic-gate int fd, wrote, error; 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate nstat = NULL; 17297c478bd9Sstevel@tonic-gate sz = 0; 17307c478bd9Sstevel@tonic-gate error = nvlist_pack(walk_arg.new_nvlp, &nstat, &sz, 17317c478bd9Sstevel@tonic-gate NV_ENCODE_XDR, 0); 17327c478bd9Sstevel@tonic-gate if (error) { 17337c478bd9Sstevel@tonic-gate bam_error(PACK_FAIL, strerror(error)); 17347c478bd9Sstevel@tonic-gate return; 17357c478bd9Sstevel@tonic-gate } 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT_TMP); 17387c478bd9Sstevel@tonic-gate fd = open(path, O_RDWR|O_CREAT|O_TRUNC, FILE_STAT_MODE); 17397c478bd9Sstevel@tonic-gate if (fd == -1) { 17407c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, path, strerror(errno)); 17417c478bd9Sstevel@tonic-gate free(nstat); 17427c478bd9Sstevel@tonic-gate return; 17437c478bd9Sstevel@tonic-gate } 17447c478bd9Sstevel@tonic-gate wrote = write(fd, nstat, sz); 17457c478bd9Sstevel@tonic-gate if (wrote != sz) { 17467c478bd9Sstevel@tonic-gate bam_error(WRITE_FAIL, path, strerror(errno)); 17477c478bd9Sstevel@tonic-gate (void) close(fd); 17487c478bd9Sstevel@tonic-gate free(nstat); 17497c478bd9Sstevel@tonic-gate return; 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate (void) close(fd); 17527c478bd9Sstevel@tonic-gate free(nstat); 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate (void) snprintf(path2, sizeof (path2), "%s%s", root, FILE_STAT); 17557c478bd9Sstevel@tonic-gate if (rename(path, path2) != 0) { 17567c478bd9Sstevel@tonic-gate bam_error(RENAME_FAIL, path2, strerror(errno)); 17577c478bd9Sstevel@tonic-gate } 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate static void 17617c478bd9Sstevel@tonic-gate clear_walk_args(void) 17627c478bd9Sstevel@tonic-gate { 17637c478bd9Sstevel@tonic-gate if (walk_arg.old_nvlp) 17647c478bd9Sstevel@tonic-gate nvlist_free(walk_arg.old_nvlp); 17657c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp) 17667c478bd9Sstevel@tonic-gate nvlist_free(walk_arg.new_nvlp); 17677c478bd9Sstevel@tonic-gate walk_arg.need_update = 0; 17687c478bd9Sstevel@tonic-gate walk_arg.old_nvlp = NULL; 17697c478bd9Sstevel@tonic-gate walk_arg.new_nvlp = NULL; 17707c478bd9Sstevel@tonic-gate } 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate /* 17737c478bd9Sstevel@tonic-gate * Returns: 17747c478bd9Sstevel@tonic-gate * 0 - no update necessary 17757c478bd9Sstevel@tonic-gate * 1 - update required. 17767c478bd9Sstevel@tonic-gate * BAM_ERROR (-1) - An error occurred 17777c478bd9Sstevel@tonic-gate * 17787c478bd9Sstevel@tonic-gate * Special handling for check (-n): 17797c478bd9Sstevel@tonic-gate * ================================ 17807c478bd9Sstevel@tonic-gate * The check (-n) option produces parseable output. 17817c478bd9Sstevel@tonic-gate * To do this, we suppress all stdout messages unrelated 17827c478bd9Sstevel@tonic-gate * to out of sync files. 17837c478bd9Sstevel@tonic-gate * All stderr messages are still printed though. 17847c478bd9Sstevel@tonic-gate * 17857c478bd9Sstevel@tonic-gate */ 17867c478bd9Sstevel@tonic-gate static int 17877c478bd9Sstevel@tonic-gate update_required(char *root) 17887c478bd9Sstevel@tonic-gate { 17897c478bd9Sstevel@tonic-gate struct stat sb; 17907c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 17917c478bd9Sstevel@tonic-gate filelist_t flist; 17927c478bd9Sstevel@tonic-gate filelist_t *flistp = &flist; 17937c478bd9Sstevel@tonic-gate int need_update; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate flistp->head = flistp->tail = NULL; 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate walk_arg.need_update = 0; 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate /* 18007c478bd9Sstevel@tonic-gate * Without consulting stat data, check if we need update 18017c478bd9Sstevel@tonic-gate */ 18027c478bd9Sstevel@tonic-gate check_flags_and_files(root); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate /* 18057c478bd9Sstevel@tonic-gate * In certain deployment scenarios, filestat may not 18067c478bd9Sstevel@tonic-gate * exist. Ignore it during boot-archive SMF check. 18077c478bd9Sstevel@tonic-gate */ 18087c478bd9Sstevel@tonic-gate if (bam_smf_check) { 18097c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT); 18107c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) 18117c478bd9Sstevel@tonic-gate return (0); 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate 18147c478bd9Sstevel@tonic-gate /* 18157c478bd9Sstevel@tonic-gate * consult stat data only if we haven't made a decision 18167c478bd9Sstevel@tonic-gate * about update. If checking (-n) however, we always 18177c478bd9Sstevel@tonic-gate * need stat data (since we want to compare old and new) 18187c478bd9Sstevel@tonic-gate */ 18197c478bd9Sstevel@tonic-gate if (!walk_arg.need_update || bam_check) 18207c478bd9Sstevel@tonic-gate getoldstat(root); 18217c478bd9Sstevel@tonic-gate 1822a28d77b8Svikram /* 1823a28d77b8Svikram * Check if the archive contains files that are no longer 1824a28d77b8Svikram * present on the root filesystem. 1825a28d77b8Svikram */ 1826a28d77b8Svikram if (!walk_arg.need_update || bam_check) 1827a28d77b8Svikram check4stale(root); 1828a28d77b8Svikram 18297c478bd9Sstevel@tonic-gate /* 18307c478bd9Sstevel@tonic-gate * read list of files 18317c478bd9Sstevel@tonic-gate */ 18327c478bd9Sstevel@tonic-gate if (read_list(root, flistp) != BAM_SUCCESS) { 18337c478bd9Sstevel@tonic-gate clear_walk_args(); 18347c478bd9Sstevel@tonic-gate return (BAM_ERROR); 18357c478bd9Sstevel@tonic-gate } 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate assert(flistp->head && flistp->tail); 18387c478bd9Sstevel@tonic-gate 18397c478bd9Sstevel@tonic-gate /* 18407c478bd9Sstevel@tonic-gate * At this point either the update is required 18417c478bd9Sstevel@tonic-gate * or the decision is pending. In either case 18427c478bd9Sstevel@tonic-gate * we need to create new stat nvlist 18437c478bd9Sstevel@tonic-gate */ 18447c478bd9Sstevel@tonic-gate create_newstat(); 18457c478bd9Sstevel@tonic-gate 18467c478bd9Sstevel@tonic-gate /* 18477c478bd9Sstevel@tonic-gate * This walk does 2 things: 18487c478bd9Sstevel@tonic-gate * - gets new stat data for every file 18497c478bd9Sstevel@tonic-gate * - (optional) compare old and new stat data 18507c478bd9Sstevel@tonic-gate */ 18517c478bd9Sstevel@tonic-gate walk_list(root, &flist); 18527c478bd9Sstevel@tonic-gate 18537c478bd9Sstevel@tonic-gate /* done with the file list */ 18547c478bd9Sstevel@tonic-gate filelist_free(flistp); 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate /* 18577c478bd9Sstevel@tonic-gate * if we didn't succeed in creating new stat data above 18587c478bd9Sstevel@tonic-gate * just return result of update check so that archive is built. 18597c478bd9Sstevel@tonic-gate */ 18607c478bd9Sstevel@tonic-gate if (walk_arg.new_nvlp == NULL) { 18617c478bd9Sstevel@tonic-gate bam_error(NO_NEW_STAT); 18627c478bd9Sstevel@tonic-gate need_update = walk_arg.need_update; 18637c478bd9Sstevel@tonic-gate clear_walk_args(); 18647c478bd9Sstevel@tonic-gate return (need_update ? 1 : 0); 18657c478bd9Sstevel@tonic-gate } 18667c478bd9Sstevel@tonic-gate 18677c478bd9Sstevel@tonic-gate 18687c478bd9Sstevel@tonic-gate /* 18697c478bd9Sstevel@tonic-gate * If no update required, discard newstat 18707c478bd9Sstevel@tonic-gate */ 18717c478bd9Sstevel@tonic-gate if (!walk_arg.need_update) { 18727c478bd9Sstevel@tonic-gate clear_walk_args(); 18737c478bd9Sstevel@tonic-gate return (0); 18747c478bd9Sstevel@tonic-gate } 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate return (1); 18777c478bd9Sstevel@tonic-gate } 18787c478bd9Sstevel@tonic-gate 18797c478bd9Sstevel@tonic-gate static error_t 18807c478bd9Sstevel@tonic-gate create_ramdisk(char *root) 18817c478bd9Sstevel@tonic-gate { 18827c478bd9Sstevel@tonic-gate char *cmdline, path[PATH_MAX]; 18837c478bd9Sstevel@tonic-gate size_t len; 18847c478bd9Sstevel@tonic-gate struct stat sb; 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate /* 18877c478bd9Sstevel@tonic-gate * Setup command args for create_ramdisk.ksh 18887c478bd9Sstevel@tonic-gate */ 1889*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 18907c478bd9Sstevel@tonic-gate if (stat(path, &sb) != 0) { 18917c478bd9Sstevel@tonic-gate bam_error(ARCH_EXEC_MISS, path, strerror(errno)); 18927c478bd9Sstevel@tonic-gate return (BAM_ERROR); 18937c478bd9Sstevel@tonic-gate } 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate len = strlen(path) + strlen(root) + 10; /* room for space + -R */ 18967c478bd9Sstevel@tonic-gate cmdline = s_calloc(1, len); 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate if (strlen(root) > 1) { 18997c478bd9Sstevel@tonic-gate (void) snprintf(cmdline, len, "%s -R %s", path, root); 19007c478bd9Sstevel@tonic-gate /* chop off / at the end */ 19017c478bd9Sstevel@tonic-gate cmdline[strlen(cmdline) - 1] = '\0'; 19027c478bd9Sstevel@tonic-gate } else 19037c478bd9Sstevel@tonic-gate (void) snprintf(cmdline, len, "%s", path); 19047c478bd9Sstevel@tonic-gate 1905*986fd29aSsetje if (exec_cmd(cmdline, NULL) != 0) { 19067c478bd9Sstevel@tonic-gate bam_error(ARCHIVE_FAIL, cmdline); 19077c478bd9Sstevel@tonic-gate free(cmdline); 19087c478bd9Sstevel@tonic-gate return (BAM_ERROR); 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate free(cmdline); 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate /* 1913*986fd29aSsetje * The existence of the expected archives used to be 1914*986fd29aSsetje * verified here. This check is done in create_ramdisk as 1915*986fd29aSsetje * it needs to be in sync with the altroot operated upon. 19167c478bd9Sstevel@tonic-gate */ 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 19197c478bd9Sstevel@tonic-gate } 19207c478bd9Sstevel@tonic-gate 19217c478bd9Sstevel@tonic-gate /* 19227c478bd9Sstevel@tonic-gate * Checks if target filesystem is on a ramdisk 19237c478bd9Sstevel@tonic-gate * 1 - is miniroot 19247c478bd9Sstevel@tonic-gate * 0 - is not 19257c478bd9Sstevel@tonic-gate * When in doubt assume it is not a ramdisk. 19267c478bd9Sstevel@tonic-gate */ 19277c478bd9Sstevel@tonic-gate static int 19287c478bd9Sstevel@tonic-gate is_ramdisk(char *root) 19297c478bd9Sstevel@tonic-gate { 19307c478bd9Sstevel@tonic-gate struct extmnttab mnt; 19317c478bd9Sstevel@tonic-gate FILE *fp; 19327c478bd9Sstevel@tonic-gate int found; 1933b610f78eSvikram char mntpt[PATH_MAX]; 1934b610f78eSvikram char *cp; 19357c478bd9Sstevel@tonic-gate 19367c478bd9Sstevel@tonic-gate /* 19377c478bd9Sstevel@tonic-gate * There are 3 situations where creating archive is 19387c478bd9Sstevel@tonic-gate * of dubious value: 1939b610f78eSvikram * - create boot_archive on a lofi-mounted boot_archive 19407c478bd9Sstevel@tonic-gate * - create it on a ramdisk which is the root filesystem 19417c478bd9Sstevel@tonic-gate * - create it on a ramdisk mounted somewhere else 19427c478bd9Sstevel@tonic-gate * The first is not easy to detect and checking for it is not 19437c478bd9Sstevel@tonic-gate * worth it. 19447c478bd9Sstevel@tonic-gate * The other two conditions are handled here 19457c478bd9Sstevel@tonic-gate */ 19467c478bd9Sstevel@tonic-gate 19477c478bd9Sstevel@tonic-gate fp = fopen(MNTTAB, "r"); 19487c478bd9Sstevel@tonic-gate if (fp == NULL) { 19497c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 19507c478bd9Sstevel@tonic-gate return (0); 19517c478bd9Sstevel@tonic-gate } 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate resetmnttab(fp); 19547c478bd9Sstevel@tonic-gate 1955b610f78eSvikram /* 1956b610f78eSvikram * Remove any trailing / from the mount point 1957b610f78eSvikram */ 1958b610f78eSvikram (void) strlcpy(mntpt, root, sizeof (mntpt)); 1959b610f78eSvikram if (strcmp(root, "/") != 0) { 1960b610f78eSvikram cp = mntpt + strlen(mntpt) - 1; 1961b610f78eSvikram if (*cp == '/') 1962b610f78eSvikram *cp = '\0'; 1963b610f78eSvikram } 19647c478bd9Sstevel@tonic-gate found = 0; 19657c478bd9Sstevel@tonic-gate while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 1966b610f78eSvikram if (strcmp(mnt.mnt_mountp, mntpt) == 0) { 19677c478bd9Sstevel@tonic-gate found = 1; 19687c478bd9Sstevel@tonic-gate break; 19697c478bd9Sstevel@tonic-gate } 19707c478bd9Sstevel@tonic-gate } 19717c478bd9Sstevel@tonic-gate 19727c478bd9Sstevel@tonic-gate if (!found) { 19737c478bd9Sstevel@tonic-gate if (bam_verbose) 1974b610f78eSvikram bam_error(NOT_IN_MNTTAB, mntpt); 19757c478bd9Sstevel@tonic-gate (void) fclose(fp); 19767c478bd9Sstevel@tonic-gate return (0); 19777c478bd9Sstevel@tonic-gate } 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate if (strstr(mnt.mnt_special, RAMDISK_SPECIAL) != NULL) { 19807c478bd9Sstevel@tonic-gate if (bam_verbose) 19817c478bd9Sstevel@tonic-gate bam_error(IS_RAMDISK, bam_root); 19827c478bd9Sstevel@tonic-gate (void) fclose(fp); 19837c478bd9Sstevel@tonic-gate return (1); 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 19867c478bd9Sstevel@tonic-gate (void) fclose(fp); 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate return (0); 19897c478bd9Sstevel@tonic-gate } 19907c478bd9Sstevel@tonic-gate 19917c478bd9Sstevel@tonic-gate static int 1992*986fd29aSsetje is_boot_archive(char *root) 19937c478bd9Sstevel@tonic-gate { 19947c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 19957c478bd9Sstevel@tonic-gate struct stat sb; 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate /* 1998*986fd29aSsetje * We can't create an archive without the create_ramdisk script 19997c478bd9Sstevel@tonic-gate */ 2000*986fd29aSsetje (void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK); 20017c478bd9Sstevel@tonic-gate if (stat(path, &sb) == -1) { 20027c478bd9Sstevel@tonic-gate if (bam_verbose) 20037c478bd9Sstevel@tonic-gate bam_print(FILE_MISS, path); 20047c478bd9Sstevel@tonic-gate return (0); 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate 2007*986fd29aSsetje return (1); 2008*986fd29aSsetje } 2009*986fd29aSsetje 2010*986fd29aSsetje /* 2011*986fd29aSsetje * Need to call this for anything that operates on the GRUB menu 2012*986fd29aSsetje */ 2013*986fd29aSsetje int 2014*986fd29aSsetje is_grub(const char *root) 2015*986fd29aSsetje { 2016*986fd29aSsetje char path[PATH_MAX]; 2017*986fd29aSsetje struct stat sb; 2018*986fd29aSsetje 20197c478bd9Sstevel@tonic-gate /* 2020*986fd29aSsetje * GRUB_DIR is required to modify the menu 20217c478bd9Sstevel@tonic-gate */ 20227c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", root, GRUB_DIR); 20237c478bd9Sstevel@tonic-gate if (stat(path, &sb) == -1) { 2024*986fd29aSsetje if (bam_debug) 20257c478bd9Sstevel@tonic-gate bam_print(DIR_MISS, path); 20267c478bd9Sstevel@tonic-gate return (0); 20277c478bd9Sstevel@tonic-gate } 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate return (1); 20307c478bd9Sstevel@tonic-gate } 20317c478bd9Sstevel@tonic-gate 20327c478bd9Sstevel@tonic-gate static int 20337c478bd9Sstevel@tonic-gate is_readonly(char *root) 20347c478bd9Sstevel@tonic-gate { 20357c478bd9Sstevel@tonic-gate struct statvfs vfs; 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate /* 20387c478bd9Sstevel@tonic-gate * Check for RDONLY filesystem 20397c478bd9Sstevel@tonic-gate * When in doubt assume it is not readonly 20407c478bd9Sstevel@tonic-gate */ 20417c478bd9Sstevel@tonic-gate if (statvfs(root, &vfs) != 0) { 20427c478bd9Sstevel@tonic-gate if (bam_verbose) 20437c478bd9Sstevel@tonic-gate bam_error(STATVFS_FAIL, root, strerror(errno)); 20447c478bd9Sstevel@tonic-gate return (0); 20457c478bd9Sstevel@tonic-gate } 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate if (vfs.f_flag & ST_RDONLY) { 20487c478bd9Sstevel@tonic-gate return (1); 20497c478bd9Sstevel@tonic-gate } 20507c478bd9Sstevel@tonic-gate 20517c478bd9Sstevel@tonic-gate return (0); 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate static error_t 20557c478bd9Sstevel@tonic-gate update_archive(char *root, char *opt) 20567c478bd9Sstevel@tonic-gate { 20577c478bd9Sstevel@tonic-gate error_t ret; 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate assert(root); 20607c478bd9Sstevel@tonic-gate assert(opt == NULL); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate /* 2063*986fd29aSsetje * root must belong to a boot archive based OS, 20647c478bd9Sstevel@tonic-gate */ 2065*986fd29aSsetje if (!is_boot_archive(root)) { 2066b610f78eSvikram /* 2067b610f78eSvikram * Emit message only if not in context of update_all. 2068b610f78eSvikram * If in update_all, emit only if verbose flag is set. 2069b610f78eSvikram */ 2070b610f78eSvikram if (!bam_update_all || bam_verbose) 2071b610f78eSvikram bam_print(NOT_GRUB_BOOT, root); 20727c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 20737c478bd9Sstevel@tonic-gate } 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate /* 20768c1b6884Sszhou * If smf check is requested when / is writable (can happen 20778c1b6884Sszhou * on first reboot following an upgrade because service 20788c1b6884Sszhou * dependency is messed up), skip the check. 20798c1b6884Sszhou */ 20808c1b6884Sszhou if (bam_smf_check && !bam_root_readonly) 20818c1b6884Sszhou return (BAM_SUCCESS); 20828c1b6884Sszhou 20838c1b6884Sszhou /* 20848c1b6884Sszhou * root must be writable. This check applies to alternate 20858c1b6884Sszhou * root (-R option); bam_root_readonly applies to '/' only. 20867c478bd9Sstevel@tonic-gate * Note: statvfs() does not always report the truth 20877c478bd9Sstevel@tonic-gate */ 208861cb17bdSsetje if (!bam_smf_check && !bam_check && is_readonly(root)) { 20898c1b6884Sszhou if (bam_verbose) 20907c478bd9Sstevel@tonic-gate bam_print(RDONLY_FS, root); 20917c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate /* 20957c478bd9Sstevel@tonic-gate * Don't generate archive on ramdisk 20967c478bd9Sstevel@tonic-gate */ 20977c478bd9Sstevel@tonic-gate if (is_ramdisk(root)) { 20987c478bd9Sstevel@tonic-gate if (bam_verbose) 20997c478bd9Sstevel@tonic-gate bam_print(SKIP_RAMDISK); 21007c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate /* 21047c478bd9Sstevel@tonic-gate * Now check if updated is really needed 21057c478bd9Sstevel@tonic-gate */ 21067c478bd9Sstevel@tonic-gate ret = update_required(root); 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate /* 21097c478bd9Sstevel@tonic-gate * The check command (-n) is *not* a dry run 21107c478bd9Sstevel@tonic-gate * It only checks if the archive is in sync. 21117c478bd9Sstevel@tonic-gate */ 21127c478bd9Sstevel@tonic-gate if (bam_check) { 21137c478bd9Sstevel@tonic-gate bam_exit((ret != 0) ? 1 : 0); 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate if (ret == 1) { 21177c478bd9Sstevel@tonic-gate /* create the ramdisk */ 21187c478bd9Sstevel@tonic-gate ret = create_ramdisk(root); 21197c478bd9Sstevel@tonic-gate } 2120*986fd29aSsetje 2121*986fd29aSsetje /* if the archive is updated, save the new stat data */ 2122*986fd29aSsetje if (ret == 0 && walk_arg.new_nvlp != NULL) { 2123*986fd29aSsetje savenew(root); 2124*986fd29aSsetje } 2125*986fd29aSsetje 2126*986fd29aSsetje clear_walk_args(); 2127*986fd29aSsetje 21287c478bd9Sstevel@tonic-gate return (ret); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate 2131fbac2b2bSvikram static void 2132fbac2b2bSvikram update_fdisk(void) 2133fbac2b2bSvikram { 2134fbac2b2bSvikram struct stat sb; 2135fbac2b2bSvikram char cmd[PATH_MAX]; 2136fbac2b2bSvikram int ret1, ret2; 2137fbac2b2bSvikram 2138fbac2b2bSvikram assert(stat(GRUB_fdisk, &sb) == 0); 2139fbac2b2bSvikram assert(stat(GRUB_fdisk_target, &sb) == 0); 2140fbac2b2bSvikram 2141fbac2b2bSvikram (void) snprintf(cmd, sizeof (cmd), "/sbin/fdisk -F %s `/bin/cat %s`", 2142fbac2b2bSvikram GRUB_fdisk, GRUB_fdisk_target); 2143fbac2b2bSvikram 2144fbac2b2bSvikram bam_print(UPDATING_FDISK); 2145*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 2146fbac2b2bSvikram bam_error(FDISK_UPDATE_FAILED); 2147fbac2b2bSvikram } 2148fbac2b2bSvikram 2149fbac2b2bSvikram /* 2150fbac2b2bSvikram * We are done, remove the files. 2151fbac2b2bSvikram */ 2152fbac2b2bSvikram ret1 = unlink(GRUB_fdisk); 2153fbac2b2bSvikram ret2 = unlink(GRUB_fdisk_target); 2154fbac2b2bSvikram if (ret1 != 0 || ret2 != 0) { 2155fbac2b2bSvikram bam_error(FILE_REMOVE_FAILED, GRUB_fdisk, GRUB_fdisk_target); 2156fbac2b2bSvikram } 2157fbac2b2bSvikram } 2158fbac2b2bSvikram 2159b610f78eSvikram static void 2160b610f78eSvikram restore_grub_slice(void) 2161b610f78eSvikram { 2162b610f78eSvikram struct stat sb; 2163b610f78eSvikram char *mntpt, *physlice; 2164b610f78eSvikram int mnted; /* set if we did a mount */ 2165b610f78eSvikram char menupath[PATH_MAX], cmd[PATH_MAX]; 2166b610f78eSvikram 2167b610f78eSvikram if (stat(GRUB_slice, &sb) != 0) { 2168b610f78eSvikram bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno)); 2169b610f78eSvikram return; 2170b610f78eSvikram } 2171b610f78eSvikram 2172b610f78eSvikram /* 2173b610f78eSvikram * If we are doing an luactivate, don't attempt to restore GRUB or else 2174b610f78eSvikram * we may not be able to get to DCA boot environments. Let luactivate 2175b610f78eSvikram * handle GRUB/DCA installation 2176b610f78eSvikram */ 2177b610f78eSvikram if (stat(LU_ACTIVATE_FILE, &sb) == 0) { 2178b610f78eSvikram return; 2179b610f78eSvikram } 2180b610f78eSvikram 2181b610f78eSvikram mnted = 0; 2182b610f78eSvikram physlice = NULL; 218340541d5dSvikram mntpt = mount_grub_slice(&mnted, &physlice, NULL, NULL); 2184b610f78eSvikram if (mntpt == NULL) { 2185b610f78eSvikram bam_error(CANNOT_RESTORE_GRUB_SLICE); 2186b610f78eSvikram return; 2187b610f78eSvikram } 2188b610f78eSvikram 2189b610f78eSvikram (void) snprintf(menupath, sizeof (menupath), "%s%s", mntpt, GRUB_MENU); 2190b610f78eSvikram if (stat(menupath, &sb) == 0) { 219140541d5dSvikram umount_grub_slice(mnted, mntpt, physlice, NULL, NULL); 2192b610f78eSvikram return; 2193b610f78eSvikram } 2194b610f78eSvikram 2195b610f78eSvikram /* 2196b610f78eSvikram * The menu is missing - we need to do a restore 2197b610f78eSvikram */ 2198b610f78eSvikram bam_print(RESTORING_GRUB); 2199b610f78eSvikram 2200b610f78eSvikram (void) snprintf(cmd, sizeof (cmd), "%s %s %s %s", 2201b610f78eSvikram INSTALLGRUB, STAGE1, STAGE2, physlice); 2202b610f78eSvikram 2203*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 2204b610f78eSvikram bam_error(RESTORE_GRUB_FAILED); 220540541d5dSvikram umount_grub_slice(mnted, mntpt, physlice, NULL, NULL); 2206b610f78eSvikram return; 2207b610f78eSvikram } 2208b610f78eSvikram 2209b610f78eSvikram if (stat(GRUB_backup_menu, &sb) != 0) { 2210b610f78eSvikram bam_error(MISSING_BACKUP_MENU, 2211b610f78eSvikram GRUB_backup_menu, strerror(errno)); 221240541d5dSvikram umount_grub_slice(mnted, mntpt, physlice, NULL, NULL); 2213b610f78eSvikram return; 2214b610f78eSvikram } 2215b610f78eSvikram 2216b610f78eSvikram (void) snprintf(cmd, sizeof (cmd), "/bin/cp %s %s", 2217b610f78eSvikram GRUB_backup_menu, menupath); 2218b610f78eSvikram 2219*986fd29aSsetje if (exec_cmd(cmd, NULL) != 0) { 2220b610f78eSvikram bam_error(RESTORE_MENU_FAILED, menupath); 222140541d5dSvikram umount_grub_slice(mnted, mntpt, physlice, NULL, NULL); 2222b610f78eSvikram return; 2223b610f78eSvikram } 2224b610f78eSvikram 2225b610f78eSvikram /* Success */ 222640541d5dSvikram umount_grub_slice(mnted, mntpt, physlice, NULL, NULL); 2227b610f78eSvikram } 2228b610f78eSvikram 22297c478bd9Sstevel@tonic-gate static error_t 22307c478bd9Sstevel@tonic-gate update_all(char *root, char *opt) 22317c478bd9Sstevel@tonic-gate { 22327c478bd9Sstevel@tonic-gate struct extmnttab mnt; 22337c478bd9Sstevel@tonic-gate struct stat sb; 22347c478bd9Sstevel@tonic-gate FILE *fp; 22357c478bd9Sstevel@tonic-gate char multibt[PATH_MAX]; 2236*986fd29aSsetje char creatram[PATH_MAX]; 22377c478bd9Sstevel@tonic-gate error_t ret = BAM_SUCCESS; 2238fbac2b2bSvikram int ret1, ret2; 22397c478bd9Sstevel@tonic-gate 224040541d5dSvikram assert(root); 22417c478bd9Sstevel@tonic-gate assert(opt == NULL); 22427c478bd9Sstevel@tonic-gate 224340541d5dSvikram if (bam_rootlen != 1 || *root != '/') { 224440541d5dSvikram elide_trailing_slash(root, multibt, sizeof (multibt)); 224540541d5dSvikram bam_error(ALT_ROOT_INVALID, multibt); 224640541d5dSvikram return (BAM_ERROR); 224740541d5dSvikram } 224840541d5dSvikram 22497c478bd9Sstevel@tonic-gate /* 225098892a30Snadkarni * Check to see if we are in the midst of safemode patching 225198892a30Snadkarni * If so skip building the archive for /. Instead build it 225298892a30Snadkarni * against the latest bits obtained by creating a fresh lofs 225398892a30Snadkarni * mount of root. 22547c478bd9Sstevel@tonic-gate */ 225598892a30Snadkarni if (stat(LOFS_PATCH_FILE, &sb) == 0) { 225698892a30Snadkarni if (mkdir(LOFS_PATCH_MNT, 0755) == -1 && 225798892a30Snadkarni errno != EEXIST) { 225898892a30Snadkarni bam_error(MKDIR_FAILED, "%s", LOFS_PATCH_MNT, 225998892a30Snadkarni strerror(errno)); 226098892a30Snadkarni ret = BAM_ERROR; 226198892a30Snadkarni goto out; 226298892a30Snadkarni } 226398892a30Snadkarni (void) snprintf(multibt, sizeof (multibt), 226498892a30Snadkarni "/sbin/mount -F lofs -o nosub / %s", LOFS_PATCH_MNT); 2265*986fd29aSsetje if (exec_cmd(multibt, NULL) != 0) { 226698892a30Snadkarni bam_error(MOUNT_FAILED, LOFS_PATCH_MNT, "lofs"); 226798892a30Snadkarni ret = BAM_ERROR; 226898892a30Snadkarni } 226998892a30Snadkarni if (ret != BAM_ERROR) { 227098892a30Snadkarni (void) snprintf(rootbuf, sizeof (rootbuf), "%s/", 227198892a30Snadkarni LOFS_PATCH_MNT); 227298892a30Snadkarni bam_rootlen = strlen(rootbuf); 227398892a30Snadkarni if (update_archive(rootbuf, opt) != BAM_SUCCESS) 227498892a30Snadkarni ret = BAM_ERROR; 227595b1e0e9Snadkarni /* 227695b1e0e9Snadkarni * unmount the lofs mount since there could be 227795b1e0e9Snadkarni * multiple invocations of bootadm -a update_all 227895b1e0e9Snadkarni */ 227995b1e0e9Snadkarni (void) snprintf(multibt, sizeof (multibt), 228095b1e0e9Snadkarni "/sbin/umount %s", LOFS_PATCH_MNT); 2281*986fd29aSsetje if (exec_cmd(multibt, NULL) != 0) { 228295b1e0e9Snadkarni bam_error(UMOUNT_FAILED, LOFS_PATCH_MNT); 228395b1e0e9Snadkarni ret = BAM_ERROR; 228495b1e0e9Snadkarni } 228598892a30Snadkarni } 228698892a30Snadkarni } else { 228798892a30Snadkarni /* 228898892a30Snadkarni * First update archive for current root 228998892a30Snadkarni */ 229098892a30Snadkarni if (update_archive(root, opt) != BAM_SUCCESS) 229198892a30Snadkarni ret = BAM_ERROR; 229298892a30Snadkarni } 229398892a30Snadkarni 229498892a30Snadkarni if (ret == BAM_ERROR) 229598892a30Snadkarni goto out; 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate /* 22987c478bd9Sstevel@tonic-gate * Now walk the mount table, performing archive update 22997c478bd9Sstevel@tonic-gate * for all mounted Newboot root filesystems 23007c478bd9Sstevel@tonic-gate */ 23017c478bd9Sstevel@tonic-gate fp = fopen(MNTTAB, "r"); 23027c478bd9Sstevel@tonic-gate if (fp == NULL) { 23037c478bd9Sstevel@tonic-gate bam_error(OPEN_FAIL, MNTTAB, strerror(errno)); 2304b610f78eSvikram ret = BAM_ERROR; 2305b610f78eSvikram goto out; 23067c478bd9Sstevel@tonic-gate } 23077c478bd9Sstevel@tonic-gate 23087c478bd9Sstevel@tonic-gate resetmnttab(fp); 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) { 23117c478bd9Sstevel@tonic-gate if (mnt.mnt_special == NULL) 23127c478bd9Sstevel@tonic-gate continue; 23137c478bd9Sstevel@tonic-gate if (strncmp(mnt.mnt_special, "/dev/", strlen("/dev/")) != 0) 23147c478bd9Sstevel@tonic-gate continue; 23157c478bd9Sstevel@tonic-gate if (strcmp(mnt.mnt_mountp, "/") == 0) 23167c478bd9Sstevel@tonic-gate continue; 23177c478bd9Sstevel@tonic-gate 2318*986fd29aSsetje (void) snprintf(creatram, sizeof (creatram), "%s/%s", 2319*986fd29aSsetje mnt.mnt_mountp, CREATE_RAMDISK); 23207c478bd9Sstevel@tonic-gate 2321*986fd29aSsetje if (stat(creatram, &sb) == -1) 23227c478bd9Sstevel@tonic-gate continue; 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate /* 23257c478bd9Sstevel@tonic-gate * We put a trailing slash to be consistent with root = "/" 23267c478bd9Sstevel@tonic-gate * case, such that we don't have to print // in some cases. 23277c478bd9Sstevel@tonic-gate */ 23287c478bd9Sstevel@tonic-gate (void) snprintf(rootbuf, sizeof (rootbuf), "%s/", 23297c478bd9Sstevel@tonic-gate mnt.mnt_mountp); 23307c478bd9Sstevel@tonic-gate bam_rootlen = strlen(rootbuf); 2331ae115bc7Smrj 2332ae115bc7Smrj /* 2333ae115bc7Smrj * It's possible that other mounts may be an alternate boot 2334ae115bc7Smrj * architecture, so check it again. 2335ae115bc7Smrj */ 2336ae115bc7Smrj if ((dboot_or_multiboot(rootbuf) != BAM_SUCCESS) || 2337ae115bc7Smrj (update_archive(rootbuf, opt) != BAM_SUCCESS)) 23387c478bd9Sstevel@tonic-gate ret = BAM_ERROR; 23397c478bd9Sstevel@tonic-gate } 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate (void) fclose(fp); 23427c478bd9Sstevel@tonic-gate 2343b610f78eSvikram out: 2344b610f78eSvikram if (stat(GRUB_slice, &sb) == 0) { 2345b610f78eSvikram restore_grub_slice(); 2346b610f78eSvikram } 2347b610f78eSvikram 2348fbac2b2bSvikram /* 2349fbac2b2bSvikram * Update fdisk table as we go down. Updating it when 2350fbac2b2bSvikram * the system is running will confuse biosdev. 2351fbac2b2bSvikram */ 2352fbac2b2bSvikram ret1 = stat(GRUB_fdisk, &sb); 2353fbac2b2bSvikram ret2 = stat(GRUB_fdisk_target, &sb); 2354fbac2b2bSvikram if ((ret1 == 0) && (ret2 == 0)) { 2355fbac2b2bSvikram update_fdisk(); 2356fbac2b2bSvikram } else if ((ret1 == 0) ^ (ret2 == 0)) { 2357fbac2b2bSvikram /* 2358fbac2b2bSvikram * It is an error for one file to be 2359fbac2b2bSvikram * present and the other absent. 2360fbac2b2bSvikram * It is normal for both files to be 2361fbac2b2bSvikram * absent - it indicates that no fdisk 2362fbac2b2bSvikram * update is required. 2363fbac2b2bSvikram */ 2364fbac2b2bSvikram bam_error(MISSING_FDISK_FILE, 2365fbac2b2bSvikram ret1 ? GRUB_fdisk : GRUB_fdisk_target); 2366fbac2b2bSvikram ret = BAM_ERROR; 2367fbac2b2bSvikram } 2368fbac2b2bSvikram 23697c478bd9Sstevel@tonic-gate return (ret); 23707c478bd9Sstevel@tonic-gate } 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate static void 23737c478bd9Sstevel@tonic-gate append_line(menu_t *mp, line_t *lp) 23747c478bd9Sstevel@tonic-gate { 23757c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 23767c478bd9Sstevel@tonic-gate mp->start = lp; 23777c478bd9Sstevel@tonic-gate } else { 23787c478bd9Sstevel@tonic-gate mp->end->next = lp; 23798c1b6884Sszhou lp->prev = mp->end; 23807c478bd9Sstevel@tonic-gate } 23817c478bd9Sstevel@tonic-gate mp->end = lp; 23827c478bd9Sstevel@tonic-gate } 23837c478bd9Sstevel@tonic-gate 23848c1b6884Sszhou static void 23858c1b6884Sszhou unlink_line(menu_t *mp, line_t *lp) 23868c1b6884Sszhou { 23878c1b6884Sszhou /* unlink from list */ 23888c1b6884Sszhou if (lp->prev) 23898c1b6884Sszhou lp->prev->next = lp->next; 23908c1b6884Sszhou else 23918c1b6884Sszhou mp->start = lp->next; 23928c1b6884Sszhou if (lp->next) 23938c1b6884Sszhou lp->next->prev = lp->prev; 23948c1b6884Sszhou else 23958c1b6884Sszhou mp->end = lp->prev; 23968c1b6884Sszhou } 23978c1b6884Sszhou 23988c1b6884Sszhou static entry_t * 23998c1b6884Sszhou boot_entry_new(menu_t *mp, line_t *start, line_t *end) 24008c1b6884Sszhou { 24018c1b6884Sszhou entry_t *ent, *prev; 24028c1b6884Sszhou 24038c1b6884Sszhou ent = s_calloc(1, sizeof (entry_t)); 24048c1b6884Sszhou ent->start = start; 24058c1b6884Sszhou ent->end = end; 24068c1b6884Sszhou 24078c1b6884Sszhou if (mp->entries == NULL) { 24088c1b6884Sszhou mp->entries = ent; 24098c1b6884Sszhou return (ent); 24108c1b6884Sszhou } 24118c1b6884Sszhou 24128c1b6884Sszhou prev = mp->entries; 24138c1b6884Sszhou while (prev->next) 24148c1b6884Sszhou prev = prev-> next; 24158c1b6884Sszhou prev->next = ent; 24168c1b6884Sszhou ent->prev = prev; 24178c1b6884Sszhou return (ent); 24188c1b6884Sszhou } 24198c1b6884Sszhou 24208c1b6884Sszhou static void 24218c1b6884Sszhou boot_entry_addline(entry_t *ent, line_t *lp) 24228c1b6884Sszhou { 24238c1b6884Sszhou if (ent) 24248c1b6884Sszhou ent->end = lp; 24258c1b6884Sszhou } 24268c1b6884Sszhou 2427843e1988Sjohnlev /* 2428843e1988Sjohnlev * Check whether cmd matches the one indexed by which, and whether arg matches 2429843e1988Sjohnlev * str. which must be either KERNEL_CMD or MODULE_CMD, and a match to the 2430843e1988Sjohnlev * respective *_DOLLAR_CMD is also acceptable. The arg is searched using 2431843e1988Sjohnlev * strstr(), so it can be a partial match. 2432843e1988Sjohnlev */ 2433843e1988Sjohnlev static int 2434843e1988Sjohnlev check_cmd(const char *cmd, const int which, const char *arg, const char *str) 2435843e1988Sjohnlev { 2436843e1988Sjohnlev if ((strcmp(cmd, menu_cmds[which]) != 0) && 2437843e1988Sjohnlev (strcmp(cmd, menu_cmds[which + 1]) != 0)) { 2438843e1988Sjohnlev return (0); 2439843e1988Sjohnlev } 2440843e1988Sjohnlev return (strstr(arg, str) != NULL); 2441843e1988Sjohnlev } 2442843e1988Sjohnlev 24437c478bd9Sstevel@tonic-gate /* 24447c478bd9Sstevel@tonic-gate * A line in menu.lst looks like 24457c478bd9Sstevel@tonic-gate * [ ]*<cmd>[ \t=]*<arg>* 24467c478bd9Sstevel@tonic-gate */ 24477c478bd9Sstevel@tonic-gate static void 24487c478bd9Sstevel@tonic-gate line_parser(menu_t *mp, char *str, int *lineNum, int *entryNum) 24497c478bd9Sstevel@tonic-gate { 24507c478bd9Sstevel@tonic-gate /* 24517c478bd9Sstevel@tonic-gate * save state across calls. This is so that 24527c478bd9Sstevel@tonic-gate * header gets the right entry# after title has 24537c478bd9Sstevel@tonic-gate * been processed 24547c478bd9Sstevel@tonic-gate */ 24558c1b6884Sszhou static line_t *prev = NULL; 24568c1b6884Sszhou static entry_t *curr_ent = NULL; 2457ae115bc7Smrj static int in_liveupgrade = 0; 24587c478bd9Sstevel@tonic-gate 24597c478bd9Sstevel@tonic-gate line_t *lp; 24607c478bd9Sstevel@tonic-gate char *cmd, *sep, *arg; 24617c478bd9Sstevel@tonic-gate char save, *cp, *line; 24627c478bd9Sstevel@tonic-gate menu_flag_t flag = BAM_INVALID; 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate if (str == NULL) { 24657c478bd9Sstevel@tonic-gate return; 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate /* 24697c478bd9Sstevel@tonic-gate * First save a copy of the entire line. 24707c478bd9Sstevel@tonic-gate * We use this later to set the line field. 24717c478bd9Sstevel@tonic-gate */ 24727c478bd9Sstevel@tonic-gate line = s_strdup(str); 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate /* Eat up leading whitespace */ 24757c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 24767c478bd9Sstevel@tonic-gate str++; 24777c478bd9Sstevel@tonic-gate 24787c478bd9Sstevel@tonic-gate if (*str == '#') { /* comment */ 24797c478bd9Sstevel@tonic-gate cmd = s_strdup("#"); 24807c478bd9Sstevel@tonic-gate sep = NULL; 24817c478bd9Sstevel@tonic-gate arg = s_strdup(str + 1); 24827c478bd9Sstevel@tonic-gate flag = BAM_COMMENT; 2483ae115bc7Smrj if (strstr(arg, BAM_LU_HDR) != NULL) { 2484ae115bc7Smrj in_liveupgrade = 1; 2485ae115bc7Smrj } else if (strstr(arg, BAM_LU_FTR) != NULL) { 2486ae115bc7Smrj in_liveupgrade = 0; 2487ae115bc7Smrj } 24887c478bd9Sstevel@tonic-gate } else if (*str == '\0') { /* blank line */ 24897c478bd9Sstevel@tonic-gate cmd = sep = arg = NULL; 24907c478bd9Sstevel@tonic-gate flag = BAM_EMPTY; 24917c478bd9Sstevel@tonic-gate } else { 24927c478bd9Sstevel@tonic-gate /* 24937c478bd9Sstevel@tonic-gate * '=' is not a documented separator in grub syntax. 24947c478bd9Sstevel@tonic-gate * However various development bits use '=' as a 24957c478bd9Sstevel@tonic-gate * separator. In addition, external users also 24967c478bd9Sstevel@tonic-gate * use = as a separator. So we will allow that usage. 24977c478bd9Sstevel@tonic-gate */ 24987c478bd9Sstevel@tonic-gate cp = str; 24997c478bd9Sstevel@tonic-gate while (*str != ' ' && *str != '\t' && *str != '=') { 25007c478bd9Sstevel@tonic-gate if (*str == '\0') { 25017c478bd9Sstevel@tonic-gate cmd = s_strdup(cp); 25027c478bd9Sstevel@tonic-gate sep = arg = NULL; 25037c478bd9Sstevel@tonic-gate break; 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate str++; 25067c478bd9Sstevel@tonic-gate } 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate if (*str != '\0') { 25097c478bd9Sstevel@tonic-gate save = *str; 25107c478bd9Sstevel@tonic-gate *str = '\0'; 25117c478bd9Sstevel@tonic-gate cmd = s_strdup(cp); 25127c478bd9Sstevel@tonic-gate *str = save; 25137c478bd9Sstevel@tonic-gate 25147c478bd9Sstevel@tonic-gate str++; 25157c478bd9Sstevel@tonic-gate save = *str; 25167c478bd9Sstevel@tonic-gate *str = '\0'; 25177c478bd9Sstevel@tonic-gate sep = s_strdup(str - 1); 25187c478bd9Sstevel@tonic-gate *str = save; 25197c478bd9Sstevel@tonic-gate 25207c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 25217c478bd9Sstevel@tonic-gate str++; 25227c478bd9Sstevel@tonic-gate if (*str == '\0') 25237c478bd9Sstevel@tonic-gate arg = NULL; 25247c478bd9Sstevel@tonic-gate else 25257c478bd9Sstevel@tonic-gate arg = s_strdup(str); 25267c478bd9Sstevel@tonic-gate } 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 25307c478bd9Sstevel@tonic-gate 25317c478bd9Sstevel@tonic-gate lp->cmd = cmd; 25327c478bd9Sstevel@tonic-gate lp->sep = sep; 25337c478bd9Sstevel@tonic-gate lp->arg = arg; 25347c478bd9Sstevel@tonic-gate lp->line = line; 25357c478bd9Sstevel@tonic-gate lp->lineNum = ++(*lineNum); 25367c478bd9Sstevel@tonic-gate if (cmd && strcmp(cmd, menu_cmds[TITLE_CMD]) == 0) { 25377c478bd9Sstevel@tonic-gate lp->entryNum = ++(*entryNum); 25387c478bd9Sstevel@tonic-gate lp->flags = BAM_TITLE; 25397c478bd9Sstevel@tonic-gate if (prev && prev->flags == BAM_COMMENT && 2540ae115bc7Smrj prev->arg && strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 25417c478bd9Sstevel@tonic-gate prev->entryNum = lp->entryNum; 25428c1b6884Sszhou curr_ent = boot_entry_new(mp, prev, lp); 2543ae115bc7Smrj curr_ent->flags = BAM_ENTRY_BOOTADM; 25448c1b6884Sszhou } else { 25458c1b6884Sszhou curr_ent = boot_entry_new(mp, lp, lp); 2546ae115bc7Smrj if (in_liveupgrade) { 2547ae115bc7Smrj curr_ent->flags = BAM_ENTRY_LU; 2548ae115bc7Smrj } 25498c1b6884Sszhou } 2550ae115bc7Smrj curr_ent->entryNum = *entryNum; 25517c478bd9Sstevel@tonic-gate } else if (flag != BAM_INVALID) { 25527c478bd9Sstevel@tonic-gate /* 25537c478bd9Sstevel@tonic-gate * For header comments, the entry# is "fixed up" 25547c478bd9Sstevel@tonic-gate * by the subsequent title 25557c478bd9Sstevel@tonic-gate */ 25567c478bd9Sstevel@tonic-gate lp->entryNum = *entryNum; 25577c478bd9Sstevel@tonic-gate lp->flags = flag; 25587c478bd9Sstevel@tonic-gate } else { 25597c478bd9Sstevel@tonic-gate lp->entryNum = *entryNum; 2560ae115bc7Smrj 2561ae115bc7Smrj if (*entryNum == ENTRY_INIT) { 2562ae115bc7Smrj lp->flags = BAM_GLOBAL; 2563ae115bc7Smrj } else { 2564ae115bc7Smrj lp->flags = BAM_ENTRY; 2565ae115bc7Smrj 2566ae115bc7Smrj if (cmd && arg) { 2567ae115bc7Smrj /* 2568ae115bc7Smrj * We only compare for the length of "module" 2569ae115bc7Smrj * so that "module$" will also match. 2570ae115bc7Smrj */ 2571843e1988Sjohnlev if (check_cmd(cmd, MODULE_CMD, arg, MINIROOT)) 2572ae115bc7Smrj curr_ent->flags |= BAM_ENTRY_MINIROOT; 2573843e1988Sjohnlev else if (check_cmd(cmd, KERNEL_CMD, arg, 2574843e1988Sjohnlev "xen.gz")) 2575843e1988Sjohnlev curr_ent->flags |= BAM_ENTRY_HV; 2576ae115bc7Smrj else if (strcmp(cmd, menu_cmds[ROOT_CMD]) == 0) 2577ae115bc7Smrj curr_ent->flags |= BAM_ENTRY_ROOT; 2578ae115bc7Smrj else if (strcmp(cmd, 2579ae115bc7Smrj menu_cmds[CHAINLOADER_CMD]) == 0) 2580ae115bc7Smrj curr_ent->flags |= 2581ae115bc7Smrj BAM_ENTRY_CHAINLOADER; 2582ae115bc7Smrj } 2583ae115bc7Smrj } 25847c478bd9Sstevel@tonic-gate } 25857c478bd9Sstevel@tonic-gate 25868c1b6884Sszhou /* record default, old default, and entry line ranges */ 25878c1b6884Sszhou if (lp->flags == BAM_GLOBAL && 25888c1b6884Sszhou strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0) { 25898c1b6884Sszhou mp->curdefault = lp; 25908c1b6884Sszhou } else if (lp->flags == BAM_COMMENT && 25918c1b6884Sszhou strncmp(lp->arg, BAM_OLDDEF, strlen(BAM_OLDDEF)) == 0) { 25928c1b6884Sszhou mp->olddefault = lp; 2593ae115bc7Smrj } else if (lp->flags == BAM_COMMENT && 2594ae115bc7Smrj strncmp(lp->arg, BAM_OLD_RC_DEF, strlen(BAM_OLD_RC_DEF)) == 0) { 2595ae115bc7Smrj mp->old_rc_default = lp; 25968c1b6884Sszhou } else if (lp->flags == BAM_ENTRY || 2597ae115bc7Smrj (lp->flags == BAM_COMMENT && 2598ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_FTR) == 0)) { 25998c1b6884Sszhou boot_entry_addline(curr_ent, lp); 26008c1b6884Sszhou } 26017c478bd9Sstevel@tonic-gate append_line(mp, lp); 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate prev = lp; 26047c478bd9Sstevel@tonic-gate } 26057c478bd9Sstevel@tonic-gate 260640541d5dSvikram static void 260740541d5dSvikram update_numbering(menu_t *mp) 260840541d5dSvikram { 260940541d5dSvikram int lineNum; 261040541d5dSvikram int entryNum; 261140541d5dSvikram int old_default_value; 261240541d5dSvikram line_t *lp, *prev, *default_lp, *default_entry; 261340541d5dSvikram char buf[PATH_MAX]; 261440541d5dSvikram 261540541d5dSvikram if (mp->start == NULL) { 261640541d5dSvikram return; 261740541d5dSvikram } 261840541d5dSvikram 261940541d5dSvikram lineNum = LINE_INIT; 262040541d5dSvikram entryNum = ENTRY_INIT; 262140541d5dSvikram old_default_value = ENTRY_INIT; 262240541d5dSvikram lp = default_lp = default_entry = NULL; 262340541d5dSvikram 262440541d5dSvikram prev = NULL; 262540541d5dSvikram for (lp = mp->start; lp; prev = lp, lp = lp->next) { 262640541d5dSvikram lp->lineNum = ++lineNum; 262740541d5dSvikram 262840541d5dSvikram /* 262940541d5dSvikram * Get the value of the default command 263040541d5dSvikram */ 263140541d5dSvikram if (lp->entryNum == ENTRY_INIT && lp->cmd && 263240541d5dSvikram strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0 && 263340541d5dSvikram lp->arg) { 263440541d5dSvikram old_default_value = atoi(lp->arg); 263540541d5dSvikram default_lp = lp; 263640541d5dSvikram } 263740541d5dSvikram 263840541d5dSvikram /* 263940541d5dSvikram * If not boot entry, nothing else to fix for this 264040541d5dSvikram * entry 264140541d5dSvikram */ 264240541d5dSvikram if (lp->entryNum == ENTRY_INIT) 264340541d5dSvikram continue; 264440541d5dSvikram 264540541d5dSvikram /* 264640541d5dSvikram * Record the position of the default entry. 264740541d5dSvikram * The following works because global 264840541d5dSvikram * commands like default and timeout should precede 264940541d5dSvikram * actual boot entries, so old_default_value 265040541d5dSvikram * is already known (or default cmd is missing). 265140541d5dSvikram */ 265240541d5dSvikram if (default_entry == NULL && 265340541d5dSvikram old_default_value != ENTRY_INIT && 265440541d5dSvikram lp->entryNum == old_default_value) { 265540541d5dSvikram default_entry = lp; 265640541d5dSvikram } 265740541d5dSvikram 265840541d5dSvikram /* 265940541d5dSvikram * Now fixup the entry number 266040541d5dSvikram */ 266140541d5dSvikram if (lp->cmd && strcmp(lp->cmd, menu_cmds[TITLE_CMD]) == 0) { 266240541d5dSvikram lp->entryNum = ++entryNum; 266340541d5dSvikram /* fixup the bootadm header */ 266440541d5dSvikram if (prev && prev->flags == BAM_COMMENT && 2665ae115bc7Smrj prev->arg && 2666ae115bc7Smrj strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) { 266740541d5dSvikram prev->entryNum = lp->entryNum; 266840541d5dSvikram } 266940541d5dSvikram } else { 267040541d5dSvikram lp->entryNum = entryNum; 267140541d5dSvikram } 267240541d5dSvikram } 267340541d5dSvikram 267440541d5dSvikram /* 267540541d5dSvikram * No default command in menu, simply return 267640541d5dSvikram */ 267740541d5dSvikram if (default_lp == NULL) { 267840541d5dSvikram return; 267940541d5dSvikram } 268040541d5dSvikram 268140541d5dSvikram free(default_lp->arg); 268240541d5dSvikram free(default_lp->line); 268340541d5dSvikram 268440541d5dSvikram if (default_entry == NULL) { 268540541d5dSvikram default_lp->arg = s_strdup("0"); 268640541d5dSvikram } else { 268740541d5dSvikram (void) snprintf(buf, sizeof (buf), "%d", 268840541d5dSvikram default_entry->entryNum); 268940541d5dSvikram default_lp->arg = s_strdup(buf); 269040541d5dSvikram } 269140541d5dSvikram 269240541d5dSvikram /* 269340541d5dSvikram * The following is required since only the line field gets 269440541d5dSvikram * written back to menu.lst 269540541d5dSvikram */ 269640541d5dSvikram (void) snprintf(buf, sizeof (buf), "%s%s%s", 269740541d5dSvikram menu_cmds[DEFAULT_CMD], menu_cmds[SEP_CMD], default_lp->arg); 269840541d5dSvikram default_lp->line = s_strdup(buf); 269940541d5dSvikram } 270040541d5dSvikram 270140541d5dSvikram 27027c478bd9Sstevel@tonic-gate static menu_t * 27037c478bd9Sstevel@tonic-gate menu_read(char *menu_path) 27047c478bd9Sstevel@tonic-gate { 27057c478bd9Sstevel@tonic-gate FILE *fp; 27067c478bd9Sstevel@tonic-gate char buf[BAM_MAXLINE], *cp; 27077c478bd9Sstevel@tonic-gate menu_t *mp; 27087c478bd9Sstevel@tonic-gate int line, entry, len, n; 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate mp = s_calloc(1, sizeof (menu_t)); 27117c478bd9Sstevel@tonic-gate 27127c478bd9Sstevel@tonic-gate fp = fopen(menu_path, "r"); 27137c478bd9Sstevel@tonic-gate if (fp == NULL) { /* Let the caller handle this error */ 27147c478bd9Sstevel@tonic-gate return (mp); 27157c478bd9Sstevel@tonic-gate } 27167c478bd9Sstevel@tonic-gate 27177c478bd9Sstevel@tonic-gate 27187c478bd9Sstevel@tonic-gate /* Note: GRUB boot entry number starts with 0 */ 27197c478bd9Sstevel@tonic-gate line = LINE_INIT; 27207c478bd9Sstevel@tonic-gate entry = ENTRY_INIT; 27217c478bd9Sstevel@tonic-gate cp = buf; 27227c478bd9Sstevel@tonic-gate len = sizeof (buf); 27237c478bd9Sstevel@tonic-gate while (s_fgets(cp, len, fp) != NULL) { 27247c478bd9Sstevel@tonic-gate n = strlen(cp); 27257c478bd9Sstevel@tonic-gate if (cp[n - 1] == '\\') { 27267c478bd9Sstevel@tonic-gate len -= n - 1; 27277c478bd9Sstevel@tonic-gate assert(len >= 2); 27287c478bd9Sstevel@tonic-gate cp += n - 1; 27297c478bd9Sstevel@tonic-gate continue; 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate line_parser(mp, buf, &line, &entry); 27327c478bd9Sstevel@tonic-gate cp = buf; 27337c478bd9Sstevel@tonic-gate len = sizeof (buf); 27347c478bd9Sstevel@tonic-gate } 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate if (fclose(fp) == EOF) { 27377c478bd9Sstevel@tonic-gate bam_error(CLOSE_FAIL, menu_path, strerror(errno)); 27387c478bd9Sstevel@tonic-gate } 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate return (mp); 27417c478bd9Sstevel@tonic-gate } 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate static error_t 27447c478bd9Sstevel@tonic-gate selector(menu_t *mp, char *opt, int *entry, char **title) 27457c478bd9Sstevel@tonic-gate { 27467c478bd9Sstevel@tonic-gate char *eq; 27477c478bd9Sstevel@tonic-gate char *opt_dup; 27487c478bd9Sstevel@tonic-gate int entryNum; 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate assert(mp); 27517c478bd9Sstevel@tonic-gate assert(mp->start); 27527c478bd9Sstevel@tonic-gate assert(opt); 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate opt_dup = s_strdup(opt); 27557c478bd9Sstevel@tonic-gate 27567c478bd9Sstevel@tonic-gate if (entry) 27577c478bd9Sstevel@tonic-gate *entry = ENTRY_INIT; 27587c478bd9Sstevel@tonic-gate if (title) 27597c478bd9Sstevel@tonic-gate *title = NULL; 27607c478bd9Sstevel@tonic-gate 27617c478bd9Sstevel@tonic-gate eq = strchr(opt_dup, '='); 27627c478bd9Sstevel@tonic-gate if (eq == NULL) { 27637c478bd9Sstevel@tonic-gate bam_error(INVALID_OPT, opt); 27647c478bd9Sstevel@tonic-gate free(opt_dup); 27657c478bd9Sstevel@tonic-gate return (BAM_ERROR); 27667c478bd9Sstevel@tonic-gate } 27677c478bd9Sstevel@tonic-gate 27687c478bd9Sstevel@tonic-gate *eq = '\0'; 27697c478bd9Sstevel@tonic-gate if (entry && strcmp(opt_dup, OPT_ENTRY_NUM) == 0) { 27707c478bd9Sstevel@tonic-gate assert(mp->end); 27717c478bd9Sstevel@tonic-gate entryNum = s_strtol(eq + 1); 27727c478bd9Sstevel@tonic-gate if (entryNum < 0 || entryNum > mp->end->entryNum) { 27737c478bd9Sstevel@tonic-gate bam_error(INVALID_ENTRY, eq + 1); 27747c478bd9Sstevel@tonic-gate free(opt_dup); 27757c478bd9Sstevel@tonic-gate return (BAM_ERROR); 27767c478bd9Sstevel@tonic-gate } 27777c478bd9Sstevel@tonic-gate *entry = entryNum; 27787c478bd9Sstevel@tonic-gate } else if (title && strcmp(opt_dup, menu_cmds[TITLE_CMD]) == 0) { 27797c478bd9Sstevel@tonic-gate *title = opt + (eq - opt_dup) + 1; 27807c478bd9Sstevel@tonic-gate } else { 27817c478bd9Sstevel@tonic-gate bam_error(INVALID_OPT, opt); 27827c478bd9Sstevel@tonic-gate free(opt_dup); 27837c478bd9Sstevel@tonic-gate return (BAM_ERROR); 27847c478bd9Sstevel@tonic-gate } 27857c478bd9Sstevel@tonic-gate 27867c478bd9Sstevel@tonic-gate free(opt_dup); 27877c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 27887c478bd9Sstevel@tonic-gate } 27897c478bd9Sstevel@tonic-gate 27907c478bd9Sstevel@tonic-gate /* 27917c478bd9Sstevel@tonic-gate * If invoked with no titles/entries (opt == NULL) 27927c478bd9Sstevel@tonic-gate * only title lines in file are printed. 27937c478bd9Sstevel@tonic-gate * 27947c478bd9Sstevel@tonic-gate * If invoked with a title or entry #, all 27957c478bd9Sstevel@tonic-gate * lines in *every* matching entry are listed 27967c478bd9Sstevel@tonic-gate */ 27977c478bd9Sstevel@tonic-gate static error_t 27987c478bd9Sstevel@tonic-gate list_entry(menu_t *mp, char *menu_path, char *opt) 27997c478bd9Sstevel@tonic-gate { 28007c478bd9Sstevel@tonic-gate line_t *lp; 28017c478bd9Sstevel@tonic-gate int entry = ENTRY_INIT; 28027c478bd9Sstevel@tonic-gate int found; 28037c478bd9Sstevel@tonic-gate char *title = NULL; 28047c478bd9Sstevel@tonic-gate 28057c478bd9Sstevel@tonic-gate assert(mp); 28067c478bd9Sstevel@tonic-gate assert(menu_path); 28077c478bd9Sstevel@tonic-gate 28087c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 28097c478bd9Sstevel@tonic-gate bam_error(NO_MENU, menu_path); 28107c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28117c478bd9Sstevel@tonic-gate } 28127c478bd9Sstevel@tonic-gate 28137c478bd9Sstevel@tonic-gate if (opt != NULL) { 28147c478bd9Sstevel@tonic-gate if (selector(mp, opt, &entry, &title) != BAM_SUCCESS) { 28157c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate assert((entry != ENTRY_INIT) ^ (title != NULL)); 28187c478bd9Sstevel@tonic-gate } else { 28197c478bd9Sstevel@tonic-gate (void) read_globals(mp, menu_path, menu_cmds[DEFAULT_CMD], 0); 28207c478bd9Sstevel@tonic-gate (void) read_globals(mp, menu_path, menu_cmds[TIMEOUT_CMD], 0); 28217c478bd9Sstevel@tonic-gate } 28227c478bd9Sstevel@tonic-gate 28237c478bd9Sstevel@tonic-gate found = 0; 28247c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 28257c478bd9Sstevel@tonic-gate if (lp->flags == BAM_COMMENT || lp->flags == BAM_EMPTY) 28267c478bd9Sstevel@tonic-gate continue; 28277c478bd9Sstevel@tonic-gate if (opt == NULL && lp->flags == BAM_TITLE) { 28287c478bd9Sstevel@tonic-gate bam_print(PRINT_TITLE, lp->entryNum, 28297c478bd9Sstevel@tonic-gate lp->arg); 28307c478bd9Sstevel@tonic-gate found = 1; 28317c478bd9Sstevel@tonic-gate continue; 28327c478bd9Sstevel@tonic-gate } 28337c478bd9Sstevel@tonic-gate if (entry != ENTRY_INIT && lp->entryNum == entry) { 28347c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 28357c478bd9Sstevel@tonic-gate found = 1; 28367c478bd9Sstevel@tonic-gate continue; 28377c478bd9Sstevel@tonic-gate } 28387c478bd9Sstevel@tonic-gate 28397c478bd9Sstevel@tonic-gate /* 28407c478bd9Sstevel@tonic-gate * We set the entry value here so that all lines 28417c478bd9Sstevel@tonic-gate * in entry get printed. If we subsequently match 28427c478bd9Sstevel@tonic-gate * title in other entries, all lines in those 28437c478bd9Sstevel@tonic-gate * entries get printed as well. 28447c478bd9Sstevel@tonic-gate */ 28457c478bd9Sstevel@tonic-gate if (title && lp->flags == BAM_TITLE && lp->arg && 28467c478bd9Sstevel@tonic-gate strncmp(title, lp->arg, strlen(title)) == 0) { 28477c478bd9Sstevel@tonic-gate bam_print(PRINT, lp->line); 28487c478bd9Sstevel@tonic-gate entry = lp->entryNum; 28497c478bd9Sstevel@tonic-gate found = 1; 28507c478bd9Sstevel@tonic-gate continue; 28517c478bd9Sstevel@tonic-gate } 28527c478bd9Sstevel@tonic-gate } 28537c478bd9Sstevel@tonic-gate 28547c478bd9Sstevel@tonic-gate if (!found) { 28557c478bd9Sstevel@tonic-gate bam_error(NO_MATCH_ENTRY); 28567c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28577c478bd9Sstevel@tonic-gate } 28587c478bd9Sstevel@tonic-gate 28597c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 28607c478bd9Sstevel@tonic-gate } 28617c478bd9Sstevel@tonic-gate 2862843e1988Sjohnlev int 28637c478bd9Sstevel@tonic-gate add_boot_entry(menu_t *mp, 28647c478bd9Sstevel@tonic-gate char *title, 28657c478bd9Sstevel@tonic-gate char *root, 28667c478bd9Sstevel@tonic-gate char *kernel, 2867843e1988Sjohnlev char *mod_kernel, 28687c478bd9Sstevel@tonic-gate char *module) 28697c478bd9Sstevel@tonic-gate { 28707c478bd9Sstevel@tonic-gate int lineNum, entryNum; 28717c478bd9Sstevel@tonic-gate char linebuf[BAM_MAXLINE]; 2872ae115bc7Smrj menu_cmd_t k_cmd, m_cmd; 28737c478bd9Sstevel@tonic-gate 28747c478bd9Sstevel@tonic-gate assert(mp); 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate if (title == NULL) { 2877ee3b8144Sszhou title = "Solaris"; /* default to Solaris */ 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate if (kernel == NULL) { 28807c478bd9Sstevel@tonic-gate bam_error(SUBOPT_MISS, menu_cmds[KERNEL_CMD]); 28817c478bd9Sstevel@tonic-gate return (BAM_ERROR); 28827c478bd9Sstevel@tonic-gate } 28837c478bd9Sstevel@tonic-gate if (module == NULL) { 2884ae115bc7Smrj if (bam_direct != BAM_DIRECT_DBOOT) { 2885ae115bc7Smrj bam_error(SUBOPT_MISS, menu_cmds[MODULE_CMD]); 2886ae115bc7Smrj return (BAM_ERROR); 2887ae115bc7Smrj } 2888ae115bc7Smrj 2889ae115bc7Smrj /* Figure the commands out from the kernel line */ 2890ae115bc7Smrj if (strstr(kernel, "$ISADIR") != NULL) { 2891ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE; 2892ae115bc7Smrj k_cmd = KERNEL_DOLLAR_CMD; 2893ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 2894ae115bc7Smrj } else if (strstr(kernel, "amd64") != NULL) { 2895ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE_64; 2896ae115bc7Smrj k_cmd = KERNEL_CMD; 2897ae115bc7Smrj m_cmd = MODULE_CMD; 2898ae115bc7Smrj } else { 2899ae115bc7Smrj module = DIRECT_BOOT_ARCHIVE_32; 2900ae115bc7Smrj k_cmd = KERNEL_CMD; 2901ae115bc7Smrj m_cmd = MODULE_CMD; 2902ae115bc7Smrj } 2903ae115bc7Smrj } else if ((bam_direct == BAM_DIRECT_DBOOT) && 2904ae115bc7Smrj (strstr(kernel, "$ISADIR") != NULL)) { 2905ae115bc7Smrj /* 2906ae115bc7Smrj * If it's a non-failsafe dboot kernel, use the "kernel$" 2907ae115bc7Smrj * command. Otherwise, use "kernel". 2908ae115bc7Smrj */ 2909ae115bc7Smrj k_cmd = KERNEL_DOLLAR_CMD; 2910ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 2911ae115bc7Smrj } else { 2912ae115bc7Smrj k_cmd = KERNEL_CMD; 2913ae115bc7Smrj m_cmd = MODULE_CMD; 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate 29167c478bd9Sstevel@tonic-gate if (mp->start) { 29177c478bd9Sstevel@tonic-gate lineNum = mp->end->lineNum; 29187c478bd9Sstevel@tonic-gate entryNum = mp->end->entryNum; 29197c478bd9Sstevel@tonic-gate } else { 29207c478bd9Sstevel@tonic-gate lineNum = LINE_INIT; 29217c478bd9Sstevel@tonic-gate entryNum = ENTRY_INIT; 29227c478bd9Sstevel@tonic-gate } 29237c478bd9Sstevel@tonic-gate 29247c478bd9Sstevel@tonic-gate /* 29257c478bd9Sstevel@tonic-gate * No separator for comment (HDR/FTR) commands 29267c478bd9Sstevel@tonic-gate * The syntax for comments is #<comment> 29277c478bd9Sstevel@tonic-gate */ 29287c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 2929ae115bc7Smrj menu_cmds[COMMENT_CMD], BAM_BOOTADM_HDR); 29308c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29317c478bd9Sstevel@tonic-gate 29327c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 29337c478bd9Sstevel@tonic-gate menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 29348c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29357c478bd9Sstevel@tonic-gate 29368c1b6884Sszhou if (root) { 29378c1b6884Sszhou (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 29388c1b6884Sszhou menu_cmds[ROOT_CMD], menu_cmds[SEP_CMD], root); 29398c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 2943ae115bc7Smrj menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel); 29448c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29457c478bd9Sstevel@tonic-gate 2946843e1988Sjohnlev if (mod_kernel != NULL) { 2947843e1988Sjohnlev (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 2948843e1988Sjohnlev menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel); 2949843e1988Sjohnlev line_parser(mp, linebuf, &lineNum, &entryNum); 2950843e1988Sjohnlev } 2951843e1988Sjohnlev 29527c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 2953ae115bc7Smrj menu_cmds[m_cmd], menu_cmds[SEP_CMD], module); 29548c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s%s", 2957ae115bc7Smrj menu_cmds[COMMENT_CMD], BAM_BOOTADM_FTR); 29588c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 29597c478bd9Sstevel@tonic-gate 29607c478bd9Sstevel@tonic-gate return (entryNum); 29617c478bd9Sstevel@tonic-gate } 29627c478bd9Sstevel@tonic-gate 29637c478bd9Sstevel@tonic-gate static error_t 29647c478bd9Sstevel@tonic-gate do_delete(menu_t *mp, int entryNum) 29657c478bd9Sstevel@tonic-gate { 29668c1b6884Sszhou line_t *lp, *freed; 29678c1b6884Sszhou entry_t *ent, *tmp; 29687c478bd9Sstevel@tonic-gate int deleted; 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate assert(entryNum != ENTRY_INIT); 29717c478bd9Sstevel@tonic-gate 29728c1b6884Sszhou ent = mp->entries; 29738c1b6884Sszhou while (ent) { 29748c1b6884Sszhou lp = ent->start; 29758c1b6884Sszhou /* check entry number and make sure it's a bootadm entry */ 29768c1b6884Sszhou if (lp->flags != BAM_COMMENT || 2977ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_HDR) != 0 || 29788c1b6884Sszhou (entryNum != ALL_ENTRIES && lp->entryNum != entryNum)) { 29798c1b6884Sszhou ent = ent->next; 29807c478bd9Sstevel@tonic-gate continue; 29817c478bd9Sstevel@tonic-gate } 29827c478bd9Sstevel@tonic-gate 29838c1b6884Sszhou /* free the entry content */ 29848c1b6884Sszhou do { 29858c1b6884Sszhou freed = lp; 29868c1b6884Sszhou lp = lp->next; /* prev stays the same */ 29878c1b6884Sszhou unlink_line(mp, freed); 29888c1b6884Sszhou line_free(freed); 29898c1b6884Sszhou } while (freed != ent->end); 29908c1b6884Sszhou 29918c1b6884Sszhou /* free the entry_t structure */ 29928c1b6884Sszhou tmp = ent; 29938c1b6884Sszhou ent = ent->next; 29948c1b6884Sszhou if (tmp->prev) 29958c1b6884Sszhou tmp->prev->next = ent; 29967c478bd9Sstevel@tonic-gate else 29978c1b6884Sszhou mp->entries = ent; 29988c1b6884Sszhou if (ent) 29998c1b6884Sszhou ent->prev = tmp->prev; 30007c478bd9Sstevel@tonic-gate deleted = 1; 30017c478bd9Sstevel@tonic-gate } 30027c478bd9Sstevel@tonic-gate 30037c478bd9Sstevel@tonic-gate if (!deleted && entryNum != ALL_ENTRIES) { 30047c478bd9Sstevel@tonic-gate bam_error(NO_BOOTADM_MATCH); 30057c478bd9Sstevel@tonic-gate return (BAM_ERROR); 30067c478bd9Sstevel@tonic-gate } 30077c478bd9Sstevel@tonic-gate 300840541d5dSvikram /* 300940541d5dSvikram * Now that we have deleted an entry, update 301040541d5dSvikram * the entry numbering and the default cmd. 301140541d5dSvikram */ 301240541d5dSvikram update_numbering(mp); 301340541d5dSvikram 30147c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 30157c478bd9Sstevel@tonic-gate } 30167c478bd9Sstevel@tonic-gate 30177c478bd9Sstevel@tonic-gate static error_t 30187c478bd9Sstevel@tonic-gate delete_all_entries(menu_t *mp, char *menu_path, char *opt) 30197c478bd9Sstevel@tonic-gate { 30207c478bd9Sstevel@tonic-gate assert(mp); 30217c478bd9Sstevel@tonic-gate assert(opt == NULL); 30227c478bd9Sstevel@tonic-gate 30237c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 30247c478bd9Sstevel@tonic-gate bam_print(EMPTY_FILE, menu_path); 30257c478bd9Sstevel@tonic-gate return (BAM_SUCCESS); 30267c478bd9Sstevel@tonic-gate } 30277c478bd9Sstevel@tonic-gate 30287c478bd9Sstevel@tonic-gate if (do_delete(mp, ALL_ENTRIES) != BAM_SUCCESS) { 30297c478bd9Sstevel@tonic-gate return (BAM_ERROR); 30307c478bd9Sstevel@tonic-gate } 30317c478bd9Sstevel@tonic-gate 30327c478bd9Sstevel@tonic-gate return (BAM_WRITE); 30337c478bd9Sstevel@tonic-gate } 30347c478bd9Sstevel@tonic-gate 30357c478bd9Sstevel@tonic-gate static FILE * 30368c1b6884Sszhou open_diskmap(char *root) 30377c478bd9Sstevel@tonic-gate { 30387c478bd9Sstevel@tonic-gate FILE *fp; 30397c478bd9Sstevel@tonic-gate char cmd[PATH_MAX]; 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate /* make sure we have a map file */ 30427c478bd9Sstevel@tonic-gate fp = fopen(GRUBDISK_MAP, "r"); 30437c478bd9Sstevel@tonic-gate if (fp == NULL) { 30447c478bd9Sstevel@tonic-gate (void) snprintf(cmd, sizeof (cmd), 3045*986fd29aSsetje "%s/%s > /dev/null", root, CREATE_DISKMAP); 30467c478bd9Sstevel@tonic-gate (void) system(cmd); 30477c478bd9Sstevel@tonic-gate fp = fopen(GRUBDISK_MAP, "r"); 30487c478bd9Sstevel@tonic-gate } 30497c478bd9Sstevel@tonic-gate return (fp); 30507c478bd9Sstevel@tonic-gate } 30517c478bd9Sstevel@tonic-gate 30527c478bd9Sstevel@tonic-gate #define SECTOR_SIZE 512 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate static int 30557c478bd9Sstevel@tonic-gate get_partition(char *device) 30567c478bd9Sstevel@tonic-gate { 30577c478bd9Sstevel@tonic-gate int i, fd, is_pcfs, partno = -1; 30587c478bd9Sstevel@tonic-gate struct mboot *mboot; 30597c478bd9Sstevel@tonic-gate char boot_sect[SECTOR_SIZE]; 30607c478bd9Sstevel@tonic-gate char *wholedisk, *slice; 30617c478bd9Sstevel@tonic-gate 30627c478bd9Sstevel@tonic-gate /* form whole disk (p0) */ 30637c478bd9Sstevel@tonic-gate slice = device + strlen(device) - 2; 30647c478bd9Sstevel@tonic-gate is_pcfs = (*slice != 's'); 30657c478bd9Sstevel@tonic-gate if (!is_pcfs) 30667c478bd9Sstevel@tonic-gate *slice = '\0'; 30677c478bd9Sstevel@tonic-gate wholedisk = s_calloc(1, strlen(device) + 3); 30687c478bd9Sstevel@tonic-gate (void) snprintf(wholedisk, strlen(device) + 3, "%sp0", device); 30697c478bd9Sstevel@tonic-gate if (!is_pcfs) 30707c478bd9Sstevel@tonic-gate *slice = 's'; 30717c478bd9Sstevel@tonic-gate 30727c478bd9Sstevel@tonic-gate /* read boot sector */ 30737c478bd9Sstevel@tonic-gate fd = open(wholedisk, O_RDONLY); 30747c478bd9Sstevel@tonic-gate free(wholedisk); 30757c478bd9Sstevel@tonic-gate if (fd == -1 || read(fd, boot_sect, SECTOR_SIZE) != SECTOR_SIZE) { 30767c478bd9Sstevel@tonic-gate return (partno); 30777c478bd9Sstevel@tonic-gate } 30787c478bd9Sstevel@tonic-gate (void) close(fd); 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate /* parse fdisk table */ 30817c478bd9Sstevel@tonic-gate mboot = (struct mboot *)((void *)boot_sect); 30827c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 30837c478bd9Sstevel@tonic-gate struct ipart *part = 30847c478bd9Sstevel@tonic-gate (struct ipart *)(uintptr_t)mboot->parts + i; 30857c478bd9Sstevel@tonic-gate if (is_pcfs) { /* looking for solaris boot part */ 30867c478bd9Sstevel@tonic-gate if (part->systid == 0xbe) { 30877c478bd9Sstevel@tonic-gate partno = i; 30887c478bd9Sstevel@tonic-gate break; 30897c478bd9Sstevel@tonic-gate } 30907c478bd9Sstevel@tonic-gate } else { /* look for solaris partition, old and new */ 30917c478bd9Sstevel@tonic-gate if (part->systid == SUNIXOS || 30927c478bd9Sstevel@tonic-gate part->systid == SUNIXOS2) { 30937c478bd9Sstevel@tonic-gate partno = i; 30947c478bd9Sstevel@tonic-gate break; 30957c478bd9Sstevel@tonic-gate } 30967c478bd9Sstevel@tonic-gate } 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate return (partno); 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate static char * 31027c478bd9Sstevel@tonic-gate get_grubdisk(char *rootdev, FILE *fp, int on_bootdev) 31037c478bd9Sstevel@tonic-gate { 31047c478bd9Sstevel@tonic-gate char *grubdisk; /* (hd#,#,#) */ 31057c478bd9Sstevel@tonic-gate char *slice; 31067c478bd9Sstevel@tonic-gate char *grubhd; 31077c478bd9Sstevel@tonic-gate int fdiskpart; 31087c478bd9Sstevel@tonic-gate int found = 0; 31097c478bd9Sstevel@tonic-gate char *devname, *ctdname = strstr(rootdev, "dsk/"); 31107c478bd9Sstevel@tonic-gate char linebuf[PATH_MAX]; 31117c478bd9Sstevel@tonic-gate 31127c478bd9Sstevel@tonic-gate if (ctdname == NULL) 31137c478bd9Sstevel@tonic-gate return (NULL); 31147c478bd9Sstevel@tonic-gate 31157c478bd9Sstevel@tonic-gate ctdname += strlen("dsk/"); 31167c478bd9Sstevel@tonic-gate slice = strrchr(ctdname, 's'); 31177c478bd9Sstevel@tonic-gate if (slice) 31187c478bd9Sstevel@tonic-gate *slice = '\0'; 31197c478bd9Sstevel@tonic-gate 31207c478bd9Sstevel@tonic-gate rewind(fp); 31217c478bd9Sstevel@tonic-gate while (s_fgets(linebuf, sizeof (linebuf), fp) != NULL) { 31227c478bd9Sstevel@tonic-gate grubhd = strtok(linebuf, " \t\n"); 31237c478bd9Sstevel@tonic-gate if (grubhd) 31247c478bd9Sstevel@tonic-gate devname = strtok(NULL, " \t\n"); 31257c478bd9Sstevel@tonic-gate else 31267c478bd9Sstevel@tonic-gate devname = NULL; 31277c478bd9Sstevel@tonic-gate if (devname && strcmp(devname, ctdname) == 0) { 31287c478bd9Sstevel@tonic-gate found = 1; 31297c478bd9Sstevel@tonic-gate break; 31307c478bd9Sstevel@tonic-gate } 31317c478bd9Sstevel@tonic-gate } 31327c478bd9Sstevel@tonic-gate 31337c478bd9Sstevel@tonic-gate if (slice) 31347c478bd9Sstevel@tonic-gate *slice = 's'; 31357c478bd9Sstevel@tonic-gate 31367c478bd9Sstevel@tonic-gate if (found == 0) { 31377c478bd9Sstevel@tonic-gate if (bam_verbose) 31387c478bd9Sstevel@tonic-gate bam_print(DISKMAP_FAIL_NONFATAL, rootdev); 31397c478bd9Sstevel@tonic-gate grubhd = "0"; /* assume disk 0 if can't match */ 31407c478bd9Sstevel@tonic-gate } 31417c478bd9Sstevel@tonic-gate 31427c478bd9Sstevel@tonic-gate fdiskpart = get_partition(rootdev); 31437c478bd9Sstevel@tonic-gate if (fdiskpart == -1) 31447c478bd9Sstevel@tonic-gate return (NULL); 31457c478bd9Sstevel@tonic-gate 31467c478bd9Sstevel@tonic-gate grubdisk = s_calloc(1, 10); 31477c478bd9Sstevel@tonic-gate if (slice) { 31487c478bd9Sstevel@tonic-gate (void) snprintf(grubdisk, 10, "(hd%s,%d,%c)", 31497c478bd9Sstevel@tonic-gate grubhd, fdiskpart, slice[1] + 'a' - '0'); 31507c478bd9Sstevel@tonic-gate } else 31517c478bd9Sstevel@tonic-gate (void) snprintf(grubdisk, 10, "(hd%s,%d)", 31527c478bd9Sstevel@tonic-gate grubhd, fdiskpart); 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* if root not on bootdev, change GRUB disk to 0 */ 31557c478bd9Sstevel@tonic-gate if (!on_bootdev) 31567c478bd9Sstevel@tonic-gate grubdisk[3] = '0'; 31577c478bd9Sstevel@tonic-gate return (grubdisk); 31587c478bd9Sstevel@tonic-gate } 31597c478bd9Sstevel@tonic-gate 3160ee3b8144Sszhou static char * 3161ee3b8144Sszhou get_title(char *rootdir) 31627c478bd9Sstevel@tonic-gate { 31637c478bd9Sstevel@tonic-gate static char title[80]; /* from /etc/release */ 31648c1b6884Sszhou char *cp = NULL, release[PATH_MAX]; 31657c478bd9Sstevel@tonic-gate FILE *fp; 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate /* open the /etc/release file */ 31687c478bd9Sstevel@tonic-gate (void) snprintf(release, sizeof (release), "%s/etc/release", rootdir); 31697c478bd9Sstevel@tonic-gate 31707c478bd9Sstevel@tonic-gate fp = fopen(release, "r"); 31717c478bd9Sstevel@tonic-gate if (fp == NULL) 3172ee3b8144Sszhou return (NULL); 31737c478bd9Sstevel@tonic-gate 31747c478bd9Sstevel@tonic-gate while (s_fgets(title, sizeof (title), fp) != NULL) { 31757c478bd9Sstevel@tonic-gate cp = strstr(title, "Solaris"); 31767c478bd9Sstevel@tonic-gate if (cp) 31777c478bd9Sstevel@tonic-gate break; 31787c478bd9Sstevel@tonic-gate } 31797c478bd9Sstevel@tonic-gate (void) fclose(fp); 31808c1b6884Sszhou return (cp == NULL ? "Solaris" : cp); 31817c478bd9Sstevel@tonic-gate } 31827c478bd9Sstevel@tonic-gate 3183ae115bc7Smrj char * 31847c478bd9Sstevel@tonic-gate get_special(char *mountp) 31857c478bd9Sstevel@tonic-gate { 31867c478bd9Sstevel@tonic-gate FILE *mntfp; 31877c478bd9Sstevel@tonic-gate struct mnttab mp = {0}, mpref = {0}; 31887c478bd9Sstevel@tonic-gate 31897c478bd9Sstevel@tonic-gate mntfp = fopen(MNTTAB, "r"); 31907c478bd9Sstevel@tonic-gate if (mntfp == NULL) { 31917c478bd9Sstevel@tonic-gate return (0); 31927c478bd9Sstevel@tonic-gate } 31937c478bd9Sstevel@tonic-gate 31947c478bd9Sstevel@tonic-gate if (*mountp == '\0') 31957c478bd9Sstevel@tonic-gate mpref.mnt_mountp = "/"; 31967c478bd9Sstevel@tonic-gate else 31977c478bd9Sstevel@tonic-gate mpref.mnt_mountp = mountp; 31987c478bd9Sstevel@tonic-gate if (getmntany(mntfp, &mp, &mpref) != 0) { 31997c478bd9Sstevel@tonic-gate (void) fclose(mntfp); 32007c478bd9Sstevel@tonic-gate return (NULL); 32017c478bd9Sstevel@tonic-gate } 32027c478bd9Sstevel@tonic-gate (void) fclose(mntfp); 32037c478bd9Sstevel@tonic-gate 32047c478bd9Sstevel@tonic-gate return (s_strdup(mp.mnt_special)); 32057c478bd9Sstevel@tonic-gate } 32067c478bd9Sstevel@tonic-gate 3207ae115bc7Smrj char * 32087c478bd9Sstevel@tonic-gate os_to_grubdisk(char *osdisk, int on_bootdev) 32097c478bd9Sstevel@tonic-gate { 32107c478bd9Sstevel@tonic-gate FILE *fp; 32117c478bd9Sstevel@tonic-gate char *grubdisk; 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate /* translate /dev/dsk name to grub disk name */ 32148c1b6884Sszhou fp = open_diskmap(""); 32157c478bd9Sstevel@tonic-gate if (fp == NULL) { 32167c478bd9Sstevel@tonic-gate bam_error(DISKMAP_FAIL, osdisk); 32177c478bd9Sstevel@tonic-gate return (NULL); 32187c478bd9Sstevel@tonic-gate } 32197c478bd9Sstevel@tonic-gate grubdisk = get_grubdisk(osdisk, fp, on_bootdev); 32207c478bd9Sstevel@tonic-gate (void) fclose(fp); 32217c478bd9Sstevel@tonic-gate return (grubdisk); 32227c478bd9Sstevel@tonic-gate } 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate /* 32257c478bd9Sstevel@tonic-gate * Check if root is on the boot device 32267c478bd9Sstevel@tonic-gate * Return 0 (false) on error 32277c478bd9Sstevel@tonic-gate */ 32287c478bd9Sstevel@tonic-gate static int 32297c478bd9Sstevel@tonic-gate menu_on_bootdev(char *menu_root, FILE *fp) 32307c478bd9Sstevel@tonic-gate { 32317c478bd9Sstevel@tonic-gate int ret; 32327c478bd9Sstevel@tonic-gate char *grubhd, *bootp, *special; 32337c478bd9Sstevel@tonic-gate 32347c478bd9Sstevel@tonic-gate special = get_special(menu_root); 32357c478bd9Sstevel@tonic-gate if (special == NULL) 32367c478bd9Sstevel@tonic-gate return (0); 32377c478bd9Sstevel@tonic-gate bootp = strstr(special, "p0:boot"); 32387c478bd9Sstevel@tonic-gate if (bootp) 32397c478bd9Sstevel@tonic-gate *bootp = '\0'; 32407c478bd9Sstevel@tonic-gate grubhd = get_grubdisk(special, fp, 1); 32417c478bd9Sstevel@tonic-gate free(special); 32427c478bd9Sstevel@tonic-gate 32437c478bd9Sstevel@tonic-gate if (grubhd == NULL) 32447c478bd9Sstevel@tonic-gate return (0); 32457c478bd9Sstevel@tonic-gate ret = grubhd[3] == '0'; 32467c478bd9Sstevel@tonic-gate free(grubhd); 32477c478bd9Sstevel@tonic-gate return (ret); 32487c478bd9Sstevel@tonic-gate } 32497c478bd9Sstevel@tonic-gate 32508c1b6884Sszhou /* 32518c1b6884Sszhou * look for matching bootadm entry with specified parameters 32528c1b6884Sszhou * Here are the rules (based on existing usage): 32538c1b6884Sszhou * - If title is specified, match on title only 3254843e1988Sjohnlev * - Else, match on kernel, grubdisk and module. Note that, if root_opt is 3255843e1988Sjohnlev * non-zero, the absence of root line is considered a match. 32568c1b6884Sszhou */ 32578c1b6884Sszhou static entry_t * 3258843e1988Sjohnlev find_boot_entry(menu_t *mp, char *title, char *kernel, char *root, 3259843e1988Sjohnlev char *module, int root_opt, int *entry_num) 32608c1b6884Sszhou { 32618c1b6884Sszhou int i; 32628c1b6884Sszhou line_t *lp; 32638c1b6884Sszhou entry_t *ent; 32648c1b6884Sszhou 32658c1b6884Sszhou /* find matching entry */ 32668c1b6884Sszhou for (i = 0, ent = mp->entries; ent; i++, ent = ent->next) { 32678c1b6884Sszhou lp = ent->start; 32688c1b6884Sszhou 32698c1b6884Sszhou /* first line of entry must be bootadm comment */ 32708c1b6884Sszhou lp = ent->start; 3271ae115bc7Smrj if (lp->flags != BAM_COMMENT || 3272ae115bc7Smrj strcmp(lp->arg, BAM_BOOTADM_HDR) != 0) { 32738c1b6884Sszhou continue; 32748c1b6884Sszhou } 32758c1b6884Sszhou 32768c1b6884Sszhou /* advance to title line */ 32778c1b6884Sszhou lp = lp->next; 32788c1b6884Sszhou if (title) { 32798c1b6884Sszhou if (lp->flags == BAM_TITLE && lp->arg && 32808c1b6884Sszhou strcmp(lp->arg, title) == 0) 32818c1b6884Sszhou break; 32828c1b6884Sszhou continue; /* check title only */ 32838c1b6884Sszhou } 32848c1b6884Sszhou 32858c1b6884Sszhou lp = lp->next; /* advance to root line */ 3286843e1988Sjohnlev if (lp == NULL) { 3287843e1988Sjohnlev continue; 3288843e1988Sjohnlev } else if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) { 32898c1b6884Sszhou /* root command found, match grub disk */ 32908c1b6884Sszhou if (strcmp(lp->arg, root) != 0) { 32918c1b6884Sszhou continue; 32928c1b6884Sszhou } 32938c1b6884Sszhou lp = lp->next; /* advance to kernel line */ 32948c1b6884Sszhou } else { 32958c1b6884Sszhou /* no root command, see if root is optional */ 32968c1b6884Sszhou if (root_opt == 0) { 32978c1b6884Sszhou continue; 32988c1b6884Sszhou } 32998c1b6884Sszhou } 33008c1b6884Sszhou 33018c1b6884Sszhou if (lp == NULL || lp->next == NULL) { 33028c1b6884Sszhou continue; 33038c1b6884Sszhou } 33048c1b6884Sszhou 3305843e1988Sjohnlev if (kernel && 3306843e1988Sjohnlev (!check_cmd(lp->cmd, KERNEL_CMD, lp->arg, kernel))) { 3307843e1988Sjohnlev continue; 3308843e1988Sjohnlev } 3309843e1988Sjohnlev 33100d69385cSrscott /* 3311843e1988Sjohnlev * Check for matching module entry (failsafe or normal). 3312843e1988Sjohnlev * If it fails to match, we go around the loop again. 3313843e1988Sjohnlev * For xpv entries, there are two module lines, so we 3314843e1988Sjohnlev * do the check twice. 33150d69385cSrscott */ 33168c1b6884Sszhou lp = lp->next; /* advance to module line */ 3317843e1988Sjohnlev if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) || 3318843e1988Sjohnlev (((lp = lp->next) != NULL) && 3319843e1988Sjohnlev check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) { 3320843e1988Sjohnlev /* match found */ 3321843e1988Sjohnlev break; 33228c1b6884Sszhou } 33238c1b6884Sszhou } 33248c1b6884Sszhou 3325843e1988Sjohnlev if (entry_num && ent) { 3326843e1988Sjohnlev *entry_num = i; 3327843e1988Sjohnlev } 33288c1b6884Sszhou return (ent); 33298c1b6884Sszhou } 33308c1b6884Sszhou 33318c1b6884Sszhou static int 33328c1b6884Sszhou update_boot_entry(menu_t *mp, char *title, char *root, char *kernel, 3333843e1988Sjohnlev char *mod_kernel, char *module, int root_opt) 33348c1b6884Sszhou { 3335ae115bc7Smrj int i, change_kernel = 0; 33368c1b6884Sszhou entry_t *ent; 33378c1b6884Sszhou line_t *lp; 33388c1b6884Sszhou char linebuf[BAM_MAXLINE]; 33398c1b6884Sszhou 33408c1b6884Sszhou /* note: don't match on title, it's updated on upgrade */ 3341843e1988Sjohnlev ent = find_boot_entry(mp, NULL, kernel, root, module, root_opt, &i); 3342ae115bc7Smrj if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) { 3343ae115bc7Smrj /* 3344ae115bc7Smrj * We may be upgrading a kernel from multiboot to 3345ae115bc7Smrj * directboot. Look for a multiboot entry. 3346ae115bc7Smrj */ 3347843e1988Sjohnlev ent = find_boot_entry(mp, NULL, "multiboot", root, 3348843e1988Sjohnlev MULTI_BOOT_ARCHIVE, root_opt, NULL); 3349ae115bc7Smrj if (ent != NULL) { 3350ae115bc7Smrj change_kernel = 1; 3351ae115bc7Smrj } 3352ae115bc7Smrj } 33538c1b6884Sszhou if (ent == NULL) 33548c1b6884Sszhou return (add_boot_entry(mp, title, root_opt ? NULL : root, 3355843e1988Sjohnlev kernel, mod_kernel, module)); 33568c1b6884Sszhou 33578c1b6884Sszhou /* replace title of exiting entry and delete root line */ 33588c1b6884Sszhou lp = ent->start; 33598c1b6884Sszhou lp = lp->next; /* title line */ 33608c1b6884Sszhou (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 33618c1b6884Sszhou menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title); 33628c1b6884Sszhou free(lp->arg); 33638c1b6884Sszhou free(lp->line); 33648c1b6884Sszhou lp->arg = s_strdup(title); 33658c1b6884Sszhou lp->line = s_strdup(linebuf); 33668c1b6884Sszhou 33678c1b6884Sszhou lp = lp->next; /* root line */ 33688c1b6884Sszhou if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) { 33698c1b6884Sszhou if (root_opt) { /* root line not needed */ 33708c1b6884Sszhou line_t *tmp = lp; 33718c1b6884Sszhou lp = lp->next; 33728c1b6884Sszhou unlink_line(mp, tmp); 33738c1b6884Sszhou line_free(tmp); 33748c1b6884Sszhou } else 33758c1b6884Sszhou lp = lp->next; 33768c1b6884Sszhou } 3377ae115bc7Smrj 3378ae115bc7Smrj if (change_kernel) { 3379ae115bc7Smrj /* 3380ae115bc7Smrj * We're upgrading from multiboot to directboot. 3381ae115bc7Smrj */ 3382ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) { 3383ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 3384ae115bc7Smrj menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD], 3385ae115bc7Smrj kernel); 3386ae115bc7Smrj free(lp->arg); 3387ae115bc7Smrj free(lp->line); 3388ae115bc7Smrj lp->arg = s_strdup(kernel); 3389ae115bc7Smrj lp->line = s_strdup(linebuf); 3390ae115bc7Smrj lp = lp->next; 3391ae115bc7Smrj } 3392ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) { 3393ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "%s%s%s", 3394ae115bc7Smrj menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD], 3395ae115bc7Smrj module); 3396ae115bc7Smrj free(lp->arg); 3397ae115bc7Smrj free(lp->line); 3398ae115bc7Smrj lp->arg = s_strdup(module); 3399ae115bc7Smrj lp->line = s_strdup(linebuf); 3400ae115bc7Smrj lp = lp->next; 3401ae115bc7Smrj } 3402ae115bc7Smrj } 34038c1b6884Sszhou return (i); 34048c1b6884Sszhou } 34058c1b6884Sszhou 34067c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 34077c478bd9Sstevel@tonic-gate static error_t 34087c478bd9Sstevel@tonic-gate update_entry(menu_t *mp, char *menu_root, char *opt) 34097c478bd9Sstevel@tonic-gate { 34107c478bd9Sstevel@tonic-gate FILE *fp; 34117c478bd9Sstevel@tonic-gate int entry; 341260d0a590Srscott char *grubdisk, *title, *osdev, *osroot, *failsafe_kernel = NULL; 34138c1b6884Sszhou struct stat sbuf; 34148c1b6884Sszhou char failsafe[256]; 34157c478bd9Sstevel@tonic-gate 34167c478bd9Sstevel@tonic-gate assert(mp); 34177c478bd9Sstevel@tonic-gate assert(opt); 34187c478bd9Sstevel@tonic-gate 34197c478bd9Sstevel@tonic-gate osdev = strtok(opt, ","); 34207c478bd9Sstevel@tonic-gate osroot = strtok(NULL, ","); 34217c478bd9Sstevel@tonic-gate if (osroot == NULL) 34227c478bd9Sstevel@tonic-gate osroot = menu_root; 34237c478bd9Sstevel@tonic-gate title = get_title(osroot); 34247c478bd9Sstevel@tonic-gate 34257c478bd9Sstevel@tonic-gate /* translate /dev/dsk name to grub disk name */ 34268c1b6884Sszhou fp = open_diskmap(osroot); 34277c478bd9Sstevel@tonic-gate if (fp == NULL) { 34287c478bd9Sstevel@tonic-gate bam_error(DISKMAP_FAIL, osdev); 34297c478bd9Sstevel@tonic-gate return (BAM_ERROR); 34307c478bd9Sstevel@tonic-gate } 34317c478bd9Sstevel@tonic-gate grubdisk = get_grubdisk(osdev, fp, menu_on_bootdev(menu_root, fp)); 34327c478bd9Sstevel@tonic-gate (void) fclose(fp); 34337c478bd9Sstevel@tonic-gate if (grubdisk == NULL) { 34347c478bd9Sstevel@tonic-gate bam_error(DISKMAP_FAIL, osdev); 34357c478bd9Sstevel@tonic-gate return (BAM_ERROR); 34367c478bd9Sstevel@tonic-gate } 34377c478bd9Sstevel@tonic-gate 34387c478bd9Sstevel@tonic-gate /* add the entry for normal Solaris */ 3439ae115bc7Smrj if (bam_direct == BAM_DIRECT_DBOOT) { 3440ae115bc7Smrj entry = update_boot_entry(mp, title, grubdisk, 3441843e1988Sjohnlev DIRECT_BOOT_KERNEL, NULL, DIRECT_BOOT_ARCHIVE, 3442ae115bc7Smrj osroot == menu_root); 3443843e1988Sjohnlev if ((entry != BAM_ERROR) && (bam_is_hv == BAM_HV_PRESENT)) { 3444843e1988Sjohnlev (void) update_boot_entry(mp, NEW_HV_ENTRY, grubdisk, 3445843e1988Sjohnlev XEN_MENU, KERNEL_MODULE_LINE, DIRECT_BOOT_ARCHIVE, 3446843e1988Sjohnlev osroot == menu_root); 3447843e1988Sjohnlev } 3448ae115bc7Smrj } else { 3449843e1988Sjohnlev entry = update_boot_entry(mp, title, grubdisk, MULTI_BOOT, 3450843e1988Sjohnlev NULL, MULTI_BOOT_ARCHIVE, osroot == menu_root); 3451ae115bc7Smrj } 34527c478bd9Sstevel@tonic-gate 3453843e1988Sjohnlev /* 3454843e1988Sjohnlev * Add the entry for failsafe archive. On a bfu'd system, the 3455843e1988Sjohnlev * failsafe may be different than the installed kernel. 3456843e1988Sjohnlev */ 3457ae115bc7Smrj (void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot, MINIROOT); 3458ae115bc7Smrj if (stat(failsafe, &sbuf) == 0) { 345960d0a590Srscott 346060d0a590Srscott /* Figure out where the kernel line should point */ 346160d0a590Srscott (void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot, 346260d0a590Srscott DIRECT_BOOT_FAILSAFE_KERNEL); 346360d0a590Srscott if (stat(failsafe, &sbuf) == 0) { 346460d0a590Srscott failsafe_kernel = DIRECT_BOOT_FAILSAFE_LINE; 346560d0a590Srscott } else { 346660d0a590Srscott (void) snprintf(failsafe, sizeof (failsafe), "%s%s", 346760d0a590Srscott osroot, MULTI_BOOT_FAILSAFE); 346860d0a590Srscott if (stat(failsafe, &sbuf) == 0) { 346960d0a590Srscott failsafe_kernel = MULTI_BOOT_FAILSAFE_LINE; 347060d0a590Srscott } 347160d0a590Srscott } 347260d0a590Srscott if (failsafe_kernel != NULL) { 347360d0a590Srscott (void) update_boot_entry(mp, FAILSAFE_TITLE, grubdisk, 3474843e1988Sjohnlev failsafe_kernel, NULL, MINIROOT, 3475843e1988Sjohnlev osroot == menu_root); 347660d0a590Srscott } 3477ae115bc7Smrj } 34787c478bd9Sstevel@tonic-gate free(grubdisk); 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate if (entry == BAM_ERROR) { 34817c478bd9Sstevel@tonic-gate return (BAM_ERROR); 34827c478bd9Sstevel@tonic-gate } 34837c478bd9Sstevel@tonic-gate (void) set_global(mp, menu_cmds[DEFAULT_CMD], entry); 34847c478bd9Sstevel@tonic-gate return (BAM_WRITE); 34857c478bd9Sstevel@tonic-gate } 34867c478bd9Sstevel@tonic-gate 3487b610f78eSvikram static char * 3488b610f78eSvikram read_grub_root(void) 3489b610f78eSvikram { 3490b610f78eSvikram FILE *fp; 3491b610f78eSvikram struct stat sb; 3492b610f78eSvikram char buf[BAM_MAXLINE]; 3493b610f78eSvikram char *rootstr; 3494b610f78eSvikram 3495b610f78eSvikram if (stat(GRUB_slice, &sb) != 0) { 3496b610f78eSvikram bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno)); 3497b610f78eSvikram return (NULL); 3498b610f78eSvikram } 3499b610f78eSvikram 3500b610f78eSvikram if (stat(GRUB_root, &sb) != 0) { 3501b610f78eSvikram bam_error(MISSING_ROOT_FILE, GRUB_root, strerror(errno)); 3502b610f78eSvikram return (NULL); 3503b610f78eSvikram } 3504b610f78eSvikram 3505b610f78eSvikram fp = fopen(GRUB_root, "r"); 3506b610f78eSvikram if (fp == NULL) { 3507b610f78eSvikram bam_error(OPEN_FAIL, GRUB_root, strerror(errno)); 3508b610f78eSvikram return (NULL); 3509b610f78eSvikram } 3510b610f78eSvikram 3511b610f78eSvikram if (s_fgets(buf, sizeof (buf), fp) == NULL) { 3512b610f78eSvikram bam_error(EMPTY_FILE, GRUB_root, strerror(errno)); 3513b610f78eSvikram (void) fclose(fp); 3514b610f78eSvikram return (NULL); 3515b610f78eSvikram } 3516b610f78eSvikram 3517b610f78eSvikram /* 3518b610f78eSvikram * Copy buf here as check below may trash the buffer 3519b610f78eSvikram */ 3520b610f78eSvikram rootstr = s_strdup(buf); 3521b610f78eSvikram 3522b610f78eSvikram if (s_fgets(buf, sizeof (buf), fp) != NULL) { 3523b610f78eSvikram bam_error(BAD_ROOT_FILE, GRUB_root); 3524b610f78eSvikram free(rootstr); 3525b610f78eSvikram rootstr = NULL; 3526b610f78eSvikram } 3527b610f78eSvikram 3528b610f78eSvikram (void) fclose(fp); 3529b610f78eSvikram 3530b610f78eSvikram return (rootstr); 3531b610f78eSvikram } 3532b610f78eSvikram 35338c1b6884Sszhou static void 3534ae115bc7Smrj save_default_entry(menu_t *mp, const char *which) 35358c1b6884Sszhou { 35368c1b6884Sszhou int lineNum, entryNum; 35378c1b6884Sszhou int entry = 0; /* default is 0 */ 35388c1b6884Sszhou char linebuf[BAM_MAXLINE]; 35398c1b6884Sszhou line_t *lp = mp->curdefault; 35408c1b6884Sszhou 3541bff269d0Svikram if (mp->start) { 3542bff269d0Svikram lineNum = mp->end->lineNum; 3543bff269d0Svikram entryNum = mp->end->entryNum; 3544bff269d0Svikram } else { 3545bff269d0Svikram lineNum = LINE_INIT; 3546bff269d0Svikram entryNum = ENTRY_INIT; 3547bff269d0Svikram } 3548bff269d0Svikram 35498c1b6884Sszhou if (lp) 35508c1b6884Sszhou entry = s_strtol(lp->arg); 35518c1b6884Sszhou 3552ae115bc7Smrj (void) snprintf(linebuf, sizeof (linebuf), "#%s%d", which, entry); 35538c1b6884Sszhou line_parser(mp, linebuf, &lineNum, &entryNum); 35548c1b6884Sszhou } 35558c1b6884Sszhou 35568c1b6884Sszhou static void 3557ae115bc7Smrj restore_default_entry(menu_t *mp, const char *which, line_t *lp) 35588c1b6884Sszhou { 35598c1b6884Sszhou int entry; 35608c1b6884Sszhou char *str; 35618c1b6884Sszhou 35628c1b6884Sszhou if (lp == NULL) 35638c1b6884Sszhou return; /* nothing to restore */ 35648c1b6884Sszhou 3565ae115bc7Smrj str = lp->arg + strlen(which); 35668c1b6884Sszhou entry = s_strtol(str); 35678c1b6884Sszhou (void) set_global(mp, menu_cmds[DEFAULT_CMD], entry); 35688c1b6884Sszhou 35698c1b6884Sszhou /* delete saved old default line */ 35708c1b6884Sszhou unlink_line(mp, lp); 35718c1b6884Sszhou line_free(lp); 35728c1b6884Sszhou } 35738c1b6884Sszhou 35747c478bd9Sstevel@tonic-gate /* 35757c478bd9Sstevel@tonic-gate * This function is for supporting reboot with args. 35767c478bd9Sstevel@tonic-gate * The opt value can be: 35777c478bd9Sstevel@tonic-gate * NULL delete temp entry, if present 35787c478bd9Sstevel@tonic-gate * entry=# switches default entry to 1 35797c478bd9Sstevel@tonic-gate * else treated as boot-args and setup a temperary menu entry 35807c478bd9Sstevel@tonic-gate * and make it the default 35817c478bd9Sstevel@tonic-gate */ 35827c478bd9Sstevel@tonic-gate #define REBOOT_TITLE "Solaris_reboot_transient" 35837c478bd9Sstevel@tonic-gate 35848c1b6884Sszhou /*ARGSUSED*/ 35857c478bd9Sstevel@tonic-gate static error_t 35867c478bd9Sstevel@tonic-gate update_temp(menu_t *mp, char *menupath, char *opt) 35877c478bd9Sstevel@tonic-gate { 35887c478bd9Sstevel@tonic-gate int entry; 3589455710d3Srscott char *grubdisk, *rootdev, *path, *opt_ptr; 3590ae115bc7Smrj char kernbuf[BUFSIZ]; 3591ae115bc7Smrj char args_buf[BUFSIZ]; 3592b610f78eSvikram struct stat sb; 35937c478bd9Sstevel@tonic-gate 35947c478bd9Sstevel@tonic-gate assert(mp); 35957c478bd9Sstevel@tonic-gate 35968c1b6884Sszhou /* If no option, delete exiting reboot menu entry */ 35978c1b6884Sszhou if (opt == NULL) { 35988c1b6884Sszhou entry_t *ent = find_boot_entry(mp, REBOOT_TITLE, NULL, NULL, 3599843e1988Sjohnlev NULL, 0, &entry); 36008c1b6884Sszhou if (ent == NULL) /* not found is ok */ 36018c1b6884Sszhou return (BAM_SUCCESS); 36028c1b6884Sszhou (void) do_delete(mp, entry); 3603ae115bc7Smrj restore_default_entry(mp, BAM_OLDDEF, mp->olddefault); 3604ae115bc7Smrj mp->olddefault = NULL; 36058c1b6884Sszhou return (BAM_WRITE); 36068c1b6884Sszhou } 36078c1b6884Sszhou 36088c1b6884Sszhou /* if entry= is specified, set the default entry */ 36098c1b6884Sszhou if (strncmp(opt, "entry=", strlen("entry=")) == 0 && 36107c478bd9Sstevel@tonic-gate selector(mp, opt, &entry, NULL) == BAM_SUCCESS) { 36117c478bd9Sstevel@tonic-gate /* this is entry=# option */ 36127c478bd9Sstevel@tonic-gate return (set_global(mp, menu_cmds[DEFAULT_CMD], entry)); 36137c478bd9Sstevel@tonic-gate } 36147c478bd9Sstevel@tonic-gate 36157c478bd9Sstevel@tonic-gate /* 36167c478bd9Sstevel@tonic-gate * add a new menu entry base on opt and make it the default 36177c478bd9Sstevel@tonic-gate */ 3618b610f78eSvikram grubdisk = NULL; 3619b610f78eSvikram if (stat(GRUB_slice, &sb) != 0) { 3620b610f78eSvikram /* 3621b610f78eSvikram * 1. First get root disk name from mnttab 3622b610f78eSvikram * 2. Translate disk name to grub name 3623b610f78eSvikram * 3. Add the new menu entry 3624b610f78eSvikram */ 3625b610f78eSvikram rootdev = get_special("/"); 3626b610f78eSvikram if (rootdev) { 3627b610f78eSvikram grubdisk = os_to_grubdisk(rootdev, 1); 3628b610f78eSvikram free(rootdev); 3629b610f78eSvikram } 3630b610f78eSvikram } else { 3631b610f78eSvikram /* 3632b610f78eSvikram * This is an LU BE. The GRUB_root file 3633b610f78eSvikram * contains entry for GRUB's "root" cmd. 3634b610f78eSvikram */ 3635b610f78eSvikram grubdisk = read_grub_root(); 36367c478bd9Sstevel@tonic-gate } 36377c478bd9Sstevel@tonic-gate if (grubdisk == NULL) { 3638b610f78eSvikram bam_error(REBOOT_WITH_ARGS_FAILED); 36397c478bd9Sstevel@tonic-gate return (BAM_ERROR); 36407c478bd9Sstevel@tonic-gate } 36417c478bd9Sstevel@tonic-gate 36427c478bd9Sstevel@tonic-gate /* add an entry for Solaris reboot */ 3643ae115bc7Smrj if (bam_direct == BAM_DIRECT_DBOOT) { 3644ae115bc7Smrj if (opt[0] == '-') { 3645ae115bc7Smrj /* It's an option - first see if boot-file is set */ 3646ae115bc7Smrj if (set_kernel(mp, KERNEL_CMD, NULL, kernbuf, BUFSIZ) 3647ae115bc7Smrj != BAM_SUCCESS) 3648ae115bc7Smrj return (BAM_ERROR); 3649ae115bc7Smrj if (kernbuf[0] == '\0') 3650ae115bc7Smrj (void) strncpy(kernbuf, DIRECT_BOOT_KERNEL, 3651ae115bc7Smrj BUFSIZ); 3652ae115bc7Smrj (void) strlcat(kernbuf, " ", BUFSIZ); 3653ae115bc7Smrj (void) strlcat(kernbuf, opt, BUFSIZ); 3654ae115bc7Smrj } else if (opt[0] == '/') { 3655455710d3Srscott /* It's a full path, so write it out. */ 3656ae115bc7Smrj (void) strlcpy(kernbuf, opt, BUFSIZ); 3657455710d3Srscott 3658455710d3Srscott /* 3659455710d3Srscott * If someone runs: 3660455710d3Srscott * 3661455710d3Srscott * # eeprom boot-args='-kd' 3662455710d3Srscott * # reboot /platform/i86pc/kernel/unix 3663455710d3Srscott * 3664455710d3Srscott * we want to use the boot-args as part of the boot 3665455710d3Srscott * line. On the other hand, if someone runs: 3666455710d3Srscott * 3667455710d3Srscott * # reboot "/platform/i86pc/kernel/unix -kd" 3668455710d3Srscott * 3669455710d3Srscott * we don't need to mess with boot-args. If there's 3670455710d3Srscott * no space in the options string, assume we're in the 3671455710d3Srscott * first case. 3672455710d3Srscott */ 3673455710d3Srscott if (strchr(opt, ' ') == NULL) { 3674455710d3Srscott if (set_kernel(mp, ARGS_CMD, NULL, args_buf, 3675455710d3Srscott BUFSIZ) != BAM_SUCCESS) 3676455710d3Srscott return (BAM_ERROR); 3677455710d3Srscott 3678455710d3Srscott if (args_buf[0] != '\0') { 3679455710d3Srscott (void) strlcat(kernbuf, " ", BUFSIZ); 3680455710d3Srscott (void) strlcat(kernbuf, args_buf, 3681455710d3Srscott BUFSIZ); 3682455710d3Srscott } 3683455710d3Srscott } 3684ae115bc7Smrj } else { 3685455710d3Srscott /* 3686455710d3Srscott * It may be a partial path, or it may be a partial 3687455710d3Srscott * path followed by options. Assume that only options 3688455710d3Srscott * follow a space. If someone sends us a kernel path 3689455710d3Srscott * that includes a space, they deserve to be broken. 3690455710d3Srscott */ 3691455710d3Srscott opt_ptr = strchr(opt, ' '); 3692455710d3Srscott if (opt_ptr != NULL) { 3693455710d3Srscott *opt_ptr = '\0'; 3694455710d3Srscott } 3695455710d3Srscott 3696ae115bc7Smrj path = expand_path(opt); 3697ae115bc7Smrj if (path != NULL) { 3698ae115bc7Smrj (void) strlcpy(kernbuf, path, BUFSIZ); 3699ae115bc7Smrj free(path); 3700455710d3Srscott 3701455710d3Srscott /* 3702455710d3Srscott * If there were options given, use those. 3703455710d3Srscott * Otherwise, copy over the default options. 3704455710d3Srscott */ 3705455710d3Srscott if (opt_ptr != NULL) { 3706455710d3Srscott /* Restore the space in opt string */ 3707455710d3Srscott *opt_ptr = ' '; 3708455710d3Srscott (void) strlcat(kernbuf, opt_ptr, 3709455710d3Srscott BUFSIZ); 3710455710d3Srscott } else { 3711ae115bc7Smrj if (set_kernel(mp, ARGS_CMD, NULL, 3712ae115bc7Smrj args_buf, BUFSIZ) != BAM_SUCCESS) 3713ae115bc7Smrj return (BAM_ERROR); 3714ae115bc7Smrj 3715ae115bc7Smrj if (args_buf[0] != '\0') { 3716ae115bc7Smrj (void) strlcat(kernbuf, " ", 3717ae115bc7Smrj BUFSIZ); 3718ae115bc7Smrj (void) strlcat(kernbuf, 3719ae115bc7Smrj args_buf, BUFSIZ); 3720ae115bc7Smrj } 3721ae115bc7Smrj } 3722455710d3Srscott } else { 3723455710d3Srscott bam_error(UNKNOWN_KERNEL, opt); 3724455710d3Srscott bam_print_stderr(UNKNOWN_KERNEL_REBOOT); 3725455710d3Srscott return (BAM_ERROR); 3726ae115bc7Smrj } 3727ae115bc7Smrj } 3728ae115bc7Smrj entry = add_boot_entry(mp, REBOOT_TITLE, grubdisk, kernbuf, 3729843e1988Sjohnlev NULL, NULL); 3730ae115bc7Smrj } else { 3731ae115bc7Smrj (void) snprintf(kernbuf, sizeof (kernbuf), "%s %s", 3732ae115bc7Smrj MULTI_BOOT, opt); 3733ae115bc7Smrj entry = add_boot_entry(mp, REBOOT_TITLE, grubdisk, kernbuf, 3734843e1988Sjohnlev NULL, MULTI_BOOT_ARCHIVE); 3735ae115bc7Smrj } 37367c478bd9Sstevel@tonic-gate free(grubdisk); 37377c478bd9Sstevel@tonic-gate 37387c478bd9Sstevel@tonic-gate if (entry == BAM_ERROR) { 3739b610f78eSvikram bam_error(REBOOT_WITH_ARGS_FAILED); 37407c478bd9Sstevel@tonic-gate return (BAM_ERROR); 37417c478bd9Sstevel@tonic-gate } 37428c1b6884Sszhou 3743ae115bc7Smrj save_default_entry(mp, BAM_OLDDEF); 37447c478bd9Sstevel@tonic-gate (void) set_global(mp, menu_cmds[DEFAULT_CMD], entry); 37457c478bd9Sstevel@tonic-gate return (BAM_WRITE); 37467c478bd9Sstevel@tonic-gate } 37477c478bd9Sstevel@tonic-gate 37487c478bd9Sstevel@tonic-gate static error_t 37497c478bd9Sstevel@tonic-gate set_global(menu_t *mp, char *globalcmd, int val) 37507c478bd9Sstevel@tonic-gate { 37517c478bd9Sstevel@tonic-gate line_t *lp, *found, *last; 37527c478bd9Sstevel@tonic-gate char *cp, *str; 37537c478bd9Sstevel@tonic-gate char prefix[BAM_MAXLINE]; 37547c478bd9Sstevel@tonic-gate size_t len; 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate assert(mp); 37577c478bd9Sstevel@tonic-gate assert(globalcmd); 37587c478bd9Sstevel@tonic-gate 3759b610f78eSvikram if (strcmp(globalcmd, menu_cmds[DEFAULT_CMD]) == 0) { 3760b610f78eSvikram if (val < 0 || mp->end == NULL || val > mp->end->entryNum) { 3761b610f78eSvikram (void) snprintf(prefix, sizeof (prefix), "%d", val); 3762b610f78eSvikram bam_error(INVALID_ENTRY, prefix); 3763b610f78eSvikram return (BAM_ERROR); 3764b610f78eSvikram } 3765b610f78eSvikram } 3766b610f78eSvikram 37677c478bd9Sstevel@tonic-gate found = last = NULL; 37687c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 37697c478bd9Sstevel@tonic-gate if (lp->flags != BAM_GLOBAL) 37707c478bd9Sstevel@tonic-gate continue; 37717c478bd9Sstevel@tonic-gate 37727c478bd9Sstevel@tonic-gate last = lp; /* track the last global found */ 37737c478bd9Sstevel@tonic-gate 37747c478bd9Sstevel@tonic-gate if (lp->cmd == NULL) { 37757c478bd9Sstevel@tonic-gate bam_error(NO_CMD, lp->lineNum); 37767c478bd9Sstevel@tonic-gate continue; 37777c478bd9Sstevel@tonic-gate } 37787c478bd9Sstevel@tonic-gate if (strcmp(globalcmd, lp->cmd) != 0) 37797c478bd9Sstevel@tonic-gate continue; 37807c478bd9Sstevel@tonic-gate 37817c478bd9Sstevel@tonic-gate if (found) { 37827c478bd9Sstevel@tonic-gate bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root); 37837c478bd9Sstevel@tonic-gate } 37847c478bd9Sstevel@tonic-gate found = lp; 37857c478bd9Sstevel@tonic-gate } 37867c478bd9Sstevel@tonic-gate 37877c478bd9Sstevel@tonic-gate if (found == NULL) { 37887c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 37897c478bd9Sstevel@tonic-gate if (last == NULL) { 37907c478bd9Sstevel@tonic-gate lp->next = mp->start; 37917c478bd9Sstevel@tonic-gate mp->start = lp; 37927c478bd9Sstevel@tonic-gate mp->end = (mp->end) ? mp->end : lp; 37937c478bd9Sstevel@tonic-gate } else { 37947c478bd9Sstevel@tonic-gate lp->next = last->next; 37957c478bd9Sstevel@tonic-gate last->next = lp; 37967c478bd9Sstevel@tonic-gate if (lp->next == NULL) 37977c478bd9Sstevel@tonic-gate mp->end = lp; 37987c478bd9Sstevel@tonic-gate } 37997c478bd9Sstevel@tonic-gate lp->flags = BAM_GLOBAL; /* other fields not needed for writes */ 38007c478bd9Sstevel@tonic-gate len = strlen(globalcmd) + strlen(menu_cmds[SEP_CMD]); 38017c478bd9Sstevel@tonic-gate len += 10; /* val < 10 digits */ 38027c478bd9Sstevel@tonic-gate lp->line = s_calloc(1, len); 38037c478bd9Sstevel@tonic-gate (void) snprintf(lp->line, len, "%s%s%d", 38047c478bd9Sstevel@tonic-gate globalcmd, menu_cmds[SEP_CMD], val); 38057c478bd9Sstevel@tonic-gate return (BAM_WRITE); 38067c478bd9Sstevel@tonic-gate } 38077c478bd9Sstevel@tonic-gate 38087c478bd9Sstevel@tonic-gate /* 38097c478bd9Sstevel@tonic-gate * We are changing an existing entry. Retain any prefix whitespace, 38107c478bd9Sstevel@tonic-gate * but overwrite everything else. This preserves tabs added for 38117c478bd9Sstevel@tonic-gate * readability. 38127c478bd9Sstevel@tonic-gate */ 38137c478bd9Sstevel@tonic-gate str = found->line; 38147c478bd9Sstevel@tonic-gate cp = prefix; 38157c478bd9Sstevel@tonic-gate while (*str == ' ' || *str == '\t') 38167c478bd9Sstevel@tonic-gate *(cp++) = *(str++); 38177c478bd9Sstevel@tonic-gate *cp = '\0'; /* Terminate prefix */ 38187c478bd9Sstevel@tonic-gate len = strlen(prefix) + strlen(globalcmd); 38197c478bd9Sstevel@tonic-gate len += strlen(menu_cmds[SEP_CMD]) + 10; 38207c478bd9Sstevel@tonic-gate 38217c478bd9Sstevel@tonic-gate free(found->line); 38227c478bd9Sstevel@tonic-gate found->line = s_calloc(1, len); 38237c478bd9Sstevel@tonic-gate (void) snprintf(found->line, len, 3824455710d3Srscott "%s%s%s%d", prefix, globalcmd, menu_cmds[SEP_CMD], val); 38257c478bd9Sstevel@tonic-gate 38267c478bd9Sstevel@tonic-gate return (BAM_WRITE); /* need a write to menu */ 38277c478bd9Sstevel@tonic-gate } 38287c478bd9Sstevel@tonic-gate 3829ae115bc7Smrj /* 3830ae115bc7Smrj * partial_path may be anything like "kernel/unix" or "kmdb". Try to 3831455710d3Srscott * expand it to a full unix path. The calling function is expected to 3832455710d3Srscott * output a message if an error occurs and NULL is returned. 3833ae115bc7Smrj */ 3834ae115bc7Smrj static char * 3835ae115bc7Smrj expand_path(const char *partial_path) 3836ae115bc7Smrj { 3837ae115bc7Smrj int new_path_len; 3838ae115bc7Smrj char *new_path, new_path2[PATH_MAX]; 3839ae115bc7Smrj struct stat sb; 3840ae115bc7Smrj 3841ae115bc7Smrj new_path_len = strlen(partial_path) + 64; 3842ae115bc7Smrj new_path = s_calloc(1, new_path_len); 3843ae115bc7Smrj 3844ae115bc7Smrj /* First, try the simplest case - something like "kernel/unix" */ 3845ae115bc7Smrj (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s", 3846ae115bc7Smrj partial_path); 3847ae115bc7Smrj if (stat(new_path, &sb) == 0) { 3848ae115bc7Smrj return (new_path); 3849ae115bc7Smrj } 3850ae115bc7Smrj 3851ae115bc7Smrj if (strcmp(partial_path, "kmdb") == 0) { 3852ae115bc7Smrj (void) snprintf(new_path, new_path_len, "%s -k", 3853ae115bc7Smrj DIRECT_BOOT_KERNEL); 3854ae115bc7Smrj return (new_path); 3855ae115bc7Smrj } 3856ae115bc7Smrj 3857ae115bc7Smrj /* 3858ae115bc7Smrj * We've quickly reached unsupported usage. Try once more to 3859ae115bc7Smrj * see if we were just given a glom name. 3860ae115bc7Smrj */ 3861ae115bc7Smrj (void) snprintf(new_path, new_path_len, "/platform/i86pc/%s/unix", 3862ae115bc7Smrj partial_path); 3863ae115bc7Smrj (void) snprintf(new_path2, PATH_MAX, "/platform/i86pc/%s/amd64/unix", 3864ae115bc7Smrj partial_path); 3865ae115bc7Smrj if (stat(new_path, &sb) == 0) { 3866ae115bc7Smrj if (stat(new_path2, &sb) == 0) { 3867ae115bc7Smrj /* 3868ae115bc7Smrj * We matched both, so we actually 3869ae115bc7Smrj * want to write the $ISADIR version. 3870ae115bc7Smrj */ 3871ae115bc7Smrj (void) snprintf(new_path, new_path_len, 3872ae115bc7Smrj "/platform/i86pc/kernel/%s/$ISADIR/unix", 3873ae115bc7Smrj partial_path); 3874ae115bc7Smrj } 3875ae115bc7Smrj return (new_path); 3876ae115bc7Smrj } 3877ae115bc7Smrj 3878ae115bc7Smrj free(new_path); 3879ae115bc7Smrj return (NULL); 3880ae115bc7Smrj } 3881ae115bc7Smrj 3882ae115bc7Smrj /* 3883ae115bc7Smrj * The kernel cmd and arg have been changed, so 3884ae115bc7Smrj * check whether the archive line needs to change. 3885ae115bc7Smrj */ 3886ae115bc7Smrj static void 3887ae115bc7Smrj set_archive_line(entry_t *entryp, line_t *kernelp) 3888ae115bc7Smrj { 3889ae115bc7Smrj line_t *lp = entryp->start; 3890ae115bc7Smrj char *new_archive; 3891ae115bc7Smrj menu_cmd_t m_cmd; 3892ae115bc7Smrj 3893ae115bc7Smrj for (; lp != NULL; lp = lp->next) { 3894ae115bc7Smrj if (strncmp(lp->cmd, menu_cmds[MODULE_CMD], 3895ae115bc7Smrj sizeof (menu_cmds[MODULE_CMD]) - 1) == 0) { 3896ae115bc7Smrj break; 3897ae115bc7Smrj } 3898ae115bc7Smrj if (lp == entryp->end) 3899ae115bc7Smrj return; 3900ae115bc7Smrj } 3901ae115bc7Smrj if (lp == NULL) 3902ae115bc7Smrj return; 3903ae115bc7Smrj 3904ae115bc7Smrj if (strstr(kernelp->arg, "$ISADIR") != NULL) { 3905ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE; 3906ae115bc7Smrj m_cmd = MODULE_DOLLAR_CMD; 3907ae115bc7Smrj } else if (strstr(kernelp->arg, "amd64") != NULL) { 3908ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE_64; 3909ae115bc7Smrj m_cmd = MODULE_CMD; 3910ae115bc7Smrj } else { 3911ae115bc7Smrj new_archive = DIRECT_BOOT_ARCHIVE_32; 3912ae115bc7Smrj m_cmd = MODULE_CMD; 3913ae115bc7Smrj } 3914ae115bc7Smrj 3915ae115bc7Smrj if (strcmp(lp->arg, new_archive) == 0) 3916ae115bc7Smrj return; 3917ae115bc7Smrj 3918ae115bc7Smrj if (strcmp(lp->cmd, menu_cmds[m_cmd]) != 0) { 3919ae115bc7Smrj free(lp->cmd); 3920ae115bc7Smrj lp->cmd = s_strdup(menu_cmds[m_cmd]); 3921ae115bc7Smrj } 3922ae115bc7Smrj 3923ae115bc7Smrj free(lp->arg); 3924ae115bc7Smrj lp->arg = s_strdup(new_archive); 3925ae115bc7Smrj update_line(lp); 3926ae115bc7Smrj } 3927ae115bc7Smrj 3928ae115bc7Smrj /* 3929ae115bc7Smrj * Title for an entry to set properties that once went in bootenv.rc. 3930ae115bc7Smrj */ 3931ae115bc7Smrj #define BOOTENV_RC_TITLE "Solaris bootenv rc" 3932ae115bc7Smrj 3933ae115bc7Smrj /* 3934ae115bc7Smrj * If path is NULL, return the kernel (optnum == KERNEL_CMD) or arguments 3935ae115bc7Smrj * (optnum == ARGS_CMD) in the argument buf. If path is a zero-length 3936ae115bc7Smrj * string, reset the value to the default. If path is a non-zero-length 3937ae115bc7Smrj * string, set the kernel or arguments. 3938ae115bc7Smrj */ 3939ae115bc7Smrj static error_t 3940ae115bc7Smrj set_kernel(menu_t *mp, menu_cmd_t optnum, char *path, char *buf, size_t bufsize) 3941ae115bc7Smrj { 3942ae115bc7Smrj int entryNum, rv = BAM_SUCCESS, free_new_path = 0; 3943ae115bc7Smrj entry_t *entryp; 3944ae115bc7Smrj line_t *ptr, *kernelp; 3945ae115bc7Smrj char *new_arg, *old_args, *space; 3946ae115bc7Smrj char *grubdisk, *rootdev, *new_path; 3947ae115bc7Smrj char old_space; 3948ae115bc7Smrj size_t old_kernel_len, new_str_len; 3949ae115bc7Smrj struct stat sb; 3950ae115bc7Smrj 3951ae115bc7Smrj assert(bufsize > 0); 3952ae115bc7Smrj 3953ae115bc7Smrj ptr = kernelp = NULL; 3954ae115bc7Smrj new_arg = old_args = space = NULL; 3955ae115bc7Smrj grubdisk = rootdev = new_path = NULL; 3956ae115bc7Smrj buf[0] = '\0'; 3957ae115bc7Smrj 3958ae115bc7Smrj if (bam_direct != BAM_DIRECT_DBOOT) { 3959ae115bc7Smrj bam_error(NOT_DBOOT, optnum == KERNEL_CMD ? "kernel" : "args"); 3960ae115bc7Smrj return (BAM_ERROR); 3961ae115bc7Smrj } 3962ae115bc7Smrj 3963ae115bc7Smrj /* 3964ae115bc7Smrj * If a user changed the default entry to a non-bootadm controlled 3965ae115bc7Smrj * one, we don't want to mess with it. Just print an error and 3966ae115bc7Smrj * return. 3967ae115bc7Smrj */ 3968ae115bc7Smrj if (mp->curdefault) { 3969ae115bc7Smrj entryNum = s_strtol(mp->curdefault->arg); 3970ae115bc7Smrj for (entryp = mp->entries; entryp; entryp = entryp->next) { 3971ae115bc7Smrj if (entryp->entryNum == entryNum) 3972ae115bc7Smrj break; 3973ae115bc7Smrj } 3974ae115bc7Smrj if ((entryp != NULL) && 3975ae115bc7Smrj ((entryp->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU)) == 0)) { 3976ae115bc7Smrj bam_error(DEFAULT_NOT_BAM); 3977ae115bc7Smrj return (BAM_ERROR); 3978ae115bc7Smrj } 3979ae115bc7Smrj } 3980ae115bc7Smrj 3981ae115bc7Smrj entryNum = -1; 3982843e1988Sjohnlev entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, 0, 3983ae115bc7Smrj &entryNum); 3984ae115bc7Smrj 3985ae115bc7Smrj if (entryp != NULL) { 3986ae115bc7Smrj for (ptr = entryp->start; ptr && ptr != entryp->end; 3987ae115bc7Smrj ptr = ptr->next) { 3988ae115bc7Smrj if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD], 3989ae115bc7Smrj sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) { 3990ae115bc7Smrj kernelp = ptr; 3991ae115bc7Smrj break; 3992ae115bc7Smrj } 3993ae115bc7Smrj } 3994ae115bc7Smrj if (kernelp == NULL) { 3995ae115bc7Smrj bam_error(NO_KERNEL, entryNum); 3996ae115bc7Smrj return (BAM_ERROR); 3997ae115bc7Smrj } 3998ae115bc7Smrj 3999ae115bc7Smrj old_kernel_len = strcspn(kernelp->arg, " \t"); 4000ae115bc7Smrj space = old_args = kernelp->arg + old_kernel_len; 4001ae115bc7Smrj while ((*old_args == ' ') || (*old_args == '\t')) 4002ae115bc7Smrj old_args++; 4003ae115bc7Smrj } 4004ae115bc7Smrj 4005ae115bc7Smrj if (path == NULL) { 4006ae115bc7Smrj /* Simply report what was found */ 4007ae115bc7Smrj if (kernelp == NULL) 4008ae115bc7Smrj return (BAM_SUCCESS); 4009ae115bc7Smrj 4010ae115bc7Smrj if (optnum == ARGS_CMD) { 4011ae115bc7Smrj if (old_args[0] != '\0') 4012ae115bc7Smrj (void) strlcpy(buf, old_args, bufsize); 4013ae115bc7Smrj } else { 4014ae115bc7Smrj /* 4015ae115bc7Smrj * We need to print the kernel, so we just turn the 4016ae115bc7Smrj * first space into a '\0' and print the beginning. 4017ae115bc7Smrj * We don't print anything if it's the default kernel. 4018ae115bc7Smrj */ 4019ae115bc7Smrj old_space = *space; 4020ae115bc7Smrj *space = '\0'; 4021ae115bc7Smrj if (strcmp(kernelp->arg, DIRECT_BOOT_KERNEL) != 0) 4022ae115bc7Smrj (void) strlcpy(buf, kernelp->arg, bufsize); 4023ae115bc7Smrj *space = old_space; 4024ae115bc7Smrj } 4025ae115bc7Smrj return (BAM_SUCCESS); 4026ae115bc7Smrj } 4027ae115bc7Smrj 4028ae115bc7Smrj /* 4029ae115bc7Smrj * First, check if we're resetting an entry to the default. 4030ae115bc7Smrj */ 4031ae115bc7Smrj if ((path[0] == '\0') || 4032ae115bc7Smrj ((optnum == KERNEL_CMD) && 4033ae115bc7Smrj (strcmp(path, DIRECT_BOOT_KERNEL) == 0))) { 4034ae115bc7Smrj if ((entryp == NULL) || (kernelp == NULL)) { 4035ae115bc7Smrj /* No previous entry, it's already the default */ 4036ae115bc7Smrj return (BAM_SUCCESS); 4037ae115bc7Smrj } 4038ae115bc7Smrj 4039ae115bc7Smrj /* 4040ae115bc7Smrj * Check if we can delete the entry. If we're resetting the 4041ae115bc7Smrj * kernel command, and the args is already empty, or if we're 4042ae115bc7Smrj * resetting the args command, and the kernel is already the 4043ae115bc7Smrj * default, we can restore the old default and delete the entry. 4044ae115bc7Smrj */ 4045ae115bc7Smrj if (((optnum == KERNEL_CMD) && 4046ae115bc7Smrj ((old_args == NULL) || (old_args[0] == '\0'))) || 4047ae115bc7Smrj ((optnum == ARGS_CMD) && 4048ae115bc7Smrj (strncmp(kernelp->arg, DIRECT_BOOT_KERNEL, 4049ae115bc7Smrj sizeof (DIRECT_BOOT_KERNEL) - 1) == 0))) { 4050ae115bc7Smrj kernelp = NULL; 4051ae115bc7Smrj (void) do_delete(mp, entryNum); 4052ae115bc7Smrj restore_default_entry(mp, BAM_OLD_RC_DEF, 4053ae115bc7Smrj mp->old_rc_default); 4054ae115bc7Smrj mp->old_rc_default = NULL; 4055ae115bc7Smrj rv = BAM_WRITE; 4056ae115bc7Smrj goto done; 4057ae115bc7Smrj } 4058ae115bc7Smrj 4059ae115bc7Smrj if (optnum == KERNEL_CMD) { 4060ae115bc7Smrj /* 4061ae115bc7Smrj * At this point, we've already checked that old_args 4062ae115bc7Smrj * and entryp are valid pointers. The "+ 2" is for 4063ae115bc7Smrj * a space a the string termination character. 4064ae115bc7Smrj */ 4065ae115bc7Smrj new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) + 4066ae115bc7Smrj strlen(old_args) + 2; 4067ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 4068ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", 4069ae115bc7Smrj DIRECT_BOOT_KERNEL, old_args); 4070ae115bc7Smrj free(kernelp->arg); 4071ae115bc7Smrj kernelp->arg = new_arg; 4072ae115bc7Smrj 4073ae115bc7Smrj /* 4074ae115bc7Smrj * We have changed the kernel line, so we may need 4075ae115bc7Smrj * to update the archive line as well. 4076ae115bc7Smrj */ 4077ae115bc7Smrj set_archive_line(entryp, kernelp); 4078ae115bc7Smrj } else { 4079ae115bc7Smrj /* 4080ae115bc7Smrj * We're resetting the boot args to nothing, so 4081ae115bc7Smrj * we only need to copy the kernel. We've already 4082ae115bc7Smrj * checked that the kernel is not the default. 4083ae115bc7Smrj */ 4084ae115bc7Smrj new_arg = s_calloc(1, old_kernel_len + 1); 4085ae115bc7Smrj (void) snprintf(new_arg, old_kernel_len + 1, "%s", 4086ae115bc7Smrj kernelp->arg); 4087ae115bc7Smrj free(kernelp->arg); 4088ae115bc7Smrj kernelp->arg = new_arg; 4089ae115bc7Smrj } 4090ae115bc7Smrj rv = BAM_WRITE; 4091ae115bc7Smrj goto done; 4092ae115bc7Smrj } 4093ae115bc7Smrj 4094ae115bc7Smrj /* 4095ae115bc7Smrj * Expand the kernel file to a full path, if necessary 4096ae115bc7Smrj */ 4097ae115bc7Smrj if ((optnum == KERNEL_CMD) && (path[0] != '/')) { 4098ae115bc7Smrj new_path = expand_path(path); 4099ae115bc7Smrj if (new_path == NULL) { 4100455710d3Srscott bam_error(UNKNOWN_KERNEL, path); 4101ae115bc7Smrj return (BAM_ERROR); 4102ae115bc7Smrj } 4103ae115bc7Smrj free_new_path = 1; 4104ae115bc7Smrj } else { 4105ae115bc7Smrj new_path = path; 4106ae115bc7Smrj free_new_path = 0; 4107ae115bc7Smrj } 4108ae115bc7Smrj 4109ae115bc7Smrj /* 4110ae115bc7Smrj * At this point, we know we're setting a new value. First, take care 4111ae115bc7Smrj * of the case where there was no previous entry. 4112ae115bc7Smrj */ 4113ae115bc7Smrj if (entryp == NULL) { 4114ae115bc7Smrj /* Similar to code in update_temp */ 4115ae115bc7Smrj if (stat(GRUB_slice, &sb) != 0) { 4116ae115bc7Smrj /* 4117ae115bc7Smrj * 1. First get root disk name from mnttab 4118ae115bc7Smrj * 2. Translate disk name to grub name 4119ae115bc7Smrj * 3. Add the new menu entry 4120ae115bc7Smrj */ 4121ae115bc7Smrj rootdev = get_special("/"); 4122ae115bc7Smrj if (rootdev) { 4123ae115bc7Smrj grubdisk = os_to_grubdisk(rootdev, 1); 4124ae115bc7Smrj free(rootdev); 4125ae115bc7Smrj } 4126ae115bc7Smrj } else { 4127ae115bc7Smrj /* 4128ae115bc7Smrj * This is an LU BE. The GRUB_root file 4129ae115bc7Smrj * contains entry for GRUB's "root" cmd. 4130ae115bc7Smrj */ 4131ae115bc7Smrj grubdisk = read_grub_root(); 4132ae115bc7Smrj } 4133ae115bc7Smrj if (grubdisk == NULL) { 4134ae115bc7Smrj bam_error(REBOOT_WITH_ARGS_FAILED); 4135ae115bc7Smrj rv = BAM_ERROR; 4136ae115bc7Smrj goto done; 4137ae115bc7Smrj } 4138ae115bc7Smrj if (optnum == KERNEL_CMD) { 4139ae115bc7Smrj entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 4140843e1988Sjohnlev grubdisk, new_path, NULL, NULL); 4141ae115bc7Smrj } else { 4142ae115bc7Smrj new_str_len = strlen(DIRECT_BOOT_KERNEL) + 4143ae115bc7Smrj strlen(path) + 8; 4144ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 4145ae115bc7Smrj 4146ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", 4147ae115bc7Smrj DIRECT_BOOT_KERNEL, path); 4148ae115bc7Smrj entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE, 4149843e1988Sjohnlev grubdisk, new_arg, NULL, DIRECT_BOOT_ARCHIVE); 4150ae115bc7Smrj } 4151ae115bc7Smrj save_default_entry(mp, BAM_OLD_RC_DEF); 4152ae115bc7Smrj (void) set_global(mp, menu_cmds[DEFAULT_CMD], entryNum); 4153ae115bc7Smrj rv = BAM_WRITE; 4154ae115bc7Smrj goto done; 4155ae115bc7Smrj } 4156ae115bc7Smrj 4157ae115bc7Smrj /* 4158ae115bc7Smrj * There was already an bootenv entry which we need to edit. 4159ae115bc7Smrj */ 4160ae115bc7Smrj if (optnum == KERNEL_CMD) { 4161ae115bc7Smrj new_str_len = strlen(new_path) + strlen(old_args) + 2; 4162ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 4163ae115bc7Smrj (void) snprintf(new_arg, new_str_len, "%s %s", new_path, 4164ae115bc7Smrj old_args); 4165ae115bc7Smrj free(kernelp->arg); 4166ae115bc7Smrj kernelp->arg = new_arg; 4167ae115bc7Smrj 4168ae115bc7Smrj /* 4169ae115bc7Smrj * If we have changed the kernel line, we may need to update 4170ae115bc7Smrj * the archive line as well. 4171ae115bc7Smrj */ 4172ae115bc7Smrj set_archive_line(entryp, kernelp); 4173ae115bc7Smrj } else { 4174ae115bc7Smrj new_str_len = old_kernel_len + strlen(path) + 8; 4175ae115bc7Smrj new_arg = s_calloc(1, new_str_len); 4176ae115bc7Smrj (void) strncpy(new_arg, kernelp->arg, old_kernel_len); 4177ae115bc7Smrj (void) strlcat(new_arg, " ", new_str_len); 4178ae115bc7Smrj (void) strlcat(new_arg, path, new_str_len); 4179ae115bc7Smrj free(kernelp->arg); 4180ae115bc7Smrj kernelp->arg = new_arg; 4181ae115bc7Smrj } 4182ae115bc7Smrj rv = BAM_WRITE; 4183ae115bc7Smrj 4184ae115bc7Smrj done: 4185ae115bc7Smrj if ((rv == BAM_WRITE) && kernelp) 4186ae115bc7Smrj update_line(kernelp); 4187ae115bc7Smrj if (free_new_path) 4188ae115bc7Smrj free(new_path); 4189ae115bc7Smrj return (rv); 4190ae115bc7Smrj } 4191ae115bc7Smrj 41927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 41937c478bd9Sstevel@tonic-gate static error_t 41947c478bd9Sstevel@tonic-gate set_option(menu_t *mp, char *menu_path, char *opt) 41957c478bd9Sstevel@tonic-gate { 41967c478bd9Sstevel@tonic-gate int optnum, optval; 41977c478bd9Sstevel@tonic-gate char *val; 4198ae115bc7Smrj char buf[BUFSIZ] = ""; 4199ae115bc7Smrj error_t rv; 42007c478bd9Sstevel@tonic-gate 42017c478bd9Sstevel@tonic-gate assert(mp); 42027c478bd9Sstevel@tonic-gate assert(opt); 42037c478bd9Sstevel@tonic-gate 42047c478bd9Sstevel@tonic-gate val = strchr(opt, '='); 4205ae115bc7Smrj if (val != NULL) { 4206ae115bc7Smrj *val = '\0'; 42077c478bd9Sstevel@tonic-gate } 42087c478bd9Sstevel@tonic-gate 42097c478bd9Sstevel@tonic-gate if (strcmp(opt, "default") == 0) { 42107c478bd9Sstevel@tonic-gate optnum = DEFAULT_CMD; 42117c478bd9Sstevel@tonic-gate } else if (strcmp(opt, "timeout") == 0) { 42127c478bd9Sstevel@tonic-gate optnum = TIMEOUT_CMD; 4213ae115bc7Smrj } else if (strcmp(opt, menu_cmds[KERNEL_CMD]) == 0) { 4214ae115bc7Smrj optnum = KERNEL_CMD; 4215ae115bc7Smrj } else if (strcmp(opt, menu_cmds[ARGS_CMD]) == 0) { 4216ae115bc7Smrj optnum = ARGS_CMD; 42177c478bd9Sstevel@tonic-gate } else { 42187c478bd9Sstevel@tonic-gate bam_error(INVALID_ENTRY, opt); 42197c478bd9Sstevel@tonic-gate return (BAM_ERROR); 42207c478bd9Sstevel@tonic-gate } 42217c478bd9Sstevel@tonic-gate 4222ae115bc7Smrj /* 4223ae115bc7Smrj * kernel and args are allowed without "=new_value" strings. All 4224ae115bc7Smrj * others cause errors 4225ae115bc7Smrj */ 4226ae115bc7Smrj if ((val == NULL) && (optnum != KERNEL_CMD) && (optnum != ARGS_CMD)) { 4227ae115bc7Smrj bam_error(INVALID_ENTRY, opt); 4228ae115bc7Smrj return (BAM_ERROR); 4229ae115bc7Smrj } else if (val != NULL) { 4230ae115bc7Smrj *val = '='; 4231ae115bc7Smrj } 4232ae115bc7Smrj 4233ae115bc7Smrj if ((optnum == KERNEL_CMD) || (optnum == ARGS_CMD)) { 4234ae115bc7Smrj rv = set_kernel(mp, optnum, val ? val + 1 : NULL, buf, BUFSIZ); 4235ae115bc7Smrj if ((rv == BAM_SUCCESS) && (buf[0] != '\0')) 4236ae115bc7Smrj (void) printf("%s\n", buf); 4237ae115bc7Smrj return (rv); 4238ae115bc7Smrj } else { 4239ae115bc7Smrj optval = s_strtol(val + 1); 4240ae115bc7Smrj return (set_global(mp, menu_cmds[optnum], optval)); 4241ae115bc7Smrj } 42427c478bd9Sstevel@tonic-gate } 42437c478bd9Sstevel@tonic-gate 42447c478bd9Sstevel@tonic-gate /* 42457c478bd9Sstevel@tonic-gate * The quiet argument suppresses messages. This is used 42467c478bd9Sstevel@tonic-gate * when invoked in the context of other commands (e.g. list_entry) 42477c478bd9Sstevel@tonic-gate */ 42487c478bd9Sstevel@tonic-gate static error_t 42497c478bd9Sstevel@tonic-gate read_globals(menu_t *mp, char *menu_path, char *globalcmd, int quiet) 42507c478bd9Sstevel@tonic-gate { 42517c478bd9Sstevel@tonic-gate line_t *lp; 42527c478bd9Sstevel@tonic-gate char *arg; 42537c478bd9Sstevel@tonic-gate int done, ret = BAM_SUCCESS; 42547c478bd9Sstevel@tonic-gate 42557c478bd9Sstevel@tonic-gate assert(mp); 42567c478bd9Sstevel@tonic-gate assert(menu_path); 42577c478bd9Sstevel@tonic-gate assert(globalcmd); 42587c478bd9Sstevel@tonic-gate 42597c478bd9Sstevel@tonic-gate if (mp->start == NULL) { 42607c478bd9Sstevel@tonic-gate if (!quiet) 42617c478bd9Sstevel@tonic-gate bam_error(NO_MENU, menu_path); 42627c478bd9Sstevel@tonic-gate return (BAM_ERROR); 42637c478bd9Sstevel@tonic-gate } 42647c478bd9Sstevel@tonic-gate 42657c478bd9Sstevel@tonic-gate done = 0; 42667c478bd9Sstevel@tonic-gate for (lp = mp->start; lp; lp = lp->next) { 42677c478bd9Sstevel@tonic-gate if (lp->flags != BAM_GLOBAL) 42687c478bd9Sstevel@tonic-gate continue; 42697c478bd9Sstevel@tonic-gate 42707c478bd9Sstevel@tonic-gate if (lp->cmd == NULL) { 42717c478bd9Sstevel@tonic-gate if (!quiet) 42727c478bd9Sstevel@tonic-gate bam_error(NO_CMD, lp->lineNum); 42737c478bd9Sstevel@tonic-gate continue; 42747c478bd9Sstevel@tonic-gate } 42757c478bd9Sstevel@tonic-gate 42767c478bd9Sstevel@tonic-gate if (strcmp(globalcmd, lp->cmd) != 0) 42777c478bd9Sstevel@tonic-gate continue; 42787c478bd9Sstevel@tonic-gate 42797c478bd9Sstevel@tonic-gate /* Found global. Check for duplicates */ 42807c478bd9Sstevel@tonic-gate if (done && !quiet) { 42817c478bd9Sstevel@tonic-gate bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root); 42827c478bd9Sstevel@tonic-gate ret = BAM_ERROR; 42837c478bd9Sstevel@tonic-gate } 42847c478bd9Sstevel@tonic-gate 42857c478bd9Sstevel@tonic-gate arg = lp->arg ? lp->arg : ""; 42867c478bd9Sstevel@tonic-gate bam_print(GLOBAL_CMD, globalcmd, arg); 42877c478bd9Sstevel@tonic-gate done = 1; 42887c478bd9Sstevel@tonic-gate } 42897c478bd9Sstevel@tonic-gate 42907c478bd9Sstevel@tonic-gate if (!done && bam_verbose) 42917c478bd9Sstevel@tonic-gate bam_print(NO_ENTRY, globalcmd); 42927c478bd9Sstevel@tonic-gate 42937c478bd9Sstevel@tonic-gate return (ret); 42947c478bd9Sstevel@tonic-gate } 42957c478bd9Sstevel@tonic-gate 42967c478bd9Sstevel@tonic-gate static error_t 42977c478bd9Sstevel@tonic-gate menu_write(char *root, menu_t *mp) 42987c478bd9Sstevel@tonic-gate { 42997c478bd9Sstevel@tonic-gate return (list2file(root, MENU_TMP, GRUB_MENU, mp->start)); 43007c478bd9Sstevel@tonic-gate } 43017c478bd9Sstevel@tonic-gate 43027c478bd9Sstevel@tonic-gate static void 43037c478bd9Sstevel@tonic-gate line_free(line_t *lp) 43047c478bd9Sstevel@tonic-gate { 43057c478bd9Sstevel@tonic-gate if (lp == NULL) 43067c478bd9Sstevel@tonic-gate return; 43077c478bd9Sstevel@tonic-gate 43087c478bd9Sstevel@tonic-gate if (lp->cmd) 43097c478bd9Sstevel@tonic-gate free(lp->cmd); 43107c478bd9Sstevel@tonic-gate if (lp->sep) 43117c478bd9Sstevel@tonic-gate free(lp->sep); 43127c478bd9Sstevel@tonic-gate if (lp->arg) 43137c478bd9Sstevel@tonic-gate free(lp->arg); 43147c478bd9Sstevel@tonic-gate if (lp->line) 43157c478bd9Sstevel@tonic-gate free(lp->line); 43167c478bd9Sstevel@tonic-gate free(lp); 43177c478bd9Sstevel@tonic-gate } 43187c478bd9Sstevel@tonic-gate 43197c478bd9Sstevel@tonic-gate static void 43207c478bd9Sstevel@tonic-gate linelist_free(line_t *start) 43217c478bd9Sstevel@tonic-gate { 43227c478bd9Sstevel@tonic-gate line_t *lp; 43237c478bd9Sstevel@tonic-gate 43247c478bd9Sstevel@tonic-gate while (start) { 43257c478bd9Sstevel@tonic-gate lp = start; 43267c478bd9Sstevel@tonic-gate start = start->next; 43277c478bd9Sstevel@tonic-gate line_free(lp); 43287c478bd9Sstevel@tonic-gate } 43297c478bd9Sstevel@tonic-gate } 43307c478bd9Sstevel@tonic-gate 43317c478bd9Sstevel@tonic-gate static void 43327c478bd9Sstevel@tonic-gate filelist_free(filelist_t *flistp) 43337c478bd9Sstevel@tonic-gate { 43347c478bd9Sstevel@tonic-gate linelist_free(flistp->head); 43357c478bd9Sstevel@tonic-gate flistp->head = NULL; 43367c478bd9Sstevel@tonic-gate flistp->tail = NULL; 43377c478bd9Sstevel@tonic-gate } 43387c478bd9Sstevel@tonic-gate 43397c478bd9Sstevel@tonic-gate static void 43407c478bd9Sstevel@tonic-gate menu_free(menu_t *mp) 43417c478bd9Sstevel@tonic-gate { 43428c1b6884Sszhou entry_t *ent, *tmp; 43437c478bd9Sstevel@tonic-gate assert(mp); 43447c478bd9Sstevel@tonic-gate 43457c478bd9Sstevel@tonic-gate if (mp->start) 43467c478bd9Sstevel@tonic-gate linelist_free(mp->start); 43478c1b6884Sszhou ent = mp->entries; 43488c1b6884Sszhou while (ent) { 43498c1b6884Sszhou tmp = ent; 43508c1b6884Sszhou ent = tmp->next; 43518c1b6884Sszhou free(tmp); 43528c1b6884Sszhou } 43537c478bd9Sstevel@tonic-gate 43548c1b6884Sszhou free(mp); 43557c478bd9Sstevel@tonic-gate } 43567c478bd9Sstevel@tonic-gate 43577c478bd9Sstevel@tonic-gate /* 43587c478bd9Sstevel@tonic-gate * Utility routines 43597c478bd9Sstevel@tonic-gate */ 43607c478bd9Sstevel@tonic-gate 43617c478bd9Sstevel@tonic-gate 43627c478bd9Sstevel@tonic-gate /* 43637c478bd9Sstevel@tonic-gate * Returns 0 on success 43647c478bd9Sstevel@tonic-gate * Any other value indicates an error 43657c478bd9Sstevel@tonic-gate */ 43667c478bd9Sstevel@tonic-gate static int 4367*986fd29aSsetje exec_cmd(char *cmdline, filelist_t *flistp) 43687c478bd9Sstevel@tonic-gate { 43697c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 43707c478bd9Sstevel@tonic-gate int ret; 43717c478bd9Sstevel@tonic-gate FILE *ptr; 43727c478bd9Sstevel@tonic-gate sigset_t set; 43737c478bd9Sstevel@tonic-gate void (*disp)(int); 43747c478bd9Sstevel@tonic-gate 43757c478bd9Sstevel@tonic-gate /* 43767c478bd9Sstevel@tonic-gate * For security 43777c478bd9Sstevel@tonic-gate * - only absolute paths are allowed 43787c478bd9Sstevel@tonic-gate * - set IFS to space and tab 43797c478bd9Sstevel@tonic-gate */ 43807c478bd9Sstevel@tonic-gate if (*cmdline != '/') { 43817c478bd9Sstevel@tonic-gate bam_error(ABS_PATH_REQ, cmdline); 43827c478bd9Sstevel@tonic-gate return (-1); 43837c478bd9Sstevel@tonic-gate } 43847c478bd9Sstevel@tonic-gate (void) putenv("IFS= \t"); 43857c478bd9Sstevel@tonic-gate 43867c478bd9Sstevel@tonic-gate /* 43877c478bd9Sstevel@tonic-gate * We may have been exec'ed with SIGCHLD blocked 43887c478bd9Sstevel@tonic-gate * unblock it here 43897c478bd9Sstevel@tonic-gate */ 43907c478bd9Sstevel@tonic-gate (void) sigemptyset(&set); 43917c478bd9Sstevel@tonic-gate (void) sigaddset(&set, SIGCHLD); 43927c478bd9Sstevel@tonic-gate if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) { 43937c478bd9Sstevel@tonic-gate bam_error(CANT_UNBLOCK_SIGCHLD, strerror(errno)); 43947c478bd9Sstevel@tonic-gate return (-1); 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate 43977c478bd9Sstevel@tonic-gate /* 43987c478bd9Sstevel@tonic-gate * Set SIGCHLD disposition to SIG_DFL for popen/pclose 43997c478bd9Sstevel@tonic-gate */ 44007c478bd9Sstevel@tonic-gate disp = sigset(SIGCHLD, SIG_DFL); 44017c478bd9Sstevel@tonic-gate if (disp == SIG_ERR) { 44027c478bd9Sstevel@tonic-gate bam_error(FAILED_SIG, strerror(errno)); 44037c478bd9Sstevel@tonic-gate return (-1); 44047c478bd9Sstevel@tonic-gate } 44057c478bd9Sstevel@tonic-gate if (disp == SIG_HOLD) { 44067c478bd9Sstevel@tonic-gate bam_error(BLOCKED_SIG, cmdline); 44077c478bd9Sstevel@tonic-gate return (-1); 44087c478bd9Sstevel@tonic-gate } 44097c478bd9Sstevel@tonic-gate 44107c478bd9Sstevel@tonic-gate ptr = popen(cmdline, "r"); 44117c478bd9Sstevel@tonic-gate if (ptr == NULL) { 44127c478bd9Sstevel@tonic-gate bam_error(POPEN_FAIL, cmdline, strerror(errno)); 44137c478bd9Sstevel@tonic-gate return (-1); 44147c478bd9Sstevel@tonic-gate } 44157c478bd9Sstevel@tonic-gate 44167c478bd9Sstevel@tonic-gate /* 44177c478bd9Sstevel@tonic-gate * If we simply do a pclose() following a popen(), pclose() 44187c478bd9Sstevel@tonic-gate * will close the reader end of the pipe immediately even 44197c478bd9Sstevel@tonic-gate * if the child process has not started/exited. pclose() 44207c478bd9Sstevel@tonic-gate * does wait for cmd to terminate before returning though. 44217c478bd9Sstevel@tonic-gate * When the executed command writes its output to the pipe 44227c478bd9Sstevel@tonic-gate * there is no reader process and the command dies with 44237c478bd9Sstevel@tonic-gate * SIGPIPE. To avoid this we read repeatedly until read 44247c478bd9Sstevel@tonic-gate * terminates with EOF. This indicates that the command 44257c478bd9Sstevel@tonic-gate * (writer) has closed the pipe and we can safely do a 44267c478bd9Sstevel@tonic-gate * pclose(). 44277c478bd9Sstevel@tonic-gate * 44287c478bd9Sstevel@tonic-gate * Since pclose() does wait for the command to exit, 44297c478bd9Sstevel@tonic-gate * we can safely reap the exit status of the command 44307c478bd9Sstevel@tonic-gate * from the value returned by pclose() 44317c478bd9Sstevel@tonic-gate */ 4432*986fd29aSsetje while (s_fgets(buf, sizeof (buf), ptr) != NULL) { 4433*986fd29aSsetje if (flistp == NULL) { 4434*986fd29aSsetje /* s_fgets strips newlines, so insert them at the end */ 4435*986fd29aSsetje bam_print(PRINT, buf); 4436*986fd29aSsetje } else { 4437*986fd29aSsetje append_to_flist(flistp, buf); 44387c478bd9Sstevel@tonic-gate } 44397c478bd9Sstevel@tonic-gate } 44407c478bd9Sstevel@tonic-gate 44417c478bd9Sstevel@tonic-gate ret = pclose(ptr); 44427c478bd9Sstevel@tonic-gate if (ret == -1) { 44437c478bd9Sstevel@tonic-gate bam_error(PCLOSE_FAIL, cmdline, strerror(errno)); 44447c478bd9Sstevel@tonic-gate return (-1); 44457c478bd9Sstevel@tonic-gate } 44467c478bd9Sstevel@tonic-gate 44477c478bd9Sstevel@tonic-gate if (WIFEXITED(ret)) { 44487c478bd9Sstevel@tonic-gate return (WEXITSTATUS(ret)); 44497c478bd9Sstevel@tonic-gate } else { 44507c478bd9Sstevel@tonic-gate bam_error(EXEC_FAIL, cmdline, ret); 44517c478bd9Sstevel@tonic-gate return (-1); 44527c478bd9Sstevel@tonic-gate } 44537c478bd9Sstevel@tonic-gate } 44547c478bd9Sstevel@tonic-gate 44557c478bd9Sstevel@tonic-gate /* 44567c478bd9Sstevel@tonic-gate * Since this function returns -1 on error 44577c478bd9Sstevel@tonic-gate * it cannot be used to convert -1. However, 44587c478bd9Sstevel@tonic-gate * that is sufficient for what we need. 44597c478bd9Sstevel@tonic-gate */ 44607c478bd9Sstevel@tonic-gate static long 44617c478bd9Sstevel@tonic-gate s_strtol(char *str) 44627c478bd9Sstevel@tonic-gate { 44637c478bd9Sstevel@tonic-gate long l; 44647c478bd9Sstevel@tonic-gate char *res = NULL; 44657c478bd9Sstevel@tonic-gate 44667c478bd9Sstevel@tonic-gate if (str == NULL) { 44677c478bd9Sstevel@tonic-gate return (-1); 44687c478bd9Sstevel@tonic-gate } 44697c478bd9Sstevel@tonic-gate 44707c478bd9Sstevel@tonic-gate errno = 0; 44717c478bd9Sstevel@tonic-gate l = strtol(str, &res, 10); 44727c478bd9Sstevel@tonic-gate if (errno || *res != '\0') { 44737c478bd9Sstevel@tonic-gate return (-1); 44747c478bd9Sstevel@tonic-gate } 44757c478bd9Sstevel@tonic-gate 44767c478bd9Sstevel@tonic-gate return (l); 44777c478bd9Sstevel@tonic-gate } 44787c478bd9Sstevel@tonic-gate 44797c478bd9Sstevel@tonic-gate /* 44807c478bd9Sstevel@tonic-gate * Wrapper around fputs, that adds a newline (since fputs doesn't) 44817c478bd9Sstevel@tonic-gate */ 44827c478bd9Sstevel@tonic-gate static int 44837c478bd9Sstevel@tonic-gate s_fputs(char *str, FILE *fp) 44847c478bd9Sstevel@tonic-gate { 44857c478bd9Sstevel@tonic-gate char linebuf[BAM_MAXLINE]; 44867c478bd9Sstevel@tonic-gate 44877c478bd9Sstevel@tonic-gate (void) snprintf(linebuf, sizeof (linebuf), "%s\n", str); 44887c478bd9Sstevel@tonic-gate return (fputs(linebuf, fp)); 44897c478bd9Sstevel@tonic-gate } 44907c478bd9Sstevel@tonic-gate 44917c478bd9Sstevel@tonic-gate /* 44927c478bd9Sstevel@tonic-gate * Wrapper around fgets, that strips newlines returned by fgets 44937c478bd9Sstevel@tonic-gate */ 4494ae115bc7Smrj char * 44957c478bd9Sstevel@tonic-gate s_fgets(char *buf, int buflen, FILE *fp) 44967c478bd9Sstevel@tonic-gate { 44977c478bd9Sstevel@tonic-gate int n; 44987c478bd9Sstevel@tonic-gate 44997c478bd9Sstevel@tonic-gate buf = fgets(buf, buflen, fp); 45007c478bd9Sstevel@tonic-gate if (buf) { 45017c478bd9Sstevel@tonic-gate n = strlen(buf); 45027c478bd9Sstevel@tonic-gate if (n == buflen - 1 && buf[n-1] != '\n') 45037c478bd9Sstevel@tonic-gate bam_error(TOO_LONG, buflen - 1, buf); 45047c478bd9Sstevel@tonic-gate buf[n-1] = (buf[n-1] == '\n') ? '\0' : buf[n-1]; 45057c478bd9Sstevel@tonic-gate } 45067c478bd9Sstevel@tonic-gate 45077c478bd9Sstevel@tonic-gate return (buf); 45087c478bd9Sstevel@tonic-gate } 45097c478bd9Sstevel@tonic-gate 4510ae115bc7Smrj void * 45117c478bd9Sstevel@tonic-gate s_calloc(size_t nelem, size_t sz) 45127c478bd9Sstevel@tonic-gate { 45137c478bd9Sstevel@tonic-gate void *ptr; 45147c478bd9Sstevel@tonic-gate 45157c478bd9Sstevel@tonic-gate ptr = calloc(nelem, sz); 45167c478bd9Sstevel@tonic-gate if (ptr == NULL) { 45177c478bd9Sstevel@tonic-gate bam_error(NO_MEM, nelem*sz); 45187c478bd9Sstevel@tonic-gate bam_exit(1); 45197c478bd9Sstevel@tonic-gate } 45207c478bd9Sstevel@tonic-gate return (ptr); 45217c478bd9Sstevel@tonic-gate } 45227c478bd9Sstevel@tonic-gate 4523ae115bc7Smrj void * 4524ae115bc7Smrj s_realloc(void *ptr, size_t sz) 4525ae115bc7Smrj { 4526ae115bc7Smrj ptr = realloc(ptr, sz); 4527ae115bc7Smrj if (ptr == NULL) { 4528ae115bc7Smrj bam_error(NO_MEM, sz); 4529ae115bc7Smrj bam_exit(1); 4530ae115bc7Smrj } 4531ae115bc7Smrj return (ptr); 4532ae115bc7Smrj } 4533ae115bc7Smrj 45347c478bd9Sstevel@tonic-gate static char * 45357c478bd9Sstevel@tonic-gate s_strdup(char *str) 45367c478bd9Sstevel@tonic-gate { 45377c478bd9Sstevel@tonic-gate char *ptr; 45387c478bd9Sstevel@tonic-gate 45397c478bd9Sstevel@tonic-gate if (str == NULL) 45407c478bd9Sstevel@tonic-gate return (NULL); 45417c478bd9Sstevel@tonic-gate 45427c478bd9Sstevel@tonic-gate ptr = strdup(str); 45437c478bd9Sstevel@tonic-gate if (ptr == NULL) { 45447c478bd9Sstevel@tonic-gate bam_error(NO_MEM, strlen(str) + 1); 45457c478bd9Sstevel@tonic-gate bam_exit(1); 45467c478bd9Sstevel@tonic-gate } 45477c478bd9Sstevel@tonic-gate return (ptr); 45487c478bd9Sstevel@tonic-gate } 45497c478bd9Sstevel@tonic-gate 45507c478bd9Sstevel@tonic-gate /* 45517c478bd9Sstevel@tonic-gate * Returns 1 if amd64 (or sparc, for syncing x86 diskless clients) 45527c478bd9Sstevel@tonic-gate * Returns 0 otherwise 45537c478bd9Sstevel@tonic-gate */ 45547c478bd9Sstevel@tonic-gate static int 45557c478bd9Sstevel@tonic-gate is_amd64(void) 45567c478bd9Sstevel@tonic-gate { 45577c478bd9Sstevel@tonic-gate static int amd64 = -1; 45587c478bd9Sstevel@tonic-gate char isabuf[257]; /* from sysinfo(2) manpage */ 45597c478bd9Sstevel@tonic-gate 45607c478bd9Sstevel@tonic-gate if (amd64 != -1) 45617c478bd9Sstevel@tonic-gate return (amd64); 45627c478bd9Sstevel@tonic-gate 45637c478bd9Sstevel@tonic-gate if (sysinfo(SI_ISALIST, isabuf, sizeof (isabuf)) > 0 && 45647c478bd9Sstevel@tonic-gate strncmp(isabuf, "amd64 ", strlen("amd64 ")) == 0) 45657c478bd9Sstevel@tonic-gate amd64 = 1; 45667c478bd9Sstevel@tonic-gate else if (strstr(isabuf, "i386") == NULL) 45677c478bd9Sstevel@tonic-gate amd64 = 1; /* diskless server */ 45687c478bd9Sstevel@tonic-gate else 45697c478bd9Sstevel@tonic-gate amd64 = 0; 45707c478bd9Sstevel@tonic-gate 45717c478bd9Sstevel@tonic-gate return (amd64); 45727c478bd9Sstevel@tonic-gate } 45737c478bd9Sstevel@tonic-gate 4574*986fd29aSsetje static int 4575*986fd29aSsetje is_sun4u(void) 4576*986fd29aSsetje { 4577*986fd29aSsetje static int sun4u = 0; 4578*986fd29aSsetje char mbuf[257]; /* from sysinfo(2) manpage */ 4579*986fd29aSsetje 4580*986fd29aSsetje if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0 && 4581*986fd29aSsetje strncmp(mbuf, "sun4u", strlen("sun4u")) == 0) 4582*986fd29aSsetje sun4u = 1; 4583*986fd29aSsetje 4584*986fd29aSsetje return (sun4u); 4585*986fd29aSsetje } 4586*986fd29aSsetje 4587*986fd29aSsetje static int 4588*986fd29aSsetje is_sun4v(void) 4589*986fd29aSsetje { 4590*986fd29aSsetje static int sun4v = 0; 4591*986fd29aSsetje char mbuf[257]; /* from sysinfo(2) manpage */ 4592*986fd29aSsetje 4593*986fd29aSsetje if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0 && 4594*986fd29aSsetje strncmp(mbuf, "sun4v", strlen("sun4v")) == 0) 4595*986fd29aSsetje sun4v = 1; 4596*986fd29aSsetje 4597*986fd29aSsetje return (sun4v); 4598*986fd29aSsetje } 4599*986fd29aSsetje 4600*986fd29aSsetje 46017c478bd9Sstevel@tonic-gate static void 46027c478bd9Sstevel@tonic-gate append_to_flist(filelist_t *flistp, char *s) 46037c478bd9Sstevel@tonic-gate { 46047c478bd9Sstevel@tonic-gate line_t *lp; 46057c478bd9Sstevel@tonic-gate 46067c478bd9Sstevel@tonic-gate lp = s_calloc(1, sizeof (line_t)); 46077c478bd9Sstevel@tonic-gate lp->line = s_strdup(s); 46087c478bd9Sstevel@tonic-gate if (flistp->head == NULL) 46097c478bd9Sstevel@tonic-gate flistp->head = lp; 46107c478bd9Sstevel@tonic-gate else 46117c478bd9Sstevel@tonic-gate flistp->tail->next = lp; 46127c478bd9Sstevel@tonic-gate flistp->tail = lp; 46137c478bd9Sstevel@tonic-gate } 46142449e17fSsherrym 4615*986fd29aSsetje #if !defined(_OPB) 46162449e17fSsherrym 46172449e17fSsherrym UCODE_VENDORS; 46182449e17fSsherrym 46192449e17fSsherrym /*ARGSUSED*/ 46202449e17fSsherrym static void 46212449e17fSsherrym ucode_install(char *root) 46222449e17fSsherrym { 46232449e17fSsherrym int i; 46242449e17fSsherrym 46252449e17fSsherrym for (i = 0; ucode_vendors[i].filestr != NULL; i++) { 46262449e17fSsherrym int cmd_len = PATH_MAX + 256; 46272449e17fSsherrym char cmd[PATH_MAX + 256]; 46282449e17fSsherrym char file[PATH_MAX]; 46292449e17fSsherrym char timestamp[PATH_MAX]; 46302449e17fSsherrym struct stat fstatus, tstatus; 46312449e17fSsherrym struct utimbuf u_times; 46322449e17fSsherrym 46332449e17fSsherrym (void) snprintf(file, PATH_MAX, "%s/%s/%s-ucode.txt", 46342449e17fSsherrym bam_root, UCODE_INSTALL_PATH, ucode_vendors[i].filestr); 46352449e17fSsherrym 46362449e17fSsherrym if (stat(file, &fstatus) != 0 || !(S_ISREG(fstatus.st_mode))) 46372449e17fSsherrym continue; 46382449e17fSsherrym 46392449e17fSsherrym (void) snprintf(timestamp, PATH_MAX, "%s.ts", file); 46402449e17fSsherrym 46412449e17fSsherrym if (stat(timestamp, &tstatus) == 0 && 46422449e17fSsherrym fstatus.st_mtime <= tstatus.st_mtime) 46432449e17fSsherrym continue; 46442449e17fSsherrym 46452449e17fSsherrym (void) snprintf(cmd, cmd_len, "/usr/sbin/ucodeadm -i -R " 46462449e17fSsherrym "%s/%s/%s %s > /dev/null 2>&1", bam_root, 46472449e17fSsherrym UCODE_INSTALL_PATH, ucode_vendors[i].vendorstr, file); 46482449e17fSsherrym if (system(cmd) != 0) 46492449e17fSsherrym return; 46502449e17fSsherrym 46512449e17fSsherrym if (creat(timestamp, S_IRUSR | S_IWUSR) == -1) 46522449e17fSsherrym return; 46532449e17fSsherrym 46542449e17fSsherrym u_times.actime = fstatus.st_atime; 46552449e17fSsherrym u_times.modtime = fstatus.st_mtime; 46562449e17fSsherrym (void) utime(timestamp, &u_times); 46572449e17fSsherrym } 46582449e17fSsherrym } 46592449e17fSsherrym #endif 4660