xref: /titanic_52/usr/src/cmd/boot/bootadm/bootadm.c (revision d5cb36d3c7216aae8e4ce9e18de69236501cdec7)
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 /*
22eff168e0SEnrico Perla - Sun Microsystems  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*
277c478bd9Sstevel@tonic-gate  * bootadm(1M) is a new utility for managing bootability of
287c478bd9Sstevel@tonic-gate  * Solaris *Newboot* environments. It has two primary tasks:
297c478bd9Sstevel@tonic-gate  * 	- Allow end users to manage bootability of Newboot Solaris instances
307c478bd9Sstevel@tonic-gate  *	- Provide services to other subsystems in Solaris (primarily Install)
317c478bd9Sstevel@tonic-gate  */
327c478bd9Sstevel@tonic-gate 
337c478bd9Sstevel@tonic-gate /* Headers */
347c478bd9Sstevel@tonic-gate #include <stdio.h>
357c478bd9Sstevel@tonic-gate #include <errno.h>
367c478bd9Sstevel@tonic-gate #include <stdlib.h>
377c478bd9Sstevel@tonic-gate #include <string.h>
387c478bd9Sstevel@tonic-gate #include <unistd.h>
397c478bd9Sstevel@tonic-gate #include <sys/types.h>
407c478bd9Sstevel@tonic-gate #include <sys/stat.h>
4144da779fSWilliam Kucharski #include <alloca.h>
427c478bd9Sstevel@tonic-gate #include <stdarg.h>
437c478bd9Sstevel@tonic-gate #include <limits.h>
447c478bd9Sstevel@tonic-gate #include <signal.h>
457c478bd9Sstevel@tonic-gate #include <sys/wait.h>
467c478bd9Sstevel@tonic-gate #include <sys/mnttab.h>
47f904d32dSJerry Gilliam #include <sys/mntent.h>
487c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
497c478bd9Sstevel@tonic-gate #include <libnvpair.h>
507c478bd9Sstevel@tonic-gate #include <ftw.h>
517c478bd9Sstevel@tonic-gate #include <fcntl.h>
527c478bd9Sstevel@tonic-gate #include <strings.h>
532449e17fSsherrym #include <utime.h>
547c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h>
557c478bd9Sstevel@tonic-gate #include <sys/dktp/fdisk.h>
5658091fd8Ssetje #include <sys/param.h>
57eb2bd662Svikram #include <dirent.h>
58eb2bd662Svikram #include <ctype.h>
59eb2bd662Svikram #include <libgen.h>
60e7cbe64fSgw25295 #include <sys/sysmacros.h>
6148847494SEnrico Perla - Sun Microsystems #include <sys/elf.h>
62963390b4Svikram #include <libscf.h>
6348847494SEnrico Perla - Sun Microsystems #include <zlib.h>
6448847494SEnrico Perla - Sun Microsystems #include <sys/lockfs.h>
6548847494SEnrico Perla - Sun Microsystems #include <sys/filio.h>
66e998e519SSheshadri Vasudevan #ifdef i386
67e998e519SSheshadri Vasudevan #include <libfdisk.h>
68e998e519SSheshadri Vasudevan #endif
69986fd29aSsetje 
70986fd29aSsetje #if !defined(_OPB)
712449e17fSsherrym #include <sys/ucode.h>
722449e17fSsherrym #endif
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate #include <pwd.h>
757c478bd9Sstevel@tonic-gate #include <grp.h>
767c478bd9Sstevel@tonic-gate #include <device_info.h>
77eb2bd662Svikram #include <sys/vtoc.h>
78eb2bd662Svikram #include <sys/efi_partition.h>
7989c3ee43SGangadhar Mylapuram #include <regex.h>
807c478bd9Sstevel@tonic-gate #include <locale.h>
817c478bd9Sstevel@tonic-gate 
827c478bd9Sstevel@tonic-gate #include "message.h"
83ae115bc7Smrj #include "bootadm.h"
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN
867c478bd9Sstevel@tonic-gate #define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
877c478bd9Sstevel@tonic-gate #endif	/* TEXT_DOMAIN */
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate /* Type definitions */
907c478bd9Sstevel@tonic-gate 
917c478bd9Sstevel@tonic-gate /* Primary subcmds */
927c478bd9Sstevel@tonic-gate typedef enum {
937c478bd9Sstevel@tonic-gate 	BAM_MENU = 3,
947c478bd9Sstevel@tonic-gate 	BAM_ARCHIVE
957c478bd9Sstevel@tonic-gate } subcmd_t;
967c478bd9Sstevel@tonic-gate 
977c478bd9Sstevel@tonic-gate typedef enum {
987c478bd9Sstevel@tonic-gate     OPT_ABSENT = 0,	/* No option */
997c478bd9Sstevel@tonic-gate     OPT_REQ,		/* option required */
1007c478bd9Sstevel@tonic-gate     OPT_OPTIONAL	/* option may or may not be present */
1017c478bd9Sstevel@tonic-gate } option_t;
1027c478bd9Sstevel@tonic-gate 
1037c478bd9Sstevel@tonic-gate typedef struct {
1047c478bd9Sstevel@tonic-gate 	char	*subcmd;
1057c478bd9Sstevel@tonic-gate 	option_t option;
1067c478bd9Sstevel@tonic-gate 	error_t (*handler)();
1071a97e40eSvikram 	int	unpriv;			/* is this an unprivileged command */
1087c478bd9Sstevel@tonic-gate } subcmd_defn_t;
1097c478bd9Sstevel@tonic-gate 
1107c478bd9Sstevel@tonic-gate #define	LINE_INIT	0	/* lineNum initial value */
1117c478bd9Sstevel@tonic-gate #define	ENTRY_INIT	-1	/* entryNum initial value */
1127c478bd9Sstevel@tonic-gate #define	ALL_ENTRIES	-2	/* selects all boot entries */
1137c478bd9Sstevel@tonic-gate 
1147c478bd9Sstevel@tonic-gate #define	GRUB_DIR		"/boot/grub"
115963390b4Svikram #define	GRUB_STAGE2		GRUB_DIR "/stage2"
1167c478bd9Sstevel@tonic-gate #define	GRUB_MENU		"/boot/grub/menu.lst"
1177c478bd9Sstevel@tonic-gate #define	MENU_TMP		"/boot/grub/menu.lst.tmp"
118963390b4Svikram #define	GRUB_BACKUP_MENU	"/etc/lu/GRUB_backup_menu"
1197c478bd9Sstevel@tonic-gate #define	RAMDISK_SPECIAL		"/ramdisk"
12040541d5dSvikram #define	STUBBOOT		"/stubboot"
121eb2bd662Svikram #define	MULTIBOOT		"/platform/i86pc/multiboot"
122eb2bd662Svikram #define	GRUBSIGN_DIR		"/boot/grub/bootsign"
123eb2bd662Svikram #define	GRUBSIGN_BACKUP		"/etc/bootsign"
124eb2bd662Svikram #define	GRUBSIGN_UFS_PREFIX	"rootfs"
125eb2bd662Svikram #define	GRUBSIGN_ZFS_PREFIX	"pool_"
126eb2bd662Svikram #define	GRUBSIGN_LU_PREFIX	"BE_"
127eb2bd662Svikram #define	UFS_SIGNATURE_LIST	"/var/run/grub_ufs_signatures"
128eb2bd662Svikram #define	ZFS_LEGACY_MNTPT	"/tmp/bootadm_mnt_zfs_legacy"
129eb2bd662Svikram 
130eb2bd662Svikram #define	BOOTADM_RDONLY_TEST	"BOOTADM_RDONLY_TEST"
1317c478bd9Sstevel@tonic-gate 
1327c478bd9Sstevel@tonic-gate /* lock related */
1337c478bd9Sstevel@tonic-gate #define	BAM_LOCK_FILE		"/var/run/bootadm.lock"
1347c478bd9Sstevel@tonic-gate #define	LOCK_FILE_PERMS		(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)
1357c478bd9Sstevel@tonic-gate 
136986fd29aSsetje #define	CREATE_RAMDISK		"boot/solaris/bin/create_ramdisk"
137986fd29aSsetje #define	CREATE_DISKMAP		"boot/solaris/bin/create_diskmap"
138986fd29aSsetje #define	EXTRACT_BOOT_FILELIST	"boot/solaris/bin/extract_boot_filelist"
1397c478bd9Sstevel@tonic-gate #define	GRUBDISK_MAP		"/var/run/solaris_grubdisk.map"
1407c478bd9Sstevel@tonic-gate 
141b610f78eSvikram #define	GRUB_slice		"/etc/lu/GRUB_slice"
142b610f78eSvikram #define	GRUB_root		"/etc/lu/GRUB_root"
143fbac2b2bSvikram #define	GRUB_fdisk		"/etc/lu/GRUB_fdisk"
144fbac2b2bSvikram #define	GRUB_fdisk_target	"/etc/lu/GRUB_fdisk_target"
145963390b4Svikram #define	FINDROOT_INSTALLGRUB	"/etc/lu/installgrub.findroot"
146963390b4Svikram #define	LULIB			"/usr/lib/lu/lulib"
147963390b4Svikram #define	LULIB_PROPAGATE_FILE	"lulib_propagate_file"
148963390b4Svikram #define	CKSUM			"/usr/bin/cksum"
149963390b4Svikram #define	LU_MENU_CKSUM		"/etc/lu/menu.cksum"
150963390b4Svikram #define	BOOTADM			"/sbin/bootadm"
151b610f78eSvikram 
152b610f78eSvikram #define	INSTALLGRUB		"/sbin/installgrub"
153b610f78eSvikram #define	STAGE1			"/boot/grub/stage1"
154b610f78eSvikram #define	STAGE2			"/boot/grub/stage2"
155b610f78eSvikram 
156eb2bd662Svikram typedef enum zfs_mnted {
157eb2bd662Svikram 	ZFS_MNT_ERROR = -1,
158eb2bd662Svikram 	LEGACY_MOUNTED = 1,
159eb2bd662Svikram 	LEGACY_ALREADY,
160eb2bd662Svikram 	ZFS_MOUNTED,
161eb2bd662Svikram 	ZFS_ALREADY
162eb2bd662Svikram } zfs_mnted_t;
163eb2bd662Svikram 
1647c478bd9Sstevel@tonic-gate /*
16598892a30Snadkarni  * The following two defines are used to detect and create the correct
16698892a30Snadkarni  * boot archive  when safemode patching is underway.  LOFS_PATCH_FILE is a
16798892a30Snadkarni  * contracted private interface between bootadm and the install
16898892a30Snadkarni  * consolidation.  It is set by pdo.c when a patch with SUNW_PATCH_SAFEMODE
16998892a30Snadkarni  * is applied.
17098892a30Snadkarni  */
17198892a30Snadkarni #define	LOFS_PATCH_FILE		"/var/run/.patch_loopback_mode"
17298892a30Snadkarni #define	LOFS_PATCH_MNT		"/var/run/.patch_root_loopbackmnt"
17398892a30Snadkarni 
17498892a30Snadkarni /*
1757c478bd9Sstevel@tonic-gate  * Default file attributes
1767c478bd9Sstevel@tonic-gate  */
1777c478bd9Sstevel@tonic-gate #define	DEFAULT_DEV_MODE	0644	/* default permissions */
1787c478bd9Sstevel@tonic-gate #define	DEFAULT_DEV_UID		0	/* user root */
1797c478bd9Sstevel@tonic-gate #define	DEFAULT_DEV_GID		3	/* group sys */
1807c478bd9Sstevel@tonic-gate 
1817c478bd9Sstevel@tonic-gate /*
1827c478bd9Sstevel@tonic-gate  * Menu related
1837c478bd9Sstevel@tonic-gate  * menu_cmd_t and menu_cmds must be kept in sync
1847c478bd9Sstevel@tonic-gate  */
185ae115bc7Smrj char *menu_cmds[] = {
1867c478bd9Sstevel@tonic-gate 	"default",	/* DEFAULT_CMD */
1877c478bd9Sstevel@tonic-gate 	"timeout",	/* TIMEOUT_CMD */
1887c478bd9Sstevel@tonic-gate 	"title",	/* TITLE_CMD */
1897c478bd9Sstevel@tonic-gate 	"root",		/* ROOT_CMD */
1907c478bd9Sstevel@tonic-gate 	"kernel",	/* KERNEL_CMD */
191ae115bc7Smrj 	"kernel$",	/* KERNEL_DOLLAR_CMD */
1927c478bd9Sstevel@tonic-gate 	"module",	/* MODULE_CMD */
193ae115bc7Smrj 	"module$",	/* MODULE_DOLLAR_CMD */
1947c478bd9Sstevel@tonic-gate 	" ",		/* SEP_CMD */
1957c478bd9Sstevel@tonic-gate 	"#",		/* COMMENT_CMD */
196ae115bc7Smrj 	"chainloader",	/* CHAINLOADER_CMD */
197ae115bc7Smrj 	"args",		/* ARGS_CMD */
198eb2bd662Svikram 	"findroot",	/* FINDROOT_CMD */
19944da779fSWilliam Kucharski 	"bootfs",	/* BOOTFS_CMD */
2007c478bd9Sstevel@tonic-gate 	NULL
2017c478bd9Sstevel@tonic-gate };
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate #define	OPT_ENTRY_NUM	"entry"
2047c478bd9Sstevel@tonic-gate 
2057c478bd9Sstevel@tonic-gate /*
206eb2bd662Svikram  * exec_cmd related
2077c478bd9Sstevel@tonic-gate  */
2087c478bd9Sstevel@tonic-gate typedef struct {
2097c478bd9Sstevel@tonic-gate 	line_t *head;
2107c478bd9Sstevel@tonic-gate 	line_t *tail;
2117c478bd9Sstevel@tonic-gate } filelist_t;
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate #define	BOOT_FILE_LIST	"boot/solaris/filelist.ramdisk"
2147c478bd9Sstevel@tonic-gate #define	ETC_FILE_LIST	"etc/boot/solaris/filelist.ramdisk"
2157c478bd9Sstevel@tonic-gate 
2167c478bd9Sstevel@tonic-gate #define	FILE_STAT	"boot/solaris/filestat.ramdisk"
2177c478bd9Sstevel@tonic-gate #define	FILE_STAT_TMP	"boot/solaris/filestat.ramdisk.tmp"
2187c478bd9Sstevel@tonic-gate #define	DIR_PERMS	(S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
2197c478bd9Sstevel@tonic-gate #define	FILE_STAT_MODE	(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)
2207c478bd9Sstevel@tonic-gate 
2214a9df875SEnrico Perla - Sun Microsystems #define	FILE_STAT_TIMESTAMP	"boot/solaris/timestamp.cache"
2224a9df875SEnrico Perla - Sun Microsystems 
2237c478bd9Sstevel@tonic-gate /* Globals */
224ae115bc7Smrj int bam_verbose;
225ae115bc7Smrj int bam_force;
226eb2bd662Svikram int bam_debug;
2277c478bd9Sstevel@tonic-gate static char *prog;
2287c478bd9Sstevel@tonic-gate static subcmd_t bam_cmd;
2297c478bd9Sstevel@tonic-gate static char *bam_root;
2307c478bd9Sstevel@tonic-gate static int bam_rootlen;
2317c478bd9Sstevel@tonic-gate static int bam_root_readonly;
23240541d5dSvikram static int bam_alt_root;
23348847494SEnrico Perla - Sun Microsystems static int bam_extend = 0;
23448847494SEnrico Perla - Sun Microsystems static int bam_purge = 0;
2357c478bd9Sstevel@tonic-gate static char *bam_subcmd;
2367c478bd9Sstevel@tonic-gate static char *bam_opt;
2377c478bd9Sstevel@tonic-gate static char **bam_argv;
2387c478bd9Sstevel@tonic-gate static int bam_argc;
2397c478bd9Sstevel@tonic-gate static int bam_check;
2405eea6091SEnrico Perla - Sun Microsystems static int bam_saved_check;
2417c478bd9Sstevel@tonic-gate static int bam_smf_check;
2427c478bd9Sstevel@tonic-gate static int bam_lock_fd = -1;
243e7cbe64fSgw25295 static int bam_zfs;
2447c478bd9Sstevel@tonic-gate static char rootbuf[PATH_MAX] = "/";
245b610f78eSvikram static int bam_update_all;
246d876c67dSjg static int bam_alt_platform;
247d876c67dSjg static char *bam_platform;
248cedc7e57SEnrico Perla - Sun Microsystems static char *bam_home_env = NULL;
2497c478bd9Sstevel@tonic-gate 
2507c478bd9Sstevel@tonic-gate /* function prototypes */
251986fd29aSsetje static void parse_args_internal(int, char *[]);
252986fd29aSsetje static void parse_args(int, char *argv[]);
253986fd29aSsetje static error_t bam_menu(char *, char *, int, char *[]);
254986fd29aSsetje static error_t bam_archive(char *, char *);
2557c478bd9Sstevel@tonic-gate 
2567c478bd9Sstevel@tonic-gate static void bam_lock(void);
2577c478bd9Sstevel@tonic-gate static void bam_unlock(void);
2587c478bd9Sstevel@tonic-gate 
259986fd29aSsetje static int exec_cmd(char *, filelist_t *);
260986fd29aSsetje static error_t read_globals(menu_t *, char *, char *, int);
261eb2bd662Svikram static int menu_on_bootdisk(char *os_root, char *menu_root);
262986fd29aSsetje static menu_t *menu_read(char *);
263986fd29aSsetje static error_t menu_write(char *, menu_t *);
264986fd29aSsetje static void linelist_free(line_t *);
265986fd29aSsetje static void menu_free(menu_t *);
266986fd29aSsetje static void filelist_free(filelist_t *);
267986fd29aSsetje static error_t list2file(char *, char *, char *, line_t *);
268986fd29aSsetje static error_t list_entry(menu_t *, char *, char *);
26944da779fSWilliam Kucharski static error_t list_setting(menu_t *, char *, char *);
270986fd29aSsetje static error_t delete_all_entries(menu_t *, char *, char *);
271eb2bd662Svikram static error_t update_entry(menu_t *mp, char *menu_root, char *opt);
272eb2bd662Svikram static error_t update_temp(menu_t *mp, char *dummy, char *opt);
2737c478bd9Sstevel@tonic-gate 
274986fd29aSsetje static error_t update_archive(char *, char *);
275986fd29aSsetje static error_t list_archive(char *, char *);
276986fd29aSsetje static error_t update_all(char *, char *);
277986fd29aSsetje static error_t read_list(char *, filelist_t *);
278986fd29aSsetje static error_t set_option(menu_t *, char *, char *);
279986fd29aSsetje static error_t set_kernel(menu_t *, menu_cmd_t, char *, char *, size_t);
280eb2bd662Svikram static error_t get_kernel(menu_t *, menu_cmd_t, char *, size_t);
281986fd29aSsetje static char *expand_path(const char *);
2827c478bd9Sstevel@tonic-gate 
283986fd29aSsetje static long s_strtol(char *);
284986fd29aSsetje static int s_fputs(char *, FILE *);
2857c478bd9Sstevel@tonic-gate 
286eb2bd662Svikram static int is_zfs(char *root);
287eb2bd662Svikram static int is_ufs(char *root);
288eb2bd662Svikram static int is_pcfs(char *root);
2897c478bd9Sstevel@tonic-gate static int is_amd64(void);
29079755401Ssetje static char *get_machine(void);
2917c478bd9Sstevel@tonic-gate static void append_to_flist(filelist_t *, char *);
292eb2bd662Svikram static char *mount_top_dataset(char *pool, zfs_mnted_t *mnted);
293eb2bd662Svikram static int umount_top_dataset(char *pool, zfs_mnted_t mnted, char *mntpt);
294eb2bd662Svikram static int ufs_add_to_sign_list(char *sign);
295963390b4Svikram static error_t synchronize_BE_menu(void);
2967c478bd9Sstevel@tonic-gate 
297986fd29aSsetje #if !defined(_OPB)
2982449e17fSsherrym static void ucode_install();
2992449e17fSsherrym #endif
3002449e17fSsherrym 
3017c478bd9Sstevel@tonic-gate /* Menu related sub commands */
3027c478bd9Sstevel@tonic-gate static subcmd_defn_t menu_subcmds[] = {
303eb2bd662Svikram 	"set_option",		OPT_ABSENT,	set_option, 0,	/* PUB */
3041a97e40eSvikram 	"list_entry",		OPT_OPTIONAL,	list_entry, 1,	/* PUB */
3051a97e40eSvikram 	"delete_all_entries",	OPT_ABSENT,	delete_all_entries, 0, /* PVT */
3061a97e40eSvikram 	"update_entry",		OPT_REQ,	update_entry, 0, /* menu */
3071a97e40eSvikram 	"update_temp",		OPT_OPTIONAL,	update_temp, 0,	/* reboot */
308ae115bc7Smrj 	"upgrade",		OPT_ABSENT,	upgrade_menu, 0, /* menu */
30944da779fSWilliam Kucharski 	"list_setting",		OPT_OPTIONAL,	list_setting, 1, /* menu */
31044da779fSWilliam Kucharski 	"disable_hypervisor",	OPT_ABSENT,	cvt_to_metal, 0, /* menu */
31144da779fSWilliam Kucharski 	"enable_hypervisor",	OPT_ABSENT,	cvt_to_hyper, 0, /* menu */
3121a97e40eSvikram 	NULL,			0,		NULL, 0	/* must be last */
3137c478bd9Sstevel@tonic-gate };
3147c478bd9Sstevel@tonic-gate 
3157c478bd9Sstevel@tonic-gate /* Archive related sub commands */
3167c478bd9Sstevel@tonic-gate static subcmd_defn_t arch_subcmds[] = {
3171a97e40eSvikram 	"update",		OPT_ABSENT,	update_archive, 0, /* PUB */
3181a97e40eSvikram 	"update_all",		OPT_ABSENT,	update_all, 0,	/* PVT */
3191a97e40eSvikram 	"list",			OPT_OPTIONAL,	list_archive, 1, /* PUB */
3201a97e40eSvikram 	NULL,			0,		NULL, 0	/* must be last */
3217c478bd9Sstevel@tonic-gate };
3227c478bd9Sstevel@tonic-gate 
32348847494SEnrico Perla - Sun Microsystems enum dircache_copy_opt {
32448847494SEnrico Perla - Sun Microsystems 	FILE32 = 0,
32548847494SEnrico Perla - Sun Microsystems 	FILE64,
32648847494SEnrico Perla - Sun Microsystems 	CACHEDIR_NUM
32748847494SEnrico Perla - Sun Microsystems };
32848847494SEnrico Perla - Sun Microsystems 
32948847494SEnrico Perla - Sun Microsystems /*
33048847494SEnrico Perla - Sun Microsystems  * Directory specific flags:
33148847494SEnrico Perla - Sun Microsystems  * NEED_UPDATE : the specified archive needs to be updated
33248847494SEnrico Perla - Sun Microsystems  * NO_MULTI : don't extend the specified archive, but recreate it
33348847494SEnrico Perla - Sun Microsystems  */
33448847494SEnrico Perla - Sun Microsystems #define	NEED_UPDATE		0x00000001
33548847494SEnrico Perla - Sun Microsystems #define	NO_MULTI		0x00000002
33648847494SEnrico Perla - Sun Microsystems 
33748847494SEnrico Perla - Sun Microsystems #define	set_dir_flag(id, f)	(walk_arg.dirinfo[id].flags |= f)
33848847494SEnrico Perla - Sun Microsystems #define	unset_dir_flag(id, f)	(walk_arg.dirinfo[id].flags &= ~f)
33948847494SEnrico Perla - Sun Microsystems #define	is_dir_flag_on(id, f)	(walk_arg.dirinfo[id].flags & f ? 1 : 0)
34048847494SEnrico Perla - Sun Microsystems 
34148847494SEnrico Perla - Sun Microsystems #define	get_cachedir(id)	(walk_arg.dirinfo[id].cdir_path)
34248847494SEnrico Perla - Sun Microsystems #define	get_updatedir(id)	(walk_arg.dirinfo[id].update_path)
34348847494SEnrico Perla - Sun Microsystems #define	get_count(id)		(walk_arg.dirinfo[id].count)
34448847494SEnrico Perla - Sun Microsystems #define	has_cachedir(id)	(walk_arg.dirinfo[id].has_dir)
34548847494SEnrico Perla - Sun Microsystems #define	set_dir_present(id)	(walk_arg.dirinfo[id].has_dir = 1)
34648847494SEnrico Perla - Sun Microsystems 
34748847494SEnrico Perla - Sun Microsystems /*
34848847494SEnrico Perla - Sun Microsystems  * dirinfo_t (specific cache directory information):
34948847494SEnrico Perla - Sun Microsystems  * cdir_path:   path to the archive cache directory
35048847494SEnrico Perla - Sun Microsystems  * update_path: path to the update directory (contains the files that will be
35148847494SEnrico Perla - Sun Microsystems  *              used to extend the archive)
35248847494SEnrico Perla - Sun Microsystems  * has_dir:	the specified cache directory is active
35348847494SEnrico Perla - Sun Microsystems  * count:	the number of files to update
35448847494SEnrico Perla - Sun Microsystems  * flags:	directory specific flags
35548847494SEnrico Perla - Sun Microsystems  */
35648847494SEnrico Perla - Sun Microsystems typedef struct _dirinfo {
35748847494SEnrico Perla - Sun Microsystems 	char	cdir_path[PATH_MAX];
35848847494SEnrico Perla - Sun Microsystems 	char	update_path[PATH_MAX];
35948847494SEnrico Perla - Sun Microsystems 	int	has_dir;
36048847494SEnrico Perla - Sun Microsystems 	int	count;
36148847494SEnrico Perla - Sun Microsystems 	int	flags;
36248847494SEnrico Perla - Sun Microsystems } dirinfo_t;
36348847494SEnrico Perla - Sun Microsystems 
36448847494SEnrico Perla - Sun Microsystems /*
36548847494SEnrico Perla - Sun Microsystems  * Update flags:
36648847494SEnrico Perla - Sun Microsystems  * NEED_CACHE_DIR : cache directory is missing and needs to be created
36748847494SEnrico Perla - Sun Microsystems  * IS_SPARC_TARGET : the target mountpoint is a SPARC environment
36848847494SEnrico Perla - Sun Microsystems  * UPDATE_ERROR : an error occourred while traversing the list of files
36948847494SEnrico Perla - Sun Microsystems  * RDONLY_FSCHK : the target filesystem is read-only
37048847494SEnrico Perla - Sun Microsystems  * RAMDSK_FSCHK : the target filesystem is on a ramdisk
37148847494SEnrico Perla - Sun Microsystems  */
37248847494SEnrico Perla - Sun Microsystems #define	NEED_CACHE_DIR		0x00000001
37348847494SEnrico Perla - Sun Microsystems #define	IS_SPARC_TARGET		0x00000002
37448847494SEnrico Perla - Sun Microsystems #define	UPDATE_ERROR		0x00000004
37548847494SEnrico Perla - Sun Microsystems #define	RDONLY_FSCHK		0x00000008
3764a9df875SEnrico Perla - Sun Microsystems #define	INVALIDATE_CACHE	0x00000010
37748847494SEnrico Perla - Sun Microsystems 
37848847494SEnrico Perla - Sun Microsystems #define	is_flag_on(flag)	(walk_arg.update_flags & flag ? 1 : 0)
37948847494SEnrico Perla - Sun Microsystems #define	set_flag(flag)		(walk_arg.update_flags |= flag)
38048847494SEnrico Perla - Sun Microsystems #define	unset_flag(flag)	(walk_arg.update_flags &= ~flag)
38148847494SEnrico Perla - Sun Microsystems 
38248847494SEnrico Perla - Sun Microsystems /*
38348847494SEnrico Perla - Sun Microsystems  * struct walk_arg :
38448847494SEnrico Perla - Sun Microsystems  * update_flags: flags related to the current updating process
38548847494SEnrico Perla - Sun Microsystems  * new_nvlp/old_nvlp: new and old list of archive-files / attributes pairs
38648847494SEnrico Perla - Sun Microsystems  * sparcfile: list of file paths for mkisofs -path-list (SPARC only)
38748847494SEnrico Perla - Sun Microsystems  */
3887c478bd9Sstevel@tonic-gate static struct {
38948847494SEnrico Perla - Sun Microsystems 	int 		update_flags;
3907c478bd9Sstevel@tonic-gate 	nvlist_t 	*new_nvlp;
3917c478bd9Sstevel@tonic-gate 	nvlist_t 	*old_nvlp;
39248847494SEnrico Perla - Sun Microsystems 	FILE 		*sparcfile;
39348847494SEnrico Perla - Sun Microsystems 	dirinfo_t	dirinfo[CACHEDIR_NUM];
3947c478bd9Sstevel@tonic-gate } walk_arg;
3957c478bd9Sstevel@tonic-gate 
3969632cfadSsetje struct safefile {
39758091fd8Ssetje 	char *name;
39858091fd8Ssetje 	struct safefile *next;
39958091fd8Ssetje };
40058091fd8Ssetje 
401ae115bc7Smrj static struct safefile *safefiles = NULL;
40258091fd8Ssetje #define	NEED_UPDATE_FILE "/etc/svc/volatile/boot_archive_needs_update"
40358091fd8Ssetje 
40448847494SEnrico Perla - Sun Microsystems /* Thanks growisofs */
40548847494SEnrico Perla - Sun Microsystems #define	CD_BLOCK	((off64_t)2048)
40648847494SEnrico Perla - Sun Microsystems #define	VOLDESC_OFF	16
40748847494SEnrico Perla - Sun Microsystems #define	DVD_BLOCK	(32*1024)
40848847494SEnrico Perla - Sun Microsystems #define	MAX_IVDs	16
40948847494SEnrico Perla - Sun Microsystems 
41048847494SEnrico Perla - Sun Microsystems struct iso_pdesc {
41148847494SEnrico Perla - Sun Microsystems     unsigned char type	[1];
41248847494SEnrico Perla - Sun Microsystems     unsigned char id	[5];
41348847494SEnrico Perla - Sun Microsystems     unsigned char void1	[80-5-1];
41448847494SEnrico Perla - Sun Microsystems     unsigned char volume_space_size [8];
41548847494SEnrico Perla - Sun Microsystems     unsigned char void2	[2048-80-8];
41648847494SEnrico Perla - Sun Microsystems };
41748847494SEnrico Perla - Sun Microsystems 
41848847494SEnrico Perla - Sun Microsystems /*
41948847494SEnrico Perla - Sun Microsystems  * COUNT_MAX:	maximum number of changed files to justify a multisession update
42048847494SEnrico Perla - Sun Microsystems  * BA_SIZE_MAX:	maximum size of the boot_archive to justify a multisession
42148847494SEnrico Perla - Sun Microsystems  * 		update
42248847494SEnrico Perla - Sun Microsystems  */
42348847494SEnrico Perla - Sun Microsystems #define	COUNT_MAX		50
42448847494SEnrico Perla - Sun Microsystems #define	BA_SIZE_MAX		(50 * 1024 * 1024)
42548847494SEnrico Perla - Sun Microsystems 
42648847494SEnrico Perla - Sun Microsystems #define	bam_nowrite()		(bam_check || bam_smf_check)
42748847494SEnrico Perla - Sun Microsystems 
42819397407SSherry Moore static int sync_menu = 1;	/* whether we need to sync the BE menus */
42919397407SSherry Moore 
4307c478bd9Sstevel@tonic-gate static void
4317c478bd9Sstevel@tonic-gate usage(void)
4327c478bd9Sstevel@tonic-gate {
4337c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr, "USAGE:\n");
4347c478bd9Sstevel@tonic-gate 
4357c478bd9Sstevel@tonic-gate 	/* archive usage */
436d876c67dSjg 	(void) fprintf(stderr,
437d876c67dSjg 	    "\t%s update-archive [-vn] [-R altroot [-p platform>]]\n", prog);
438d876c67dSjg 	(void) fprintf(stderr,
439d876c67dSjg 	    "\t%s list-archive [-R altroot [-p platform>]]\n", prog);
440986fd29aSsetje #if !defined(_OPB)
4417c478bd9Sstevel@tonic-gate 	/* x86 only */
4427c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr, "\t%s set-menu [-R altroot] key=value\n", prog);
4437c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr, "\t%s list-menu [-R altroot]\n", prog);
4447c478bd9Sstevel@tonic-gate #endif
4457c478bd9Sstevel@tonic-gate }
4467c478bd9Sstevel@tonic-gate 
447cedc7e57SEnrico Perla - Sun Microsystems /*
448cedc7e57SEnrico Perla - Sun Microsystems  * Best effort attempt to restore the $HOME value.
449cedc7e57SEnrico Perla - Sun Microsystems  */
450cedc7e57SEnrico Perla - Sun Microsystems static void
451cedc7e57SEnrico Perla - Sun Microsystems restore_env()
452cedc7e57SEnrico Perla - Sun Microsystems {
453cedc7e57SEnrico Perla - Sun Microsystems 	char	home_env[PATH_MAX];
454cedc7e57SEnrico Perla - Sun Microsystems 
455cedc7e57SEnrico Perla - Sun Microsystems 	if (bam_home_env) {
456cedc7e57SEnrico Perla - Sun Microsystems 		(void) snprintf(home_env, sizeof (home_env), "HOME=%s",
457cedc7e57SEnrico Perla - Sun Microsystems 		    bam_home_env);
458cedc7e57SEnrico Perla - Sun Microsystems 		(void) putenv(home_env);
459cedc7e57SEnrico Perla - Sun Microsystems 	}
460cedc7e57SEnrico Perla - Sun Microsystems }
461cedc7e57SEnrico Perla - Sun Microsystems 
462cedc7e57SEnrico Perla - Sun Microsystems 
463cedc7e57SEnrico Perla - Sun Microsystems #define		SLEEP_TIME	5
464cedc7e57SEnrico Perla - Sun Microsystems #define		MAX_TRIES	4
465cedc7e57SEnrico Perla - Sun Microsystems 
466cedc7e57SEnrico Perla - Sun Microsystems /*
467cedc7e57SEnrico Perla - Sun Microsystems  * Sanitize the environment in which bootadm will execute its sub-processes
468cedc7e57SEnrico Perla - Sun Microsystems  * (ex. mkisofs). This is done to prevent those processes from attempting
469cedc7e57SEnrico Perla - Sun Microsystems  * to access files (ex. .mkisofsrc) or stat paths that might be on NFS
470cedc7e57SEnrico Perla - Sun Microsystems  * or, potentially, insecure.
471cedc7e57SEnrico Perla - Sun Microsystems  */
472cedc7e57SEnrico Perla - Sun Microsystems static void
473cedc7e57SEnrico Perla - Sun Microsystems sanitize_env()
474cedc7e57SEnrico Perla - Sun Microsystems {
475cedc7e57SEnrico Perla - Sun Microsystems 	int	stry = 0;
476cedc7e57SEnrico Perla - Sun Microsystems 
477cedc7e57SEnrico Perla - Sun Microsystems 	/* don't depend on caller umask */
478cedc7e57SEnrico Perla - Sun Microsystems 	(void) umask(0022);
479cedc7e57SEnrico Perla - Sun Microsystems 
480cedc7e57SEnrico Perla - Sun Microsystems 	/* move away from a potential unsafe current working directory */
481cedc7e57SEnrico Perla - Sun Microsystems 	while (chdir("/") == -1) {
482cedc7e57SEnrico Perla - Sun Microsystems 		if (errno != EINTR) {
483cedc7e57SEnrico Perla - Sun Microsystems 			bam_print("WARNING: unable to chdir to /");
484cedc7e57SEnrico Perla - Sun Microsystems 			break;
485cedc7e57SEnrico Perla - Sun Microsystems 		}
486cedc7e57SEnrico Perla - Sun Microsystems 	}
487cedc7e57SEnrico Perla - Sun Microsystems 
488cedc7e57SEnrico Perla - Sun Microsystems 	bam_home_env = getenv("HOME");
489cedc7e57SEnrico Perla - Sun Microsystems 	while (bam_home_env != NULL && putenv("HOME=/") == -1) {
490cedc7e57SEnrico Perla - Sun Microsystems 		if (errno == ENOMEM) {
491cedc7e57SEnrico Perla - Sun Microsystems 			/* retry no more than MAX_TRIES times */
492cedc7e57SEnrico Perla - Sun Microsystems 			if (++stry > MAX_TRIES) {
493cedc7e57SEnrico Perla - Sun Microsystems 				bam_print("WARNING: unable to recover from "
494cedc7e57SEnrico Perla - Sun Microsystems 				    "system memory pressure... aborting \n");
495cedc7e57SEnrico Perla - Sun Microsystems 				bam_exit(EXIT_FAILURE);
496cedc7e57SEnrico Perla - Sun Microsystems 			}
497cedc7e57SEnrico Perla - Sun Microsystems 			/* memory is tight, try to sleep */
498cedc7e57SEnrico Perla - Sun Microsystems 			bam_print("Attempting to recover from memory pressure: "
499cedc7e57SEnrico Perla - Sun Microsystems 			    "sleeping for %d seconds\n", SLEEP_TIME * stry);
500cedc7e57SEnrico Perla - Sun Microsystems 			(void) sleep(SLEEP_TIME * stry);
501cedc7e57SEnrico Perla - Sun Microsystems 		} else {
502cedc7e57SEnrico Perla - Sun Microsystems 			bam_print("WARNING: unable to sanitize HOME\n");
503cedc7e57SEnrico Perla - Sun Microsystems 		}
504cedc7e57SEnrico Perla - Sun Microsystems 	}
505cedc7e57SEnrico Perla - Sun Microsystems }
506cedc7e57SEnrico Perla - Sun Microsystems 
5077c478bd9Sstevel@tonic-gate int
5087c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
5097c478bd9Sstevel@tonic-gate {
5107c478bd9Sstevel@tonic-gate 	error_t ret;
5117c478bd9Sstevel@tonic-gate 
5127c478bd9Sstevel@tonic-gate 	(void) setlocale(LC_ALL, "");
5137c478bd9Sstevel@tonic-gate 	(void) textdomain(TEXT_DOMAIN);
5147c478bd9Sstevel@tonic-gate 
5157c478bd9Sstevel@tonic-gate 	if ((prog = strrchr(argv[0], '/')) == NULL) {
5167c478bd9Sstevel@tonic-gate 		prog = argv[0];
5177c478bd9Sstevel@tonic-gate 	} else {
5187c478bd9Sstevel@tonic-gate 		prog++;
5197c478bd9Sstevel@tonic-gate 	}
5207c478bd9Sstevel@tonic-gate 
521eb2bd662Svikram 	INJECT_ERROR1("ASSERT_ON", assert(0))
5227c478bd9Sstevel@tonic-gate 
523cedc7e57SEnrico Perla - Sun Microsystems 	sanitize_env();
5247c478bd9Sstevel@tonic-gate 
5257c478bd9Sstevel@tonic-gate 	parse_args(argc, argv);
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate 	switch (bam_cmd) {
5287c478bd9Sstevel@tonic-gate 		case BAM_MENU:
5297c478bd9Sstevel@tonic-gate 			ret = bam_menu(bam_subcmd, bam_opt, bam_argc, bam_argv);
5307c478bd9Sstevel@tonic-gate 			break;
5317c478bd9Sstevel@tonic-gate 		case BAM_ARCHIVE:
5327c478bd9Sstevel@tonic-gate 			ret = bam_archive(bam_subcmd, bam_opt);
5337c478bd9Sstevel@tonic-gate 			break;
5347c478bd9Sstevel@tonic-gate 		default:
5357c478bd9Sstevel@tonic-gate 			usage();
5367c478bd9Sstevel@tonic-gate 			bam_exit(1);
5377c478bd9Sstevel@tonic-gate 	}
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate 	if (ret != BAM_SUCCESS)
54044da779fSWilliam Kucharski 		bam_exit((ret == BAM_NOCHANGE) ? 2 : 1);
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate 	bam_unlock();
5437c478bd9Sstevel@tonic-gate 	return (0);
5447c478bd9Sstevel@tonic-gate }
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate /*
5477c478bd9Sstevel@tonic-gate  * Equivalence of public and internal commands:
5487c478bd9Sstevel@tonic-gate  *	update-archive  -- -a update
5497c478bd9Sstevel@tonic-gate  *	list-archive	-- -a list
5507c478bd9Sstevel@tonic-gate  *	set-menu	-- -m set_option
5517c478bd9Sstevel@tonic-gate  *	list-menu	-- -m list_entry
5527c478bd9Sstevel@tonic-gate  *	update-menu	-- -m update_entry
5537c478bd9Sstevel@tonic-gate  */
5547c478bd9Sstevel@tonic-gate static struct cmd_map {
5557c478bd9Sstevel@tonic-gate 	char *bam_cmdname;
5567c478bd9Sstevel@tonic-gate 	int bam_cmd;
5577c478bd9Sstevel@tonic-gate 	char *bam_subcmd;
5587c478bd9Sstevel@tonic-gate } cmd_map[] = {
5597c478bd9Sstevel@tonic-gate 	{ "update-archive",	BAM_ARCHIVE,	"update"},
5607c478bd9Sstevel@tonic-gate 	{ "list-archive",	BAM_ARCHIVE,	"list"},
5617c478bd9Sstevel@tonic-gate 	{ "set-menu",		BAM_MENU,	"set_option"},
5627c478bd9Sstevel@tonic-gate 	{ "list-menu",		BAM_MENU,	"list_entry"},
5637c478bd9Sstevel@tonic-gate 	{ "update-menu",	BAM_MENU,	"update_entry"},
5647c478bd9Sstevel@tonic-gate 	{ NULL,			0,		NULL}
5657c478bd9Sstevel@tonic-gate };
5667c478bd9Sstevel@tonic-gate 
5677c478bd9Sstevel@tonic-gate /*
5687c478bd9Sstevel@tonic-gate  * Commands syntax published in bootadm(1M) are parsed here
5697c478bd9Sstevel@tonic-gate  */
5707c478bd9Sstevel@tonic-gate static void
5717c478bd9Sstevel@tonic-gate parse_args(int argc, char *argv[])
5727c478bd9Sstevel@tonic-gate {
5737c478bd9Sstevel@tonic-gate 	struct cmd_map *cmp = cmd_map;
5747c478bd9Sstevel@tonic-gate 
5757c478bd9Sstevel@tonic-gate 	/* command conforming to the final spec */
5767c478bd9Sstevel@tonic-gate 	if (argc > 1 && argv[1][0] != '-') {
5777c478bd9Sstevel@tonic-gate 		/*
5787c478bd9Sstevel@tonic-gate 		 * Map commands to internal table.
5797c478bd9Sstevel@tonic-gate 		 */
5807c478bd9Sstevel@tonic-gate 		while (cmp->bam_cmdname) {
5817c478bd9Sstevel@tonic-gate 			if (strcmp(argv[1], cmp->bam_cmdname) == 0) {
5827c478bd9Sstevel@tonic-gate 				bam_cmd = cmp->bam_cmd;
5837c478bd9Sstevel@tonic-gate 				bam_subcmd = cmp->bam_subcmd;
5847c478bd9Sstevel@tonic-gate 				break;
5857c478bd9Sstevel@tonic-gate 			}
5867c478bd9Sstevel@tonic-gate 			cmp++;
5877c478bd9Sstevel@tonic-gate 		}
5887c478bd9Sstevel@tonic-gate 		if (cmp->bam_cmdname == NULL) {
5897c478bd9Sstevel@tonic-gate 			usage();
5907c478bd9Sstevel@tonic-gate 			bam_exit(1);
5917c478bd9Sstevel@tonic-gate 		}
5927c478bd9Sstevel@tonic-gate 		argc--;
5937c478bd9Sstevel@tonic-gate 		argv++;
5947c478bd9Sstevel@tonic-gate 	}
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate 	parse_args_internal(argc, argv);
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate /*
6007c478bd9Sstevel@tonic-gate  * A combination of public and private commands are parsed here.
6017c478bd9Sstevel@tonic-gate  * The internal syntax and the corresponding functionality are:
6027c478bd9Sstevel@tonic-gate  *	-a update			-- update-archive
6037c478bd9Sstevel@tonic-gate  *	-a list				-- list-archive
60444da779fSWilliam Kucharski  *	-a update-all			-- (reboot to sync all mnted OS archive)
6057c478bd9Sstevel@tonic-gate  *	-m update_entry			-- update-menu
6067c478bd9Sstevel@tonic-gate  *	-m list_entry			-- list-menu
6077c478bd9Sstevel@tonic-gate  *	-m update_temp			-- (reboot -- [boot-args])
6087c478bd9Sstevel@tonic-gate  *	-m delete_all_entries		-- (called from install)
60944da779fSWilliam Kucharski  *	-m enable_hypervisor [args]	-- cvt_to_hyper
61044da779fSWilliam Kucharski  *	-m disable_hypervisor		-- cvt_to_metal
61144da779fSWilliam Kucharski  *	-m list_setting [entry] [value]	-- list_setting
61244da779fSWilliam Kucharski  *
61348847494SEnrico Perla - Sun Microsystems  * A set of private flags is there too:
61448847494SEnrico Perla - Sun Microsystems  *	-F		-- purge the cache directories and rebuild them
61548847494SEnrico Perla - Sun Microsystems  *	-e		-- use the (faster) archive update approach (used by
61648847494SEnrico Perla - Sun Microsystems  *			   reboot)
6177c478bd9Sstevel@tonic-gate  */
6187c478bd9Sstevel@tonic-gate static void
6197c478bd9Sstevel@tonic-gate parse_args_internal(int argc, char *argv[])
6207c478bd9Sstevel@tonic-gate {
6217c478bd9Sstevel@tonic-gate 	int c, error;
6227c478bd9Sstevel@tonic-gate 	extern char *optarg;
6237c478bd9Sstevel@tonic-gate 	extern int optind, opterr;
6247c478bd9Sstevel@tonic-gate 
6257c478bd9Sstevel@tonic-gate 	/* Suppress error message from getopt */
6267c478bd9Sstevel@tonic-gate 	opterr = 0;
6277c478bd9Sstevel@tonic-gate 
6287c478bd9Sstevel@tonic-gate 	error = 0;
6293028dfd6SFrank Van Der Linden 	while ((c = getopt(argc, argv, "a:d:fm:no:veFCR:p:XZ")) != -1) {
6307c478bd9Sstevel@tonic-gate 		switch (c) {
6317c478bd9Sstevel@tonic-gate 		case 'a':
6327c478bd9Sstevel@tonic-gate 			if (bam_cmd) {
6337c478bd9Sstevel@tonic-gate 				error = 1;
6347c478bd9Sstevel@tonic-gate 				bam_error(MULT_CMDS, c);
6357c478bd9Sstevel@tonic-gate 			}
6367c478bd9Sstevel@tonic-gate 			bam_cmd = BAM_ARCHIVE;
6377c478bd9Sstevel@tonic-gate 			bam_subcmd = optarg;
6387c478bd9Sstevel@tonic-gate 			break;
6397c478bd9Sstevel@tonic-gate 		case 'd':
6407c478bd9Sstevel@tonic-gate 			if (bam_debug) {
6417c478bd9Sstevel@tonic-gate 				error = 1;
6427c478bd9Sstevel@tonic-gate 				bam_error(DUP_OPT, c);
6437c478bd9Sstevel@tonic-gate 			}
6447c478bd9Sstevel@tonic-gate 			bam_debug = s_strtol(optarg);
6457c478bd9Sstevel@tonic-gate 			break;
6467c478bd9Sstevel@tonic-gate 		case 'f':
6477c478bd9Sstevel@tonic-gate 			bam_force = 1;
6487c478bd9Sstevel@tonic-gate 			break;
64948847494SEnrico Perla - Sun Microsystems 		case 'F':
65048847494SEnrico Perla - Sun Microsystems 			bam_purge = 1;
65148847494SEnrico Perla - Sun Microsystems 			break;
6527c478bd9Sstevel@tonic-gate 		case 'm':
6537c478bd9Sstevel@tonic-gate 			if (bam_cmd) {
6547c478bd9Sstevel@tonic-gate 				error = 1;
6557c478bd9Sstevel@tonic-gate 				bam_error(MULT_CMDS, c);
6567c478bd9Sstevel@tonic-gate 			}
6577c478bd9Sstevel@tonic-gate 			bam_cmd = BAM_MENU;
6587c478bd9Sstevel@tonic-gate 			bam_subcmd = optarg;
6597c478bd9Sstevel@tonic-gate 			break;
6607c478bd9Sstevel@tonic-gate 		case 'n':
6617c478bd9Sstevel@tonic-gate 			bam_check = 1;
6625eea6091SEnrico Perla - Sun Microsystems 			/*
6635eea6091SEnrico Perla - Sun Microsystems 			 * We save the original value of bam_check. The new
6645eea6091SEnrico Perla - Sun Microsystems 			 * approach in case of a read-only filesystem is to
6655eea6091SEnrico Perla - Sun Microsystems 			 * behave as a check, so we need a way to restore the
6665eea6091SEnrico Perla - Sun Microsystems 			 * original value after the evaluation of the read-only
6675eea6091SEnrico Perla - Sun Microsystems 			 * filesystem has been done.
6685eea6091SEnrico Perla - Sun Microsystems 			 * Even if we don't allow at the moment a check with
6695eea6091SEnrico Perla - Sun Microsystems 			 * update_all, this approach is more robust than
6705eea6091SEnrico Perla - Sun Microsystems 			 * simply resetting bam_check to zero.
6715eea6091SEnrico Perla - Sun Microsystems 			 */
6725eea6091SEnrico Perla - Sun Microsystems 			bam_saved_check = 1;
6737c478bd9Sstevel@tonic-gate 			break;
6747c478bd9Sstevel@tonic-gate 		case 'o':
6757c478bd9Sstevel@tonic-gate 			if (bam_opt) {
6767c478bd9Sstevel@tonic-gate 				error = 1;
6777c478bd9Sstevel@tonic-gate 				bam_error(DUP_OPT, c);
6787c478bd9Sstevel@tonic-gate 			}
6797c478bd9Sstevel@tonic-gate 			bam_opt = optarg;
6807c478bd9Sstevel@tonic-gate 			break;
6817c478bd9Sstevel@tonic-gate 		case 'v':
6827c478bd9Sstevel@tonic-gate 			bam_verbose = 1;
6837c478bd9Sstevel@tonic-gate 			break;
6848c1b6884Sszhou 		case 'C':
6858c1b6884Sszhou 			bam_smf_check = 1;
6868c1b6884Sszhou 			break;
6877c478bd9Sstevel@tonic-gate 		case 'R':
6887c478bd9Sstevel@tonic-gate 			if (bam_root) {
6897c478bd9Sstevel@tonic-gate 				error = 1;
6907c478bd9Sstevel@tonic-gate 				bam_error(DUP_OPT, c);
6917c478bd9Sstevel@tonic-gate 				break;
6927c478bd9Sstevel@tonic-gate 			} else if (realpath(optarg, rootbuf) == NULL) {
6937c478bd9Sstevel@tonic-gate 				error = 1;
6947c478bd9Sstevel@tonic-gate 				bam_error(CANT_RESOLVE, optarg,
6957c478bd9Sstevel@tonic-gate 				    strerror(errno));
6967c478bd9Sstevel@tonic-gate 				break;
6977c478bd9Sstevel@tonic-gate 			}
69840541d5dSvikram 			bam_alt_root = 1;
6997c478bd9Sstevel@tonic-gate 			bam_root = rootbuf;
7007c478bd9Sstevel@tonic-gate 			bam_rootlen = strlen(rootbuf);
7017c478bd9Sstevel@tonic-gate 			break;
702d876c67dSjg 		case 'p':
703d876c67dSjg 			bam_alt_platform = 1;
704d876c67dSjg 			bam_platform = optarg;
705d876c67dSjg 			if ((strcmp(bam_platform, "i86pc") != 0) &&
706d876c67dSjg 			    (strcmp(bam_platform, "sun4u") != 0) &&
707d876c67dSjg 			    (strcmp(bam_platform, "sun4v") != 0)) {
708d876c67dSjg 				error = 1;
709d876c67dSjg 				bam_error(INVALID_PLAT, bam_platform);
710d876c67dSjg 			}
711d876c67dSjg 			break;
7123028dfd6SFrank Van Der Linden 		case 'X':
7133028dfd6SFrank Van Der Linden 			bam_is_hv = BAM_HV_PRESENT;
7143028dfd6SFrank Van Der Linden 			break;
715e7cbe64fSgw25295 		case 'Z':
716e7cbe64fSgw25295 			bam_zfs = 1;
717e7cbe64fSgw25295 			break;
71848847494SEnrico Perla - Sun Microsystems 		case 'e':
71948847494SEnrico Perla - Sun Microsystems 			bam_extend = 1;
72048847494SEnrico Perla - Sun Microsystems 			break;
7217c478bd9Sstevel@tonic-gate 		case '?':
7227c478bd9Sstevel@tonic-gate 			error = 1;
7237c478bd9Sstevel@tonic-gate 			bam_error(BAD_OPT, optopt);
7247c478bd9Sstevel@tonic-gate 			break;
7257c478bd9Sstevel@tonic-gate 		default :
7267c478bd9Sstevel@tonic-gate 			error = 1;
7277c478bd9Sstevel@tonic-gate 			bam_error(BAD_OPT, c);
7287c478bd9Sstevel@tonic-gate 			break;
7297c478bd9Sstevel@tonic-gate 		}
7307c478bd9Sstevel@tonic-gate 	}
7317c478bd9Sstevel@tonic-gate 
7327c478bd9Sstevel@tonic-gate 	/*
733d876c67dSjg 	 * An alternate platform requires an alternate root
734d876c67dSjg 	 */
735d876c67dSjg 	if (bam_alt_platform && bam_alt_root == 0) {
736d876c67dSjg 		usage();
737d876c67dSjg 		bam_exit(0);
738d876c67dSjg 	}
739d876c67dSjg 
740d876c67dSjg 	/*
7417c478bd9Sstevel@tonic-gate 	 * A command option must be specfied
7427c478bd9Sstevel@tonic-gate 	 */
7437c478bd9Sstevel@tonic-gate 	if (!bam_cmd) {
7447c478bd9Sstevel@tonic-gate 		if (bam_opt && strcmp(bam_opt, "all") == 0) {
7457c478bd9Sstevel@tonic-gate 			usage();
7467c478bd9Sstevel@tonic-gate 			bam_exit(0);
7477c478bd9Sstevel@tonic-gate 		}
7487c478bd9Sstevel@tonic-gate 		bam_error(NEED_CMD);
7497c478bd9Sstevel@tonic-gate 		error = 1;
7507c478bd9Sstevel@tonic-gate 	}
7517c478bd9Sstevel@tonic-gate 
7527c478bd9Sstevel@tonic-gate 	if (error) {
7537c478bd9Sstevel@tonic-gate 		usage();
7547c478bd9Sstevel@tonic-gate 		bam_exit(1);
7557c478bd9Sstevel@tonic-gate 	}
7567c478bd9Sstevel@tonic-gate 
7577c478bd9Sstevel@tonic-gate 	if (optind > argc) {
7587c478bd9Sstevel@tonic-gate 		bam_error(INT_ERROR, "parse_args");
7597c478bd9Sstevel@tonic-gate 		bam_exit(1);
7607c478bd9Sstevel@tonic-gate 	} else if (optind < argc) {
7617c478bd9Sstevel@tonic-gate 		bam_argv = &argv[optind];
7627c478bd9Sstevel@tonic-gate 		bam_argc = argc - optind;
7637c478bd9Sstevel@tonic-gate 	}
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	/*
7667c478bd9Sstevel@tonic-gate 	 * -n implies verbose mode
7677c478bd9Sstevel@tonic-gate 	 */
7687c478bd9Sstevel@tonic-gate 	if (bam_check)
7697c478bd9Sstevel@tonic-gate 		bam_verbose = 1;
7707c478bd9Sstevel@tonic-gate }
7717c478bd9Sstevel@tonic-gate 
7727c478bd9Sstevel@tonic-gate static error_t
7737c478bd9Sstevel@tonic-gate check_subcmd_and_options(
7747c478bd9Sstevel@tonic-gate 	char *subcmd,
7757c478bd9Sstevel@tonic-gate 	char *opt,
7767c478bd9Sstevel@tonic-gate 	subcmd_defn_t *table,
7777c478bd9Sstevel@tonic-gate 	error_t (**fp)())
7787c478bd9Sstevel@tonic-gate {
7797c478bd9Sstevel@tonic-gate 	int i;
7807c478bd9Sstevel@tonic-gate 
7817c478bd9Sstevel@tonic-gate 	if (subcmd == NULL) {
7827c478bd9Sstevel@tonic-gate 		bam_error(NEED_SUBCMD);
7837c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
7847c478bd9Sstevel@tonic-gate 	}
7857c478bd9Sstevel@tonic-gate 
786eb2bd662Svikram 	if (strcmp(subcmd, "set_option") == 0) {
787eb2bd662Svikram 		if (bam_argc == 0 || bam_argv == NULL || bam_argv[0] == NULL) {
788eb2bd662Svikram 			bam_error(MISSING_ARG);
789eb2bd662Svikram 			usage();
790eb2bd662Svikram 			return (BAM_ERROR);
791eb2bd662Svikram 		} else if (bam_argc > 1 || bam_argv[1] != NULL) {
7921a97e40eSvikram 			bam_error(TRAILING_ARGS);
7931a97e40eSvikram 			usage();
7941a97e40eSvikram 			return (BAM_ERROR);
7951a97e40eSvikram 		}
79619397407SSherry Moore 	} else if (strcmp(subcmd, "update_all") == 0) {
79719397407SSherry Moore 		/*
79819397407SSherry Moore 		 * The only option we accept for the "update_all"
79919397407SSherry Moore 		 * subcmd is "fastboot".
80019397407SSherry Moore 		 */
80119397407SSherry Moore 		if (bam_argc > 1 || (bam_argc == 1 &&
80219397407SSherry Moore 		    strcmp(bam_argv[0], "fastboot") != 0)) {
80319397407SSherry Moore 			bam_error(TRAILING_ARGS);
80419397407SSherry Moore 			usage();
80519397407SSherry Moore 			return (BAM_ERROR);
80619397407SSherry Moore 		}
80719397407SSherry Moore 		if (bam_argc == 1)
80819397407SSherry Moore 			sync_menu = 0;
80944da779fSWilliam Kucharski 	} else if (((strcmp(subcmd, "enable_hypervisor") != 0) &&
81044da779fSWilliam Kucharski 	    (strcmp(subcmd, "list_setting") != 0)) && (bam_argc || bam_argv)) {
81144da779fSWilliam Kucharski 		/*
81244da779fSWilliam Kucharski 		 * Of the remaining subcommands, only "enable_hypervisor" and
81344da779fSWilliam Kucharski 		 * "list_setting" take trailing arguments.
81444da779fSWilliam Kucharski 		 */
815eb2bd662Svikram 		bam_error(TRAILING_ARGS);
816eb2bd662Svikram 		usage();
817eb2bd662Svikram 		return (BAM_ERROR);
8181a97e40eSvikram 	}
8191a97e40eSvikram 
8207c478bd9Sstevel@tonic-gate 	if (bam_root == NULL) {
8217c478bd9Sstevel@tonic-gate 		bam_root = rootbuf;
8227c478bd9Sstevel@tonic-gate 		bam_rootlen = 1;
8237c478bd9Sstevel@tonic-gate 	}
8247c478bd9Sstevel@tonic-gate 
8257c478bd9Sstevel@tonic-gate 	/* verify that subcmd is valid */
8267c478bd9Sstevel@tonic-gate 	for (i = 0; table[i].subcmd != NULL; i++) {
8277c478bd9Sstevel@tonic-gate 		if (strcmp(table[i].subcmd, subcmd) == 0)
8287c478bd9Sstevel@tonic-gate 			break;
8297c478bd9Sstevel@tonic-gate 	}
8307c478bd9Sstevel@tonic-gate 
8317c478bd9Sstevel@tonic-gate 	if (table[i].subcmd == NULL) {
8327c478bd9Sstevel@tonic-gate 		bam_error(INVALID_SUBCMD, subcmd);
8337c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
8347c478bd9Sstevel@tonic-gate 	}
8357c478bd9Sstevel@tonic-gate 
8361a97e40eSvikram 	if (table[i].unpriv == 0 && geteuid() != 0) {
8371a97e40eSvikram 		bam_error(MUST_BE_ROOT);
8381a97e40eSvikram 		return (BAM_ERROR);
8391a97e40eSvikram 	}
8401a97e40eSvikram 
8411a97e40eSvikram 	/*
8421a97e40eSvikram 	 * Currently only privileged commands need a lock
8431a97e40eSvikram 	 */
8441a97e40eSvikram 	if (table[i].unpriv == 0)
8451a97e40eSvikram 		bam_lock();
8461a97e40eSvikram 
8477c478bd9Sstevel@tonic-gate 	/* subcmd verifies that opt is appropriate */
8487c478bd9Sstevel@tonic-gate 	if (table[i].option != OPT_OPTIONAL) {
8497c478bd9Sstevel@tonic-gate 		if ((table[i].option == OPT_REQ) ^ (opt != NULL)) {
8507c478bd9Sstevel@tonic-gate 			if (opt)
8517c478bd9Sstevel@tonic-gate 				bam_error(NO_OPT_REQ, subcmd);
8527c478bd9Sstevel@tonic-gate 			else
8537c478bd9Sstevel@tonic-gate 				bam_error(MISS_OPT, subcmd);
8547c478bd9Sstevel@tonic-gate 			return (BAM_ERROR);
8557c478bd9Sstevel@tonic-gate 		}
8567c478bd9Sstevel@tonic-gate 	}
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 	*fp = table[i].handler;
8597c478bd9Sstevel@tonic-gate 
8607c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
8617c478bd9Sstevel@tonic-gate }
8627c478bd9Sstevel@tonic-gate 
86340541d5dSvikram /*
86440541d5dSvikram  * NOTE: A single "/" is also considered a trailing slash and will
86540541d5dSvikram  * be deleted.
86640541d5dSvikram  */
86740541d5dSvikram static void
86840541d5dSvikram elide_trailing_slash(const char *src, char *dst, size_t dstsize)
86940541d5dSvikram {
87040541d5dSvikram 	size_t dstlen;
87140541d5dSvikram 
87240541d5dSvikram 	assert(src);
87340541d5dSvikram 	assert(dst);
87440541d5dSvikram 
87540541d5dSvikram 	(void) strlcpy(dst, src, dstsize);
87640541d5dSvikram 
87740541d5dSvikram 	dstlen = strlen(dst);
87840541d5dSvikram 	if (dst[dstlen - 1] == '/') {
87940541d5dSvikram 		dst[dstlen - 1] = '\0';
88040541d5dSvikram 	}
88140541d5dSvikram }
88240541d5dSvikram 
883cedc7e57SEnrico Perla - Sun Microsystems static int
884cedc7e57SEnrico Perla - Sun Microsystems is_safe_exec(char *path)
885cedc7e57SEnrico Perla - Sun Microsystems {
886cedc7e57SEnrico Perla - Sun Microsystems 	struct stat	sb;
887cedc7e57SEnrico Perla - Sun Microsystems 
888cedc7e57SEnrico Perla - Sun Microsystems 	if (lstat(path, &sb) != 0) {
889cedc7e57SEnrico Perla - Sun Microsystems 		bam_error(STAT_FAIL, path, strerror(errno));
890cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
891cedc7e57SEnrico Perla - Sun Microsystems 	}
892cedc7e57SEnrico Perla - Sun Microsystems 
893cedc7e57SEnrico Perla - Sun Microsystems 	if (!S_ISREG(sb.st_mode)) {
894cedc7e57SEnrico Perla - Sun Microsystems 		bam_error(PATH_EXEC_LINK, path);
895cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
896cedc7e57SEnrico Perla - Sun Microsystems 	}
897cedc7e57SEnrico Perla - Sun Microsystems 
898cedc7e57SEnrico Perla - Sun Microsystems 	if (sb.st_uid != getuid()) {
899cedc7e57SEnrico Perla - Sun Microsystems 		bam_error(PATH_EXEC_OWNER, path, getuid());
900cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
901cedc7e57SEnrico Perla - Sun Microsystems 	}
902cedc7e57SEnrico Perla - Sun Microsystems 
903cedc7e57SEnrico Perla - Sun Microsystems 	if (sb.st_mode & S_IWOTH || sb.st_mode & S_IWGRP) {
904cedc7e57SEnrico Perla - Sun Microsystems 		bam_error(PATH_EXEC_PERMS, path);
905cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
906cedc7e57SEnrico Perla - Sun Microsystems 	}
907cedc7e57SEnrico Perla - Sun Microsystems 
908cedc7e57SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
909cedc7e57SEnrico Perla - Sun Microsystems }
910cedc7e57SEnrico Perla - Sun Microsystems 
9117c478bd9Sstevel@tonic-gate static error_t
91244da779fSWilliam Kucharski list_setting(menu_t *mp, char *which, char *setting)
91344da779fSWilliam Kucharski {
91444da779fSWilliam Kucharski 	line_t	*lp;
91544da779fSWilliam Kucharski 	entry_t	*ent;
91644da779fSWilliam Kucharski 
91744da779fSWilliam Kucharski 	char	*p = which;
91844da779fSWilliam Kucharski 	int	entry;
91944da779fSWilliam Kucharski 
92044da779fSWilliam Kucharski 	int	found;
92144da779fSWilliam Kucharski 
92244da779fSWilliam Kucharski 	assert(which);
92344da779fSWilliam Kucharski 	assert(setting);
92444da779fSWilliam Kucharski 
92544da779fSWilliam Kucharski 	if (*which != NULL) {
92644da779fSWilliam Kucharski 		/*
92744da779fSWilliam Kucharski 		 * If "which" is not a number, assume it's a setting we want
92844da779fSWilliam Kucharski 		 * to look for and so set up the routine to look for "which"
92944da779fSWilliam Kucharski 		 * in the default entry.
93044da779fSWilliam Kucharski 		 */
93144da779fSWilliam Kucharski 		while (*p != NULL)
93244da779fSWilliam Kucharski 			if (!(isdigit((int)*p++))) {
93344da779fSWilliam Kucharski 				setting = which;
93444da779fSWilliam Kucharski 				which = mp->curdefault->arg;
93544da779fSWilliam Kucharski 				break;
93644da779fSWilliam Kucharski 			}
93744da779fSWilliam Kucharski 	} else {
93844da779fSWilliam Kucharski 		which = mp->curdefault->arg;
93944da779fSWilliam Kucharski 	}
94044da779fSWilliam Kucharski 
94144da779fSWilliam Kucharski 	entry = atoi(which);
94244da779fSWilliam Kucharski 
94344da779fSWilliam Kucharski 	for (ent = mp->entries; ((ent != NULL) && (ent->entryNum != entry));
94444da779fSWilliam Kucharski 	    ent = ent->next)
94544da779fSWilliam Kucharski 		;
94644da779fSWilliam Kucharski 
94744da779fSWilliam Kucharski 	if (!ent) {
94844da779fSWilliam Kucharski 		bam_error(NO_MATCH_ENTRY);
94944da779fSWilliam Kucharski 		return (BAM_ERROR);
95044da779fSWilliam Kucharski 	}
95144da779fSWilliam Kucharski 
95244da779fSWilliam Kucharski 	found = (*setting == NULL);
95344da779fSWilliam Kucharski 
95444da779fSWilliam Kucharski 	for (lp = ent->start; lp != NULL; lp = lp->next) {
95544da779fSWilliam Kucharski 		if ((*setting == NULL) && (lp->flags != BAM_COMMENT))
95644da779fSWilliam Kucharski 			bam_print(PRINT, lp->line);
957eac223ccSWilliam Kucharski 		else if (lp->cmd != NULL && strcmp(setting, lp->cmd) == 0) {
95844da779fSWilliam Kucharski 			bam_print(PRINT, lp->arg);
95944da779fSWilliam Kucharski 			found = 1;
96044da779fSWilliam Kucharski 		}
96144da779fSWilliam Kucharski 
96244da779fSWilliam Kucharski 		if (lp == ent->end)
96344da779fSWilliam Kucharski 			break;
96444da779fSWilliam Kucharski 	}
96544da779fSWilliam Kucharski 
96644da779fSWilliam Kucharski 	if (!found) {
96744da779fSWilliam Kucharski 		bam_error(NO_MATCH_ENTRY);
96844da779fSWilliam Kucharski 		return (BAM_ERROR);
96944da779fSWilliam Kucharski 	}
97044da779fSWilliam Kucharski 
97144da779fSWilliam Kucharski 	return (BAM_SUCCESS);
97244da779fSWilliam Kucharski }
97344da779fSWilliam Kucharski 
97444da779fSWilliam Kucharski static error_t
9757c478bd9Sstevel@tonic-gate bam_menu(char *subcmd, char *opt, int largc, char *largv[])
9767c478bd9Sstevel@tonic-gate {
9777c478bd9Sstevel@tonic-gate 	error_t			ret;
9787c478bd9Sstevel@tonic-gate 	char			menu_path[PATH_MAX];
979eb2bd662Svikram 	char			clean_menu_root[PATH_MAX];
980ae115bc7Smrj 	char			path[PATH_MAX];
9817c478bd9Sstevel@tonic-gate 	menu_t			*menu;
982eb2bd662Svikram 	char			menu_root[PATH_MAX];
983b610f78eSvikram 	struct stat		sb;
9847c478bd9Sstevel@tonic-gate 	error_t (*f)(menu_t *mp, char *menu_path, char *opt);
985eb2bd662Svikram 	char			*special;
986eb2bd662Svikram 	char			*pool = NULL;
987eb2bd662Svikram 	zfs_mnted_t		zmnted;
988eb2bd662Svikram 	char			*zmntpt;
989eb2bd662Svikram 	char			*osdev;
990eb2bd662Svikram 	char			*osroot;
991eb2bd662Svikram 	const char		*fcn = "bam_menu()";
992986fd29aSsetje 
993986fd29aSsetje 	/*
994986fd29aSsetje 	 * Menu sub-command only applies to GRUB (i.e. x86)
995986fd29aSsetje 	 */
996eb2bd662Svikram 	if (!is_grub(bam_alt_root ? bam_root : "/")) {
997eb2bd662Svikram 		bam_error(NOT_GRUB_BOOT);
998986fd29aSsetje 		return (BAM_ERROR);
999986fd29aSsetje 	}
10007c478bd9Sstevel@tonic-gate 
10017c478bd9Sstevel@tonic-gate 	/*
10027c478bd9Sstevel@tonic-gate 	 * Check arguments
10037c478bd9Sstevel@tonic-gate 	 */
10047c478bd9Sstevel@tonic-gate 	ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f);
10057c478bd9Sstevel@tonic-gate 	if (ret == BAM_ERROR) {
10067c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
10077c478bd9Sstevel@tonic-gate 	}
10087c478bd9Sstevel@tonic-gate 
1009eb2bd662Svikram 	assert(bam_root);
1010eb2bd662Svikram 
1011eb2bd662Svikram 	(void) strlcpy(menu_root, bam_root, sizeof (menu_root));
1012eb2bd662Svikram 	osdev = osroot = NULL;
1013eb2bd662Svikram 
1014eb2bd662Svikram 	if (strcmp(subcmd, "update_entry") == 0) {
1015eb2bd662Svikram 		assert(opt);
1016eb2bd662Svikram 
1017eb2bd662Svikram 		osdev = strtok(opt, ",");
1018eb2bd662Svikram 		assert(osdev);
1019eb2bd662Svikram 		osroot = strtok(NULL, ",");
1020eb2bd662Svikram 		if (osroot) {
1021eb2bd662Svikram 			/* fixup bam_root so that it points at osroot */
1022eb2bd662Svikram 			if (realpath(osroot, rootbuf) == NULL) {
1023eb2bd662Svikram 				bam_error(CANT_RESOLVE, osroot,
1024eb2bd662Svikram 				    strerror(errno));
1025eb2bd662Svikram 				return (BAM_ERROR);
1026eb2bd662Svikram 			}
1027eb2bd662Svikram 			bam_alt_root = 1;
1028eb2bd662Svikram 			bam_root  = rootbuf;
1029eb2bd662Svikram 			bam_rootlen = strlen(rootbuf);
1030eb2bd662Svikram 		}
1031eb2bd662Svikram 	}
103240541d5dSvikram 
103340541d5dSvikram 	/*
1034eb2bd662Svikram 	 * We support menu on PCFS (under certain conditions), but
1035eb2bd662Svikram 	 * not the OS root
103640541d5dSvikram 	 */
1037eb2bd662Svikram 	if (is_pcfs(bam_root)) {
1038eb2bd662Svikram 		bam_error(PCFS_ROOT_NOTSUP, bam_root);
1039eb2bd662Svikram 		return (BAM_ERROR);
1040ae115bc7Smrj 	}
1041ae115bc7Smrj 
1042eb2bd662Svikram 	if (stat(menu_root, &sb) == -1) {
104340541d5dSvikram 		bam_error(CANNOT_LOCATE_GRUB_MENU);
104440541d5dSvikram 		return (BAM_ERROR);
104540541d5dSvikram 	}
104640541d5dSvikram 
1047eb2bd662Svikram 	BAM_DPRINTF((D_MENU_ROOT, fcn, menu_root));
1048e7cbe64fSgw25295 
1049eb2bd662Svikram 	/*
1050eb2bd662Svikram 	 * We no longer use the GRUB slice file. If it exists, then
1051eb2bd662Svikram 	 * the user is doing something that is unsupported (such as
1052eb2bd662Svikram 	 * standard upgrading an old Live Upgrade BE). If that
1053eb2bd662Svikram 	 * happens, mimic existing behavior i.e. pretend that it is
1054eb2bd662Svikram 	 * not a BE. Emit a warning though.
1055eb2bd662Svikram 	 */
1056eb2bd662Svikram 	if (bam_alt_root) {
1057eb2bd662Svikram 		(void) snprintf(path, sizeof (path), "%s%s", bam_root,
1058eb2bd662Svikram 		    GRUB_slice);
1059eb2bd662Svikram 	} else {
1060eb2bd662Svikram 		(void) snprintf(path, sizeof (path), "%s", GRUB_slice);
1061e7cbe64fSgw25295 	}
1062e7cbe64fSgw25295 
106337eb779cSVikram Hegde 	if (bam_verbose && stat(path, &sb) == 0)
1064eb2bd662Svikram 		bam_error(GRUB_SLICE_FILE_EXISTS, path);
1065eb2bd662Svikram 
1066eb2bd662Svikram 	if (is_zfs(menu_root)) {
1067eb2bd662Svikram 		assert(strcmp(menu_root, bam_root) == 0);
1068eb2bd662Svikram 		special = get_special(menu_root);
1069eb2bd662Svikram 		INJECT_ERROR1("Z_MENU_GET_SPECIAL", special = NULL);
1070eb2bd662Svikram 		if (special == NULL) {
1071eb2bd662Svikram 			bam_error(CANT_FIND_SPECIAL, menu_root);
1072eb2bd662Svikram 			return (BAM_ERROR);
1073eb2bd662Svikram 		}
1074eb2bd662Svikram 		pool = strtok(special, "/");
1075eb2bd662Svikram 		INJECT_ERROR1("Z_MENU_GET_POOL", pool = NULL);
1076eb2bd662Svikram 		if (pool == NULL) {
1077eb2bd662Svikram 			free(special);
1078eb2bd662Svikram 			bam_error(CANT_FIND_POOL, menu_root);
1079eb2bd662Svikram 			return (BAM_ERROR);
1080eb2bd662Svikram 		}
1081eb2bd662Svikram 		BAM_DPRINTF((D_Z_MENU_GET_POOL_FROM_SPECIAL, fcn, pool));
1082eb2bd662Svikram 
1083eb2bd662Svikram 		zmntpt = mount_top_dataset(pool, &zmnted);
1084eb2bd662Svikram 		INJECT_ERROR1("Z_MENU_MOUNT_TOP_DATASET", zmntpt = NULL);
1085eb2bd662Svikram 		if (zmntpt == NULL) {
1086eb2bd662Svikram 			bam_error(CANT_MOUNT_POOL_DATASET, pool);
1087eb2bd662Svikram 			free(special);
1088eb2bd662Svikram 			return (BAM_ERROR);
1089eb2bd662Svikram 		}
1090eb2bd662Svikram 		BAM_DPRINTF((D_Z_GET_MENU_MOUNT_TOP_DATASET, fcn, zmntpt));
1091eb2bd662Svikram 
1092eb2bd662Svikram 		(void) strlcpy(menu_root, zmntpt, sizeof (menu_root));
1093eb2bd662Svikram 		BAM_DPRINTF((D_Z_GET_MENU_MENU_ROOT, fcn, menu_root));
1094eb2bd662Svikram 	}
1095eb2bd662Svikram 
1096eb2bd662Svikram 	elide_trailing_slash(menu_root, clean_menu_root,
1097eb2bd662Svikram 	    sizeof (clean_menu_root));
1098eb2bd662Svikram 
1099eb2bd662Svikram 	BAM_DPRINTF((D_CLEAN_MENU_ROOT, fcn, clean_menu_root));
1100eb2bd662Svikram 
1101eb2bd662Svikram 	(void) strlcpy(menu_path, clean_menu_root, sizeof (menu_path));
110240541d5dSvikram 	(void) strlcat(menu_path, GRUB_MENU, sizeof (menu_path));
110340541d5dSvikram 
1104eb2bd662Svikram 	BAM_DPRINTF((D_MENU_PATH, fcn, menu_path));
1105eb2bd662Svikram 
110640541d5dSvikram 	/*
1107eb2bd662Svikram 	 * If listing the menu, display the menu location
110840541d5dSvikram 	 */
110944da779fSWilliam Kucharski 	if (strcmp(subcmd, "list_entry") == 0)
1110eb2bd662Svikram 		bam_print(GRUB_MENU_PATH, menu_path);
111144da779fSWilliam Kucharski 
111244da779fSWilliam Kucharski 	if ((menu = menu_read(menu_path)) == NULL) {
111344da779fSWilliam Kucharski 		bam_error(CANNOT_LOCATE_GRUB_MENU_FILE, menu_path);
111444da779fSWilliam Kucharski 		if (special != NULL)
111544da779fSWilliam Kucharski 			free(special);
111644da779fSWilliam Kucharski 
111744da779fSWilliam Kucharski 		return (BAM_ERROR);
111840541d5dSvikram 	}
11197c478bd9Sstevel@tonic-gate 
11207c478bd9Sstevel@tonic-gate 	/*
1121eb2bd662Svikram 	 * We already checked the following case in
1122eb2bd662Svikram 	 * check_subcmd_and_suboptions() above. Complete the
1123eb2bd662Svikram 	 * final step now.
11247c478bd9Sstevel@tonic-gate 	 */
11257c478bd9Sstevel@tonic-gate 	if (strcmp(subcmd, "set_option") == 0) {
1126eb2bd662Svikram 		assert(largc == 1 && largv[0] && largv[1] == NULL);
11277c478bd9Sstevel@tonic-gate 		opt = largv[0];
112844da779fSWilliam Kucharski 	} else if ((strcmp(subcmd, "enable_hypervisor") != 0) &&
112944da779fSWilliam Kucharski 	    (strcmp(subcmd, "list_setting") != 0)) {
1130eb2bd662Svikram 		assert(largc == 0 && largv == NULL);
11317c478bd9Sstevel@tonic-gate 	}
11327c478bd9Sstevel@tonic-gate 
1133eb2bd662Svikram 	ret = get_boot_cap(bam_root);
1134eb2bd662Svikram 	if (ret != BAM_SUCCESS) {
1135eb2bd662Svikram 		BAM_DPRINTF((D_BOOT_GET_CAP_FAILED, fcn));
1136eb2bd662Svikram 		goto out;
1137eb2bd662Svikram 	}
1138ae115bc7Smrj 
11397c478bd9Sstevel@tonic-gate 	/*
11407c478bd9Sstevel@tonic-gate 	 * Once the sub-cmd handler has run
11417c478bd9Sstevel@tonic-gate 	 * only the line field is guaranteed to have valid values
11427c478bd9Sstevel@tonic-gate 	 */
114344da779fSWilliam Kucharski 	if (strcmp(subcmd, "update_entry") == 0) {
1144eb2bd662Svikram 		ret = f(menu, menu_root, osdev);
114544da779fSWilliam Kucharski 	} else if (strcmp(subcmd, "upgrade") == 0) {
1146eb2bd662Svikram 		ret = f(menu, bam_root, menu_root);
114744da779fSWilliam Kucharski 	} else if (strcmp(subcmd, "list_entry") == 0) {
11487c478bd9Sstevel@tonic-gate 		ret = f(menu, menu_path, opt);
114944da779fSWilliam Kucharski 	} else if (strcmp(subcmd, "list_setting") == 0) {
115044da779fSWilliam Kucharski 		ret = f(menu, ((largc > 0) ? largv[0] : ""),
115144da779fSWilliam Kucharski 		    ((largc > 1) ? largv[1] : ""));
115244da779fSWilliam Kucharski 	} else if (strcmp(subcmd, "disable_hypervisor") == 0) {
115344da779fSWilliam Kucharski 		if (is_sparc()) {
115444da779fSWilliam Kucharski 			bam_error(NO_SPARC, subcmd);
115544da779fSWilliam Kucharski 			ret = BAM_ERROR;
115644da779fSWilliam Kucharski 		} else {
115744da779fSWilliam Kucharski 			ret = f(menu, bam_root, NULL);
115844da779fSWilliam Kucharski 		}
115944da779fSWilliam Kucharski 	} else if (strcmp(subcmd, "enable_hypervisor") == 0) {
116044da779fSWilliam Kucharski 		if (is_sparc()) {
116144da779fSWilliam Kucharski 			bam_error(NO_SPARC, subcmd);
116244da779fSWilliam Kucharski 			ret = BAM_ERROR;
116344da779fSWilliam Kucharski 		} else {
116444da779fSWilliam Kucharski 			char *extra_args = NULL;
116544da779fSWilliam Kucharski 
116644da779fSWilliam Kucharski 			/*
116744da779fSWilliam Kucharski 			 * Compress all arguments passed in the largv[] array
116844da779fSWilliam Kucharski 			 * into one string that can then be appended to the
116944da779fSWilliam Kucharski 			 * end of the kernel$ string the routine to enable the
117044da779fSWilliam Kucharski 			 * hypervisor will build.
117144da779fSWilliam Kucharski 			 *
117244da779fSWilliam Kucharski 			 * This allows the caller to supply arbitrary unparsed
117344da779fSWilliam Kucharski 			 * arguments, such as dom0 memory settings or APIC
117444da779fSWilliam Kucharski 			 * options.
117544da779fSWilliam Kucharski 			 *
117644da779fSWilliam Kucharski 			 * This concatenation will be done without ANY syntax
117744da779fSWilliam Kucharski 			 * checking whatsoever, so it's the responsibility of
117844da779fSWilliam Kucharski 			 * the caller to make sure the arguments are valid and
117944da779fSWilliam Kucharski 			 * do not duplicate arguments the conversion routines
118044da779fSWilliam Kucharski 			 * may create.
118144da779fSWilliam Kucharski 			 */
118244da779fSWilliam Kucharski 			if (largc > 0) {
118344da779fSWilliam Kucharski 				int extra_len, i;
118444da779fSWilliam Kucharski 
118544da779fSWilliam Kucharski 				for (extra_len = 0, i = 0; i < largc; i++)
118644da779fSWilliam Kucharski 					extra_len += strlen(largv[i]);
118744da779fSWilliam Kucharski 
118844da779fSWilliam Kucharski 				/*
118944da779fSWilliam Kucharski 				 * Allocate space for argument strings,
119044da779fSWilliam Kucharski 				 * intervening spaces and terminating NULL.
119144da779fSWilliam Kucharski 				 */
119244da779fSWilliam Kucharski 				extra_args = alloca(extra_len + largc);
119344da779fSWilliam Kucharski 
119444da779fSWilliam Kucharski 				(void) strcpy(extra_args, largv[0]);
119544da779fSWilliam Kucharski 
119644da779fSWilliam Kucharski 				for (i = 1; i < largc; i++) {
119744da779fSWilliam Kucharski 					(void) strcat(extra_args, " ");
119844da779fSWilliam Kucharski 					(void) strcat(extra_args, largv[i]);
119944da779fSWilliam Kucharski 				}
120044da779fSWilliam Kucharski 			}
120144da779fSWilliam Kucharski 
120244da779fSWilliam Kucharski 			ret = f(menu, bam_root, extra_args);
120344da779fSWilliam Kucharski 		}
120444da779fSWilliam Kucharski 	} else
1205eb2bd662Svikram 		ret = f(menu, NULL, opt);
1206eb2bd662Svikram 
12077c478bd9Sstevel@tonic-gate 	if (ret == BAM_WRITE) {
1208eb2bd662Svikram 		BAM_DPRINTF((D_WRITING_MENU_ROOT, fcn, clean_menu_root));
1209eb2bd662Svikram 		ret = menu_write(clean_menu_root, menu);
12107c478bd9Sstevel@tonic-gate 	}
12117c478bd9Sstevel@tonic-gate 
1212eb2bd662Svikram out:
1213eb2bd662Svikram 	INJECT_ERROR1("POOL_SET", pool = "/pooldata");
1214eb2bd662Svikram 	assert((is_zfs(menu_root)) ^ (pool == NULL));
1215eb2bd662Svikram 	if (pool) {
1216eb2bd662Svikram 		(void) umount_top_dataset(pool, zmnted, zmntpt);
1217eb2bd662Svikram 		free(special);
1218eb2bd662Svikram 	}
12197c478bd9Sstevel@tonic-gate 	menu_free(menu);
12207c478bd9Sstevel@tonic-gate 	return (ret);
12217c478bd9Sstevel@tonic-gate }
12227c478bd9Sstevel@tonic-gate 
12237c478bd9Sstevel@tonic-gate 
12247c478bd9Sstevel@tonic-gate static error_t
12257c478bd9Sstevel@tonic-gate bam_archive(
12267c478bd9Sstevel@tonic-gate 	char *subcmd,
12277c478bd9Sstevel@tonic-gate 	char *opt)
12287c478bd9Sstevel@tonic-gate {
12297c478bd9Sstevel@tonic-gate 	error_t			ret;
12307c478bd9Sstevel@tonic-gate 	error_t			(*f)(char *root, char *opt);
1231eb2bd662Svikram 	const char		*fcn = "bam_archive()";
12327c478bd9Sstevel@tonic-gate 
12337c478bd9Sstevel@tonic-gate 	/*
12348c1b6884Sszhou 	 * Add trailing / for archive subcommands
12358c1b6884Sszhou 	 */
12368c1b6884Sszhou 	if (rootbuf[strlen(rootbuf) - 1] != '/')
12378c1b6884Sszhou 		(void) strcat(rootbuf, "/");
12388c1b6884Sszhou 	bam_rootlen = strlen(rootbuf);
12398c1b6884Sszhou 
12408c1b6884Sszhou 	/*
12417c478bd9Sstevel@tonic-gate 	 * Check arguments
12427c478bd9Sstevel@tonic-gate 	 */
12437c478bd9Sstevel@tonic-gate 	ret = check_subcmd_and_options(subcmd, opt, arch_subcmds, &f);
12447c478bd9Sstevel@tonic-gate 	if (ret != BAM_SUCCESS) {
12457c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
12467c478bd9Sstevel@tonic-gate 	}
12477c478bd9Sstevel@tonic-gate 
1248eb2bd662Svikram 	ret = get_boot_cap(rootbuf);
1249eb2bd662Svikram 	if (ret != BAM_SUCCESS) {
1250eb2bd662Svikram 		BAM_DPRINTF((D_BOOT_GET_CAP_FAILED, fcn));
1251ae115bc7Smrj 		return (ret);
1252eb2bd662Svikram 	}
1253ae115bc7Smrj 
12547c478bd9Sstevel@tonic-gate 	/*
12557c478bd9Sstevel@tonic-gate 	 * Check archive not supported with update_all
12567c478bd9Sstevel@tonic-gate 	 * since it is awkward to display out-of-sync
12577c478bd9Sstevel@tonic-gate 	 * information for each BE.
12587c478bd9Sstevel@tonic-gate 	 */
12597c478bd9Sstevel@tonic-gate 	if (bam_check && strcmp(subcmd, "update_all") == 0) {
12607c478bd9Sstevel@tonic-gate 		bam_error(CHECK_NOT_SUPPORTED, subcmd);
12617c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
12627c478bd9Sstevel@tonic-gate 	}
12637c478bd9Sstevel@tonic-gate 
1264b610f78eSvikram 	if (strcmp(subcmd, "update_all") == 0)
1265b610f78eSvikram 		bam_update_all = 1;
1266b610f78eSvikram 
1267986fd29aSsetje #if !defined(_OPB)
12682449e17fSsherrym 	ucode_install(bam_root);
12692449e17fSsherrym #endif
12702449e17fSsherrym 
1271b610f78eSvikram 	ret = f(bam_root, opt);
1272b610f78eSvikram 
1273b610f78eSvikram 	bam_update_all = 0;
1274b610f78eSvikram 
1275b610f78eSvikram 	return (ret);
12767c478bd9Sstevel@tonic-gate }
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
1279ae115bc7Smrj void
12807c478bd9Sstevel@tonic-gate bam_error(char *format, ...)
12817c478bd9Sstevel@tonic-gate {
12827c478bd9Sstevel@tonic-gate 	va_list ap;
12837c478bd9Sstevel@tonic-gate 
12847c478bd9Sstevel@tonic-gate 	va_start(ap, format);
12857c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr, "%s: ", prog);
12867c478bd9Sstevel@tonic-gate 	(void) vfprintf(stderr, format, ap);
12877c478bd9Sstevel@tonic-gate 	va_end(ap);
12887c478bd9Sstevel@tonic-gate }
12897c478bd9Sstevel@tonic-gate 
12907c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
1291eb2bd662Svikram void
1292eb2bd662Svikram bam_derror(char *format, ...)
1293eb2bd662Svikram {
1294eb2bd662Svikram 	va_list ap;
1295eb2bd662Svikram 
1296eb2bd662Svikram 	assert(bam_debug);
1297eb2bd662Svikram 
1298eb2bd662Svikram 	va_start(ap, format);
1299eb2bd662Svikram 	(void) fprintf(stderr, "DEBUG: ");
1300eb2bd662Svikram 	(void) vfprintf(stderr, format, ap);
1301eb2bd662Svikram 	va_end(ap);
1302eb2bd662Svikram }
1303eb2bd662Svikram 
1304eb2bd662Svikram /*PRINTFLIKE1*/
1305eb2bd662Svikram void
13067c478bd9Sstevel@tonic-gate bam_print(char *format, ...)
13077c478bd9Sstevel@tonic-gate {
13087c478bd9Sstevel@tonic-gate 	va_list ap;
13097c478bd9Sstevel@tonic-gate 
13107c478bd9Sstevel@tonic-gate 	va_start(ap, format);
13117c478bd9Sstevel@tonic-gate 	(void) vfprintf(stdout, format, ap);
13127c478bd9Sstevel@tonic-gate 	va_end(ap);
13137c478bd9Sstevel@tonic-gate }
13147c478bd9Sstevel@tonic-gate 
1315ae115bc7Smrj /*PRINTFLIKE1*/
1316ae115bc7Smrj void
1317ae115bc7Smrj bam_print_stderr(char *format, ...)
1318ae115bc7Smrj {
1319ae115bc7Smrj 	va_list ap;
1320ae115bc7Smrj 
1321ae115bc7Smrj 	va_start(ap, format);
1322ae115bc7Smrj 	(void) vfprintf(stderr, format, ap);
1323ae115bc7Smrj 	va_end(ap);
1324ae115bc7Smrj }
1325ae115bc7Smrj 
132666b6aef6SWilliam Kucharski void
13277c478bd9Sstevel@tonic-gate bam_exit(int excode)
13287c478bd9Sstevel@tonic-gate {
1329cedc7e57SEnrico Perla - Sun Microsystems 	restore_env();
13307c478bd9Sstevel@tonic-gate 	bam_unlock();
13317c478bd9Sstevel@tonic-gate 	exit(excode);
13327c478bd9Sstevel@tonic-gate }
13337c478bd9Sstevel@tonic-gate 
13347c478bd9Sstevel@tonic-gate static void
13357c478bd9Sstevel@tonic-gate bam_lock(void)
13367c478bd9Sstevel@tonic-gate {
13377c478bd9Sstevel@tonic-gate 	struct flock lock;
13387c478bd9Sstevel@tonic-gate 	pid_t pid;
13397c478bd9Sstevel@tonic-gate 
13407c478bd9Sstevel@tonic-gate 	bam_lock_fd = open(BAM_LOCK_FILE, O_CREAT|O_RDWR, LOCK_FILE_PERMS);
13417c478bd9Sstevel@tonic-gate 	if (bam_lock_fd < 0) {
13427c478bd9Sstevel@tonic-gate 		/*
13437c478bd9Sstevel@tonic-gate 		 * We may be invoked early in boot for archive verification.
13447c478bd9Sstevel@tonic-gate 		 * In this case, root is readonly and /var/run may not exist.
13457c478bd9Sstevel@tonic-gate 		 * Proceed without the lock
13467c478bd9Sstevel@tonic-gate 		 */
13477c478bd9Sstevel@tonic-gate 		if (errno == EROFS || errno == ENOENT) {
13487c478bd9Sstevel@tonic-gate 			bam_root_readonly = 1;
13497c478bd9Sstevel@tonic-gate 			return;
13507c478bd9Sstevel@tonic-gate 		}
13517c478bd9Sstevel@tonic-gate 
13527c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, BAM_LOCK_FILE, strerror(errno));
13537c478bd9Sstevel@tonic-gate 		bam_exit(1);
13547c478bd9Sstevel@tonic-gate 	}
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 	lock.l_type = F_WRLCK;
13577c478bd9Sstevel@tonic-gate 	lock.l_whence = SEEK_SET;
13587c478bd9Sstevel@tonic-gate 	lock.l_start = 0;
13597c478bd9Sstevel@tonic-gate 	lock.l_len = 0;
13607c478bd9Sstevel@tonic-gate 
13617c478bd9Sstevel@tonic-gate 	if (fcntl(bam_lock_fd, F_SETLK, &lock) == -1) {
13627c478bd9Sstevel@tonic-gate 		if (errno != EACCES && errno != EAGAIN) {
13637c478bd9Sstevel@tonic-gate 			bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
13647c478bd9Sstevel@tonic-gate 			(void) close(bam_lock_fd);
13657c478bd9Sstevel@tonic-gate 			bam_lock_fd = -1;
13667c478bd9Sstevel@tonic-gate 			bam_exit(1);
13677c478bd9Sstevel@tonic-gate 		}
13687c478bd9Sstevel@tonic-gate 		pid = 0;
13697c478bd9Sstevel@tonic-gate 		(void) pread(bam_lock_fd, &pid, sizeof (pid_t), 0);
13707c478bd9Sstevel@tonic-gate 		bam_print(FILE_LOCKED, pid);
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate 		lock.l_type = F_WRLCK;
13737c478bd9Sstevel@tonic-gate 		lock.l_whence = SEEK_SET;
13747c478bd9Sstevel@tonic-gate 		lock.l_start = 0;
13757c478bd9Sstevel@tonic-gate 		lock.l_len = 0;
13767c478bd9Sstevel@tonic-gate 		if (fcntl(bam_lock_fd, F_SETLKW, &lock) == -1) {
13777c478bd9Sstevel@tonic-gate 			bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
13787c478bd9Sstevel@tonic-gate 			(void) close(bam_lock_fd);
13797c478bd9Sstevel@tonic-gate 			bam_lock_fd = -1;
13807c478bd9Sstevel@tonic-gate 			bam_exit(1);
13817c478bd9Sstevel@tonic-gate 		}
13827c478bd9Sstevel@tonic-gate 	}
13837c478bd9Sstevel@tonic-gate 
13847c478bd9Sstevel@tonic-gate 	/* We own the lock now */
13857c478bd9Sstevel@tonic-gate 	pid = getpid();
13867c478bd9Sstevel@tonic-gate 	(void) write(bam_lock_fd, &pid, sizeof (pid));
13877c478bd9Sstevel@tonic-gate }
13887c478bd9Sstevel@tonic-gate 
13897c478bd9Sstevel@tonic-gate static void
13907c478bd9Sstevel@tonic-gate bam_unlock(void)
13917c478bd9Sstevel@tonic-gate {
13927c478bd9Sstevel@tonic-gate 	struct flock unlock;
13937c478bd9Sstevel@tonic-gate 
13947c478bd9Sstevel@tonic-gate 	/*
13957c478bd9Sstevel@tonic-gate 	 * NOP if we don't hold the lock
13967c478bd9Sstevel@tonic-gate 	 */
13977c478bd9Sstevel@tonic-gate 	if (bam_lock_fd < 0) {
13987c478bd9Sstevel@tonic-gate 		return;
13997c478bd9Sstevel@tonic-gate 	}
14007c478bd9Sstevel@tonic-gate 
14017c478bd9Sstevel@tonic-gate 	unlock.l_type = F_UNLCK;
14027c478bd9Sstevel@tonic-gate 	unlock.l_whence = SEEK_SET;
14037c478bd9Sstevel@tonic-gate 	unlock.l_start = 0;
14047c478bd9Sstevel@tonic-gate 	unlock.l_len = 0;
14057c478bd9Sstevel@tonic-gate 
14067c478bd9Sstevel@tonic-gate 	if (fcntl(bam_lock_fd, F_SETLK, &unlock) == -1) {
14077c478bd9Sstevel@tonic-gate 		bam_error(UNLOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
14087c478bd9Sstevel@tonic-gate 	}
14097c478bd9Sstevel@tonic-gate 
14107c478bd9Sstevel@tonic-gate 	if (close(bam_lock_fd) == -1) {
14117c478bd9Sstevel@tonic-gate 		bam_error(CLOSE_FAIL, BAM_LOCK_FILE, strerror(errno));
14127c478bd9Sstevel@tonic-gate 	}
14137c478bd9Sstevel@tonic-gate 	bam_lock_fd = -1;
14147c478bd9Sstevel@tonic-gate }
14157c478bd9Sstevel@tonic-gate 
14167c478bd9Sstevel@tonic-gate static error_t
14177c478bd9Sstevel@tonic-gate list_archive(char *root, char *opt)
14187c478bd9Sstevel@tonic-gate {
14197c478bd9Sstevel@tonic-gate 	filelist_t flist;
14207c478bd9Sstevel@tonic-gate 	filelist_t *flistp = &flist;
14217c478bd9Sstevel@tonic-gate 	line_t *lp;
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 	assert(root);
14247c478bd9Sstevel@tonic-gate 	assert(opt == NULL);
14257c478bd9Sstevel@tonic-gate 
14267c478bd9Sstevel@tonic-gate 	flistp->head = flistp->tail = NULL;
14277c478bd9Sstevel@tonic-gate 	if (read_list(root, flistp) != BAM_SUCCESS) {
14287c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
14297c478bd9Sstevel@tonic-gate 	}
14307c478bd9Sstevel@tonic-gate 	assert(flistp->head && flistp->tail);
14317c478bd9Sstevel@tonic-gate 
14327c478bd9Sstevel@tonic-gate 	for (lp = flistp->head; lp; lp = lp->next) {
14337c478bd9Sstevel@tonic-gate 		bam_print(PRINT, lp->line);
14347c478bd9Sstevel@tonic-gate 	}
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate 	filelist_free(flistp);
14377c478bd9Sstevel@tonic-gate 
14387c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
14397c478bd9Sstevel@tonic-gate }
14407c478bd9Sstevel@tonic-gate 
14417c478bd9Sstevel@tonic-gate /*
14427c478bd9Sstevel@tonic-gate  * This routine writes a list of lines to a file.
14437c478bd9Sstevel@tonic-gate  * The list is *not* freed
14447c478bd9Sstevel@tonic-gate  */
14457c478bd9Sstevel@tonic-gate static error_t
14467c478bd9Sstevel@tonic-gate list2file(char *root, char *tmp, char *final, line_t *start)
14477c478bd9Sstevel@tonic-gate {
14487c478bd9Sstevel@tonic-gate 	char		tmpfile[PATH_MAX];
14497c478bd9Sstevel@tonic-gate 	char		path[PATH_MAX];
14507c478bd9Sstevel@tonic-gate 	FILE		*fp;
14517c478bd9Sstevel@tonic-gate 	int		ret;
14527c478bd9Sstevel@tonic-gate 	struct stat	sb;
14537c478bd9Sstevel@tonic-gate 	mode_t		mode;
14547c478bd9Sstevel@tonic-gate 	uid_t		root_uid;
14557c478bd9Sstevel@tonic-gate 	gid_t		sys_gid;
14567c478bd9Sstevel@tonic-gate 	struct passwd	*pw;
14577c478bd9Sstevel@tonic-gate 	struct group	*gp;
1458eb2bd662Svikram 	const char	*fcn = "list2file()";
14597c478bd9Sstevel@tonic-gate 
14607c478bd9Sstevel@tonic-gate 	(void) snprintf(path, sizeof (path), "%s%s", root, final);
14617c478bd9Sstevel@tonic-gate 
14627c478bd9Sstevel@tonic-gate 	if (start == NULL) {
1463eb2bd662Svikram 		/* Empty GRUB menu */
14647c478bd9Sstevel@tonic-gate 		if (stat(path, &sb) != -1) {
14657c478bd9Sstevel@tonic-gate 			bam_print(UNLINK_EMPTY, path);
14667c478bd9Sstevel@tonic-gate 			if (unlink(path) != 0) {
14677c478bd9Sstevel@tonic-gate 				bam_error(UNLINK_FAIL, path, strerror(errno));
14687c478bd9Sstevel@tonic-gate 				return (BAM_ERROR);
14697c478bd9Sstevel@tonic-gate 			} else {
14707c478bd9Sstevel@tonic-gate 				return (BAM_SUCCESS);
14717c478bd9Sstevel@tonic-gate 			}
14727c478bd9Sstevel@tonic-gate 		}
1473eb2bd662Svikram 		return (BAM_SUCCESS);
14747c478bd9Sstevel@tonic-gate 	}
14757c478bd9Sstevel@tonic-gate 
14767c478bd9Sstevel@tonic-gate 	/*
14777c478bd9Sstevel@tonic-gate 	 * Preserve attributes of existing file if possible,
14787c478bd9Sstevel@tonic-gate 	 * otherwise ask the system for uid/gid of root/sys.
14797c478bd9Sstevel@tonic-gate 	 * If all fails, fall back on hard-coded defaults.
14807c478bd9Sstevel@tonic-gate 	 */
14817c478bd9Sstevel@tonic-gate 	if (stat(path, &sb) != -1) {
14827c478bd9Sstevel@tonic-gate 		mode = sb.st_mode;
14837c478bd9Sstevel@tonic-gate 		root_uid = sb.st_uid;
14847c478bd9Sstevel@tonic-gate 		sys_gid = sb.st_gid;
14857c478bd9Sstevel@tonic-gate 	} else {
14867c478bd9Sstevel@tonic-gate 		mode = DEFAULT_DEV_MODE;
14877c478bd9Sstevel@tonic-gate 		if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
14887c478bd9Sstevel@tonic-gate 			root_uid = pw->pw_uid;
14897c478bd9Sstevel@tonic-gate 		} else {
14907c478bd9Sstevel@tonic-gate 			bam_error(CANT_FIND_USER,
14917c478bd9Sstevel@tonic-gate 			    DEFAULT_DEV_USER, DEFAULT_DEV_UID);
14927c478bd9Sstevel@tonic-gate 			root_uid = (uid_t)DEFAULT_DEV_UID;
14937c478bd9Sstevel@tonic-gate 		}
14947c478bd9Sstevel@tonic-gate 		if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
14957c478bd9Sstevel@tonic-gate 			sys_gid = gp->gr_gid;
14967c478bd9Sstevel@tonic-gate 		} else {
14977c478bd9Sstevel@tonic-gate 			bam_error(CANT_FIND_GROUP,
14987c478bd9Sstevel@tonic-gate 			    DEFAULT_DEV_GROUP, DEFAULT_DEV_GID);
14997c478bd9Sstevel@tonic-gate 			sys_gid = (gid_t)DEFAULT_DEV_GID;
15007c478bd9Sstevel@tonic-gate 		}
15017c478bd9Sstevel@tonic-gate 	}
15027c478bd9Sstevel@tonic-gate 
15037c478bd9Sstevel@tonic-gate 	(void) snprintf(tmpfile, sizeof (tmpfile), "%s%s", root, tmp);
15047c478bd9Sstevel@tonic-gate 
15057c478bd9Sstevel@tonic-gate 	/* Truncate tmpfile first */
15067c478bd9Sstevel@tonic-gate 	fp = fopen(tmpfile, "w");
15077c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
15087c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, tmpfile, strerror(errno));
15097c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15107c478bd9Sstevel@tonic-gate 	}
1511963390b4Svikram 	ret = fclose(fp);
1512963390b4Svikram 	INJECT_ERROR1("LIST2FILE_TRUNC_FCLOSE", ret = EOF);
1513963390b4Svikram 	if (ret == EOF) {
15147c478bd9Sstevel@tonic-gate 		bam_error(CLOSE_FAIL, tmpfile, strerror(errno));
15157c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15167c478bd9Sstevel@tonic-gate 	}
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate 	/* Now open it in append mode */
15197c478bd9Sstevel@tonic-gate 	fp = fopen(tmpfile, "a");
15207c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
15217c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, tmpfile, strerror(errno));
15227c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15237c478bd9Sstevel@tonic-gate 	}
15247c478bd9Sstevel@tonic-gate 
15257c478bd9Sstevel@tonic-gate 	for (; start; start = start->next) {
1526963390b4Svikram 		ret = s_fputs(start->line, fp);
1527963390b4Svikram 		INJECT_ERROR1("LIST2FILE_FPUTS", ret = EOF);
1528963390b4Svikram 		if (ret == EOF) {
15297c478bd9Sstevel@tonic-gate 			bam_error(WRITE_FAIL, tmpfile, strerror(errno));
15307c478bd9Sstevel@tonic-gate 			(void) fclose(fp);
15317c478bd9Sstevel@tonic-gate 			return (BAM_ERROR);
15327c478bd9Sstevel@tonic-gate 		}
15337c478bd9Sstevel@tonic-gate 	}
15347c478bd9Sstevel@tonic-gate 
1535963390b4Svikram 	ret = fclose(fp);
1536963390b4Svikram 	INJECT_ERROR1("LIST2FILE_APPEND_FCLOSE", ret = EOF);
1537963390b4Svikram 	if (ret == EOF) {
15387c478bd9Sstevel@tonic-gate 		bam_error(CLOSE_FAIL, tmpfile, strerror(errno));
15397c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15407c478bd9Sstevel@tonic-gate 	}
15417c478bd9Sstevel@tonic-gate 
15427c478bd9Sstevel@tonic-gate 	/*
1543de531be4Sjg 	 * Set up desired attributes.  Ignore failures on filesystems
1544de531be4Sjg 	 * not supporting these operations - pcfs reports unsupported
1545de531be4Sjg 	 * operations as EINVAL.
15467c478bd9Sstevel@tonic-gate 	 */
15477c478bd9Sstevel@tonic-gate 	ret = chmod(tmpfile, mode);
1548de531be4Sjg 	if (ret == -1 &&
1549de531be4Sjg 	    errno != EINVAL && errno != ENOTSUP) {
15507c478bd9Sstevel@tonic-gate 		bam_error(CHMOD_FAIL, tmpfile, strerror(errno));
15517c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15527c478bd9Sstevel@tonic-gate 	}
15537c478bd9Sstevel@tonic-gate 
15547c478bd9Sstevel@tonic-gate 	ret = chown(tmpfile, root_uid, sys_gid);
1555de531be4Sjg 	if (ret == -1 &&
1556de531be4Sjg 	    errno != EINVAL && errno != ENOTSUP) {
15577c478bd9Sstevel@tonic-gate 		bam_error(CHOWN_FAIL, tmpfile, strerror(errno));
15587c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15597c478bd9Sstevel@tonic-gate 	}
15607c478bd9Sstevel@tonic-gate 
15617c478bd9Sstevel@tonic-gate 	/*
15627c478bd9Sstevel@tonic-gate 	 * Do an atomic rename
15637c478bd9Sstevel@tonic-gate 	 */
15647c478bd9Sstevel@tonic-gate 	ret = rename(tmpfile, path);
1565963390b4Svikram 	INJECT_ERROR1("LIST2FILE_RENAME", ret = -1);
15667c478bd9Sstevel@tonic-gate 	if (ret != 0) {
15677c478bd9Sstevel@tonic-gate 		bam_error(RENAME_FAIL, path, strerror(errno));
15687c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
15697c478bd9Sstevel@tonic-gate 	}
15707c478bd9Sstevel@tonic-gate 
1571eb2bd662Svikram 	BAM_DPRINTF((D_WROTE_FILE, fcn, path));
15727c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
15737c478bd9Sstevel@tonic-gate }
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate /*
157648847494SEnrico Perla - Sun Microsystems  * Checks if the path specified (without the file name at the end) exists
157748847494SEnrico Perla - Sun Microsystems  * and creates it if not. If the path exists and is not a directory, an attempt
157848847494SEnrico Perla - Sun Microsystems  * to unlink is made.
15797c478bd9Sstevel@tonic-gate  */
158048847494SEnrico Perla - Sun Microsystems static int
158148847494SEnrico Perla - Sun Microsystems setup_path(char *path)
158248847494SEnrico Perla - Sun Microsystems {
158348847494SEnrico Perla - Sun Microsystems 	char 		*p;
158448847494SEnrico Perla - Sun Microsystems 	int		ret;
158548847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
158648847494SEnrico Perla - Sun Microsystems 
158748847494SEnrico Perla - Sun Microsystems 	p = strrchr(path, '/');
158848847494SEnrico Perla - Sun Microsystems 	if (p != NULL) {
158948847494SEnrico Perla - Sun Microsystems 		*p = '\0';
159048847494SEnrico Perla - Sun Microsystems 		if (stat(path, &sb) != 0 || !(S_ISDIR(sb.st_mode))) {
159148847494SEnrico Perla - Sun Microsystems 			/* best effort attempt, mkdirp will catch the error */
159248847494SEnrico Perla - Sun Microsystems 			(void) unlink(path);
159348847494SEnrico Perla - Sun Microsystems 			if (bam_verbose)
159448847494SEnrico Perla - Sun Microsystems 				bam_print(NEED_DIRPATH, path);
159548847494SEnrico Perla - Sun Microsystems 			ret = mkdirp(path, DIR_PERMS);
159648847494SEnrico Perla - Sun Microsystems 			if (ret == -1) {
159748847494SEnrico Perla - Sun Microsystems 				bam_error(MKDIR_FAILED, path, strerror(errno));
159848847494SEnrico Perla - Sun Microsystems 				*p = '/';
159948847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
160048847494SEnrico Perla - Sun Microsystems 			}
160148847494SEnrico Perla - Sun Microsystems 		}
160248847494SEnrico Perla - Sun Microsystems 		*p = '/';
160348847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
160448847494SEnrico Perla - Sun Microsystems 	}
160548847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
160648847494SEnrico Perla - Sun Microsystems }
160748847494SEnrico Perla - Sun Microsystems 
160848847494SEnrico Perla - Sun Microsystems typedef union {
160948847494SEnrico Perla - Sun Microsystems 	gzFile	gzfile;
161048847494SEnrico Perla - Sun Microsystems 	int	fdfile;
161148847494SEnrico Perla - Sun Microsystems } outfile;
161248847494SEnrico Perla - Sun Microsystems 
161348847494SEnrico Perla - Sun Microsystems typedef struct {
161448847494SEnrico Perla - Sun Microsystems 	char		path[PATH_MAX];
161548847494SEnrico Perla - Sun Microsystems 	outfile		out;
161648847494SEnrico Perla - Sun Microsystems } cachefile;
161748847494SEnrico Perla - Sun Microsystems 
161848847494SEnrico Perla - Sun Microsystems static int
161948847494SEnrico Perla - Sun Microsystems setup_file(char *base, const char *path, cachefile *cf)
162048847494SEnrico Perla - Sun Microsystems {
162148847494SEnrico Perla - Sun Microsystems 	int	ret;
162248847494SEnrico Perla - Sun Microsystems 	char	*strip;
162348847494SEnrico Perla - Sun Microsystems 
162448847494SEnrico Perla - Sun Microsystems 	/* init gzfile or fdfile in case we fail before opening */
162548847494SEnrico Perla - Sun Microsystems 	if (bam_direct == BAM_DIRECT_DBOOT)
162648847494SEnrico Perla - Sun Microsystems 		cf->out.gzfile = NULL;
162748847494SEnrico Perla - Sun Microsystems 	else
162848847494SEnrico Perla - Sun Microsystems 		cf->out.fdfile = -1;
162948847494SEnrico Perla - Sun Microsystems 
163048847494SEnrico Perla - Sun Microsystems 	/* strip the trailing altroot path */
163148847494SEnrico Perla - Sun Microsystems 	strip = (char *)path + strlen(rootbuf);
163248847494SEnrico Perla - Sun Microsystems 
163348847494SEnrico Perla - Sun Microsystems 	ret = snprintf(cf->path, sizeof (cf->path), "%s/%s", base, strip);
163448847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (cf->path)) {
163548847494SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
163648847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
163748847494SEnrico Perla - Sun Microsystems 	}
163848847494SEnrico Perla - Sun Microsystems 
163948847494SEnrico Perla - Sun Microsystems 	/* Check if path is present in the archive cache directory */
164048847494SEnrico Perla - Sun Microsystems 	if (setup_path(cf->path) == BAM_ERROR)
164148847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
164248847494SEnrico Perla - Sun Microsystems 
164348847494SEnrico Perla - Sun Microsystems 	if (bam_direct == BAM_DIRECT_DBOOT) {
164448847494SEnrico Perla - Sun Microsystems 		if ((cf->out.gzfile = gzopen(cf->path, "wb")) == NULL) {
1645cedc7e57SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, cf->path, strerror(errno));
164648847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
164748847494SEnrico Perla - Sun Microsystems 		}
164848847494SEnrico Perla - Sun Microsystems 		(void) gzsetparams(cf->out.gzfile, Z_BEST_SPEED,
164948847494SEnrico Perla - Sun Microsystems 		    Z_DEFAULT_STRATEGY);
165048847494SEnrico Perla - Sun Microsystems 	} else {
165148847494SEnrico Perla - Sun Microsystems 		if ((cf->out.fdfile = open(cf->path, O_WRONLY | O_CREAT, 0644))
165248847494SEnrico Perla - Sun Microsystems 		    == -1) {
165348847494SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, cf->path, strerror(errno));
165448847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
165548847494SEnrico Perla - Sun Microsystems 		}
165648847494SEnrico Perla - Sun Microsystems 	}
165748847494SEnrico Perla - Sun Microsystems 
165848847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
165948847494SEnrico Perla - Sun Microsystems }
166048847494SEnrico Perla - Sun Microsystems 
166148847494SEnrico Perla - Sun Microsystems static int
166248847494SEnrico Perla - Sun Microsystems cache_write(cachefile cf, char *buf, int size)
166348847494SEnrico Perla - Sun Microsystems {
166448847494SEnrico Perla - Sun Microsystems 	int	err;
166548847494SEnrico Perla - Sun Microsystems 
166648847494SEnrico Perla - Sun Microsystems 	if (bam_direct == BAM_DIRECT_DBOOT) {
166748847494SEnrico Perla - Sun Microsystems 		if (gzwrite(cf.out.gzfile, buf, size) < 1) {
166848847494SEnrico Perla - Sun Microsystems 			bam_error(GZ_WRITE_FAIL, gzerror(cf.out.gzfile, &err));
1669cedc7e57SEnrico Perla - Sun Microsystems 			if (err == Z_ERRNO && bam_verbose) {
167048847494SEnrico Perla - Sun Microsystems 				bam_error(WRITE_FAIL, cf.path, strerror(errno));
1671cedc7e57SEnrico Perla - Sun Microsystems 			}
167248847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
167348847494SEnrico Perla - Sun Microsystems 		}
167448847494SEnrico Perla - Sun Microsystems 	} else {
167548847494SEnrico Perla - Sun Microsystems 		if (write(cf.out.fdfile, buf, size) < 1) {
167648847494SEnrico Perla - Sun Microsystems 			bam_error(WRITE_FAIL, cf.path, strerror(errno));
167748847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
167848847494SEnrico Perla - Sun Microsystems 		}
167948847494SEnrico Perla - Sun Microsystems 	}
168048847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
168148847494SEnrico Perla - Sun Microsystems }
168248847494SEnrico Perla - Sun Microsystems 
168348847494SEnrico Perla - Sun Microsystems static int
168448847494SEnrico Perla - Sun Microsystems cache_close(cachefile cf)
168548847494SEnrico Perla - Sun Microsystems {
168648847494SEnrico Perla - Sun Microsystems 	int	ret;
168748847494SEnrico Perla - Sun Microsystems 
168848847494SEnrico Perla - Sun Microsystems 	if (bam_direct == BAM_DIRECT_DBOOT) {
168948847494SEnrico Perla - Sun Microsystems 		if (cf.out.gzfile) {
169048847494SEnrico Perla - Sun Microsystems 			ret = gzclose(cf.out.gzfile);
1691cedc7e57SEnrico Perla - Sun Microsystems 			if (ret != Z_OK) {
169248847494SEnrico Perla - Sun Microsystems 				bam_error(CLOSE_FAIL, cf.path, strerror(errno));
169348847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
169448847494SEnrico Perla - Sun Microsystems 			}
1695cedc7e57SEnrico Perla - Sun Microsystems 		}
169648847494SEnrico Perla - Sun Microsystems 	} else {
169748847494SEnrico Perla - Sun Microsystems 		if (cf.out.fdfile != -1) {
169848847494SEnrico Perla - Sun Microsystems 			ret = close(cf.out.fdfile);
169948847494SEnrico Perla - Sun Microsystems 			if (ret != 0) {
170048847494SEnrico Perla - Sun Microsystems 				bam_error(CLOSE_FAIL, cf.path, strerror(errno));
170148847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
170248847494SEnrico Perla - Sun Microsystems 			}
170348847494SEnrico Perla - Sun Microsystems 		}
170448847494SEnrico Perla - Sun Microsystems 	}
170548847494SEnrico Perla - Sun Microsystems 
170648847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
170748847494SEnrico Perla - Sun Microsystems }
170848847494SEnrico Perla - Sun Microsystems 
170948847494SEnrico Perla - Sun Microsystems static int
171048847494SEnrico Perla - Sun Microsystems dircache_updatefile(const char *path, int what)
171148847494SEnrico Perla - Sun Microsystems {
171248847494SEnrico Perla - Sun Microsystems 	int 		ret, exitcode;
171348847494SEnrico Perla - Sun Microsystems 	char 		buf[4096 * 4];
171448847494SEnrico Perla - Sun Microsystems 	FILE 		*infile;
171548847494SEnrico Perla - Sun Microsystems 	cachefile 	outfile, outupdt;
171648847494SEnrico Perla - Sun Microsystems 
1717cedc7e57SEnrico Perla - Sun Microsystems 	if (bam_nowrite()) {
1718cedc7e57SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NEED_UPDATE);
1719cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
1720cedc7e57SEnrico Perla - Sun Microsystems 	}
1721cedc7e57SEnrico Perla - Sun Microsystems 
1722cedc7e57SEnrico Perla - Sun Microsystems 	if (!has_cachedir(what))
172348847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
172448847494SEnrico Perla - Sun Microsystems 
172548847494SEnrico Perla - Sun Microsystems 	if ((infile = fopen(path, "rb")) == NULL) {
172648847494SEnrico Perla - Sun Microsystems 		bam_error(OPEN_FAIL, path, strerror(errno));
172748847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
172848847494SEnrico Perla - Sun Microsystems 	}
172948847494SEnrico Perla - Sun Microsystems 
173048847494SEnrico Perla - Sun Microsystems 	ret = setup_file(get_cachedir(what), path, &outfile);
173148847494SEnrico Perla - Sun Microsystems 	if (ret == BAM_ERROR) {
173248847494SEnrico Perla - Sun Microsystems 		exitcode = BAM_ERROR;
173348847494SEnrico Perla - Sun Microsystems 		goto out;
173448847494SEnrico Perla - Sun Microsystems 	}
173548847494SEnrico Perla - Sun Microsystems 	if (!is_dir_flag_on(what, NO_MULTI)) {
173648847494SEnrico Perla - Sun Microsystems 		ret = setup_file(get_updatedir(what), path, &outupdt);
173748847494SEnrico Perla - Sun Microsystems 		if (ret == BAM_ERROR)
173848847494SEnrico Perla - Sun Microsystems 			set_dir_flag(what, NO_MULTI);
173948847494SEnrico Perla - Sun Microsystems 	}
174048847494SEnrico Perla - Sun Microsystems 
174148847494SEnrico Perla - Sun Microsystems 	while ((ret = fread(buf, 1, sizeof (buf), infile)) > 0) {
174248847494SEnrico Perla - Sun Microsystems 		if (cache_write(outfile, buf, ret) == BAM_ERROR) {
174348847494SEnrico Perla - Sun Microsystems 			exitcode = BAM_ERROR;
174448847494SEnrico Perla - Sun Microsystems 			goto out;
174548847494SEnrico Perla - Sun Microsystems 		}
174648847494SEnrico Perla - Sun Microsystems 		if (!is_dir_flag_on(what, NO_MULTI))
174748847494SEnrico Perla - Sun Microsystems 			if (cache_write(outupdt, buf, ret) == BAM_ERROR)
174848847494SEnrico Perla - Sun Microsystems 				set_dir_flag(what, NO_MULTI);
174948847494SEnrico Perla - Sun Microsystems 	}
175048847494SEnrico Perla - Sun Microsystems 
175148847494SEnrico Perla - Sun Microsystems 	set_dir_flag(what, NEED_UPDATE);
175248847494SEnrico Perla - Sun Microsystems 	get_count(what)++;
1753cedc7e57SEnrico Perla - Sun Microsystems 	if (get_count(what) > COUNT_MAX)
1754cedc7e57SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
175548847494SEnrico Perla - Sun Microsystems 	exitcode = BAM_SUCCESS;
175648847494SEnrico Perla - Sun Microsystems out:
175748847494SEnrico Perla - Sun Microsystems 	(void) fclose(infile);
175848847494SEnrico Perla - Sun Microsystems 	if (cache_close(outfile) == BAM_ERROR)
175948847494SEnrico Perla - Sun Microsystems 		exitcode = BAM_ERROR;
176048847494SEnrico Perla - Sun Microsystems 	if (!is_dir_flag_on(what, NO_MULTI) &&
176148847494SEnrico Perla - Sun Microsystems 	    cache_close(outupdt) == BAM_ERROR)
176248847494SEnrico Perla - Sun Microsystems 		exitcode = BAM_ERROR;
176348847494SEnrico Perla - Sun Microsystems 	if (exitcode == BAM_ERROR)
176448847494SEnrico Perla - Sun Microsystems 		set_flag(UPDATE_ERROR);
176548847494SEnrico Perla - Sun Microsystems 	return (exitcode);
176648847494SEnrico Perla - Sun Microsystems }
176748847494SEnrico Perla - Sun Microsystems 
176848847494SEnrico Perla - Sun Microsystems static int
176948847494SEnrico Perla - Sun Microsystems dircache_updatedir(const char *path, int what, int updt)
177048847494SEnrico Perla - Sun Microsystems {
177148847494SEnrico Perla - Sun Microsystems 	int		ret;
177248847494SEnrico Perla - Sun Microsystems 	char		dpath[PATH_MAX];
177348847494SEnrico Perla - Sun Microsystems 	char		*strip;
177448847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
177548847494SEnrico Perla - Sun Microsystems 
177648847494SEnrico Perla - Sun Microsystems 	strip = (char *)path + strlen(rootbuf);
177748847494SEnrico Perla - Sun Microsystems 
177848847494SEnrico Perla - Sun Microsystems 	ret = snprintf(dpath, sizeof (dpath), "%s/%s", updt ?
177948847494SEnrico Perla - Sun Microsystems 	    get_updatedir(what) : get_cachedir(what), strip);
178048847494SEnrico Perla - Sun Microsystems 
178148847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (dpath)) {
178248847494SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
178348847494SEnrico Perla - Sun Microsystems 		set_flag(UPDATE_ERROR);
178448847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
178548847494SEnrico Perla - Sun Microsystems 	}
178648847494SEnrico Perla - Sun Microsystems 
178748847494SEnrico Perla - Sun Microsystems 	if (stat(dpath, &sb) == 0 && S_ISDIR(sb.st_mode))
178848847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
178948847494SEnrico Perla - Sun Microsystems 
179048847494SEnrico Perla - Sun Microsystems 	if (updt) {
179148847494SEnrico Perla - Sun Microsystems 		if (!is_dir_flag_on(what, NO_MULTI))
179248847494SEnrico Perla - Sun Microsystems 			if (!bam_nowrite() && mkdirp(dpath, DIR_PERMS) == -1)
179348847494SEnrico Perla - Sun Microsystems 				set_dir_flag(what, NO_MULTI);
179448847494SEnrico Perla - Sun Microsystems 	} else {
179548847494SEnrico Perla - Sun Microsystems 		if (!bam_nowrite() && mkdirp(dpath, DIR_PERMS) == -1) {
179648847494SEnrico Perla - Sun Microsystems 			set_flag(UPDATE_ERROR);
179748847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
179848847494SEnrico Perla - Sun Microsystems 		}
179948847494SEnrico Perla - Sun Microsystems 	}
180048847494SEnrico Perla - Sun Microsystems 
180148847494SEnrico Perla - Sun Microsystems 	set_dir_flag(what, NEED_UPDATE);
180248847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
180348847494SEnrico Perla - Sun Microsystems }
180448847494SEnrico Perla - Sun Microsystems 
180548847494SEnrico Perla - Sun Microsystems #define	DO_CACHE_DIR	0
180648847494SEnrico Perla - Sun Microsystems #define	DO_UPDATE_DIR	1
180748847494SEnrico Perla - Sun Microsystems 
180848847494SEnrico Perla - Sun Microsystems #if defined(_LP64) || defined(_LONGLONG_TYPE)
180948847494SEnrico Perla - Sun Microsystems typedef		Elf64_Ehdr	_elfhdr;
181048847494SEnrico Perla - Sun Microsystems #else
181148847494SEnrico Perla - Sun Microsystems typedef		Elf32_Ehdr	_elfhdr;
181248847494SEnrico Perla - Sun Microsystems #endif
181348847494SEnrico Perla - Sun Microsystems 
181448847494SEnrico Perla - Sun Microsystems /*
181548847494SEnrico Perla - Sun Microsystems  * This routine updates the contents of the cache directory
181648847494SEnrico Perla - Sun Microsystems  */
181748847494SEnrico Perla - Sun Microsystems static int
181848847494SEnrico Perla - Sun Microsystems update_dircache(const char *path, int flags)
181948847494SEnrico Perla - Sun Microsystems {
182048847494SEnrico Perla - Sun Microsystems 	int rc = BAM_SUCCESS;
182148847494SEnrico Perla - Sun Microsystems 
182248847494SEnrico Perla - Sun Microsystems 	switch (flags) {
182348847494SEnrico Perla - Sun Microsystems 	case FTW_F:
182448847494SEnrico Perla - Sun Microsystems 		{
182548847494SEnrico Perla - Sun Microsystems 		int	fd;
182648847494SEnrico Perla - Sun Microsystems 		_elfhdr	elf;
182748847494SEnrico Perla - Sun Microsystems 
182848847494SEnrico Perla - Sun Microsystems 		if ((fd = open(path, O_RDONLY)) < 0) {
182948847494SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, path, strerror(errno));
183048847494SEnrico Perla - Sun Microsystems 			set_flag(UPDATE_ERROR);
183148847494SEnrico Perla - Sun Microsystems 			rc = BAM_ERROR;
183248847494SEnrico Perla - Sun Microsystems 			break;
183348847494SEnrico Perla - Sun Microsystems 		}
183448847494SEnrico Perla - Sun Microsystems 
183548847494SEnrico Perla - Sun Microsystems 		/*
183648847494SEnrico Perla - Sun Microsystems 		 * libelf and gelf would be a cleaner and easier way to handle
183748847494SEnrico Perla - Sun Microsystems 		 * this, but libelf fails compilation if _ILP32 is defined &&
183848847494SEnrico Perla - Sun Microsystems 		 * _FILE_OFFSET_BITS is != 32 ...
183948847494SEnrico Perla - Sun Microsystems 		 */
184048847494SEnrico Perla - Sun Microsystems 		if (read(fd, (void *)&elf, sizeof (_elfhdr)) < 0) {
184148847494SEnrico Perla - Sun Microsystems 			bam_error(READ_FAIL, path, strerror(errno));
184248847494SEnrico Perla - Sun Microsystems 			set_flag(UPDATE_ERROR);
184348847494SEnrico Perla - Sun Microsystems 			(void) close(fd);
184448847494SEnrico Perla - Sun Microsystems 			rc = BAM_ERROR;
184548847494SEnrico Perla - Sun Microsystems 			break;
184648847494SEnrico Perla - Sun Microsystems 		}
184748847494SEnrico Perla - Sun Microsystems 		(void) close(fd);
184848847494SEnrico Perla - Sun Microsystems 
184948847494SEnrico Perla - Sun Microsystems 		/*
185048847494SEnrico Perla - Sun Microsystems 		 * If the file is not an executable and is not inside an amd64
185148847494SEnrico Perla - Sun Microsystems 		 * directory, we copy it in both the cache directories,
185248847494SEnrico Perla - Sun Microsystems 		 * otherwise, we only copy it inside the 64-bit one.
185348847494SEnrico Perla - Sun Microsystems 		 */
185448847494SEnrico Perla - Sun Microsystems 		if (memcmp(elf.e_ident, ELFMAG, 4) != 0) {
185548847494SEnrico Perla - Sun Microsystems 			if (strstr(path, "/amd64")) {
185648847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatefile(path, FILE64);
185748847494SEnrico Perla - Sun Microsystems 			} else {
185848847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatefile(path, FILE32);
1859cedc7e57SEnrico Perla - Sun Microsystems 				if (rc == BAM_SUCCESS)
1860cedc7e57SEnrico Perla - Sun Microsystems 					rc = dircache_updatefile(path, FILE64);
186148847494SEnrico Perla - Sun Microsystems 			}
186248847494SEnrico Perla - Sun Microsystems 		} else {
186348847494SEnrico Perla - Sun Microsystems 			/*
186448847494SEnrico Perla - Sun Microsystems 			 * Based on the ELF class we copy the file in the 32-bit
186548847494SEnrico Perla - Sun Microsystems 			 * or the 64-bit cache directory.
186648847494SEnrico Perla - Sun Microsystems 			 */
1867cedc7e57SEnrico Perla - Sun Microsystems 			if (elf.e_ident[EI_CLASS] == ELFCLASS32) {
186848847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatefile(path, FILE32);
1869cedc7e57SEnrico Perla - Sun Microsystems 			} else if (elf.e_ident[EI_CLASS] == ELFCLASS64) {
187048847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatefile(path, FILE64);
1871cedc7e57SEnrico Perla - Sun Microsystems 			} else {
187248847494SEnrico Perla - Sun Microsystems 				bam_print(NO3264ELF, path);
187348847494SEnrico Perla - Sun Microsystems 				/* paranoid */
187448847494SEnrico Perla - Sun Microsystems 				rc  = dircache_updatefile(path, FILE32);
187548847494SEnrico Perla - Sun Microsystems 				if (rc == BAM_SUCCESS)
187648847494SEnrico Perla - Sun Microsystems 					rc = dircache_updatefile(path, FILE64);
187748847494SEnrico Perla - Sun Microsystems 			}
187848847494SEnrico Perla - Sun Microsystems 		}
187948847494SEnrico Perla - Sun Microsystems 		break;
188048847494SEnrico Perla - Sun Microsystems 		}
188148847494SEnrico Perla - Sun Microsystems 	case FTW_D:
188248847494SEnrico Perla - Sun Microsystems 		if (strstr(path, "/amd64") == NULL) {
188348847494SEnrico Perla - Sun Microsystems 			rc = dircache_updatedir(path, FILE32, DO_UPDATE_DIR);
188448847494SEnrico Perla - Sun Microsystems 			if (rc == BAM_SUCCESS)
188548847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatedir(path, FILE32,
188648847494SEnrico Perla - Sun Microsystems 				    DO_CACHE_DIR);
188748847494SEnrico Perla - Sun Microsystems 		} else {
188848847494SEnrico Perla - Sun Microsystems 			if (has_cachedir(FILE64)) {
188948847494SEnrico Perla - Sun Microsystems 				rc = dircache_updatedir(path, FILE64,
189048847494SEnrico Perla - Sun Microsystems 				    DO_UPDATE_DIR);
189148847494SEnrico Perla - Sun Microsystems 				if (rc == BAM_SUCCESS)
189248847494SEnrico Perla - Sun Microsystems 					rc = dircache_updatedir(path, FILE64,
189348847494SEnrico Perla - Sun Microsystems 					    DO_CACHE_DIR);
189448847494SEnrico Perla - Sun Microsystems 			}
189548847494SEnrico Perla - Sun Microsystems 		}
189648847494SEnrico Perla - Sun Microsystems 		break;
189748847494SEnrico Perla - Sun Microsystems 	default:
189848847494SEnrico Perla - Sun Microsystems 		rc = BAM_ERROR;
189948847494SEnrico Perla - Sun Microsystems 		break;
190048847494SEnrico Perla - Sun Microsystems 	}
190148847494SEnrico Perla - Sun Microsystems 
190248847494SEnrico Perla - Sun Microsystems 	return (rc);
190348847494SEnrico Perla - Sun Microsystems }
190448847494SEnrico Perla - Sun Microsystems 
19057c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19067c478bd9Sstevel@tonic-gate static int
19077c478bd9Sstevel@tonic-gate cmpstat(
19087c478bd9Sstevel@tonic-gate 	const char *file,
190948847494SEnrico Perla - Sun Microsystems 	const struct stat *st,
19107c478bd9Sstevel@tonic-gate 	int flags,
19117c478bd9Sstevel@tonic-gate 	struct FTW *ftw)
19127c478bd9Sstevel@tonic-gate {
19137c478bd9Sstevel@tonic-gate 	uint_t 		sz;
19147c478bd9Sstevel@tonic-gate 	uint64_t 	*value;
19157c478bd9Sstevel@tonic-gate 	uint64_t 	filestat[2];
191689c3ee43SGangadhar Mylapuram 	int 		error, ret, status;
19177c478bd9Sstevel@tonic-gate 
191858091fd8Ssetje 	struct safefile *safefilep;
191958091fd8Ssetje 	FILE 		*fp;
192048847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
192189c3ee43SGangadhar Mylapuram 	regex_t re;
192258091fd8Ssetje 
19237c478bd9Sstevel@tonic-gate 	/*
192448847494SEnrico Perla - Sun Microsystems 	 * On SPARC we create/update links too.
19257c478bd9Sstevel@tonic-gate 	 */
192648847494SEnrico Perla - Sun Microsystems 	if (flags != FTW_F && flags != FTW_D && (flags == FTW_SL &&
192748847494SEnrico Perla - Sun Microsystems 	    !is_flag_on(IS_SPARC_TARGET)))
192848847494SEnrico Perla - Sun Microsystems 		return (0);
192948847494SEnrico Perla - Sun Microsystems 
193048847494SEnrico Perla - Sun Microsystems 	/*
193148847494SEnrico Perla - Sun Microsystems 	 * Ignore broken links
193248847494SEnrico Perla - Sun Microsystems 	 */
193348847494SEnrico Perla - Sun Microsystems 	if (flags == FTW_SL && stat(file, &sb) < 0)
19347c478bd9Sstevel@tonic-gate 		return (0);
19357c478bd9Sstevel@tonic-gate 
19367c478bd9Sstevel@tonic-gate 	/*
19377c478bd9Sstevel@tonic-gate 	 * new_nvlp may be NULL if there were errors earlier
19387c478bd9Sstevel@tonic-gate 	 * but this is not fatal to update determination.
19397c478bd9Sstevel@tonic-gate 	 */
19407c478bd9Sstevel@tonic-gate 	if (walk_arg.new_nvlp) {
194148847494SEnrico Perla - Sun Microsystems 		filestat[0] = st->st_size;
194248847494SEnrico Perla - Sun Microsystems 		filestat[1] = st->st_mtime;
19437c478bd9Sstevel@tonic-gate 		error = nvlist_add_uint64_array(walk_arg.new_nvlp,
19447c478bd9Sstevel@tonic-gate 		    file + bam_rootlen, filestat, 2);
19457c478bd9Sstevel@tonic-gate 		if (error)
19467c478bd9Sstevel@tonic-gate 			bam_error(NVADD_FAIL, file, strerror(error));
19477c478bd9Sstevel@tonic-gate 	}
19487c478bd9Sstevel@tonic-gate 
19497c478bd9Sstevel@tonic-gate 	/*
1950d876c67dSjg 	 * If we are invoked as part of system/filesystem/boot-archive, then
195158091fd8Ssetje 	 * there are a number of things we should not worry about
19527c478bd9Sstevel@tonic-gate 	 */
195358091fd8Ssetje 	if (bam_smf_check) {
195458091fd8Ssetje 		/* ignore amd64 modules unless we are booted amd64. */
195558091fd8Ssetje 		if (!is_amd64() && strstr(file, "/amd64/") != 0)
19567c478bd9Sstevel@tonic-gate 			return (0);
19577c478bd9Sstevel@tonic-gate 
195858091fd8Ssetje 		/* read in list of safe files */
195958091fd8Ssetje 		if (safefiles == NULL)
196058091fd8Ssetje 			if (fp = fopen("/boot/solaris/filelist.safe", "r")) {
196158091fd8Ssetje 				safefiles = s_calloc(1,
196258091fd8Ssetje 				    sizeof (struct safefile));
196358091fd8Ssetje 				safefilep = safefiles;
196458091fd8Ssetje 				safefilep->name = s_calloc(1, MAXPATHLEN +
196558091fd8Ssetje 				    MAXNAMELEN);
196658091fd8Ssetje 				safefilep->next = NULL;
196758091fd8Ssetje 				while (s_fgets(safefilep->name, MAXPATHLEN +
196858091fd8Ssetje 				    MAXNAMELEN, fp) != NULL) {
196958091fd8Ssetje 					safefilep->next = s_calloc(1,
197058091fd8Ssetje 					    sizeof (struct safefile));
197158091fd8Ssetje 					safefilep = safefilep->next;
197258091fd8Ssetje 					safefilep->name = s_calloc(1,
197358091fd8Ssetje 					    MAXPATHLEN + MAXNAMELEN);
197458091fd8Ssetje 					safefilep->next = NULL;
197558091fd8Ssetje 				}
197658091fd8Ssetje 				(void) fclose(fp);
197758091fd8Ssetje 			}
197858091fd8Ssetje 	}
197958091fd8Ssetje 
19807c478bd9Sstevel@tonic-gate 	/*
198148847494SEnrico Perla - Sun Microsystems 	 * On SPARC we create a -path-list file for mkisofs
198248847494SEnrico Perla - Sun Microsystems 	 */
198348847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(IS_SPARC_TARGET) && !bam_nowrite()) {
198448847494SEnrico Perla - Sun Microsystems 		if (flags != FTW_D) {
198548847494SEnrico Perla - Sun Microsystems 			char	*strip;
198648847494SEnrico Perla - Sun Microsystems 
198748847494SEnrico Perla - Sun Microsystems 			strip = (char *)file + strlen(rootbuf);
198848847494SEnrico Perla - Sun Microsystems 			(void) fprintf(walk_arg.sparcfile, "/%s=%s\n", strip,
198948847494SEnrico Perla - Sun Microsystems 			    file);
199048847494SEnrico Perla - Sun Microsystems 		}
199148847494SEnrico Perla - Sun Microsystems 	}
199248847494SEnrico Perla - Sun Microsystems 
199348847494SEnrico Perla - Sun Microsystems 	/*
199448847494SEnrico Perla - Sun Microsystems 	 * We are transitioning from the old model to the dircache or the cache
199548847494SEnrico Perla - Sun Microsystems 	 * directory was removed: create the entry without further checkings.
199648847494SEnrico Perla - Sun Microsystems 	 */
199748847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(NEED_CACHE_DIR)) {
199848847494SEnrico Perla - Sun Microsystems 		if (bam_verbose)
199948847494SEnrico Perla - Sun Microsystems 			bam_print(PARSEABLE_NEW_FILE, file);
200048847494SEnrico Perla - Sun Microsystems 
200148847494SEnrico Perla - Sun Microsystems 		if (is_flag_on(IS_SPARC_TARGET)) {
200248847494SEnrico Perla - Sun Microsystems 			set_dir_flag(FILE64, NEED_UPDATE);
200348847494SEnrico Perla - Sun Microsystems 			return (0);
200448847494SEnrico Perla - Sun Microsystems 		}
200548847494SEnrico Perla - Sun Microsystems 
200648847494SEnrico Perla - Sun Microsystems 		ret = update_dircache(file, flags);
200748847494SEnrico Perla - Sun Microsystems 		if (ret == BAM_ERROR) {
200848847494SEnrico Perla - Sun Microsystems 			bam_error(UPDT_CACHE_FAIL, file);
200948847494SEnrico Perla - Sun Microsystems 			return (-1);
201048847494SEnrico Perla - Sun Microsystems 		}
201148847494SEnrico Perla - Sun Microsystems 
201248847494SEnrico Perla - Sun Microsystems 		return (0);
201348847494SEnrico Perla - Sun Microsystems 	}
201448847494SEnrico Perla - Sun Microsystems 
201548847494SEnrico Perla - Sun Microsystems 	/*
20167c478bd9Sstevel@tonic-gate 	 * We need an update if file doesn't exist in old archive
20177c478bd9Sstevel@tonic-gate 	 */
20187c478bd9Sstevel@tonic-gate 	if (walk_arg.old_nvlp == NULL ||
20197c478bd9Sstevel@tonic-gate 	    nvlist_lookup_uint64_array(walk_arg.old_nvlp,
20207c478bd9Sstevel@tonic-gate 	    file + bam_rootlen, &value, &sz) != 0) {
20217c478bd9Sstevel@tonic-gate 		if (bam_smf_check)	/* ignore new during smf check */
20227c478bd9Sstevel@tonic-gate 			return (0);
202348847494SEnrico Perla - Sun Microsystems 
202448847494SEnrico Perla - Sun Microsystems 		if (is_flag_on(IS_SPARC_TARGET)) {
202548847494SEnrico Perla - Sun Microsystems 			set_dir_flag(FILE64, NEED_UPDATE);
202648847494SEnrico Perla - Sun Microsystems 		} else {
202748847494SEnrico Perla - Sun Microsystems 			ret = update_dircache(file, flags);
202848847494SEnrico Perla - Sun Microsystems 			if (ret == BAM_ERROR) {
202948847494SEnrico Perla - Sun Microsystems 				bam_error(UPDT_CACHE_FAIL, file);
203048847494SEnrico Perla - Sun Microsystems 				return (-1);
203148847494SEnrico Perla - Sun Microsystems 			}
203248847494SEnrico Perla - Sun Microsystems 		}
203348847494SEnrico Perla - Sun Microsystems 
20347c478bd9Sstevel@tonic-gate 		if (bam_verbose)
20357c478bd9Sstevel@tonic-gate 			bam_print(PARSEABLE_NEW_FILE, file);
20367c478bd9Sstevel@tonic-gate 		return (0);
20377c478bd9Sstevel@tonic-gate 	}
20387c478bd9Sstevel@tonic-gate 
20397c478bd9Sstevel@tonic-gate 	/*
204048847494SEnrico Perla - Sun Microsystems 	 * If we got there, the file is already listed as to be included in the
204148847494SEnrico Perla - Sun Microsystems 	 * iso image. We just need to know if we are going to rebuild it or not
204248847494SEnrico Perla - Sun Microsystems 	 */
204348847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(IS_SPARC_TARGET) &&
2044cedc7e57SEnrico Perla - Sun Microsystems 	    is_dir_flag_on(FILE64, NEED_UPDATE) && !bam_nowrite())
204548847494SEnrico Perla - Sun Microsystems 		return (0);
204648847494SEnrico Perla - Sun Microsystems 	/*
20477c478bd9Sstevel@tonic-gate 	 * File exists in old archive. Check if file has changed
20487c478bd9Sstevel@tonic-gate 	 */
20497c478bd9Sstevel@tonic-gate 	assert(sz == 2);
20507c478bd9Sstevel@tonic-gate 	bcopy(value, filestat, sizeof (filestat));
20517c478bd9Sstevel@tonic-gate 
205248847494SEnrico Perla - Sun Microsystems 	if (flags != FTW_D && (filestat[0] != st->st_size ||
205348847494SEnrico Perla - Sun Microsystems 	    filestat[1] != st->st_mtime)) {
20547c609327Ssetje 		if (bam_smf_check) {
20557c609327Ssetje 			safefilep = safefiles;
205689c3ee43SGangadhar Mylapuram 			while (safefilep != NULL &&
205789c3ee43SGangadhar Mylapuram 			    safefilep->name[0] != '\0') {
205889c3ee43SGangadhar Mylapuram 				if (regcomp(&re, safefilep->name,
205989c3ee43SGangadhar Mylapuram 				    REG_EXTENDED|REG_NOSUB) == 0) {
206089c3ee43SGangadhar Mylapuram 					status = regexec(&re,
206189c3ee43SGangadhar Mylapuram 					    file + bam_rootlen, 0, NULL, 0);
206289c3ee43SGangadhar Mylapuram 					regfree(&re);
206389c3ee43SGangadhar Mylapuram 					if (status == 0) {
206489c3ee43SGangadhar Mylapuram 						(void) creat(NEED_UPDATE_FILE,
206589c3ee43SGangadhar Mylapuram 						    0644);
20667c609327Ssetje 						return (0);
20677c609327Ssetje 					}
206889c3ee43SGangadhar Mylapuram 				}
20697c609327Ssetje 				safefilep = safefilep->next;
20707c609327Ssetje 			}
20717c609327Ssetje 		}
207248847494SEnrico Perla - Sun Microsystems 
207348847494SEnrico Perla - Sun Microsystems 		if (is_flag_on(IS_SPARC_TARGET)) {
207448847494SEnrico Perla - Sun Microsystems 			set_dir_flag(FILE64, NEED_UPDATE);
207548847494SEnrico Perla - Sun Microsystems 		} else {
207648847494SEnrico Perla - Sun Microsystems 			ret = update_dircache(file, flags);
207748847494SEnrico Perla - Sun Microsystems 			if (ret == BAM_ERROR) {
207848847494SEnrico Perla - Sun Microsystems 				bam_error(UPDT_CACHE_FAIL, file);
207948847494SEnrico Perla - Sun Microsystems 				return (-1);
208048847494SEnrico Perla - Sun Microsystems 			}
208148847494SEnrico Perla - Sun Microsystems 		}
208248847494SEnrico Perla - Sun Microsystems 
20837c478bd9Sstevel@tonic-gate 		if (bam_verbose)
20847c478bd9Sstevel@tonic-gate 			if (bam_smf_check)
20857c478bd9Sstevel@tonic-gate 				bam_print("    %s\n", file);
20867c478bd9Sstevel@tonic-gate 			else
20877c478bd9Sstevel@tonic-gate 				bam_print(PARSEABLE_OUT_DATE, file);
20887c478bd9Sstevel@tonic-gate 	}
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	return (0);
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate 
20937c478bd9Sstevel@tonic-gate /*
209448847494SEnrico Perla - Sun Microsystems  * Remove a directory path recursively
209548847494SEnrico Perla - Sun Microsystems  */
209648847494SEnrico Perla - Sun Microsystems static int
209748847494SEnrico Perla - Sun Microsystems rmdir_r(char *path)
209848847494SEnrico Perla - Sun Microsystems {
209948847494SEnrico Perla - Sun Microsystems 	struct dirent 	*d = NULL;
210048847494SEnrico Perla - Sun Microsystems 	DIR 		*dir = NULL;
210148847494SEnrico Perla - Sun Microsystems 	char 		tpath[PATH_MAX];
210248847494SEnrico Perla - Sun Microsystems 	struct stat 	sb;
210348847494SEnrico Perla - Sun Microsystems 
210448847494SEnrico Perla - Sun Microsystems 	if ((dir = opendir(path)) == NULL)
210548847494SEnrico Perla - Sun Microsystems 		return (-1);
210648847494SEnrico Perla - Sun Microsystems 
210748847494SEnrico Perla - Sun Microsystems 	while (d = readdir(dir)) {
210848847494SEnrico Perla - Sun Microsystems 		if ((strcmp(d->d_name, ".") != 0) &&
210948847494SEnrico Perla - Sun Microsystems 		    (strcmp(d->d_name, "..") != 0)) {
211048847494SEnrico Perla - Sun Microsystems 			(void) snprintf(tpath, sizeof (tpath), "%s/%s",
211148847494SEnrico Perla - Sun Microsystems 			    path, d->d_name);
211248847494SEnrico Perla - Sun Microsystems 			if (stat(tpath, &sb) == 0) {
211348847494SEnrico Perla - Sun Microsystems 				if (sb.st_mode & S_IFDIR)
211448847494SEnrico Perla - Sun Microsystems 					(void) rmdir_r(tpath);
211548847494SEnrico Perla - Sun Microsystems 				else
211648847494SEnrico Perla - Sun Microsystems 					(void) remove(tpath);
211748847494SEnrico Perla - Sun Microsystems 			}
211848847494SEnrico Perla - Sun Microsystems 		}
211948847494SEnrico Perla - Sun Microsystems 	}
212048847494SEnrico Perla - Sun Microsystems 	return (remove(path));
212148847494SEnrico Perla - Sun Microsystems }
212248847494SEnrico Perla - Sun Microsystems 
212348847494SEnrico Perla - Sun Microsystems /*
212448847494SEnrico Perla - Sun Microsystems  * Check if cache directory exists and, if not, create it and update flags
212548847494SEnrico Perla - Sun Microsystems  * accordingly. If the path exists, but it's not a directory, a best effort
212648847494SEnrico Perla - Sun Microsystems  * attempt to remove and recreate it is made.
212748847494SEnrico Perla - Sun Microsystems  * If the user requested a 'purge', always recreate the directory from scratch.
212848847494SEnrico Perla - Sun Microsystems  */
212948847494SEnrico Perla - Sun Microsystems static int
213048847494SEnrico Perla - Sun Microsystems set_cache_dir(char *root, int what)
213148847494SEnrico Perla - Sun Microsystems {
213248847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
213348847494SEnrico Perla - Sun Microsystems 	int		ret = 0;
213448847494SEnrico Perla - Sun Microsystems 
213548847494SEnrico Perla - Sun Microsystems 	ret = snprintf(get_cachedir(what), sizeof (get_cachedir(what)),
213648847494SEnrico Perla - Sun Microsystems 	    "%s%s%s%s%s", root, ARCHIVE_PREFIX, get_machine(), what == FILE64 ?
213748847494SEnrico Perla - Sun Microsystems 	    "/amd64" : "", CACHEDIR_SUFFIX);
213848847494SEnrico Perla - Sun Microsystems 
213948847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (get_cachedir(what))) {
214048847494SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
214148847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
214248847494SEnrico Perla - Sun Microsystems 	}
214348847494SEnrico Perla - Sun Microsystems 
21444a9df875SEnrico Perla - Sun Microsystems 	if (bam_purge || is_flag_on(INVALIDATE_CACHE))
214548847494SEnrico Perla - Sun Microsystems 		(void) rmdir_r(get_cachedir(what));
214648847494SEnrico Perla - Sun Microsystems 
214748847494SEnrico Perla - Sun Microsystems 	if (stat(get_cachedir(what), &sb) != 0 || !(S_ISDIR(sb.st_mode))) {
214848847494SEnrico Perla - Sun Microsystems 		/* best effort unlink attempt, mkdir will catch errors */
214948847494SEnrico Perla - Sun Microsystems 		(void) unlink(get_cachedir(what));
215048847494SEnrico Perla - Sun Microsystems 
215148847494SEnrico Perla - Sun Microsystems 		if (bam_verbose)
215248847494SEnrico Perla - Sun Microsystems 			bam_print(UPDATE_CDIR_MISS, get_cachedir(what));
215348847494SEnrico Perla - Sun Microsystems 		ret = mkdir(get_cachedir(what), DIR_PERMS);
215448847494SEnrico Perla - Sun Microsystems 		if (ret < 0) {
215548847494SEnrico Perla - Sun Microsystems 			bam_error(MKDIR_FAILED, get_cachedir(what),
215648847494SEnrico Perla - Sun Microsystems 			    strerror(errno));
215748847494SEnrico Perla - Sun Microsystems 			get_cachedir(what)[0] = '\0';
215848847494SEnrico Perla - Sun Microsystems 			return (ret);
215948847494SEnrico Perla - Sun Microsystems 		}
216048847494SEnrico Perla - Sun Microsystems 		set_flag(NEED_CACHE_DIR);
216148847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
216248847494SEnrico Perla - Sun Microsystems 	}
216348847494SEnrico Perla - Sun Microsystems 
216448847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
216548847494SEnrico Perla - Sun Microsystems }
216648847494SEnrico Perla - Sun Microsystems 
216748847494SEnrico Perla - Sun Microsystems static int
216848847494SEnrico Perla - Sun Microsystems set_update_dir(char *root, int what)
216948847494SEnrico Perla - Sun Microsystems {
217048847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
217148847494SEnrico Perla - Sun Microsystems 	int		ret;
217248847494SEnrico Perla - Sun Microsystems 
217348847494SEnrico Perla - Sun Microsystems 	if (is_dir_flag_on(what, NO_MULTI))
217448847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
217548847494SEnrico Perla - Sun Microsystems 
217648847494SEnrico Perla - Sun Microsystems 	if (!bam_extend) {
217748847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
217848847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
217948847494SEnrico Perla - Sun Microsystems 	}
218048847494SEnrico Perla - Sun Microsystems 
218148847494SEnrico Perla - Sun Microsystems 	if (what == FILE64 && !is_flag_on(IS_SPARC_TARGET))
218248847494SEnrico Perla - Sun Microsystems 		ret = snprintf(get_updatedir(what),
218348847494SEnrico Perla - Sun Microsystems 		    sizeof (get_updatedir(what)), "%s%s%s/amd64%s", root,
218448847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_PREFIX, get_machine(), UPDATEDIR_SUFFIX);
218548847494SEnrico Perla - Sun Microsystems 	else
218648847494SEnrico Perla - Sun Microsystems 		ret = snprintf(get_updatedir(what),
218748847494SEnrico Perla - Sun Microsystems 		    sizeof (get_updatedir(what)), "%s%s%s%s", root,
218848847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_PREFIX, get_machine(), UPDATEDIR_SUFFIX);
218948847494SEnrico Perla - Sun Microsystems 
219048847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (get_updatedir(what))) {
219148847494SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
219248847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
219348847494SEnrico Perla - Sun Microsystems 	}
219448847494SEnrico Perla - Sun Microsystems 
219548847494SEnrico Perla - Sun Microsystems 	if (stat(get_updatedir(what), &sb) == 0) {
219648847494SEnrico Perla - Sun Microsystems 		if (S_ISDIR(sb.st_mode))
219748847494SEnrico Perla - Sun Microsystems 			ret = rmdir_r(get_updatedir(what));
219848847494SEnrico Perla - Sun Microsystems 		else
219948847494SEnrico Perla - Sun Microsystems 			ret = unlink(get_updatedir(what));
220048847494SEnrico Perla - Sun Microsystems 
220148847494SEnrico Perla - Sun Microsystems 		if (ret != 0)
220248847494SEnrico Perla - Sun Microsystems 			set_dir_flag(what, NO_MULTI);
220348847494SEnrico Perla - Sun Microsystems 	}
220448847494SEnrico Perla - Sun Microsystems 
220548847494SEnrico Perla - Sun Microsystems 	if (mkdir(get_updatedir(what), DIR_PERMS) < 0)
220648847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
220748847494SEnrico Perla - Sun Microsystems 
220848847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
220948847494SEnrico Perla - Sun Microsystems }
221048847494SEnrico Perla - Sun Microsystems 
221148847494SEnrico Perla - Sun Microsystems static int
221248847494SEnrico Perla - Sun Microsystems is_valid_archive(char *root, int what)
221348847494SEnrico Perla - Sun Microsystems {
221448847494SEnrico Perla - Sun Microsystems 	char 		archive_path[PATH_MAX];
22154a9df875SEnrico Perla - Sun Microsystems 	char		timestamp_path[PATH_MAX];
22164a9df875SEnrico Perla - Sun Microsystems 	struct stat 	sb, timestamp;
221748847494SEnrico Perla - Sun Microsystems 	int 		ret;
221848847494SEnrico Perla - Sun Microsystems 
221948847494SEnrico Perla - Sun Microsystems 	if (what == FILE64 && !is_flag_on(IS_SPARC_TARGET))
222048847494SEnrico Perla - Sun Microsystems 		ret = snprintf(archive_path, sizeof (archive_path),
222148847494SEnrico Perla - Sun Microsystems 		    "%s%s%s/amd64%s", root, ARCHIVE_PREFIX, get_machine(),
222248847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_SUFFIX);
222348847494SEnrico Perla - Sun Microsystems 	else
222448847494SEnrico Perla - Sun Microsystems 		ret = snprintf(archive_path, sizeof (archive_path), "%s%s%s%s",
222548847494SEnrico Perla - Sun Microsystems 		    root, ARCHIVE_PREFIX, get_machine(), ARCHIVE_SUFFIX);
222648847494SEnrico Perla - Sun Microsystems 
222748847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (archive_path)) {
222848847494SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
222948847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
223048847494SEnrico Perla - Sun Microsystems 	}
223148847494SEnrico Perla - Sun Microsystems 
223248847494SEnrico Perla - Sun Microsystems 	if (stat(archive_path, &sb) != 0) {
223348847494SEnrico Perla - Sun Microsystems 		if (bam_verbose && !bam_check)
223448847494SEnrico Perla - Sun Microsystems 			bam_print(UPDATE_ARCH_MISS, archive_path);
223548847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NEED_UPDATE);
223648847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
223748847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
223848847494SEnrico Perla - Sun Microsystems 	}
223948847494SEnrico Perla - Sun Microsystems 
22404a9df875SEnrico Perla - Sun Microsystems 	/*
22414a9df875SEnrico Perla - Sun Microsystems 	 * The timestamp file is used to prevent stale files in the archive
22424a9df875SEnrico Perla - Sun Microsystems 	 * cache.
22434a9df875SEnrico Perla - Sun Microsystems 	 * Stale files can happen if the system is booted back and forth across
22444a9df875SEnrico Perla - Sun Microsystems 	 * the transition from bootadm-before-the-cache to
22454a9df875SEnrico Perla - Sun Microsystems 	 * bootadm-after-the-cache, since older versions of bootadm don't know
22464a9df875SEnrico Perla - Sun Microsystems 	 * about the existence of the archive cache.
22474a9df875SEnrico Perla - Sun Microsystems 	 *
22484a9df875SEnrico Perla - Sun Microsystems 	 * Since only bootadm-after-the-cache versions know about about this
22494a9df875SEnrico Perla - Sun Microsystems 	 * file, we require that the boot archive be older than this file.
22504a9df875SEnrico Perla - Sun Microsystems 	 */
22514a9df875SEnrico Perla - Sun Microsystems 	ret = snprintf(timestamp_path, sizeof (timestamp_path), "%s%s", root,
22524a9df875SEnrico Perla - Sun Microsystems 	    FILE_STAT_TIMESTAMP);
22534a9df875SEnrico Perla - Sun Microsystems 
22544a9df875SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (timestamp_path)) {
22554a9df875SEnrico Perla - Sun Microsystems 		bam_error(PATH_TOO_LONG, rootbuf);
22564a9df875SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
22574a9df875SEnrico Perla - Sun Microsystems 	}
22584a9df875SEnrico Perla - Sun Microsystems 
22594a9df875SEnrico Perla - Sun Microsystems 	if (stat(timestamp_path, &timestamp) != 0 ||
22604a9df875SEnrico Perla - Sun Microsystems 	    sb.st_mtime > timestamp.st_mtime) {
22614a9df875SEnrico Perla - Sun Microsystems 		if (bam_verbose && !bam_check)
22624a9df875SEnrico Perla - Sun Microsystems 			bam_print(UPDATE_CACHE_OLD, timestamp);
22634a9df875SEnrico Perla - Sun Microsystems 		/*
22644a9df875SEnrico Perla - Sun Microsystems 		 * Don't generate a false positive for the boot-archive service
22654a9df875SEnrico Perla - Sun Microsystems 		 * but trigger an update of the archive cache in
22664a9df875SEnrico Perla - Sun Microsystems 		 * boot-archive-update.
22674a9df875SEnrico Perla - Sun Microsystems 		 */
22684a9df875SEnrico Perla - Sun Microsystems 		if (bam_smf_check) {
22694a9df875SEnrico Perla - Sun Microsystems 			(void) creat(NEED_UPDATE_FILE, 0644);
22704a9df875SEnrico Perla - Sun Microsystems 			return (BAM_SUCCESS);
22714a9df875SEnrico Perla - Sun Microsystems 		}
22724a9df875SEnrico Perla - Sun Microsystems 
22734a9df875SEnrico Perla - Sun Microsystems 		set_flag(INVALIDATE_CACHE);
22744a9df875SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NEED_UPDATE);
22754a9df875SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
22764a9df875SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
22774a9df875SEnrico Perla - Sun Microsystems 	}
22784a9df875SEnrico Perla - Sun Microsystems 
227948847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(IS_SPARC_TARGET))
228048847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
228148847494SEnrico Perla - Sun Microsystems 
228248847494SEnrico Perla - Sun Microsystems 	if (bam_extend && sb.st_size > BA_SIZE_MAX) {
228348847494SEnrico Perla - Sun Microsystems 		if (bam_verbose && !bam_check)
228448847494SEnrico Perla - Sun Microsystems 			bam_print(MULTI_SIZE, archive_path, BA_SIZE_MAX);
228548847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, NO_MULTI);
228648847494SEnrico Perla - Sun Microsystems 	}
228748847494SEnrico Perla - Sun Microsystems 
228848847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
228948847494SEnrico Perla - Sun Microsystems }
229048847494SEnrico Perla - Sun Microsystems 
229148847494SEnrico Perla - Sun Microsystems /*
229248847494SEnrico Perla - Sun Microsystems  * Check flags and presence of required files and directories.
22937c478bd9Sstevel@tonic-gate  * The force flag and/or absence of files should
22947c478bd9Sstevel@tonic-gate  * trigger an update.
22957c478bd9Sstevel@tonic-gate  * Suppress stdout output if check (-n) option is set
22967c478bd9Sstevel@tonic-gate  * (as -n should only produce parseable output.)
22977c478bd9Sstevel@tonic-gate  */
229848847494SEnrico Perla - Sun Microsystems static int
22997c478bd9Sstevel@tonic-gate check_flags_and_files(char *root)
23007c478bd9Sstevel@tonic-gate {
230148847494SEnrico Perla - Sun Microsystems 
23027c478bd9Sstevel@tonic-gate 	struct stat 	sb;
230348847494SEnrico Perla - Sun Microsystems 	int 		ret;
230448847494SEnrico Perla - Sun Microsystems 
230548847494SEnrico Perla - Sun Microsystems 	/*
230648847494SEnrico Perla - Sun Microsystems 	 * If archive is missing, create archive
230748847494SEnrico Perla - Sun Microsystems 	 */
230848847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(IS_SPARC_TARGET)) {
230948847494SEnrico Perla - Sun Microsystems 		ret = is_valid_archive(root, FILE64);
2310cedc7e57SEnrico Perla - Sun Microsystems 		if (ret == BAM_ERROR)
2311cedc7e57SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
231248847494SEnrico Perla - Sun Microsystems 	} else {
231348847494SEnrico Perla - Sun Microsystems 		int	what = FILE32;
231448847494SEnrico Perla - Sun Microsystems 		do {
231548847494SEnrico Perla - Sun Microsystems 			ret = is_valid_archive(root, what);
231648847494SEnrico Perla - Sun Microsystems 			if (ret == BAM_ERROR)
231748847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
231848847494SEnrico Perla - Sun Microsystems 			what++;
231948847494SEnrico Perla - Sun Microsystems 		} while (bam_direct == BAM_DIRECT_DBOOT && what < CACHEDIR_NUM);
232048847494SEnrico Perla - Sun Microsystems 	}
232148847494SEnrico Perla - Sun Microsystems 
232248847494SEnrico Perla - Sun Microsystems 	if (bam_nowrite())
232348847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
232448847494SEnrico Perla - Sun Microsystems 
232548847494SEnrico Perla - Sun Microsystems 
232648847494SEnrico Perla - Sun Microsystems 	/*
232748847494SEnrico Perla - Sun Microsystems 	 * check if cache directories exist on x86.
232848847494SEnrico Perla - Sun Microsystems 	 * check (and always open) the cache file on SPARC.
232948847494SEnrico Perla - Sun Microsystems 	 */
233048847494SEnrico Perla - Sun Microsystems 	if (is_sparc()) {
233148847494SEnrico Perla - Sun Microsystems 		ret = snprintf(get_cachedir(FILE64),
233248847494SEnrico Perla - Sun Microsystems 		    sizeof (get_cachedir(FILE64)), "%s%s%s/%s", root,
233348847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_PREFIX, get_machine(), CACHEDIR_SUFFIX);
233448847494SEnrico Perla - Sun Microsystems 
233548847494SEnrico Perla - Sun Microsystems 		if (ret >= sizeof (get_cachedir(FILE64))) {
233648847494SEnrico Perla - Sun Microsystems 			bam_error(PATH_TOO_LONG, rootbuf);
233748847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
233848847494SEnrico Perla - Sun Microsystems 		}
233948847494SEnrico Perla - Sun Microsystems 
234048847494SEnrico Perla - Sun Microsystems 		if (stat(get_cachedir(FILE64), &sb) != 0) {
234148847494SEnrico Perla - Sun Microsystems 			set_flag(NEED_CACHE_DIR);
234248847494SEnrico Perla - Sun Microsystems 			set_dir_flag(FILE64, NEED_UPDATE);
234348847494SEnrico Perla - Sun Microsystems 		}
234448847494SEnrico Perla - Sun Microsystems 
234548847494SEnrico Perla - Sun Microsystems 		walk_arg.sparcfile = fopen(get_cachedir(FILE64), "w");
234648847494SEnrico Perla - Sun Microsystems 		if (walk_arg.sparcfile == NULL) {
234748847494SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, get_cachedir(FILE64),
234848847494SEnrico Perla - Sun Microsystems 			    strerror(errno));
234948847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
235048847494SEnrico Perla - Sun Microsystems 		}
235148847494SEnrico Perla - Sun Microsystems 
235248847494SEnrico Perla - Sun Microsystems 		set_dir_present(FILE64);
235348847494SEnrico Perla - Sun Microsystems 	} else {
235448847494SEnrico Perla - Sun Microsystems 		int	what = FILE32;
235548847494SEnrico Perla - Sun Microsystems 
235648847494SEnrico Perla - Sun Microsystems 		do {
235748847494SEnrico Perla - Sun Microsystems 			if (set_cache_dir(root, what) != 0)
235848847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
235948847494SEnrico Perla - Sun Microsystems 
236048847494SEnrico Perla - Sun Microsystems 			set_dir_present(what);
236148847494SEnrico Perla - Sun Microsystems 
236248847494SEnrico Perla - Sun Microsystems 			if (set_update_dir(root, what) != 0)
236348847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
236448847494SEnrico Perla - Sun Microsystems 			what++;
236548847494SEnrico Perla - Sun Microsystems 		} while (bam_direct == BAM_DIRECT_DBOOT && what < CACHEDIR_NUM);
236648847494SEnrico Perla - Sun Microsystems 	}
23677c478bd9Sstevel@tonic-gate 
23687c478bd9Sstevel@tonic-gate 	/*
23697c478bd9Sstevel@tonic-gate 	 * if force, create archive unconditionally
23707c478bd9Sstevel@tonic-gate 	 */
23717c478bd9Sstevel@tonic-gate 	if (bam_force) {
237248847494SEnrico Perla - Sun Microsystems 		if (!is_sparc())
237348847494SEnrico Perla - Sun Microsystems 			set_dir_flag(FILE32, NEED_UPDATE);
237448847494SEnrico Perla - Sun Microsystems 		set_dir_flag(FILE64, NEED_UPDATE);
237548847494SEnrico Perla - Sun Microsystems 		if (bam_verbose)
23767c478bd9Sstevel@tonic-gate 			bam_print(UPDATE_FORCE);
237748847494SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
23787c478bd9Sstevel@tonic-gate 	}
23797c478bd9Sstevel@tonic-gate 
238048847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
23817c478bd9Sstevel@tonic-gate }
23827c478bd9Sstevel@tonic-gate 
23837c478bd9Sstevel@tonic-gate static error_t
23847c478bd9Sstevel@tonic-gate read_one_list(char *root, filelist_t  *flistp, char *filelist)
23857c478bd9Sstevel@tonic-gate {
23867c478bd9Sstevel@tonic-gate 	char 		path[PATH_MAX];
23877c478bd9Sstevel@tonic-gate 	FILE 		*fp;
23887c478bd9Sstevel@tonic-gate 	char 		buf[BAM_MAXLINE];
2389eb2bd662Svikram 	const char 	*fcn = "read_one_list()";
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate 	(void) snprintf(path, sizeof (path), "%s%s", root, filelist);
23927c478bd9Sstevel@tonic-gate 
23937c478bd9Sstevel@tonic-gate 	fp = fopen(path, "r");
23947c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
2395eb2bd662Svikram 		BAM_DPRINTF((D_FLIST_FAIL, fcn, path, strerror(errno)));
23967c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
23977c478bd9Sstevel@tonic-gate 	}
23987c478bd9Sstevel@tonic-gate 	while (s_fgets(buf, sizeof (buf), fp) != NULL) {
2399b610f78eSvikram 		/* skip blank lines */
2400b610f78eSvikram 		if (strspn(buf, " \t") == strlen(buf))
2401b610f78eSvikram 			continue;
24027c478bd9Sstevel@tonic-gate 		append_to_flist(flistp, buf);
24037c478bd9Sstevel@tonic-gate 	}
24047c478bd9Sstevel@tonic-gate 	if (fclose(fp) != 0) {
24057c478bd9Sstevel@tonic-gate 		bam_error(CLOSE_FAIL, path, strerror(errno));
24067c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
24077c478bd9Sstevel@tonic-gate 	}
24087c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
24097c478bd9Sstevel@tonic-gate }
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate static error_t
24127c478bd9Sstevel@tonic-gate read_list(char *root, filelist_t  *flistp)
24137c478bd9Sstevel@tonic-gate {
2414986fd29aSsetje 	char 		path[PATH_MAX];
2415986fd29aSsetje 	char 		cmd[PATH_MAX];
2416986fd29aSsetje 	struct stat 	sb;
2417986fd29aSsetje 	int 		n, rval;
2418eb2bd662Svikram 	const char 	*fcn = "read_list()";
24197c478bd9Sstevel@tonic-gate 
24207c478bd9Sstevel@tonic-gate 	flistp->head = flistp->tail = NULL;
24217c478bd9Sstevel@tonic-gate 
24227c478bd9Sstevel@tonic-gate 	/*
2423986fd29aSsetje 	 * build and check path to extract_boot_filelist.ksh
2424986fd29aSsetje 	 */
2425986fd29aSsetje 	n = snprintf(path, sizeof (path), "%s%s", root, EXTRACT_BOOT_FILELIST);
2426986fd29aSsetje 	if (n >= sizeof (path)) {
2427986fd29aSsetje 		bam_error(NO_FLIST);
2428986fd29aSsetje 		return (BAM_ERROR);
2429986fd29aSsetje 	}
2430986fd29aSsetje 
2431cedc7e57SEnrico Perla - Sun Microsystems 	if (is_safe_exec(path) == BAM_ERROR)
2432cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
2433cedc7e57SEnrico Perla - Sun Microsystems 
2434986fd29aSsetje 	/*
2435986fd29aSsetje 	 * If extract_boot_filelist is present, exec it, otherwise read
2436986fd29aSsetje 	 * the filelists directly, for compatibility with older images.
2437986fd29aSsetje 	 */
2438986fd29aSsetje 	if (stat(path, &sb) == 0) {
2439986fd29aSsetje 		/*
2440986fd29aSsetje 		 * build arguments to exec extract_boot_filelist.ksh
2441986fd29aSsetje 		 */
2442d876c67dSjg 		char *rootarg, *platarg;
2443d876c67dSjg 		int platarglen = 1, rootarglen = 1;
2444d876c67dSjg 		if (strlen(root) > 1)
2445d876c67dSjg 			rootarglen += strlen(root) + strlen("-R ");
2446d876c67dSjg 		if (bam_alt_platform)
2447d876c67dSjg 			platarglen += strlen(bam_platform) + strlen("-p ");
2448d876c67dSjg 		platarg = s_calloc(1, platarglen);
2449d876c67dSjg 		rootarg = s_calloc(1, rootarglen);
2450d876c67dSjg 		*platarg = 0;
2451d876c67dSjg 		*rootarg = 0;
2452d876c67dSjg 
2453986fd29aSsetje 		if (strlen(root) > 1) {
2454d876c67dSjg 			(void) snprintf(rootarg, rootarglen,
2455d876c67dSjg 			    "-R %s", root);
2456986fd29aSsetje 		}
2457d876c67dSjg 		if (bam_alt_platform) {
2458d876c67dSjg 			(void) snprintf(platarg, platarglen,
2459d876c67dSjg 			    "-p %s", bam_platform);
2460d876c67dSjg 		}
2461d876c67dSjg 		n = snprintf(cmd, sizeof (cmd), "%s %s %s /%s /%s",
2462d876c67dSjg 		    path, rootarg, platarg, BOOT_FILE_LIST, ETC_FILE_LIST);
2463d876c67dSjg 		free(platarg);
2464d876c67dSjg 		free(rootarg);
2465986fd29aSsetje 		if (n >= sizeof (cmd)) {
2466986fd29aSsetje 			bam_error(NO_FLIST);
2467986fd29aSsetje 			return (BAM_ERROR);
2468986fd29aSsetje 		}
2469986fd29aSsetje 		if (exec_cmd(cmd, flistp) != 0) {
2470eb2bd662Svikram 			BAM_DPRINTF((D_FLIST_FAIL, fcn, path, strerror(errno)));
2471986fd29aSsetje 			return (BAM_ERROR);
2472986fd29aSsetje 		}
2473986fd29aSsetje 	} else {
2474986fd29aSsetje 		/*
24757c478bd9Sstevel@tonic-gate 		 * Read current lists of files - only the first is mandatory
24767c478bd9Sstevel@tonic-gate 		 */
24777c478bd9Sstevel@tonic-gate 		rval = read_one_list(root, flistp, BOOT_FILE_LIST);
24787c478bd9Sstevel@tonic-gate 		if (rval != BAM_SUCCESS)
24797c478bd9Sstevel@tonic-gate 			return (rval);
24807c478bd9Sstevel@tonic-gate 		(void) read_one_list(root, flistp, ETC_FILE_LIST);
2481986fd29aSsetje 	}
24827c478bd9Sstevel@tonic-gate 
24837c478bd9Sstevel@tonic-gate 	if (flistp->head == NULL) {
24847c478bd9Sstevel@tonic-gate 		bam_error(NO_FLIST);
24857c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
24867c478bd9Sstevel@tonic-gate 	}
24877c478bd9Sstevel@tonic-gate 
24887c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
24897c478bd9Sstevel@tonic-gate }
24907c478bd9Sstevel@tonic-gate 
24917c478bd9Sstevel@tonic-gate static void
24927c478bd9Sstevel@tonic-gate getoldstat(char *root)
24937c478bd9Sstevel@tonic-gate {
24947c478bd9Sstevel@tonic-gate 	char 		path[PATH_MAX];
24957c478bd9Sstevel@tonic-gate 	int 		fd, error;
24967c478bd9Sstevel@tonic-gate 	struct stat 	sb;
24977c478bd9Sstevel@tonic-gate 	char 		*ostat;
24987c478bd9Sstevel@tonic-gate 
24997c478bd9Sstevel@tonic-gate 	(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT);
25007c478bd9Sstevel@tonic-gate 	fd = open(path, O_RDONLY);
25017c478bd9Sstevel@tonic-gate 	if (fd == -1) {
25027c478bd9Sstevel@tonic-gate 		if (bam_verbose)
25037c478bd9Sstevel@tonic-gate 			bam_print(OPEN_FAIL, path, strerror(errno));
250448847494SEnrico Perla - Sun Microsystems 		goto out_err;
25057c478bd9Sstevel@tonic-gate 	}
25067c478bd9Sstevel@tonic-gate 
25077c478bd9Sstevel@tonic-gate 	if (fstat(fd, &sb) != 0) {
25087c478bd9Sstevel@tonic-gate 		bam_error(STAT_FAIL, path, strerror(errno));
250948847494SEnrico Perla - Sun Microsystems 		goto out_err;
25107c478bd9Sstevel@tonic-gate 	}
25117c478bd9Sstevel@tonic-gate 
25127c478bd9Sstevel@tonic-gate 	ostat = s_calloc(1, sb.st_size);
25137c478bd9Sstevel@tonic-gate 
25147c478bd9Sstevel@tonic-gate 	if (read(fd, ostat, sb.st_size) != sb.st_size) {
25157c478bd9Sstevel@tonic-gate 		bam_error(READ_FAIL, path, strerror(errno));
25167c478bd9Sstevel@tonic-gate 		free(ostat);
251748847494SEnrico Perla - Sun Microsystems 		goto out_err;
25187c478bd9Sstevel@tonic-gate 	}
25197c478bd9Sstevel@tonic-gate 
25207c478bd9Sstevel@tonic-gate 	(void) close(fd);
252148847494SEnrico Perla - Sun Microsystems 	fd = -1;
25227c478bd9Sstevel@tonic-gate 
25237c478bd9Sstevel@tonic-gate 	walk_arg.old_nvlp = NULL;
25247c478bd9Sstevel@tonic-gate 	error = nvlist_unpack(ostat, sb.st_size, &walk_arg.old_nvlp, 0);
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate 	free(ostat);
25277c478bd9Sstevel@tonic-gate 
25287c478bd9Sstevel@tonic-gate 	if (error) {
25297c478bd9Sstevel@tonic-gate 		bam_error(UNPACK_FAIL, path, strerror(error));
25307c478bd9Sstevel@tonic-gate 		walk_arg.old_nvlp = NULL;
253148847494SEnrico Perla - Sun Microsystems 		goto out_err;
253248847494SEnrico Perla - Sun Microsystems 	} else {
25337c478bd9Sstevel@tonic-gate 		return;
25347c478bd9Sstevel@tonic-gate 	}
253548847494SEnrico Perla - Sun Microsystems 
253648847494SEnrico Perla - Sun Microsystems out_err:
253748847494SEnrico Perla - Sun Microsystems 	if (fd != -1)
253848847494SEnrico Perla - Sun Microsystems 		(void) close(fd);
2539cedc7e57SEnrico Perla - Sun Microsystems 	if (!is_flag_on(IS_SPARC_TARGET))
254048847494SEnrico Perla - Sun Microsystems 		set_dir_flag(FILE32, NEED_UPDATE);
254148847494SEnrico Perla - Sun Microsystems 	set_dir_flag(FILE64, NEED_UPDATE);
254248847494SEnrico Perla - Sun Microsystems }
254348847494SEnrico Perla - Sun Microsystems 
254448847494SEnrico Perla - Sun Microsystems /* Best effort stale entry removal */
254548847494SEnrico Perla - Sun Microsystems static void
254648847494SEnrico Perla - Sun Microsystems delete_stale(char *file, int what)
254748847494SEnrico Perla - Sun Microsystems {
254848847494SEnrico Perla - Sun Microsystems 	char		path[PATH_MAX];
254948847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
255048847494SEnrico Perla - Sun Microsystems 
255148847494SEnrico Perla - Sun Microsystems 	(void) snprintf(path, sizeof (path), "%s/%s", get_cachedir(what), file);
255248847494SEnrico Perla - Sun Microsystems 	if (!bam_check && stat(path, &sb) == 0) {
255348847494SEnrico Perla - Sun Microsystems 		if (sb.st_mode & S_IFDIR)
255448847494SEnrico Perla - Sun Microsystems 			(void) rmdir_r(path);
255548847494SEnrico Perla - Sun Microsystems 		else
255648847494SEnrico Perla - Sun Microsystems 			(void) unlink(path);
255748847494SEnrico Perla - Sun Microsystems 
255848847494SEnrico Perla - Sun Microsystems 		set_dir_flag(what, (NEED_UPDATE | NO_MULTI));
255948847494SEnrico Perla - Sun Microsystems 	}
25607c478bd9Sstevel@tonic-gate }
25617c478bd9Sstevel@tonic-gate 
2562a28d77b8Svikram /*
2563a28d77b8Svikram  * Checks if a file in the current (old) archive has
2564a28d77b8Svikram  * been deleted from the root filesystem. This is needed for
2565a28d77b8Svikram  * software like Trusted Extensions (TX) that switch early
2566a28d77b8Svikram  * in boot based on presence/absence of a kernel module.
2567a28d77b8Svikram  */
2568a28d77b8Svikram static void
2569a28d77b8Svikram check4stale(char *root)
2570a28d77b8Svikram {
2571a28d77b8Svikram 	nvpair_t	*nvp;
2572a28d77b8Svikram 	nvlist_t	*nvlp;
2573a28d77b8Svikram 	char 		*file;
2574a28d77b8Svikram 	char		path[PATH_MAX];
2575a28d77b8Svikram 
2576a28d77b8Svikram 	/*
2577a28d77b8Svikram 	 * Skip stale file check during smf check
2578a28d77b8Svikram 	 */
2579a28d77b8Svikram 	if (bam_smf_check)
2580a28d77b8Svikram 		return;
2581a28d77b8Svikram 
258248847494SEnrico Perla - Sun Microsystems 	/*
258348847494SEnrico Perla - Sun Microsystems 	 * If we need to (re)create the cache, there's no need to check for
258448847494SEnrico Perla - Sun Microsystems 	 * stale files
258548847494SEnrico Perla - Sun Microsystems 	 */
258648847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(NEED_CACHE_DIR))
258748847494SEnrico Perla - Sun Microsystems 		return;
258848847494SEnrico Perla - Sun Microsystems 
2589a28d77b8Svikram 	/* Nothing to do if no old stats */
2590a28d77b8Svikram 	if ((nvlp = walk_arg.old_nvlp) == NULL)
2591a28d77b8Svikram 		return;
2592a28d77b8Svikram 
2593a28d77b8Svikram 	for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp;
2594a28d77b8Svikram 	    nvp = nvlist_next_nvpair(nvlp, nvp)) {
2595a28d77b8Svikram 		file = nvpair_name(nvp);
2596a28d77b8Svikram 		if (file == NULL)
2597a28d77b8Svikram 			continue;
2598a28d77b8Svikram 		(void) snprintf(path, sizeof (path), "%s/%s",
2599a28d77b8Svikram 		    root, file);
260048847494SEnrico Perla - Sun Microsystems 		if (access(path, F_OK) < 0) {
260148847494SEnrico Perla - Sun Microsystems 			int	what;
260248847494SEnrico Perla - Sun Microsystems 
2603cedc7e57SEnrico Perla - Sun Microsystems 			if (bam_verbose)
2604cedc7e57SEnrico Perla - Sun Microsystems 				bam_print(PARSEABLE_STALE_FILE, path);
260548847494SEnrico Perla - Sun Microsystems 
2606cedc7e57SEnrico Perla - Sun Microsystems 			if (is_flag_on(IS_SPARC_TARGET)) {
2607cedc7e57SEnrico Perla - Sun Microsystems 				set_dir_flag(FILE64, NEED_UPDATE);
2608cedc7e57SEnrico Perla - Sun Microsystems 			} else {
260948847494SEnrico Perla - Sun Microsystems 				for (what = FILE32; what < CACHEDIR_NUM; what++)
261048847494SEnrico Perla - Sun Microsystems 					if (has_cachedir(what))
261148847494SEnrico Perla - Sun Microsystems 						delete_stale(file, what);
2612a28d77b8Svikram 			}
2613a28d77b8Svikram 		}
2614a28d77b8Svikram 	}
2615cedc7e57SEnrico Perla - Sun Microsystems }
2616a28d77b8Svikram 
26177c478bd9Sstevel@tonic-gate static void
26187c478bd9Sstevel@tonic-gate create_newstat(void)
26197c478bd9Sstevel@tonic-gate {
26207c478bd9Sstevel@tonic-gate 	int error;
26217c478bd9Sstevel@tonic-gate 
26227c478bd9Sstevel@tonic-gate 	error = nvlist_alloc(&walk_arg.new_nvlp, NV_UNIQUE_NAME, 0);
26237c478bd9Sstevel@tonic-gate 	if (error) {
26247c478bd9Sstevel@tonic-gate 		/*
26257c478bd9Sstevel@tonic-gate 		 * Not fatal - we can still create archive
26267c478bd9Sstevel@tonic-gate 		 */
26277c478bd9Sstevel@tonic-gate 		walk_arg.new_nvlp = NULL;
26287c478bd9Sstevel@tonic-gate 		bam_error(NVALLOC_FAIL, strerror(error));
26297c478bd9Sstevel@tonic-gate 	}
26307c478bd9Sstevel@tonic-gate }
26317c478bd9Sstevel@tonic-gate 
263248847494SEnrico Perla - Sun Microsystems static int
26337c478bd9Sstevel@tonic-gate walk_list(char *root, filelist_t *flistp)
26347c478bd9Sstevel@tonic-gate {
26357c478bd9Sstevel@tonic-gate 	char path[PATH_MAX];
26367c478bd9Sstevel@tonic-gate 	line_t *lp;
26377c478bd9Sstevel@tonic-gate 
26387c478bd9Sstevel@tonic-gate 	for (lp = flistp->head; lp; lp = lp->next) {
2639986fd29aSsetje 		/*
2640986fd29aSsetje 		 * Don't follow symlinks.  A symlink must refer to
2641986fd29aSsetje 		 * a file that would appear in the archive through
2642986fd29aSsetje 		 * a direct reference.  This matches the archive
2643986fd29aSsetje 		 * construction behavior.
2644986fd29aSsetje 		 */
26457c478bd9Sstevel@tonic-gate 		(void) snprintf(path, sizeof (path), "%s%s", root, lp->line);
2646986fd29aSsetje 		if (nftw(path, cmpstat, 20, FTW_PHYS) == -1) {
264748847494SEnrico Perla - Sun Microsystems 			if (is_flag_on(UPDATE_ERROR))
264848847494SEnrico Perla - Sun Microsystems 				return (BAM_ERROR);
26497c478bd9Sstevel@tonic-gate 			/*
26507c478bd9Sstevel@tonic-gate 			 * Some files may not exist.
26517c478bd9Sstevel@tonic-gate 			 * For example: etc/rtc_config on a x86 diskless system
26527c478bd9Sstevel@tonic-gate 			 * Emit verbose message only
26537c478bd9Sstevel@tonic-gate 			 */
26547c478bd9Sstevel@tonic-gate 			if (bam_verbose)
26557c478bd9Sstevel@tonic-gate 				bam_print(NFTW_FAIL, path, strerror(errno));
26567c478bd9Sstevel@tonic-gate 		}
26577c478bd9Sstevel@tonic-gate 	}
265848847494SEnrico Perla - Sun Microsystems 
265948847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
26607c478bd9Sstevel@tonic-gate }
26617c478bd9Sstevel@tonic-gate 
26624a9df875SEnrico Perla - Sun Microsystems /*
26634a9df875SEnrico Perla - Sun Microsystems  * Update the timestamp file.
26644a9df875SEnrico Perla - Sun Microsystems  */
26654a9df875SEnrico Perla - Sun Microsystems static void
26664a9df875SEnrico Perla - Sun Microsystems update_timestamp(char *root)
26674a9df875SEnrico Perla - Sun Microsystems {
26684a9df875SEnrico Perla - Sun Microsystems 	char	timestamp_path[PATH_MAX];
26694a9df875SEnrico Perla - Sun Microsystems 
26704a9df875SEnrico Perla - Sun Microsystems 	/* this path length has already been checked in check_flags_and_files */
26714a9df875SEnrico Perla - Sun Microsystems 	(void) snprintf(timestamp_path, sizeof (timestamp_path), "%s%s", root,
26724a9df875SEnrico Perla - Sun Microsystems 	    FILE_STAT_TIMESTAMP);
26734a9df875SEnrico Perla - Sun Microsystems 
26744a9df875SEnrico Perla - Sun Microsystems 	/*
26754a9df875SEnrico Perla - Sun Microsystems 	 * recreate the timestamp file. Since an outdated or absent timestamp
26764a9df875SEnrico Perla - Sun Microsystems 	 * file translates in a complete rebuild of the archive cache, notify
26774a9df875SEnrico Perla - Sun Microsystems 	 * the user of the performance issue.
26784a9df875SEnrico Perla - Sun Microsystems 	 */
26794a9df875SEnrico Perla - Sun Microsystems 	if (creat(timestamp_path, FILE_STAT_MODE) < 0) {
26804a9df875SEnrico Perla - Sun Microsystems 		bam_error(OPEN_FAIL, timestamp_path, strerror(errno));
26814a9df875SEnrico Perla - Sun Microsystems 		bam_error(TIMESTAMP_FAIL, rootbuf);
26824a9df875SEnrico Perla - Sun Microsystems 	}
26834a9df875SEnrico Perla - Sun Microsystems }
26844a9df875SEnrico Perla - Sun Microsystems 
26854a9df875SEnrico Perla - Sun Microsystems 
26867c478bd9Sstevel@tonic-gate static void
26877c478bd9Sstevel@tonic-gate savenew(char *root)
26887c478bd9Sstevel@tonic-gate {
26897c478bd9Sstevel@tonic-gate 	char 	path[PATH_MAX];
26907c478bd9Sstevel@tonic-gate 	char 	path2[PATH_MAX];
26917c478bd9Sstevel@tonic-gate 	size_t 	sz;
26927c478bd9Sstevel@tonic-gate 	char 	*nstat;
26937c478bd9Sstevel@tonic-gate 	int 	fd, wrote, error;
26947c478bd9Sstevel@tonic-gate 
26957c478bd9Sstevel@tonic-gate 	nstat = NULL;
26967c478bd9Sstevel@tonic-gate 	sz = 0;
26977c478bd9Sstevel@tonic-gate 	error = nvlist_pack(walk_arg.new_nvlp, &nstat, &sz,
26987c478bd9Sstevel@tonic-gate 	    NV_ENCODE_XDR, 0);
26997c478bd9Sstevel@tonic-gate 	if (error) {
27007c478bd9Sstevel@tonic-gate 		bam_error(PACK_FAIL, strerror(error));
27017c478bd9Sstevel@tonic-gate 		return;
27027c478bd9Sstevel@tonic-gate 	}
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate 	(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT_TMP);
27057c478bd9Sstevel@tonic-gate 	fd = open(path, O_RDWR|O_CREAT|O_TRUNC, FILE_STAT_MODE);
27067c478bd9Sstevel@tonic-gate 	if (fd == -1) {
27077c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, path, strerror(errno));
27087c478bd9Sstevel@tonic-gate 		free(nstat);
27097c478bd9Sstevel@tonic-gate 		return;
27107c478bd9Sstevel@tonic-gate 	}
27117c478bd9Sstevel@tonic-gate 	wrote = write(fd, nstat, sz);
27127c478bd9Sstevel@tonic-gate 	if (wrote != sz) {
27137c478bd9Sstevel@tonic-gate 		bam_error(WRITE_FAIL, path, strerror(errno));
27147c478bd9Sstevel@tonic-gate 		(void) close(fd);
27157c478bd9Sstevel@tonic-gate 		free(nstat);
27167c478bd9Sstevel@tonic-gate 		return;
27177c478bd9Sstevel@tonic-gate 	}
27187c478bd9Sstevel@tonic-gate 	(void) close(fd);
27197c478bd9Sstevel@tonic-gate 	free(nstat);
27207c478bd9Sstevel@tonic-gate 
27217c478bd9Sstevel@tonic-gate 	(void) snprintf(path2, sizeof (path2), "%s%s", root, FILE_STAT);
27227c478bd9Sstevel@tonic-gate 	if (rename(path, path2) != 0) {
27237c478bd9Sstevel@tonic-gate 		bam_error(RENAME_FAIL, path2, strerror(errno));
27247c478bd9Sstevel@tonic-gate 	}
27257c478bd9Sstevel@tonic-gate }
27267c478bd9Sstevel@tonic-gate 
272748847494SEnrico Perla - Sun Microsystems #define	init_walk_args()	bzero(&walk_arg, sizeof (walk_arg))
272848847494SEnrico Perla - Sun Microsystems 
27297c478bd9Sstevel@tonic-gate static void
27307c478bd9Sstevel@tonic-gate clear_walk_args(void)
27317c478bd9Sstevel@tonic-gate {
27327c478bd9Sstevel@tonic-gate 	if (walk_arg.old_nvlp)
27337c478bd9Sstevel@tonic-gate 		nvlist_free(walk_arg.old_nvlp);
27347c478bd9Sstevel@tonic-gate 	if (walk_arg.new_nvlp)
27357c478bd9Sstevel@tonic-gate 		nvlist_free(walk_arg.new_nvlp);
273648847494SEnrico Perla - Sun Microsystems 	if (walk_arg.sparcfile)
273748847494SEnrico Perla - Sun Microsystems 		(void) fclose(walk_arg.sparcfile);
27387c478bd9Sstevel@tonic-gate 	walk_arg.old_nvlp = NULL;
27397c478bd9Sstevel@tonic-gate 	walk_arg.new_nvlp = NULL;
274048847494SEnrico Perla - Sun Microsystems 	walk_arg.sparcfile = NULL;
27417c478bd9Sstevel@tonic-gate }
27427c478bd9Sstevel@tonic-gate 
27437c478bd9Sstevel@tonic-gate /*
27447c478bd9Sstevel@tonic-gate  * Returns:
27457c478bd9Sstevel@tonic-gate  *	0 - no update necessary
27467c478bd9Sstevel@tonic-gate  *	1 - update required.
27477c478bd9Sstevel@tonic-gate  *	BAM_ERROR (-1) - An error occurred
27487c478bd9Sstevel@tonic-gate  *
27497c478bd9Sstevel@tonic-gate  * Special handling for check (-n):
27507c478bd9Sstevel@tonic-gate  * ================================
27517c478bd9Sstevel@tonic-gate  * The check (-n) option produces parseable output.
27527c478bd9Sstevel@tonic-gate  * To do this, we suppress all stdout messages unrelated
27537c478bd9Sstevel@tonic-gate  * to out of sync files.
27547c478bd9Sstevel@tonic-gate  * All stderr messages are still printed though.
27557c478bd9Sstevel@tonic-gate  *
27567c478bd9Sstevel@tonic-gate  */
27577c478bd9Sstevel@tonic-gate static int
27587c478bd9Sstevel@tonic-gate update_required(char *root)
27597c478bd9Sstevel@tonic-gate {
27607c478bd9Sstevel@tonic-gate 	struct stat 	sb;
27617c478bd9Sstevel@tonic-gate 	char 		path[PATH_MAX];
27627c478bd9Sstevel@tonic-gate 	filelist_t 	flist;
27637c478bd9Sstevel@tonic-gate 	filelist_t 	*flistp = &flist;
276448847494SEnrico Perla - Sun Microsystems 	int 		ret;
27657c478bd9Sstevel@tonic-gate 
27667c478bd9Sstevel@tonic-gate 	flistp->head = flistp->tail = NULL;
27677c478bd9Sstevel@tonic-gate 
276848847494SEnrico Perla - Sun Microsystems 	if (is_sparc())
276948847494SEnrico Perla - Sun Microsystems 		set_flag(IS_SPARC_TARGET);
27707c478bd9Sstevel@tonic-gate 
27717c478bd9Sstevel@tonic-gate 	/*
277248847494SEnrico Perla - Sun Microsystems 	 * Check if cache directories and archives are present
27737c478bd9Sstevel@tonic-gate 	 */
277448847494SEnrico Perla - Sun Microsystems 
277548847494SEnrico Perla - Sun Microsystems 	ret = check_flags_and_files(root);
277648847494SEnrico Perla - Sun Microsystems 	if (ret < 0)
277748847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
27787c478bd9Sstevel@tonic-gate 
27797c478bd9Sstevel@tonic-gate 	/*
27807c478bd9Sstevel@tonic-gate 	 * In certain deployment scenarios, filestat may not
2781eff168e0SEnrico Perla - Sun Microsystems 	 * exist. Do not stop the boot process, but trigger an update
2782eff168e0SEnrico Perla - Sun Microsystems 	 * of the archives (which will recreate filestat.ramdisk).
27837c478bd9Sstevel@tonic-gate 	 */
27847c478bd9Sstevel@tonic-gate 	if (bam_smf_check) {
27857c478bd9Sstevel@tonic-gate 		(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT);
2786eff168e0SEnrico Perla - Sun Microsystems 		if (stat(path, &sb) != 0) {
2787eff168e0SEnrico Perla - Sun Microsystems 			(void) creat(NEED_UPDATE_FILE, 0644);
27887c478bd9Sstevel@tonic-gate 			return (0);
27897c478bd9Sstevel@tonic-gate 		}
2790eff168e0SEnrico Perla - Sun Microsystems 	}
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	getoldstat(root);
27937c478bd9Sstevel@tonic-gate 
27947c478bd9Sstevel@tonic-gate 	/*
2795a28d77b8Svikram 	 * Check if the archive contains files that are no longer
2796a28d77b8Svikram 	 * present on the root filesystem.
2797a28d77b8Svikram 	 */
2798a28d77b8Svikram 	check4stale(root);
2799a28d77b8Svikram 
2800a28d77b8Svikram 	/*
28017c478bd9Sstevel@tonic-gate 	 * read list of files
28027c478bd9Sstevel@tonic-gate 	 */
28037c478bd9Sstevel@tonic-gate 	if (read_list(root, flistp) != BAM_SUCCESS) {
28047c478bd9Sstevel@tonic-gate 		clear_walk_args();
28057c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
28067c478bd9Sstevel@tonic-gate 	}
28077c478bd9Sstevel@tonic-gate 
28087c478bd9Sstevel@tonic-gate 	assert(flistp->head && flistp->tail);
28097c478bd9Sstevel@tonic-gate 
28107c478bd9Sstevel@tonic-gate 	/*
28117c478bd9Sstevel@tonic-gate 	 * At this point either the update is required
28127c478bd9Sstevel@tonic-gate 	 * or the decision is pending. In either case
28137c478bd9Sstevel@tonic-gate 	 * we need to create new stat nvlist
28147c478bd9Sstevel@tonic-gate 	 */
28157c478bd9Sstevel@tonic-gate 	create_newstat();
28167c478bd9Sstevel@tonic-gate 	/*
28177c478bd9Sstevel@tonic-gate 	 * This walk does 2 things:
28187c478bd9Sstevel@tonic-gate 	 *  	- gets new stat data for every file
28197c478bd9Sstevel@tonic-gate 	 *	- (optional) compare old and new stat data
28207c478bd9Sstevel@tonic-gate 	 */
282148847494SEnrico Perla - Sun Microsystems 	ret = walk_list(root, &flist);
28227c478bd9Sstevel@tonic-gate 
28237c478bd9Sstevel@tonic-gate 	/* done with the file list */
28247c478bd9Sstevel@tonic-gate 	filelist_free(flistp);
28257c478bd9Sstevel@tonic-gate 
282648847494SEnrico Perla - Sun Microsystems 	/* something went wrong */
282748847494SEnrico Perla - Sun Microsystems 
282848847494SEnrico Perla - Sun Microsystems 	if (ret == BAM_ERROR) {
282948847494SEnrico Perla - Sun Microsystems 		bam_error(CACHE_FAIL);
283048847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
28317c478bd9Sstevel@tonic-gate 	}
28327c478bd9Sstevel@tonic-gate 
283348847494SEnrico Perla - Sun Microsystems 	if (walk_arg.new_nvlp == NULL) {
2834cedc7e57SEnrico Perla - Sun Microsystems 		if (walk_arg.sparcfile != NULL)
283548847494SEnrico Perla - Sun Microsystems 			(void) fclose(walk_arg.sparcfile);
283648847494SEnrico Perla - Sun Microsystems 		bam_error(NO_NEW_STAT);
283748847494SEnrico Perla - Sun Microsystems 	}
28387c478bd9Sstevel@tonic-gate 
283948847494SEnrico Perla - Sun Microsystems 	/* If nothing was updated, discard newstat. */
284048847494SEnrico Perla - Sun Microsystems 
284148847494SEnrico Perla - Sun Microsystems 	if (!is_dir_flag_on(FILE32, NEED_UPDATE) &&
284248847494SEnrico Perla - Sun Microsystems 	    !is_dir_flag_on(FILE64, NEED_UPDATE)) {
28437c478bd9Sstevel@tonic-gate 		clear_walk_args();
28447c478bd9Sstevel@tonic-gate 		return (0);
28457c478bd9Sstevel@tonic-gate 	}
28467c478bd9Sstevel@tonic-gate 
2847cedc7e57SEnrico Perla - Sun Microsystems 	if (walk_arg.sparcfile != NULL)
284848847494SEnrico Perla - Sun Microsystems 		(void) fclose(walk_arg.sparcfile);
284948847494SEnrico Perla - Sun Microsystems 
28507c478bd9Sstevel@tonic-gate 	return (1);
28517c478bd9Sstevel@tonic-gate }
28527c478bd9Sstevel@tonic-gate 
285348847494SEnrico Perla - Sun Microsystems static int
285448847494SEnrico Perla - Sun Microsystems flushfs(char *root)
285548847494SEnrico Perla - Sun Microsystems {
285648847494SEnrico Perla - Sun Microsystems 	char	cmd[PATH_MAX + 30];
285748847494SEnrico Perla - Sun Microsystems 
285848847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmd, sizeof (cmd), "%s -f \"%s\" 2>/dev/null",
285948847494SEnrico Perla - Sun Microsystems 	    LOCKFS_PATH, root);
286048847494SEnrico Perla - Sun Microsystems 
286148847494SEnrico Perla - Sun Microsystems 	return (exec_cmd(cmd, NULL));
286248847494SEnrico Perla - Sun Microsystems }
286348847494SEnrico Perla - Sun Microsystems 
286448847494SEnrico Perla - Sun Microsystems static int
286548847494SEnrico Perla - Sun Microsystems do_archive_copy(char *source, char *dest)
286648847494SEnrico Perla - Sun Microsystems {
286748847494SEnrico Perla - Sun Microsystems 
2868cedc7e57SEnrico Perla - Sun Microsystems 	sync();
286948847494SEnrico Perla - Sun Microsystems 
287048847494SEnrico Perla - Sun Microsystems 	/* the equivalent of mv archive-new-$pid boot_archive */
2871cedc7e57SEnrico Perla - Sun Microsystems 	if (rename(source, dest) != 0) {
2872cedc7e57SEnrico Perla - Sun Microsystems 		(void) unlink(source);
287348847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
2874cedc7e57SEnrico Perla - Sun Microsystems 	}
287548847494SEnrico Perla - Sun Microsystems 
287648847494SEnrico Perla - Sun Microsystems 	if (flushfs(bam_root) != 0)
2877cedc7e57SEnrico Perla - Sun Microsystems 		sync();
287848847494SEnrico Perla - Sun Microsystems 
287948847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
288048847494SEnrico Perla - Sun Microsystems }
288148847494SEnrico Perla - Sun Microsystems 
288248847494SEnrico Perla - Sun Microsystems static int
288348847494SEnrico Perla - Sun Microsystems check_cmdline(filelist_t flist)
288448847494SEnrico Perla - Sun Microsystems {
288548847494SEnrico Perla - Sun Microsystems 	line_t	*lp;
288648847494SEnrico Perla - Sun Microsystems 
288748847494SEnrico Perla - Sun Microsystems 	for (lp = flist.head; lp; lp = lp->next) {
288848847494SEnrico Perla - Sun Microsystems 		if (strstr(lp->line, "Error:") != NULL ||
288948847494SEnrico Perla - Sun Microsystems 		    strstr(lp->line, "Inode number overflow") != NULL) {
2890cedc7e57SEnrico Perla - Sun Microsystems 			(void) fprintf(stderr, "%s\n", lp->line);
289148847494SEnrico Perla - Sun Microsystems 			return (BAM_ERROR);
289248847494SEnrico Perla - Sun Microsystems 		}
289348847494SEnrico Perla - Sun Microsystems 	}
289448847494SEnrico Perla - Sun Microsystems 
289548847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
289648847494SEnrico Perla - Sun Microsystems }
289748847494SEnrico Perla - Sun Microsystems 
2898cedc7e57SEnrico Perla - Sun Microsystems static void
2899cedc7e57SEnrico Perla - Sun Microsystems dump_errormsg(filelist_t flist)
2900cedc7e57SEnrico Perla - Sun Microsystems {
2901cedc7e57SEnrico Perla - Sun Microsystems 	line_t	*lp;
2902cedc7e57SEnrico Perla - Sun Microsystems 
2903cedc7e57SEnrico Perla - Sun Microsystems 	for (lp = flist.head; lp; lp = lp->next)
2904cedc7e57SEnrico Perla - Sun Microsystems 		(void) fprintf(stderr, "%s\n", lp->line);
2905cedc7e57SEnrico Perla - Sun Microsystems }
2906cedc7e57SEnrico Perla - Sun Microsystems 
290748847494SEnrico Perla - Sun Microsystems static int
290848847494SEnrico Perla - Sun Microsystems check_archive(char *dest)
290948847494SEnrico Perla - Sun Microsystems {
291048847494SEnrico Perla - Sun Microsystems 	struct stat	sb;
291148847494SEnrico Perla - Sun Microsystems 
291248847494SEnrico Perla - Sun Microsystems 	if (stat(dest, &sb) != 0 || !S_ISREG(sb.st_mode) ||
291348847494SEnrico Perla - Sun Microsystems 	    sb.st_size < 10000) {
291448847494SEnrico Perla - Sun Microsystems 		bam_error(ARCHIVE_BAD, dest);
291548847494SEnrico Perla - Sun Microsystems 		(void) unlink(dest);
291648847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
291748847494SEnrico Perla - Sun Microsystems 	}
291848847494SEnrico Perla - Sun Microsystems 
291948847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
292048847494SEnrico Perla - Sun Microsystems }
292148847494SEnrico Perla - Sun Microsystems 
292248847494SEnrico Perla - Sun Microsystems /*
292348847494SEnrico Perla - Sun Microsystems  * Returns 1 if mkiso is in the expected PATH, 0 otherwise
292448847494SEnrico Perla - Sun Microsystems  */
292548847494SEnrico Perla - Sun Microsystems static int
292648847494SEnrico Perla - Sun Microsystems is_mkisofs()
292748847494SEnrico Perla - Sun Microsystems {
2928cedc7e57SEnrico Perla - Sun Microsystems 	if (access(MKISOFS_PATH, X_OK) == 0)
292948847494SEnrico Perla - Sun Microsystems 		return (1);
293048847494SEnrico Perla - Sun Microsystems 	return (0);
293148847494SEnrico Perla - Sun Microsystems }
293248847494SEnrico Perla - Sun Microsystems 
293348847494SEnrico Perla - Sun Microsystems #define	MKISO_PARAMS	" -quiet -graft-points -dlrDJN -relaxed-filenames "
293448847494SEnrico Perla - Sun Microsystems 
293548847494SEnrico Perla - Sun Microsystems static int
293648847494SEnrico Perla - Sun Microsystems create_sparc_archive(char *archive, char *tempname, char *bootblk, char *list)
293748847494SEnrico Perla - Sun Microsystems {
293848847494SEnrico Perla - Sun Microsystems 	int		ret;
293948847494SEnrico Perla - Sun Microsystems 	char		cmdline[3 * PATH_MAX + 64];
294048847494SEnrico Perla - Sun Microsystems 	filelist_t	flist = {0};
294148847494SEnrico Perla - Sun Microsystems 	const char	*func = "create_sparc_archive()";
294248847494SEnrico Perla - Sun Microsystems 
294348847494SEnrico Perla - Sun Microsystems 	if (access(bootblk, R_OK) == 1) {
294448847494SEnrico Perla - Sun Microsystems 		bam_error(BOOTBLK_FAIL, bootblk);
294548847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
294648847494SEnrico Perla - Sun Microsystems 	}
294748847494SEnrico Perla - Sun Microsystems 
294848847494SEnrico Perla - Sun Microsystems 	/*
294948847494SEnrico Perla - Sun Microsystems 	 * Prepare mkisofs command line and execute it
295048847494SEnrico Perla - Sun Microsystems 	 */
295148847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmdline, sizeof (cmdline), "%s %s -G %s -o \"%s\" "
2952cedc7e57SEnrico Perla - Sun Microsystems 	    "-path-list \"%s\" 2>&1", MKISOFS_PATH, MKISO_PARAMS, bootblk,
295348847494SEnrico Perla - Sun Microsystems 	    tempname, list);
295448847494SEnrico Perla - Sun Microsystems 
295548847494SEnrico Perla - Sun Microsystems 	BAM_DPRINTF((D_CMDLINE, func, cmdline));
295648847494SEnrico Perla - Sun Microsystems 
295748847494SEnrico Perla - Sun Microsystems 	ret = exec_cmd(cmdline, &flist);
2958cedc7e57SEnrico Perla - Sun Microsystems 	if (ret != 0 || check_cmdline(flist) == BAM_ERROR) {
2959cedc7e57SEnrico Perla - Sun Microsystems 		dump_errormsg(flist);
296048847494SEnrico Perla - Sun Microsystems 		goto out_err;
2961cedc7e57SEnrico Perla - Sun Microsystems 	}
296248847494SEnrico Perla - Sun Microsystems 
296348847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
296448847494SEnrico Perla - Sun Microsystems 
296548847494SEnrico Perla - Sun Microsystems 	/*
296648847494SEnrico Perla - Sun Microsystems 	 * Prepare dd command line to copy the bootblk on the new archive and
296748847494SEnrico Perla - Sun Microsystems 	 * execute it
296848847494SEnrico Perla - Sun Microsystems 	 */
296948847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmdline, sizeof (cmdline), "%s if=\"%s\" of=\"%s\""
2970cedc7e57SEnrico Perla - Sun Microsystems 	    " bs=1b oseek=1 count=15 conv=notrunc conv=sync 2>&1", DD_PATH_USR,
297148847494SEnrico Perla - Sun Microsystems 	    bootblk, tempname);
297248847494SEnrico Perla - Sun Microsystems 
297348847494SEnrico Perla - Sun Microsystems 	BAM_DPRINTF((D_CMDLINE, func, cmdline));
297448847494SEnrico Perla - Sun Microsystems 
297548847494SEnrico Perla - Sun Microsystems 	ret = exec_cmd(cmdline, &flist);
297648847494SEnrico Perla - Sun Microsystems 	if (ret != 0 || check_cmdline(flist) == BAM_ERROR)
297748847494SEnrico Perla - Sun Microsystems 		goto out_err;
297848847494SEnrico Perla - Sun Microsystems 
297948847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
298048847494SEnrico Perla - Sun Microsystems 
298148847494SEnrico Perla - Sun Microsystems 	/* Did we get a valid archive ? */
298248847494SEnrico Perla - Sun Microsystems 	if (check_archive(tempname) == BAM_ERROR)
298348847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
298448847494SEnrico Perla - Sun Microsystems 
298548847494SEnrico Perla - Sun Microsystems 	return (do_archive_copy(tempname, archive));
298648847494SEnrico Perla - Sun Microsystems 
298748847494SEnrico Perla - Sun Microsystems out_err:
298848847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
298948847494SEnrico Perla - Sun Microsystems 	bam_error(ARCHIVE_FAIL, cmdline);
299048847494SEnrico Perla - Sun Microsystems 	(void) unlink(tempname);
299148847494SEnrico Perla - Sun Microsystems 	return (BAM_ERROR);
299248847494SEnrico Perla - Sun Microsystems }
299348847494SEnrico Perla - Sun Microsystems 
299448847494SEnrico Perla - Sun Microsystems static unsigned int
299548847494SEnrico Perla - Sun Microsystems from_733(unsigned char *s)
299648847494SEnrico Perla - Sun Microsystems {
299748847494SEnrico Perla - Sun Microsystems 	int		i;
299848847494SEnrico Perla - Sun Microsystems 	unsigned int	ret = 0;
299948847494SEnrico Perla - Sun Microsystems 
300048847494SEnrico Perla - Sun Microsystems 	for (i = 0; i < 4; i++)
300148847494SEnrico Perla - Sun Microsystems 		ret |= s[i] << (8 * i);
300248847494SEnrico Perla - Sun Microsystems 
300348847494SEnrico Perla - Sun Microsystems 	return (ret);
300448847494SEnrico Perla - Sun Microsystems }
300548847494SEnrico Perla - Sun Microsystems 
300648847494SEnrico Perla - Sun Microsystems static void
300748847494SEnrico Perla - Sun Microsystems to_733(unsigned char *s, unsigned int val)
300848847494SEnrico Perla - Sun Microsystems {
300948847494SEnrico Perla - Sun Microsystems 	int	i;
301048847494SEnrico Perla - Sun Microsystems 
301148847494SEnrico Perla - Sun Microsystems 	for (i = 0; i < 4; i++)
301248847494SEnrico Perla - Sun Microsystems 		s[i] = s[7-i] = (val >> (8 * i)) & 0xFF;
301348847494SEnrico Perla - Sun Microsystems }
301448847494SEnrico Perla - Sun Microsystems 
301548847494SEnrico Perla - Sun Microsystems /*
301648847494SEnrico Perla - Sun Microsystems  * Extends the current boot archive without recreating it from scratch
301748847494SEnrico Perla - Sun Microsystems  */
301848847494SEnrico Perla - Sun Microsystems static int
301948847494SEnrico Perla - Sun Microsystems extend_iso_archive(char *archive, char *tempname, char *update_dir)
302048847494SEnrico Perla - Sun Microsystems {
302148847494SEnrico Perla - Sun Microsystems 	int			fd = -1, newfd = -1, ret, i;
302248847494SEnrico Perla - Sun Microsystems 	int			next_session = 0, new_size = 0;
302348847494SEnrico Perla - Sun Microsystems 	char			cmdline[3 * PATH_MAX + 64];
302448847494SEnrico Perla - Sun Microsystems 	const char		*func = "extend_iso_archive()";
302548847494SEnrico Perla - Sun Microsystems 	filelist_t		flist = {0};
302648847494SEnrico Perla - Sun Microsystems 	struct iso_pdesc	saved_desc[MAX_IVDs];
302748847494SEnrico Perla - Sun Microsystems 
302848847494SEnrico Perla - Sun Microsystems 	fd = open(archive, O_RDWR);
302948847494SEnrico Perla - Sun Microsystems 	if (fd == -1) {
3030cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
303148847494SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, archive, strerror(errno));
303248847494SEnrico Perla - Sun Microsystems 		goto out_err;
303348847494SEnrico Perla - Sun Microsystems 	}
303448847494SEnrico Perla - Sun Microsystems 
303548847494SEnrico Perla - Sun Microsystems 	/*
303648847494SEnrico Perla - Sun Microsystems 	 * A partial read is likely due to a corrupted file
303748847494SEnrico Perla - Sun Microsystems 	 */
303848847494SEnrico Perla - Sun Microsystems 	ret = pread64(fd, saved_desc, sizeof (saved_desc),
303948847494SEnrico Perla - Sun Microsystems 	    VOLDESC_OFF * CD_BLOCK);
304048847494SEnrico Perla - Sun Microsystems 	if (ret != sizeof (saved_desc)) {
3041cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
304248847494SEnrico Perla - Sun Microsystems 			bam_error(READ_FAIL, archive, strerror(errno));
304348847494SEnrico Perla - Sun Microsystems 		goto out_err;
304448847494SEnrico Perla - Sun Microsystems 	}
304548847494SEnrico Perla - Sun Microsystems 
304648847494SEnrico Perla - Sun Microsystems 	if (memcmp(saved_desc[0].type, "\1CD001", 6)) {
3047cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
304848847494SEnrico Perla - Sun Microsystems 			bam_error(SIGN_FAIL, archive);
304948847494SEnrico Perla - Sun Microsystems 		goto out_err;
305048847494SEnrico Perla - Sun Microsystems 	}
305148847494SEnrico Perla - Sun Microsystems 
305248847494SEnrico Perla - Sun Microsystems 	/*
305348847494SEnrico Perla - Sun Microsystems 	 * Read primary descriptor and locate next_session offset (it should
305448847494SEnrico Perla - Sun Microsystems 	 * point to the end of the archive)
305548847494SEnrico Perla - Sun Microsystems 	 */
305648847494SEnrico Perla - Sun Microsystems 	next_session = P2ROUNDUP(from_733(saved_desc[0].volume_space_size), 16);
305748847494SEnrico Perla - Sun Microsystems 
305848847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmdline, sizeof (cmdline), "%s -C 16,%d -M %s %s -o \""
3059cedc7e57SEnrico Perla - Sun Microsystems 	    "%s\" \"%s\" 2>&1", MKISOFS_PATH, next_session, archive,
3060cedc7e57SEnrico Perla - Sun Microsystems 	    MKISO_PARAMS, tempname, update_dir);
306148847494SEnrico Perla - Sun Microsystems 
306248847494SEnrico Perla - Sun Microsystems 	BAM_DPRINTF((D_CMDLINE, func, cmdline));
306348847494SEnrico Perla - Sun Microsystems 
306448847494SEnrico Perla - Sun Microsystems 	ret = exec_cmd(cmdline, &flist);
306548847494SEnrico Perla - Sun Microsystems 	if (ret != 0 || check_cmdline(flist) == BAM_ERROR) {
3066cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose) {
306748847494SEnrico Perla - Sun Microsystems 			bam_error(MULTI_FAIL, cmdline);
3068cedc7e57SEnrico Perla - Sun Microsystems 			dump_errormsg(flist);
3069cedc7e57SEnrico Perla - Sun Microsystems 		}
307048847494SEnrico Perla - Sun Microsystems 		goto out_flist_err;
307148847494SEnrico Perla - Sun Microsystems 	}
307248847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
307348847494SEnrico Perla - Sun Microsystems 
307448847494SEnrico Perla - Sun Microsystems 	newfd = open(tempname, O_RDONLY);
307548847494SEnrico Perla - Sun Microsystems 	if (newfd == -1) {
3076cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
307748847494SEnrico Perla - Sun Microsystems 			bam_error(OPEN_FAIL, archive, strerror(errno));
307848847494SEnrico Perla - Sun Microsystems 		goto out_err;
307948847494SEnrico Perla - Sun Microsystems 	}
308048847494SEnrico Perla - Sun Microsystems 
308148847494SEnrico Perla - Sun Microsystems 	ret = pread64(newfd, saved_desc, sizeof (saved_desc),
308248847494SEnrico Perla - Sun Microsystems 	    VOLDESC_OFF * CD_BLOCK);
308348847494SEnrico Perla - Sun Microsystems 	if (ret != sizeof (saved_desc)) {
3084cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
308548847494SEnrico Perla - Sun Microsystems 			bam_error(READ_FAIL, archive, strerror(errno));
308648847494SEnrico Perla - Sun Microsystems 		goto out_err;
308748847494SEnrico Perla - Sun Microsystems 	}
308848847494SEnrico Perla - Sun Microsystems 
308948847494SEnrico Perla - Sun Microsystems 	if (memcmp(saved_desc[0].type, "\1CD001", 6)) {
3090cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
309148847494SEnrico Perla - Sun Microsystems 			bam_error(SIGN_FAIL, archive);
309248847494SEnrico Perla - Sun Microsystems 		goto out_err;
309348847494SEnrico Perla - Sun Microsystems 	}
309448847494SEnrico Perla - Sun Microsystems 
309548847494SEnrico Perla - Sun Microsystems 	new_size = from_733(saved_desc[0].volume_space_size) + next_session;
309648847494SEnrico Perla - Sun Microsystems 	to_733(saved_desc[0].volume_space_size, new_size);
309748847494SEnrico Perla - Sun Microsystems 
309848847494SEnrico Perla - Sun Microsystems 	for (i = 1; i < MAX_IVDs; i++) {
309948847494SEnrico Perla - Sun Microsystems 		if (saved_desc[i].type[0] == (unsigned char)255)
310048847494SEnrico Perla - Sun Microsystems 			break;
310148847494SEnrico Perla - Sun Microsystems 		if (memcmp(saved_desc[i].id, "CD001", 5))
310248847494SEnrico Perla - Sun Microsystems 			break;
310348847494SEnrico Perla - Sun Microsystems 
310448847494SEnrico Perla - Sun Microsystems 		if (bam_verbose)
310548847494SEnrico Perla - Sun Microsystems 			bam_print("%s: Updating descriptor entry [%d]\n", func,
310648847494SEnrico Perla - Sun Microsystems 			    i);
310748847494SEnrico Perla - Sun Microsystems 
310848847494SEnrico Perla - Sun Microsystems 		to_733(saved_desc[i].volume_space_size, new_size);
310948847494SEnrico Perla - Sun Microsystems 	}
311048847494SEnrico Perla - Sun Microsystems 
311148847494SEnrico Perla - Sun Microsystems 	ret = pwrite64(fd, saved_desc, DVD_BLOCK, VOLDESC_OFF*CD_BLOCK);
311248847494SEnrico Perla - Sun Microsystems 	if (ret != DVD_BLOCK) {
3113cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
311448847494SEnrico Perla - Sun Microsystems 			bam_error(WRITE_FAIL, archive, strerror(errno));
311548847494SEnrico Perla - Sun Microsystems 		goto out_err;
311648847494SEnrico Perla - Sun Microsystems 	}
311748847494SEnrico Perla - Sun Microsystems 	(void) close(newfd);
311848847494SEnrico Perla - Sun Microsystems 	newfd = -1;
311948847494SEnrico Perla - Sun Microsystems 
3120cedc7e57SEnrico Perla - Sun Microsystems 	ret = fsync(fd);
3121cedc7e57SEnrico Perla - Sun Microsystems 	if (ret != 0)
3122cedc7e57SEnrico Perla - Sun Microsystems 		sync();
3123cedc7e57SEnrico Perla - Sun Microsystems 
312448847494SEnrico Perla - Sun Microsystems 	ret = close(fd);
312548847494SEnrico Perla - Sun Microsystems 	if (ret != 0) {
3126cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
312748847494SEnrico Perla - Sun Microsystems 			bam_error(CLOSE_FAIL, archive, strerror(errno));
312848847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
312948847494SEnrico Perla - Sun Microsystems 	}
313048847494SEnrico Perla - Sun Microsystems 	fd = -1;
313148847494SEnrico Perla - Sun Microsystems 
313248847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmdline, sizeof (cmdline), "%s if=%s of=%s bs=32k "
3133cedc7e57SEnrico Perla - Sun Microsystems 	    "seek=%d conv=sync 2>&1", DD_PATH_USR, tempname, archive,
313448847494SEnrico Perla - Sun Microsystems 	    (next_session/16));
313548847494SEnrico Perla - Sun Microsystems 
313648847494SEnrico Perla - Sun Microsystems 	BAM_DPRINTF((D_CMDLINE, func, cmdline));
313748847494SEnrico Perla - Sun Microsystems 
313848847494SEnrico Perla - Sun Microsystems 	ret = exec_cmd(cmdline, &flist);
313948847494SEnrico Perla - Sun Microsystems 	if (ret != 0 || check_cmdline(flist) == BAM_ERROR) {
3140cedc7e57SEnrico Perla - Sun Microsystems 		if (bam_verbose)
314148847494SEnrico Perla - Sun Microsystems 			bam_error(MULTI_FAIL, cmdline);
314248847494SEnrico Perla - Sun Microsystems 		goto out_flist_err;
314348847494SEnrico Perla - Sun Microsystems 	}
314448847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
314548847494SEnrico Perla - Sun Microsystems 
314648847494SEnrico Perla - Sun Microsystems 	(void) unlink(tempname);
314748847494SEnrico Perla - Sun Microsystems 
3148cedc7e57SEnrico Perla - Sun Microsystems 	if (flushfs(bam_root) != 0)
3149cedc7e57SEnrico Perla - Sun Microsystems 		sync();
3150cedc7e57SEnrico Perla - Sun Microsystems 
315148847494SEnrico Perla - Sun Microsystems 	if (bam_verbose)
315248847494SEnrico Perla - Sun Microsystems 		bam_print("boot archive updated successfully\n");
315348847494SEnrico Perla - Sun Microsystems 
315448847494SEnrico Perla - Sun Microsystems 	return (BAM_SUCCESS);
315548847494SEnrico Perla - Sun Microsystems 
315648847494SEnrico Perla - Sun Microsystems out_flist_err:
315748847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
315848847494SEnrico Perla - Sun Microsystems out_err:
315948847494SEnrico Perla - Sun Microsystems 	if (fd != -1)
316048847494SEnrico Perla - Sun Microsystems 		(void) close(fd);
316148847494SEnrico Perla - Sun Microsystems 	if (newfd != -1)
316248847494SEnrico Perla - Sun Microsystems 		(void) close(newfd);
316348847494SEnrico Perla - Sun Microsystems 	return (BAM_ERROR);
316448847494SEnrico Perla - Sun Microsystems }
316548847494SEnrico Perla - Sun Microsystems 
316648847494SEnrico Perla - Sun Microsystems static int
316748847494SEnrico Perla - Sun Microsystems create_x86_archive(char *archive, char *tempname, char *update_dir)
316848847494SEnrico Perla - Sun Microsystems {
316948847494SEnrico Perla - Sun Microsystems 	int		ret;
317048847494SEnrico Perla - Sun Microsystems 	char		cmdline[3 * PATH_MAX + 64];
317148847494SEnrico Perla - Sun Microsystems 	filelist_t	flist = {0};
317248847494SEnrico Perla - Sun Microsystems 	const char	*func = "create_x86_archive()";
317348847494SEnrico Perla - Sun Microsystems 
317448847494SEnrico Perla - Sun Microsystems 	(void) snprintf(cmdline, sizeof (cmdline), "%s %s -o \"%s\" \"%s\" "
3175cedc7e57SEnrico Perla - Sun Microsystems 	    "2>&1", MKISOFS_PATH, MKISO_PARAMS, tempname, update_dir);
317648847494SEnrico Perla - Sun Microsystems 
317748847494SEnrico Perla - Sun Microsystems 	BAM_DPRINTF((D_CMDLINE, func, cmdline));
317848847494SEnrico Perla - Sun Microsystems 
317948847494SEnrico Perla - Sun Microsystems 	ret = exec_cmd(cmdline, &flist);
318048847494SEnrico Perla - Sun Microsystems 	if (ret != 0 || check_cmdline(flist) == BAM_ERROR) {
318148847494SEnrico Perla - Sun Microsystems 		bam_error(ARCHIVE_FAIL, cmdline);
3182cedc7e57SEnrico Perla - Sun Microsystems 		dump_errormsg(flist);
318348847494SEnrico Perla - Sun Microsystems 		filelist_free(&flist);
318448847494SEnrico Perla - Sun Microsystems 		(void) unlink(tempname);
318548847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
318648847494SEnrico Perla - Sun Microsystems 	}
318748847494SEnrico Perla - Sun Microsystems 
318848847494SEnrico Perla - Sun Microsystems 	filelist_free(&flist);
318948847494SEnrico Perla - Sun Microsystems 
319048847494SEnrico Perla - Sun Microsystems 	if (check_archive(tempname) == BAM_ERROR)
319148847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
319248847494SEnrico Perla - Sun Microsystems 
319348847494SEnrico Perla - Sun Microsystems 	return (do_archive_copy(tempname, archive));
319448847494SEnrico Perla - Sun Microsystems }
319548847494SEnrico Perla - Sun Microsystems 
319648847494SEnrico Perla - Sun Microsystems static int
319748847494SEnrico Perla - Sun Microsystems mkisofs_archive(char *root, int what)
319848847494SEnrico Perla - Sun Microsystems {
319948847494SEnrico Perla - Sun Microsystems 	int		ret;
320048847494SEnrico Perla - Sun Microsystems 	char		temp[PATH_MAX];
320148847494SEnrico Perla - Sun Microsystems 	char 		bootblk[PATH_MAX];
320248847494SEnrico Perla - Sun Microsystems 	char		boot_archive[PATH_MAX];
320348847494SEnrico Perla - Sun Microsystems 
320448847494SEnrico Perla - Sun Microsystems 	if (what == FILE64 && !is_flag_on(IS_SPARC_TARGET))
320548847494SEnrico Perla - Sun Microsystems 		ret = snprintf(temp, sizeof (temp),
320648847494SEnrico Perla - Sun Microsystems 		    "%s%s%s/amd64/archive-new-%d", root, ARCHIVE_PREFIX,
320748847494SEnrico Perla - Sun Microsystems 		    get_machine(), getpid());
320848847494SEnrico Perla - Sun Microsystems 	else
320948847494SEnrico Perla - Sun Microsystems 		ret = snprintf(temp, sizeof (temp), "%s%s%s/archive-new-%d",
321048847494SEnrico Perla - Sun Microsystems 		    root, ARCHIVE_PREFIX, get_machine(), getpid());
321148847494SEnrico Perla - Sun Microsystems 
321248847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (temp))
321348847494SEnrico Perla - Sun Microsystems 		goto out_path_err;
321448847494SEnrico Perla - Sun Microsystems 
321548847494SEnrico Perla - Sun Microsystems 	if (what == FILE64 && !is_flag_on(IS_SPARC_TARGET))
321648847494SEnrico Perla - Sun Microsystems 		ret = snprintf(boot_archive, sizeof (boot_archive),
321748847494SEnrico Perla - Sun Microsystems 		    "%s%s%s/amd64%s", root, ARCHIVE_PREFIX, get_machine(),
321848847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_SUFFIX);
321948847494SEnrico Perla - Sun Microsystems 	else
322048847494SEnrico Perla - Sun Microsystems 		ret = snprintf(boot_archive, sizeof (boot_archive),
322148847494SEnrico Perla - Sun Microsystems 		    "%s%s%s%s", root, ARCHIVE_PREFIX, get_machine(),
322248847494SEnrico Perla - Sun Microsystems 		    ARCHIVE_SUFFIX);
322348847494SEnrico Perla - Sun Microsystems 
322448847494SEnrico Perla - Sun Microsystems 	if (ret >= sizeof (boot_archive))
322548847494SEnrico Perla - Sun Microsystems 		goto out_path_err;
322648847494SEnrico Perla - Sun Microsystems 
322748847494SEnrico Perla - Sun Microsystems 	bam_print("updating %s\n", boot_archive);
322848847494SEnrico Perla - Sun Microsystems 
322948847494SEnrico Perla - Sun Microsystems 	if (is_flag_on(IS_SPARC_TARGET)) {
323048847494SEnrico Perla - Sun Microsystems 		ret = snprintf(bootblk, sizeof (bootblk),
323148847494SEnrico Perla - Sun Microsystems 		    "%s/platform/%s/lib/fs/hsfs/bootblk", root, get_machine());
323248847494SEnrico Perla - Sun Microsystems 		if (ret >= sizeof (bootblk))
323348847494SEnrico Perla - Sun Microsystems 			goto out_path_err;
323448847494SEnrico Perla - Sun Microsystems 
323548847494SEnrico Perla - Sun Microsystems 		ret = create_sparc_archive(boot_archive, temp, bootblk,
323648847494SEnrico Perla - Sun Microsystems 		    get_cachedir(what));
323748847494SEnrico Perla - Sun Microsystems 	} else {
323848847494SEnrico Perla - Sun Microsystems 		if (!is_dir_flag_on(what, NO_MULTI)) {
323948847494SEnrico Perla - Sun Microsystems 			if (bam_verbose)
324048847494SEnrico Perla - Sun Microsystems 				bam_print("Attempting to extend x86 archive: "
324148847494SEnrico Perla - Sun Microsystems 				    "%s\n", boot_archive);
324248847494SEnrico Perla - Sun Microsystems 
324348847494SEnrico Perla - Sun Microsystems 			ret = extend_iso_archive(boot_archive, temp,
324448847494SEnrico Perla - Sun Microsystems 			    get_updatedir(what));
324548847494SEnrico Perla - Sun Microsystems 			if (ret == BAM_SUCCESS) {
324648847494SEnrico Perla - Sun Microsystems 				if (bam_verbose)
324748847494SEnrico Perla - Sun Microsystems 					bam_print("Successfully extended %s\n",
324848847494SEnrico Perla - Sun Microsystems 					    boot_archive);
324948847494SEnrico Perla - Sun Microsystems 
325048847494SEnrico Perla - Sun Microsystems 				(void) rmdir_r(get_updatedir(what));
325148847494SEnrico Perla - Sun Microsystems 				return (BAM_SUCCESS);
325248847494SEnrico Perla - Sun Microsystems 			}
325348847494SEnrico Perla - Sun Microsystems 		}
325448847494SEnrico Perla - Sun Microsystems 		/*
325548847494SEnrico Perla - Sun Microsystems 		 * The boot archive will be recreated from scratch. We get here
325648847494SEnrico Perla - Sun Microsystems 		 * if at least one of these conditions is true:
325748847494SEnrico Perla - Sun Microsystems 		 * - bootadm was called without the -e switch
325848847494SEnrico Perla - Sun Microsystems 		 * - the archive (or the archive cache) doesn't exist
325948847494SEnrico Perla - Sun Microsystems 		 * - archive size is bigger than BA_SIZE_MAX
326048847494SEnrico Perla - Sun Microsystems 		 * - more than COUNT_MAX files need to be updated
326148847494SEnrico Perla - Sun Microsystems 		 * - an error occourred either populating the /updates directory
326248847494SEnrico Perla - Sun Microsystems 		 *   or extend_iso_archive() failed
326348847494SEnrico Perla - Sun Microsystems 		 */
326448847494SEnrico Perla - Sun Microsystems 		if (bam_verbose)
326548847494SEnrico Perla - Sun Microsystems 			bam_print("Unable to extend %s... rebuilding archive\n",
326648847494SEnrico Perla - Sun Microsystems 			    boot_archive);
326748847494SEnrico Perla - Sun Microsystems 
326848847494SEnrico Perla - Sun Microsystems 		if (get_updatedir(what)[0] != '\0')
326948847494SEnrico Perla - Sun Microsystems 			(void) rmdir_r(get_updatedir(what));
327048847494SEnrico Perla - Sun Microsystems 
327148847494SEnrico Perla - Sun Microsystems 
327248847494SEnrico Perla - Sun Microsystems 		ret = create_x86_archive(boot_archive, temp,
327348847494SEnrico Perla - Sun Microsystems 		    get_cachedir(what));
327448847494SEnrico Perla - Sun Microsystems 	}
327548847494SEnrico Perla - Sun Microsystems 
327648847494SEnrico Perla - Sun Microsystems 	if (ret == BAM_SUCCESS && bam_verbose)
327748847494SEnrico Perla - Sun Microsystems 		bam_print("Successfully created %s\n", boot_archive);
327848847494SEnrico Perla - Sun Microsystems 
327948847494SEnrico Perla - Sun Microsystems 	return (ret);
328048847494SEnrico Perla - Sun Microsystems 
328148847494SEnrico Perla - Sun Microsystems out_path_err:
328248847494SEnrico Perla - Sun Microsystems 	bam_error(PATH_TOO_LONG, root);
328348847494SEnrico Perla - Sun Microsystems 	return (BAM_ERROR);
328448847494SEnrico Perla - Sun Microsystems }
328548847494SEnrico Perla - Sun Microsystems 
32867c478bd9Sstevel@tonic-gate static error_t
32877c478bd9Sstevel@tonic-gate create_ramdisk(char *root)
32887c478bd9Sstevel@tonic-gate {
32897c478bd9Sstevel@tonic-gate 	char *cmdline, path[PATH_MAX];
32907c478bd9Sstevel@tonic-gate 	size_t len;
32917c478bd9Sstevel@tonic-gate 	struct stat sb;
3292cedc7e57SEnrico Perla - Sun Microsystems 	int ret, what, status = BAM_SUCCESS;
329348847494SEnrico Perla - Sun Microsystems 
329448847494SEnrico Perla - Sun Microsystems 	/* If there is mkisofs, use it to create the required archives */
329548847494SEnrico Perla - Sun Microsystems 	if (is_mkisofs()) {
329648847494SEnrico Perla - Sun Microsystems 		for (what = FILE32; what < CACHEDIR_NUM; what++) {
3297cedc7e57SEnrico Perla - Sun Microsystems 			if (has_cachedir(what) && is_dir_flag_on(what,
3298cedc7e57SEnrico Perla - Sun Microsystems 			    NEED_UPDATE)) {
329948847494SEnrico Perla - Sun Microsystems 				ret = mkisofs_archive(root, what);
330048847494SEnrico Perla - Sun Microsystems 				if (ret != 0)
3301cedc7e57SEnrico Perla - Sun Microsystems 					status = BAM_ERROR;
330248847494SEnrico Perla - Sun Microsystems 			}
330348847494SEnrico Perla - Sun Microsystems 		}
3304cedc7e57SEnrico Perla - Sun Microsystems 		return (status);
330548847494SEnrico Perla - Sun Microsystems 	}
33067c478bd9Sstevel@tonic-gate 
33077c478bd9Sstevel@tonic-gate 	/*
330848847494SEnrico Perla - Sun Microsystems 	 * Else setup command args for create_ramdisk.ksh for the UFS archives
33097c478bd9Sstevel@tonic-gate 	 */
331048847494SEnrico Perla - Sun Microsystems 	if (bam_verbose)
331148847494SEnrico Perla - Sun Microsystems 		bam_print("mkisofs not found, creating UFS archive\n");
331248847494SEnrico Perla - Sun Microsystems 
3313986fd29aSsetje 	(void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK);
33147c478bd9Sstevel@tonic-gate 	if (stat(path, &sb) != 0) {
33157c478bd9Sstevel@tonic-gate 		bam_error(ARCH_EXEC_MISS, path, strerror(errno));
33167c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
33177c478bd9Sstevel@tonic-gate 	}
33187c478bd9Sstevel@tonic-gate 
3319cedc7e57SEnrico Perla - Sun Microsystems 	if (is_safe_exec(path) == BAM_ERROR)
3320cedc7e57SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
3321cedc7e57SEnrico Perla - Sun Microsystems 
33227c478bd9Sstevel@tonic-gate 	len = strlen(path) + strlen(root) + 10;	/* room for space + -R */
3323d876c67dSjg 	if (bam_alt_platform)
3324d876c67dSjg 		len += strlen(bam_platform) + strlen("-p ");
33257c478bd9Sstevel@tonic-gate 	cmdline = s_calloc(1, len);
33267c478bd9Sstevel@tonic-gate 
3327d876c67dSjg 	if (bam_alt_platform) {
3328d876c67dSjg 		assert(strlen(root) > 1);
3329d876c67dSjg 		(void) snprintf(cmdline, len, "%s -p %s -R %s",
3330d876c67dSjg 		    path, bam_platform, root);
3331d876c67dSjg 		/* chop off / at the end */
3332d876c67dSjg 		cmdline[strlen(cmdline) - 1] = '\0';
3333d876c67dSjg 	} else if (strlen(root) > 1) {
33347c478bd9Sstevel@tonic-gate 		(void) snprintf(cmdline, len, "%s -R %s", path, root);
33357c478bd9Sstevel@tonic-gate 		/* chop off / at the end */
33367c478bd9Sstevel@tonic-gate 		cmdline[strlen(cmdline) - 1] = '\0';
33377c478bd9Sstevel@tonic-gate 	} else
33387c478bd9Sstevel@tonic-gate 		(void) snprintf(cmdline, len, "%s", path);
33397c478bd9Sstevel@tonic-gate 
3340986fd29aSsetje 	if (exec_cmd(cmdline, NULL) != 0) {
33417c478bd9Sstevel@tonic-gate 		bam_error(ARCHIVE_FAIL, cmdline);
33427c478bd9Sstevel@tonic-gate 		free(cmdline);
33437c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
33447c478bd9Sstevel@tonic-gate 	}
33457c478bd9Sstevel@tonic-gate 	free(cmdline);
33467c478bd9Sstevel@tonic-gate 	/*
3347986fd29aSsetje 	 * The existence of the expected archives used to be
3348986fd29aSsetje 	 * verified here. This check is done in create_ramdisk as
3349986fd29aSsetje 	 * it needs to be in sync with the altroot operated upon.
33507c478bd9Sstevel@tonic-gate 	 */
33517c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
33527c478bd9Sstevel@tonic-gate }
33537c478bd9Sstevel@tonic-gate 
33547c478bd9Sstevel@tonic-gate /*
33557c478bd9Sstevel@tonic-gate  * Checks if target filesystem is on a ramdisk
33567c478bd9Sstevel@tonic-gate  * 1 - is miniroot
33577c478bd9Sstevel@tonic-gate  * 0 - is not
33587c478bd9Sstevel@tonic-gate  * When in doubt assume it is not a ramdisk.
33597c478bd9Sstevel@tonic-gate  */
33607c478bd9Sstevel@tonic-gate static int
33617c478bd9Sstevel@tonic-gate is_ramdisk(char *root)
33627c478bd9Sstevel@tonic-gate {
33637c478bd9Sstevel@tonic-gate 	struct extmnttab mnt;
33647c478bd9Sstevel@tonic-gate 	FILE *fp;
33657c478bd9Sstevel@tonic-gate 	int found;
3366b610f78eSvikram 	char mntpt[PATH_MAX];
3367b610f78eSvikram 	char *cp;
33687c478bd9Sstevel@tonic-gate 
33697c478bd9Sstevel@tonic-gate 	/*
33707c478bd9Sstevel@tonic-gate 	 * There are 3 situations where creating archive is
33717c478bd9Sstevel@tonic-gate 	 * of dubious value:
3372b610f78eSvikram 	 *	- create boot_archive on a lofi-mounted boot_archive
33737c478bd9Sstevel@tonic-gate 	 *	- create it on a ramdisk which is the root filesystem
33747c478bd9Sstevel@tonic-gate 	 *	- create it on a ramdisk mounted somewhere else
33757c478bd9Sstevel@tonic-gate 	 * The first is not easy to detect and checking for it is not
33767c478bd9Sstevel@tonic-gate 	 * worth it.
33777c478bd9Sstevel@tonic-gate 	 * The other two conditions are handled here
33787c478bd9Sstevel@tonic-gate 	 */
33797c478bd9Sstevel@tonic-gate 	fp = fopen(MNTTAB, "r");
33807c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
33817c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
33827c478bd9Sstevel@tonic-gate 		return (0);
33837c478bd9Sstevel@tonic-gate 	}
33847c478bd9Sstevel@tonic-gate 
33857c478bd9Sstevel@tonic-gate 	resetmnttab(fp);
33867c478bd9Sstevel@tonic-gate 
3387b610f78eSvikram 	/*
3388b610f78eSvikram 	 * Remove any trailing / from the mount point
3389b610f78eSvikram 	 */
3390b610f78eSvikram 	(void) strlcpy(mntpt, root, sizeof (mntpt));
3391b610f78eSvikram 	if (strcmp(root, "/") != 0) {
3392b610f78eSvikram 		cp = mntpt + strlen(mntpt) - 1;
3393b610f78eSvikram 		if (*cp == '/')
3394b610f78eSvikram 			*cp = '\0';
3395b610f78eSvikram 	}
33967c478bd9Sstevel@tonic-gate 	found = 0;
33977c478bd9Sstevel@tonic-gate 	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
3398b610f78eSvikram 		if (strcmp(mnt.mnt_mountp, mntpt) == 0) {
33997c478bd9Sstevel@tonic-gate 			found = 1;
34007c478bd9Sstevel@tonic-gate 			break;
34017c478bd9Sstevel@tonic-gate 		}
34027c478bd9Sstevel@tonic-gate 	}
34037c478bd9Sstevel@tonic-gate 
34047c478bd9Sstevel@tonic-gate 	if (!found) {
34057c478bd9Sstevel@tonic-gate 		if (bam_verbose)
3406b610f78eSvikram 			bam_error(NOT_IN_MNTTAB, mntpt);
34077c478bd9Sstevel@tonic-gate 		(void) fclose(fp);
34087c478bd9Sstevel@tonic-gate 		return (0);
34097c478bd9Sstevel@tonic-gate 	}
34107c478bd9Sstevel@tonic-gate 
34117c478bd9Sstevel@tonic-gate 	if (strstr(mnt.mnt_special, RAMDISK_SPECIAL) != NULL) {
34127c478bd9Sstevel@tonic-gate 		if (bam_verbose)
34137c478bd9Sstevel@tonic-gate 			bam_error(IS_RAMDISK, bam_root);
34147c478bd9Sstevel@tonic-gate 		(void) fclose(fp);
34157c478bd9Sstevel@tonic-gate 		return (1);
34167c478bd9Sstevel@tonic-gate 	}
34177c478bd9Sstevel@tonic-gate 
34187c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
34197c478bd9Sstevel@tonic-gate 
34207c478bd9Sstevel@tonic-gate 	return (0);
34217c478bd9Sstevel@tonic-gate }
34227c478bd9Sstevel@tonic-gate 
34237c478bd9Sstevel@tonic-gate static int
3424986fd29aSsetje is_boot_archive(char *root)
34257c478bd9Sstevel@tonic-gate {
34267c478bd9Sstevel@tonic-gate 	char		path[PATH_MAX];
34277c478bd9Sstevel@tonic-gate 	struct stat	sb;
3428eb2bd662Svikram 	int		error;
3429eb2bd662Svikram 	const char	*fcn = "is_boot_archive()";
34307c478bd9Sstevel@tonic-gate 
34317c478bd9Sstevel@tonic-gate 	/*
3432986fd29aSsetje 	 * We can't create an archive without the create_ramdisk script
34337c478bd9Sstevel@tonic-gate 	 */
3434986fd29aSsetje 	(void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK);
3435eb2bd662Svikram 	error = stat(path, &sb);
3436eb2bd662Svikram 	INJECT_ERROR1("NOT_ARCHIVE_BASED", error = -1);
3437eb2bd662Svikram 	if (error == -1) {
34387c478bd9Sstevel@tonic-gate 		if (bam_verbose)
34397c478bd9Sstevel@tonic-gate 			bam_print(FILE_MISS, path);
3440eb2bd662Svikram 		BAM_DPRINTF((D_NOT_ARCHIVE_BOOT, fcn, root));
34417c478bd9Sstevel@tonic-gate 		return (0);
34427c478bd9Sstevel@tonic-gate 	}
34437c478bd9Sstevel@tonic-gate 
3444eb2bd662Svikram 	BAM_DPRINTF((D_IS_ARCHIVE_BOOT, fcn, root));
3445986fd29aSsetje 	return (1);
3446986fd29aSsetje }
3447986fd29aSsetje 
34487c478bd9Sstevel@tonic-gate /*
3449986fd29aSsetje  * Need to call this for anything that operates on the GRUB menu
3450963390b4Svikram  * In the x86 live upgrade case the directory /boot/grub may be present
3451963390b4Svikram  * even on pre-newboot BEs. The authoritative way to check for a GRUB target
3452963390b4Svikram  * is to check for the presence of the stage2 binary which is present
3453963390b4Svikram  * only on GRUB targets (even on x86 boot partitions). Checking for the
3454963390b4Svikram  * presence of the multiboot binary is not correct as it is not present
3455963390b4Svikram  * on x86 boot partitions.
3456986fd29aSsetje  */
3457986fd29aSsetje int
3458986fd29aSsetje is_grub(const char *root)
3459986fd29aSsetje {
3460986fd29aSsetje 	char path[PATH_MAX];
3461986fd29aSsetje 	struct stat sb;
3462eb2bd662Svikram 	const char *fcn = "is_grub()";
3463986fd29aSsetje 
3464963390b4Svikram 	(void) snprintf(path, sizeof (path), "%s%s", root, GRUB_STAGE2);
34657c478bd9Sstevel@tonic-gate 	if (stat(path, &sb) == -1) {
3466eb2bd662Svikram 		BAM_DPRINTF((D_NO_GRUB_DIR, fcn, path));
34677c478bd9Sstevel@tonic-gate 		return (0);
34687c478bd9Sstevel@tonic-gate 	}
34697c478bd9Sstevel@tonic-gate 
34707c478bd9Sstevel@tonic-gate 	return (1);
34717c478bd9Sstevel@tonic-gate }
34727c478bd9Sstevel@tonic-gate 
34737c478bd9Sstevel@tonic-gate static int
3474eb2bd662Svikram is_zfs(char *root)
3475eb2bd662Svikram {
3476eb2bd662Svikram 	struct statvfs		vfs;
3477eb2bd662Svikram 	int			ret;
3478eb2bd662Svikram 	const char		*fcn = "is_zfs()";
3479eb2bd662Svikram 
3480eb2bd662Svikram 	ret = statvfs(root, &vfs);
3481eb2bd662Svikram 	INJECT_ERROR1("STATVFS_ZFS", ret = 1);
3482eb2bd662Svikram 	if (ret != 0) {
3483eb2bd662Svikram 		bam_error(STATVFS_FAIL, root, strerror(errno));
3484eb2bd662Svikram 		return (0);
3485eb2bd662Svikram 	}
3486eb2bd662Svikram 
3487eb2bd662Svikram 	if (strncmp(vfs.f_basetype, "zfs", strlen("zfs")) == 0) {
3488eb2bd662Svikram 		BAM_DPRINTF((D_IS_ZFS, fcn, root));
3489eb2bd662Svikram 		return (1);
3490eb2bd662Svikram 	} else {
3491eb2bd662Svikram 		BAM_DPRINTF((D_IS_NOT_ZFS, fcn, root));
3492eb2bd662Svikram 		return (0);
3493eb2bd662Svikram 	}
3494eb2bd662Svikram }
3495eb2bd662Svikram 
3496eb2bd662Svikram static int
3497eb2bd662Svikram is_ufs(char *root)
3498eb2bd662Svikram {
3499eb2bd662Svikram 	struct statvfs		vfs;
3500eb2bd662Svikram 	int			ret;
3501eb2bd662Svikram 	const char		*fcn = "is_ufs()";
3502eb2bd662Svikram 
3503eb2bd662Svikram 	ret = statvfs(root, &vfs);
3504eb2bd662Svikram 	INJECT_ERROR1("STATVFS_UFS", ret = 1);
3505eb2bd662Svikram 	if (ret != 0) {
3506eb2bd662Svikram 		bam_error(STATVFS_FAIL, root, strerror(errno));
3507eb2bd662Svikram 		return (0);
3508eb2bd662Svikram 	}
3509eb2bd662Svikram 
3510eb2bd662Svikram 	if (strncmp(vfs.f_basetype, "ufs", strlen("ufs")) == 0) {
3511eb2bd662Svikram 		BAM_DPRINTF((D_IS_UFS, fcn, root));
3512eb2bd662Svikram 		return (1);
3513eb2bd662Svikram 	} else {
3514eb2bd662Svikram 		BAM_DPRINTF((D_IS_NOT_UFS, fcn, root));
3515eb2bd662Svikram 		return (0);
3516eb2bd662Svikram 	}
3517eb2bd662Svikram }
3518eb2bd662Svikram 
3519eb2bd662Svikram static int
3520eb2bd662Svikram is_pcfs(char *root)
3521eb2bd662Svikram {
3522eb2bd662Svikram 	struct statvfs		vfs;
3523eb2bd662Svikram 	int			ret;
3524eb2bd662Svikram 	const char		*fcn = "is_pcfs()";
3525eb2bd662Svikram 
3526eb2bd662Svikram 	ret = statvfs(root, &vfs);
3527eb2bd662Svikram 	INJECT_ERROR1("STATVFS_PCFS", ret = 1);
3528eb2bd662Svikram 	if (ret != 0) {
3529eb2bd662Svikram 		bam_error(STATVFS_FAIL, root, strerror(errno));
3530eb2bd662Svikram 		return (0);
3531eb2bd662Svikram 	}
3532eb2bd662Svikram 
3533eb2bd662Svikram 	if (strncmp(vfs.f_basetype, "pcfs", strlen("pcfs")) == 0) {
3534eb2bd662Svikram 		BAM_DPRINTF((D_IS_PCFS, fcn, root));
3535eb2bd662Svikram 		return (1);
3536eb2bd662Svikram 	} else {
3537eb2bd662Svikram 		BAM_DPRINTF((D_IS_NOT_PCFS, fcn, root));
3538eb2bd662Svikram 		return (0);
3539eb2bd662Svikram 	}
3540eb2bd662Svikram }
3541eb2bd662Svikram 
3542eb2bd662Svikram static int
35437c478bd9Sstevel@tonic-gate is_readonly(char *root)
35447c478bd9Sstevel@tonic-gate {
3545eb2bd662Svikram 	int		fd;
3546eb2bd662Svikram 	int		error;
3547eb2bd662Svikram 	char		testfile[PATH_MAX];
3548eb2bd662Svikram 	const char	*fcn = "is_readonly()";
35497c478bd9Sstevel@tonic-gate 
35507c478bd9Sstevel@tonic-gate 	/*
3551eb2bd662Svikram 	 * Using statvfs() to check for a read-only filesystem is not
3552eb2bd662Svikram 	 * reliable. The only way to reliably test is to attempt to
3553eb2bd662Svikram 	 * create a file
35547c478bd9Sstevel@tonic-gate 	 */
3555eb2bd662Svikram 	(void) snprintf(testfile, sizeof (testfile), "%s/%s.%d",
3556eb2bd662Svikram 	    root, BOOTADM_RDONLY_TEST, getpid());
35577c478bd9Sstevel@tonic-gate 
3558eb2bd662Svikram 	(void) unlink(testfile);
3559eb2bd662Svikram 
3560eb2bd662Svikram 	errno = 0;
3561eb2bd662Svikram 	fd = open(testfile, O_RDWR|O_CREAT|O_EXCL, 0644);
3562eb2bd662Svikram 	error = errno;
3563eb2bd662Svikram 	INJECT_ERROR2("RDONLY_TEST_ERROR", fd = -1, error = EACCES);
3564eb2bd662Svikram 	if (fd == -1 && error == EROFS) {
3565eb2bd662Svikram 		BAM_DPRINTF((D_RDONLY_FS, fcn, root));
35667c478bd9Sstevel@tonic-gate 		return (1);
3567eb2bd662Svikram 	} else if (fd == -1) {
3568eb2bd662Svikram 		bam_error(RDONLY_TEST_ERROR, root, strerror(error));
35697c478bd9Sstevel@tonic-gate 	}
35707c478bd9Sstevel@tonic-gate 
3571eb2bd662Svikram 	(void) close(fd);
3572eb2bd662Svikram 	(void) unlink(testfile);
35737c478bd9Sstevel@tonic-gate 
3574eb2bd662Svikram 	BAM_DPRINTF((D_RDWR_FS, fcn, root));
3575e7cbe64fSgw25295 	return (0);
3576e7cbe64fSgw25295 }
3577e7cbe64fSgw25295 
35787c478bd9Sstevel@tonic-gate static error_t
35797c478bd9Sstevel@tonic-gate update_archive(char *root, char *opt)
35807c478bd9Sstevel@tonic-gate {
35817c478bd9Sstevel@tonic-gate 	error_t ret;
35827c478bd9Sstevel@tonic-gate 
35837c478bd9Sstevel@tonic-gate 	assert(root);
35847c478bd9Sstevel@tonic-gate 	assert(opt == NULL);
35857c478bd9Sstevel@tonic-gate 
358648847494SEnrico Perla - Sun Microsystems 	init_walk_args();
358748847494SEnrico Perla - Sun Microsystems 	(void) umask(022);
358848847494SEnrico Perla - Sun Microsystems 
35897c478bd9Sstevel@tonic-gate 	/*
3590986fd29aSsetje 	 * root must belong to a boot archive based OS,
35917c478bd9Sstevel@tonic-gate 	 */
3592986fd29aSsetje 	if (!is_boot_archive(root)) {
3593b610f78eSvikram 		/*
3594b610f78eSvikram 		 * Emit message only if not in context of update_all.
3595b610f78eSvikram 		 * If in update_all, emit only if verbose flag is set.
3596b610f78eSvikram 		 */
3597b610f78eSvikram 		if (!bam_update_all || bam_verbose)
3598eb2bd662Svikram 			bam_print(NOT_ARCHIVE_BOOT, root);
359948847494SEnrico Perla - Sun Microsystems 		return (BAM_ERROR);
36007c478bd9Sstevel@tonic-gate 	}
36017c478bd9Sstevel@tonic-gate 
36027c478bd9Sstevel@tonic-gate 	/*
36038c1b6884Sszhou 	 * If smf check is requested when / is writable (can happen
36048c1b6884Sszhou 	 * on first reboot following an upgrade because service
36058c1b6884Sszhou 	 * dependency is messed up), skip the check.
36068c1b6884Sszhou 	 */
360748847494SEnrico Perla - Sun Microsystems 	if (bam_smf_check && !bam_root_readonly && !is_zfs(root))
36088c1b6884Sszhou 		return (BAM_SUCCESS);
36098c1b6884Sszhou 
36108c1b6884Sszhou 	/*
36115eea6091SEnrico Perla - Sun Microsystems 	 * Don't generate archive on ramdisk.
36125eea6091SEnrico Perla - Sun Microsystems 	 */
36135eea6091SEnrico Perla - Sun Microsystems 	if (is_ramdisk(root))
36145eea6091SEnrico Perla - Sun Microsystems 		return (BAM_SUCCESS);
36155eea6091SEnrico Perla - Sun Microsystems 
36165eea6091SEnrico Perla - Sun Microsystems 	/*
36178c1b6884Sszhou 	 * root must be writable. This check applies to alternate
36188c1b6884Sszhou 	 * root (-R option); bam_root_readonly applies to '/' only.
361948847494SEnrico Perla - Sun Microsystems 	 * The behaviour translates into being the one of a 'check'.
36207c478bd9Sstevel@tonic-gate 	 */
362161cb17bdSsetje 	if (!bam_smf_check && !bam_check && is_readonly(root)) {
362248847494SEnrico Perla - Sun Microsystems 		set_flag(RDONLY_FSCHK);
362348847494SEnrico Perla - Sun Microsystems 		bam_check = 1;
36247c478bd9Sstevel@tonic-gate 	}
36257c478bd9Sstevel@tonic-gate 
36267c478bd9Sstevel@tonic-gate 	/*
3627cedc7e57SEnrico Perla - Sun Microsystems 	 * Now check if an update is really needed.
36287c478bd9Sstevel@tonic-gate 	 */
36297c478bd9Sstevel@tonic-gate 	ret = update_required(root);
36307c478bd9Sstevel@tonic-gate 
36317c478bd9Sstevel@tonic-gate 	/*
3632cedc7e57SEnrico Perla - Sun Microsystems 	 * The check command (-n) is *not* a dry run.
36337c478bd9Sstevel@tonic-gate 	 * It only checks if the archive is in sync.
3634cedc7e57SEnrico Perla - Sun Microsystems 	 * A readonly filesystem has to be considered an error only if an update
3635cedc7e57SEnrico Perla - Sun Microsystems 	 * is required.
36367c478bd9Sstevel@tonic-gate 	 */
3637cedc7e57SEnrico Perla - Sun Microsystems 	if (bam_nowrite()) {
363848847494SEnrico Perla - Sun Microsystems 		if (is_flag_on(RDONLY_FSCHK)) {
36395eea6091SEnrico Perla - Sun Microsystems 			bam_check = bam_saved_check;
364048847494SEnrico Perla - Sun Microsystems 			if (ret > 0)
364148847494SEnrico Perla - Sun Microsystems 				bam_error(RDONLY_FS, root);
364248847494SEnrico Perla - Sun Microsystems 			if (bam_update_all)
364348847494SEnrico Perla - Sun Microsystems 				return ((ret != 0) ? BAM_ERROR : BAM_SUCCESS);
364448847494SEnrico Perla - Sun Microsystems 		}
364548847494SEnrico Perla - Sun Microsystems 
36467c478bd9Sstevel@tonic-gate 		bam_exit((ret != 0) ? 1 : 0);
36477c478bd9Sstevel@tonic-gate 	}
36487c478bd9Sstevel@tonic-gate 
36497c478bd9Sstevel@tonic-gate 	if (ret == 1) {
36507c478bd9Sstevel@tonic-gate 		/* create the ramdisk */
36517c478bd9Sstevel@tonic-gate 		ret = create_ramdisk(root);
36527c478bd9Sstevel@tonic-gate 	}
3653986fd29aSsetje 
36544a9df875SEnrico Perla - Sun Microsystems 	/*
36554a9df875SEnrico Perla - Sun Microsystems 	 * if the archive is updated, save the new stat data and update the
36564a9df875SEnrico Perla - Sun Microsystems 	 * timestamp file
36574a9df875SEnrico Perla - Sun Microsystems 	 */
3658986fd29aSsetje 	if (ret == 0 && walk_arg.new_nvlp != NULL) {
3659986fd29aSsetje 		savenew(root);
36604a9df875SEnrico Perla - Sun Microsystems 		update_timestamp(root);
3661986fd29aSsetje 	}
3662986fd29aSsetje 
3663986fd29aSsetje 	clear_walk_args();
3664986fd29aSsetje 
36657c478bd9Sstevel@tonic-gate 	return (ret);
36667c478bd9Sstevel@tonic-gate }
36677c478bd9Sstevel@tonic-gate 
366840b108d7SMark J Musante static char *
366940b108d7SMark J Musante find_root_pool()
367040b108d7SMark J Musante {
367140b108d7SMark J Musante 	char *special = get_special("/");
367240b108d7SMark J Musante 	char *p;
367340b108d7SMark J Musante 
367440b108d7SMark J Musante 	if (special == NULL)
367540b108d7SMark J Musante 		return (NULL);
367640b108d7SMark J Musante 
367740b108d7SMark J Musante 	if (*special == '/') {
367840b108d7SMark J Musante 		free(special);
367940b108d7SMark J Musante 		return (NULL);
368040b108d7SMark J Musante 	}
368140b108d7SMark J Musante 
368240b108d7SMark J Musante 	if ((p = strchr(special, '/')) != NULL)
368340b108d7SMark J Musante 		*p = '\0';
368440b108d7SMark J Musante 
368540b108d7SMark J Musante 	return (special);
368640b108d7SMark J Musante }
368740b108d7SMark J Musante 
3688963390b4Svikram static error_t
3689963390b4Svikram synchronize_BE_menu(void)
3690fbac2b2bSvikram {
3691fbac2b2bSvikram 	struct stat	sb;
3692963390b4Svikram 	char		cmdline[PATH_MAX];
3693963390b4Svikram 	char		cksum_line[PATH_MAX];
3694963390b4Svikram 	filelist_t	flist = {0};
3695963390b4Svikram 	char		*old_cksum_str;
3696963390b4Svikram 	char		*old_size_str;
3697963390b4Svikram 	char		*old_file;
3698963390b4Svikram 	char		*curr_cksum_str;
3699963390b4Svikram 	char		*curr_size_str;
3700963390b4Svikram 	char		*curr_file;
370140b108d7SMark J Musante 	char		*pool;
3702963390b4Svikram 	FILE		*cfp;
3703963390b4Svikram 	int		found;
3704963390b4Svikram 	int		ret;
3705963390b4Svikram 	const char	*fcn = "synchronize_BE_menu()";
3706fbac2b2bSvikram 
3707963390b4Svikram 	BAM_DPRINTF((D_FUNC_ENTRY0, fcn));
3708fbac2b2bSvikram 
3709963390b4Svikram 	/* Check if findroot enabled LU BE */
3710963390b4Svikram 	if (stat(FINDROOT_INSTALLGRUB, &sb) != 0) {
3711963390b4Svikram 		BAM_DPRINTF((D_NOT_LU_BE, fcn));
3712963390b4Svikram 		return (BAM_SUCCESS);
3713fbac2b2bSvikram 	}
3714fbac2b2bSvikram 
3715963390b4Svikram 	if (stat(LU_MENU_CKSUM, &sb) != 0) {
3716963390b4Svikram 		BAM_DPRINTF((D_NO_CKSUM_FILE, fcn, LU_MENU_CKSUM));
3717963390b4Svikram 		goto menu_sync;
3718fbac2b2bSvikram 	}
3719963390b4Svikram 
3720963390b4Svikram 	cfp = fopen(LU_MENU_CKSUM, "r");
3721963390b4Svikram 	INJECT_ERROR1("CKSUM_FILE_MISSING", cfp = NULL);
3722963390b4Svikram 	if (cfp == NULL) {
3723963390b4Svikram 		bam_error(CANNOT_READ_LU_CKSUM, LU_MENU_CKSUM);
3724963390b4Svikram 		goto menu_sync;
3725963390b4Svikram 	}
3726963390b4Svikram 	BAM_DPRINTF((D_CKSUM_FILE_OPENED, fcn, LU_MENU_CKSUM));
3727963390b4Svikram 
3728963390b4Svikram 	found = 0;
3729963390b4Svikram 	while (s_fgets(cksum_line, sizeof (cksum_line), cfp) != NULL) {
3730963390b4Svikram 		INJECT_ERROR1("MULTIPLE_CKSUM", found = 1);
3731963390b4Svikram 		if (found) {
3732963390b4Svikram 			bam_error(MULTIPLE_LU_CKSUM, LU_MENU_CKSUM);
3733963390b4Svikram 			(void) fclose(cfp);
3734963390b4Svikram 			goto menu_sync;
3735963390b4Svikram 		}
3736963390b4Svikram 		found = 1;
3737963390b4Svikram 	}
3738963390b4Svikram 	BAM_DPRINTF((D_CKSUM_FILE_READ, fcn, LU_MENU_CKSUM));
3739963390b4Svikram 
3740963390b4Svikram 
3741963390b4Svikram 	old_cksum_str = strtok(cksum_line, " \t");
3742963390b4Svikram 	old_size_str = strtok(NULL, " \t");
3743963390b4Svikram 	old_file = strtok(NULL, " \t");
3744963390b4Svikram 
3745963390b4Svikram 	INJECT_ERROR1("OLD_CKSUM_NULL", old_cksum_str = NULL);
3746963390b4Svikram 	INJECT_ERROR1("OLD_SIZE_NULL", old_size_str = NULL);
3747963390b4Svikram 	INJECT_ERROR1("OLD_FILE_NULL", old_file = NULL);
3748963390b4Svikram 	if (old_cksum_str == NULL || old_size_str == NULL || old_file == NULL) {
3749963390b4Svikram 		bam_error(CANNOT_PARSE_LU_CKSUM, LU_MENU_CKSUM);
3750963390b4Svikram 		goto menu_sync;
3751963390b4Svikram 	}
3752963390b4Svikram 	BAM_DPRINTF((D_CKSUM_FILE_PARSED, fcn, LU_MENU_CKSUM));
3753963390b4Svikram 
3754963390b4Svikram 	/* Get checksum of current menu */
375540b108d7SMark J Musante 	pool = find_root_pool();
375640b108d7SMark J Musante 	(void) snprintf(cmdline, sizeof (cmdline), "%s %s%s%s",
375740b108d7SMark J Musante 	    CKSUM, pool == NULL ? "" : "/", pool == NULL ? "" : pool,
375840b108d7SMark J Musante 	    GRUB_MENU);
375940b108d7SMark J Musante 	free(pool);
3760963390b4Svikram 	ret = exec_cmd(cmdline, &flist);
3761963390b4Svikram 	INJECT_ERROR1("GET_CURR_CKSUM", ret = 1);
3762963390b4Svikram 	if (ret != 0) {
3763963390b4Svikram 		bam_error(MENU_CKSUM_FAIL);
3764963390b4Svikram 		return (BAM_ERROR);
3765963390b4Svikram 	}
3766963390b4Svikram 	BAM_DPRINTF((D_CKSUM_GEN_SUCCESS, fcn));
3767963390b4Svikram 
3768963390b4Svikram 	INJECT_ERROR1("GET_CURR_CKSUM_OUTPUT", flist.head = NULL);
3769963390b4Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
3770963390b4Svikram 		bam_error(BAD_CKSUM);
3771963390b4Svikram 		filelist_free(&flist);
3772963390b4Svikram 		return (BAM_ERROR);
3773963390b4Svikram 	}
3774963390b4Svikram 	BAM_DPRINTF((D_CKSUM_GEN_OUTPUT_VALID, fcn));
3775963390b4Svikram 
3776963390b4Svikram 	curr_cksum_str = strtok(flist.head->line, " \t");
3777963390b4Svikram 	curr_size_str = strtok(NULL, " \t");
3778963390b4Svikram 	curr_file = strtok(NULL, " \t");
3779963390b4Svikram 
3780963390b4Svikram 	INJECT_ERROR1("CURR_CKSUM_NULL", curr_cksum_str = NULL);
3781963390b4Svikram 	INJECT_ERROR1("CURR_SIZE_NULL", curr_size_str = NULL);
3782963390b4Svikram 	INJECT_ERROR1("CURR_FILE_NULL", curr_file = NULL);
3783963390b4Svikram 	if (curr_cksum_str == NULL || curr_size_str == NULL ||
3784963390b4Svikram 	    curr_file == NULL) {
3785963390b4Svikram 		bam_error(BAD_CKSUM_PARSE);
3786963390b4Svikram 		filelist_free(&flist);
3787963390b4Svikram 		return (BAM_ERROR);
3788963390b4Svikram 	}
3789963390b4Svikram 	BAM_DPRINTF((D_CKSUM_GEN_PARSED, fcn));
3790963390b4Svikram 
3791963390b4Svikram 	if (strcmp(old_cksum_str, curr_cksum_str) == 0 &&
3792963390b4Svikram 	    strcmp(old_size_str, curr_size_str) == 0 &&
3793963390b4Svikram 	    strcmp(old_file, curr_file) == 0) {
3794963390b4Svikram 		filelist_free(&flist);
3795963390b4Svikram 		BAM_DPRINTF((D_CKSUM_NO_CHANGE, fcn));
3796963390b4Svikram 		return (BAM_SUCCESS);
3797963390b4Svikram 	}
3798963390b4Svikram 
3799963390b4Svikram 	filelist_free(&flist);
3800963390b4Svikram 
3801963390b4Svikram 	/* cksum doesn't match - the menu has changed */
3802963390b4Svikram 	BAM_DPRINTF((D_CKSUM_HAS_CHANGED, fcn));
3803963390b4Svikram 
3804963390b4Svikram menu_sync:
3805963390b4Svikram 	bam_print(PROP_GRUB_MENU);
3806963390b4Svikram 
3807963390b4Svikram 	(void) snprintf(cmdline, sizeof (cmdline),
3808a6968364Svikram 	    "/bin/sh -c '. %s > /dev/null; %s %s yes > /dev/null'",
3809963390b4Svikram 	    LULIB, LULIB_PROPAGATE_FILE, GRUB_MENU);
3810963390b4Svikram 	ret = exec_cmd(cmdline, NULL);
3811963390b4Svikram 	INJECT_ERROR1("PROPAGATE_MENU", ret = 1);
3812963390b4Svikram 	if (ret != 0) {
3813963390b4Svikram 		bam_error(MENU_PROP_FAIL);
3814963390b4Svikram 		return (BAM_ERROR);
3815963390b4Svikram 	}
3816963390b4Svikram 	BAM_DPRINTF((D_PROPAGATED_MENU, fcn));
3817963390b4Svikram 
3818a6968364Svikram 	(void) snprintf(cmdline, sizeof (cmdline), "/bin/cp %s %s > /dev/null",
3819963390b4Svikram 	    GRUB_MENU, GRUB_BACKUP_MENU);
3820963390b4Svikram 	ret = exec_cmd(cmdline, NULL);
3821963390b4Svikram 	INJECT_ERROR1("CREATE_BACKUP", ret = 1);
3822963390b4Svikram 	if (ret != 0) {
3823963390b4Svikram 		bam_error(MENU_BACKUP_FAIL, GRUB_BACKUP_MENU);
3824963390b4Svikram 		return (BAM_ERROR);
3825963390b4Svikram 	}
3826963390b4Svikram 	BAM_DPRINTF((D_CREATED_BACKUP, fcn, GRUB_BACKUP_MENU));
3827963390b4Svikram 
3828963390b4Svikram 	(void) snprintf(cmdline, sizeof (cmdline),
3829a6968364Svikram 	    "/bin/sh -c '. %s > /dev/null; %s %s no > /dev/null'",
3830963390b4Svikram 	    LULIB, LULIB_PROPAGATE_FILE, GRUB_BACKUP_MENU);
3831963390b4Svikram 	ret = exec_cmd(cmdline, NULL);
3832963390b4Svikram 	INJECT_ERROR1("PROPAGATE_BACKUP", ret = 1);
3833963390b4Svikram 	if (ret != 0) {
3834963390b4Svikram 		bam_error(BACKUP_PROP_FAIL, GRUB_BACKUP_MENU);
3835963390b4Svikram 		return (BAM_ERROR);
3836963390b4Svikram 	}
3837963390b4Svikram 	BAM_DPRINTF((D_PROPAGATED_BACKUP, fcn, GRUB_BACKUP_MENU));
3838963390b4Svikram 
3839963390b4Svikram 	(void) snprintf(cmdline, sizeof (cmdline), "%s %s > %s",
3840963390b4Svikram 	    CKSUM, GRUB_MENU, LU_MENU_CKSUM);
3841963390b4Svikram 	ret = exec_cmd(cmdline, NULL);
3842963390b4Svikram 	INJECT_ERROR1("CREATE_CKSUM_FILE", ret = 1);
3843963390b4Svikram 	if (ret != 0) {
3844963390b4Svikram 		bam_error(MENU_CKSUM_WRITE_FAIL, LU_MENU_CKSUM);
3845963390b4Svikram 		return (BAM_ERROR);
3846963390b4Svikram 	}
3847963390b4Svikram 	BAM_DPRINTF((D_CREATED_CKSUM_FILE, fcn, LU_MENU_CKSUM));
3848963390b4Svikram 
3849963390b4Svikram 	(void) snprintf(cmdline, sizeof (cmdline),
3850a6968364Svikram 	    "/bin/sh -c '. %s > /dev/null; %s %s no > /dev/null'",
3851963390b4Svikram 	    LULIB, LULIB_PROPAGATE_FILE, LU_MENU_CKSUM);
3852963390b4Svikram 	ret = exec_cmd(cmdline, NULL);
3853963390b4Svikram 	INJECT_ERROR1("PROPAGATE_MENU_CKSUM_FILE", ret = 1);
3854963390b4Svikram 	if (ret != 0) {
3855963390b4Svikram 		bam_error(MENU_CKSUM_PROP_FAIL, LU_MENU_CKSUM);
3856963390b4Svikram 		return (BAM_ERROR);
3857963390b4Svikram 	}
3858963390b4Svikram 	BAM_DPRINTF((D_PROPAGATED_CKSUM_FILE, fcn, LU_MENU_CKSUM));
3859963390b4Svikram 
3860963390b4Svikram 	return (BAM_SUCCESS);
3861fbac2b2bSvikram }
3862fbac2b2bSvikram 
38637c478bd9Sstevel@tonic-gate static error_t
38647c478bd9Sstevel@tonic-gate update_all(char *root, char *opt)
38657c478bd9Sstevel@tonic-gate {
38667c478bd9Sstevel@tonic-gate 	struct extmnttab mnt;
38677c478bd9Sstevel@tonic-gate 	struct stat sb;
38687c478bd9Sstevel@tonic-gate 	FILE *fp;
38697c478bd9Sstevel@tonic-gate 	char multibt[PATH_MAX];
3870986fd29aSsetje 	char creatram[PATH_MAX];
38717c478bd9Sstevel@tonic-gate 	error_t ret = BAM_SUCCESS;
38727c478bd9Sstevel@tonic-gate 
387340541d5dSvikram 	assert(root);
38747c478bd9Sstevel@tonic-gate 	assert(opt == NULL);
38757c478bd9Sstevel@tonic-gate 
387640541d5dSvikram 	if (bam_rootlen != 1 || *root != '/') {
387740541d5dSvikram 		elide_trailing_slash(root, multibt, sizeof (multibt));
387840541d5dSvikram 		bam_error(ALT_ROOT_INVALID, multibt);
387940541d5dSvikram 		return (BAM_ERROR);
388040541d5dSvikram 	}
388140541d5dSvikram 
38827c478bd9Sstevel@tonic-gate 	/*
388398892a30Snadkarni 	 * Check to see if we are in the midst of safemode patching
388498892a30Snadkarni 	 * If so skip building the archive for /. Instead build it
388598892a30Snadkarni 	 * against the latest bits obtained by creating a fresh lofs
388698892a30Snadkarni 	 * mount of root.
388798892a30Snadkarni 	 */
388898892a30Snadkarni 	if (stat(LOFS_PATCH_FILE, &sb) == 0)  {
388948847494SEnrico Perla - Sun Microsystems 		if (mkdir(LOFS_PATCH_MNT, DIR_PERMS) == -1 &&
389098892a30Snadkarni 		    errno != EEXIST) {
389198892a30Snadkarni 			bam_error(MKDIR_FAILED, "%s", LOFS_PATCH_MNT,
389298892a30Snadkarni 			    strerror(errno));
389398892a30Snadkarni 			ret = BAM_ERROR;
389498892a30Snadkarni 			goto out;
389598892a30Snadkarni 		}
389698892a30Snadkarni 		(void) snprintf(multibt, sizeof (multibt),
389798892a30Snadkarni 		    "/sbin/mount -F lofs -o nosub /  %s", LOFS_PATCH_MNT);
3898986fd29aSsetje 		if (exec_cmd(multibt, NULL) != 0) {
389998892a30Snadkarni 			bam_error(MOUNT_FAILED, LOFS_PATCH_MNT, "lofs");
390098892a30Snadkarni 			ret = BAM_ERROR;
390198892a30Snadkarni 		}
390298892a30Snadkarni 		if (ret != BAM_ERROR) {
390398892a30Snadkarni 			(void) snprintf(rootbuf, sizeof (rootbuf), "%s/",
390498892a30Snadkarni 			    LOFS_PATCH_MNT);
390598892a30Snadkarni 			bam_rootlen = strlen(rootbuf);
390698892a30Snadkarni 			if (update_archive(rootbuf, opt) != BAM_SUCCESS)
390798892a30Snadkarni 				ret = BAM_ERROR;
390895b1e0e9Snadkarni 			/*
390995b1e0e9Snadkarni 			 * unmount the lofs mount since there could be
391095b1e0e9Snadkarni 			 * multiple invocations of bootadm -a update_all
391195b1e0e9Snadkarni 			 */
391295b1e0e9Snadkarni 			(void) snprintf(multibt, sizeof (multibt),
391395b1e0e9Snadkarni 			    "/sbin/umount %s", LOFS_PATCH_MNT);
3914986fd29aSsetje 			if (exec_cmd(multibt, NULL) != 0) {
391595b1e0e9Snadkarni 				bam_error(UMOUNT_FAILED, LOFS_PATCH_MNT);
391695b1e0e9Snadkarni 				ret = BAM_ERROR;
391795b1e0e9Snadkarni 			}
391898892a30Snadkarni 		}
391998892a30Snadkarni 	} else {
392098892a30Snadkarni 		/*
39217c478bd9Sstevel@tonic-gate 		 * First update archive for current root
39227c478bd9Sstevel@tonic-gate 		 */
39237c478bd9Sstevel@tonic-gate 		if (update_archive(root, opt) != BAM_SUCCESS)
39247c478bd9Sstevel@tonic-gate 			ret = BAM_ERROR;
392598892a30Snadkarni 	}
392698892a30Snadkarni 
392798892a30Snadkarni 	if (ret == BAM_ERROR)
392898892a30Snadkarni 		goto out;
39297c478bd9Sstevel@tonic-gate 
39307c478bd9Sstevel@tonic-gate 	/*
39317c478bd9Sstevel@tonic-gate 	 * Now walk the mount table, performing archive update
39327c478bd9Sstevel@tonic-gate 	 * for all mounted Newboot root filesystems
39337c478bd9Sstevel@tonic-gate 	 */
39347c478bd9Sstevel@tonic-gate 	fp = fopen(MNTTAB, "r");
39357c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
39367c478bd9Sstevel@tonic-gate 		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
3937b610f78eSvikram 		ret = BAM_ERROR;
3938b610f78eSvikram 		goto out;
39397c478bd9Sstevel@tonic-gate 	}
39407c478bd9Sstevel@tonic-gate 
39417c478bd9Sstevel@tonic-gate 	resetmnttab(fp);
39427c478bd9Sstevel@tonic-gate 
39437c478bd9Sstevel@tonic-gate 	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
39447c478bd9Sstevel@tonic-gate 		if (mnt.mnt_special == NULL)
39457c478bd9Sstevel@tonic-gate 			continue;
3946f904d32dSJerry Gilliam 		if ((strcmp(mnt.mnt_fstype, MNTTYPE_ZFS) != 0) &&
3947f904d32dSJerry Gilliam 		    (strncmp(mnt.mnt_special, "/dev/", strlen("/dev/")) != 0))
39487c478bd9Sstevel@tonic-gate 			continue;
39497c478bd9Sstevel@tonic-gate 		if (strcmp(mnt.mnt_mountp, "/") == 0)
39507c478bd9Sstevel@tonic-gate 			continue;
39517c478bd9Sstevel@tonic-gate 
3952986fd29aSsetje 		(void) snprintf(creatram, sizeof (creatram), "%s/%s",
3953986fd29aSsetje 		    mnt.mnt_mountp, CREATE_RAMDISK);
39547c478bd9Sstevel@tonic-gate 
3955986fd29aSsetje 		if (stat(creatram, &sb) == -1)
39567c478bd9Sstevel@tonic-gate 			continue;
39577c478bd9Sstevel@tonic-gate 
39587c478bd9Sstevel@tonic-gate 		/*
39597c478bd9Sstevel@tonic-gate 		 * We put a trailing slash to be consistent with root = "/"
39607c478bd9Sstevel@tonic-gate 		 * case, such that we don't have to print // in some cases.
39617c478bd9Sstevel@tonic-gate 		 */
39627c478bd9Sstevel@tonic-gate 		(void) snprintf(rootbuf, sizeof (rootbuf), "%s/",
39637c478bd9Sstevel@tonic-gate 		    mnt.mnt_mountp);
39647c478bd9Sstevel@tonic-gate 		bam_rootlen = strlen(rootbuf);
3965ae115bc7Smrj 
3966ae115bc7Smrj 		/*
3967ae115bc7Smrj 		 * It's possible that other mounts may be an alternate boot
3968ae115bc7Smrj 		 * architecture, so check it again.
3969ae115bc7Smrj 		 */
3970eb2bd662Svikram 		if ((get_boot_cap(rootbuf) != BAM_SUCCESS) ||
3971ae115bc7Smrj 		    (update_archive(rootbuf, opt) != BAM_SUCCESS))
39727c478bd9Sstevel@tonic-gate 			ret = BAM_ERROR;
39737c478bd9Sstevel@tonic-gate 	}
39747c478bd9Sstevel@tonic-gate 
39757c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
39767c478bd9Sstevel@tonic-gate 
3977b610f78eSvikram out:
3978fbac2b2bSvikram 	/*
3979963390b4Svikram 	 * We no longer use biosdev for Live Upgrade. Hence
3980963390b4Svikram 	 * there is no need to defer (to shutdown time) any fdisk
3981963390b4Svikram 	 * updates
3982fbac2b2bSvikram 	 */
3983963390b4Svikram 	if (stat(GRUB_fdisk, &sb) == 0 || stat(GRUB_fdisk_target, &sb) == 0) {
3984963390b4Svikram 		bam_error(FDISK_FILES_FOUND, GRUB_fdisk, GRUB_fdisk_target);
3985fbac2b2bSvikram 	}
3986fbac2b2bSvikram 
3987963390b4Svikram 	/*
3988963390b4Svikram 	 * If user has updated menu in current BE, propagate the
3989963390b4Svikram 	 * updates to all BEs.
3990963390b4Svikram 	 */
399119397407SSherry Moore 	if (sync_menu && synchronize_BE_menu() != BAM_SUCCESS)
3992963390b4Svikram 		ret = BAM_ERROR;
3993963390b4Svikram 
39947c478bd9Sstevel@tonic-gate 	return (ret);
39957c478bd9Sstevel@tonic-gate }
39967c478bd9Sstevel@tonic-gate 
39977c478bd9Sstevel@tonic-gate static void
39987c478bd9Sstevel@tonic-gate append_line(menu_t *mp, line_t *lp)
39997c478bd9Sstevel@tonic-gate {
40007c478bd9Sstevel@tonic-gate 	if (mp->start == NULL) {
40017c478bd9Sstevel@tonic-gate 		mp->start = lp;
40027c478bd9Sstevel@tonic-gate 	} else {
40037c478bd9Sstevel@tonic-gate 		mp->end->next = lp;
40048c1b6884Sszhou 		lp->prev = mp->end;
40057c478bd9Sstevel@tonic-gate 	}
40067c478bd9Sstevel@tonic-gate 	mp->end = lp;
40077c478bd9Sstevel@tonic-gate }
40087c478bd9Sstevel@tonic-gate 
4009eb2bd662Svikram void
40108c1b6884Sszhou unlink_line(menu_t *mp, line_t *lp)
40118c1b6884Sszhou {
40128c1b6884Sszhou 	/* unlink from list */
40138c1b6884Sszhou 	if (lp->prev)
40148c1b6884Sszhou 		lp->prev->next = lp->next;
40158c1b6884Sszhou 	else
40168c1b6884Sszhou 		mp->start = lp->next;
40178c1b6884Sszhou 	if (lp->next)
40188c1b6884Sszhou 		lp->next->prev = lp->prev;
40198c1b6884Sszhou 	else
40208c1b6884Sszhou 		mp->end = lp->prev;
40218c1b6884Sszhou }
40228c1b6884Sszhou 
40238c1b6884Sszhou static entry_t *
40248c1b6884Sszhou boot_entry_new(menu_t *mp, line_t *start, line_t *end)
40258c1b6884Sszhou {
40268c1b6884Sszhou 	entry_t *ent, *prev;
4027eb2bd662Svikram 	const char *fcn = "boot_entry_new()";
4028eb2bd662Svikram 
4029eb2bd662Svikram 	assert(mp);
4030eb2bd662Svikram 	assert(start);
4031eb2bd662Svikram 	assert(end);
40328c1b6884Sszhou 
40338c1b6884Sszhou 	ent = s_calloc(1, sizeof (entry_t));
4034eb2bd662Svikram 	BAM_DPRINTF((D_ENTRY_NEW, fcn));
40358c1b6884Sszhou 	ent->start = start;
40368c1b6884Sszhou 	ent->end = end;
40378c1b6884Sszhou 
40388c1b6884Sszhou 	if (mp->entries == NULL) {
40398c1b6884Sszhou 		mp->entries = ent;
4040eb2bd662Svikram 		BAM_DPRINTF((D_ENTRY_NEW_FIRST, fcn));
40418c1b6884Sszhou 		return (ent);
40428c1b6884Sszhou 	}
40438c1b6884Sszhou 
40448c1b6884Sszhou 	prev = mp->entries;
40458c1b6884Sszhou 	while (prev->next)
40468c1b6884Sszhou 		prev = prev->next;
40478c1b6884Sszhou 	prev->next = ent;
40488c1b6884Sszhou 	ent->prev = prev;
4049eb2bd662Svikram 	BAM_DPRINTF((D_ENTRY_NEW_LINKED, fcn));
40508c1b6884Sszhou 	return (ent);
40518c1b6884Sszhou }
40528c1b6884Sszhou 
40538c1b6884Sszhou static void
40548c1b6884Sszhou boot_entry_addline(entry_t *ent, line_t *lp)
40558c1b6884Sszhou {
40568c1b6884Sszhou 	if (ent)
40578c1b6884Sszhou 		ent->end = lp;
40588c1b6884Sszhou }
40598c1b6884Sszhou 
40607c478bd9Sstevel@tonic-gate /*
4061843e1988Sjohnlev  * Check whether cmd matches the one indexed by which, and whether arg matches
4062843e1988Sjohnlev  * str.  which must be either KERNEL_CMD or MODULE_CMD, and a match to the
4063843e1988Sjohnlev  * respective *_DOLLAR_CMD is also acceptable.  The arg is searched using
4064843e1988Sjohnlev  * strstr(), so it can be a partial match.
4065843e1988Sjohnlev  */
4066843e1988Sjohnlev static int
4067843e1988Sjohnlev check_cmd(const char *cmd, const int which, const char *arg, const char *str)
4068843e1988Sjohnlev {
4069eb2bd662Svikram 	int			ret;
4070eb2bd662Svikram 	const char		*fcn = "check_cmd()";
4071eb2bd662Svikram 
4072eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, arg, str));
4073eb2bd662Svikram 
4074eac223ccSWilliam Kucharski 	if (cmd != NULL) {
4075843e1988Sjohnlev 		if ((strcmp(cmd, menu_cmds[which]) != 0) &&
4076843e1988Sjohnlev 		    (strcmp(cmd, menu_cmds[which + 1]) != 0)) {
4077eb2bd662Svikram 			BAM_DPRINTF((D_CHECK_CMD_CMD_NOMATCH,
4078eb2bd662Svikram 			    fcn, cmd, menu_cmds[which]));
4079843e1988Sjohnlev 			return (0);
4080843e1988Sjohnlev 		}
4081eb2bd662Svikram 		ret = (strstr(arg, str) != NULL);
4082eac223ccSWilliam Kucharski 	} else
4083eac223ccSWilliam Kucharski 		ret = 0;
4084eb2bd662Svikram 
4085eb2bd662Svikram 	if (ret) {
4086eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
4087eb2bd662Svikram 	} else {
4088eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
4089eb2bd662Svikram 	}
4090eb2bd662Svikram 
4091eb2bd662Svikram 	return (ret);
4092eb2bd662Svikram }
4093eb2bd662Svikram 
4094eb2bd662Svikram static error_t
4095eb2bd662Svikram kernel_parser(entry_t *entry, char *cmd, char *arg, int linenum)
4096eb2bd662Svikram {
4097eb2bd662Svikram 	const char		*fcn  = "kernel_parser()";
4098eb2bd662Svikram 
4099eb2bd662Svikram 	assert(entry);
4100eb2bd662Svikram 	assert(cmd);
4101eb2bd662Svikram 	assert(arg);
4102eb2bd662Svikram 
4103eb2bd662Svikram 	if (strcmp(cmd, menu_cmds[KERNEL_CMD]) != 0 &&
4104eb2bd662Svikram 	    strcmp(cmd, menu_cmds[KERNEL_DOLLAR_CMD]) != 0) {
4105eb2bd662Svikram 		BAM_DPRINTF((D_NOT_KERNEL_CMD, fcn, cmd));
4106eb2bd662Svikram 		return (BAM_ERROR);
4107eb2bd662Svikram 	}
4108eb2bd662Svikram 
4109eb2bd662Svikram 	if (strncmp(arg, DIRECT_BOOT_32, sizeof (DIRECT_BOOT_32) - 1) == 0) {
4110eb2bd662Svikram 		BAM_DPRINTF((D_SET_DBOOT_32, fcn, arg));
4111eb2bd662Svikram 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_32BIT;
4112eb2bd662Svikram 	} else if (strncmp(arg, DIRECT_BOOT_KERNEL,
4113eb2bd662Svikram 	    sizeof (DIRECT_BOOT_KERNEL) - 1) == 0) {
4114eb2bd662Svikram 		BAM_DPRINTF((D_SET_DBOOT, fcn, arg));
4115eb2bd662Svikram 		entry->flags |= BAM_ENTRY_DBOOT;
4116eb2bd662Svikram 	} else if (strncmp(arg, DIRECT_BOOT_64,
4117eb2bd662Svikram 	    sizeof (DIRECT_BOOT_64) - 1) == 0) {
4118eb2bd662Svikram 		BAM_DPRINTF((D_SET_DBOOT_64, fcn, arg));
4119eb2bd662Svikram 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_64BIT;
4120eb2bd662Svikram 	} else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_KERNEL,
4121eb2bd662Svikram 	    sizeof (DIRECT_BOOT_FAILSAFE_KERNEL) - 1) == 0) {
4122eb2bd662Svikram 		BAM_DPRINTF((D_SET_DBOOT_FAILSAFE, fcn, arg));
4123eb2bd662Svikram 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE;
4124bbcc54bdSEnrico Perla - Sun Microsystems 	} else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_32,
4125bbcc54bdSEnrico Perla - Sun Microsystems 	    sizeof (DIRECT_BOOT_FAILSAFE_32) - 1) == 0) {
4126bbcc54bdSEnrico Perla - Sun Microsystems 		BAM_DPRINTF((D_SET_DBOOT_FAILSAFE_32, fcn, arg));
4127bbcc54bdSEnrico Perla - Sun Microsystems 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE
4128bbcc54bdSEnrico Perla - Sun Microsystems 		    | BAM_ENTRY_32BIT;
4129bbcc54bdSEnrico Perla - Sun Microsystems 	} else if (strncmp(arg, DIRECT_BOOT_FAILSAFE_64,
4130bbcc54bdSEnrico Perla - Sun Microsystems 	    sizeof (DIRECT_BOOT_FAILSAFE_64) - 1) == 0) {
4131bbcc54bdSEnrico Perla - Sun Microsystems 		BAM_DPRINTF((D_SET_DBOOT_FAILSAFE_64, fcn, arg));
4132bbcc54bdSEnrico Perla - Sun Microsystems 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_FAILSAFE
4133bbcc54bdSEnrico Perla - Sun Microsystems 		    | BAM_ENTRY_64BIT;
4134eb2bd662Svikram 	} else if (strncmp(arg, MULTI_BOOT, sizeof (MULTI_BOOT) - 1) == 0) {
4135eb2bd662Svikram 		BAM_DPRINTF((D_SET_MULTIBOOT, fcn, arg));
4136eb2bd662Svikram 		entry->flags |= BAM_ENTRY_MULTIBOOT;
4137eb2bd662Svikram 	} else if (strncmp(arg, MULTI_BOOT_FAILSAFE,
4138eb2bd662Svikram 	    sizeof (MULTI_BOOT_FAILSAFE) - 1) == 0) {
4139eb2bd662Svikram 		BAM_DPRINTF((D_SET_MULTIBOOT_FAILSAFE, fcn, arg));
4140eb2bd662Svikram 		entry->flags |= BAM_ENTRY_MULTIBOOT | BAM_ENTRY_FAILSAFE;
4141eb2bd662Svikram 	} else if (strstr(arg, XEN_KERNEL_SUBSTR)) {
4142eb2bd662Svikram 		BAM_DPRINTF((D_SET_HV, fcn, arg));
4143eb2bd662Svikram 		entry->flags |= BAM_ENTRY_HV;
4144eb2bd662Svikram 	} else if (!(entry->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU))) {
4145eb2bd662Svikram 		BAM_DPRINTF((D_SET_HAND_KERNEL, fcn, arg));
4146eb2bd662Svikram 		return (BAM_ERROR);
414737eb779cSVikram Hegde 	} else if (strncmp(arg, KERNEL_PREFIX, strlen(KERNEL_PREFIX)) == 0 &&
414837eb779cSVikram Hegde 	    strstr(arg, UNIX_SPACE)) {
414937eb779cSVikram Hegde 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_32BIT;
415037eb779cSVikram Hegde 	} else if (strncmp(arg, KERNEL_PREFIX, strlen(KERNEL_PREFIX)) == 0 &&
415137eb779cSVikram Hegde 	    strstr(arg, AMD_UNIX_SPACE)) {
415237eb779cSVikram Hegde 		entry->flags |= BAM_ENTRY_DBOOT | BAM_ENTRY_64BIT;
4153eb2bd662Svikram 	} else {
4154eb2bd662Svikram 		BAM_DPRINTF((D_IS_UNKNOWN_KERNEL, fcn, arg));
4155eb2bd662Svikram 		bam_error(UNKNOWN_KERNEL_LINE, linenum);
4156eb2bd662Svikram 		return (BAM_ERROR);
4157eb2bd662Svikram 	}
4158eb2bd662Svikram 
4159eb2bd662Svikram 	return (BAM_SUCCESS);
4160eb2bd662Svikram }
4161eb2bd662Svikram 
4162eb2bd662Svikram static error_t
4163eb2bd662Svikram module_parser(entry_t *entry, char *cmd, char *arg, int linenum)
4164eb2bd662Svikram {
4165eb2bd662Svikram 	const char		*fcn = "module_parser()";
4166eb2bd662Svikram 
4167eb2bd662Svikram 	assert(entry);
4168eb2bd662Svikram 	assert(cmd);
4169eb2bd662Svikram 	assert(arg);
4170eb2bd662Svikram 
4171eb2bd662Svikram 	if (strcmp(cmd, menu_cmds[MODULE_CMD]) != 0 &&
4172eb2bd662Svikram 	    strcmp(cmd, menu_cmds[MODULE_DOLLAR_CMD]) != 0) {
4173eb2bd662Svikram 		BAM_DPRINTF((D_NOT_MODULE_CMD, fcn, cmd));
4174eb2bd662Svikram 		return (BAM_ERROR);
4175eb2bd662Svikram 	}
4176eb2bd662Svikram 
4177eb2bd662Svikram 	if (strcmp(arg, DIRECT_BOOT_ARCHIVE) == 0 ||
4178eb2bd662Svikram 	    strcmp(arg, DIRECT_BOOT_ARCHIVE_32) == 0 ||
4179eb2bd662Svikram 	    strcmp(arg, DIRECT_BOOT_ARCHIVE_64) == 0 ||
4180eb2bd662Svikram 	    strcmp(arg, MULTIBOOT_ARCHIVE) == 0 ||
4181eb2bd662Svikram 	    strcmp(arg, FAILSAFE_ARCHIVE) == 0 ||
4182bbcc54bdSEnrico Perla - Sun Microsystems 	    strcmp(arg, FAILSAFE_ARCHIVE_32) == 0 ||
4183bbcc54bdSEnrico Perla - Sun Microsystems 	    strcmp(arg, FAILSAFE_ARCHIVE_64) == 0 ||
4184eb2bd662Svikram 	    strcmp(arg, XEN_KERNEL_MODULE_LINE) == 0 ||
4185eb2bd662Svikram 	    strcmp(arg, XEN_KERNEL_MODULE_LINE_ZFS) == 0) {
4186eb2bd662Svikram 		BAM_DPRINTF((D_BOOTADM_LU_MODULE, fcn, arg));
4187eb2bd662Svikram 		return (BAM_SUCCESS);
4188eb2bd662Svikram 	} else if (!(entry->flags & BAM_ENTRY_BOOTADM) &&
4189eb2bd662Svikram 	    !(entry->flags & BAM_ENTRY_LU)) {
4190eb2bd662Svikram 		/* don't emit warning for hand entries */
4191eb2bd662Svikram 		BAM_DPRINTF((D_IS_HAND_MODULE, fcn, arg));
4192eb2bd662Svikram 		return (BAM_ERROR);
4193eb2bd662Svikram 	} else {
4194eb2bd662Svikram 		BAM_DPRINTF((D_IS_UNKNOWN_MODULE, fcn, arg));
4195eb2bd662Svikram 		bam_error(UNKNOWN_MODULE_LINE, linenum);
4196eb2bd662Svikram 		return (BAM_ERROR);
4197eb2bd662Svikram 	}
4198843e1988Sjohnlev }
4199843e1988Sjohnlev 
4200843e1988Sjohnlev /*
42017c478bd9Sstevel@tonic-gate  * A line in menu.lst looks like
42027c478bd9Sstevel@tonic-gate  * [ ]*<cmd>[ \t=]*<arg>*
42037c478bd9Sstevel@tonic-gate  */
42047c478bd9Sstevel@tonic-gate static void
42057c478bd9Sstevel@tonic-gate line_parser(menu_t *mp, char *str, int *lineNum, int *entryNum)
42067c478bd9Sstevel@tonic-gate {
42077c478bd9Sstevel@tonic-gate 	/*
42087c478bd9Sstevel@tonic-gate 	 * save state across calls. This is so that
42097c478bd9Sstevel@tonic-gate 	 * header gets the right entry# after title has
42107c478bd9Sstevel@tonic-gate 	 * been processed
42117c478bd9Sstevel@tonic-gate 	 */
42128c1b6884Sszhou 	static line_t *prev = NULL;
42138c1b6884Sszhou 	static entry_t *curr_ent = NULL;
4214ae115bc7Smrj 	static int in_liveupgrade = 0;
4215772d6a58SWilliam Kucharski 	static int is_libbe_ent = 0;
42167c478bd9Sstevel@tonic-gate 
42177c478bd9Sstevel@tonic-gate 	line_t	*lp;
42187c478bd9Sstevel@tonic-gate 	char *cmd, *sep, *arg;
42197c478bd9Sstevel@tonic-gate 	char save, *cp, *line;
42207c478bd9Sstevel@tonic-gate 	menu_flag_t flag = BAM_INVALID;
4221eb2bd662Svikram 	const char *fcn = "line_parser()";
42227c478bd9Sstevel@tonic-gate 
42237c478bd9Sstevel@tonic-gate 	if (str == NULL) {
42247c478bd9Sstevel@tonic-gate 		return;
42257c478bd9Sstevel@tonic-gate 	}
42267c478bd9Sstevel@tonic-gate 
42277c478bd9Sstevel@tonic-gate 	/*
42287c478bd9Sstevel@tonic-gate 	 * First save a copy of the entire line.
42297c478bd9Sstevel@tonic-gate 	 * We use this later to set the line field.
42307c478bd9Sstevel@tonic-gate 	 */
42317c478bd9Sstevel@tonic-gate 	line = s_strdup(str);
42327c478bd9Sstevel@tonic-gate 
42337c478bd9Sstevel@tonic-gate 	/* Eat up leading whitespace */
42347c478bd9Sstevel@tonic-gate 	while (*str == ' ' || *str == '\t')
42357c478bd9Sstevel@tonic-gate 		str++;
42367c478bd9Sstevel@tonic-gate 
42377c478bd9Sstevel@tonic-gate 	if (*str == '#') {		/* comment */
42387c478bd9Sstevel@tonic-gate 		cmd = s_strdup("#");
42397c478bd9Sstevel@tonic-gate 		sep = NULL;
42407c478bd9Sstevel@tonic-gate 		arg = s_strdup(str + 1);
42417c478bd9Sstevel@tonic-gate 		flag = BAM_COMMENT;
4242ae115bc7Smrj 		if (strstr(arg, BAM_LU_HDR) != NULL) {
4243ae115bc7Smrj 			in_liveupgrade = 1;
4244ae115bc7Smrj 		} else if (strstr(arg, BAM_LU_FTR) != NULL) {
4245ae115bc7Smrj 			in_liveupgrade = 0;
4246772d6a58SWilliam Kucharski 		} else if (strstr(arg, BAM_LIBBE_FTR) != NULL) {
4247772d6a58SWilliam Kucharski 			is_libbe_ent = 1;
4248ae115bc7Smrj 		}
42497c478bd9Sstevel@tonic-gate 	} else if (*str == '\0') {	/* blank line */
42507c478bd9Sstevel@tonic-gate 		cmd = sep = arg = NULL;
42517c478bd9Sstevel@tonic-gate 		flag = BAM_EMPTY;
42527c478bd9Sstevel@tonic-gate 	} else {
42537c478bd9Sstevel@tonic-gate 		/*
42547c478bd9Sstevel@tonic-gate 		 * '=' is not a documented separator in grub syntax.
42557c478bd9Sstevel@tonic-gate 		 * However various development bits use '=' as a
42567c478bd9Sstevel@tonic-gate 		 * separator. In addition, external users also
42577c478bd9Sstevel@tonic-gate 		 * use = as a separator. So we will allow that usage.
42587c478bd9Sstevel@tonic-gate 		 */
42597c478bd9Sstevel@tonic-gate 		cp = str;
42607c478bd9Sstevel@tonic-gate 		while (*str != ' ' && *str != '\t' && *str != '=') {
42617c478bd9Sstevel@tonic-gate 			if (*str == '\0') {
42627c478bd9Sstevel@tonic-gate 				cmd = s_strdup(cp);
42637c478bd9Sstevel@tonic-gate 				sep = arg = NULL;
42647c478bd9Sstevel@tonic-gate 				break;
42657c478bd9Sstevel@tonic-gate 			}
42667c478bd9Sstevel@tonic-gate 			str++;
42677c478bd9Sstevel@tonic-gate 		}
42687c478bd9Sstevel@tonic-gate 
42697c478bd9Sstevel@tonic-gate 		if (*str != '\0') {
42707c478bd9Sstevel@tonic-gate 			save = *str;
42717c478bd9Sstevel@tonic-gate 			*str = '\0';
42727c478bd9Sstevel@tonic-gate 			cmd = s_strdup(cp);
42737c478bd9Sstevel@tonic-gate 			*str = save;
42747c478bd9Sstevel@tonic-gate 
42757c478bd9Sstevel@tonic-gate 			str++;
42767c478bd9Sstevel@tonic-gate 			save = *str;
42777c478bd9Sstevel@tonic-gate 			*str = '\0';
42787c478bd9Sstevel@tonic-gate 			sep = s_strdup(str - 1);
42797c478bd9Sstevel@tonic-gate 			*str = save;
42807c478bd9Sstevel@tonic-gate 
42817c478bd9Sstevel@tonic-gate 			while (*str == ' ' || *str == '\t')
42827c478bd9Sstevel@tonic-gate 				str++;
42837c478bd9Sstevel@tonic-gate 			if (*str == '\0')
42847c478bd9Sstevel@tonic-gate 				arg = NULL;
42857c478bd9Sstevel@tonic-gate 			else
42867c478bd9Sstevel@tonic-gate 				arg = s_strdup(str);
42877c478bd9Sstevel@tonic-gate 		}
42887c478bd9Sstevel@tonic-gate 	}
42897c478bd9Sstevel@tonic-gate 
42907c478bd9Sstevel@tonic-gate 	lp = s_calloc(1, sizeof (line_t));
42917c478bd9Sstevel@tonic-gate 
42927c478bd9Sstevel@tonic-gate 	lp->cmd = cmd;
42937c478bd9Sstevel@tonic-gate 	lp->sep = sep;
42947c478bd9Sstevel@tonic-gate 	lp->arg = arg;
42957c478bd9Sstevel@tonic-gate 	lp->line = line;
42967c478bd9Sstevel@tonic-gate 	lp->lineNum = ++(*lineNum);
42977c478bd9Sstevel@tonic-gate 	if (cmd && strcmp(cmd, menu_cmds[TITLE_CMD]) == 0) {
42987c478bd9Sstevel@tonic-gate 		lp->entryNum = ++(*entryNum);
42997c478bd9Sstevel@tonic-gate 		lp->flags = BAM_TITLE;
43007c478bd9Sstevel@tonic-gate 		if (prev && prev->flags == BAM_COMMENT &&
4301ae115bc7Smrj 		    prev->arg && strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) {
43027c478bd9Sstevel@tonic-gate 			prev->entryNum = lp->entryNum;
43038c1b6884Sszhou 			curr_ent = boot_entry_new(mp, prev, lp);
4304eb2bd662Svikram 			curr_ent->flags |= BAM_ENTRY_BOOTADM;
4305eb2bd662Svikram 			BAM_DPRINTF((D_IS_BOOTADM_ENTRY, fcn, arg));
43068c1b6884Sszhou 		} else {
43078c1b6884Sszhou 			curr_ent = boot_entry_new(mp, lp, lp);
4308ae115bc7Smrj 			if (in_liveupgrade) {
4309eb2bd662Svikram 				curr_ent->flags |= BAM_ENTRY_LU;
4310eb2bd662Svikram 				BAM_DPRINTF((D_IS_LU_ENTRY, fcn, arg));
43118c1b6884Sszhou 			}
4312ae115bc7Smrj 		}
4313ae115bc7Smrj 		curr_ent->entryNum = *entryNum;
43147c478bd9Sstevel@tonic-gate 	} else if (flag != BAM_INVALID) {
43157c478bd9Sstevel@tonic-gate 		/*
43167c478bd9Sstevel@tonic-gate 		 * For header comments, the entry# is "fixed up"
43177c478bd9Sstevel@tonic-gate 		 * by the subsequent title
43187c478bd9Sstevel@tonic-gate 		 */
43197c478bd9Sstevel@tonic-gate 		lp->entryNum = *entryNum;
43207c478bd9Sstevel@tonic-gate 		lp->flags = flag;
43217c478bd9Sstevel@tonic-gate 	} else {
43227c478bd9Sstevel@tonic-gate 		lp->entryNum = *entryNum;
4323ae115bc7Smrj 
4324ae115bc7Smrj 		if (*entryNum == ENTRY_INIT) {
4325ae115bc7Smrj 			lp->flags = BAM_GLOBAL;
4326ae115bc7Smrj 		} else {
4327ae115bc7Smrj 			lp->flags = BAM_ENTRY;
4328ae115bc7Smrj 
4329ae115bc7Smrj 			if (cmd && arg) {
4330eb2bd662Svikram 				if (strcmp(cmd, menu_cmds[ROOT_CMD]) == 0) {
4331eb2bd662Svikram 					BAM_DPRINTF((D_IS_ROOT_CMD, fcn, arg));
4332ae115bc7Smrj 					curr_ent->flags |= BAM_ENTRY_ROOT;
4333eb2bd662Svikram 				} else if (strcmp(cmd, menu_cmds[FINDROOT_CMD])
4334eb2bd662Svikram 				    == 0) {
4335eb2bd662Svikram 					BAM_DPRINTF((D_IS_FINDROOT_CMD, fcn,
4336eb2bd662Svikram 					    arg));
4337eb2bd662Svikram 					curr_ent->flags |= BAM_ENTRY_FINDROOT;
4338eb2bd662Svikram 				} else if (strcmp(cmd,
4339eb2bd662Svikram 				    menu_cmds[CHAINLOADER_CMD]) == 0) {
4340eb2bd662Svikram 					BAM_DPRINTF((D_IS_CHAINLOADER_CMD, fcn,
4341eb2bd662Svikram 					    arg));
4342ae115bc7Smrj 					curr_ent->flags |=
4343ae115bc7Smrj 					    BAM_ENTRY_CHAINLOADER;
4344eb2bd662Svikram 				} else if (kernel_parser(curr_ent, cmd, arg,
4345eb2bd662Svikram 				    lp->lineNum) != BAM_SUCCESS) {
4346eb2bd662Svikram 					(void) module_parser(curr_ent, cmd,
4347eb2bd662Svikram 					    arg, lp->lineNum);
4348eb2bd662Svikram 				}
4349ae115bc7Smrj 			}
4350ae115bc7Smrj 		}
43517c478bd9Sstevel@tonic-gate 	}
43527c478bd9Sstevel@tonic-gate 
43538c1b6884Sszhou 	/* record default, old default, and entry line ranges */
4354eac223ccSWilliam Kucharski 	if (lp->flags == BAM_GLOBAL && lp->cmd != NULL &&
43558c1b6884Sszhou 	    strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0) {
43568c1b6884Sszhou 		mp->curdefault = lp;
43578c1b6884Sszhou 	} else if (lp->flags == BAM_COMMENT &&
43588c1b6884Sszhou 	    strncmp(lp->arg, BAM_OLDDEF, strlen(BAM_OLDDEF)) == 0) {
43598c1b6884Sszhou 		mp->olddefault = lp;
4360ae115bc7Smrj 	} else if (lp->flags == BAM_COMMENT &&
4361ae115bc7Smrj 	    strncmp(lp->arg, BAM_OLD_RC_DEF, strlen(BAM_OLD_RC_DEF)) == 0) {
4362ae115bc7Smrj 		mp->old_rc_default = lp;
43638c1b6884Sszhou 	} else if (lp->flags == BAM_ENTRY ||
4364ae115bc7Smrj 	    (lp->flags == BAM_COMMENT &&
4365772d6a58SWilliam Kucharski 	    ((strcmp(lp->arg, BAM_BOOTADM_FTR) == 0) || is_libbe_ent))) {
4366772d6a58SWilliam Kucharski 		if (is_libbe_ent) {
4367772d6a58SWilliam Kucharski 			curr_ent->flags |= BAM_ENTRY_LIBBE;
4368772d6a58SWilliam Kucharski 			is_libbe_ent = 0;
4369772d6a58SWilliam Kucharski 		}
4370772d6a58SWilliam Kucharski 
43718c1b6884Sszhou 		boot_entry_addline(curr_ent, lp);
43728c1b6884Sszhou 	}
43737c478bd9Sstevel@tonic-gate 	append_line(mp, lp);
43747c478bd9Sstevel@tonic-gate 
43757c478bd9Sstevel@tonic-gate 	prev = lp;
43767c478bd9Sstevel@tonic-gate }
43777c478bd9Sstevel@tonic-gate 
4378eb2bd662Svikram void
437940541d5dSvikram update_numbering(menu_t *mp)
438040541d5dSvikram {
438140541d5dSvikram 	int lineNum;
438240541d5dSvikram 	int entryNum;
438340541d5dSvikram 	int old_default_value;
438440541d5dSvikram 	line_t *lp, *prev, *default_lp, *default_entry;
438540541d5dSvikram 	char buf[PATH_MAX];
438640541d5dSvikram 
438740541d5dSvikram 	if (mp->start == NULL) {
438840541d5dSvikram 		return;
438940541d5dSvikram 	}
439040541d5dSvikram 
439140541d5dSvikram 	lineNum = LINE_INIT;
439240541d5dSvikram 	entryNum = ENTRY_INIT;
439340541d5dSvikram 	old_default_value = ENTRY_INIT;
439440541d5dSvikram 	lp = default_lp = default_entry = NULL;
439540541d5dSvikram 
439640541d5dSvikram 	prev = NULL;
439740541d5dSvikram 	for (lp = mp->start; lp; prev = lp, lp = lp->next) {
439840541d5dSvikram 		lp->lineNum = ++lineNum;
439940541d5dSvikram 
440040541d5dSvikram 		/*
440140541d5dSvikram 		 * Get the value of the default command
440240541d5dSvikram 		 */
4403eac223ccSWilliam Kucharski 		if (lp->entryNum == ENTRY_INIT && lp->cmd != NULL &&
440440541d5dSvikram 		    strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0 &&
440540541d5dSvikram 		    lp->arg) {
440640541d5dSvikram 			old_default_value = atoi(lp->arg);
440740541d5dSvikram 			default_lp = lp;
440840541d5dSvikram 		}
440940541d5dSvikram 
441040541d5dSvikram 		/*
4411eb2bd662Svikram 		 * If not a booting entry, nothing else to fix for this
441240541d5dSvikram 		 * entry
441340541d5dSvikram 		 */
441440541d5dSvikram 		if (lp->entryNum == ENTRY_INIT)
441540541d5dSvikram 			continue;
441640541d5dSvikram 
441740541d5dSvikram 		/*
441840541d5dSvikram 		 * Record the position of the default entry.
441940541d5dSvikram 		 * The following works because global
442040541d5dSvikram 		 * commands like default and timeout should precede
442140541d5dSvikram 		 * actual boot entries, so old_default_value
442240541d5dSvikram 		 * is already known (or default cmd is missing).
442340541d5dSvikram 		 */
442440541d5dSvikram 		if (default_entry == NULL &&
442540541d5dSvikram 		    old_default_value != ENTRY_INIT &&
442640541d5dSvikram 		    lp->entryNum == old_default_value) {
442740541d5dSvikram 			default_entry = lp;
442840541d5dSvikram 		}
442940541d5dSvikram 
443040541d5dSvikram 		/*
443140541d5dSvikram 		 * Now fixup the entry number
443240541d5dSvikram 		 */
4433eac223ccSWilliam Kucharski 		if (lp->cmd != NULL &&
4434eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[TITLE_CMD]) == 0) {
443540541d5dSvikram 			lp->entryNum = ++entryNum;
443640541d5dSvikram 			/* fixup the bootadm header */
443740541d5dSvikram 			if (prev && prev->flags == BAM_COMMENT &&
4438ae115bc7Smrj 			    prev->arg &&
4439ae115bc7Smrj 			    strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) {
444040541d5dSvikram 				prev->entryNum = lp->entryNum;
444140541d5dSvikram 			}
444240541d5dSvikram 		} else {
444340541d5dSvikram 			lp->entryNum = entryNum;
444440541d5dSvikram 		}
444540541d5dSvikram 	}
444640541d5dSvikram 
444740541d5dSvikram 	/*
444840541d5dSvikram 	 * No default command in menu, simply return
444940541d5dSvikram 	 */
445040541d5dSvikram 	if (default_lp == NULL) {
445140541d5dSvikram 		return;
445240541d5dSvikram 	}
445340541d5dSvikram 
445440541d5dSvikram 	free(default_lp->arg);
445540541d5dSvikram 	free(default_lp->line);
445640541d5dSvikram 
445740541d5dSvikram 	if (default_entry == NULL) {
445840541d5dSvikram 		default_lp->arg = s_strdup("0");
445940541d5dSvikram 	} else {
446040541d5dSvikram 		(void) snprintf(buf, sizeof (buf), "%d",
446140541d5dSvikram 		    default_entry->entryNum);
446240541d5dSvikram 		default_lp->arg = s_strdup(buf);
446340541d5dSvikram 	}
446440541d5dSvikram 
446540541d5dSvikram 	/*
446640541d5dSvikram 	 * The following is required since only the line field gets
446740541d5dSvikram 	 * written back to menu.lst
446840541d5dSvikram 	 */
446940541d5dSvikram 	(void) snprintf(buf, sizeof (buf), "%s%s%s",
447040541d5dSvikram 	    menu_cmds[DEFAULT_CMD], menu_cmds[SEP_CMD], default_lp->arg);
447140541d5dSvikram 	default_lp->line = s_strdup(buf);
447240541d5dSvikram }
447340541d5dSvikram 
447440541d5dSvikram 
44757c478bd9Sstevel@tonic-gate static menu_t *
44767c478bd9Sstevel@tonic-gate menu_read(char *menu_path)
44777c478bd9Sstevel@tonic-gate {
44787c478bd9Sstevel@tonic-gate 	FILE *fp;
44797c478bd9Sstevel@tonic-gate 	char buf[BAM_MAXLINE], *cp;
44807c478bd9Sstevel@tonic-gate 	menu_t *mp;
44817c478bd9Sstevel@tonic-gate 	int line, entry, len, n;
44827c478bd9Sstevel@tonic-gate 
44837c478bd9Sstevel@tonic-gate 	mp = s_calloc(1, sizeof (menu_t));
44847c478bd9Sstevel@tonic-gate 
44857c478bd9Sstevel@tonic-gate 	fp = fopen(menu_path, "r");
44867c478bd9Sstevel@tonic-gate 	if (fp == NULL) { /* Let the caller handle this error */
448744da779fSWilliam Kucharski 		free(mp);
448844da779fSWilliam Kucharski 		return (NULL);
44897c478bd9Sstevel@tonic-gate 	}
44907c478bd9Sstevel@tonic-gate 
44917c478bd9Sstevel@tonic-gate 	/* Note: GRUB boot entry number starts with 0 */
44927c478bd9Sstevel@tonic-gate 	line = LINE_INIT;
44937c478bd9Sstevel@tonic-gate 	entry = ENTRY_INIT;
44947c478bd9Sstevel@tonic-gate 	cp = buf;
44957c478bd9Sstevel@tonic-gate 	len = sizeof (buf);
44967c478bd9Sstevel@tonic-gate 	while (s_fgets(cp, len, fp) != NULL) {
44977c478bd9Sstevel@tonic-gate 		n = strlen(cp);
44987c478bd9Sstevel@tonic-gate 		if (cp[n - 1] == '\\') {
44997c478bd9Sstevel@tonic-gate 			len -= n - 1;
45007c478bd9Sstevel@tonic-gate 			assert(len >= 2);
45017c478bd9Sstevel@tonic-gate 			cp += n - 1;
45027c478bd9Sstevel@tonic-gate 			continue;
45037c478bd9Sstevel@tonic-gate 		}
45047c478bd9Sstevel@tonic-gate 		line_parser(mp, buf, &line, &entry);
45057c478bd9Sstevel@tonic-gate 		cp = buf;
45067c478bd9Sstevel@tonic-gate 		len = sizeof (buf);
45077c478bd9Sstevel@tonic-gate 	}
45087c478bd9Sstevel@tonic-gate 
45097c478bd9Sstevel@tonic-gate 	if (fclose(fp) == EOF) {
45107c478bd9Sstevel@tonic-gate 		bam_error(CLOSE_FAIL, menu_path, strerror(errno));
45117c478bd9Sstevel@tonic-gate 	}
45127c478bd9Sstevel@tonic-gate 
45137c478bd9Sstevel@tonic-gate 	return (mp);
45147c478bd9Sstevel@tonic-gate }
45157c478bd9Sstevel@tonic-gate 
45167c478bd9Sstevel@tonic-gate static error_t
45177c478bd9Sstevel@tonic-gate selector(menu_t *mp, char *opt, int *entry, char **title)
45187c478bd9Sstevel@tonic-gate {
45197c478bd9Sstevel@tonic-gate 	char *eq;
45207c478bd9Sstevel@tonic-gate 	char *opt_dup;
45217c478bd9Sstevel@tonic-gate 	int entryNum;
45227c478bd9Sstevel@tonic-gate 
45237c478bd9Sstevel@tonic-gate 	assert(mp);
45247c478bd9Sstevel@tonic-gate 	assert(mp->start);
45257c478bd9Sstevel@tonic-gate 	assert(opt);
45267c478bd9Sstevel@tonic-gate 
45277c478bd9Sstevel@tonic-gate 	opt_dup = s_strdup(opt);
45287c478bd9Sstevel@tonic-gate 
45297c478bd9Sstevel@tonic-gate 	if (entry)
45307c478bd9Sstevel@tonic-gate 		*entry = ENTRY_INIT;
45317c478bd9Sstevel@tonic-gate 	if (title)
45327c478bd9Sstevel@tonic-gate 		*title = NULL;
45337c478bd9Sstevel@tonic-gate 
45347c478bd9Sstevel@tonic-gate 	eq = strchr(opt_dup, '=');
45357c478bd9Sstevel@tonic-gate 	if (eq == NULL) {
45367c478bd9Sstevel@tonic-gate 		bam_error(INVALID_OPT, opt);
45377c478bd9Sstevel@tonic-gate 		free(opt_dup);
45387c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
45397c478bd9Sstevel@tonic-gate 	}
45407c478bd9Sstevel@tonic-gate 
45417c478bd9Sstevel@tonic-gate 	*eq = '\0';
45427c478bd9Sstevel@tonic-gate 	if (entry && strcmp(opt_dup, OPT_ENTRY_NUM) == 0) {
45437c478bd9Sstevel@tonic-gate 		assert(mp->end);
45447c478bd9Sstevel@tonic-gate 		entryNum = s_strtol(eq + 1);
45457c478bd9Sstevel@tonic-gate 		if (entryNum < 0 || entryNum > mp->end->entryNum) {
45467c478bd9Sstevel@tonic-gate 			bam_error(INVALID_ENTRY, eq + 1);
45477c478bd9Sstevel@tonic-gate 			free(opt_dup);
45487c478bd9Sstevel@tonic-gate 			return (BAM_ERROR);
45497c478bd9Sstevel@tonic-gate 		}
45507c478bd9Sstevel@tonic-gate 		*entry = entryNum;
45517c478bd9Sstevel@tonic-gate 	} else if (title && strcmp(opt_dup, menu_cmds[TITLE_CMD]) == 0) {
45527c478bd9Sstevel@tonic-gate 		*title = opt + (eq - opt_dup) + 1;
45537c478bd9Sstevel@tonic-gate 	} else {
45547c478bd9Sstevel@tonic-gate 		bam_error(INVALID_OPT, opt);
45557c478bd9Sstevel@tonic-gate 		free(opt_dup);
45567c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
45577c478bd9Sstevel@tonic-gate 	}
45587c478bd9Sstevel@tonic-gate 
45597c478bd9Sstevel@tonic-gate 	free(opt_dup);
45607c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
45617c478bd9Sstevel@tonic-gate }
45627c478bd9Sstevel@tonic-gate 
45637c478bd9Sstevel@tonic-gate /*
45647c478bd9Sstevel@tonic-gate  * If invoked with no titles/entries (opt == NULL)
45657c478bd9Sstevel@tonic-gate  * only title lines in file are printed.
45667c478bd9Sstevel@tonic-gate  *
45677c478bd9Sstevel@tonic-gate  * If invoked with a title or entry #, all
45687c478bd9Sstevel@tonic-gate  * lines in *every* matching entry are listed
45697c478bd9Sstevel@tonic-gate  */
45707c478bd9Sstevel@tonic-gate static error_t
45717c478bd9Sstevel@tonic-gate list_entry(menu_t *mp, char *menu_path, char *opt)
45727c478bd9Sstevel@tonic-gate {
45737c478bd9Sstevel@tonic-gate 	line_t *lp;
45747c478bd9Sstevel@tonic-gate 	int entry = ENTRY_INIT;
45757c478bd9Sstevel@tonic-gate 	int found;
45767c478bd9Sstevel@tonic-gate 	char *title = NULL;
45777c478bd9Sstevel@tonic-gate 
45787c478bd9Sstevel@tonic-gate 	assert(mp);
45797c478bd9Sstevel@tonic-gate 	assert(menu_path);
45807c478bd9Sstevel@tonic-gate 
4581eb2bd662Svikram 	/* opt is optional */
4582eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, "list_entry", menu_path,
4583eb2bd662Svikram 	    opt ? opt : "<NULL>"));
4584eb2bd662Svikram 
45857c478bd9Sstevel@tonic-gate 	if (mp->start == NULL) {
45867c478bd9Sstevel@tonic-gate 		bam_error(NO_MENU, menu_path);
45877c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
45887c478bd9Sstevel@tonic-gate 	}
45897c478bd9Sstevel@tonic-gate 
45907c478bd9Sstevel@tonic-gate 	if (opt != NULL) {
45917c478bd9Sstevel@tonic-gate 		if (selector(mp, opt, &entry, &title) != BAM_SUCCESS) {
45927c478bd9Sstevel@tonic-gate 			return (BAM_ERROR);
45937c478bd9Sstevel@tonic-gate 		}
45947c478bd9Sstevel@tonic-gate 		assert((entry != ENTRY_INIT) ^ (title != NULL));
45957c478bd9Sstevel@tonic-gate 	} else {
45967c478bd9Sstevel@tonic-gate 		(void) read_globals(mp, menu_path, menu_cmds[DEFAULT_CMD], 0);
45977c478bd9Sstevel@tonic-gate 		(void) read_globals(mp, menu_path, menu_cmds[TIMEOUT_CMD], 0);
45987c478bd9Sstevel@tonic-gate 	}
45997c478bd9Sstevel@tonic-gate 
46007c478bd9Sstevel@tonic-gate 	found = 0;
46017c478bd9Sstevel@tonic-gate 	for (lp = mp->start; lp; lp = lp->next) {
46027c478bd9Sstevel@tonic-gate 		if (lp->flags == BAM_COMMENT || lp->flags == BAM_EMPTY)
46037c478bd9Sstevel@tonic-gate 			continue;
46047c478bd9Sstevel@tonic-gate 		if (opt == NULL && lp->flags == BAM_TITLE) {
46057c478bd9Sstevel@tonic-gate 			bam_print(PRINT_TITLE, lp->entryNum,
46067c478bd9Sstevel@tonic-gate 			    lp->arg);
46077c478bd9Sstevel@tonic-gate 			found = 1;
46087c478bd9Sstevel@tonic-gate 			continue;
46097c478bd9Sstevel@tonic-gate 		}
46107c478bd9Sstevel@tonic-gate 		if (entry != ENTRY_INIT && lp->entryNum == entry) {
46117c478bd9Sstevel@tonic-gate 			bam_print(PRINT, lp->line);
46127c478bd9Sstevel@tonic-gate 			found = 1;
46137c478bd9Sstevel@tonic-gate 			continue;
46147c478bd9Sstevel@tonic-gate 		}
46157c478bd9Sstevel@tonic-gate 
46167c478bd9Sstevel@tonic-gate 		/*
46177c478bd9Sstevel@tonic-gate 		 * We set the entry value here so that all lines
46187c478bd9Sstevel@tonic-gate 		 * in entry get printed. If we subsequently match
46197c478bd9Sstevel@tonic-gate 		 * title in other entries, all lines in those
46207c478bd9Sstevel@tonic-gate 		 * entries get printed as well.
46217c478bd9Sstevel@tonic-gate 		 */
46227c478bd9Sstevel@tonic-gate 		if (title && lp->flags == BAM_TITLE && lp->arg &&
46237c478bd9Sstevel@tonic-gate 		    strncmp(title, lp->arg, strlen(title)) == 0) {
46247c478bd9Sstevel@tonic-gate 			bam_print(PRINT, lp->line);
46257c478bd9Sstevel@tonic-gate 			entry = lp->entryNum;
46267c478bd9Sstevel@tonic-gate 			found = 1;
46277c478bd9Sstevel@tonic-gate 			continue;
46287c478bd9Sstevel@tonic-gate 		}
46297c478bd9Sstevel@tonic-gate 	}
46307c478bd9Sstevel@tonic-gate 
46317c478bd9Sstevel@tonic-gate 	if (!found) {
46327c478bd9Sstevel@tonic-gate 		bam_error(NO_MATCH_ENTRY);
46337c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
46347c478bd9Sstevel@tonic-gate 	}
46357c478bd9Sstevel@tonic-gate 
46367c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
46377c478bd9Sstevel@tonic-gate }
46387c478bd9Sstevel@tonic-gate 
4639843e1988Sjohnlev int
46407c478bd9Sstevel@tonic-gate add_boot_entry(menu_t *mp,
46417c478bd9Sstevel@tonic-gate 	char *title,
4642eb2bd662Svikram 	char *findroot,
46437c478bd9Sstevel@tonic-gate 	char *kernel,
4644843e1988Sjohnlev 	char *mod_kernel,
464544da779fSWilliam Kucharski 	char *module,
464644da779fSWilliam Kucharski 	char *bootfs)
46477c478bd9Sstevel@tonic-gate {
4648eb2bd662Svikram 	int		lineNum;
4649eb2bd662Svikram 	int		entryNum;
46507c478bd9Sstevel@tonic-gate 	char		linebuf[BAM_MAXLINE];
4651eb2bd662Svikram 	menu_cmd_t	k_cmd;
4652eb2bd662Svikram 	menu_cmd_t	m_cmd;
4653eb2bd662Svikram 	const char	*fcn = "add_boot_entry()";
46547c478bd9Sstevel@tonic-gate 
46557c478bd9Sstevel@tonic-gate 	assert(mp);
46567c478bd9Sstevel@tonic-gate 
4657eb2bd662Svikram 	INJECT_ERROR1("ADD_BOOT_ENTRY_FINDROOT_NULL", findroot = NULL);
4658eb2bd662Svikram 	if (findroot == NULL) {
4659eb2bd662Svikram 		bam_error(NULL_FINDROOT);
4660eb2bd662Svikram 		return (BAM_ERROR);
4661eb2bd662Svikram 	}
4662eb2bd662Svikram 
46637c478bd9Sstevel@tonic-gate 	if (title == NULL) {
4664ee3b8144Sszhou 		title = "Solaris";	/* default to Solaris */
46657c478bd9Sstevel@tonic-gate 	}
46667c478bd9Sstevel@tonic-gate 	if (kernel == NULL) {
46677c478bd9Sstevel@tonic-gate 		bam_error(SUBOPT_MISS, menu_cmds[KERNEL_CMD]);
46687c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
46697c478bd9Sstevel@tonic-gate 	}
46707c478bd9Sstevel@tonic-gate 	if (module == NULL) {
4671ae115bc7Smrj 		if (bam_direct != BAM_DIRECT_DBOOT) {
46727c478bd9Sstevel@tonic-gate 			bam_error(SUBOPT_MISS, menu_cmds[MODULE_CMD]);
46737c478bd9Sstevel@tonic-gate 			return (BAM_ERROR);
46747c478bd9Sstevel@tonic-gate 		}
46757c478bd9Sstevel@tonic-gate 
4676ae115bc7Smrj 		/* Figure the commands out from the kernel line */
4677ae115bc7Smrj 		if (strstr(kernel, "$ISADIR") != NULL) {
4678ae115bc7Smrj 			module = DIRECT_BOOT_ARCHIVE;
4679ae115bc7Smrj 			k_cmd = KERNEL_DOLLAR_CMD;
4680ae115bc7Smrj 			m_cmd = MODULE_DOLLAR_CMD;
4681ae115bc7Smrj 		} else if (strstr(kernel, "amd64") != NULL) {
4682ae115bc7Smrj 			module = DIRECT_BOOT_ARCHIVE_64;
4683ae115bc7Smrj 			k_cmd = KERNEL_CMD;
4684ae115bc7Smrj 			m_cmd = MODULE_CMD;
4685ae115bc7Smrj 		} else {
4686ae115bc7Smrj 			module = DIRECT_BOOT_ARCHIVE_32;
4687ae115bc7Smrj 			k_cmd = KERNEL_CMD;
4688ae115bc7Smrj 			m_cmd = MODULE_CMD;
4689ae115bc7Smrj 		}
4690ae115bc7Smrj 	} else if ((bam_direct == BAM_DIRECT_DBOOT) &&
4691ae115bc7Smrj 	    (strstr(kernel, "$ISADIR") != NULL)) {
4692ae115bc7Smrj 		/*
4693ae115bc7Smrj 		 * If it's a non-failsafe dboot kernel, use the "kernel$"
4694ae115bc7Smrj 		 * command.  Otherwise, use "kernel".
4695ae115bc7Smrj 		 */
4696ae115bc7Smrj 		k_cmd = KERNEL_DOLLAR_CMD;
4697ae115bc7Smrj 		m_cmd = MODULE_DOLLAR_CMD;
4698ae115bc7Smrj 	} else {
4699ae115bc7Smrj 		k_cmd = KERNEL_CMD;
4700ae115bc7Smrj 		m_cmd = MODULE_CMD;
4701ae115bc7Smrj 	}
4702ae115bc7Smrj 
47037c478bd9Sstevel@tonic-gate 	if (mp->start) {
47047c478bd9Sstevel@tonic-gate 		lineNum = mp->end->lineNum;
47057c478bd9Sstevel@tonic-gate 		entryNum = mp->end->entryNum;
47067c478bd9Sstevel@tonic-gate 	} else {
47077c478bd9Sstevel@tonic-gate 		lineNum = LINE_INIT;
47087c478bd9Sstevel@tonic-gate 		entryNum = ENTRY_INIT;
47097c478bd9Sstevel@tonic-gate 	}
47107c478bd9Sstevel@tonic-gate 
47117c478bd9Sstevel@tonic-gate 	/*
47127c478bd9Sstevel@tonic-gate 	 * No separator for comment (HDR/FTR) commands
47137c478bd9Sstevel@tonic-gate 	 * The syntax for comments is #<comment>
47147c478bd9Sstevel@tonic-gate 	 */
47157c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s",
4716ae115bc7Smrj 	    menu_cmds[COMMENT_CMD], BAM_BOOTADM_HDR);
47178c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
47187c478bd9Sstevel@tonic-gate 
47197c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
47207c478bd9Sstevel@tonic-gate 	    menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title);
47218c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
47227c478bd9Sstevel@tonic-gate 
47237c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4724eb2bd662Svikram 	    menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot);
47258c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
4726eb2bd662Svikram 	BAM_DPRINTF((D_ADD_FINDROOT_NUM, fcn, lineNum, entryNum));
47277c478bd9Sstevel@tonic-gate 
472844da779fSWilliam Kucharski 	if (bootfs != NULL) {
472944da779fSWilliam Kucharski 		(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
473044da779fSWilliam Kucharski 		    menu_cmds[BOOTFS_CMD], menu_cmds[SEP_CMD], bootfs);
473144da779fSWilliam Kucharski 		line_parser(mp, linebuf, &lineNum, &entryNum);
473244da779fSWilliam Kucharski 	}
473344da779fSWilliam Kucharski 
47347c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4735ae115bc7Smrj 	    menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel);
47368c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
47377c478bd9Sstevel@tonic-gate 
4738843e1988Sjohnlev 	if (mod_kernel != NULL) {
4739843e1988Sjohnlev 		(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4740843e1988Sjohnlev 		    menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel);
4741843e1988Sjohnlev 		line_parser(mp, linebuf, &lineNum, &entryNum);
4742843e1988Sjohnlev 	}
4743843e1988Sjohnlev 
47447c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
4745ae115bc7Smrj 	    menu_cmds[m_cmd], menu_cmds[SEP_CMD], module);
47468c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
47477c478bd9Sstevel@tonic-gate 
47487c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s",
4749ae115bc7Smrj 	    menu_cmds[COMMENT_CMD], BAM_BOOTADM_FTR);
47508c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
47517c478bd9Sstevel@tonic-gate 
47527c478bd9Sstevel@tonic-gate 	return (entryNum);
47537c478bd9Sstevel@tonic-gate }
47547c478bd9Sstevel@tonic-gate 
475544da779fSWilliam Kucharski error_t
475644da779fSWilliam Kucharski delete_boot_entry(menu_t *mp, int entryNum, int quiet)
47577c478bd9Sstevel@tonic-gate {
4758eb2bd662Svikram 	line_t		*lp;
4759eb2bd662Svikram 	line_t		*freed;
4760eb2bd662Svikram 	entry_t		*ent;
4761eb2bd662Svikram 	entry_t		*tmp;
476244da779fSWilliam Kucharski 	int		deleted = 0;
476344da779fSWilliam Kucharski 	const char	*fcn = "delete_boot_entry()";
47647c478bd9Sstevel@tonic-gate 
47657c478bd9Sstevel@tonic-gate 	assert(entryNum != ENTRY_INIT);
47667c478bd9Sstevel@tonic-gate 
4767eb2bd662Svikram 	tmp = NULL;
4768eb2bd662Svikram 
47698c1b6884Sszhou 	ent = mp->entries;
47708c1b6884Sszhou 	while (ent) {
47718c1b6884Sszhou 		lp = ent->start;
4772772d6a58SWilliam Kucharski 
4773772d6a58SWilliam Kucharski 		/*
4774772d6a58SWilliam Kucharski 		 * Check entry number and make sure it's a modifiable entry.
4775772d6a58SWilliam Kucharski 		 *
4776772d6a58SWilliam Kucharski 		 * Guidelines:
4777772d6a58SWilliam Kucharski 		 *	+ We can modify a bootadm-created entry
4778772d6a58SWilliam Kucharski 		 *	+ We can modify a libbe-created entry
4779772d6a58SWilliam Kucharski 		 */
4780772d6a58SWilliam Kucharski 		if ((lp->flags != BAM_COMMENT &&
4781772d6a58SWilliam Kucharski 		    (((ent->flags & BAM_ENTRY_LIBBE) == 0) &&
4782772d6a58SWilliam Kucharski 		    strcmp(lp->arg, BAM_BOOTADM_HDR) != 0)) ||
47838c1b6884Sszhou 		    (entryNum != ALL_ENTRIES && lp->entryNum != entryNum)) {
47848c1b6884Sszhou 			ent = ent->next;
47857c478bd9Sstevel@tonic-gate 			continue;
47867c478bd9Sstevel@tonic-gate 		}
47877c478bd9Sstevel@tonic-gate 
47888c1b6884Sszhou 		/* free the entry content */
47898c1b6884Sszhou 		do {
47908c1b6884Sszhou 			freed = lp;
47918c1b6884Sszhou 			lp = lp->next;	/* prev stays the same */
4792eb2bd662Svikram 			BAM_DPRINTF((D_FREEING_LINE, fcn, freed->lineNum));
47938c1b6884Sszhou 			unlink_line(mp, freed);
47948c1b6884Sszhou 			line_free(freed);
47958c1b6884Sszhou 		} while (freed != ent->end);
47967c478bd9Sstevel@tonic-gate 
47978c1b6884Sszhou 		/* free the entry_t structure */
4798eb2bd662Svikram 		assert(tmp == NULL);
47998c1b6884Sszhou 		tmp = ent;
48008c1b6884Sszhou 		ent = ent->next;
48018c1b6884Sszhou 		if (tmp->prev)
48028c1b6884Sszhou 			tmp->prev->next = ent;
48037c478bd9Sstevel@tonic-gate 		else
48048c1b6884Sszhou 			mp->entries = ent;
48058c1b6884Sszhou 		if (ent)
48068c1b6884Sszhou 			ent->prev = tmp->prev;
4807eb2bd662Svikram 		BAM_DPRINTF((D_FREEING_ENTRY, fcn, tmp->entryNum));
4808eb2bd662Svikram 		free(tmp);
4809eb2bd662Svikram 		tmp = NULL;
48107c478bd9Sstevel@tonic-gate 		deleted = 1;
48117c478bd9Sstevel@tonic-gate 	}
48127c478bd9Sstevel@tonic-gate 
4813eb2bd662Svikram 	assert(tmp == NULL);
4814eb2bd662Svikram 
48157c478bd9Sstevel@tonic-gate 	if (!deleted && entryNum != ALL_ENTRIES) {
481644da779fSWilliam Kucharski 		if (quiet == DBE_PRINTERR)
48177c478bd9Sstevel@tonic-gate 			bam_error(NO_BOOTADM_MATCH);
48187c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
48197c478bd9Sstevel@tonic-gate 	}
48207c478bd9Sstevel@tonic-gate 
482140541d5dSvikram 	/*
482240541d5dSvikram 	 * Now that we have deleted an entry, update
482340541d5dSvikram 	 * the entry numbering and the default cmd.
482440541d5dSvikram 	 */
482540541d5dSvikram 	update_numbering(mp);
482640541d5dSvikram 
48277c478bd9Sstevel@tonic-gate 	return (BAM_SUCCESS);
48287c478bd9Sstevel@tonic-gate }
48297c478bd9Sstevel@tonic-gate 
48307c478bd9Sstevel@tonic-gate static error_t
4831eb2bd662Svikram delete_all_entries(menu_t *mp, char *dummy, char *opt)
48327c478bd9Sstevel@tonic-gate {
48337c478bd9Sstevel@tonic-gate 	assert(mp);
4834eb2bd662Svikram 	assert(dummy == NULL);
48357c478bd9Sstevel@tonic-gate 	assert(opt == NULL);
48367c478bd9Sstevel@tonic-gate 
4837eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY0, "delete_all_entries"));
4838eb2bd662Svikram 
48397c478bd9Sstevel@tonic-gate 	if (mp->start == NULL) {
4840eb2bd662Svikram 		bam_print(EMPTY_MENU);
48417c478bd9Sstevel@tonic-gate 		return (BAM_SUCCESS);
48427c478bd9Sstevel@tonic-gate 	}
48437c478bd9Sstevel@tonic-gate 
484444da779fSWilliam Kucharski 	if (delete_boot_entry(mp, ALL_ENTRIES, DBE_PRINTERR) != BAM_SUCCESS) {
48457c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
48467c478bd9Sstevel@tonic-gate 	}
48477c478bd9Sstevel@tonic-gate 
48487c478bd9Sstevel@tonic-gate 	return (BAM_WRITE);
48497c478bd9Sstevel@tonic-gate }
48507c478bd9Sstevel@tonic-gate 
48517c478bd9Sstevel@tonic-gate static FILE *
4852eb2bd662Svikram create_diskmap(char *osroot)
48537c478bd9Sstevel@tonic-gate {
48547c478bd9Sstevel@tonic-gate 	FILE *fp;
4855cedc7e57SEnrico Perla - Sun Microsystems 	char cmd[PATH_MAX + 16];
4856cedc7e57SEnrico Perla - Sun Microsystems 	char path[PATH_MAX];
4857eb2bd662Svikram 	const char *fcn = "create_diskmap()";
48587c478bd9Sstevel@tonic-gate 
48597c478bd9Sstevel@tonic-gate 	/* make sure we have a map file */
48607c478bd9Sstevel@tonic-gate 	fp = fopen(GRUBDISK_MAP, "r");
48617c478bd9Sstevel@tonic-gate 	if (fp == NULL) {
4862cedc7e57SEnrico Perla - Sun Microsystems 		int	ret;
4863cedc7e57SEnrico Perla - Sun Microsystems 
4864cedc7e57SEnrico Perla - Sun Microsystems 		ret = snprintf(path, sizeof (path), "%s/%s", osroot,
4865cedc7e57SEnrico Perla - Sun Microsystems 		    CREATE_DISKMAP);
4866cedc7e57SEnrico Perla - Sun Microsystems 		if (ret >= sizeof (path)) {
4867cedc7e57SEnrico Perla - Sun Microsystems 			bam_error(PATH_TOO_LONG, osroot);
4868cedc7e57SEnrico Perla - Sun Microsystems 			return (NULL);
4869cedc7e57SEnrico Perla - Sun Microsystems 		}
4870cedc7e57SEnrico Perla - Sun Microsystems 		if (is_safe_exec(path) == BAM_ERROR)
4871cedc7e57SEnrico Perla - Sun Microsystems 			return (NULL);
4872cedc7e57SEnrico Perla - Sun Microsystems 
48737c478bd9Sstevel@tonic-gate 		(void) snprintf(cmd, sizeof (cmd),
4874eb2bd662Svikram 		    "%s/%s > /dev/null", osroot, CREATE_DISKMAP);
4875eb2bd662Svikram 		if (exec_cmd(cmd, NULL) != 0)
4876eb2bd662Svikram 			return (NULL);
48777c478bd9Sstevel@tonic-gate 		fp = fopen(GRUBDISK_MAP, "r");
4878eb2bd662Svikram 		INJECT_ERROR1("DISKMAP_CREATE_FAIL", fp = NULL);
4879eb2bd662Svikram 		if (fp) {
4880eb2bd662Svikram 			BAM_DPRINTF((D_CREATED_DISKMAP, fcn, GRUBDISK_MAP));
4881eb2bd662Svikram 		} else {
4882eb2bd662Svikram 			BAM_DPRINTF((D_CREATE_DISKMAP_FAIL, fcn, GRUBDISK_MAP));
4883eb2bd662Svikram 		}
48847c478bd9Sstevel@tonic-gate 	}
48857c478bd9Sstevel@tonic-gate 	return (fp);
48867c478bd9Sstevel@tonic-gate }
48877c478bd9Sstevel@tonic-gate 
48887c478bd9Sstevel@tonic-gate #define	SECTOR_SIZE	512
48897c478bd9Sstevel@tonic-gate 
48907c478bd9Sstevel@tonic-gate static int
48917c478bd9Sstevel@tonic-gate get_partition(char *device)
48927c478bd9Sstevel@tonic-gate {
48937c478bd9Sstevel@tonic-gate 	int i, fd, is_pcfs, partno = -1;
48947c478bd9Sstevel@tonic-gate 	struct mboot *mboot;
48957c478bd9Sstevel@tonic-gate 	char boot_sect[SECTOR_SIZE];
48967c478bd9Sstevel@tonic-gate 	char *wholedisk, *slice;
4897e998e519SSheshadri Vasudevan #ifdef i386
4898e998e519SSheshadri Vasudevan 	ext_part_t *epp;
4899e998e519SSheshadri Vasudevan 	uint32_t secnum, numsec;
490028074f82SSheshadri Vasudevan 	int rval, pno, ext_partno = -1;
4901e998e519SSheshadri Vasudevan #endif
49027c478bd9Sstevel@tonic-gate 
49037c478bd9Sstevel@tonic-gate 	/* form whole disk (p0) */
49047c478bd9Sstevel@tonic-gate 	slice = device + strlen(device) - 2;
49057c478bd9Sstevel@tonic-gate 	is_pcfs = (*slice != 's');
49067c478bd9Sstevel@tonic-gate 	if (!is_pcfs)
49077c478bd9Sstevel@tonic-gate 		*slice = '\0';
49087c478bd9Sstevel@tonic-gate 	wholedisk = s_calloc(1, strlen(device) + 3);
49097c478bd9Sstevel@tonic-gate 	(void) snprintf(wholedisk, strlen(device) + 3, "%sp0", device);
49107c478bd9Sstevel@tonic-gate 	if (!is_pcfs)
49117c478bd9Sstevel@tonic-gate 		*slice = 's';
49127c478bd9Sstevel@tonic-gate 
49137c478bd9Sstevel@tonic-gate 	/* read boot sector */
49147c478bd9Sstevel@tonic-gate 	fd = open(wholedisk, O_RDONLY);
49157c478bd9Sstevel@tonic-gate 	if (fd == -1 || read(fd, boot_sect, SECTOR_SIZE) != SECTOR_SIZE) {
49167c478bd9Sstevel@tonic-gate 		return (partno);
49177c478bd9Sstevel@tonic-gate 	}
49187c478bd9Sstevel@tonic-gate 	(void) close(fd);
49197c478bd9Sstevel@tonic-gate 
4920e998e519SSheshadri Vasudevan #ifdef i386
4921e998e519SSheshadri Vasudevan 	/* Read/Initialize extended partition information */
4922e998e519SSheshadri Vasudevan 	if ((rval = libfdisk_init(&epp, wholedisk, NULL, FDISK_READ_DISK))
4923e998e519SSheshadri Vasudevan 	    != FDISK_SUCCESS) {
4924e998e519SSheshadri Vasudevan 		switch (rval) {
4925e998e519SSheshadri Vasudevan 			/*
4926e998e519SSheshadri Vasudevan 			 * FDISK_EBADLOGDRIVE and FDISK_ENOLOGDRIVE can
4927e998e519SSheshadri Vasudevan 			 * be considered as soft errors and hence
4928e998e519SSheshadri Vasudevan 			 * we do not return
4929e998e519SSheshadri Vasudevan 			 */
4930e998e519SSheshadri Vasudevan 			case FDISK_EBADLOGDRIVE:
4931e998e519SSheshadri Vasudevan 				break;
4932e998e519SSheshadri Vasudevan 			case FDISK_ENOLOGDRIVE:
4933e998e519SSheshadri Vasudevan 				break;
49346cb5747bSSharath M Srinivasan 			case FDISK_EBADMAGIC:
49356cb5747bSSharath M Srinivasan 				/*FALLTHROUGH*/
4936e998e519SSheshadri Vasudevan 			default:
4937e998e519SSheshadri Vasudevan 				free(wholedisk);
49386cb5747bSSharath M Srinivasan 				libfdisk_fini(&epp);
4939e998e519SSheshadri Vasudevan 				return (partno);
4940e998e519SSheshadri Vasudevan 				break;
4941e998e519SSheshadri Vasudevan 		}
4942e998e519SSheshadri Vasudevan 	}
4943e998e519SSheshadri Vasudevan #endif
4944e998e519SSheshadri Vasudevan 	free(wholedisk);
4945e998e519SSheshadri Vasudevan 
49467c478bd9Sstevel@tonic-gate 	/* parse fdisk table */
49477c478bd9Sstevel@tonic-gate 	mboot = (struct mboot *)((void *)boot_sect);
49487c478bd9Sstevel@tonic-gate 	for (i = 0; i < FD_NUMPART; i++) {
49497c478bd9Sstevel@tonic-gate 		struct ipart *part =
49507c478bd9Sstevel@tonic-gate 		    (struct ipart *)(uintptr_t)mboot->parts + i;
49517c478bd9Sstevel@tonic-gate 		if (is_pcfs) {	/* looking for solaris boot part */
49527c478bd9Sstevel@tonic-gate 			if (part->systid == 0xbe) {
49537c478bd9Sstevel@tonic-gate 				partno = i;
49547c478bd9Sstevel@tonic-gate 				break;
49557c478bd9Sstevel@tonic-gate 			}
49567c478bd9Sstevel@tonic-gate 		} else {	/* look for solaris partition, old and new */
4957e998e519SSheshadri Vasudevan #ifdef i386
4958e998e519SSheshadri Vasudevan 			if ((part->systid == SUNIXOS &&
4959e998e519SSheshadri Vasudevan 			    (fdisk_is_linux_swap(epp, part->relsect,
4960e998e519SSheshadri Vasudevan 			    NULL) != 0)) || part->systid == SUNIXOS2) {
4961e998e519SSheshadri Vasudevan #else
49627c478bd9Sstevel@tonic-gate 			if (part->systid == SUNIXOS ||
49637c478bd9Sstevel@tonic-gate 			    part->systid == SUNIXOS2) {
4964e998e519SSheshadri Vasudevan #endif
49657c478bd9Sstevel@tonic-gate 				partno = i;
49667c478bd9Sstevel@tonic-gate 				break;
49677c478bd9Sstevel@tonic-gate 			}
496828074f82SSheshadri Vasudevan 
496928074f82SSheshadri Vasudevan #ifdef i386
497028074f82SSheshadri Vasudevan 			if (fdisk_is_dos_extended(part->systid))
497128074f82SSheshadri Vasudevan 				ext_partno = i;
497228074f82SSheshadri Vasudevan #endif
49737c478bd9Sstevel@tonic-gate 		}
49747c478bd9Sstevel@tonic-gate 	}
4975e998e519SSheshadri Vasudevan #ifdef i386
497628074f82SSheshadri Vasudevan 	/* If no primary solaris partition, check extended partition */
497728074f82SSheshadri Vasudevan 	if ((partno == -1) && (ext_partno != -1)) {
497828074f82SSheshadri Vasudevan 		rval = fdisk_get_solaris_part(epp, &pno, &secnum, &numsec);
497928074f82SSheshadri Vasudevan 		if (rval == FDISK_SUCCESS) {
498028074f82SSheshadri Vasudevan 			partno = pno - 1;
498128074f82SSheshadri Vasudevan 		}
498228074f82SSheshadri Vasudevan 	}
4983e998e519SSheshadri Vasudevan 	libfdisk_fini(&epp);
4984e998e519SSheshadri Vasudevan #endif
49857c478bd9Sstevel@tonic-gate 	return (partno);
49867c478bd9Sstevel@tonic-gate }
49877c478bd9Sstevel@tonic-gate 
4988eb2bd662Svikram char *
4989eb2bd662Svikram get_grubroot(char *osroot, char *osdev, char *menu_root)
49907c478bd9Sstevel@tonic-gate {
4991eb2bd662Svikram 	char		*grubroot;	/* (hd#,#,#) */
49927c478bd9Sstevel@tonic-gate 	char		*slice;
49937c478bd9Sstevel@tonic-gate 	char		*grubhd;
49947c478bd9Sstevel@tonic-gate 	int		fdiskpart;
49957c478bd9Sstevel@tonic-gate 	int		found = 0;
4996eb2bd662Svikram 	char		*devname;
4997eb2bd662Svikram 	char		*ctdname = strstr(osdev, "dsk/");
49987c478bd9Sstevel@tonic-gate 	char		linebuf[PATH_MAX];
4999eb2bd662Svikram 	FILE		*fp;
50007c478bd9Sstevel@tonic-gate 
5001eb2bd662Svikram 	INJECT_ERROR1("GRUBROOT_INVALID_OSDEV", ctdname = NULL);
5002eb2bd662Svikram 	if (ctdname == NULL) {
5003eb2bd662Svikram 		bam_error(INVALID_DEV_DSK, osdev);
50047c478bd9Sstevel@tonic-gate 		return (NULL);
5005eb2bd662Svikram 	}
5006eb2bd662Svikram 
5007eb2bd662Svikram 	if (menu_root && !menu_on_bootdisk(osroot, menu_root)) {
5008eb2bd662Svikram 		/* menu bears no resemblance to our reality */
500937eb779cSVikram Hegde 		bam_error(CANNOT_GRUBROOT_BOOTDISK, osdev);
5010eb2bd662Svikram 		return (NULL);
5011eb2bd662Svikram 	}
50127c478bd9Sstevel@tonic-gate 
50137c478bd9Sstevel@tonic-gate 	ctdname += strlen("dsk/");
50147c478bd9Sstevel@tonic-gate 	slice = strrchr(ctdname, 's');
50157c478bd9Sstevel@tonic-gate 	if (slice)
50167c478bd9Sstevel@tonic-gate 		*slice = '\0';
50177c478bd9Sstevel@tonic-gate 
5018eb2bd662Svikram 	fp = create_diskmap(osroot);
5019eb2bd662Svikram 	if (fp == NULL) {
5020eb2bd662Svikram 		bam_error(DISKMAP_FAIL, osroot);
5021eb2bd662Svikram 		return (NULL);
5022eb2bd662Svikram 	}
5023eb2bd662Svikram 
50247c478bd9Sstevel@tonic-gate 	rewind(fp);
50257c478bd9Sstevel@tonic-gate 	while (s_fgets(linebuf, sizeof (linebuf), fp) != NULL) {
50267c478bd9Sstevel@tonic-gate 		grubhd = strtok(linebuf, " \t\n");
50277c478bd9Sstevel@tonic-gate 		if (grubhd)
50287c478bd9Sstevel@tonic-gate 			devname = strtok(NULL, " \t\n");
50297c478bd9Sstevel@tonic-gate 		else
50307c478bd9Sstevel@tonic-gate 			devname = NULL;
50317c478bd9Sstevel@tonic-gate 		if (devname && strcmp(devname, ctdname) == 0) {
50327c478bd9Sstevel@tonic-gate 			found = 1;
50337c478bd9Sstevel@tonic-gate 			break;
50347c478bd9Sstevel@tonic-gate 		}
50357c478bd9Sstevel@tonic-gate 	}
50367c478bd9Sstevel@tonic-gate 
50377c478bd9Sstevel@tonic-gate 	if (slice)
50387c478bd9Sstevel@tonic-gate 		*slice = 's';
50397c478bd9Sstevel@tonic-gate 
5040eb2bd662Svikram 	(void) fclose(fp);
5041eb2bd662Svikram 	fp = NULL;
5042eb2bd662Svikram 
5043eb2bd662Svikram 	INJECT_ERROR1("GRUBROOT_BIOSDEV_FAIL", found = 0);
50447c478bd9Sstevel@tonic-gate 	if (found == 0) {
504537eb779cSVikram Hegde 		bam_error(BIOSDEV_SKIP, osdev);
5046eb2bd662Svikram 		return (NULL);
50477c478bd9Sstevel@tonic-gate 	}
50487c478bd9Sstevel@tonic-gate 
5049eb2bd662Svikram 	fdiskpart = get_partition(osdev);
5050eb2bd662Svikram 	INJECT_ERROR1("GRUBROOT_FDISK_FAIL", fdiskpart = -1);
5051eb2bd662Svikram 	if (fdiskpart == -1) {
5052eb2bd662Svikram 		bam_error(FDISKPART_FAIL, osdev);
50537c478bd9Sstevel@tonic-gate 		return (NULL);
5054eb2bd662Svikram 	}
50557c478bd9Sstevel@tonic-gate 
5056eb2bd662Svikram 	grubroot = s_calloc(1, 10);
50577c478bd9Sstevel@tonic-gate 	if (slice) {
5058eb2bd662Svikram 		(void) snprintf(grubroot, 10, "(hd%s,%d,%c)",
50597c478bd9Sstevel@tonic-gate 		    grubhd, fdiskpart, slice[1] + 'a' - '0');
50607c478bd9Sstevel@tonic-gate 	} else
5061eb2bd662Svikram 		(void) snprintf(grubroot, 10, "(hd%s,%d)",
50627c478bd9Sstevel@tonic-gate 		    grubhd, fdiskpart);
50637c478bd9Sstevel@tonic-gate 
5064eb2bd662Svikram 	assert(fp == NULL);
5065eb2bd662Svikram 	assert(strncmp(grubroot, "(hd", strlen("(hd")) == 0);
5066eb2bd662Svikram 	return (grubroot);
5067eb2bd662Svikram }
5068eb2bd662Svikram 
5069eb2bd662Svikram static char *
5070eb2bd662Svikram find_primary_common(char *mntpt, char *fstype)
5071eb2bd662Svikram {
5072eb2bd662Svikram 	char		signdir[PATH_MAX];
5073eb2bd662Svikram 	char		tmpsign[MAXNAMELEN + 1];
5074eb2bd662Svikram 	char		*lu;
5075eb2bd662Svikram 	char		*ufs;
5076eb2bd662Svikram 	char		*zfs;
5077eb2bd662Svikram 	DIR		*dirp = NULL;
5078eb2bd662Svikram 	struct dirent	*entp;
5079eb2bd662Svikram 	struct stat	sb;
5080eb2bd662Svikram 	const char	*fcn = "find_primary_common()";
5081eb2bd662Svikram 
5082eb2bd662Svikram 	(void) snprintf(signdir, sizeof (signdir), "%s/%s",
5083eb2bd662Svikram 	    mntpt, GRUBSIGN_DIR);
5084eb2bd662Svikram 
5085eb2bd662Svikram 	if (stat(signdir, &sb) == -1) {
5086eb2bd662Svikram 		BAM_DPRINTF((D_NO_SIGNDIR, fcn, signdir));
5087eb2bd662Svikram 		return (NULL);
5088eb2bd662Svikram 	}
5089eb2bd662Svikram 
5090eb2bd662Svikram 	dirp = opendir(signdir);
5091eb2bd662Svikram 	INJECT_ERROR1("SIGNDIR_OPENDIR_FAIL", dirp = NULL);
5092eb2bd662Svikram 	if (dirp == NULL) {
5093eb2bd662Svikram 		bam_error(OPENDIR_FAILED, signdir, strerror(errno));
5094eb2bd662Svikram 		return (NULL);
5095eb2bd662Svikram 	}
5096eb2bd662Svikram 
5097eb2bd662Svikram 	ufs = zfs = lu = NULL;
5098eb2bd662Svikram 
5099eb2bd662Svikram 	while (entp = readdir(dirp)) {
5100eb2bd662Svikram 		if (strcmp(entp->d_name, ".") == 0 ||
5101eb2bd662Svikram 		    strcmp(entp->d_name, "..") == 0)
5102eb2bd662Svikram 			continue;
5103eb2bd662Svikram 
5104eb2bd662Svikram 		(void) snprintf(tmpsign, sizeof (tmpsign), "%s", entp->d_name);
5105eb2bd662Svikram 
5106eb2bd662Svikram 		if (lu == NULL &&
5107eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_LU_PREFIX,
5108eb2bd662Svikram 		    strlen(GRUBSIGN_LU_PREFIX)) == 0) {
5109eb2bd662Svikram 			lu = s_strdup(tmpsign);
5110eb2bd662Svikram 		}
5111eb2bd662Svikram 
5112eb2bd662Svikram 		if (ufs == NULL &&
5113eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_UFS_PREFIX,
5114eb2bd662Svikram 		    strlen(GRUBSIGN_UFS_PREFIX)) == 0) {
5115eb2bd662Svikram 			ufs = s_strdup(tmpsign);
5116eb2bd662Svikram 		}
5117eb2bd662Svikram 
5118eb2bd662Svikram 		if (zfs == NULL &&
5119eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX,
5120eb2bd662Svikram 		    strlen(GRUBSIGN_ZFS_PREFIX)) == 0) {
5121eb2bd662Svikram 			zfs = s_strdup(tmpsign);
5122eb2bd662Svikram 		}
5123eb2bd662Svikram 	}
5124eb2bd662Svikram 
5125eb2bd662Svikram 	BAM_DPRINTF((D_EXIST_PRIMARY_SIGNS, fcn,
5126eb2bd662Svikram 	    zfs ? zfs : "NULL",
5127eb2bd662Svikram 	    ufs ? ufs : "NULL",
5128eb2bd662Svikram 	    lu ? lu : "NULL"));
5129eb2bd662Svikram 
5130eb2bd662Svikram 	if (dirp) {
5131eb2bd662Svikram 		(void) closedir(dirp);
5132eb2bd662Svikram 		dirp = NULL;
5133eb2bd662Svikram 	}
5134eb2bd662Svikram 
5135eb2bd662Svikram 	if (strcmp(fstype, "ufs") == 0 && zfs) {
5136eb2bd662Svikram 		bam_error(SIGN_FSTYPE_MISMATCH, zfs, "ufs");
5137eb2bd662Svikram 		free(zfs);
5138eb2bd662Svikram 		zfs = NULL;
5139eb2bd662Svikram 	} else if (strcmp(fstype, "zfs") == 0 && ufs) {
5140eb2bd662Svikram 		bam_error(SIGN_FSTYPE_MISMATCH, ufs, "zfs");
5141eb2bd662Svikram 		free(ufs);
5142eb2bd662Svikram 		ufs = NULL;
5143eb2bd662Svikram 	}
5144eb2bd662Svikram 
5145eb2bd662Svikram 	assert(dirp == NULL);
5146eb2bd662Svikram 
5147eb2bd662Svikram 	/* For now, we let Live Upgrade take care of its signature itself */
5148eb2bd662Svikram 	if (lu) {
5149eb2bd662Svikram 		BAM_DPRINTF((D_FREEING_LU_SIGNS, fcn, lu));
5150eb2bd662Svikram 		free(lu);
5151eb2bd662Svikram 		lu = NULL;
5152eb2bd662Svikram 	}
5153eb2bd662Svikram 
5154eb2bd662Svikram 	return (zfs ? zfs : ufs);
5155eb2bd662Svikram }
5156eb2bd662Svikram 
5157eb2bd662Svikram static char *
5158eb2bd662Svikram find_backup_common(char *mntpt, char *fstype)
5159eb2bd662Svikram {
5160eb2bd662Svikram 	FILE		*bfp = NULL;
5161eb2bd662Svikram 	char		tmpsign[MAXNAMELEN + 1];
5162eb2bd662Svikram 	char		backup[PATH_MAX];
5163eb2bd662Svikram 	char		*ufs;
5164eb2bd662Svikram 	char		*zfs;
5165eb2bd662Svikram 	char		*lu;
5166eb2bd662Svikram 	int		error;
5167eb2bd662Svikram 	const char	*fcn = "find_backup_common()";
5168eb2bd662Svikram 
5169eb2bd662Svikram 	/*
5170eb2bd662Svikram 	 * We didn't find it in the primary directory.
5171eb2bd662Svikram 	 * Look at the backup
5172eb2bd662Svikram 	 */
5173eb2bd662Svikram 	(void) snprintf(backup, sizeof (backup), "%s%s",
5174eb2bd662Svikram 	    mntpt, GRUBSIGN_BACKUP);
5175eb2bd662Svikram 
5176eb2bd662Svikram 	bfp = fopen(backup, "r");
5177eb2bd662Svikram 	if (bfp == NULL) {
5178eb2bd662Svikram 		error = errno;
5179eb2bd662Svikram 		if (bam_verbose) {
5180eb2bd662Svikram 			bam_error(OPEN_FAIL, backup, strerror(error));
5181eb2bd662Svikram 		}
5182eb2bd662Svikram 		BAM_DPRINTF((D_OPEN_FAIL, fcn, backup, strerror(error)));
5183eb2bd662Svikram 		return (NULL);
5184eb2bd662Svikram 	}
5185eb2bd662Svikram 
5186eb2bd662Svikram 	ufs = zfs = lu = NULL;
5187eb2bd662Svikram 
5188eb2bd662Svikram 	while (s_fgets(tmpsign, sizeof (tmpsign), bfp) != NULL) {
5189eb2bd662Svikram 
5190eb2bd662Svikram 		if (lu == NULL &&
5191eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_LU_PREFIX,
5192eb2bd662Svikram 		    strlen(GRUBSIGN_LU_PREFIX)) == 0) {
5193eb2bd662Svikram 			lu = s_strdup(tmpsign);
5194eb2bd662Svikram 		}
5195eb2bd662Svikram 
5196eb2bd662Svikram 		if (ufs == NULL &&
5197eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_UFS_PREFIX,
5198eb2bd662Svikram 		    strlen(GRUBSIGN_UFS_PREFIX)) == 0) {
5199eb2bd662Svikram 			ufs = s_strdup(tmpsign);
5200eb2bd662Svikram 		}
5201eb2bd662Svikram 
5202eb2bd662Svikram 		if (zfs == NULL &&
5203eb2bd662Svikram 		    strncmp(tmpsign, GRUBSIGN_ZFS_PREFIX,
5204eb2bd662Svikram 		    strlen(GRUBSIGN_ZFS_PREFIX)) == 0) {
5205eb2bd662Svikram 			zfs = s_strdup(tmpsign);
5206eb2bd662Svikram 		}
5207eb2bd662Svikram 	}
5208eb2bd662Svikram 
5209eb2bd662Svikram 	BAM_DPRINTF((D_EXIST_BACKUP_SIGNS, fcn,
5210eb2bd662Svikram 	    zfs ? zfs : "NULL",
5211eb2bd662Svikram 	    ufs ? ufs : "NULL",
5212eb2bd662Svikram 	    lu ? lu : "NULL"));
5213eb2bd662Svikram 
5214eb2bd662Svikram 	if (bfp) {
5215eb2bd662Svikram 		(void) fclose(bfp);
5216eb2bd662Svikram 		bfp = NULL;
5217eb2bd662Svikram 	}
5218eb2bd662Svikram 
5219eb2bd662Svikram 	if (strcmp(fstype, "ufs") == 0 && zfs) {
5220eb2bd662Svikram 		bam_error(SIGN_FSTYPE_MISMATCH, zfs, "ufs");
5221eb2bd662Svikram 		free(zfs);
5222eb2bd662Svikram 		zfs = NULL;
5223eb2bd662Svikram 	} else if (strcmp(fstype, "zfs") == 0 && ufs) {
5224eb2bd662Svikram 		bam_error(SIGN_FSTYPE_MISMATCH, ufs, "zfs");
5225eb2bd662Svikram 		free(ufs);
5226eb2bd662Svikram 		ufs = NULL;
5227eb2bd662Svikram 	}
5228eb2bd662Svikram 
5229eb2bd662Svikram 	assert(bfp == NULL);
5230eb2bd662Svikram 
5231eb2bd662Svikram 	/* For now, we let Live Upgrade take care of its signature itself */
5232eb2bd662Svikram 	if (lu) {
5233eb2bd662Svikram 		BAM_DPRINTF((D_FREEING_LU_SIGNS, fcn, lu));
5234eb2bd662Svikram 		free(lu);
5235eb2bd662Svikram 		lu = NULL;
5236eb2bd662Svikram 	}
5237eb2bd662Svikram 
5238eb2bd662Svikram 	return (zfs ? zfs : ufs);
5239eb2bd662Svikram }
5240eb2bd662Svikram 
5241eb2bd662Svikram static char *
5242eb2bd662Svikram find_ufs_existing(char *osroot)
5243eb2bd662Svikram {
5244eb2bd662Svikram 	char		*sign;
5245eb2bd662Svikram 	const char	*fcn = "find_ufs_existing()";
5246eb2bd662Svikram 
5247eb2bd662Svikram 	sign = find_primary_common(osroot, "ufs");
5248eb2bd662Svikram 	if (sign == NULL) {
5249eb2bd662Svikram 		sign = find_backup_common(osroot, "ufs");
5250eb2bd662Svikram 		BAM_DPRINTF((D_EXIST_BACKUP_SIGN, fcn, sign ? sign : "NULL"));
5251eb2bd662Svikram 	} else {
5252eb2bd662Svikram 		BAM_DPRINTF((D_EXIST_PRIMARY_SIGN, fcn, sign));
5253eb2bd662Svikram 	}
5254eb2bd662Svikram 
5255eb2bd662Svikram 	return (sign);
5256eb2bd662Svikram }
5257eb2bd662Svikram 
5258eb2bd662Svikram char *
5259eb2bd662Svikram get_mountpoint(char *special, char *fstype)
5260eb2bd662Svikram {
5261eb2bd662Svikram 	FILE		*mntfp;
5262eb2bd662Svikram 	struct mnttab	mp = {0};
5263eb2bd662Svikram 	struct mnttab	mpref = {0};
5264eb2bd662Svikram 	int		error;
5265eb2bd662Svikram 	int		ret;
5266eb2bd662Svikram 	const char	*fcn = "get_mountpoint()";
5267eb2bd662Svikram 
5268eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, special, fstype));
5269eb2bd662Svikram 
5270eb2bd662Svikram 	mntfp = fopen(MNTTAB, "r");
5271eb2bd662Svikram 	error = errno;
5272eb2bd662Svikram 	INJECT_ERROR1("MNTTAB_ERR_GET_MNTPT", mntfp = NULL);
5273eb2bd662Svikram 	if (mntfp == NULL) {
5274eb2bd662Svikram 		bam_error(OPEN_FAIL, MNTTAB, strerror(error));
5275eb2bd662Svikram 		return (NULL);
5276eb2bd662Svikram 	}
5277eb2bd662Svikram 
5278eb2bd662Svikram 	mpref.mnt_special = special;
5279eb2bd662Svikram 	mpref.mnt_fstype = fstype;
5280eb2bd662Svikram 
5281eb2bd662Svikram 	ret = getmntany(mntfp, &mp, &mpref);
5282eb2bd662Svikram 	INJECT_ERROR1("GET_MOUNTPOINT_MNTANY", ret = 1);
5283eb2bd662Svikram 	if (ret != 0) {
5284eb2bd662Svikram 		(void) fclose(mntfp);
5285eb2bd662Svikram 		BAM_DPRINTF((D_NO_MNTPT, fcn, special, fstype));
5286eb2bd662Svikram 		return (NULL);
5287eb2bd662Svikram 	}
5288eb2bd662Svikram 	(void) fclose(mntfp);
5289eb2bd662Svikram 
5290eb2bd662Svikram 	assert(mp.mnt_mountp);
5291eb2bd662Svikram 
5292eb2bd662Svikram 	BAM_DPRINTF((D_GET_MOUNTPOINT_RET, fcn, special, mp.mnt_mountp));
5293eb2bd662Svikram 
5294eb2bd662Svikram 	return (s_strdup(mp.mnt_mountp));
5295eb2bd662Svikram }
5296eb2bd662Svikram 
5297eb2bd662Svikram /*
5298eb2bd662Svikram  * Mounts a "legacy" top dataset (if needed)
5299eb2bd662Svikram  * Returns:	The mountpoint of the legacy top dataset or NULL on error
5300eb2bd662Svikram  * 		mnted returns one of the above values defined for zfs_mnted_t
5301eb2bd662Svikram  */
5302eb2bd662Svikram static char *
5303eb2bd662Svikram mount_legacy_dataset(char *pool, zfs_mnted_t *mnted)
5304eb2bd662Svikram {
5305eb2bd662Svikram 	char		cmd[PATH_MAX];
5306eb2bd662Svikram 	char		tmpmnt[PATH_MAX];
5307eb2bd662Svikram 	filelist_t	flist = {0};
5308eb2bd662Svikram 	char		*is_mounted;
5309eb2bd662Svikram 	struct stat	sb;
5310eb2bd662Svikram 	int		ret;
5311eb2bd662Svikram 	const char	*fcn = "mount_legacy_dataset()";
5312eb2bd662Svikram 
5313eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, pool));
5314eb2bd662Svikram 
5315eb2bd662Svikram 	*mnted = ZFS_MNT_ERROR;
5316eb2bd662Svikram 
5317eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5318eb2bd662Svikram 	    "/sbin/zfs get -Ho value mounted %s",
5319eb2bd662Svikram 	    pool);
5320eb2bd662Svikram 
5321eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
5322eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_CMD", ret = 1);
5323eb2bd662Svikram 	if (ret != 0) {
5324eb2bd662Svikram 		bam_error(ZFS_MNTED_FAILED, pool);
5325eb2bd662Svikram 		return (NULL);
5326eb2bd662Svikram 	}
5327eb2bd662Svikram 
5328eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_OUT", flist.head = NULL);
5329eb2bd662Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
5330eb2bd662Svikram 		bam_error(BAD_ZFS_MNTED, pool);
5331eb2bd662Svikram 		filelist_free(&flist);
5332eb2bd662Svikram 		return (NULL);
5333eb2bd662Svikram 	}
5334eb2bd662Svikram 
5335eb2bd662Svikram 	is_mounted = strtok(flist.head->line, " \t\n");
5336eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_YES", is_mounted = "yes");
5337eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_LEG_GET_MOUNTED_STRTOK_NO", is_mounted = "no");
5338eb2bd662Svikram 	if (strcmp(is_mounted, "no") != 0) {
5339eb2bd662Svikram 		filelist_free(&flist);
5340eb2bd662Svikram 		*mnted = LEGACY_ALREADY;
5341eb2bd662Svikram 		/* get_mountpoint returns a strdup'ed string */
5342eb2bd662Svikram 		BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_ALREADY, fcn, pool));
5343eb2bd662Svikram 		return (get_mountpoint(pool, "zfs"));
5344eb2bd662Svikram 	}
5345eb2bd662Svikram 
5346eb2bd662Svikram 	filelist_free(&flist);
5347eb2bd662Svikram 
5348eb2bd662Svikram 	/*
5349eb2bd662Svikram 	 * legacy top dataset is not mounted. Mount it now
5350eb2bd662Svikram 	 * First create a mountpoint.
5351eb2bd662Svikram 	 */
5352eb2bd662Svikram 	(void) snprintf(tmpmnt, sizeof (tmpmnt), "%s.%d",
5353eb2bd662Svikram 	    ZFS_LEGACY_MNTPT, getpid());
5354eb2bd662Svikram 
5355eb2bd662Svikram 	ret = stat(tmpmnt, &sb);
5356eb2bd662Svikram 	if (ret == -1) {
5357eb2bd662Svikram 		BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MNTPT_ABS, fcn, pool, tmpmnt));
535848847494SEnrico Perla - Sun Microsystems 		ret = mkdirp(tmpmnt, DIR_PERMS);
5359eb2bd662Svikram 		INJECT_ERROR1("Z_MOUNT_TOP_LEG_MNTPT_MKDIRP", ret = -1);
5360eb2bd662Svikram 		if (ret == -1) {
5361eb2bd662Svikram 			bam_error(MKDIR_FAILED, tmpmnt, strerror(errno));
5362eb2bd662Svikram 			return (NULL);
5363eb2bd662Svikram 		}
5364eb2bd662Svikram 	} else {
5365eb2bd662Svikram 		BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MNTPT_PRES, fcn, pool, tmpmnt));
5366eb2bd662Svikram 	}
5367eb2bd662Svikram 
5368eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5369eb2bd662Svikram 	    "/sbin/mount -F zfs %s %s",
5370eb2bd662Svikram 	    pool, tmpmnt);
5371eb2bd662Svikram 
5372eb2bd662Svikram 	ret = exec_cmd(cmd, NULL);
5373eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_LEG_MOUNT_CMD", ret = 1);
5374eb2bd662Svikram 	if (ret != 0) {
5375eb2bd662Svikram 		bam_error(ZFS_MOUNT_FAILED, pool);
5376eb2bd662Svikram 		(void) rmdir(tmpmnt);
5377eb2bd662Svikram 		return (NULL);
5378eb2bd662Svikram 	}
5379eb2bd662Svikram 
5380eb2bd662Svikram 	*mnted = LEGACY_MOUNTED;
5381eb2bd662Svikram 	BAM_DPRINTF((D_Z_MOUNT_TOP_LEG_MOUNTED, fcn, pool, tmpmnt));
5382eb2bd662Svikram 	return (s_strdup(tmpmnt));
5383eb2bd662Svikram }
5384eb2bd662Svikram 
5385eb2bd662Svikram /*
5386eb2bd662Svikram  * Mounts the top dataset (if needed)
5387eb2bd662Svikram  * Returns:	The mountpoint of the top dataset or NULL on error
5388eb2bd662Svikram  * 		mnted returns one of the above values defined for zfs_mnted_t
5389eb2bd662Svikram  */
5390eb2bd662Svikram static char *
5391eb2bd662Svikram mount_top_dataset(char *pool, zfs_mnted_t *mnted)
5392eb2bd662Svikram {
5393eb2bd662Svikram 	char		cmd[PATH_MAX];
5394eb2bd662Svikram 	filelist_t	flist = {0};
5395eb2bd662Svikram 	char		*is_mounted;
5396eb2bd662Svikram 	char		*mntpt;
5397eb2bd662Svikram 	char		*zmntpt;
5398eb2bd662Svikram 	int		ret;
5399eb2bd662Svikram 	const char	*fcn = "mount_top_dataset()";
5400eb2bd662Svikram 
5401eb2bd662Svikram 	*mnted = ZFS_MNT_ERROR;
5402eb2bd662Svikram 
5403eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, pool));
5404eb2bd662Svikram 
5405eb2bd662Svikram 	/*
5406eb2bd662Svikram 	 * First check if the top dataset is a "legacy" dataset
5407eb2bd662Svikram 	 */
5408eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5409eb2bd662Svikram 	    "/sbin/zfs get -Ho value mountpoint %s",
5410eb2bd662Svikram 	    pool);
5411eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
5412eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_GET_MNTPT", ret = 1);
5413eb2bd662Svikram 	if (ret != 0) {
5414eb2bd662Svikram 		bam_error(ZFS_MNTPT_FAILED, pool);
5415eb2bd662Svikram 		return (NULL);
5416eb2bd662Svikram 	}
5417eb2bd662Svikram 
5418eb2bd662Svikram 	if (flist.head && (flist.head == flist.tail)) {
5419eb2bd662Svikram 		char *legacy = strtok(flist.head->line, " \t\n");
5420eb2bd662Svikram 		if (legacy && strcmp(legacy, "legacy") == 0) {
5421eb2bd662Svikram 			filelist_free(&flist);
5422eb2bd662Svikram 			BAM_DPRINTF((D_Z_IS_LEGACY, fcn, pool));
5423eb2bd662Svikram 			return (mount_legacy_dataset(pool, mnted));
5424eb2bd662Svikram 		}
5425eb2bd662Svikram 	}
5426eb2bd662Svikram 
5427eb2bd662Svikram 	filelist_free(&flist);
5428eb2bd662Svikram 
5429eb2bd662Svikram 	BAM_DPRINTF((D_Z_IS_NOT_LEGACY, fcn, pool));
5430eb2bd662Svikram 
5431eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5432eb2bd662Svikram 	    "/sbin/zfs get -Ho value mounted %s",
5433eb2bd662Svikram 	    pool);
5434eb2bd662Svikram 
5435eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
5436eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED", ret = 1);
5437eb2bd662Svikram 	if (ret != 0) {
5438eb2bd662Svikram 		bam_error(ZFS_MNTED_FAILED, pool);
5439eb2bd662Svikram 		return (NULL);
5440eb2bd662Svikram 	}
5441eb2bd662Svikram 
5442eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_VAL", flist.head = NULL);
5443eb2bd662Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
5444eb2bd662Svikram 		bam_error(BAD_ZFS_MNTED, pool);
5445eb2bd662Svikram 		filelist_free(&flist);
5446eb2bd662Svikram 		return (NULL);
5447eb2bd662Svikram 	}
5448eb2bd662Svikram 
5449eb2bd662Svikram 	is_mounted = strtok(flist.head->line, " \t\n");
5450eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_YES", is_mounted = "yes");
5451eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MOUNTED_NO", is_mounted = "no");
5452eb2bd662Svikram 	if (strcmp(is_mounted, "no") != 0) {
5453eb2bd662Svikram 		filelist_free(&flist);
5454eb2bd662Svikram 		*mnted = ZFS_ALREADY;
5455eb2bd662Svikram 		BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_ALREADY, fcn, pool));
5456eb2bd662Svikram 		goto mounted;
5457eb2bd662Svikram 	}
5458eb2bd662Svikram 
5459eb2bd662Svikram 	filelist_free(&flist);
5460eb2bd662Svikram 	BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_NOT_ALREADY, fcn, pool));
5461eb2bd662Svikram 
5462eb2bd662Svikram 	/* top dataset is not mounted. Mount it now */
5463eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5464eb2bd662Svikram 	    "/sbin/zfs mount %s", pool);
5465eb2bd662Svikram 	ret = exec_cmd(cmd, NULL);
5466eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_MOUNT_CMD", ret = 1);
5467eb2bd662Svikram 	if (ret != 0) {
5468eb2bd662Svikram 		bam_error(ZFS_MOUNT_FAILED, pool);
5469eb2bd662Svikram 		return (NULL);
5470eb2bd662Svikram 	}
5471eb2bd662Svikram 	*mnted = ZFS_MOUNTED;
5472eb2bd662Svikram 	BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MOUNTED_NOW, fcn, pool));
5473eb2bd662Svikram 	/*FALLTHRU*/
5474eb2bd662Svikram mounted:
5475eb2bd662Svikram 	/*
5476eb2bd662Svikram 	 * Now get the mountpoint
5477eb2bd662Svikram 	 */
5478eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5479eb2bd662Svikram 	    "/sbin/zfs get -Ho value mountpoint %s",
5480eb2bd662Svikram 	    pool);
5481eb2bd662Svikram 
5482eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
5483eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_CMD", ret = 1);
5484eb2bd662Svikram 	if (ret != 0) {
5485eb2bd662Svikram 		bam_error(ZFS_MNTPT_FAILED, pool);
5486eb2bd662Svikram 		goto error;
5487eb2bd662Svikram 	}
5488eb2bd662Svikram 
5489eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_OUT", flist.head = NULL);
5490eb2bd662Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
5491eb2bd662Svikram 		bam_error(NULL_ZFS_MNTPT, pool);
5492eb2bd662Svikram 		goto error;
5493eb2bd662Svikram 	}
5494eb2bd662Svikram 
5495eb2bd662Svikram 	mntpt = strtok(flist.head->line, " \t\n");
5496eb2bd662Svikram 	INJECT_ERROR1("Z_MOUNT_TOP_NONLEG_GET_MNTPT_STRTOK", mntpt = "foo");
5497eb2bd662Svikram 	if (*mntpt != '/') {
5498eb2bd662Svikram 		bam_error(BAD_ZFS_MNTPT, pool, mntpt);
5499eb2bd662Svikram 		goto error;
5500eb2bd662Svikram 	}
5501eb2bd662Svikram 	zmntpt = s_strdup(mntpt);
5502eb2bd662Svikram 
5503eb2bd662Svikram 	filelist_free(&flist);
5504eb2bd662Svikram 
5505eb2bd662Svikram 	BAM_DPRINTF((D_Z_MOUNT_TOP_NONLEG_MNTPT, fcn, pool, zmntpt));
5506eb2bd662Svikram 
5507eb2bd662Svikram 	return (zmntpt);
5508eb2bd662Svikram 
5509eb2bd662Svikram error:
5510eb2bd662Svikram 	filelist_free(&flist);
5511eb2bd662Svikram 	(void) umount_top_dataset(pool, *mnted, NULL);
5512eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_FAILURE, fcn));
5513eb2bd662Svikram 	return (NULL);
5514eb2bd662Svikram }
5515eb2bd662Svikram 
5516eb2bd662Svikram static int
5517eb2bd662Svikram umount_top_dataset(char *pool, zfs_mnted_t mnted, char *mntpt)
5518eb2bd662Svikram {
5519eb2bd662Svikram 	char		cmd[PATH_MAX];
5520eb2bd662Svikram 	int		ret;
5521eb2bd662Svikram 	const char	*fcn = "umount_top_dataset()";
5522eb2bd662Svikram 
5523eb2bd662Svikram 	INJECT_ERROR1("Z_UMOUNT_TOP_INVALID_STATE", mnted = ZFS_MNT_ERROR);
5524eb2bd662Svikram 	switch (mnted) {
5525eb2bd662Svikram 	case LEGACY_ALREADY:
5526eb2bd662Svikram 	case ZFS_ALREADY:
5527eb2bd662Svikram 		/* nothing to do */
5528eb2bd662Svikram 		BAM_DPRINTF((D_Z_UMOUNT_TOP_ALREADY_NOP, fcn, pool,
5529eb2bd662Svikram 		    mntpt ? mntpt : "NULL"));
5530eb2bd662Svikram 		free(mntpt);
5531eb2bd662Svikram 		return (BAM_SUCCESS);
5532eb2bd662Svikram 	case LEGACY_MOUNTED:
5533eb2bd662Svikram 		(void) snprintf(cmd, sizeof (cmd),
5534eb2bd662Svikram 		    "/sbin/umount %s", pool);
5535eb2bd662Svikram 		ret = exec_cmd(cmd, NULL);
5536eb2bd662Svikram 		INJECT_ERROR1("Z_UMOUNT_TOP_LEGACY_UMOUNT_FAIL", ret = 1);
5537eb2bd662Svikram 		if (ret != 0) {
5538eb2bd662Svikram 			bam_error(UMOUNT_FAILED, pool);
5539eb2bd662Svikram 			free(mntpt);
5540eb2bd662Svikram 			return (BAM_ERROR);
5541eb2bd662Svikram 		}
5542eb2bd662Svikram 		if (mntpt)
5543eb2bd662Svikram 			(void) rmdir(mntpt);
5544eb2bd662Svikram 		free(mntpt);
5545eb2bd662Svikram 		BAM_DPRINTF((D_Z_UMOUNT_TOP_LEGACY, fcn, pool));
5546eb2bd662Svikram 		return (BAM_SUCCESS);
5547eb2bd662Svikram 	case ZFS_MOUNTED:
5548eb2bd662Svikram 		free(mntpt);
5549eb2bd662Svikram 		(void) snprintf(cmd, sizeof (cmd),
5550eb2bd662Svikram 		    "/sbin/zfs unmount %s", pool);
5551eb2bd662Svikram 		ret = exec_cmd(cmd, NULL);
5552eb2bd662Svikram 		INJECT_ERROR1("Z_UMOUNT_TOP_NONLEG_UMOUNT_FAIL", ret = 1);
5553eb2bd662Svikram 		if (ret != 0) {
5554eb2bd662Svikram 			bam_error(UMOUNT_FAILED, pool);
5555eb2bd662Svikram 			return (BAM_ERROR);
5556eb2bd662Svikram 		}
5557eb2bd662Svikram 		BAM_DPRINTF((D_Z_UMOUNT_TOP_NONLEG, fcn, pool));
5558eb2bd662Svikram 		return (BAM_SUCCESS);
5559eb2bd662Svikram 	default:
5560eb2bd662Svikram 		bam_error(INT_BAD_MNTSTATE, pool);
5561eb2bd662Svikram 		return (BAM_ERROR);
5562eb2bd662Svikram 	}
5563eb2bd662Svikram 	/*NOTREACHED*/
5564eb2bd662Svikram }
5565eb2bd662Svikram 
5566eb2bd662Svikram /*
5567eb2bd662Svikram  * For ZFS, osdev can be one of two forms
5568eb2bd662Svikram  * It can be a "special" file as seen in mnttab: rpool/ROOT/szboot_0402
5569eb2bd662Svikram  * It can be a /dev/[r]dsk special file. We handle both instances
5570eb2bd662Svikram  */
5571eb2bd662Svikram static char *
5572eb2bd662Svikram get_pool(char *osdev)
5573eb2bd662Svikram {
5574eb2bd662Svikram 	char		cmd[PATH_MAX];
5575eb2bd662Svikram 	char		buf[PATH_MAX];
5576eb2bd662Svikram 	filelist_t	flist = {0};
5577eb2bd662Svikram 	char		*pool;
5578eb2bd662Svikram 	char		*cp;
5579eb2bd662Svikram 	char		*slash;
5580eb2bd662Svikram 	int		ret;
5581eb2bd662Svikram 	const char	*fcn = "get_pool()";
5582eb2bd662Svikram 
5583eb2bd662Svikram 	INJECT_ERROR1("GET_POOL_OSDEV", osdev = NULL);
5584eb2bd662Svikram 	if (osdev == NULL) {
5585eb2bd662Svikram 		bam_error(GET_POOL_OSDEV_NULL);
5586eb2bd662Svikram 		return (NULL);
5587eb2bd662Svikram 	}
5588eb2bd662Svikram 
5589eb2bd662Svikram 	BAM_DPRINTF((D_GET_POOL_OSDEV, fcn, osdev));
5590eb2bd662Svikram 
5591eb2bd662Svikram 	if (osdev[0] != '/') {
5592eb2bd662Svikram 		(void) strlcpy(buf, osdev, sizeof (buf));
5593eb2bd662Svikram 		slash = strchr(buf, '/');
5594eb2bd662Svikram 		if (slash)
5595eb2bd662Svikram 			*slash = '\0';
5596eb2bd662Svikram 		pool = s_strdup(buf);
5597eb2bd662Svikram 		BAM_DPRINTF((D_GET_POOL_RET, fcn, pool));
5598eb2bd662Svikram 		return (pool);
5599eb2bd662Svikram 	} else if (strncmp(osdev, "/dev/dsk/", strlen("/dev/dsk/")) != 0 &&
5600eb2bd662Svikram 	    strncmp(osdev, "/dev/rdsk/", strlen("/dev/rdsk/")) != 0) {
5601eb2bd662Svikram 		bam_error(GET_POOL_BAD_OSDEV, osdev);
5602eb2bd662Svikram 		return (NULL);
5603eb2bd662Svikram 	}
5604eb2bd662Svikram 
5605*d5cb36d3SJan Setje-Eilers 	/*
5606*d5cb36d3SJan Setje-Eilers 	 * Call the zfs fstyp directly since this is a zpool. This avoids
5607*d5cb36d3SJan Setje-Eilers 	 * potential pcfs conflicts if the first block wasn't cleared.
5608*d5cb36d3SJan Setje-Eilers 	 */
5609eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5610*d5cb36d3SJan Setje-Eilers 	    "/usr/lib/fs/zfs/fstyp -a %s 2>/dev/null | /bin/grep '^name:'",
5611eb2bd662Svikram 	    osdev);
5612eb2bd662Svikram 
5613eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
5614eb2bd662Svikram 	INJECT_ERROR1("GET_POOL_FSTYP", ret = 1);
5615eb2bd662Svikram 	if (ret != 0) {
5616eb2bd662Svikram 		bam_error(FSTYP_A_FAILED, osdev);
5617eb2bd662Svikram 		return (NULL);
5618eb2bd662Svikram 	}
5619eb2bd662Svikram 
5620eb2bd662Svikram 	INJECT_ERROR1("GET_POOL_FSTYP_OUT", flist.head = NULL);
5621eb2bd662Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
5622eb2bd662Svikram 		bam_error(NULL_FSTYP_A, osdev);
5623eb2bd662Svikram 		filelist_free(&flist);
5624eb2bd662Svikram 		return (NULL);
5625eb2bd662Svikram 	}
5626eb2bd662Svikram 
5627eb2bd662Svikram 	(void) strtok(flist.head->line, "'");
5628eb2bd662Svikram 	cp = strtok(NULL, "'");
5629eb2bd662Svikram 	INJECT_ERROR1("GET_POOL_FSTYP_STRTOK", cp = NULL);
5630eb2bd662Svikram 	if (cp == NULL) {
5631eb2bd662Svikram 		bam_error(BAD_FSTYP_A, osdev);
5632eb2bd662Svikram 		filelist_free(&flist);
5633eb2bd662Svikram 		return (NULL);
5634eb2bd662Svikram 	}
5635eb2bd662Svikram 
5636eb2bd662Svikram 	pool = s_strdup(cp);
5637eb2bd662Svikram 
5638eb2bd662Svikram 	filelist_free(&flist);
5639eb2bd662Svikram 
5640eb2bd662Svikram 	BAM_DPRINTF((D_GET_POOL_RET, fcn, pool));
5641eb2bd662Svikram 
5642eb2bd662Svikram 	return (pool);
5643eb2bd662Svikram }
5644eb2bd662Svikram 
5645eb2bd662Svikram static char *
5646eb2bd662Svikram find_zfs_existing(char *osdev)
5647eb2bd662Svikram {
5648eb2bd662Svikram 	char		*pool;
5649eb2bd662Svikram 	zfs_mnted_t	mnted;
5650eb2bd662Svikram 	char		*mntpt;
5651eb2bd662Svikram 	char		*sign;
5652eb2bd662Svikram 	const char	*fcn = "find_zfs_existing()";
5653eb2bd662Svikram 
5654eb2bd662Svikram 	pool = get_pool(osdev);
5655eb2bd662Svikram 	INJECT_ERROR1("ZFS_FIND_EXIST_POOL", pool = NULL);
5656eb2bd662Svikram 	if (pool == NULL) {
5657eb2bd662Svikram 		bam_error(ZFS_GET_POOL_FAILED, osdev);
5658eb2bd662Svikram 		return (NULL);
5659eb2bd662Svikram 	}
5660eb2bd662Svikram 
5661eb2bd662Svikram 	mntpt = mount_top_dataset(pool, &mnted);
5662eb2bd662Svikram 	INJECT_ERROR1("ZFS_FIND_EXIST_MOUNT_TOP", mntpt = NULL);
5663eb2bd662Svikram 	if (mntpt == NULL) {
5664eb2bd662Svikram 		bam_error(ZFS_MOUNT_TOP_DATASET_FAILED, pool);
5665eb2bd662Svikram 		free(pool);
5666eb2bd662Svikram 		return (NULL);
5667eb2bd662Svikram 	}
5668eb2bd662Svikram 
5669eb2bd662Svikram 	sign = find_primary_common(mntpt, "zfs");
5670eb2bd662Svikram 	if (sign == NULL) {
5671eb2bd662Svikram 		sign = find_backup_common(mntpt, "zfs");
5672eb2bd662Svikram 		BAM_DPRINTF((D_EXIST_BACKUP_SIGN, fcn, sign ? sign : "NULL"));
5673eb2bd662Svikram 	} else {
5674eb2bd662Svikram 		BAM_DPRINTF((D_EXIST_PRIMARY_SIGN, fcn, sign));
5675eb2bd662Svikram 	}
5676eb2bd662Svikram 
5677eb2bd662Svikram 	(void) umount_top_dataset(pool, mnted, mntpt);
5678eb2bd662Svikram 
5679eb2bd662Svikram 	free(pool);
5680eb2bd662Svikram 
5681eb2bd662Svikram 	return (sign);
5682eb2bd662Svikram }
5683eb2bd662Svikram 
5684eb2bd662Svikram static char *
5685eb2bd662Svikram find_existing_sign(char *osroot, char *osdev, char *fstype)
5686eb2bd662Svikram {
5687eb2bd662Svikram 	const char		*fcn = "find_existing_sign()";
5688eb2bd662Svikram 
5689eb2bd662Svikram 	INJECT_ERROR1("FIND_EXIST_NOTSUP_FS", fstype = "foofs");
5690eb2bd662Svikram 	if (strcmp(fstype, "ufs") == 0) {
5691eb2bd662Svikram 		BAM_DPRINTF((D_CHECK_UFS_EXIST_SIGN, fcn));
5692eb2bd662Svikram 		return (find_ufs_existing(osroot));
5693eb2bd662Svikram 	} else if (strcmp(fstype, "zfs") == 0) {
5694eb2bd662Svikram 		BAM_DPRINTF((D_CHECK_ZFS_EXIST_SIGN, fcn));
5695eb2bd662Svikram 		return (find_zfs_existing(osdev));
5696eb2bd662Svikram 	} else {
5697eb2bd662Svikram 		bam_error(GRUBSIGN_NOTSUP, fstype);
5698eb2bd662Svikram 		return (NULL);
5699eb2bd662Svikram 	}
5700eb2bd662Svikram }
5701eb2bd662Svikram 
5702eb2bd662Svikram #define	MH_HASH_SZ	16
5703eb2bd662Svikram 
5704eb2bd662Svikram typedef enum {
5705eb2bd662Svikram 	MH_ERROR = -1,
5706eb2bd662Svikram 	MH_NOMATCH,
5707eb2bd662Svikram 	MH_MATCH
5708eb2bd662Svikram } mh_search_t;
5709eb2bd662Svikram 
5710eb2bd662Svikram typedef struct mcache {
5711eb2bd662Svikram 	char	*mc_special;
5712eb2bd662Svikram 	char	*mc_mntpt;
5713eb2bd662Svikram 	char	*mc_fstype;
5714eb2bd662Svikram 	struct mcache *mc_next;
5715eb2bd662Svikram } mcache_t;
5716eb2bd662Svikram 
5717eb2bd662Svikram typedef struct mhash {
5718eb2bd662Svikram 	mcache_t *mh_hash[MH_HASH_SZ];
5719eb2bd662Svikram } mhash_t;
5720eb2bd662Svikram 
5721eb2bd662Svikram static int
5722eb2bd662Svikram mhash_fcn(char *key)
5723eb2bd662Svikram {
5724eb2bd662Svikram 	int		i;
5725eb2bd662Svikram 	uint64_t	sum = 0;
5726eb2bd662Svikram 
5727eb2bd662Svikram 	for (i = 0; key[i] != '\0'; i++) {
5728eb2bd662Svikram 		sum += (uchar_t)key[i];
5729eb2bd662Svikram 	}
5730eb2bd662Svikram 
5731eb2bd662Svikram 	sum %= MH_HASH_SZ;
5732eb2bd662Svikram 
5733eb2bd662Svikram 	assert(sum < MH_HASH_SZ);
5734eb2bd662Svikram 
5735eb2bd662Svikram 	return (sum);
5736eb2bd662Svikram }
5737eb2bd662Svikram 
5738eb2bd662Svikram static mhash_t *
5739eb2bd662Svikram cache_mnttab(void)
5740eb2bd662Svikram {
5741eb2bd662Svikram 	FILE		*mfp;
5742eb2bd662Svikram 	struct extmnttab mnt;
5743eb2bd662Svikram 	mcache_t	*mcp;
5744eb2bd662Svikram 	mhash_t		*mhp;
5745eb2bd662Svikram 	char		*ctds;
5746eb2bd662Svikram 	int		idx;
5747eb2bd662Svikram 	int		error;
5748eb2bd662Svikram 	char		*special_dup;
5749eb2bd662Svikram 	const char	*fcn = "cache_mnttab()";
5750eb2bd662Svikram 
5751eb2bd662Svikram 	mfp = fopen(MNTTAB, "r");
5752eb2bd662Svikram 	error = errno;
5753eb2bd662Svikram 	INJECT_ERROR1("CACHE_MNTTAB_MNTTAB_ERR", mfp = NULL);
5754eb2bd662Svikram 	if (mfp == NULL) {
5755eb2bd662Svikram 		bam_error(OPEN_FAIL, MNTTAB, strerror(error));
5756eb2bd662Svikram 		return (NULL);
5757eb2bd662Svikram 	}
5758eb2bd662Svikram 
5759eb2bd662Svikram 	mhp = s_calloc(1, sizeof (mhash_t));
5760eb2bd662Svikram 
5761eb2bd662Svikram 	resetmnttab(mfp);
5762eb2bd662Svikram 
5763eb2bd662Svikram 	while (getextmntent(mfp, &mnt, sizeof (mnt)) == 0) {
5764eb2bd662Svikram 		/* only cache ufs */
5765eb2bd662Svikram 		if (strcmp(mnt.mnt_fstype, "ufs") != 0)
5766eb2bd662Svikram 			continue;
5767eb2bd662Svikram 
5768eb2bd662Svikram 		/* basename() modifies its arg, so dup it */
5769eb2bd662Svikram 		special_dup = s_strdup(mnt.mnt_special);
5770eb2bd662Svikram 		ctds = basename(special_dup);
5771eb2bd662Svikram 
5772eb2bd662Svikram 		mcp = s_calloc(1, sizeof (mcache_t));
5773eb2bd662Svikram 		mcp->mc_special = s_strdup(ctds);
5774eb2bd662Svikram 		mcp->mc_mntpt = s_strdup(mnt.mnt_mountp);
5775eb2bd662Svikram 		mcp->mc_fstype = s_strdup(mnt.mnt_fstype);
5776eb2bd662Svikram 		BAM_DPRINTF((D_CACHE_MNTS, fcn, ctds,
5777eb2bd662Svikram 		    mnt.mnt_mountp, mnt.mnt_fstype));
5778eb2bd662Svikram 		idx = mhash_fcn(ctds);
5779eb2bd662Svikram 		mcp->mc_next = mhp->mh_hash[idx];
5780eb2bd662Svikram 		mhp->mh_hash[idx] = mcp;
5781eb2bd662Svikram 		free(special_dup);
5782eb2bd662Svikram 	}
5783eb2bd662Svikram 
5784eb2bd662Svikram 	(void) fclose(mfp);
5785eb2bd662Svikram 
5786eb2bd662Svikram 	return (mhp);
5787eb2bd662Svikram }
5788eb2bd662Svikram 
5789eb2bd662Svikram static void
5790eb2bd662Svikram free_mnttab(mhash_t *mhp)
5791eb2bd662Svikram {
5792eb2bd662Svikram 	mcache_t	*mcp;
5793eb2bd662Svikram 	int		i;
5794eb2bd662Svikram 
5795eb2bd662Svikram 	for (i = 0; i < MH_HASH_SZ; i++) {
5796eb2bd662Svikram 		/*LINTED*/
5797eb2bd662Svikram 		while (mcp = mhp->mh_hash[i]) {
5798eb2bd662Svikram 			mhp->mh_hash[i] = mcp->mc_next;
5799eb2bd662Svikram 			free(mcp->mc_special);
5800eb2bd662Svikram 			free(mcp->mc_mntpt);
5801eb2bd662Svikram 			free(mcp->mc_fstype);
5802eb2bd662Svikram 			free(mcp);
5803eb2bd662Svikram 		}
5804eb2bd662Svikram 	}
5805eb2bd662Svikram 
5806eb2bd662Svikram 	for (i = 0; i < MH_HASH_SZ; i++) {
5807eb2bd662Svikram 		assert(mhp->mh_hash[i] == NULL);
5808eb2bd662Svikram 	}
5809eb2bd662Svikram 	free(mhp);
5810eb2bd662Svikram }
5811eb2bd662Svikram 
5812eb2bd662Svikram static mh_search_t
5813eb2bd662Svikram search_hash(mhash_t *mhp, char *special, char **mntpt)
5814eb2bd662Svikram {
5815eb2bd662Svikram 	int		idx;
5816eb2bd662Svikram 	mcache_t	*mcp;
5817eb2bd662Svikram 	const char 	*fcn = "search_hash()";
5818eb2bd662Svikram 
5819eb2bd662Svikram 	assert(mntpt);
5820eb2bd662Svikram 
5821eb2bd662Svikram 	*mntpt = NULL;
5822eb2bd662Svikram 
5823eb2bd662Svikram 	INJECT_ERROR1("SEARCH_HASH_FULL_PATH", special = "/foo");
5824eb2bd662Svikram 	if (strchr(special, '/')) {
5825eb2bd662Svikram 		bam_error(INVALID_MHASH_KEY, special);
5826eb2bd662Svikram 		return (MH_ERROR);
5827eb2bd662Svikram 	}
5828eb2bd662Svikram 
5829eb2bd662Svikram 	idx = mhash_fcn(special);
5830eb2bd662Svikram 
5831eb2bd662Svikram 	for (mcp = mhp->mh_hash[idx]; mcp; mcp = mcp->mc_next) {
5832eb2bd662Svikram 		if (strcmp(mcp->mc_special, special) == 0)
5833eb2bd662Svikram 			break;
5834eb2bd662Svikram 	}
5835eb2bd662Svikram 
5836eb2bd662Svikram 	if (mcp == NULL) {
5837eb2bd662Svikram 		BAM_DPRINTF((D_MNTTAB_HASH_NOMATCH, fcn, special));
5838eb2bd662Svikram 		return (MH_NOMATCH);
5839eb2bd662Svikram 	}
5840eb2bd662Svikram 
5841eb2bd662Svikram 	assert(strcmp(mcp->mc_fstype, "ufs") == 0);
5842eb2bd662Svikram 	*mntpt = mcp->mc_mntpt;
5843eb2bd662Svikram 	BAM_DPRINTF((D_MNTTAB_HASH_MATCH, fcn, special));
5844eb2bd662Svikram 	return (MH_MATCH);
5845eb2bd662Svikram }
5846eb2bd662Svikram 
5847eb2bd662Svikram static int
5848eb2bd662Svikram check_add_ufs_sign_to_list(FILE *tfp, char *mntpt)
5849eb2bd662Svikram {
5850eb2bd662Svikram 	char		*sign;
5851eb2bd662Svikram 	char		*signline;
5852eb2bd662Svikram 	char		signbuf[MAXNAMELEN];
5853eb2bd662Svikram 	int		len;
5854eb2bd662Svikram 	int		error;
5855eb2bd662Svikram 	const char	*fcn = "check_add_ufs_sign_to_list()";
5856eb2bd662Svikram 
5857eb2bd662Svikram 	/* safe to specify NULL as "osdev" arg for UFS */
5858eb2bd662Svikram 	sign = find_existing_sign(mntpt, NULL, "ufs");
5859eb2bd662Svikram 	if (sign == NULL) {
5860eb2bd662Svikram 		/* No existing signature, nothing to add to list */
5861eb2bd662Svikram 		BAM_DPRINTF((D_NO_SIGN_TO_LIST, fcn, mntpt));
5862eb2bd662Svikram 		return (0);
5863eb2bd662Svikram 	}
5864eb2bd662Svikram 
5865eb2bd662Svikram 	(void) snprintf(signbuf, sizeof (signbuf), "%s\n", sign);
5866eb2bd662Svikram 	signline = signbuf;
5867eb2bd662Svikram 
5868eb2bd662Svikram 	INJECT_ERROR1("UFS_MNTPT_SIGN_NOTUFS", signline = "pool_rpool10\n");
5869eb2bd662Svikram 	if (strncmp(signline, GRUBSIGN_UFS_PREFIX,
5870eb2bd662Svikram 	    strlen(GRUBSIGN_UFS_PREFIX))) {
5871eb2bd662Svikram 		bam_error(INVALID_UFS_SIGNATURE, sign);
5872eb2bd662Svikram 		free(sign);
5873eb2bd662Svikram 		/* ignore invalid signatures */
5874eb2bd662Svikram 		return (0);
5875eb2bd662Svikram 	}
5876eb2bd662Svikram 
5877eb2bd662Svikram 	len = fputs(signline, tfp);
5878eb2bd662Svikram 	error = errno;
5879eb2bd662Svikram 	INJECT_ERROR1("SIGN_LIST_PUTS_ERROR", len = 0);
5880eb2bd662Svikram 	if (len != strlen(signline)) {
5881eb2bd662Svikram 		bam_error(SIGN_LIST_FPUTS_ERR, sign, strerror(error));
5882eb2bd662Svikram 		free(sign);
5883eb2bd662Svikram 		return (-1);
5884eb2bd662Svikram 	}
5885eb2bd662Svikram 
5886eb2bd662Svikram 	free(sign);
5887eb2bd662Svikram 
5888eb2bd662Svikram 	BAM_DPRINTF((D_SIGN_LIST_PUTS_DONE, fcn, mntpt));
5889eb2bd662Svikram 	return (0);
5890eb2bd662Svikram }
5891eb2bd662Svikram 
5892eb2bd662Svikram /*
5893eb2bd662Svikram  * slice is a basename not a full pathname
5894eb2bd662Svikram  */
5895eb2bd662Svikram static int
5896eb2bd662Svikram process_slice_common(char *slice, FILE *tfp, mhash_t *mhp, char *tmpmnt)
5897eb2bd662Svikram {
5898eb2bd662Svikram 	int		ret;
5899eb2bd662Svikram 	char		cmd[PATH_MAX];
5900eb2bd662Svikram 	char		path[PATH_MAX];
5901eb2bd662Svikram 	struct stat	sbuf;
5902eb2bd662Svikram 	char		*mntpt;
5903eb2bd662Svikram 	filelist_t	flist = {0};
5904eb2bd662Svikram 	char		*fstype;
5905eb2bd662Svikram 	char		blkslice[PATH_MAX];
5906eb2bd662Svikram 	const char	*fcn = "process_slice_common()";
5907eb2bd662Svikram 
5908eb2bd662Svikram 
5909eb2bd662Svikram 	ret = search_hash(mhp, slice, &mntpt);
5910eb2bd662Svikram 	switch (ret) {
5911eb2bd662Svikram 		case MH_MATCH:
5912eb2bd662Svikram 			if (check_add_ufs_sign_to_list(tfp, mntpt) == -1)
5913eb2bd662Svikram 				return (-1);
5914eb2bd662Svikram 			else
5915eb2bd662Svikram 				return (0);
5916eb2bd662Svikram 		case MH_NOMATCH:
5917eb2bd662Svikram 			break;
5918eb2bd662Svikram 		case MH_ERROR:
5919eb2bd662Svikram 		default:
5920eb2bd662Svikram 			return (-1);
5921eb2bd662Svikram 	}
5922eb2bd662Svikram 
5923eb2bd662Svikram 	(void) snprintf(path, sizeof (path), "/dev/rdsk/%s", slice);
5924eb2bd662Svikram 	if (stat(path, &sbuf) == -1) {
5925eb2bd662Svikram 		BAM_DPRINTF((D_SLICE_ENOENT, fcn, path));
5926eb2bd662Svikram 		return (0);
5927eb2bd662Svikram 	}
5928eb2bd662Svikram 
5929*d5cb36d3SJan Setje-Eilers 	/* Check if ufs. Call ufs fstyp directly to avoid pcfs conflicts. */
5930eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5931*d5cb36d3SJan Setje-Eilers 	    "/usr/lib/fs/ufs/fstyp /dev/rdsk/%s 2>/dev/null",
5932eb2bd662Svikram 	    slice);
5933eb2bd662Svikram 
5934eb2bd662Svikram 	if (exec_cmd(cmd, &flist) != 0) {
5935eb2bd662Svikram 		if (bam_verbose)
5936eb2bd662Svikram 			bam_print(FSTYP_FAILED, slice);
5937eb2bd662Svikram 		return (0);
5938eb2bd662Svikram 	}
5939eb2bd662Svikram 
5940eb2bd662Svikram 	if ((flist.head == NULL) || (flist.head != flist.tail)) {
5941eb2bd662Svikram 		if (bam_verbose)
5942eb2bd662Svikram 			bam_print(FSTYP_BAD, slice);
5943eb2bd662Svikram 		filelist_free(&flist);
5944eb2bd662Svikram 		return (0);
5945eb2bd662Svikram 	}
5946eb2bd662Svikram 
5947eb2bd662Svikram 	fstype = strtok(flist.head->line, " \t\n");
5948eb2bd662Svikram 	if (fstype == NULL || strcmp(fstype, "ufs") != 0) {
5949eb2bd662Svikram 		if (bam_verbose)
5950eb2bd662Svikram 			bam_print(NOT_UFS_SLICE, slice, fstype);
5951eb2bd662Svikram 		filelist_free(&flist);
5952eb2bd662Svikram 		return (0);
5953eb2bd662Svikram 	}
5954eb2bd662Svikram 
5955eb2bd662Svikram 	filelist_free(&flist);
5956eb2bd662Svikram 
5957eb2bd662Svikram 	/*
5958eb2bd662Svikram 	 * Since we are mounting the filesystem read-only, the
5959eb2bd662Svikram 	 * the last mount field of the superblock is unchanged
5960eb2bd662Svikram 	 * and does not need to be fixed up post-mount;
5961eb2bd662Svikram 	 */
5962eb2bd662Svikram 
5963eb2bd662Svikram 	(void) snprintf(blkslice, sizeof (blkslice), "/dev/dsk/%s",
5964eb2bd662Svikram 	    slice);
5965eb2bd662Svikram 
5966eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5967eb2bd662Svikram 	    "/usr/sbin/mount -F ufs -o ro %s %s "
5968eb2bd662Svikram 	    "> /dev/null 2>&1", blkslice, tmpmnt);
5969eb2bd662Svikram 
5970eb2bd662Svikram 	if (exec_cmd(cmd, NULL) != 0) {
5971eb2bd662Svikram 		if (bam_verbose)
5972eb2bd662Svikram 			bam_print(MOUNT_FAILED, blkslice, "ufs");
5973eb2bd662Svikram 		return (0);
5974eb2bd662Svikram 	}
5975eb2bd662Svikram 
5976eb2bd662Svikram 	ret = check_add_ufs_sign_to_list(tfp, tmpmnt);
5977eb2bd662Svikram 
5978eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
5979eb2bd662Svikram 	    "/usr/sbin/umount -f %s > /dev/null 2>&1",
5980eb2bd662Svikram 	    tmpmnt);
5981eb2bd662Svikram 
5982eb2bd662Svikram 	if (exec_cmd(cmd, NULL) != 0) {
5983eb2bd662Svikram 		bam_print(UMOUNT_FAILED, slice);
5984eb2bd662Svikram 		return (0);
5985eb2bd662Svikram 	}
5986eb2bd662Svikram 
5987eb2bd662Svikram 	return (ret);
5988eb2bd662Svikram }
5989eb2bd662Svikram 
5990eb2bd662Svikram static int
5991eb2bd662Svikram process_vtoc_slices(
5992eb2bd662Svikram 	char *s0,
5993eb2bd662Svikram 	struct vtoc *vtoc,
5994eb2bd662Svikram 	FILE *tfp,
5995eb2bd662Svikram 	mhash_t *mhp,
5996eb2bd662Svikram 	char *tmpmnt)
5997eb2bd662Svikram {
5998eb2bd662Svikram 	int		idx;
5999eb2bd662Svikram 	char		slice[PATH_MAX];
6000eb2bd662Svikram 	size_t		len;
6001eb2bd662Svikram 	char		*cp;
6002eb2bd662Svikram 	const char	*fcn = "process_vtoc_slices()";
6003eb2bd662Svikram 
6004eb2bd662Svikram 	len = strlen(s0);
6005eb2bd662Svikram 
6006eb2bd662Svikram 	assert(s0[len - 2] == 's' && s0[len - 1] == '0');
6007eb2bd662Svikram 
6008eb2bd662Svikram 	s0[len - 1] = '\0';
6009eb2bd662Svikram 
6010eb2bd662Svikram 	(void) strlcpy(slice, s0, sizeof (slice));
6011eb2bd662Svikram 
6012eb2bd662Svikram 	s0[len - 1] = '0';
6013eb2bd662Svikram 
6014eb2bd662Svikram 	cp = slice + len - 1;
6015eb2bd662Svikram 
6016eb2bd662Svikram 	for (idx = 0; idx < vtoc->v_nparts; idx++) {
6017eb2bd662Svikram 
6018eb2bd662Svikram 		(void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx);
6019eb2bd662Svikram 
6020eb2bd662Svikram 		if (vtoc->v_part[idx].p_size == 0) {
6021eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_SIZE_ZERO, fcn, slice));
6022eb2bd662Svikram 			continue;
6023eb2bd662Svikram 		}
6024eb2bd662Svikram 
6025eb2bd662Svikram 		/* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */
6026eb2bd662Svikram 		switch (vtoc->v_part[idx].p_tag) {
6027eb2bd662Svikram 		case V_SWAP:
6028eb2bd662Svikram 		case V_USR:
6029eb2bd662Svikram 		case V_BACKUP:
6030eb2bd662Svikram 		case V_VAR:
6031eb2bd662Svikram 		case V_HOME:
6032eb2bd662Svikram 		case V_ALTSCTR:
6033eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_NOT_ROOT_TAG, fcn, slice));
6034eb2bd662Svikram 			continue;
6035eb2bd662Svikram 		default:
6036eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_ROOT_TAG, fcn, slice));
6037eb2bd662Svikram 			break;
6038eb2bd662Svikram 		}
6039eb2bd662Svikram 
6040eb2bd662Svikram 		/* skip unmountable and readonly slices */
6041eb2bd662Svikram 		switch (vtoc->v_part[idx].p_flag) {
6042eb2bd662Svikram 		case V_UNMNT:
6043eb2bd662Svikram 		case V_RONLY:
6044eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_NOT_RDWR_FLAG, fcn, slice));
6045eb2bd662Svikram 			continue;
6046eb2bd662Svikram 		default:
6047eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_RDWR_FLAG, fcn, slice));
6048eb2bd662Svikram 			break;
6049eb2bd662Svikram 		}
6050eb2bd662Svikram 
6051eb2bd662Svikram 		if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) {
6052eb2bd662Svikram 			return (-1);
6053eb2bd662Svikram 		}
6054eb2bd662Svikram 	}
6055eb2bd662Svikram 
6056eb2bd662Svikram 	return (0);
6057eb2bd662Svikram }
6058eb2bd662Svikram 
6059eb2bd662Svikram static int
6060eb2bd662Svikram process_efi_slices(
6061eb2bd662Svikram 	char *s0,
6062eb2bd662Svikram 	struct dk_gpt *efi,
6063eb2bd662Svikram 	FILE *tfp,
6064eb2bd662Svikram 	mhash_t *mhp,
6065eb2bd662Svikram 	char *tmpmnt)
6066eb2bd662Svikram {
6067eb2bd662Svikram 	int		idx;
6068eb2bd662Svikram 	char		slice[PATH_MAX];
6069eb2bd662Svikram 	size_t		len;
6070eb2bd662Svikram 	char		*cp;
6071eb2bd662Svikram 	const char	*fcn = "process_efi_slices()";
6072eb2bd662Svikram 
6073eb2bd662Svikram 	len = strlen(s0);
6074eb2bd662Svikram 
6075eb2bd662Svikram 	assert(s0[len - 2] == 's' && s0[len - 1] == '0');
6076eb2bd662Svikram 
6077eb2bd662Svikram 	s0[len - 1] = '\0';
6078eb2bd662Svikram 
6079eb2bd662Svikram 	(void) strlcpy(slice, s0, sizeof (slice));
6080eb2bd662Svikram 
6081eb2bd662Svikram 	s0[len - 1] = '0';
6082eb2bd662Svikram 
6083eb2bd662Svikram 	cp = slice + len - 1;
6084eb2bd662Svikram 
6085eb2bd662Svikram 	for (idx = 0; idx < efi->efi_nparts; idx++) {
6086eb2bd662Svikram 
6087eb2bd662Svikram 		(void) snprintf(cp, sizeof (slice) - (len - 1), "%u", idx);
6088eb2bd662Svikram 
6089eb2bd662Svikram 		if (efi->efi_parts[idx].p_size == 0) {
6090eb2bd662Svikram 			BAM_DPRINTF((D_EFI_SIZE_ZERO, fcn, slice));
6091eb2bd662Svikram 			continue;
6092eb2bd662Svikram 		}
6093eb2bd662Svikram 
6094eb2bd662Svikram 		/* Skip "SWAP", "USR", "BACKUP", "VAR", "HOME", "ALTSCTR" */
6095eb2bd662Svikram 		switch (efi->efi_parts[idx].p_tag) {
6096eb2bd662Svikram 		case V_SWAP:
6097eb2bd662Svikram 		case V_USR:
6098eb2bd662Svikram 		case V_BACKUP:
6099eb2bd662Svikram 		case V_VAR:
6100eb2bd662Svikram 		case V_HOME:
6101eb2bd662Svikram 		case V_ALTSCTR:
6102eb2bd662Svikram 			BAM_DPRINTF((D_EFI_NOT_ROOT_TAG, fcn, slice));
6103eb2bd662Svikram 			continue;
6104eb2bd662Svikram 		default:
6105eb2bd662Svikram 			BAM_DPRINTF((D_EFI_ROOT_TAG, fcn, slice));
6106eb2bd662Svikram 			break;
6107eb2bd662Svikram 		}
6108eb2bd662Svikram 
6109eb2bd662Svikram 		/* skip unmountable and readonly slices */
6110eb2bd662Svikram 		switch (efi->efi_parts[idx].p_flag) {
6111eb2bd662Svikram 		case V_UNMNT:
6112eb2bd662Svikram 		case V_RONLY:
6113eb2bd662Svikram 			BAM_DPRINTF((D_EFI_NOT_RDWR_FLAG, fcn, slice));
6114eb2bd662Svikram 			continue;
6115eb2bd662Svikram 		default:
6116eb2bd662Svikram 			BAM_DPRINTF((D_EFI_RDWR_FLAG, fcn, slice));
6117eb2bd662Svikram 			break;
6118eb2bd662Svikram 		}
6119eb2bd662Svikram 
6120eb2bd662Svikram 		if (process_slice_common(slice, tfp, mhp, tmpmnt) == -1) {
6121eb2bd662Svikram 			return (-1);
6122eb2bd662Svikram 		}
6123eb2bd662Svikram 	}
6124eb2bd662Svikram 
6125eb2bd662Svikram 	return (0);
6126eb2bd662Svikram }
6127eb2bd662Svikram 
6128eb2bd662Svikram /*
6129eb2bd662Svikram  * s0 is a basename not a full path
6130eb2bd662Svikram  */
6131eb2bd662Svikram static int
6132eb2bd662Svikram process_slice0(char *s0, FILE *tfp, mhash_t *mhp, char *tmpmnt)
6133eb2bd662Svikram {
6134eb2bd662Svikram 	struct vtoc		vtoc;
6135eb2bd662Svikram 	struct dk_gpt		*efi;
6136eb2bd662Svikram 	char			s0path[PATH_MAX];
6137eb2bd662Svikram 	struct stat		sbuf;
6138eb2bd662Svikram 	int			e_flag;
6139eb2bd662Svikram 	int			v_flag;
6140eb2bd662Svikram 	int			retval;
6141eb2bd662Svikram 	int			err;
6142eb2bd662Svikram 	int			fd;
6143eb2bd662Svikram 	const char		*fcn = "process_slice0()";
6144eb2bd662Svikram 
6145eb2bd662Svikram 	(void) snprintf(s0path, sizeof (s0path), "/dev/rdsk/%s", s0);
6146eb2bd662Svikram 
6147eb2bd662Svikram 	if (stat(s0path, &sbuf) == -1) {
6148eb2bd662Svikram 		BAM_DPRINTF((D_SLICE0_ENOENT, fcn, s0path));
6149eb2bd662Svikram 		return (0);
6150eb2bd662Svikram 	}
6151eb2bd662Svikram 
6152eb2bd662Svikram 	fd = open(s0path, O_NONBLOCK|O_RDONLY);
6153eb2bd662Svikram 	if (fd == -1) {
6154eb2bd662Svikram 		bam_error(OPEN_FAIL, s0path, strerror(errno));
6155eb2bd662Svikram 		return (0);
6156eb2bd662Svikram 	}
6157eb2bd662Svikram 
6158eb2bd662Svikram 	e_flag = v_flag = 0;
6159eb2bd662Svikram 	retval = ((err = read_vtoc(fd, &vtoc)) >= 0) ? 0 : err;
6160eb2bd662Svikram 	switch (retval) {
6161eb2bd662Svikram 		case VT_EIO:
6162eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_READ_FAIL, fcn, s0path));
6163eb2bd662Svikram 			break;
6164eb2bd662Svikram 		case VT_EINVAL:
6165eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_INVALID, fcn, s0path));
6166eb2bd662Svikram 			break;
6167eb2bd662Svikram 		case VT_ERROR:
6168eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_UNKNOWN_ERR, fcn, s0path));
6169eb2bd662Svikram 			break;
6170eb2bd662Svikram 		case VT_ENOTSUP:
6171eb2bd662Svikram 			e_flag = 1;
6172eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_NOTSUP, fcn, s0path));
6173eb2bd662Svikram 			break;
6174eb2bd662Svikram 		case 0:
6175eb2bd662Svikram 			v_flag = 1;
6176eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_READ_SUCCESS, fcn, s0path));
6177eb2bd662Svikram 			break;
6178eb2bd662Svikram 		default:
6179eb2bd662Svikram 			BAM_DPRINTF((D_VTOC_UNKNOWN_RETCODE, fcn, s0path));
6180eb2bd662Svikram 			break;
6181eb2bd662Svikram 	}
6182eb2bd662Svikram 
6183eb2bd662Svikram 
6184eb2bd662Svikram 	if (e_flag) {
6185eb2bd662Svikram 		e_flag = 0;
6186eb2bd662Svikram 		retval = ((err = efi_alloc_and_read(fd, &efi)) >= 0) ? 0 : err;
6187eb2bd662Svikram 		switch (retval) {
6188eb2bd662Svikram 		case VT_EIO:
6189eb2bd662Svikram 			BAM_DPRINTF((D_EFI_READ_FAIL, fcn, s0path));
6190eb2bd662Svikram 			break;
6191eb2bd662Svikram 		case VT_EINVAL:
6192eb2bd662Svikram 			BAM_DPRINTF((D_EFI_INVALID, fcn, s0path));
6193eb2bd662Svikram 			break;
6194eb2bd662Svikram 		case VT_ERROR:
6195eb2bd662Svikram 			BAM_DPRINTF((D_EFI_UNKNOWN_ERR, fcn, s0path));
6196eb2bd662Svikram 			break;
6197eb2bd662Svikram 		case VT_ENOTSUP:
6198eb2bd662Svikram 			BAM_DPRINTF((D_EFI_NOTSUP, fcn, s0path));
6199eb2bd662Svikram 			break;
6200eb2bd662Svikram 		case 0:
6201eb2bd662Svikram 			e_flag = 1;
6202eb2bd662Svikram 			BAM_DPRINTF((D_EFI_READ_SUCCESS, fcn, s0path));
6203eb2bd662Svikram 			break;
6204eb2bd662Svikram 		default:
6205eb2bd662Svikram 			BAM_DPRINTF((D_EFI_UNKNOWN_RETCODE, fcn, s0path));
6206eb2bd662Svikram 			break;
6207eb2bd662Svikram 		}
6208eb2bd662Svikram 	}
6209eb2bd662Svikram 
6210eb2bd662Svikram 	(void) close(fd);
6211eb2bd662Svikram 
6212eb2bd662Svikram 	if (v_flag) {
6213eb2bd662Svikram 		retval = process_vtoc_slices(s0,
6214eb2bd662Svikram 		    &vtoc, tfp, mhp, tmpmnt);
6215eb2bd662Svikram 	} else if (e_flag) {
6216eb2bd662Svikram 		retval = process_efi_slices(s0,
6217eb2bd662Svikram 		    efi, tfp, mhp, tmpmnt);
6218eb2bd662Svikram 	} else {
6219eb2bd662Svikram 		BAM_DPRINTF((D_NOT_VTOC_OR_EFI, fcn, s0path));
6220eb2bd662Svikram 		return (0);
6221eb2bd662Svikram 	}
6222eb2bd662Svikram 
6223eb2bd662Svikram 	return (retval);
6224eb2bd662Svikram }
6225eb2bd662Svikram 
6226eb2bd662Svikram /*
6227eb2bd662Svikram  * Find and create a list of all existing UFS boot signatures
6228eb2bd662Svikram  */
6229eb2bd662Svikram static int
6230eb2bd662Svikram FindAllUfsSignatures(void)
6231eb2bd662Svikram {
6232eb2bd662Svikram 	mhash_t		*mnttab_hash;
6233eb2bd662Svikram 	DIR		*dirp = NULL;
6234eb2bd662Svikram 	struct dirent	*dp;
6235eb2bd662Svikram 	char		tmpmnt[PATH_MAX];
6236eb2bd662Svikram 	char		cmd[PATH_MAX];
6237eb2bd662Svikram 	struct stat	sb;
6238eb2bd662Svikram 	int		fd;
6239eb2bd662Svikram 	FILE		*tfp;
6240eb2bd662Svikram 	size_t		len;
6241eb2bd662Svikram 	int		ret;
6242eb2bd662Svikram 	int		error;
6243eb2bd662Svikram 	const char	*fcn = "FindAllUfsSignatures()";
6244eb2bd662Svikram 
6245eb2bd662Svikram 	if (stat(UFS_SIGNATURE_LIST, &sb) != -1)  {
6246eb2bd662Svikram 		bam_print(SIGNATURE_LIST_EXISTS, UFS_SIGNATURE_LIST);
6247eb2bd662Svikram 		return (0);
6248eb2bd662Svikram 	}
6249eb2bd662Svikram 
6250eb2bd662Svikram 	fd = open(UFS_SIGNATURE_LIST".tmp",
6251eb2bd662Svikram 	    O_RDWR|O_CREAT|O_TRUNC, 0644);
6252eb2bd662Svikram 	error = errno;
6253eb2bd662Svikram 	INJECT_ERROR1("SIGN_LIST_TMP_TRUNC", fd = -1);
6254eb2bd662Svikram 	if (fd == -1) {
6255eb2bd662Svikram 		bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error));
6256eb2bd662Svikram 		return (-1);
6257eb2bd662Svikram 	}
6258eb2bd662Svikram 
6259eb2bd662Svikram 	ret = close(fd);
6260eb2bd662Svikram 	error = errno;
6261eb2bd662Svikram 	INJECT_ERROR1("SIGN_LIST_TMP_CLOSE", ret = -1);
6262eb2bd662Svikram 	if (ret == -1) {
6263eb2bd662Svikram 		bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp",
6264eb2bd662Svikram 		    strerror(error));
6265eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6266eb2bd662Svikram 		return (-1);
6267eb2bd662Svikram 	}
6268eb2bd662Svikram 
6269eb2bd662Svikram 	tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a");
6270eb2bd662Svikram 	error = errno;
6271eb2bd662Svikram 	INJECT_ERROR1("SIGN_LIST_APPEND_FOPEN", tfp = NULL);
6272eb2bd662Svikram 	if (tfp == NULL) {
6273eb2bd662Svikram 		bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error));
6274eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6275eb2bd662Svikram 		return (-1);
6276eb2bd662Svikram 	}
6277eb2bd662Svikram 
6278eb2bd662Svikram 	mnttab_hash = cache_mnttab();
6279eb2bd662Svikram 	INJECT_ERROR1("CACHE_MNTTAB_ERROR", mnttab_hash = NULL);
6280eb2bd662Svikram 	if (mnttab_hash == NULL) {
6281eb2bd662Svikram 		(void) fclose(tfp);
6282eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6283eb2bd662Svikram 		bam_error(CACHE_MNTTAB_FAIL, fcn);
6284eb2bd662Svikram 		return (-1);
6285eb2bd662Svikram 	}
6286eb2bd662Svikram 
6287eb2bd662Svikram 	(void) snprintf(tmpmnt, sizeof (tmpmnt),
6288eb2bd662Svikram 	    "/tmp/bootadm_ufs_sign_mnt.%d", getpid());
6289eb2bd662Svikram 	(void) unlink(tmpmnt);
6290eb2bd662Svikram 
629148847494SEnrico Perla - Sun Microsystems 	ret = mkdirp(tmpmnt, DIR_PERMS);
6292eb2bd662Svikram 	error = errno;
6293eb2bd662Svikram 	INJECT_ERROR1("MKDIRP_SIGN_MNT", ret = -1);
6294eb2bd662Svikram 	if (ret == -1) {
6295eb2bd662Svikram 		bam_error(MKDIR_FAILED, tmpmnt, strerror(error));
6296eb2bd662Svikram 		free_mnttab(mnttab_hash);
6297eb2bd662Svikram 		(void) fclose(tfp);
6298eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6299eb2bd662Svikram 		return (-1);
6300eb2bd662Svikram 	}
6301eb2bd662Svikram 
6302eb2bd662Svikram 	dirp = opendir("/dev/rdsk");
6303eb2bd662Svikram 	error = errno;
6304eb2bd662Svikram 	INJECT_ERROR1("OPENDIR_DEV_RDSK", dirp = NULL);
6305eb2bd662Svikram 	if (dirp == NULL) {
6306eb2bd662Svikram 		bam_error(OPENDIR_FAILED, "/dev/rdsk", strerror(error));
6307eb2bd662Svikram 		goto fail;
6308eb2bd662Svikram 	}
6309eb2bd662Svikram 
6310eb2bd662Svikram 	while (dp = readdir(dirp)) {
6311eb2bd662Svikram 		if (strcmp(dp->d_name, ".") == 0 ||
6312eb2bd662Svikram 		    strcmp(dp->d_name, "..") == 0)
6313eb2bd662Svikram 			continue;
6314eb2bd662Svikram 
6315eb2bd662Svikram 		/*
6316eb2bd662Svikram 		 * we only look for the s0 slice. This is guranteed to
6317eb2bd662Svikram 		 * have 's' at len - 2.
6318eb2bd662Svikram 		 */
6319eb2bd662Svikram 		len = strlen(dp->d_name);
6320eb2bd662Svikram 		if (dp->d_name[len - 2 ] != 's' || dp->d_name[len - 1] != '0') {
6321eb2bd662Svikram 			BAM_DPRINTF((D_SKIP_SLICE_NOTZERO, fcn, dp->d_name));
6322eb2bd662Svikram 			continue;
6323eb2bd662Svikram 		}
6324eb2bd662Svikram 
6325eb2bd662Svikram 		ret = process_slice0(dp->d_name, tfp, mnttab_hash, tmpmnt);
6326eb2bd662Svikram 		INJECT_ERROR1("PROCESS_S0_FAIL", ret = -1);
6327eb2bd662Svikram 		if (ret == -1)
6328eb2bd662Svikram 			goto fail;
6329eb2bd662Svikram 	}
6330eb2bd662Svikram 
6331eb2bd662Svikram 	(void) closedir(dirp);
6332eb2bd662Svikram 	free_mnttab(mnttab_hash);
6333eb2bd662Svikram 	(void) rmdir(tmpmnt);
6334eb2bd662Svikram 
6335eb2bd662Svikram 	ret = fclose(tfp);
6336eb2bd662Svikram 	error = errno;
6337eb2bd662Svikram 	INJECT_ERROR1("FCLOSE_SIGNLIST_TMP", ret = EOF);
6338eb2bd662Svikram 	if (ret == EOF) {
6339eb2bd662Svikram 		bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp",
6340eb2bd662Svikram 		    strerror(error));
6341eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6342eb2bd662Svikram 		return (-1);
6343eb2bd662Svikram 	}
6344eb2bd662Svikram 
6345eb2bd662Svikram 	/* We have a list of existing GRUB signatures. Sort it first */
6346eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
6347eb2bd662Svikram 	    "/usr/bin/sort -u %s.tmp > %s.sorted",
6348eb2bd662Svikram 	    UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST);
6349eb2bd662Svikram 
6350eb2bd662Svikram 	ret = exec_cmd(cmd, NULL);
6351eb2bd662Svikram 	INJECT_ERROR1("SORT_SIGN_LIST", ret = 1);
6352eb2bd662Svikram 	if (ret != 0) {
6353eb2bd662Svikram 		bam_error(GRUBSIGN_SORT_FAILED);
6354eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".sorted");
6355eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6356eb2bd662Svikram 		return (-1);
6357eb2bd662Svikram 	}
6358eb2bd662Svikram 
6359eb2bd662Svikram 	(void) unlink(UFS_SIGNATURE_LIST".tmp");
6360eb2bd662Svikram 
6361eb2bd662Svikram 	ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST);
6362eb2bd662Svikram 	error = errno;
6363eb2bd662Svikram 	INJECT_ERROR1("RENAME_TMP_SIGNLIST", ret = -1);
6364eb2bd662Svikram 	if (ret == -1) {
6365eb2bd662Svikram 		bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST, strerror(error));
6366eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".sorted");
6367eb2bd662Svikram 		return (-1);
6368eb2bd662Svikram 	}
6369eb2bd662Svikram 
6370eb2bd662Svikram 	if (stat(UFS_SIGNATURE_LIST, &sb) == 0 && sb.st_size == 0) {
6371eb2bd662Svikram 		BAM_DPRINTF((D_ZERO_LEN_SIGNLIST, fcn, UFS_SIGNATURE_LIST));
6372eb2bd662Svikram 	}
6373eb2bd662Svikram 
6374eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6375eb2bd662Svikram 	return (0);
6376eb2bd662Svikram 
6377eb2bd662Svikram fail:
6378eb2bd662Svikram 	if (dirp)
6379eb2bd662Svikram 		(void) closedir(dirp);
6380eb2bd662Svikram 	free_mnttab(mnttab_hash);
6381eb2bd662Svikram 	(void) rmdir(tmpmnt);
6382eb2bd662Svikram 	(void) fclose(tfp);
6383eb2bd662Svikram 	(void) unlink(UFS_SIGNATURE_LIST".tmp");
6384eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_FAILURE, fcn));
6385eb2bd662Svikram 	return (-1);
6386eb2bd662Svikram }
6387eb2bd662Svikram 
6388eb2bd662Svikram static char *
6389eb2bd662Svikram create_ufs_sign(void)
6390eb2bd662Svikram {
6391eb2bd662Svikram 	struct stat	sb;
6392eb2bd662Svikram 	int		signnum = -1;
6393eb2bd662Svikram 	char		tmpsign[MAXNAMELEN + 1];
6394eb2bd662Svikram 	char		*numstr;
6395eb2bd662Svikram 	int		i;
6396eb2bd662Svikram 	FILE		*tfp;
6397eb2bd662Svikram 	int		ret;
6398eb2bd662Svikram 	int		error;
6399eb2bd662Svikram 	const char	*fcn = "create_ufs_sign()";
6400eb2bd662Svikram 
6401eb2bd662Svikram 	bam_print(SEARCHING_UFS_SIGN);
6402eb2bd662Svikram 
6403eb2bd662Svikram 	ret = FindAllUfsSignatures();
6404eb2bd662Svikram 	INJECT_ERROR1("FIND_ALL_UFS", ret = -1);
6405eb2bd662Svikram 	if (ret == -1) {
6406eb2bd662Svikram 		bam_error(ERR_FIND_UFS_SIGN);
6407eb2bd662Svikram 		return (NULL);
6408eb2bd662Svikram 	}
6409eb2bd662Svikram 
6410eb2bd662Svikram 	/* Make sure the list exists and is owned by root */
6411eb2bd662Svikram 	INJECT_ERROR1("SIGNLIST_NOT_CREATED",
6412eb2bd662Svikram 	    (void) unlink(UFS_SIGNATURE_LIST));
6413eb2bd662Svikram 	if (stat(UFS_SIGNATURE_LIST, &sb) == -1 || sb.st_uid != 0) {
6414eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
6415eb2bd662Svikram 		bam_error(UFS_SIGNATURE_LIST_MISS, UFS_SIGNATURE_LIST);
6416eb2bd662Svikram 		return (NULL);
6417eb2bd662Svikram 	}
6418eb2bd662Svikram 
6419eb2bd662Svikram 	if (sb.st_size == 0) {
6420eb2bd662Svikram 		bam_print(GRUBSIGN_UFS_NONE);
6421eb2bd662Svikram 		i = 0;
6422eb2bd662Svikram 		goto found;
6423eb2bd662Svikram 	}
6424eb2bd662Svikram 
6425eb2bd662Svikram 	/* The signature list was sorted when it was created */
6426eb2bd662Svikram 	tfp = fopen(UFS_SIGNATURE_LIST, "r");
6427eb2bd662Svikram 	error = errno;
6428eb2bd662Svikram 	INJECT_ERROR1("FOPEN_SIGN_LIST", tfp = NULL);
6429eb2bd662Svikram 	if (tfp == NULL) {
6430eb2bd662Svikram 		bam_error(UFS_SIGNATURE_LIST_OPENERR,
6431eb2bd662Svikram 		    UFS_SIGNATURE_LIST, strerror(error));
6432eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
6433eb2bd662Svikram 		return (NULL);
6434eb2bd662Svikram 	}
6435eb2bd662Svikram 
6436eb2bd662Svikram 	for (i = 0; s_fgets(tmpsign, sizeof (tmpsign), tfp); i++) {
6437eb2bd662Svikram 
6438eb2bd662Svikram 		if (strncmp(tmpsign, GRUBSIGN_UFS_PREFIX,
6439eb2bd662Svikram 		    strlen(GRUBSIGN_UFS_PREFIX)) != 0) {
6440eb2bd662Svikram 			(void) fclose(tfp);
6441eb2bd662Svikram 			(void) unlink(UFS_SIGNATURE_LIST);
6442eb2bd662Svikram 			bam_error(UFS_BADSIGN, tmpsign);
6443eb2bd662Svikram 			return (NULL);
6444eb2bd662Svikram 		}
6445eb2bd662Svikram 		numstr = tmpsign + strlen(GRUBSIGN_UFS_PREFIX);
6446eb2bd662Svikram 
6447eb2bd662Svikram 		if (numstr[0] == '\0' || !isdigit(numstr[0])) {
6448eb2bd662Svikram 			(void) fclose(tfp);
6449eb2bd662Svikram 			(void) unlink(UFS_SIGNATURE_LIST);
6450eb2bd662Svikram 			bam_error(UFS_BADSIGN, tmpsign);
6451eb2bd662Svikram 			return (NULL);
6452eb2bd662Svikram 		}
6453eb2bd662Svikram 
6454eb2bd662Svikram 		signnum = atoi(numstr);
6455eb2bd662Svikram 		INJECT_ERROR1("NEGATIVE_SIGN", signnum = -1);
6456eb2bd662Svikram 		if (signnum < 0) {
6457eb2bd662Svikram 			(void) fclose(tfp);
6458eb2bd662Svikram 			(void) unlink(UFS_SIGNATURE_LIST);
6459eb2bd662Svikram 			bam_error(UFS_BADSIGN, tmpsign);
6460eb2bd662Svikram 			return (NULL);
6461eb2bd662Svikram 		}
6462eb2bd662Svikram 
6463eb2bd662Svikram 		if (i != signnum) {
6464eb2bd662Svikram 			BAM_DPRINTF((D_FOUND_HOLE_SIGNLIST, fcn, i));
6465eb2bd662Svikram 			break;
6466eb2bd662Svikram 		}
6467eb2bd662Svikram 	}
6468eb2bd662Svikram 
6469eb2bd662Svikram 	(void) fclose(tfp);
6470eb2bd662Svikram 
6471eb2bd662Svikram found:
6472eb2bd662Svikram 	(void) snprintf(tmpsign, sizeof (tmpsign), "rootfs%d", i);
6473eb2bd662Svikram 
6474eb2bd662Svikram 	/* add the ufs signature to the /var/run list of signatures */
6475eb2bd662Svikram 	ret = ufs_add_to_sign_list(tmpsign);
6476eb2bd662Svikram 	INJECT_ERROR1("UFS_ADD_TO_SIGN_LIST", ret = -1);
6477eb2bd662Svikram 	if (ret == -1) {
6478eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
6479eb2bd662Svikram 		bam_error(FAILED_ADD_SIGNLIST, tmpsign);
6480eb2bd662Svikram 		return (NULL);
6481eb2bd662Svikram 	}
6482eb2bd662Svikram 
6483eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6484eb2bd662Svikram 
6485eb2bd662Svikram 	return (s_strdup(tmpsign));
6486eb2bd662Svikram }
6487eb2bd662Svikram 
6488eb2bd662Svikram static char *
6489eb2bd662Svikram get_fstype(char *osroot)
6490eb2bd662Svikram {
6491eb2bd662Svikram 	FILE		*mntfp;
6492eb2bd662Svikram 	struct mnttab	mp = {0};
6493eb2bd662Svikram 	struct mnttab	mpref = {0};
6494eb2bd662Svikram 	int		error;
6495eb2bd662Svikram 	int		ret;
6496eb2bd662Svikram 	const char	*fcn = "get_fstype()";
6497eb2bd662Svikram 
6498eb2bd662Svikram 	INJECT_ERROR1("GET_FSTYPE_OSROOT", osroot = NULL);
6499eb2bd662Svikram 	if (osroot == NULL) {
6500eb2bd662Svikram 		bam_error(GET_FSTYPE_ARGS);
6501eb2bd662Svikram 		return (NULL);
6502eb2bd662Svikram 	}
6503eb2bd662Svikram 
6504eb2bd662Svikram 	mntfp = fopen(MNTTAB, "r");
6505eb2bd662Svikram 	error = errno;
6506eb2bd662Svikram 	INJECT_ERROR1("GET_FSTYPE_FOPEN", mntfp = NULL);
6507eb2bd662Svikram 	if (mntfp == NULL) {
6508eb2bd662Svikram 		bam_error(OPEN_FAIL, MNTTAB, strerror(error));
6509eb2bd662Svikram 		return (NULL);
6510eb2bd662Svikram 	}
6511eb2bd662Svikram 
6512eb2bd662Svikram 	if (*osroot == '\0')
6513eb2bd662Svikram 		mpref.mnt_mountp = "/";
6514eb2bd662Svikram 	else
6515eb2bd662Svikram 		mpref.mnt_mountp = osroot;
6516eb2bd662Svikram 
6517eb2bd662Svikram 	ret = getmntany(mntfp, &mp, &mpref);
6518eb2bd662Svikram 	INJECT_ERROR1("GET_FSTYPE_GETMNTANY", ret = 1);
6519eb2bd662Svikram 	if (ret != 0) {
6520eb2bd662Svikram 		bam_error(MNTTAB_MNTPT_NOT_FOUND, osroot, MNTTAB);
6521eb2bd662Svikram 		(void) fclose(mntfp);
6522eb2bd662Svikram 		return (NULL);
6523eb2bd662Svikram 	}
6524eb2bd662Svikram 	(void) fclose(mntfp);
6525eb2bd662Svikram 
6526eb2bd662Svikram 	INJECT_ERROR1("GET_FSTYPE_NULL", mp.mnt_fstype = NULL);
6527eb2bd662Svikram 	if (mp.mnt_fstype == NULL) {
6528eb2bd662Svikram 		bam_error(MNTTAB_FSTYPE_NULL, osroot);
6529eb2bd662Svikram 		return (NULL);
6530eb2bd662Svikram 	}
6531eb2bd662Svikram 
6532eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6533eb2bd662Svikram 
6534eb2bd662Svikram 	return (s_strdup(mp.mnt_fstype));
6535eb2bd662Svikram }
6536eb2bd662Svikram 
6537eb2bd662Svikram static char *
6538eb2bd662Svikram create_zfs_sign(char *osdev)
6539eb2bd662Svikram {
6540eb2bd662Svikram 	char		tmpsign[PATH_MAX];
6541eb2bd662Svikram 	char		*pool;
6542eb2bd662Svikram 	const char	*fcn = "create_zfs_sign()";
6543eb2bd662Svikram 
6544eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, osdev));
6545eb2bd662Svikram 
6546eb2bd662Svikram 	/*
6547eb2bd662Svikram 	 * First find the pool name
6548eb2bd662Svikram 	 */
6549eb2bd662Svikram 	pool = get_pool(osdev);
6550eb2bd662Svikram 	INJECT_ERROR1("CREATE_ZFS_SIGN_GET_POOL", pool = NULL);
6551eb2bd662Svikram 	if (pool == NULL) {
6552eb2bd662Svikram 		bam_error(GET_POOL_FAILED, osdev);
6553eb2bd662Svikram 		return (NULL);
6554eb2bd662Svikram 	}
6555eb2bd662Svikram 
6556eb2bd662Svikram 	(void) snprintf(tmpsign, sizeof (tmpsign), "pool_%s", pool);
6557eb2bd662Svikram 
6558eb2bd662Svikram 	BAM_DPRINTF((D_CREATED_ZFS_SIGN, fcn, tmpsign));
6559eb2bd662Svikram 
6560eb2bd662Svikram 	free(pool);
6561eb2bd662Svikram 
6562eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6563eb2bd662Svikram 
6564eb2bd662Svikram 	return (s_strdup(tmpsign));
6565eb2bd662Svikram }
6566eb2bd662Svikram 
6567eb2bd662Svikram static char *
6568eb2bd662Svikram create_new_sign(char *osdev, char *fstype)
6569eb2bd662Svikram {
6570eb2bd662Svikram 	char		*sign;
6571eb2bd662Svikram 	const char	*fcn = "create_new_sign()";
6572eb2bd662Svikram 
6573eb2bd662Svikram 	INJECT_ERROR1("NEW_SIGN_FSTYPE", fstype = "foofs");
6574eb2bd662Svikram 
6575eb2bd662Svikram 	if (strcmp(fstype, "zfs") == 0) {
6576eb2bd662Svikram 		BAM_DPRINTF((D_CREATE_NEW_ZFS, fcn));
6577eb2bd662Svikram 		sign = create_zfs_sign(osdev);
6578eb2bd662Svikram 	} else if (strcmp(fstype, "ufs") == 0) {
6579eb2bd662Svikram 		BAM_DPRINTF((D_CREATE_NEW_UFS, fcn));
6580eb2bd662Svikram 		sign = create_ufs_sign();
6581eb2bd662Svikram 	} else {
6582eb2bd662Svikram 		bam_error(GRUBSIGN_NOTSUP, fstype);
6583eb2bd662Svikram 		sign = NULL;
6584eb2bd662Svikram 	}
6585eb2bd662Svikram 
6586eb2bd662Svikram 	BAM_DPRINTF((D_CREATED_NEW_SIGN, fcn, sign ? sign : "<NULL>"));
6587eb2bd662Svikram 	return (sign);
6588eb2bd662Svikram }
6589eb2bd662Svikram 
6590eb2bd662Svikram static int
6591eb2bd662Svikram set_backup_common(char *mntpt, char *sign)
6592eb2bd662Svikram {
6593eb2bd662Svikram 	FILE		*bfp;
6594eb2bd662Svikram 	char		backup[PATH_MAX];
6595eb2bd662Svikram 	char		tmpsign[PATH_MAX];
6596eb2bd662Svikram 	int		error;
6597eb2bd662Svikram 	char		*bdir;
6598eb2bd662Svikram 	char		*backup_dup;
6599eb2bd662Svikram 	struct stat	sb;
6600eb2bd662Svikram 	int		ret;
6601eb2bd662Svikram 	const char	*fcn = "set_backup_common()";
6602eb2bd662Svikram 
6603eb2bd662Svikram 	(void) snprintf(backup, sizeof (backup), "%s%s",
6604eb2bd662Svikram 	    mntpt, GRUBSIGN_BACKUP);
6605eb2bd662Svikram 
6606eb2bd662Svikram 	/* First read the backup */
6607eb2bd662Svikram 	bfp = fopen(backup, "r");
6608eb2bd662Svikram 	if (bfp != NULL) {
6609eb2bd662Svikram 		while (s_fgets(tmpsign, sizeof (tmpsign), bfp)) {
6610eb2bd662Svikram 			if (strcmp(tmpsign, sign) == 0) {
6611eb2bd662Svikram 				BAM_DPRINTF((D_FOUND_IN_BACKUP, fcn, sign));
6612eb2bd662Svikram 				(void) fclose(bfp);
6613eb2bd662Svikram 				return (0);
6614eb2bd662Svikram 			}
6615eb2bd662Svikram 		}
6616eb2bd662Svikram 		(void) fclose(bfp);
6617eb2bd662Svikram 		BAM_DPRINTF((D_NOT_FOUND_IN_EXIST_BACKUP, fcn, sign));
6618eb2bd662Svikram 	} else {
6619eb2bd662Svikram 		BAM_DPRINTF((D_BACKUP_NOT_EXIST, fcn, backup));
6620eb2bd662Svikram 	}
6621eb2bd662Svikram 
6622eb2bd662Svikram 	/*
6623eb2bd662Svikram 	 * Didn't find the correct signature. First create
6624eb2bd662Svikram 	 * the directory if necessary.
6625eb2bd662Svikram 	 */
6626eb2bd662Svikram 
6627eb2bd662Svikram 	/* dirname() modifies its argument so dup it */
6628eb2bd662Svikram 	backup_dup = s_strdup(backup);
6629eb2bd662Svikram 	bdir = dirname(backup_dup);
6630eb2bd662Svikram 	assert(bdir);
6631eb2bd662Svikram 
6632eb2bd662Svikram 	ret = stat(bdir, &sb);
6633eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_STAT", ret = -1);
6634eb2bd662Svikram 	if (ret == -1) {
6635eb2bd662Svikram 		BAM_DPRINTF((D_BACKUP_DIR_NOEXIST, fcn, bdir));
663648847494SEnrico Perla - Sun Microsystems 		ret = mkdirp(bdir, DIR_PERMS);
6637eb2bd662Svikram 		error = errno;
6638eb2bd662Svikram 		INJECT_ERROR1("SET_BACKUP_MKDIRP", ret = -1);
6639eb2bd662Svikram 		if (ret == -1) {
6640eb2bd662Svikram 			bam_error(GRUBSIGN_BACKUP_MKDIRERR,
6641eb2bd662Svikram 			    GRUBSIGN_BACKUP, strerror(error));
6642eb2bd662Svikram 			free(backup_dup);
6643eb2bd662Svikram 			return (-1);
6644eb2bd662Svikram 		}
6645eb2bd662Svikram 	}
6646eb2bd662Svikram 	free(backup_dup);
6647eb2bd662Svikram 
6648eb2bd662Svikram 	/*
6649eb2bd662Svikram 	 * Open the backup in append mode to add the correct
6650eb2bd662Svikram 	 * signature;
6651eb2bd662Svikram 	 */
6652eb2bd662Svikram 	bfp = fopen(backup, "a");
6653eb2bd662Svikram 	error = errno;
6654eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_FOPEN_A", bfp = NULL);
6655eb2bd662Svikram 	if (bfp == NULL) {
6656eb2bd662Svikram 		bam_error(GRUBSIGN_BACKUP_OPENERR,
6657eb2bd662Svikram 		    GRUBSIGN_BACKUP, strerror(error));
6658eb2bd662Svikram 		return (-1);
6659eb2bd662Svikram 	}
6660eb2bd662Svikram 
6661eb2bd662Svikram 	(void) snprintf(tmpsign, sizeof (tmpsign), "%s\n", sign);
6662eb2bd662Svikram 
6663eb2bd662Svikram 	ret = fputs(tmpsign, bfp);
6664eb2bd662Svikram 	error = errno;
6665eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_FPUTS", ret = 0);
6666eb2bd662Svikram 	if (ret != strlen(tmpsign)) {
6667eb2bd662Svikram 		bam_error(GRUBSIGN_BACKUP_WRITEERR,
6668eb2bd662Svikram 		    GRUBSIGN_BACKUP, strerror(error));
6669eb2bd662Svikram 		(void) fclose(bfp);
6670eb2bd662Svikram 		return (-1);
6671eb2bd662Svikram 	}
6672eb2bd662Svikram 
6673eb2bd662Svikram 	(void) fclose(bfp);
6674eb2bd662Svikram 
6675eb2bd662Svikram 	if (bam_verbose)
6676eb2bd662Svikram 		bam_print(GRUBSIGN_BACKUP_UPDATED, GRUBSIGN_BACKUP);
6677eb2bd662Svikram 
6678eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6679eb2bd662Svikram 
6680eb2bd662Svikram 	return (0);
6681eb2bd662Svikram }
6682eb2bd662Svikram 
6683eb2bd662Svikram static int
6684eb2bd662Svikram set_backup_ufs(char *osroot, char *sign)
6685eb2bd662Svikram {
6686eb2bd662Svikram 	const char	*fcn = "set_backup_ufs()";
6687eb2bd662Svikram 
6688eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, sign));
6689eb2bd662Svikram 	return (set_backup_common(osroot, sign));
6690eb2bd662Svikram }
6691eb2bd662Svikram 
6692eb2bd662Svikram static int
6693eb2bd662Svikram set_backup_zfs(char *osdev, char *sign)
6694eb2bd662Svikram {
6695eb2bd662Svikram 	char		*pool;
6696eb2bd662Svikram 	char		*mntpt;
6697eb2bd662Svikram 	zfs_mnted_t	mnted;
6698eb2bd662Svikram 	int		ret;
6699eb2bd662Svikram 	const char	*fcn = "set_backup_zfs()";
6700eb2bd662Svikram 
6701eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osdev, sign));
6702eb2bd662Svikram 
6703eb2bd662Svikram 	pool = get_pool(osdev);
6704eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_GET_POOL", pool = NULL);
6705eb2bd662Svikram 	if (pool == NULL) {
6706eb2bd662Svikram 		bam_error(GET_POOL_FAILED, osdev);
6707eb2bd662Svikram 		return (-1);
6708eb2bd662Svikram 	}
6709eb2bd662Svikram 
6710eb2bd662Svikram 	mntpt = mount_top_dataset(pool, &mnted);
6711eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_MOUNT_DATASET", mntpt = NULL);
6712eb2bd662Svikram 	if (mntpt == NULL) {
6713eb2bd662Svikram 		bam_error(FAIL_MNT_TOP_DATASET, pool);
6714eb2bd662Svikram 		free(pool);
6715eb2bd662Svikram 		return (-1);
6716eb2bd662Svikram 	}
6717eb2bd662Svikram 
6718eb2bd662Svikram 	ret = set_backup_common(mntpt, sign);
6719eb2bd662Svikram 
6720eb2bd662Svikram 	(void) umount_top_dataset(pool, mnted, mntpt);
6721eb2bd662Svikram 
6722eb2bd662Svikram 	free(pool);
6723eb2bd662Svikram 
6724eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_ZFS_FAIL", ret = 1);
6725eb2bd662Svikram 	if (ret == 0) {
6726eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6727eb2bd662Svikram 	} else {
6728eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
6729eb2bd662Svikram 	}
6730eb2bd662Svikram 
6731eb2bd662Svikram 	return (ret);
6732eb2bd662Svikram }
6733eb2bd662Svikram 
6734eb2bd662Svikram static int
6735eb2bd662Svikram set_backup(char *osroot, char *osdev, char *sign, char *fstype)
6736eb2bd662Svikram {
6737eb2bd662Svikram 	const char	*fcn = "set_backup()";
6738eb2bd662Svikram 	int		ret;
6739eb2bd662Svikram 
6740eb2bd662Svikram 	INJECT_ERROR1("SET_BACKUP_FSTYPE", fstype = "foofs");
6741eb2bd662Svikram 
6742eb2bd662Svikram 	if (strcmp(fstype, "ufs") == 0) {
6743eb2bd662Svikram 		BAM_DPRINTF((D_SET_BACKUP_UFS, fcn));
6744eb2bd662Svikram 		ret = set_backup_ufs(osroot, sign);
6745eb2bd662Svikram 	} else if (strcmp(fstype, "zfs") == 0) {
6746eb2bd662Svikram 		BAM_DPRINTF((D_SET_BACKUP_ZFS, fcn));
6747eb2bd662Svikram 		ret = set_backup_zfs(osdev, sign);
6748eb2bd662Svikram 	} else {
6749eb2bd662Svikram 		bam_error(GRUBSIGN_NOTSUP, fstype);
6750eb2bd662Svikram 		ret = -1;
6751eb2bd662Svikram 	}
6752eb2bd662Svikram 
6753eb2bd662Svikram 	if (ret == 0) {
6754eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6755eb2bd662Svikram 	} else {
6756eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
6757eb2bd662Svikram 	}
6758eb2bd662Svikram 
6759eb2bd662Svikram 	return (ret);
6760eb2bd662Svikram }
6761eb2bd662Svikram 
6762eb2bd662Svikram static int
6763eb2bd662Svikram set_primary_common(char *mntpt, char *sign)
6764eb2bd662Svikram {
6765eb2bd662Svikram 	char		signfile[PATH_MAX];
6766eb2bd662Svikram 	char		signdir[PATH_MAX];
6767eb2bd662Svikram 	struct stat	sb;
6768eb2bd662Svikram 	int		fd;
6769eb2bd662Svikram 	int		error;
6770eb2bd662Svikram 	int		ret;
6771eb2bd662Svikram 	const char	*fcn = "set_primary_common()";
6772eb2bd662Svikram 
6773eb2bd662Svikram 	(void) snprintf(signfile, sizeof (signfile), "%s/%s/%s",
6774eb2bd662Svikram 	    mntpt, GRUBSIGN_DIR, sign);
6775eb2bd662Svikram 
6776eb2bd662Svikram 	if (stat(signfile, &sb) != -1) {
6777eb2bd662Svikram 		if (bam_verbose)
6778eb2bd662Svikram 			bam_print(PRIMARY_SIGN_EXISTS, sign);
6779eb2bd662Svikram 		return (0);
6780eb2bd662Svikram 	} else {
6781eb2bd662Svikram 		BAM_DPRINTF((D_PRIMARY_NOT_EXIST, fcn, signfile));
6782eb2bd662Svikram 	}
6783eb2bd662Svikram 
6784eb2bd662Svikram 	(void) snprintf(signdir, sizeof (signdir), "%s/%s",
6785eb2bd662Svikram 	    mntpt, GRUBSIGN_DIR);
6786eb2bd662Svikram 
6787eb2bd662Svikram 	if (stat(signdir, &sb) == -1) {
6788eb2bd662Svikram 		BAM_DPRINTF((D_PRIMARY_DIR_NOEXIST, fcn, signdir));
678948847494SEnrico Perla - Sun Microsystems 		ret = mkdirp(signdir, DIR_PERMS);
6790eb2bd662Svikram 		error = errno;
6791eb2bd662Svikram 		INJECT_ERROR1("SET_PRIMARY_MKDIRP", ret = -1);
6792eb2bd662Svikram 		if (ret == -1) {
6793eb2bd662Svikram 			bam_error(GRUBSIGN_MKDIR_ERR, signdir, strerror(errno));
6794eb2bd662Svikram 			return (-1);
6795eb2bd662Svikram 		}
6796eb2bd662Svikram 	}
6797eb2bd662Svikram 
6798eb2bd662Svikram 	fd = open(signfile, O_RDWR|O_CREAT|O_TRUNC, 0444);
6799eb2bd662Svikram 	error = errno;
6800eb2bd662Svikram 	INJECT_ERROR1("PRIMARY_SIGN_CREAT", fd = -1);
6801eb2bd662Svikram 	if (fd == -1) {
6802eb2bd662Svikram 		bam_error(GRUBSIGN_PRIMARY_CREATERR, signfile, strerror(error));
6803eb2bd662Svikram 		return (-1);
6804eb2bd662Svikram 	}
6805eb2bd662Svikram 
6806eb2bd662Svikram 	ret = fsync(fd);
6807eb2bd662Svikram 	error = errno;
6808eb2bd662Svikram 	INJECT_ERROR1("PRIMARY_FSYNC", ret = -1);
6809eb2bd662Svikram 	if (ret != 0) {
6810eb2bd662Svikram 		bam_error(GRUBSIGN_PRIMARY_SYNCERR, signfile, strerror(error));
6811eb2bd662Svikram 	}
6812eb2bd662Svikram 
6813eb2bd662Svikram 	(void) close(fd);
6814eb2bd662Svikram 
6815eb2bd662Svikram 	if (bam_verbose)
6816eb2bd662Svikram 		bam_print(GRUBSIGN_CREATED_PRIMARY, signfile);
6817eb2bd662Svikram 
6818eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6819eb2bd662Svikram 
6820eb2bd662Svikram 	return (0);
6821eb2bd662Svikram }
6822eb2bd662Svikram 
6823eb2bd662Svikram static int
6824eb2bd662Svikram set_primary_ufs(char *osroot, char *sign)
6825eb2bd662Svikram {
6826eb2bd662Svikram 	const char	*fcn = "set_primary_ufs()";
6827eb2bd662Svikram 
6828eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, sign));
6829eb2bd662Svikram 	return (set_primary_common(osroot, sign));
6830eb2bd662Svikram }
6831eb2bd662Svikram 
6832eb2bd662Svikram static int
6833eb2bd662Svikram set_primary_zfs(char *osdev, char *sign)
6834eb2bd662Svikram {
6835eb2bd662Svikram 	char		*pool;
6836eb2bd662Svikram 	char		*mntpt;
6837eb2bd662Svikram 	zfs_mnted_t	mnted;
6838eb2bd662Svikram 	int		ret;
6839eb2bd662Svikram 	const char	*fcn = "set_primary_zfs()";
6840eb2bd662Svikram 
6841eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osdev, sign));
6842eb2bd662Svikram 
6843eb2bd662Svikram 	pool = get_pool(osdev);
6844eb2bd662Svikram 	INJECT_ERROR1("SET_PRIMARY_ZFS_GET_POOL", pool = NULL);
6845eb2bd662Svikram 	if (pool == NULL) {
6846eb2bd662Svikram 		bam_error(GET_POOL_FAILED, osdev);
6847eb2bd662Svikram 		return (-1);
6848eb2bd662Svikram 	}
6849eb2bd662Svikram 
6850eb2bd662Svikram 	/* Pool name must exist in the sign */
6851eb2bd662Svikram 	ret = (strstr(sign, pool) != NULL);
6852eb2bd662Svikram 	INJECT_ERROR1("SET_PRIMARY_ZFS_POOL_SIGN_INCOMPAT", ret = 0);
6853eb2bd662Svikram 	if (ret == 0) {
6854eb2bd662Svikram 		bam_error(POOL_SIGN_INCOMPAT, pool, sign);
6855eb2bd662Svikram 		free(pool);
6856eb2bd662Svikram 		return (-1);
6857eb2bd662Svikram 	}
6858eb2bd662Svikram 
6859eb2bd662Svikram 	mntpt = mount_top_dataset(pool, &mnted);
6860eb2bd662Svikram 	INJECT_ERROR1("SET_PRIMARY_ZFS_MOUNT_DATASET", mntpt = NULL);
6861eb2bd662Svikram 	if (mntpt == NULL) {
6862eb2bd662Svikram 		bam_error(FAIL_MNT_TOP_DATASET, pool);
6863eb2bd662Svikram 		free(pool);
6864eb2bd662Svikram 		return (-1);
6865eb2bd662Svikram 	}
6866eb2bd662Svikram 
6867eb2bd662Svikram 	ret = set_primary_common(mntpt, sign);
6868eb2bd662Svikram 
6869eb2bd662Svikram 	(void) umount_top_dataset(pool, mnted, mntpt);
6870eb2bd662Svikram 
6871eb2bd662Svikram 	free(pool);
6872eb2bd662Svikram 
6873eb2bd662Svikram 	INJECT_ERROR1("SET_PRIMARY_ZFS_FAIL", ret = 1);
6874eb2bd662Svikram 	if (ret == 0) {
6875eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6876eb2bd662Svikram 	} else {
6877eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
6878eb2bd662Svikram 	}
6879eb2bd662Svikram 
6880eb2bd662Svikram 	return (ret);
6881eb2bd662Svikram }
6882eb2bd662Svikram 
6883eb2bd662Svikram static int
6884eb2bd662Svikram set_primary(char *osroot, char *osdev, char *sign, char *fstype)
6885eb2bd662Svikram {
6886eb2bd662Svikram 	const char	*fcn = "set_primary()";
6887eb2bd662Svikram 	int		ret;
6888eb2bd662Svikram 
6889eb2bd662Svikram 	INJECT_ERROR1("SET_PRIMARY_FSTYPE", fstype = "foofs");
6890eb2bd662Svikram 	if (strcmp(fstype, "ufs") == 0) {
6891eb2bd662Svikram 		BAM_DPRINTF((D_SET_PRIMARY_UFS, fcn));
6892eb2bd662Svikram 		ret = set_primary_ufs(osroot, sign);
6893eb2bd662Svikram 	} else if (strcmp(fstype, "zfs") == 0) {
6894eb2bd662Svikram 		BAM_DPRINTF((D_SET_PRIMARY_ZFS, fcn));
6895eb2bd662Svikram 		ret = set_primary_zfs(osdev, sign);
6896eb2bd662Svikram 	} else {
6897eb2bd662Svikram 		bam_error(GRUBSIGN_NOTSUP, fstype);
6898eb2bd662Svikram 		ret = -1;
6899eb2bd662Svikram 	}
6900eb2bd662Svikram 
6901eb2bd662Svikram 	if (ret == 0) {
6902eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
6903eb2bd662Svikram 	} else {
6904eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
6905eb2bd662Svikram 	}
6906eb2bd662Svikram 
6907eb2bd662Svikram 	return (ret);
6908eb2bd662Svikram }
6909eb2bd662Svikram 
6910eb2bd662Svikram static int
6911eb2bd662Svikram ufs_add_to_sign_list(char *sign)
6912eb2bd662Svikram {
6913eb2bd662Svikram 	FILE		*tfp;
6914eb2bd662Svikram 	char		signline[MAXNAMELEN];
6915eb2bd662Svikram 	char		cmd[PATH_MAX];
6916eb2bd662Svikram 	int		ret;
6917eb2bd662Svikram 	int		error;
6918eb2bd662Svikram 	const char	*fcn = "ufs_add_to_sign_list()";
6919eb2bd662Svikram 
6920eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_NOT_UFS", sign = "pool_rpool5");
6921eb2bd662Svikram 	if (strncmp(sign, GRUBSIGN_UFS_PREFIX,
6922eb2bd662Svikram 	    strlen(GRUBSIGN_UFS_PREFIX)) != 0) {
6923eb2bd662Svikram 		bam_error(INVALID_UFS_SIGN, sign);
6924eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
6925eb2bd662Svikram 		return (-1);
6926eb2bd662Svikram 	}
6927eb2bd662Svikram 
6928eb2bd662Svikram 	/*
6929eb2bd662Svikram 	 * most failures in this routine are not a fatal error
6930eb2bd662Svikram 	 * We simply unlink the /var/run file and continue
6931eb2bd662Svikram 	 */
6932eb2bd662Svikram 
6933eb2bd662Svikram 	ret = rename(UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST".tmp");
6934eb2bd662Svikram 	error = errno;
6935eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME", ret = -1);
6936eb2bd662Svikram 	if (ret == -1) {
6937eb2bd662Svikram 		bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST".tmp",
6938eb2bd662Svikram 		    strerror(error));
6939eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
6940eb2bd662Svikram 		return (0);
6941eb2bd662Svikram 	}
6942eb2bd662Svikram 
6943eb2bd662Svikram 	tfp = fopen(UFS_SIGNATURE_LIST".tmp", "a");
6944eb2bd662Svikram 	error = errno;
6945eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_FOPEN", tfp = NULL);
6946eb2bd662Svikram 	if (tfp == NULL) {
6947eb2bd662Svikram 		bam_error(OPEN_FAIL, UFS_SIGNATURE_LIST".tmp", strerror(error));
6948eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6949eb2bd662Svikram 		return (0);
6950eb2bd662Svikram 	}
6951eb2bd662Svikram 
6952eb2bd662Svikram 	(void) snprintf(signline, sizeof (signline), "%s\n", sign);
6953eb2bd662Svikram 
6954eb2bd662Svikram 	ret = fputs(signline, tfp);
6955eb2bd662Svikram 	error = errno;
6956eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_FPUTS", ret = 0);
6957eb2bd662Svikram 	if (ret != strlen(signline)) {
6958eb2bd662Svikram 		bam_error(SIGN_LIST_FPUTS_ERR, sign, strerror(error));
6959eb2bd662Svikram 		(void) fclose(tfp);
6960eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6961eb2bd662Svikram 		return (0);
6962eb2bd662Svikram 	}
6963eb2bd662Svikram 
6964eb2bd662Svikram 	ret = fclose(tfp);
6965eb2bd662Svikram 	error = errno;
6966eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_FCLOSE", ret = EOF);
6967eb2bd662Svikram 	if (ret == EOF) {
6968eb2bd662Svikram 		bam_error(CLOSE_FAIL, UFS_SIGNATURE_LIST".tmp",
6969eb2bd662Svikram 		    strerror(error));
6970eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6971eb2bd662Svikram 		return (0);
6972eb2bd662Svikram 	}
6973eb2bd662Svikram 
6974eb2bd662Svikram 	/* Sort the list again */
6975eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd),
6976eb2bd662Svikram 	    "/usr/bin/sort -u %s.tmp > %s.sorted",
6977eb2bd662Svikram 	    UFS_SIGNATURE_LIST, UFS_SIGNATURE_LIST);
6978eb2bd662Svikram 
6979eb2bd662Svikram 	ret = exec_cmd(cmd, NULL);
6980eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_SORT", ret = 1);
6981eb2bd662Svikram 	if (ret != 0) {
6982eb2bd662Svikram 		bam_error(GRUBSIGN_SORT_FAILED);
6983eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".sorted");
6984eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".tmp");
6985eb2bd662Svikram 		return (0);
6986eb2bd662Svikram 	}
6987eb2bd662Svikram 
6988eb2bd662Svikram 	(void) unlink(UFS_SIGNATURE_LIST".tmp");
6989eb2bd662Svikram 
6990eb2bd662Svikram 	ret = rename(UFS_SIGNATURE_LIST".sorted", UFS_SIGNATURE_LIST);
6991eb2bd662Svikram 	error = errno;
6992eb2bd662Svikram 	INJECT_ERROR1("ADD_TO_SIGN_LIST_RENAME2", ret = -1);
6993eb2bd662Svikram 	if (ret == -1) {
6994eb2bd662Svikram 		bam_error(RENAME_FAIL, UFS_SIGNATURE_LIST, strerror(error));
6995eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST".sorted");
6996eb2bd662Svikram 		return (0);
6997eb2bd662Svikram 	}
6998eb2bd662Svikram 
6999eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7000eb2bd662Svikram 
7001eb2bd662Svikram 	return (0);
7002eb2bd662Svikram }
7003eb2bd662Svikram 
7004eb2bd662Svikram static int
7005eb2bd662Svikram set_signature(char *osroot, char *osdev, char *sign, char *fstype)
7006eb2bd662Svikram {
7007eb2bd662Svikram 	int		ret;
7008eb2bd662Svikram 	const char	*fcn = "set_signature()";
7009eb2bd662Svikram 
7010eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY4, fcn, osroot, osdev, sign, fstype));
7011eb2bd662Svikram 
7012eb2bd662Svikram 	ret = set_backup(osroot, osdev, sign, fstype);
7013eb2bd662Svikram 	INJECT_ERROR1("SET_SIGNATURE_BACKUP", ret = -1);
7014eb2bd662Svikram 	if (ret == -1) {
7015eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
7016eb2bd662Svikram 		bam_error(SET_BACKUP_FAILED, sign, osroot, osdev);
7017eb2bd662Svikram 		return (-1);
7018eb2bd662Svikram 	}
7019eb2bd662Svikram 
7020eb2bd662Svikram 	ret = set_primary(osroot, osdev, sign, fstype);
7021eb2bd662Svikram 	INJECT_ERROR1("SET_SIGNATURE_PRIMARY", ret = -1);
7022eb2bd662Svikram 
7023eb2bd662Svikram 	if (ret == 0) {
7024eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7025eb2bd662Svikram 	} else {
7026eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
7027eb2bd662Svikram 		bam_error(SET_PRIMARY_FAILED, sign, osroot, osdev);
7028eb2bd662Svikram 
7029eb2bd662Svikram 	}
7030eb2bd662Svikram 	return (ret);
7031eb2bd662Svikram }
7032eb2bd662Svikram 
7033eb2bd662Svikram char *
7034eb2bd662Svikram get_grubsign(char *osroot, char *osdev)
7035eb2bd662Svikram {
7036eb2bd662Svikram 	char		*grubsign;	/* (<sign>,#,#) */
7037eb2bd662Svikram 	char		*slice;
7038eb2bd662Svikram 	int		fdiskpart;
7039eb2bd662Svikram 	char		*sign;
7040eb2bd662Svikram 	char		*fstype;
7041eb2bd662Svikram 	int		ret;
7042eb2bd662Svikram 	const char	*fcn = "get_grubsign()";
7043eb2bd662Svikram 
7044eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, osdev));
7045eb2bd662Svikram 	fstype = get_fstype(osroot);
7046eb2bd662Svikram 	INJECT_ERROR1("GET_GRUBSIGN_FSTYPE", fstype = NULL);
7047eb2bd662Svikram 	if (fstype == NULL) {
7048eb2bd662Svikram 		bam_error(GET_FSTYPE_FAILED, osroot);
7049eb2bd662Svikram 		return (NULL);
7050eb2bd662Svikram 	}
7051eb2bd662Svikram 
7052eb2bd662Svikram 	sign = find_existing_sign(osroot, osdev, fstype);
7053eb2bd662Svikram 	INJECT_ERROR1("FIND_EXISTING_SIGN", sign = NULL);
7054eb2bd662Svikram 	if (sign == NULL) {
7055eb2bd662Svikram 		BAM_DPRINTF((D_GET_GRUBSIGN_NO_EXISTING, fcn, osroot, osdev));
7056eb2bd662Svikram 		sign = create_new_sign(osdev, fstype);
7057eb2bd662Svikram 		INJECT_ERROR1("CREATE_NEW_SIGN", sign = NULL);
7058eb2bd662Svikram 		if (sign == NULL) {
7059eb2bd662Svikram 			bam_error(GRUBSIGN_CREATE_FAIL, osdev);
7060eb2bd662Svikram 			free(fstype);
7061eb2bd662Svikram 			return (NULL);
7062eb2bd662Svikram 		}
7063eb2bd662Svikram 	}
7064eb2bd662Svikram 
7065eb2bd662Svikram 	ret = set_signature(osroot, osdev, sign, fstype);
7066eb2bd662Svikram 	INJECT_ERROR1("SET_SIGNATURE_FAIL", ret = -1);
7067eb2bd662Svikram 	if (ret == -1) {
7068eb2bd662Svikram 		bam_error(GRUBSIGN_WRITE_FAIL, osdev);
7069eb2bd662Svikram 		free(sign);
7070eb2bd662Svikram 		free(fstype);
7071eb2bd662Svikram 		(void) unlink(UFS_SIGNATURE_LIST);
7072eb2bd662Svikram 		return (NULL);
7073eb2bd662Svikram 	}
7074eb2bd662Svikram 
7075eb2bd662Svikram 	free(fstype);
7076eb2bd662Svikram 
7077eb2bd662Svikram 	if (bam_verbose)
7078eb2bd662Svikram 		bam_print(GRUBSIGN_FOUND_OR_CREATED, sign, osdev);
7079eb2bd662Svikram 
7080eb2bd662Svikram 	fdiskpart = get_partition(osdev);
7081eb2bd662Svikram 	INJECT_ERROR1("GET_GRUBSIGN_FDISK", fdiskpart = -1);
7082eb2bd662Svikram 	if (fdiskpart == -1) {
7083eb2bd662Svikram 		bam_error(FDISKPART_FAIL, osdev);
7084eb2bd662Svikram 		free(sign);
7085eb2bd662Svikram 		return (NULL);
7086eb2bd662Svikram 	}
7087eb2bd662Svikram 
7088eb2bd662Svikram 	slice = strrchr(osdev, 's');
7089eb2bd662Svikram 
7090eb2bd662Svikram 	grubsign = s_calloc(1, MAXNAMELEN + 10);
7091eb2bd662Svikram 	if (slice) {
7092eb2bd662Svikram 		(void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d,%c)",
7093eb2bd662Svikram 		    sign, fdiskpart, slice[1] + 'a' - '0');
7094eb2bd662Svikram 	} else
7095eb2bd662Svikram 		(void) snprintf(grubsign, MAXNAMELEN + 10, "(%s,%d)",
7096eb2bd662Svikram 		    sign, fdiskpart);
7097eb2bd662Svikram 
7098eb2bd662Svikram 	free(sign);
7099eb2bd662Svikram 
7100eb2bd662Svikram 	BAM_DPRINTF((D_GET_GRUBSIGN_SUCCESS, fcn, grubsign));
7101eb2bd662Svikram 
7102eb2bd662Svikram 	return (grubsign);
71037c478bd9Sstevel@tonic-gate }
71047c478bd9Sstevel@tonic-gate 
7105ee3b8144Sszhou static char *
7106ee3b8144Sszhou get_title(char *rootdir)
71077c478bd9Sstevel@tonic-gate {
7108eb2bd662Svikram 	static char	title[80];
7109eb2bd662Svikram 	char		*cp = NULL;
7110eb2bd662Svikram 	char		release[PATH_MAX];
71117c478bd9Sstevel@tonic-gate 	FILE		*fp;
7112eb2bd662Svikram 	const char	*fcn = "get_title()";
71137c478bd9Sstevel@tonic-gate 
71147c478bd9Sstevel@tonic-gate 	/* open the /etc/release file */
71157c478bd9Sstevel@tonic-gate 	(void) snprintf(release, sizeof (release), "%s/etc/release", rootdir);
71167c478bd9Sstevel@tonic-gate 
71177c478bd9Sstevel@tonic-gate 	fp = fopen(release, "r");
7118eb2bd662Svikram 	if (fp == NULL) {
7119eb2bd662Svikram 		bam_error(OPEN_FAIL, release, strerror(errno));
7120eb2bd662Svikram 		cp = NULL;
7121eb2bd662Svikram 		goto out;
7122eb2bd662Svikram 	}
71237c478bd9Sstevel@tonic-gate 
71247c478bd9Sstevel@tonic-gate 	while (s_fgets(title, sizeof (title), fp) != NULL) {
71257c478bd9Sstevel@tonic-gate 		cp = strstr(title, "Solaris");
71267c478bd9Sstevel@tonic-gate 		if (cp)
71277c478bd9Sstevel@tonic-gate 			break;
71287c478bd9Sstevel@tonic-gate 	}
71297c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
7130eb2bd662Svikram 
7131eb2bd662Svikram out:
7132eb2bd662Svikram 	cp = cp ? cp : "Solaris";
7133eb2bd662Svikram 
7134eb2bd662Svikram 	BAM_DPRINTF((D_GET_TITLE, fcn, cp));
7135eb2bd662Svikram 
7136eb2bd662Svikram 	return (cp);
71377c478bd9Sstevel@tonic-gate }
71387c478bd9Sstevel@tonic-gate 
7139ae115bc7Smrj char *
71407c478bd9Sstevel@tonic-gate get_special(char *mountp)
71417c478bd9Sstevel@tonic-gate {
71427c478bd9Sstevel@tonic-gate 	FILE		*mntfp;
7143eb2bd662Svikram 	struct mnttab	mp = {0};
7144eb2bd662Svikram 	struct mnttab	mpref = {0};
7145eb2bd662Svikram 	int		error;
7146eb2bd662Svikram 	int		ret;
7147eb2bd662Svikram 	const char 	*fcn = "get_special()";
7148eb2bd662Svikram 
7149eb2bd662Svikram 	INJECT_ERROR1("GET_SPECIAL_MNTPT", mountp = NULL);
7150eb2bd662Svikram 	if (mountp == NULL) {
7151eb2bd662Svikram 		bam_error(GET_SPECIAL_NULL_MNTPT);
7152eb2bd662Svikram 		return (NULL);
7153eb2bd662Svikram 	}
71547c478bd9Sstevel@tonic-gate 
71557c478bd9Sstevel@tonic-gate 	mntfp = fopen(MNTTAB, "r");
7156eb2bd662Svikram 	error = errno;
7157eb2bd662Svikram 	INJECT_ERROR1("GET_SPECIAL_MNTTAB_OPEN", mntfp = NULL);
71587c478bd9Sstevel@tonic-gate 	if (mntfp == NULL) {
7159eb2bd662Svikram 		bam_error(OPEN_FAIL, MNTTAB, strerror(error));
7160eb2bd662Svikram 		return (NULL);
71617c478bd9Sstevel@tonic-gate 	}
71627c478bd9Sstevel@tonic-gate 
71637c478bd9Sstevel@tonic-gate 	if (*mountp == '\0')
71647c478bd9Sstevel@tonic-gate 		mpref.mnt_mountp = "/";
71657c478bd9Sstevel@tonic-gate 	else
71667c478bd9Sstevel@tonic-gate 		mpref.mnt_mountp = mountp;
7167eb2bd662Svikram 
7168eb2bd662Svikram 	ret = getmntany(mntfp, &mp, &mpref);
7169eb2bd662Svikram 	INJECT_ERROR1("GET_SPECIAL_MNTTAB_SEARCH", ret = 1);
7170eb2bd662Svikram 	if (ret != 0) {
71717c478bd9Sstevel@tonic-gate 		(void) fclose(mntfp);
7172eb2bd662Svikram 		BAM_DPRINTF((D_GET_SPECIAL_NOT_IN_MNTTAB, fcn, mountp));
71737c478bd9Sstevel@tonic-gate 		return (NULL);
71747c478bd9Sstevel@tonic-gate 	}
71757c478bd9Sstevel@tonic-gate 	(void) fclose(mntfp);
71767c478bd9Sstevel@tonic-gate 
7177eb2bd662Svikram 	BAM_DPRINTF((D_GET_SPECIAL, fcn, mp.mnt_special));
7178eb2bd662Svikram 
71797c478bd9Sstevel@tonic-gate 	return (s_strdup(mp.mnt_special));
71807c478bd9Sstevel@tonic-gate }
71817c478bd9Sstevel@tonic-gate 
7182eb2bd662Svikram static void
7183eb2bd662Svikram free_physarray(char **physarray, int n)
71847c478bd9Sstevel@tonic-gate {
7185eb2bd662Svikram 	int			i;
7186eb2bd662Svikram 	const char		*fcn = "free_physarray()";
71877c478bd9Sstevel@tonic-gate 
7188eb2bd662Svikram 	assert(physarray);
7189eb2bd662Svikram 	assert(n);
7190eb2bd662Svikram 
7191eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY_N1, fcn, n));
7192eb2bd662Svikram 
7193eb2bd662Svikram 	for (i = 0; i < n; i++) {
7194eb2bd662Svikram 		free(physarray[i]);
71957c478bd9Sstevel@tonic-gate 	}
7196eb2bd662Svikram 	free(physarray);
7197eb2bd662Svikram 
7198eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7199eb2bd662Svikram }
7200eb2bd662Svikram 
7201eb2bd662Svikram static int
7202eb2bd662Svikram zfs_get_physical(char *special, char ***physarray, int *n)
7203eb2bd662Svikram {
7204eb2bd662Svikram 	char			sdup[PATH_MAX];
7205eb2bd662Svikram 	char			cmd[PATH_MAX];
7206eb2bd662Svikram 	char			dsk[PATH_MAX];
7207eb2bd662Svikram 	char			*pool;
7208eb2bd662Svikram 	filelist_t		flist = {0};
7209eb2bd662Svikram 	line_t			*lp;
7210eb2bd662Svikram 	line_t			*startlp;
7211eb2bd662Svikram 	char			*comp1;
7212eb2bd662Svikram 	int			i;
7213eb2bd662Svikram 	int			ret;
7214eb2bd662Svikram 	const char		*fcn = "zfs_get_physical()";
7215eb2bd662Svikram 
7216eb2bd662Svikram 	assert(special);
7217eb2bd662Svikram 
7218eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, special));
7219eb2bd662Svikram 
7220eb2bd662Svikram 	INJECT_ERROR1("INVALID_ZFS_SPECIAL", special = "/foo");
7221eb2bd662Svikram 	if (special[0] == '/') {
7222eb2bd662Svikram 		bam_error(INVALID_ZFS_SPECIAL, special);
7223eb2bd662Svikram 		return (-1);
7224eb2bd662Svikram 	}
7225eb2bd662Svikram 
7226eb2bd662Svikram 	(void) strlcpy(sdup, special, sizeof (sdup));
7227eb2bd662Svikram 
7228eb2bd662Svikram 	pool = strtok(sdup, "/");
7229eb2bd662Svikram 	INJECT_ERROR1("ZFS_GET_PHYS_POOL", pool = NULL);
7230eb2bd662Svikram 	if (pool == NULL) {
7231eb2bd662Svikram 		bam_error(CANT_FIND_POOL_FROM_SPECIAL, special);
7232eb2bd662Svikram 		return (-1);
7233eb2bd662Svikram 	}
7234eb2bd662Svikram 
7235eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd), "/sbin/zpool status %s", pool);
7236eb2bd662Svikram 
7237eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
7238eb2bd662Svikram 	INJECT_ERROR1("ZFS_GET_PHYS_STATUS", ret = 1);
7239eb2bd662Svikram 	if (ret != 0) {
7240eb2bd662Svikram 		bam_error(ZFS_GET_POOL_STATUS, pool);
7241eb2bd662Svikram 		return (-1);
7242eb2bd662Svikram 	}
7243eb2bd662Svikram 
7244eb2bd662Svikram 	INJECT_ERROR1("ZFS_GET_PHYS_STATUS_OUT", flist.head = NULL);
7245eb2bd662Svikram 	if (flist.head == NULL) {
7246eb2bd662Svikram 		bam_error(BAD_ZPOOL_STATUS, pool);
7247eb2bd662Svikram 		filelist_free(&flist);
7248eb2bd662Svikram 		return (-1);
7249eb2bd662Svikram 	}
7250eb2bd662Svikram 
7251eb2bd662Svikram 	for (lp = flist.head; lp; lp = lp->next) {
7252eb2bd662Svikram 		BAM_DPRINTF((D_STRTOK_ZPOOL_STATUS, fcn, lp->line));
7253eb2bd662Svikram 		comp1 = strtok(lp->line, " \t");
7254eb2bd662Svikram 		if (comp1 == NULL) {
7255eb2bd662Svikram 			free(lp->line);
7256eb2bd662Svikram 			lp->line = NULL;
7257eb2bd662Svikram 		} else {
7258eb2bd662Svikram 			comp1 = s_strdup(comp1);
7259eb2bd662Svikram 			free(lp->line);
7260eb2bd662Svikram 			lp->line = comp1;
7261eb2bd662Svikram 		}
7262eb2bd662Svikram 	}
7263eb2bd662Svikram 
7264eb2bd662Svikram 	for (lp = flist.head; lp; lp = lp->next) {
7265eb2bd662Svikram 		if (lp->line == NULL)
7266eb2bd662Svikram 			continue;
7267eb2bd662Svikram 		if (strcmp(lp->line, pool) == 0) {
7268eb2bd662Svikram 			BAM_DPRINTF((D_FOUND_POOL_IN_ZPOOL_STATUS, fcn, pool));
7269eb2bd662Svikram 			break;
7270eb2bd662Svikram 		}
7271eb2bd662Svikram 	}
7272eb2bd662Svikram 
7273eb2bd662Svikram 	if (lp == NULL) {
7274eb2bd662Svikram 		bam_error(NO_POOL_IN_ZPOOL_STATUS, pool);
7275eb2bd662Svikram 		filelist_free(&flist);
7276eb2bd662Svikram 		return (-1);
7277eb2bd662Svikram 	}
7278eb2bd662Svikram 
7279eb2bd662Svikram 	startlp = lp->next;
7280eb2bd662Svikram 	for (i = 0, lp = startlp; lp; lp = lp->next) {
7281eb2bd662Svikram 		if (lp->line == NULL)
7282eb2bd662Svikram 			continue;
7283eb2bd662Svikram 		if (strcmp(lp->line, "mirror") == 0)
7284eb2bd662Svikram 			continue;
7285eb2bd662Svikram 		if (lp->line[0] == '\0' || strcmp(lp->line, "errors:") == 0)
7286eb2bd662Svikram 			break;
7287eb2bd662Svikram 		i++;
7288eb2bd662Svikram 		BAM_DPRINTF((D_COUNTING_ZFS_PHYS, fcn, i));
7289eb2bd662Svikram 	}
7290eb2bd662Svikram 
7291eb2bd662Svikram 	if (i == 0) {
7292eb2bd662Svikram 		bam_error(NO_PHYS_IN_ZPOOL_STATUS, pool);
7293eb2bd662Svikram 		filelist_free(&flist);
7294eb2bd662Svikram 		return (-1);
7295eb2bd662Svikram 	}
7296eb2bd662Svikram 
7297eb2bd662Svikram 	*n = i;
7298eb2bd662Svikram 	*physarray = s_calloc(*n, sizeof (char *));
7299eb2bd662Svikram 	for (i = 0, lp = startlp; lp; lp = lp->next) {
7300eb2bd662Svikram 		if (lp->line == NULL)
7301eb2bd662Svikram 			continue;
7302eb2bd662Svikram 		if (strcmp(lp->line, "mirror") == 0)
7303eb2bd662Svikram 			continue;
7304eb2bd662Svikram 		if (strcmp(lp->line, "errors:") == 0)
7305eb2bd662Svikram 			break;
7306eb2bd662Svikram 		if (strncmp(lp->line, "/dev/dsk/", strlen("/dev/dsk/")) != 0 &&
7307eb2bd662Svikram 		    strncmp(lp->line, "/dev/rdsk/",
7308eb2bd662Svikram 		    strlen("/dev/rdsk/")) != 0)  {
7309e998e519SSheshadri Vasudevan 			(void) snprintf(dsk, sizeof (dsk), "/dev/rdsk/%s",
7310eb2bd662Svikram 			    lp->line);
7311eb2bd662Svikram 		} else {
7312eb2bd662Svikram 			(void) strlcpy(dsk, lp->line, sizeof (dsk));
7313eb2bd662Svikram 		}
7314eb2bd662Svikram 		BAM_DPRINTF((D_ADDING_ZFS_PHYS, fcn, dsk, pool));
7315eb2bd662Svikram 		(*physarray)[i++] = s_strdup(dsk);
7316eb2bd662Svikram 	}
7317eb2bd662Svikram 
7318eb2bd662Svikram 	assert(i == *n);
7319eb2bd662Svikram 
7320eb2bd662Svikram 	filelist_free(&flist);
7321eb2bd662Svikram 
7322eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7323eb2bd662Svikram 	return (0);
7324eb2bd662Svikram }
7325eb2bd662Svikram 
7326963390b4Svikram /*
7327963390b4Svikram  * Certain services needed to run metastat successfully may not
7328963390b4Svikram  * be enabled. Enable them now.
7329963390b4Svikram  */
7330963390b4Svikram /*
7331963390b4Svikram  * Checks if the specified service is online
7332963390b4Svikram  * Returns: 	1 if the service is online
7333963390b4Svikram  *		0 if the service is not online
7334963390b4Svikram  *		-1 on error
7335963390b4Svikram  */
7336963390b4Svikram static int
7337963390b4Svikram is_svc_online(char *svc)
7338963390b4Svikram {
7339963390b4Svikram 	char			*state;
7340963390b4Svikram 	const char		*fcn = "is_svc_online()";
7341963390b4Svikram 
7342963390b4Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, svc));
7343963390b4Svikram 
7344963390b4Svikram 	state = smf_get_state(svc);
7345963390b4Svikram 	INJECT_ERROR2("GET_SVC_STATE", free(state), state = NULL);
7346963390b4Svikram 	if (state == NULL) {
7347963390b4Svikram 		bam_error(GET_SVC_STATE_ERR, svc);
7348963390b4Svikram 		return (-1);
7349963390b4Svikram 	}
7350963390b4Svikram 	BAM_DPRINTF((D_GOT_SVC_STATUS, fcn, svc));
7351963390b4Svikram 
7352963390b4Svikram 	if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) {
7353963390b4Svikram 		BAM_DPRINTF((D_SVC_ONLINE, fcn, svc));
7354963390b4Svikram 		free(state);
7355963390b4Svikram 		return (1);
7356963390b4Svikram 	}
7357963390b4Svikram 
7358963390b4Svikram 	BAM_DPRINTF((D_SVC_NOT_ONLINE, fcn, state, svc));
7359963390b4Svikram 
7360963390b4Svikram 	free(state);
7361963390b4Svikram 
7362963390b4Svikram 	return (0);
7363963390b4Svikram }
7364963390b4Svikram 
7365963390b4Svikram static int
7366963390b4Svikram enable_svc(char *svc)
7367963390b4Svikram {
7368963390b4Svikram 	int			ret;
7369963390b4Svikram 	int			sleeptime;
7370963390b4Svikram 	const char		*fcn = "enable_svc()";
7371963390b4Svikram 
7372963390b4Svikram 	ret = is_svc_online(svc);
7373963390b4Svikram 	if (ret == -1) {
7374963390b4Svikram 		bam_error(SVC_IS_ONLINE_FAILED, svc);
7375963390b4Svikram 		return (-1);
7376963390b4Svikram 	} else if (ret == 1) {
7377963390b4Svikram 		BAM_DPRINTF((D_SVC_ALREADY_ONLINE, fcn, svc));
7378963390b4Svikram 		return (0);
7379963390b4Svikram 	}
7380963390b4Svikram 
7381963390b4Svikram 	/* Service is not enabled. Enable it now. */
7382963390b4Svikram 	ret = smf_enable_instance(svc, 0);
7383963390b4Svikram 	INJECT_ERROR1("ENABLE_SVC_FAILED", ret = -1);
7384963390b4Svikram 	if (ret != 0) {
7385963390b4Svikram 		bam_error(ENABLE_SVC_FAILED, svc);
7386963390b4Svikram 		return (-1);
7387963390b4Svikram 	}
7388963390b4Svikram 
7389963390b4Svikram 	BAM_DPRINTF((D_SVC_ONLINE_INITIATED, fcn, svc));
7390963390b4Svikram 
7391963390b4Svikram 	sleeptime = 0;
7392963390b4Svikram 	do {
7393963390b4Svikram 		ret = is_svc_online(svc);
7394963390b4Svikram 		INJECT_ERROR1("SVC_ONLINE_SUCCESS", ret = 1);
7395963390b4Svikram 		INJECT_ERROR1("SVC_ONLINE_FAILURE", ret = -1);
7396963390b4Svikram 		INJECT_ERROR1("SVC_ONLINE_NOTYET", ret = 0);
7397963390b4Svikram 		if (ret == -1) {
7398963390b4Svikram 			bam_error(ERR_SVC_GET_ONLINE, svc);
7399963390b4Svikram 			return (-1);
7400963390b4Svikram 		} else if (ret == 1) {
7401963390b4Svikram 			BAM_DPRINTF((D_SVC_NOW_ONLINE, fcn, svc));
7402963390b4Svikram 			return (1);
7403963390b4Svikram 		}
7404963390b4Svikram 		(void) sleep(1);
7405589ac1f4SRobert Harris 	} while (++sleeptime < 60);
7406963390b4Svikram 
7407963390b4Svikram 	bam_error(TIMEOUT_ENABLE_SVC, svc);
7408963390b4Svikram 
7409963390b4Svikram 	return (-1);
7410963390b4Svikram }
7411963390b4Svikram 
7412eb2bd662Svikram static int
7413eb2bd662Svikram ufs_get_physical(char *special, char ***physarray, int *n)
7414eb2bd662Svikram {
7415eb2bd662Svikram 	char			cmd[PATH_MAX];
7416eb2bd662Svikram 	char			*shortname;
7417eb2bd662Svikram 	filelist_t		flist = {0};
7418eb2bd662Svikram 	char			*meta;
7419eb2bd662Svikram 	char			*type;
7420eb2bd662Svikram 	char			*comp1;
7421eb2bd662Svikram 	char			*comp2;
7422eb2bd662Svikram 	char			*comp3;
7423eb2bd662Svikram 	char			*comp4;
7424eb2bd662Svikram 	int			i;
7425eb2bd662Svikram 	line_t			*lp;
7426eb2bd662Svikram 	int			ret;
7427963390b4Svikram 	char			*svc;
7428eb2bd662Svikram 	const char		*fcn = "ufs_get_physical()";
7429eb2bd662Svikram 
7430eb2bd662Svikram 	assert(special);
7431eb2bd662Svikram 
7432eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, special));
7433eb2bd662Svikram 
7434eb2bd662Svikram 	if (strncmp(special, "/dev/md/", strlen("/dev/md/")) != 0) {
7435eb2bd662Svikram 		bam_error(UFS_GET_PHYS_NOT_SVM, special);
7436eb2bd662Svikram 		return (-1);
7437eb2bd662Svikram 	}
7438eb2bd662Svikram 
7439eb2bd662Svikram 	if (strncmp(special, "/dev/md/dsk/", strlen("/dev/md/dsk/")) == 0) {
7440eb2bd662Svikram 		shortname = special + strlen("/dev/md/dsk/");
7441eb2bd662Svikram 	} else if (strncmp(special, "/dev/md/rdsk/",
7442eb2bd662Svikram 	    strlen("/dev/md/rdsk/")) == 0) {
7443eb2bd662Svikram 		shortname = special + strlen("/dev/md/rdsk");
7444eb2bd662Svikram 	} else {
7445eb2bd662Svikram 		bam_error(UFS_GET_PHYS_INVALID_SVM, special);
7446eb2bd662Svikram 		return (-1);
7447eb2bd662Svikram 	}
7448eb2bd662Svikram 
7449eb2bd662Svikram 	BAM_DPRINTF((D_UFS_SVM_SHORT, fcn, special, shortname));
7450eb2bd662Svikram 
7451963390b4Svikram 	svc = "network/rpc/meta:default";
7452963390b4Svikram 	if (enable_svc(svc) == -1) {
7453963390b4Svikram 		bam_error(UFS_SVM_METASTAT_SVC_ERR, svc);
7454963390b4Svikram 	}
7455963390b4Svikram 
7456eb2bd662Svikram 	(void) snprintf(cmd, sizeof (cmd), "/sbin/metastat -p %s", shortname);
7457eb2bd662Svikram 
7458eb2bd662Svikram 	ret = exec_cmd(cmd, &flist);
7459eb2bd662Svikram 	INJECT_ERROR1("UFS_SVM_METASTAT", ret = 1);
7460eb2bd662Svikram 	if (ret != 0) {
7461eb2bd662Svikram 		bam_error(UFS_SVM_METASTAT_ERR, shortname);
7462eb2bd662Svikram 		return (-1);
7463eb2bd662Svikram 	}
7464eb2bd662Svikram 
7465eb2bd662Svikram 	INJECT_ERROR1("UFS_SVM_METASTAT_OUT", flist.head = NULL);
7466eb2bd662Svikram 	if (flist.head == NULL) {
7467eb2bd662Svikram 		bam_error(BAD_UFS_SVM_METASTAT, shortname);
7468eb2bd662Svikram 		filelist_free(&flist);
7469eb2bd662Svikram 		return (-1);
74707c478bd9Sstevel@tonic-gate 	}
74717c478bd9Sstevel@tonic-gate 
74727c478bd9Sstevel@tonic-gate 	/*
7473eb2bd662Svikram 	 * Check if not a mirror. We only parse a single metadevice
7474eb2bd662Svikram 	 * if not a mirror
7475eb2bd662Svikram 	 */
7476eb2bd662Svikram 	meta = strtok(flist.head->line, " \t");
7477eb2bd662Svikram 	type = strtok(NULL, " \t");
7478eb2bd662Svikram 	if (meta == NULL || type == NULL) {
7479eb2bd662Svikram 		bam_error(ERROR_PARSE_UFS_SVM_METASTAT, shortname);
7480eb2bd662Svikram 		filelist_free(&flist);
7481eb2bd662Svikram 		return (-1);
7482eb2bd662Svikram 	}
7483eb2bd662Svikram 	if (strcmp(type, "-m") != 0) {
7484eb2bd662Svikram 		comp1 = strtok(NULL, " \t");
7485eb2bd662Svikram 		comp2 = strtok(NULL, " \t");
7486eb2bd662Svikram 		if (comp1 == NULL || comp2 != NULL) {
7487eb2bd662Svikram 			bam_error(INVALID_UFS_SVM_METASTAT, shortname);
7488eb2bd662Svikram 			filelist_free(&flist);
7489eb2bd662Svikram 			return (-1);
7490eb2bd662Svikram 		}
7491eb2bd662Svikram 		BAM_DPRINTF((D_UFS_SVM_ONE_COMP, fcn, comp1, shortname));
7492eb2bd662Svikram 		*physarray = s_calloc(1, sizeof (char *));
7493eb2bd662Svikram 		(*physarray)[0] = s_strdup(comp1);
7494eb2bd662Svikram 		*n = 1;
7495eb2bd662Svikram 		filelist_free(&flist);
7496eb2bd662Svikram 		return (0);
7497eb2bd662Svikram 	}
7498eb2bd662Svikram 
7499eb2bd662Svikram 	/*
7500eb2bd662Svikram 	 * Okay we have a mirror. Everything after the first line
7501eb2bd662Svikram 	 * is a submirror
7502eb2bd662Svikram 	 */
7503eb2bd662Svikram 	for (i = 0, lp = flist.head->next; lp; lp = lp->next) {
7504eb2bd662Svikram 		if (strstr(lp->line, "/dev/dsk/") == NULL &&
7505eb2bd662Svikram 		    strstr(lp->line, "/dev/rdsk/") == NULL) {
7506eb2bd662Svikram 			bam_error(CANNOT_PARSE_UFS_SVM_METASTAT, shortname);
7507eb2bd662Svikram 			filelist_free(&flist);
7508eb2bd662Svikram 			return (-1);
7509eb2bd662Svikram 		}
7510eb2bd662Svikram 		i++;
7511eb2bd662Svikram 	}
7512eb2bd662Svikram 
7513eb2bd662Svikram 	*physarray = s_calloc(i, sizeof (char *));
7514eb2bd662Svikram 	*n = i;
7515eb2bd662Svikram 
7516eb2bd662Svikram 	for (i = 0, lp = flist.head->next; lp; lp = lp->next) {
7517eb2bd662Svikram 		comp1 = strtok(lp->line, " \t");
7518eb2bd662Svikram 		comp2 = strtok(NULL, " \t");
7519eb2bd662Svikram 		comp3 = strtok(NULL, " \t");
7520eb2bd662Svikram 		comp4 = strtok(NULL, " \t");
7521eb2bd662Svikram 
7522eb2bd662Svikram 		if (comp3 == NULL || comp4 == NULL ||
7523eb2bd662Svikram 		    (strncmp(comp4, "/dev/dsk/", strlen("/dev/dsk/")) != 0 &&
7524eb2bd662Svikram 		    strncmp(comp4, "/dev/rdsk/", strlen("/dev/rdsk/")) != 0)) {
7525eb2bd662Svikram 			bam_error(CANNOT_PARSE_UFS_SVM_SUBMIRROR, shortname);
7526eb2bd662Svikram 			filelist_free(&flist);
7527eb2bd662Svikram 			free_physarray(*physarray, *n);
7528eb2bd662Svikram 			return (-1);
7529eb2bd662Svikram 		}
7530eb2bd662Svikram 
7531eb2bd662Svikram 		(*physarray)[i++] = s_strdup(comp4);
7532eb2bd662Svikram 	}
7533eb2bd662Svikram 
7534eb2bd662Svikram 	assert(i == *n);
7535eb2bd662Svikram 
7536eb2bd662Svikram 	filelist_free(&flist);
7537eb2bd662Svikram 
7538eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7539eb2bd662Svikram 	return (0);
7540eb2bd662Svikram }
7541eb2bd662Svikram 
7542eb2bd662Svikram static int
7543eb2bd662Svikram get_physical(char *menu_root, char ***physarray, int *n)
7544eb2bd662Svikram {
7545eb2bd662Svikram 	char			*special;
7546eb2bd662Svikram 	int			ret;
7547eb2bd662Svikram 	const char		*fcn = "get_physical()";
7548eb2bd662Svikram 
7549eb2bd662Svikram 	assert(menu_root);
7550eb2bd662Svikram 	assert(physarray);
7551eb2bd662Svikram 	assert(n);
7552eb2bd662Svikram 
7553eb2bd662Svikram 	*physarray = NULL;
7554eb2bd662Svikram 	*n = 0;
7555eb2bd662Svikram 
7556eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, menu_root));
7557eb2bd662Svikram 
7558eb2bd662Svikram 	/* First get the device special file from /etc/mnttab */
7559eb2bd662Svikram 	special = get_special(menu_root);
7560eb2bd662Svikram 	INJECT_ERROR1("GET_PHYSICAL_SPECIAL", special = NULL);
7561eb2bd662Svikram 	if (special == NULL) {
7562eb2bd662Svikram 		bam_error(GET_SPECIAL_NULL, menu_root);
7563eb2bd662Svikram 		return (-1);
7564eb2bd662Svikram 	}
7565eb2bd662Svikram 
7566eb2bd662Svikram 	/* If already a physical device nothing to do */
7567eb2bd662Svikram 	if (strncmp(special, "/dev/dsk/", strlen("/dev/dsk/")) == 0 ||
7568eb2bd662Svikram 	    strncmp(special, "/dev/rdsk/", strlen("/dev/rdsk/")) == 0) {
7569eb2bd662Svikram 		BAM_DPRINTF((D_GET_PHYSICAL_ALREADY, fcn, menu_root, special));
7570eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7571eb2bd662Svikram 		*physarray = s_calloc(1, sizeof (char *));
7572eb2bd662Svikram 		(*physarray)[0] = special;
7573eb2bd662Svikram 		*n = 1;
7574eb2bd662Svikram 		return (0);
7575eb2bd662Svikram 	}
7576eb2bd662Svikram 
7577eb2bd662Svikram 	if (is_zfs(menu_root)) {
7578eb2bd662Svikram 		ret = zfs_get_physical(special, physarray, n);
7579eb2bd662Svikram 	} else if (is_ufs(menu_root)) {
7580eb2bd662Svikram 		ret = ufs_get_physical(special, physarray, n);
7581eb2bd662Svikram 	} else {
7582eb2bd662Svikram 		bam_error(GET_PHYSICAL_NOTSUP_FSTYPE, menu_root, special);
7583eb2bd662Svikram 		ret = -1;
7584eb2bd662Svikram 	}
7585eb2bd662Svikram 
7586eb2bd662Svikram 	free(special);
7587eb2bd662Svikram 
7588eb2bd662Svikram 	INJECT_ERROR1("GET_PHYSICAL_RET", ret = -1);
7589eb2bd662Svikram 	if (ret == -1) {
7590eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
7591eb2bd662Svikram 	} else {
7592eb2bd662Svikram 		int	i;
7593eb2bd662Svikram 		assert (*n > 0);
7594eb2bd662Svikram 		for (i = 0; i < *n; i++) {
7595eb2bd662Svikram 			BAM_DPRINTF((D_GET_PHYSICAL_RET, fcn, (*physarray)[i]));
7596eb2bd662Svikram 		}
7597eb2bd662Svikram 	}
7598eb2bd662Svikram 
7599eb2bd662Svikram 	return (ret);
7600eb2bd662Svikram }
7601eb2bd662Svikram 
7602eb2bd662Svikram static int
7603eb2bd662Svikram is_bootdisk(char *osroot, char *physical)
7604eb2bd662Svikram {
7605eb2bd662Svikram 	int			ret;
7606eb2bd662Svikram 	char			*grubroot;
7607eb2bd662Svikram 	char			*bootp;
7608eb2bd662Svikram 	const char		*fcn = "is_bootdisk()";
7609eb2bd662Svikram 
7610eb2bd662Svikram 	assert(osroot);
7611eb2bd662Svikram 	assert(physical);
7612eb2bd662Svikram 
7613eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, physical));
7614eb2bd662Svikram 
7615eb2bd662Svikram 	bootp = strstr(physical, "p0:boot");
7616eb2bd662Svikram 	if (bootp)
7617eb2bd662Svikram 		*bootp = '\0';
7618eb2bd662Svikram 	/*
7619eb2bd662Svikram 	 * We just want the BIOS mapping for menu disk.
7620eb2bd662Svikram 	 * Don't pass menu_root to get_grubroot() as the
7621eb2bd662Svikram 	 * check that it is used for is not relevant here.
7622eb2bd662Svikram 	 * The osroot is immaterial as well - it is only used to
7623eb2bd662Svikram 	 * to find create_diskmap script. Everything hinges on
7624eb2bd662Svikram 	 * "physical"
7625eb2bd662Svikram 	 */
7626eb2bd662Svikram 	grubroot = get_grubroot(osroot, physical, NULL);
7627eb2bd662Svikram 
7628eb2bd662Svikram 	INJECT_ERROR1("IS_BOOTDISK_GRUBROOT", grubroot = NULL);
7629eb2bd662Svikram 	if (grubroot == NULL) {
763037eb779cSVikram Hegde 		if (bam_verbose)
763137eb779cSVikram Hegde 			bam_error(NO_GRUBROOT_FOR_DISK, physical);
7632eb2bd662Svikram 		return (0);
7633eb2bd662Svikram 	}
7634eb2bd662Svikram 	ret = grubroot[3] == '0';
7635eb2bd662Svikram 	free(grubroot);
7636eb2bd662Svikram 
7637eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_RET, fcn, ret));
7638eb2bd662Svikram 
7639eb2bd662Svikram 	return (ret);
7640eb2bd662Svikram }
7641eb2bd662Svikram 
7642eb2bd662Svikram /*
7643eb2bd662Svikram  * Check if menu is on the boot device
76447c478bd9Sstevel@tonic-gate  * Return 0 (false) on error
76457c478bd9Sstevel@tonic-gate  */
76467c478bd9Sstevel@tonic-gate static int
7647eb2bd662Svikram menu_on_bootdisk(char *osroot, char *menu_root)
76487c478bd9Sstevel@tonic-gate {
7649eb2bd662Svikram 	char		**physarray;
76507c478bd9Sstevel@tonic-gate 	int		ret;
7651eb2bd662Svikram 	int		n;
7652eb2bd662Svikram 	int		i;
7653eb2bd662Svikram 	int		on_bootdisk;
7654eb2bd662Svikram 	const char	*fcn = "menu_on_bootdisk()";
76557c478bd9Sstevel@tonic-gate 
7656eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, menu_root));
76577c478bd9Sstevel@tonic-gate 
7658eb2bd662Svikram 	ret = get_physical(menu_root, &physarray, &n);
7659eb2bd662Svikram 	INJECT_ERROR1("MENU_ON_BOOTDISK_PHYSICAL", ret = -1);
7660eb2bd662Svikram 	if (ret != 0) {
7661eb2bd662Svikram 		bam_error(GET_PHYSICAL_MENU_NULL, menu_root);
76627c478bd9Sstevel@tonic-gate 		return (0);
7663eb2bd662Svikram 	}
7664eb2bd662Svikram 
7665eb2bd662Svikram 	assert(physarray);
7666eb2bd662Svikram 	assert(n > 0);
7667eb2bd662Svikram 
7668eb2bd662Svikram 	on_bootdisk = 0;
7669eb2bd662Svikram 	for (i = 0; i < n; i++) {
7670eb2bd662Svikram 		assert(strncmp(physarray[i], "/dev/dsk/",
7671eb2bd662Svikram 		    strlen("/dev/dsk/")) == 0 ||
7672eb2bd662Svikram 		    strncmp(physarray[i], "/dev/rdsk/",
7673eb2bd662Svikram 		    strlen("/dev/rdsk/")) == 0);
7674eb2bd662Svikram 
7675eb2bd662Svikram 		BAM_DPRINTF((D_CHECK_ON_BOOTDISK, fcn, physarray[i]));
7676eb2bd662Svikram 		if (is_bootdisk(osroot, physarray[i])) {
7677eb2bd662Svikram 			on_bootdisk = 1;
7678eb2bd662Svikram 			BAM_DPRINTF((D_IS_ON_BOOTDISK, fcn, physarray[i]));
7679eb2bd662Svikram 		}
7680eb2bd662Svikram 	}
7681eb2bd662Svikram 
7682eb2bd662Svikram 	free_physarray(physarray, n);
7683eb2bd662Svikram 
7684eb2bd662Svikram 	INJECT_ERROR1("ON_BOOTDISK_YES", on_bootdisk = 1);
7685eb2bd662Svikram 	INJECT_ERROR1("ON_BOOTDISK_NO", on_bootdisk = 0);
7686eb2bd662Svikram 	if (on_bootdisk) {
7687eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
7688eb2bd662Svikram 	} else {
7689eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
7690eb2bd662Svikram 	}
7691eb2bd662Svikram 
7692eb2bd662Svikram 	return (on_bootdisk);
7693eb2bd662Svikram }
7694eb2bd662Svikram 
7695eb2bd662Svikram void
7696eb2bd662Svikram bam_add_line(menu_t *mp, entry_t *entry, line_t *prev, line_t *lp)
7697eb2bd662Svikram {
7698eb2bd662Svikram 	const char	*fcn = "bam_add_line()";
7699eb2bd662Svikram 
7700eb2bd662Svikram 	assert(mp);
7701eb2bd662Svikram 	assert(entry);
7702eb2bd662Svikram 	assert(prev);
7703eb2bd662Svikram 	assert(lp);
7704eb2bd662Svikram 
7705eb2bd662Svikram 	lp->next = prev->next;
7706eb2bd662Svikram 	if (prev->next) {
7707eb2bd662Svikram 		BAM_DPRINTF((D_ADD_LINE_PREV_NEXT, fcn));
7708eb2bd662Svikram 		prev->next->prev = lp;
7709eb2bd662Svikram 	} else {
7710eb2bd662Svikram 		BAM_DPRINTF((D_ADD_LINE_NOT_PREV_NEXT, fcn));
7711eb2bd662Svikram 	}
7712eb2bd662Svikram 	prev->next = lp;
7713eb2bd662Svikram 	lp->prev = prev;
7714eb2bd662Svikram 
7715eb2bd662Svikram 	if (entry->end == prev) {
7716eb2bd662Svikram 		BAM_DPRINTF((D_ADD_LINE_LAST_LINE_IN_ENTRY, fcn));
7717eb2bd662Svikram 		entry->end = lp;
7718eb2bd662Svikram 	}
7719eb2bd662Svikram 	if (mp->end == prev) {
7720eb2bd662Svikram 		assert(lp->next == NULL);
7721eb2bd662Svikram 		mp->end = lp;
7722eb2bd662Svikram 		BAM_DPRINTF((D_ADD_LINE_LAST_LINE_IN_MENU, fcn));
7723eb2bd662Svikram 	}
77247c478bd9Sstevel@tonic-gate }
77257c478bd9Sstevel@tonic-gate 
77268c1b6884Sszhou /*
77278c1b6884Sszhou  * look for matching bootadm entry with specified parameters
77288c1b6884Sszhou  * Here are the rules (based on existing usage):
77298c1b6884Sszhou  * - If title is specified, match on title only
7730eb2bd662Svikram  * - Else, match on root/findroot, kernel, and module.
7731eb2bd662Svikram  *   Note that, if root_opt is non-zero, the absence of
7732eb2bd662Svikram  *   root line is considered a match.
77338c1b6884Sszhou  */
77348c1b6884Sszhou static entry_t *
7735eb2bd662Svikram find_boot_entry(
7736eb2bd662Svikram 	menu_t *mp,
7737eb2bd662Svikram 	char *title,
7738eb2bd662Svikram 	char *kernel,
7739eb2bd662Svikram 	char *findroot,
7740eb2bd662Svikram 	char *root,
7741eb2bd662Svikram 	char *module,
7742eb2bd662Svikram 	int root_opt,
7743eb2bd662Svikram 	int *entry_num)
77448c1b6884Sszhou {
77458c1b6884Sszhou 	int		i;
77468c1b6884Sszhou 	line_t		*lp;
77478c1b6884Sszhou 	entry_t		*ent;
7748eb2bd662Svikram 	const char	*fcn = "find_boot_entry()";
7749eb2bd662Svikram 
7750eb2bd662Svikram 	if (entry_num)
7751eb2bd662Svikram 		*entry_num = BAM_ERROR;
77528c1b6884Sszhou 
77538c1b6884Sszhou 	/* find matching entry */
77548c1b6884Sszhou 	for (i = 0, ent = mp->entries; ent; i++, ent = ent->next) {
77558c1b6884Sszhou 		lp = ent->start;
77568c1b6884Sszhou 
77578c1b6884Sszhou 		/* first line of entry must be bootadm comment */
77588c1b6884Sszhou 		lp = ent->start;
7759ae115bc7Smrj 		if (lp->flags != BAM_COMMENT ||
7760ae115bc7Smrj 		    strcmp(lp->arg, BAM_BOOTADM_HDR) != 0) {
77618c1b6884Sszhou 			continue;
77628c1b6884Sszhou 		}
77638c1b6884Sszhou 
77648c1b6884Sszhou 		/* advance to title line */
77658c1b6884Sszhou 		lp = lp->next;
77668c1b6884Sszhou 		if (title) {
77678c1b6884Sszhou 			if (lp->flags == BAM_TITLE && lp->arg &&
7768eb2bd662Svikram 			    strcmp(lp->arg, title) == 0) {
7769eb2bd662Svikram 				BAM_DPRINTF((D_MATCHED_TITLE, fcn, title));
77708c1b6884Sszhou 				break;
7771eb2bd662Svikram 			}
7772eb2bd662Svikram 			BAM_DPRINTF((D_NOMATCH_TITLE, fcn, title, lp->arg));
77738c1b6884Sszhou 			continue;	/* check title only */
77748c1b6884Sszhou 		}
77758c1b6884Sszhou 
77768c1b6884Sszhou 		lp = lp->next;	/* advance to root line */
7777843e1988Sjohnlev 		if (lp == NULL) {
7778843e1988Sjohnlev 			continue;
7779eac223ccSWilliam Kucharski 		} else if (lp->cmd != NULL &&
7780eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) == 0) {
7781eb2bd662Svikram 			INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_FINDROOT",
7782eb2bd662Svikram 			    findroot = NULL);
7783eb2bd662Svikram 			if (findroot == NULL) {
7784eb2bd662Svikram 				BAM_DPRINTF((D_NOMATCH_FINDROOT_NULL,
7785eb2bd662Svikram 				    fcn, lp->arg));
77868c1b6884Sszhou 				continue;
77878c1b6884Sszhou 			}
7788eb2bd662Svikram 			/* findroot command found, try match  */
7789eb2bd662Svikram 			if (strcmp(lp->arg, findroot) != 0) {
7790eb2bd662Svikram 				BAM_DPRINTF((D_NOMATCH_FINDROOT,
7791eb2bd662Svikram 				    fcn, findroot, lp->arg));
7792eb2bd662Svikram 				continue;
7793eb2bd662Svikram 			}
7794eb2bd662Svikram 			BAM_DPRINTF((D_MATCHED_FINDROOT, fcn, findroot));
7795eb2bd662Svikram 			lp = lp->next;	/* advance to kernel line */
7796eac223ccSWilliam Kucharski 		} else if (lp->cmd != NULL &&
7797eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) {
7798eb2bd662Svikram 			INJECT_ERROR1("FIND_BOOT_ENTRY_NULL_ROOT", root = NULL);
7799eb2bd662Svikram 			if (root == NULL) {
7800eb2bd662Svikram 				BAM_DPRINTF((D_NOMATCH_ROOT_NULL,
7801eb2bd662Svikram 				    fcn, lp->arg));
7802eb2bd662Svikram 				continue;
7803eb2bd662Svikram 			}
7804eb2bd662Svikram 			/* root cmd found, try match */
7805eb2bd662Svikram 			if (strcmp(lp->arg, root) != 0) {
7806eb2bd662Svikram 				BAM_DPRINTF((D_NOMATCH_ROOT,
7807eb2bd662Svikram 				    fcn, root, lp->arg));
7808eb2bd662Svikram 				continue;
7809eb2bd662Svikram 			}
7810eb2bd662Svikram 			BAM_DPRINTF((D_MATCHED_ROOT, fcn, root));
78118c1b6884Sszhou 			lp = lp->next;	/* advance to kernel line */
78128c1b6884Sszhou 		} else {
7813eb2bd662Svikram 			INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_NO",
7814eb2bd662Svikram 			    root_opt = 0);
7815eb2bd662Svikram 			INJECT_ERROR1("FIND_BOOT_ENTRY_ROOT_OPT_YES",
7816eb2bd662Svikram 			    root_opt = 1);
78178c1b6884Sszhou 			/* no root command, see if root is optional */
78188c1b6884Sszhou 			if (root_opt == 0) {
7819eb2bd662Svikram 				BAM_DPRINTF((D_NO_ROOT_OPT, fcn));
78208c1b6884Sszhou 				continue;
78218c1b6884Sszhou 			}
7822eb2bd662Svikram 			BAM_DPRINTF((D_ROOT_OPT, fcn));
78238c1b6884Sszhou 		}
78248c1b6884Sszhou 
78258c1b6884Sszhou 		if (lp == NULL || lp->next == NULL) {
78268c1b6884Sszhou 			continue;
78278c1b6884Sszhou 		}
78288c1b6884Sszhou 
7829843e1988Sjohnlev 		if (kernel &&
7830843e1988Sjohnlev 		    (!check_cmd(lp->cmd, KERNEL_CMD, lp->arg, kernel))) {
7831bbcc54bdSEnrico Perla - Sun Microsystems 			if (!(ent->flags & BAM_ENTRY_FAILSAFE) ||
7832bbcc54bdSEnrico Perla - Sun Microsystems 			    !(ent->flags & BAM_ENTRY_DBOOT) ||
7833bbcc54bdSEnrico Perla - Sun Microsystems 			    strcmp(kernel, DIRECT_BOOT_FAILSAFE_LINE) != 0)
78348c1b6884Sszhou 				continue;
7835bbcc54bdSEnrico Perla - Sun Microsystems 
7836bbcc54bdSEnrico Perla - Sun Microsystems 			ent->flags |= BAM_ENTRY_UPGFSKERNEL;
7837bbcc54bdSEnrico Perla - Sun Microsystems 
78388c1b6884Sszhou 		}
7839eb2bd662Svikram 		BAM_DPRINTF((D_KERNEL_MATCH, fcn, kernel, lp->arg));
7840843e1988Sjohnlev 
7841843e1988Sjohnlev 		/*
7842843e1988Sjohnlev 		 * Check for matching module entry (failsafe or normal).
7843843e1988Sjohnlev 		 * If it fails to match, we go around the loop again.
7844843e1988Sjohnlev 		 * For xpv entries, there are two module lines, so we
7845843e1988Sjohnlev 		 * do the check twice.
7846843e1988Sjohnlev 		 */
7847843e1988Sjohnlev 		lp = lp->next;	/* advance to module line */
7848843e1988Sjohnlev 		if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) ||
7849843e1988Sjohnlev 		    (((lp = lp->next) != NULL) &&
7850843e1988Sjohnlev 		    check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) {
7851843e1988Sjohnlev 			/* match found */
7852eb2bd662Svikram 			BAM_DPRINTF((D_MODULE_MATCH, fcn, module, lp->arg));
7853843e1988Sjohnlev 			break;
7854843e1988Sjohnlev 		}
7855bbcc54bdSEnrico Perla - Sun Microsystems 
7856bbcc54bdSEnrico Perla - Sun Microsystems 		if (strcmp(module, FAILSAFE_ARCHIVE) == 0 &&
7857bbcc54bdSEnrico Perla - Sun Microsystems 		    (strcmp(lp->prev->arg, FAILSAFE_ARCHIVE_32) == 0 ||
7858bbcc54bdSEnrico Perla - Sun Microsystems 		    strcmp(lp->prev->arg, FAILSAFE_ARCHIVE_64) == 0)) {
7859bbcc54bdSEnrico Perla - Sun Microsystems 			ent->flags |= BAM_ENTRY_UPGFSMODULE;
7860bbcc54bdSEnrico Perla - Sun Microsystems 			break;
7861bbcc54bdSEnrico Perla - Sun Microsystems 		}
7862bbcc54bdSEnrico Perla - Sun Microsystems 
78638c1b6884Sszhou 	}
78648c1b6884Sszhou 
7865eb2bd662Svikram 	if (ent && entry_num) {
78668c1b6884Sszhou 		*entry_num = i;
7867843e1988Sjohnlev 	}
7868eb2bd662Svikram 
7869eb2bd662Svikram 	if (ent) {
7870eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_RET, fcn, i));
7871eb2bd662Svikram 	} else {
7872eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_RET, fcn, BAM_ERROR));
7873eb2bd662Svikram 	}
78748c1b6884Sszhou 	return (ent);
78758c1b6884Sszhou }
78768c1b6884Sszhou 
78778c1b6884Sszhou static int
7878eb2bd662Svikram update_boot_entry(menu_t *mp, char *title, char *findroot, char *root,
7879eb2bd662Svikram     char *kernel, char *mod_kernel, char *module, int root_opt)
78808c1b6884Sszhou {
7881eb2bd662Svikram 	int		i;
7882eb2bd662Svikram 	int		change_kernel = 0;
78838c1b6884Sszhou 	entry_t		*ent;
78848c1b6884Sszhou 	line_t		*lp;
7885eb2bd662Svikram 	line_t		*tlp;
78868c1b6884Sszhou 	char		linebuf[BAM_MAXLINE];
7887eb2bd662Svikram 	const char	*fcn = "update_boot_entry()";
78888c1b6884Sszhou 
78898c1b6884Sszhou 	/* note: don't match on title, it's updated on upgrade */
7890eb2bd662Svikram 	ent = find_boot_entry(mp, NULL, kernel, findroot, root, module,
7891eb2bd662Svikram 	    root_opt, &i);
7892ae115bc7Smrj 	if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) {
7893ae115bc7Smrj 		/*
7894ae115bc7Smrj 		 * We may be upgrading a kernel from multiboot to
7895eb2bd662Svikram 		 * directboot.  Look for a multiboot entry. A multiboot
7896eb2bd662Svikram 		 * entry will not have a findroot line.
7897ae115bc7Smrj 		 */
7898eb2bd662Svikram 		ent = find_boot_entry(mp, NULL, "multiboot", NULL, root,
7899eb2bd662Svikram 		    MULTIBOOT_ARCHIVE, root_opt, &i);
7900ae115bc7Smrj 		if (ent != NULL) {
7901eb2bd662Svikram 			BAM_DPRINTF((D_UPGRADE_FROM_MULTIBOOT, fcn, root));
7902ae115bc7Smrj 			change_kernel = 1;
7903ae115bc7Smrj 		}
7904eb2bd662Svikram 	} else if (ent) {
7905eb2bd662Svikram 		BAM_DPRINTF((D_FOUND_FINDROOT, fcn, findroot));
7906ae115bc7Smrj 	}
79078c1b6884Sszhou 
7908eb2bd662Svikram 	if (ent == NULL) {
7909eb2bd662Svikram 		BAM_DPRINTF((D_ENTRY_NOT_FOUND_CREATING, fcn, findroot));
7910eb2bd662Svikram 		return (add_boot_entry(mp, title, findroot,
791144da779fSWilliam Kucharski 		    kernel, mod_kernel, module, NULL));
7912eb2bd662Svikram 	}
7913eb2bd662Svikram 
7914eb2bd662Svikram 	/* replace title of existing entry and update findroot line */
79158c1b6884Sszhou 	lp = ent->start;
79168c1b6884Sszhou 	lp = lp->next;	/* title line */
79178c1b6884Sszhou 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
79188c1b6884Sszhou 	    menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title);
79198c1b6884Sszhou 	free(lp->arg);
79208c1b6884Sszhou 	free(lp->line);
79218c1b6884Sszhou 	lp->arg = s_strdup(title);
79228c1b6884Sszhou 	lp->line = s_strdup(linebuf);
7923eb2bd662Svikram 	BAM_DPRINTF((D_CHANGING_TITLE, fcn, title));
79248c1b6884Sszhou 
7925eb2bd662Svikram 	tlp = lp;	/* title line */
79268c1b6884Sszhou 	lp = lp->next;	/* root line */
7927eb2bd662Svikram 
7928eb2bd662Svikram 	/* if no root or findroot command, create a new line_t */
7929eac223ccSWilliam Kucharski 	if ((lp->cmd != NULL) && (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) != 0 &&
7930eac223ccSWilliam Kucharski 	    strcmp(lp->cmd, menu_cmds[FINDROOT_CMD]) != 0)) {
7931eb2bd662Svikram 		lp = s_calloc(1, sizeof (line_t));
7932eb2bd662Svikram 		bam_add_line(mp, ent, tlp, lp);
7933eb2bd662Svikram 	} else {
7934eac223ccSWilliam Kucharski 		if (lp->cmd != NULL)
7935eb2bd662Svikram 			free(lp->cmd);
7936eac223ccSWilliam Kucharski 
7937eb2bd662Svikram 		free(lp->sep);
7938eb2bd662Svikram 		free(lp->arg);
7939eb2bd662Svikram 		free(lp->line);
79408c1b6884Sszhou 	}
7941ae115bc7Smrj 
7942eb2bd662Svikram 	lp->cmd = s_strdup(menu_cmds[FINDROOT_CMD]);
7943eb2bd662Svikram 	lp->sep = s_strdup(menu_cmds[SEP_CMD]);
7944eb2bd662Svikram 	lp->arg = s_strdup(findroot);
7945eb2bd662Svikram 	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7946eb2bd662Svikram 	    menu_cmds[FINDROOT_CMD], menu_cmds[SEP_CMD], findroot);
7947eb2bd662Svikram 	lp->line = s_strdup(linebuf);
7948eb2bd662Svikram 	BAM_DPRINTF((D_ADDING_FINDROOT_LINE, fcn, findroot));
7949eb2bd662Svikram 
7950eb2bd662Svikram 	/* kernel line */
7951eb2bd662Svikram 	lp = lp->next;
7952eb2bd662Svikram 
7953bbcc54bdSEnrico Perla - Sun Microsystems 	if (ent->flags & BAM_ENTRY_UPGFSKERNEL) {
7954bbcc54bdSEnrico Perla - Sun Microsystems 		char		*params = NULL;
7955bbcc54bdSEnrico Perla - Sun Microsystems 
7956bbcc54bdSEnrico Perla - Sun Microsystems 		params = strstr(lp->line, "-s");
7957bbcc54bdSEnrico Perla - Sun Microsystems 		if (params != NULL)
7958bbcc54bdSEnrico Perla - Sun Microsystems 			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s%s",
7959bbcc54bdSEnrico Perla - Sun Microsystems 			    menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
7960bbcc54bdSEnrico Perla - Sun Microsystems 			    kernel, params+2);
7961bbcc54bdSEnrico Perla - Sun Microsystems 		else
7962bbcc54bdSEnrico Perla - Sun Microsystems 			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7963bbcc54bdSEnrico Perla - Sun Microsystems 			    menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
7964bbcc54bdSEnrico Perla - Sun Microsystems 			    kernel);
7965bbcc54bdSEnrico Perla - Sun Microsystems 
7966eac223ccSWilliam Kucharski 		if (lp->cmd != NULL)
7967bbcc54bdSEnrico Perla - Sun Microsystems 			free(lp->cmd);
7968eac223ccSWilliam Kucharski 
7969bbcc54bdSEnrico Perla - Sun Microsystems 		free(lp->arg);
7970bbcc54bdSEnrico Perla - Sun Microsystems 		free(lp->line);
7971bbcc54bdSEnrico Perla - Sun Microsystems 		lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]);
7972bbcc54bdSEnrico Perla - Sun Microsystems 		lp->arg = s_strdup(strstr(linebuf, "/"));
7973bbcc54bdSEnrico Perla - Sun Microsystems 		lp->line = s_strdup(linebuf);
7974bbcc54bdSEnrico Perla - Sun Microsystems 		ent->flags &= ~BAM_ENTRY_UPGFSKERNEL;
7975bbcc54bdSEnrico Perla - Sun Microsystems 		BAM_DPRINTF((D_ADDING_KERNEL_DOLLAR, fcn, lp->prev->cmd));
7976bbcc54bdSEnrico Perla - Sun Microsystems 	}
7977bbcc54bdSEnrico Perla - Sun Microsystems 
7978ae115bc7Smrj 	if (change_kernel) {
7979ae115bc7Smrj 		/*
7980ae115bc7Smrj 		 * We're upgrading from multiboot to directboot.
7981ae115bc7Smrj 		 */
7982eac223ccSWilliam Kucharski 		if (lp->cmd != NULL &&
7983eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) {
7984ae115bc7Smrj 			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7985ae115bc7Smrj 			    menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
7986ae115bc7Smrj 			    kernel);
7987eb2bd662Svikram 			free(lp->cmd);
7988ae115bc7Smrj 			free(lp->arg);
7989ae115bc7Smrj 			free(lp->line);
7990eb2bd662Svikram 			lp->cmd = s_strdup(menu_cmds[KERNEL_DOLLAR_CMD]);
7991ae115bc7Smrj 			lp->arg = s_strdup(kernel);
7992ae115bc7Smrj 			lp->line = s_strdup(linebuf);
7993ae115bc7Smrj 			lp = lp->next;
7994eb2bd662Svikram 			BAM_DPRINTF((D_ADDING_KERNEL_DOLLAR, fcn, kernel));
7995ae115bc7Smrj 		}
7996eac223ccSWilliam Kucharski 		if (lp->cmd != NULL &&
7997eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) {
7998ae115bc7Smrj 			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
7999ae115bc7Smrj 			    menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD],
8000ae115bc7Smrj 			    module);
8001eb2bd662Svikram 			free(lp->cmd);
8002ae115bc7Smrj 			free(lp->arg);
8003ae115bc7Smrj 			free(lp->line);
8004eb2bd662Svikram 			lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]);
8005ae115bc7Smrj 			lp->arg = s_strdup(module);
8006ae115bc7Smrj 			lp->line = s_strdup(linebuf);
8007ae115bc7Smrj 			lp = lp->next;
8008eb2bd662Svikram 			BAM_DPRINTF((D_ADDING_MODULE_DOLLAR, fcn, module));
8009ae115bc7Smrj 		}
8010ae115bc7Smrj 	}
8011bbcc54bdSEnrico Perla - Sun Microsystems 
8012bbcc54bdSEnrico Perla - Sun Microsystems 	/* module line */
8013bbcc54bdSEnrico Perla - Sun Microsystems 	lp = lp->next;
8014bbcc54bdSEnrico Perla - Sun Microsystems 
8015bbcc54bdSEnrico Perla - Sun Microsystems 	if (ent->flags & BAM_ENTRY_UPGFSMODULE) {
8016eac223ccSWilliam Kucharski 		if (lp->cmd != NULL &&
8017eac223ccSWilliam Kucharski 		    strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) {
8018bbcc54bdSEnrico Perla - Sun Microsystems 			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
8019bbcc54bdSEnrico Perla - Sun Microsystems 			    menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD],
8020bbcc54bdSEnrico Perla - Sun Microsystems 			    module);
8021bbcc54bdSEnrico Perla - Sun Microsystems 			free(lp->cmd);
8022bbcc54bdSEnrico Perla - Sun Microsystems 			free(lp->arg);
8023bbcc54bdSEnrico Perla - Sun Microsystems 			free(lp->line);
8024bbcc54bdSEnrico Perla - Sun Microsystems 			lp->cmd = s_strdup(menu_cmds[MODULE_DOLLAR_CMD]);
8025bbcc54bdSEnrico Perla - Sun Microsystems 			lp->arg = s_strdup(module);
8026bbcc54bdSEnrico Perla - Sun Microsystems 			lp->line = s_strdup(linebuf);
8027bbcc54bdSEnrico Perla - Sun Microsystems 			lp = lp->next;
8028bbcc54bdSEnrico Perla - Sun Microsystems 			ent->flags &= ~BAM_ENTRY_UPGFSMODULE;
8029bbcc54bdSEnrico Perla - Sun Microsystems 			BAM_DPRINTF((D_ADDING_MODULE_DOLLAR, fcn, module));
8030bbcc54bdSEnrico Perla - Sun Microsystems 		}
8031bbcc54bdSEnrico Perla - Sun Microsystems 	}
8032bbcc54bdSEnrico Perla - Sun Microsystems 
8033eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_RET, fcn, i));
80348c1b6884Sszhou 	return (i);
80358c1b6884Sszhou }
80368c1b6884Sszhou 
8037eb2bd662Svikram int
8038eb2bd662Svikram root_optional(char *osroot, char *menu_root)
8039eb2bd662Svikram {
8040eb2bd662Svikram 	char			*ospecial;
8041eb2bd662Svikram 	char			*mspecial;
8042eb2bd662Svikram 	char			*slash;
8043eb2bd662Svikram 	int			root_opt;
8044eb2bd662Svikram 	int			ret1;
8045eb2bd662Svikram 	int			ret2;
8046eb2bd662Svikram 	const char		*fcn = "root_optional()";
8047eb2bd662Svikram 
8048eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, osroot, menu_root));
8049eb2bd662Svikram 
8050eb2bd662Svikram 	/*
8051eb2bd662Svikram 	 * For all filesystems except ZFS, a straight compare of osroot
8052eb2bd662Svikram 	 * and menu_root will tell us if root is optional.
8053eb2bd662Svikram 	 * For ZFS, the situation is complicated by the fact that
8054eb2bd662Svikram 	 * menu_root and osroot are always different
8055eb2bd662Svikram 	 */
8056eb2bd662Svikram 	ret1 = is_zfs(osroot);
8057eb2bd662Svikram 	ret2 = is_zfs(menu_root);
8058eb2bd662Svikram 	INJECT_ERROR1("ROOT_OPT_NOT_ZFS", ret1 = 0);
8059eb2bd662Svikram 	if (!ret1 || !ret2) {
8060eb2bd662Svikram 		BAM_DPRINTF((D_ROOT_OPT_NOT_ZFS, fcn, osroot, menu_root));
8061eb2bd662Svikram 		root_opt = (strcmp(osroot, menu_root) == 0);
8062eb2bd662Svikram 		goto out;
8063eb2bd662Svikram 	}
8064eb2bd662Svikram 
8065eb2bd662Svikram 	ospecial = get_special(osroot);
8066eb2bd662Svikram 	INJECT_ERROR1("ROOT_OPTIONAL_OSPECIAL", ospecial = NULL);
8067eb2bd662Svikram 	if (ospecial == NULL) {
8068eb2bd662Svikram 		bam_error(GET_OSROOT_SPECIAL_ERR, osroot);
8069eb2bd662Svikram 		return (0);
8070eb2bd662Svikram 	}
8071eb2bd662Svikram 	BAM_DPRINTF((D_ROOT_OPTIONAL_OSPECIAL, fcn, ospecial, osroot));
8072eb2bd662Svikram 
8073eb2bd662Svikram 	mspecial = get_special(menu_root);
8074eb2bd662Svikram 	INJECT_ERROR1("ROOT_OPTIONAL_MSPECIAL", mspecial = NULL);
8075eb2bd662Svikram 	if (mspecial == NULL) {
8076eb2bd662Svikram 		bam_error(GET_MENU_ROOT_SPECIAL_ERR, menu_root);
8077eb2bd662Svikram 		free(ospecial);
8078eb2bd662Svikram 		return (0);
8079eb2bd662Svikram 	}
8080eb2bd662Svikram 	BAM_DPRINTF((D_ROOT_OPTIONAL_MSPECIAL, fcn, mspecial, menu_root));
8081eb2bd662Svikram 
8082eb2bd662Svikram 	slash = strchr(ospecial, '/');
8083eb2bd662Svikram 	if (slash)
8084eb2bd662Svikram 		*slash = '\0';
8085eb2bd662Svikram 	BAM_DPRINTF((D_ROOT_OPTIONAL_FIXED_OSPECIAL, fcn, ospecial, osroot));
8086eb2bd662Svikram 
8087eb2bd662Svikram 	root_opt = (strcmp(ospecial, mspecial) == 0);
8088eb2bd662Svikram 
8089eb2bd662Svikram 	free(ospecial);
8090eb2bd662Svikram 	free(mspecial);
8091eb2bd662Svikram 
8092eb2bd662Svikram out:
8093eb2bd662Svikram 	INJECT_ERROR1("ROOT_OPTIONAL_NO", root_opt = 0);
8094eb2bd662Svikram 	INJECT_ERROR1("ROOT_OPTIONAL_YES", root_opt = 1);
8095eb2bd662Svikram 	if (root_opt) {
8096eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
8097eb2bd662Svikram 	} else {
8098eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
8099eb2bd662Svikram 	}
8100eb2bd662Svikram 
8101eb2bd662Svikram 	return (root_opt);
8102eb2bd662Svikram }
8103eb2bd662Svikram 
81047c478bd9Sstevel@tonic-gate /*ARGSUSED*/
81057c478bd9Sstevel@tonic-gate static error_t
8106eb2bd662Svikram update_entry(menu_t *mp, char *menu_root, char *osdev)
81077c478bd9Sstevel@tonic-gate {
81087c478bd9Sstevel@tonic-gate 	int		entry;
8109eb2bd662Svikram 	char		*grubsign;
8110eb2bd662Svikram 	char		*grubroot;
8111eb2bd662Svikram 	char		*title;
8112eb2bd662Svikram 	char		osroot[PATH_MAX];
8113eb2bd662Svikram 	char		*failsafe_kernel = NULL;
81148c1b6884Sszhou 	struct stat	sbuf;
81158c1b6884Sszhou 	char		failsafe[256];
8116bbcc54bdSEnrico Perla - Sun Microsystems 	char		failsafe_64[256];
8117eb2bd662Svikram 	int		ret;
8118eb2bd662Svikram 	const char	*fcn = "update_entry()";
81197c478bd9Sstevel@tonic-gate 
81207c478bd9Sstevel@tonic-gate 	assert(mp);
8121eb2bd662Svikram 	assert(menu_root);
8122eb2bd662Svikram 	assert(osdev);
8123eb2bd662Svikram 	assert(bam_root);
81247c478bd9Sstevel@tonic-gate 
8125eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY3, fcn, menu_root, osdev, bam_root));
8126eb2bd662Svikram 
8127eb2bd662Svikram 	(void) strlcpy(osroot, bam_root, sizeof (osroot));
8128eb2bd662Svikram 
81297c478bd9Sstevel@tonic-gate 	title = get_title(osroot);
8130eb2bd662Svikram 	assert(title);
81317c478bd9Sstevel@tonic-gate 
8132eb2bd662Svikram 	grubsign = get_grubsign(osroot, osdev);
8133eb2bd662Svikram 	INJECT_ERROR1("GET_GRUBSIGN_FAIL", grubsign = NULL);
8134eb2bd662Svikram 	if (grubsign == NULL) {
8135eb2bd662Svikram 		bam_error(GET_GRUBSIGN_ERROR, osroot, osdev);
81367c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
81377c478bd9Sstevel@tonic-gate 	}
8138eb2bd662Svikram 
8139eb2bd662Svikram 	/*
8140eb2bd662Svikram 	 * It is not a fatal error if get_grubroot() fails
8141eb2bd662Svikram 	 * We no longer rely on biosdev to populate the
8142eb2bd662Svikram 	 * menu
8143eb2bd662Svikram 	 */
8144eb2bd662Svikram 	grubroot = get_grubroot(osroot, osdev, menu_root);
8145eb2bd662Svikram 	INJECT_ERROR1("GET_GRUBROOT_FAIL", grubroot = NULL);
8146eb2bd662Svikram 	if (grubroot) {
8147eb2bd662Svikram 		BAM_DPRINTF((D_GET_GRUBROOT_SUCCESS,
8148eb2bd662Svikram 		    fcn, osroot, osdev, menu_root));
8149eb2bd662Svikram 	} else {
8150eb2bd662Svikram 		BAM_DPRINTF((D_GET_GRUBROOT_FAILURE,
8151eb2bd662Svikram 		    fcn, osroot, osdev, menu_root));
81527c478bd9Sstevel@tonic-gate 	}
81537c478bd9Sstevel@tonic-gate 
81547c478bd9Sstevel@tonic-gate 	/* add the entry for normal Solaris */
8155eb2bd662Svikram 	INJECT_ERROR1("UPDATE_ENTRY_MULTIBOOT",
8156eb2bd662Svikram 	    bam_direct = BAM_DIRECT_MULTIBOOT);
8157ae115bc7Smrj 	if (bam_direct == BAM_DIRECT_DBOOT) {
8158eb2bd662Svikram 		entry = update_boot_entry(mp, title, grubsign, grubroot,
8159e7cbe64fSgw25295 		    (bam_zfs ? DIRECT_BOOT_KERNEL_ZFS : DIRECT_BOOT_KERNEL),
8160eb2bd662Svikram 		    NULL, DIRECT_BOOT_ARCHIVE,
8161eb2bd662Svikram 		    root_optional(osroot, menu_root));
8162eb2bd662Svikram 		BAM_DPRINTF((D_UPDATED_BOOT_ENTRY, fcn, bam_zfs, grubsign));
8163843e1988Sjohnlev 		if ((entry != BAM_ERROR) && (bam_is_hv == BAM_HV_PRESENT)) {
8164eb2bd662Svikram 			(void) update_boot_entry(mp, NEW_HV_ENTRY, grubsign,
8165eb2bd662Svikram 			    grubroot, XEN_MENU, bam_zfs ?
8166eb2bd662Svikram 			    XEN_KERNEL_MODULE_LINE_ZFS : XEN_KERNEL_MODULE_LINE,
8167eb2bd662Svikram 			    DIRECT_BOOT_ARCHIVE,
8168eb2bd662Svikram 			    root_optional(osroot, menu_root));
8169eb2bd662Svikram 			BAM_DPRINTF((D_UPDATED_HV_ENTRY,
8170eb2bd662Svikram 			    fcn, bam_zfs, grubsign));
8171ae115bc7Smrj 		}
8172843e1988Sjohnlev 	} else {
8173eb2bd662Svikram 		entry = update_boot_entry(mp, title, grubsign, grubroot,
8174eb2bd662Svikram 		    MULTI_BOOT, NULL, MULTIBOOT_ARCHIVE,
8175eb2bd662Svikram 		    root_optional(osroot, menu_root));
8176eb2bd662Svikram 
8177eb2bd662Svikram 		BAM_DPRINTF((D_UPDATED_MULTIBOOT_ENTRY, fcn, grubsign));
8178843e1988Sjohnlev 	}
81797c478bd9Sstevel@tonic-gate 
8180843e1988Sjohnlev 	/*
8181843e1988Sjohnlev 	 * Add the entry for failsafe archive.  On a bfu'd system, the
8182843e1988Sjohnlev 	 * failsafe may be different than the installed kernel.
8183843e1988Sjohnlev 	 */
8184eb2bd662Svikram 	(void) snprintf(failsafe, sizeof (failsafe), "%s%s",
8185bbcc54bdSEnrico Perla - Sun Microsystems 	    osroot, FAILSAFE_ARCHIVE_32);
8186bbcc54bdSEnrico Perla - Sun Microsystems 	(void) snprintf(failsafe_64, sizeof (failsafe_64), "%s%s",
8187bbcc54bdSEnrico Perla - Sun Microsystems 	    osroot, FAILSAFE_ARCHIVE_64);
8188bbcc54bdSEnrico Perla - Sun Microsystems 
8189bbcc54bdSEnrico Perla - Sun Microsystems 	/*
8190bbcc54bdSEnrico Perla - Sun Microsystems 	 * Check if at least one of the two archives exists
8191bbcc54bdSEnrico Perla - Sun Microsystems 	 * Using $ISADIR as the default line, we have an entry which works
8192bbcc54bdSEnrico Perla - Sun Microsystems 	 * for both the cases.
8193bbcc54bdSEnrico Perla - Sun Microsystems 	 */
8194bbcc54bdSEnrico Perla - Sun Microsystems 
8195bbcc54bdSEnrico Perla - Sun Microsystems 	if (stat(failsafe, &sbuf) == 0 || stat(failsafe_64, &sbuf) == 0) {
819660d0a590Srscott 
819760d0a590Srscott 		/* Figure out where the kernel line should point */
819860d0a590Srscott 		(void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot,
8199bbcc54bdSEnrico Perla - Sun Microsystems 		    DIRECT_BOOT_FAILSAFE_32);
8200bbcc54bdSEnrico Perla - Sun Microsystems 		(void) snprintf(failsafe_64, sizeof (failsafe_64), "%s%s",
8201bbcc54bdSEnrico Perla - Sun Microsystems 		    osroot, DIRECT_BOOT_FAILSAFE_64);
8202bbcc54bdSEnrico Perla - Sun Microsystems 		if (stat(failsafe, &sbuf) == 0 ||
8203bbcc54bdSEnrico Perla - Sun Microsystems 		    stat(failsafe_64, &sbuf) == 0) {
8204963390b4Svikram 			failsafe_kernel = DIRECT_BOOT_FAILSAFE_LINE;
820560d0a590Srscott 		} else {
820660d0a590Srscott 			(void) snprintf(failsafe, sizeof (failsafe), "%s%s",
820760d0a590Srscott 			    osroot, MULTI_BOOT_FAILSAFE);
820860d0a590Srscott 			if (stat(failsafe, &sbuf) == 0) {
820960d0a590Srscott 				failsafe_kernel = MULTI_BOOT_FAILSAFE_LINE;
821060d0a590Srscott 			}
821160d0a590Srscott 		}
821260d0a590Srscott 		if (failsafe_kernel != NULL) {
8213eb2bd662Svikram 			(void) update_boot_entry(mp, FAILSAFE_TITLE, grubsign,
8214eb2bd662Svikram 			    grubroot, failsafe_kernel, NULL, FAILSAFE_ARCHIVE,
8215eb2bd662Svikram 			    root_optional(osroot, menu_root));
8216eb2bd662Svikram 			BAM_DPRINTF((D_UPDATED_FAILSAFE_ENTRY, fcn,
8217eb2bd662Svikram 			    failsafe_kernel));
821860d0a590Srscott 		}
8219ae115bc7Smrj 	}
8220eb2bd662Svikram 	free(grubroot);
82217c478bd9Sstevel@tonic-gate 
8222eb2bd662Svikram 	INJECT_ERROR1("UPDATE_ENTRY_ERROR", entry = BAM_ERROR);
82237c478bd9Sstevel@tonic-gate 	if (entry == BAM_ERROR) {
8224eb2bd662Svikram 		bam_error(FAILED_TO_ADD_BOOT_ENTRY, title, grubsign);
8225eb2bd662Svikram 		free(grubsign);
82267c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
82277c478bd9Sstevel@tonic-gate 	}
8228eb2bd662Svikram 	free(grubsign);
8229eb2bd662Svikram 
8230eb2bd662Svikram 	update_numbering(mp);
8231eb2bd662Svikram 	ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry);
8232eb2bd662Svikram 	INJECT_ERROR1("SET_DEFAULT_ERROR", ret = BAM_ERROR);
8233eb2bd662Svikram 	if (ret == BAM_ERROR) {
8234eb2bd662Svikram 		bam_error(SET_DEFAULT_FAILED, entry);
8235eb2bd662Svikram 	}
8236eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
82377c478bd9Sstevel@tonic-gate 	return (BAM_WRITE);
82387c478bd9Sstevel@tonic-gate }
82397c478bd9Sstevel@tonic-gate 
82408c1b6884Sszhou static void
8241ae115bc7Smrj save_default_entry(menu_t *mp, const char *which)
82428c1b6884Sszhou {
8243eb2bd662Svikram 	int		lineNum;
8244eb2bd662Svikram 	int		entryNum;
82458c1b6884Sszhou 	int		entry = 0;	/* default is 0 */
82468c1b6884Sszhou 	char		linebuf[BAM_MAXLINE];
82478c1b6884Sszhou 	line_t		*lp = mp->curdefault;
8248eb2bd662Svikram 	const char	*fcn = "save_default_entry()";
82498c1b6884Sszhou 
8250bff269d0Svikram 	if (mp->start) {
8251bff269d0Svikram 		lineNum = mp->end->lineNum;
8252bff269d0Svikram 		entryNum = mp->end->entryNum;
8253bff269d0Svikram 	} else {
8254bff269d0Svikram 		lineNum = LINE_INIT;
8255bff269d0Svikram 		entryNum = ENTRY_INIT;
8256bff269d0Svikram 	}
8257bff269d0Svikram 
82588c1b6884Sszhou 	if (lp)
82598c1b6884Sszhou 		entry = s_strtol(lp->arg);
82608c1b6884Sszhou 
8261ae115bc7Smrj 	(void) snprintf(linebuf, sizeof (linebuf), "#%s%d", which, entry);
8262eb2bd662Svikram 	BAM_DPRINTF((D_SAVING_DEFAULT_TO, fcn, linebuf));
82638c1b6884Sszhou 	line_parser(mp, linebuf, &lineNum, &entryNum);
8264eb2bd662Svikram 	BAM_DPRINTF((D_SAVED_DEFAULT_TO, fcn, lineNum, entryNum));
82658c1b6884Sszhou }
82668c1b6884Sszhou 
82678c1b6884Sszhou static void
8268ae115bc7Smrj restore_default_entry(menu_t *mp, const char *which, line_t *lp)
82698c1b6884Sszhou {
82708c1b6884Sszhou 	int		entry;
82718c1b6884Sszhou 	char		*str;
8272eb2bd662Svikram 	const char	*fcn = "restore_default_entry()";
82738c1b6884Sszhou 
8274eb2bd662Svikram 	if (lp == NULL) {
8275eb2bd662Svikram 		BAM_DPRINTF((D_RESTORE_DEFAULT_NULL, fcn));
82768c1b6884Sszhou 		return;		/* nothing to restore */
8277eb2bd662Svikram 	}
8278eb2bd662Svikram 
8279eb2bd662Svikram 	BAM_DPRINTF((D_RESTORE_DEFAULT_STR, fcn, which));
82808c1b6884Sszhou 
8281ae115bc7Smrj 	str = lp->arg + strlen(which);
82828c1b6884Sszhou 	entry = s_strtol(str);
82838c1b6884Sszhou 	(void) set_global(mp, menu_cmds[DEFAULT_CMD], entry);
82848c1b6884Sszhou 
8285eb2bd662Svikram 	BAM_DPRINTF((D_RESTORED_DEFAULT_TO, fcn, entry));
8286eb2bd662Svikram 
82878c1b6884Sszhou 	/* delete saved old default line */
82888c1b6884Sszhou 	unlink_line(mp, lp);
82898c1b6884Sszhou 	line_free(lp);
82908c1b6884Sszhou }
82918c1b6884Sszhou 
82927c478bd9Sstevel@tonic-gate /*
82937c478bd9Sstevel@tonic-gate  * This function is for supporting reboot with args.
82947c478bd9Sstevel@tonic-gate  * The opt value can be:
82957c478bd9Sstevel@tonic-gate  * NULL		delete temp entry, if present
8296eb2bd662Svikram  * entry=<n>	switches default entry to <n>
82977c478bd9Sstevel@tonic-gate  * else		treated as boot-args and setup a temperary menu entry
82987c478bd9Sstevel@tonic-gate  *		and make it the default
8299eb2bd662Svikram  * Note that we are always rebooting the current OS instance
8300eb2bd662Svikram  * so osroot == / always.
83017c478bd9Sstevel@tonic-gate  */
83027c478bd9Sstevel@tonic-gate #define	REBOOT_TITLE	"Solaris_reboot_transient"
83037c478bd9Sstevel@tonic-gate 
83048c1b6884Sszhou /*ARGSUSED*/
83057c478bd9Sstevel@tonic-gate static error_t
8306eb2bd662Svikram update_temp(menu_t *mp, char *dummy, char *opt)
83077c478bd9Sstevel@tonic-gate {
83087c478bd9Sstevel@tonic-gate 	int		entry;
8309eb2bd662Svikram 	char		*osdev;
8310eb2bd662Svikram 	char		*fstype;
8311eb2bd662Svikram 	char		*sign;
8312eb2bd662Svikram 	char		*opt_ptr;
8313eb2bd662Svikram 	char		*path;
8314ae115bc7Smrj 	char		kernbuf[BUFSIZ];
8315ae115bc7Smrj 	char		args_buf[BUFSIZ];
8316eb2bd662Svikram 	char		signbuf[PATH_MAX];
8317eb2bd662Svikram 	int		ret;
8318eb2bd662Svikram 	const char	*fcn = "update_temp()";
83197c478bd9Sstevel@tonic-gate 
83207c478bd9Sstevel@tonic-gate 	assert(mp);
8321eb2bd662Svikram 	assert(dummy == NULL);
8322eb2bd662Svikram 
8323eb2bd662Svikram 	/* opt can be NULL */
8324eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, opt ? opt : "<NULL>"));
8325eb2bd662Svikram 	BAM_DPRINTF((D_BAM_ROOT, fcn, bam_alt_root, bam_root));
8326eb2bd662Svikram 
8327eb2bd662Svikram 	if (bam_alt_root || bam_rootlen != 1 ||
8328eb2bd662Svikram 	    strcmp(bam_root, "/") != 0 ||
8329eb2bd662Svikram 	    strcmp(rootbuf, "/") != 0) {
8330eb2bd662Svikram 		bam_error(ALT_ROOT_INVALID, bam_root);
8331eb2bd662Svikram 		return (BAM_ERROR);
8332eb2bd662Svikram 	}
83337c478bd9Sstevel@tonic-gate 
83348c1b6884Sszhou 	/* If no option, delete exiting reboot menu entry */
83358c1b6884Sszhou 	if (opt == NULL) {
8336eb2bd662Svikram 		entry_t		*ent;
8337eb2bd662Svikram 		BAM_DPRINTF((D_OPT_NULL, fcn));
8338eb2bd662Svikram 		ent = find_boot_entry(mp, REBOOT_TITLE, NULL, NULL,
8339eb2bd662Svikram 		    NULL, NULL, 0, &entry);
8340eb2bd662Svikram 		if (ent == NULL) {	/* not found is ok */
8341eb2bd662Svikram 			BAM_DPRINTF((D_TRANSIENT_NOTFOUND, fcn));
83428c1b6884Sszhou 			return (BAM_SUCCESS);
8343eb2bd662Svikram 		}
834444da779fSWilliam Kucharski 		(void) delete_boot_entry(mp, entry, DBE_PRINTERR);
8345ae115bc7Smrj 		restore_default_entry(mp, BAM_OLDDEF, mp->olddefault);
8346ae115bc7Smrj 		mp->olddefault = NULL;
8347eb2bd662Svikram 		BAM_DPRINTF((D_RESTORED_DEFAULT, fcn));
8348eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
83498c1b6884Sszhou 		return (BAM_WRITE);
83508c1b6884Sszhou 	}
83518c1b6884Sszhou 
83528c1b6884Sszhou 	/* if entry= is specified, set the default entry */
8353eb2bd662Svikram 	if (strncmp(opt, "entry=", strlen("entry=")) == 0) {
8354eb2bd662Svikram 		int entryNum = s_strtol(opt + strlen("entry="));
8355eb2bd662Svikram 		BAM_DPRINTF((D_ENTRY_EQUALS, fcn, opt));
8356eb2bd662Svikram 		if (selector(mp, opt, &entry, NULL) == BAM_SUCCESS) {
83577c478bd9Sstevel@tonic-gate 			/* this is entry=# option */
8358eb2bd662Svikram 			ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry);
8359eb2bd662Svikram 			BAM_DPRINTF((D_ENTRY_SET_IS, fcn, entry, ret));
8360eb2bd662Svikram 			return (ret);
8361eb2bd662Svikram 		} else {
8362eb2bd662Svikram 			bam_error(SET_DEFAULT_FAILED, entryNum);
8363eb2bd662Svikram 			return (BAM_ERROR);
8364eb2bd662Svikram 		}
83657c478bd9Sstevel@tonic-gate 	}
83667c478bd9Sstevel@tonic-gate 
83677c478bd9Sstevel@tonic-gate 	/*
8368eb2bd662Svikram 	 * add a new menu entry based on opt and make it the default
8369b610f78eSvikram 	 */
8370eb2bd662Svikram 
8371eb2bd662Svikram 	fstype = get_fstype("/");
8372eb2bd662Svikram 	INJECT_ERROR1("REBOOT_FSTYPE_NULL", fstype = NULL);
8373eb2bd662Svikram 	if (fstype == NULL) {
8374eb2bd662Svikram 		bam_error(REBOOT_FSTYPE_FAILED);
8375eb2bd662Svikram 		return (BAM_ERROR);
83767c478bd9Sstevel@tonic-gate 	}
8377eb2bd662Svikram 
8378eb2bd662Svikram 	osdev = get_special("/");
8379eb2bd662Svikram 	INJECT_ERROR1("REBOOT_SPECIAL_NULL", osdev = NULL);
8380eb2bd662Svikram 	if (osdev == NULL) {
8381eb2bd662Svikram 		free(fstype);
8382eb2bd662Svikram 		bam_error(REBOOT_SPECIAL_FAILED);
8383eb2bd662Svikram 		return (BAM_ERROR);
8384b610f78eSvikram 	}
8385eb2bd662Svikram 
8386eb2bd662Svikram 	sign = find_existing_sign("/", osdev, fstype);
8387eb2bd662Svikram 	INJECT_ERROR1("REBOOT_SIGN_NULL", sign = NULL);
8388eb2bd662Svikram 	if (sign == NULL) {
8389eb2bd662Svikram 		free(fstype);
8390eb2bd662Svikram 		free(osdev);
8391eb2bd662Svikram 		bam_error(REBOOT_SIGN_FAILED);
8392eb2bd662Svikram 		return (BAM_ERROR);
8393eb2bd662Svikram 	}
8394eb2bd662Svikram 
8395eb2bd662Svikram 	free(osdev);
8396eb2bd662Svikram 	(void) strlcpy(signbuf, sign, sizeof (signbuf));
8397eb2bd662Svikram 	free(sign);
8398eb2bd662Svikram 
8399eb2bd662Svikram 	assert(strchr(signbuf, '(') == NULL && strchr(signbuf, ',') == NULL &&
8400eb2bd662Svikram 	    strchr(signbuf, ')') == NULL);
8401eb2bd662Svikram 
8402eb2bd662Svikram 	/*
8403eb2bd662Svikram 	 * There is no alternate root while doing reboot with args
8404eb2bd662Svikram 	 * This version of bootadm is only delivered with a DBOOT
8405eb2bd662Svikram 	 * version of Solaris.
8406eb2bd662Svikram 	 */
8407eb2bd662Svikram 	INJECT_ERROR1("REBOOT_NOT_DBOOT", bam_direct = BAM_DIRECT_MULTIBOOT);
8408eb2bd662Svikram 	if (bam_direct != BAM_DIRECT_DBOOT) {
84099bd6d269SLin Ling 		free(fstype);
8410eb2bd662Svikram 		bam_error(REBOOT_DIRECT_FAILED);
84117c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
84127c478bd9Sstevel@tonic-gate 	}
84137c478bd9Sstevel@tonic-gate 
84147c478bd9Sstevel@tonic-gate 	/* add an entry for Solaris reboot */
8415ae115bc7Smrj 	if (opt[0] == '-') {
8416ae115bc7Smrj 		/* It's an option - first see if boot-file is set */
8417eb2bd662Svikram 		ret = get_kernel(mp, KERNEL_CMD, kernbuf, sizeof (kernbuf));
8418eb2bd662Svikram 		INJECT_ERROR1("REBOOT_GET_KERNEL", ret = BAM_ERROR);
8419eb2bd662Svikram 		if (ret != BAM_SUCCESS) {
84209bd6d269SLin Ling 			free(fstype);
8421eb2bd662Svikram 			bam_error(REBOOT_GET_KERNEL_FAILED);
8422ae115bc7Smrj 			return (BAM_ERROR);
8423eb2bd662Svikram 		}
8424ae115bc7Smrj 		if (kernbuf[0] == '\0')
8425eb2bd662Svikram 			(void) strlcpy(kernbuf, DIRECT_BOOT_KERNEL,
8426eb2bd662Svikram 			    sizeof (kernbuf));
84279bd6d269SLin Ling 		/*
84289bd6d269SLin Ling 		 * If this is a zfs file system and kernbuf does not
84299bd6d269SLin Ling 		 * have "-B $ZFS-BOOTFS" string yet, add it.
84309bd6d269SLin Ling 		 */
84319bd6d269SLin Ling 		if (strcmp(fstype, "zfs") == 0 && !strstr(kernbuf, ZFS_BOOT)) {
84329bd6d269SLin Ling 			(void) strlcat(kernbuf, " ", sizeof (kernbuf));
84339bd6d269SLin Ling 			(void) strlcat(kernbuf, ZFS_BOOT, sizeof (kernbuf));
84349bd6d269SLin Ling 		}
8435eb2bd662Svikram 		(void) strlcat(kernbuf, " ", sizeof (kernbuf));
8436eb2bd662Svikram 		(void) strlcat(kernbuf, opt, sizeof (kernbuf));
8437eb2bd662Svikram 		BAM_DPRINTF((D_REBOOT_OPTION, fcn, kernbuf));
8438ae115bc7Smrj 	} else if (opt[0] == '/') {
8439455710d3Srscott 		/* It's a full path, so write it out. */
8440eb2bd662Svikram 		(void) strlcpy(kernbuf, opt, sizeof (kernbuf));
8441455710d3Srscott 
8442455710d3Srscott 		/*
8443455710d3Srscott 		 * If someone runs:
8444455710d3Srscott 		 *
8445455710d3Srscott 		 *	# eeprom boot-args='-kd'
8446455710d3Srscott 		 *	# reboot /platform/i86pc/kernel/unix
8447455710d3Srscott 		 *
8448455710d3Srscott 		 * we want to use the boot-args as part of the boot
8449455710d3Srscott 		 * line.  On the other hand, if someone runs:
8450455710d3Srscott 		 *
8451455710d3Srscott 		 *	# reboot "/platform/i86pc/kernel/unix -kd"
8452455710d3Srscott 		 *
8453455710d3Srscott 		 * we don't need to mess with boot-args.  If there's
8454455710d3Srscott 		 * no space in the options string, assume we're in the
8455455710d3Srscott 		 * first case.
8456455710d3Srscott 		 */
8457455710d3Srscott 		if (strchr(opt, ' ') == NULL) {
8458eb2bd662Svikram 			ret = get_kernel(mp, ARGS_CMD, args_buf,
8459eb2bd662Svikram 			    sizeof (args_buf));
8460eb2bd662Svikram 			INJECT_ERROR1("REBOOT_GET_ARGS", ret = BAM_ERROR);
8461eb2bd662Svikram 			if (ret != BAM_SUCCESS) {
84629bd6d269SLin Ling 				free(fstype);
8463eb2bd662Svikram 				bam_error(REBOOT_GET_ARGS_FAILED);
8464455710d3Srscott 				return (BAM_ERROR);
8465eb2bd662Svikram 			}
8466455710d3Srscott 
8467455710d3Srscott 			if (args_buf[0] != '\0') {
8468eb2bd662Svikram 				(void) strlcat(kernbuf, " ", sizeof (kernbuf));
8469455710d3Srscott 				(void) strlcat(kernbuf, args_buf,
8470eb2bd662Svikram 				    sizeof (kernbuf));
8471455710d3Srscott 			}
8472455710d3Srscott 		}
8473eb2bd662Svikram 		BAM_DPRINTF((D_REBOOT_ABSPATH, fcn, kernbuf));
8474ae115bc7Smrj 	} else {
8475455710d3Srscott 		/*
8476455710d3Srscott 		 * It may be a partial path, or it may be a partial
8477455710d3Srscott 		 * path followed by options.  Assume that only options
8478455710d3Srscott 		 * follow a space.  If someone sends us a kernel path
8479455710d3Srscott 		 * that includes a space, they deserve to be broken.
8480455710d3Srscott 		 */
8481455710d3Srscott 		opt_ptr = strchr(opt, ' ');
8482455710d3Srscott 		if (opt_ptr != NULL) {
8483455710d3Srscott 			*opt_ptr = '\0';
8484455710d3Srscott 		}
8485455710d3Srscott 
8486ae115bc7Smrj 		path = expand_path(opt);
8487ae115bc7Smrj 		if (path != NULL) {
8488eb2bd662Svikram 			(void) strlcpy(kernbuf, path, sizeof (kernbuf));
8489ae115bc7Smrj 			free(path);
8490455710d3Srscott 
8491455710d3Srscott 			/*
8492455710d3Srscott 			 * If there were options given, use those.
8493455710d3Srscott 			 * Otherwise, copy over the default options.
8494455710d3Srscott 			 */
8495455710d3Srscott 			if (opt_ptr != NULL) {
8496455710d3Srscott 				/* Restore the space in opt string */
8497455710d3Srscott 				*opt_ptr = ' ';
8498455710d3Srscott 				(void) strlcat(kernbuf, opt_ptr,
8499eb2bd662Svikram 				    sizeof (kernbuf));
8500455710d3Srscott 			} else {
8501eb2bd662Svikram 				ret = get_kernel(mp, ARGS_CMD, args_buf,
8502eb2bd662Svikram 				    sizeof (args_buf));
8503eb2bd662Svikram 				INJECT_ERROR1("UPDATE_TEMP_PARTIAL_ARGS",
8504eb2bd662Svikram 				    ret = BAM_ERROR);
8505eb2bd662Svikram 				if (ret != BAM_SUCCESS) {
85069bd6d269SLin Ling 					free(fstype);
8507eb2bd662Svikram 					bam_error(REBOOT_GET_ARGS_FAILED);
8508ae115bc7Smrj 					return (BAM_ERROR);
8509eb2bd662Svikram 				}
8510ae115bc7Smrj 
8511ae115bc7Smrj 				if (args_buf[0] != '\0') {
8512ae115bc7Smrj 					(void) strlcat(kernbuf, " ",
8513eb2bd662Svikram 					    sizeof (kernbuf));
8514ae115bc7Smrj 					(void) strlcat(kernbuf,
8515eb2bd662Svikram 					    args_buf, sizeof (kernbuf));
8516ae115bc7Smrj 				}
8517ae115bc7Smrj 			}
8518eb2bd662Svikram 			BAM_DPRINTF((D_REBOOT_RESOLVED_PARTIAL, fcn, kernbuf));
8519455710d3Srscott 		} else {
85209bd6d269SLin Ling 			free(fstype);
8521455710d3Srscott 			bam_error(UNKNOWN_KERNEL, opt);
8522455710d3Srscott 			bam_print_stderr(UNKNOWN_KERNEL_REBOOT);
8523455710d3Srscott 			return (BAM_ERROR);
8524ae115bc7Smrj 		}
8525ae115bc7Smrj 	}
85269bd6d269SLin Ling 	free(fstype);
8527eb2bd662Svikram 	entry = add_boot_entry(mp, REBOOT_TITLE, signbuf, kernbuf,
852844da779fSWilliam Kucharski 	    NULL, NULL, NULL);
8529eb2bd662Svikram 	INJECT_ERROR1("REBOOT_ADD_BOOT_ENTRY", entry = BAM_ERROR);
85307c478bd9Sstevel@tonic-gate 	if (entry == BAM_ERROR) {
8531eb2bd662Svikram 		bam_error(REBOOT_WITH_ARGS_ADD_ENTRY_FAILED);
85327c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
85337c478bd9Sstevel@tonic-gate 	}
85348c1b6884Sszhou 
8535ae115bc7Smrj 	save_default_entry(mp, BAM_OLDDEF);
8536eb2bd662Svikram 	ret = set_global(mp, menu_cmds[DEFAULT_CMD], entry);
8537eb2bd662Svikram 	INJECT_ERROR1("REBOOT_SET_GLOBAL", ret = BAM_ERROR);
8538eb2bd662Svikram 	if (ret == BAM_ERROR) {
8539eb2bd662Svikram 		bam_error(REBOOT_SET_DEFAULT_FAILED, entry);
8540eb2bd662Svikram 	}
8541eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
85427c478bd9Sstevel@tonic-gate 	return (BAM_WRITE);
85437c478bd9Sstevel@tonic-gate }
85447c478bd9Sstevel@tonic-gate 
854544da779fSWilliam Kucharski error_t
85467c478bd9Sstevel@tonic-gate set_global(menu_t *mp, char *globalcmd, int val)
85477c478bd9Sstevel@tonic-gate {
8548eb2bd662Svikram 	line_t		*lp;
8549eb2bd662Svikram 	line_t		*found;
8550eb2bd662Svikram 	line_t		*last;
8551eb2bd662Svikram 	char		*cp;
8552eb2bd662Svikram 	char		*str;
85537c478bd9Sstevel@tonic-gate 	char		prefix[BAM_MAXLINE];
85547c478bd9Sstevel@tonic-gate 	size_t		len;
8555eb2bd662Svikram 	const char	*fcn = "set_global()";
85567c478bd9Sstevel@tonic-gate 
85577c478bd9Sstevel@tonic-gate 	assert(mp);
85587c478bd9Sstevel@tonic-gate 	assert(globalcmd);
85597c478bd9Sstevel@tonic-gate 
8560b610f78eSvikram 	if (strcmp(globalcmd, menu_cmds[DEFAULT_CMD]) == 0) {
8561eb2bd662Svikram 		INJECT_ERROR1("SET_GLOBAL_VAL_NEG", val = -1);
8562eb2bd662Svikram 		INJECT_ERROR1("SET_GLOBAL_MENU_EMPTY", mp->end = NULL);
8563eb2bd662Svikram 		INJECT_ERROR1("SET_GLOBAL_VAL_TOO_BIG", val = 100);
8564b610f78eSvikram 		if (val < 0 || mp->end == NULL || val > mp->end->entryNum) {
8565b610f78eSvikram 			(void) snprintf(prefix, sizeof (prefix), "%d", val);
8566b610f78eSvikram 			bam_error(INVALID_ENTRY, prefix);
8567b610f78eSvikram 			return (BAM_ERROR);
8568b610f78eSvikram 		}
8569b610f78eSvikram 	}
8570b610f78eSvikram 
85717c478bd9Sstevel@tonic-gate 	found = last = NULL;
85727c478bd9Sstevel@tonic-gate 	for (lp = mp->start; lp; lp = lp->next) {
85737c478bd9Sstevel@tonic-gate 		if (lp->flags != BAM_GLOBAL)
85747c478bd9Sstevel@tonic-gate 			continue;
85757c478bd9Sstevel@tonic-gate 
85767c478bd9Sstevel@tonic-gate 		last = lp; /* track the last global found */
85777c478bd9Sstevel@tonic-gate 
8578eb2bd662Svikram 		INJECT_ERROR1("SET_GLOBAL_NULL_CMD", lp->cmd = NULL);
85797c478bd9Sstevel@tonic-gate 		if (lp->cmd == NULL) {
85807c478bd9Sstevel@tonic-gate 			bam_error(NO_CMD, lp->lineNum);
85817c478bd9Sstevel@tonic-gate 			continue;
85827c478bd9Sstevel@tonic-gate 		}
85837c478bd9Sstevel@tonic-gate 		if (strcmp(globalcmd, lp->cmd) != 0)
85847c478bd9Sstevel@tonic-gate 			continue;
85857c478bd9Sstevel@tonic-gate 
8586eb2bd662Svikram 		BAM_DPRINTF((D_FOUND_GLOBAL, fcn, globalcmd));
8587eb2bd662Svikram 
85887c478bd9Sstevel@tonic-gate 		if (found) {
85897c478bd9Sstevel@tonic-gate 			bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root);
85907c478bd9Sstevel@tonic-gate 		}
85917c478bd9Sstevel@tonic-gate 		found = lp;
85927c478bd9Sstevel@tonic-gate 	}
85937c478bd9Sstevel@tonic-gate 
85947c478bd9Sstevel@tonic-gate 	if (found == NULL) {
85957c478bd9Sstevel@tonic-gate 		lp = s_calloc(1, sizeof (line_t));
85967c478bd9Sstevel@tonic-gate 		if (last == NULL) {
85977c478bd9Sstevel@tonic-gate 			lp->next = mp->start;
85987c478bd9Sstevel@tonic-gate 			mp->start = lp;
85997c478bd9Sstevel@tonic-gate 			mp->end = (mp->end) ? mp->end : lp;
86007c478bd9Sstevel@tonic-gate 		} else {
86017c478bd9Sstevel@tonic-gate 			lp->next = last->next;
86027c478bd9Sstevel@tonic-gate 			last->next = lp;
86037c478bd9Sstevel@tonic-gate 			if (lp->next == NULL)
86047c478bd9Sstevel@tonic-gate 				mp->end = lp;
86057c478bd9Sstevel@tonic-gate 		}
86067c478bd9Sstevel@tonic-gate 		lp->flags = BAM_GLOBAL; /* other fields not needed for writes */
86077c478bd9Sstevel@tonic-gate 		len = strlen(globalcmd) + strlen(menu_cmds[SEP_CMD]);
86087c478bd9Sstevel@tonic-gate 		len += 10;	/* val < 10 digits */
86097c478bd9Sstevel@tonic-gate 		lp->line = s_calloc(1, len);
86107c478bd9Sstevel@tonic-gate 		(void) snprintf(lp->line, len, "%s%s%d",
86117c478bd9Sstevel@tonic-gate 		    globalcmd, menu_cmds[SEP_CMD], val);
8612eb2bd662Svikram 		BAM_DPRINTF((D_SET_GLOBAL_WROTE_NEW, fcn, lp->line));
8613eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
86147c478bd9Sstevel@tonic-gate 		return (BAM_WRITE);
86157c478bd9Sstevel@tonic-gate 	}
86167c478bd9Sstevel@tonic-gate 
86177c478bd9Sstevel@tonic-gate 	/*
86187c478bd9Sstevel@tonic-gate 	 * We are changing an existing entry. Retain any prefix whitespace,
86197c478bd9Sstevel@tonic-gate 	 * but overwrite everything else. This preserves tabs added for
86207c478bd9Sstevel@tonic-gate 	 * readability.
86217c478bd9Sstevel@tonic-gate 	 */
86227c478bd9Sstevel@tonic-gate 	str = found->line;
86237c478bd9Sstevel@tonic-gate 	cp = prefix;
86247c478bd9Sstevel@tonic-gate 	while (*str == ' ' || *str == '\t')
86257c478bd9Sstevel@tonic-gate 		*(cp++) = *(str++);
86267c478bd9Sstevel@tonic-gate 	*cp = '\0'; /* Terminate prefix */
86277c478bd9Sstevel@tonic-gate 	len = strlen(prefix) + strlen(globalcmd);
86287c478bd9Sstevel@tonic-gate 	len += strlen(menu_cmds[SEP_CMD]) + 10;
86297c478bd9Sstevel@tonic-gate 
86307c478bd9Sstevel@tonic-gate 	free(found->line);
86317c478bd9Sstevel@tonic-gate 	found->line = s_calloc(1, len);
86327c478bd9Sstevel@tonic-gate 	(void) snprintf(found->line, len,
86337c478bd9Sstevel@tonic-gate 	    "%s%s%s%d", prefix, globalcmd, menu_cmds[SEP_CMD], val);
86347c478bd9Sstevel@tonic-gate 
8635eb2bd662Svikram 	BAM_DPRINTF((D_SET_GLOBAL_REPLACED, fcn, found->line));
8636eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
86377c478bd9Sstevel@tonic-gate 	return (BAM_WRITE); /* need a write to menu */
86387c478bd9Sstevel@tonic-gate }
86397c478bd9Sstevel@tonic-gate 
8640ae115bc7Smrj /*
8641ae115bc7Smrj  * partial_path may be anything like "kernel/unix" or "kmdb".  Try to
8642455710d3Srscott  * expand it to a full unix path.  The calling function is expected to
8643455710d3Srscott  * output a message if an error occurs and NULL is returned.
8644ae115bc7Smrj  */
8645ae115bc7Smrj static char *
8646ae115bc7Smrj expand_path(const char *partial_path)
8647ae115bc7Smrj {
8648ae115bc7Smrj 	int		new_path_len;
8649eb2bd662Svikram 	char		*new_path;
8650eb2bd662Svikram 	char		new_path2[PATH_MAX];
8651ae115bc7Smrj 	struct stat	sb;
8652eb2bd662Svikram 	const char	*fcn = "expand_path()";
8653ae115bc7Smrj 
8654ae115bc7Smrj 	new_path_len = strlen(partial_path) + 64;
8655ae115bc7Smrj 	new_path = s_calloc(1, new_path_len);
8656ae115bc7Smrj 
8657ae115bc7Smrj 	/* First, try the simplest case - something like "kernel/unix" */
8658ae115bc7Smrj 	(void) snprintf(new_path, new_path_len, "/platform/i86pc/%s",
8659ae115bc7Smrj 	    partial_path);
8660ae115bc7Smrj 	if (stat(new_path, &sb) == 0) {
8661eb2bd662Svikram 		BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path));
8662ae115bc7Smrj 		return (new_path);
8663ae115bc7Smrj 	}
8664ae115bc7Smrj 
8665ae115bc7Smrj 	if (strcmp(partial_path, "kmdb") == 0) {
8666ae115bc7Smrj 		(void) snprintf(new_path, new_path_len, "%s -k",
8667ae115bc7Smrj 		    DIRECT_BOOT_KERNEL);
8668eb2bd662Svikram 		BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path));
8669ae115bc7Smrj 		return (new_path);
8670ae115bc7Smrj 	}
8671ae115bc7Smrj 
8672ae115bc7Smrj 	/*
8673ae115bc7Smrj 	 * We've quickly reached unsupported usage.  Try once more to
8674ae115bc7Smrj 	 * see if we were just given a glom name.
8675ae115bc7Smrj 	 */
8676ae115bc7Smrj 	(void) snprintf(new_path, new_path_len, "/platform/i86pc/%s/unix",
8677ae115bc7Smrj 	    partial_path);
8678ae115bc7Smrj 	(void) snprintf(new_path2, PATH_MAX, "/platform/i86pc/%s/amd64/unix",
8679ae115bc7Smrj 	    partial_path);
8680ae115bc7Smrj 	if (stat(new_path, &sb) == 0) {
8681ae115bc7Smrj 		if (stat(new_path2, &sb) == 0) {
8682ae115bc7Smrj 			/*
8683ae115bc7Smrj 			 * We matched both, so we actually
8684ae115bc7Smrj 			 * want to write the $ISADIR version.
8685ae115bc7Smrj 			 */
8686ae115bc7Smrj 			(void) snprintf(new_path, new_path_len,
8687ae115bc7Smrj 			    "/platform/i86pc/kernel/%s/$ISADIR/unix",
8688ae115bc7Smrj 			    partial_path);
8689ae115bc7Smrj 		}
8690eb2bd662Svikram 		BAM_DPRINTF((D_EXPAND_PATH, fcn, new_path));
8691ae115bc7Smrj 		return (new_path);
8692ae115bc7Smrj 	}
8693ae115bc7Smrj 
8694ae115bc7Smrj 	free(new_path);
8695eb2bd662Svikram 	BAM_DPRINTF((D_RETURN_FAILURE, fcn));
8696ae115bc7Smrj 	return (NULL);
8697ae115bc7Smrj }
8698ae115bc7Smrj 
8699ae115bc7Smrj /*
8700ae115bc7Smrj  * The kernel cmd and arg have been changed, so
8701ae115bc7Smrj  * check whether the archive line needs to change.
8702ae115bc7Smrj  */
8703ae115bc7Smrj static void
8704ae115bc7Smrj set_archive_line(entry_t *entryp, line_t *kernelp)
8705ae115bc7Smrj {
8706ae115bc7Smrj 	line_t		*lp = entryp->start;
8707ae115bc7Smrj 	char		*new_archive;
8708ae115bc7Smrj 	menu_cmd_t	m_cmd;
8709eb2bd662Svikram 	const char	*fcn = "set_archive_line()";
8710ae115bc7Smrj 
8711ae115bc7Smrj 	for (; lp != NULL; lp = lp->next) {
8712eac223ccSWilliam Kucharski 		if (lp->cmd != NULL && strncmp(lp->cmd, menu_cmds[MODULE_CMD],
8713ae115bc7Smrj 		    sizeof (menu_cmds[MODULE_CMD]) - 1) == 0) {
8714ae115bc7Smrj 			break;
8715ae115bc7Smrj 		}
8716eb2bd662Svikram 
8717eb2bd662Svikram 		INJECT_ERROR1("SET_ARCHIVE_LINE_END_ENTRY", lp = entryp->end);
8718eb2bd662Svikram 		if (lp == entryp->end) {
8719eb2bd662Svikram 			BAM_DPRINTF((D_ARCHIVE_LINE_NONE, fcn,
8720eb2bd662Svikram 			    entryp->entryNum));
8721ae115bc7Smrj 			return;
8722ae115bc7Smrj 		}
8723eb2bd662Svikram 	}
8724eb2bd662Svikram 	INJECT_ERROR1("SET_ARCHIVE_LINE_END_MENU", lp = NULL);
8725eb2bd662Svikram 	if (lp == NULL) {
8726eb2bd662Svikram 		BAM_DPRINTF((D_ARCHIVE_LINE_NONE, fcn, entryp->entryNum));
8727ae115bc7Smrj 		return;
8728eb2bd662Svikram 	}
8729ae115bc7Smrj 
8730ae115bc7Smrj 	if (strstr(kernelp->arg, "$ISADIR") != NULL) {
8731ae115bc7Smrj 		new_archive = DIRECT_BOOT_ARCHIVE;
8732ae115bc7Smrj 		m_cmd = MODULE_DOLLAR_CMD;
8733ae115bc7Smrj 	} else if (strstr(kernelp->arg, "amd64") != NULL) {
8734ae115bc7Smrj 		new_archive = DIRECT_BOOT_ARCHIVE_64;
8735ae115bc7Smrj 		m_cmd = MODULE_CMD;
8736ae115bc7Smrj 	} else {
8737ae115bc7Smrj 		new_archive = DIRECT_BOOT_ARCHIVE_32;
8738ae115bc7Smrj 		m_cmd = MODULE_CMD;
8739ae115bc7Smrj 	}
8740ae115bc7Smrj 
8741eb2bd662Svikram 	if (strcmp(lp->arg, new_archive) == 0) {
8742eb2bd662Svikram 		BAM_DPRINTF((D_ARCHIVE_LINE_NOCHANGE, fcn, lp->arg));
8743ae115bc7Smrj 		return;
8744eb2bd662Svikram 	}
8745ae115bc7Smrj 
8746eac223ccSWilliam Kucharski 	if (lp->cmd != NULL && strcmp(lp->cmd, menu_cmds[m_cmd]) != 0) {
8747ae115bc7Smrj 		free(lp->cmd);
8748ae115bc7Smrj 		lp->cmd = s_strdup(menu_cmds[m_cmd]);
8749ae115bc7Smrj 	}
8750ae115bc7Smrj 
8751ae115bc7Smrj 	free(lp->arg);
8752ae115bc7Smrj 	lp->arg = s_strdup(new_archive);
8753ae115bc7Smrj 	update_line(lp);
8754eb2bd662Svikram 	BAM_DPRINTF((D_ARCHIVE_LINE_REPLACED, fcn, lp->line));
8755ae115bc7Smrj }
8756ae115bc7Smrj 
8757ae115bc7Smrj /*
8758ae115bc7Smrj  * Title for an entry to set properties that once went in bootenv.rc.
8759ae115bc7Smrj  */
8760ae115bc7Smrj #define	BOOTENV_RC_TITLE	"Solaris bootenv rc"
8761ae115bc7Smrj 
8762ae115bc7Smrj /*
8763ae115bc7Smrj  * If path is NULL, return the kernel (optnum == KERNEL_CMD) or arguments
8764ae115bc7Smrj  * (optnum == ARGS_CMD) in the argument buf.  If path is a zero-length
8765ae115bc7Smrj  * string, reset the value to the default.  If path is a non-zero-length
8766ae115bc7Smrj  * string, set the kernel or arguments.
8767ae115bc7Smrj  */
8768ae115bc7Smrj static error_t
8769eb2bd662Svikram get_set_kernel(
8770eb2bd662Svikram 	menu_t *mp,
8771eb2bd662Svikram 	menu_cmd_t optnum,
8772eb2bd662Svikram 	char *path,
8773eb2bd662Svikram 	char *buf,
8774eb2bd662Svikram 	size_t bufsize)
8775ae115bc7Smrj {
8776eb2bd662Svikram 	int		entryNum;
8777eb2bd662Svikram 	int		rv = BAM_SUCCESS;
8778eb2bd662Svikram 	int		free_new_path = 0;
8779ae115bc7Smrj 	entry_t		*entryp;
8780eb2bd662Svikram 	line_t		*ptr;
8781eb2bd662Svikram 	line_t		*kernelp;
8782eb2bd662Svikram 	char		*new_arg;
8783eb2bd662Svikram 	char		*old_args;
8784eb2bd662Svikram 	char		*space;
8785eb2bd662Svikram 	char		*new_path;
8786ae115bc7Smrj 	char		old_space;
8787eb2bd662Svikram 	size_t		old_kernel_len;
8788eb2bd662Svikram 	size_t		new_str_len;
8789eb2bd662Svikram 	char		*fstype;
8790eb2bd662Svikram 	char		*osdev;
8791eb2bd662Svikram 	char		*sign;
8792eb2bd662Svikram 	char		signbuf[PATH_MAX];
8793eb2bd662Svikram 	int		ret;
8794eb2bd662Svikram 	const char	*fcn = "get_set_kernel()";
8795ae115bc7Smrj 
8796ae115bc7Smrj 	assert(bufsize > 0);
8797ae115bc7Smrj 
8798ae115bc7Smrj 	ptr = kernelp = NULL;
8799ae115bc7Smrj 	new_arg = old_args = space = NULL;
8800eb2bd662Svikram 	new_path = NULL;
8801ae115bc7Smrj 	buf[0] = '\0';
8802ae115bc7Smrj 
8803eb2bd662Svikram 	INJECT_ERROR1("GET_SET_KERNEL_NOT_DBOOT",
8804eb2bd662Svikram 	    bam_direct = BAM_DIRECT_MULTIBOOT);
8805ae115bc7Smrj 	if (bam_direct != BAM_DIRECT_DBOOT) {
8806ae115bc7Smrj 		bam_error(NOT_DBOOT, optnum == KERNEL_CMD ? "kernel" : "args");
8807ae115bc7Smrj 		return (BAM_ERROR);
8808ae115bc7Smrj 	}
8809ae115bc7Smrj 
8810ae115bc7Smrj 	/*
8811ae115bc7Smrj 	 * If a user changed the default entry to a non-bootadm controlled
8812ae115bc7Smrj 	 * one, we don't want to mess with it.  Just print an error and
8813ae115bc7Smrj 	 * return.
8814ae115bc7Smrj 	 */
8815ae115bc7Smrj 	if (mp->curdefault) {
8816ae115bc7Smrj 		entryNum = s_strtol(mp->curdefault->arg);
8817ae115bc7Smrj 		for (entryp = mp->entries; entryp; entryp = entryp->next) {
8818ae115bc7Smrj 			if (entryp->entryNum == entryNum)
8819ae115bc7Smrj 				break;
8820ae115bc7Smrj 		}
8821ae115bc7Smrj 		if ((entryp != NULL) &&
8822ae115bc7Smrj 		    ((entryp->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU)) == 0)) {
8823ae115bc7Smrj 			bam_error(DEFAULT_NOT_BAM);
8824ae115bc7Smrj 			return (BAM_ERROR);
8825ae115bc7Smrj 		}
8826ae115bc7Smrj 	}
8827ae115bc7Smrj 
8828eb2bd662Svikram 	entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, NULL,
8829eb2bd662Svikram 	    0, &entryNum);
8830ae115bc7Smrj 
8831ae115bc7Smrj 	if (entryp != NULL) {
8832ae115bc7Smrj 		for (ptr = entryp->start; ptr && ptr != entryp->end;
8833ae115bc7Smrj 		    ptr = ptr->next) {
8834ae115bc7Smrj 			if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD],
8835ae115bc7Smrj 			    sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) {
8836ae115bc7Smrj 				kernelp = ptr;
8837ae115bc7Smrj 				break;
8838ae115bc7Smrj 			}
8839ae115bc7Smrj 		}
8840ae115bc7Smrj 		if (kernelp == NULL) {
8841ae115bc7Smrj 			bam_error(NO_KERNEL, entryNum);
8842ae115bc7Smrj 			return (BAM_ERROR);
8843ae115bc7Smrj 		}
8844ae115bc7Smrj 
8845ae115bc7Smrj 		old_kernel_len = strcspn(kernelp->arg, " \t");
8846ae115bc7Smrj 		space = old_args = kernelp->arg + old_kernel_len;
8847ae115bc7Smrj 		while ((*old_args == ' ') || (*old_args == '\t'))
8848ae115bc7Smrj 			old_args++;
8849ae115bc7Smrj 	}
8850ae115bc7Smrj 
8851ae115bc7Smrj 	if (path == NULL) {
8852eb2bd662Svikram 		if (entryp == NULL) {
8853eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_NO_RC, fcn));
8854eb2bd662Svikram 			BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
8855ae115bc7Smrj 			return (BAM_SUCCESS);
8856eb2bd662Svikram 		}
8857eb2bd662Svikram 		assert(kernelp);
8858ae115bc7Smrj 		if (optnum == ARGS_CMD) {
8859eb2bd662Svikram 			if (old_args[0] != '\0') {
8860ae115bc7Smrj 				(void) strlcpy(buf, old_args, bufsize);
8861eb2bd662Svikram 				BAM_DPRINTF((D_GET_SET_KERNEL_ARGS, fcn, buf));
8862eb2bd662Svikram 			}
8863ae115bc7Smrj 		} else {
8864ae115bc7Smrj 			/*
8865ae115bc7Smrj 			 * We need to print the kernel, so we just turn the
8866ae115bc7Smrj 			 * first space into a '\0' and print the beginning.
8867ae115bc7Smrj 			 * We don't print anything if it's the default kernel.
8868ae115bc7Smrj 			 */
8869ae115bc7Smrj 			old_space = *space;
8870ae115bc7Smrj 			*space = '\0';
8871eb2bd662Svikram 			if (strcmp(kernelp->arg, DIRECT_BOOT_KERNEL) != 0) {
8872ae115bc7Smrj 				(void) strlcpy(buf, kernelp->arg, bufsize);
8873eb2bd662Svikram 				BAM_DPRINTF((D_GET_SET_KERNEL_KERN, fcn, buf));
8874eb2bd662Svikram 			}
8875ae115bc7Smrj 			*space = old_space;
8876ae115bc7Smrj 		}
8877eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
8878ae115bc7Smrj 		return (BAM_SUCCESS);
8879ae115bc7Smrj 	}
8880ae115bc7Smrj 
8881ae115bc7Smrj 	/*
8882ae115bc7Smrj 	 * First, check if we're resetting an entry to the default.
8883ae115bc7Smrj 	 */
8884ae115bc7Smrj 	if ((path[0] == '\0') ||
8885ae115bc7Smrj 	    ((optnum == KERNEL_CMD) &&
8886ae115bc7Smrj 	    (strcmp(path, DIRECT_BOOT_KERNEL) == 0))) {
8887ae115bc7Smrj 		if ((entryp == NULL) || (kernelp == NULL)) {
8888ae115bc7Smrj 			/* No previous entry, it's already the default */
8889eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_ALREADY, fcn));
8890ae115bc7Smrj 			return (BAM_SUCCESS);
8891ae115bc7Smrj 		}
8892ae115bc7Smrj 
8893ae115bc7Smrj 		/*
8894ae115bc7Smrj 		 * Check if we can delete the entry.  If we're resetting the
8895ae115bc7Smrj 		 * kernel command, and the args is already empty, or if we're
8896ae115bc7Smrj 		 * resetting the args command, and the kernel is already the
8897ae115bc7Smrj 		 * default, we can restore the old default and delete the entry.
8898ae115bc7Smrj 		 */
8899ae115bc7Smrj 		if (((optnum == KERNEL_CMD) &&
8900ae115bc7Smrj 		    ((old_args == NULL) || (old_args[0] == '\0'))) ||
8901ae115bc7Smrj 		    ((optnum == ARGS_CMD) &&
8902ae115bc7Smrj 		    (strncmp(kernelp->arg, DIRECT_BOOT_KERNEL,
8903ae115bc7Smrj 		    sizeof (DIRECT_BOOT_KERNEL) - 1) == 0))) {
8904ae115bc7Smrj 			kernelp = NULL;
890544da779fSWilliam Kucharski 			(void) delete_boot_entry(mp, entryNum, DBE_PRINTERR);
8906ae115bc7Smrj 			restore_default_entry(mp, BAM_OLD_RC_DEF,
8907ae115bc7Smrj 			    mp->old_rc_default);
8908ae115bc7Smrj 			mp->old_rc_default = NULL;
8909ae115bc7Smrj 			rv = BAM_WRITE;
8910eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_RESTORE_DEFAULT, fcn));
8911ae115bc7Smrj 			goto done;
8912ae115bc7Smrj 		}
8913ae115bc7Smrj 
8914ae115bc7Smrj 		if (optnum == KERNEL_CMD) {
8915ae115bc7Smrj 			/*
8916ae115bc7Smrj 			 * At this point, we've already checked that old_args
8917ae115bc7Smrj 			 * and entryp are valid pointers.  The "+ 2" is for
8918ae115bc7Smrj 			 * a space a the string termination character.
8919ae115bc7Smrj 			 */
8920ae115bc7Smrj 			new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) +
8921ae115bc7Smrj 			    strlen(old_args) + 2;
8922ae115bc7Smrj 			new_arg = s_calloc(1, new_str_len);
8923ae115bc7Smrj 			(void) snprintf(new_arg, new_str_len, "%s %s",
8924ae115bc7Smrj 			    DIRECT_BOOT_KERNEL, old_args);
8925ae115bc7Smrj 			free(kernelp->arg);
8926ae115bc7Smrj 			kernelp->arg = new_arg;
8927ae115bc7Smrj 
8928ae115bc7Smrj 			/*
8929ae115bc7Smrj 			 * We have changed the kernel line, so we may need
8930ae115bc7Smrj 			 * to update the archive line as well.
8931ae115bc7Smrj 			 */
8932ae115bc7Smrj 			set_archive_line(entryp, kernelp);
8933eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_RESET_KERNEL_SET_ARG,
8934eb2bd662Svikram 			    fcn, kernelp->arg));
8935ae115bc7Smrj 		} else {
8936ae115bc7Smrj 			/*
8937ae115bc7Smrj 			 * We're resetting the boot args to nothing, so
8938ae115bc7Smrj 			 * we only need to copy the kernel.  We've already
8939ae115bc7Smrj 			 * checked that the kernel is not the default.
8940ae115bc7Smrj 			 */
8941ae115bc7Smrj 			new_arg = s_calloc(1, old_kernel_len + 1);
8942ae115bc7Smrj 			(void) snprintf(new_arg, old_kernel_len + 1, "%s",
8943ae115bc7Smrj 			    kernelp->arg);
8944ae115bc7Smrj 			free(kernelp->arg);
8945ae115bc7Smrj 			kernelp->arg = new_arg;
8946eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_RESET_ARG_SET_KERNEL,
8947eb2bd662Svikram 			    fcn, kernelp->arg));
8948ae115bc7Smrj 		}
8949ae115bc7Smrj 		rv = BAM_WRITE;
8950ae115bc7Smrj 		goto done;
8951ae115bc7Smrj 	}
8952ae115bc7Smrj 
8953ae115bc7Smrj 	/*
8954ae115bc7Smrj 	 * Expand the kernel file to a full path, if necessary
8955ae115bc7Smrj 	 */
8956ae115bc7Smrj 	if ((optnum == KERNEL_CMD) && (path[0] != '/')) {
8957ae115bc7Smrj 		new_path = expand_path(path);
8958ae115bc7Smrj 		if (new_path == NULL) {
8959455710d3Srscott 			bam_error(UNKNOWN_KERNEL, path);
8960eb2bd662Svikram 			BAM_DPRINTF((D_RETURN_FAILURE, fcn));
8961ae115bc7Smrj 			return (BAM_ERROR);
8962ae115bc7Smrj 		}
8963ae115bc7Smrj 		free_new_path = 1;
8964ae115bc7Smrj 	} else {
8965ae115bc7Smrj 		new_path = path;
8966ae115bc7Smrj 		free_new_path = 0;
8967ae115bc7Smrj 	}
8968ae115bc7Smrj 
8969ae115bc7Smrj 	/*
8970ae115bc7Smrj 	 * At this point, we know we're setting a new value.  First, take care
8971ae115bc7Smrj 	 * of the case where there was no previous entry.
8972ae115bc7Smrj 	 */
8973ae115bc7Smrj 	if (entryp == NULL) {
8974eb2bd662Svikram 
8975ae115bc7Smrj 		/* Similar to code in update_temp */
8976eb2bd662Svikram 		fstype = get_fstype("/");
8977eb2bd662Svikram 		INJECT_ERROR1("GET_SET_KERNEL_FSTYPE", fstype = NULL);
8978eb2bd662Svikram 		if (fstype == NULL) {
8979eb2bd662Svikram 			bam_error(BOOTENV_FSTYPE_FAILED);
8980ae115bc7Smrj 			rv = BAM_ERROR;
8981ae115bc7Smrj 			goto done;
8982ae115bc7Smrj 		}
8983eb2bd662Svikram 
8984eb2bd662Svikram 		osdev = get_special("/");
8985eb2bd662Svikram 		INJECT_ERROR1("GET_SET_KERNEL_SPECIAL", osdev = NULL);
8986eb2bd662Svikram 		if (osdev == NULL) {
8987eb2bd662Svikram 			free(fstype);
8988eb2bd662Svikram 			bam_error(BOOTENV_SPECIAL_FAILED);
8989eb2bd662Svikram 			rv = BAM_ERROR;
8990eb2bd662Svikram 			goto done;
8991eb2bd662Svikram 		}
8992eb2bd662Svikram 
8993eb2bd662Svikram 		sign = find_existing_sign("/", osdev, fstype);
8994eb2bd662Svikram 		INJECT_ERROR1("GET_SET_KERNEL_SIGN", sign = NULL);
8995eb2bd662Svikram 		if (sign == NULL) {
8996eb2bd662Svikram 			free(fstype);
8997eb2bd662Svikram 			free(osdev);
8998eb2bd662Svikram 			bam_error(BOOTENV_SIGN_FAILED);
8999eb2bd662Svikram 			rv = BAM_ERROR;
9000eb2bd662Svikram 			goto done;
9001eb2bd662Svikram 		}
9002eb2bd662Svikram 
9003eb2bd662Svikram 		free(osdev);
9004eb2bd662Svikram 		(void) strlcpy(signbuf, sign, sizeof (signbuf));
9005eb2bd662Svikram 		free(sign);
9006eb2bd662Svikram 		assert(strchr(signbuf, '(') == NULL &&
9007eb2bd662Svikram 		    strchr(signbuf, ',') == NULL &&
9008eb2bd662Svikram 		    strchr(signbuf, ')') == NULL);
9009eb2bd662Svikram 
9010ae115bc7Smrj 		if (optnum == KERNEL_CMD) {
90114e483a70SGangadhar Mylapuram 			if (strcmp(fstype, "zfs") == 0) {
90124e483a70SGangadhar Mylapuram 				new_str_len = strlen(new_path) +
90134e483a70SGangadhar Mylapuram 				    strlen(ZFS_BOOT) + 8;
90144e483a70SGangadhar Mylapuram 				new_arg = s_calloc(1, new_str_len);
90154e483a70SGangadhar Mylapuram 				(void) snprintf(new_arg, new_str_len, "%s %s",
90164e483a70SGangadhar Mylapuram 				    new_path, ZFS_BOOT);
90174e483a70SGangadhar Mylapuram 				BAM_DPRINTF((D_GET_SET_KERNEL_NEW_KERN, fcn,
90184e483a70SGangadhar Mylapuram 				    new_arg));
90194e483a70SGangadhar Mylapuram 				entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE,
90204e483a70SGangadhar Mylapuram 				    signbuf, new_arg, NULL, NULL, NULL);
90214e483a70SGangadhar Mylapuram 				free(new_arg);
90224e483a70SGangadhar Mylapuram 			} else {
90234e483a70SGangadhar Mylapuram 				BAM_DPRINTF((D_GET_SET_KERNEL_NEW_KERN, fcn,
90244e483a70SGangadhar Mylapuram 				    new_path));
9025ae115bc7Smrj 				entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE,
902644da779fSWilliam Kucharski 				    signbuf, new_path, NULL, NULL, NULL);
90274e483a70SGangadhar Mylapuram 			}
9028ae115bc7Smrj 		} else {
90294487ce1dSGangadhar Mylapuram 			new_str_len = strlen(path) + 8;
90304487ce1dSGangadhar Mylapuram 			if (strcmp(fstype, "zfs") == 0) {
90314487ce1dSGangadhar Mylapuram 				new_str_len += strlen(DIRECT_BOOT_KERNEL_ZFS);
9032ae115bc7Smrj 				new_arg = s_calloc(1, new_str_len);
90334487ce1dSGangadhar Mylapuram 				(void) snprintf(new_arg, new_str_len, "%s %s",
90344487ce1dSGangadhar Mylapuram 				    DIRECT_BOOT_KERNEL_ZFS, path);
90354487ce1dSGangadhar Mylapuram 			} else {
90364487ce1dSGangadhar Mylapuram 				new_str_len += strlen(DIRECT_BOOT_KERNEL);
90374487ce1dSGangadhar Mylapuram 				new_arg = s_calloc(1, new_str_len);
9038ae115bc7Smrj 				(void) snprintf(new_arg, new_str_len, "%s %s",
9039ae115bc7Smrj 				    DIRECT_BOOT_KERNEL, path);
90404487ce1dSGangadhar Mylapuram 			}
90414487ce1dSGangadhar Mylapuram 
9042eb2bd662Svikram 			BAM_DPRINTF((D_GET_SET_KERNEL_NEW_ARG, fcn, new_arg));
9043ae115bc7Smrj 			entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE,
904444da779fSWilliam Kucharski 			    signbuf, new_arg, NULL, DIRECT_BOOT_ARCHIVE, NULL);
9045eb2bd662Svikram 			free(new_arg);
9046eb2bd662Svikram 		}
90474487ce1dSGangadhar Mylapuram 		free(fstype);
9048eb2bd662Svikram 		INJECT_ERROR1("GET_SET_KERNEL_ADD_BOOT_ENTRY",
9049eb2bd662Svikram 		    entryNum = BAM_ERROR);
9050eb2bd662Svikram 		if (entryNum == BAM_ERROR) {
9051eb2bd662Svikram 			bam_error(GET_SET_KERNEL_ADD_BOOT_ENTRY,
9052eb2bd662Svikram 			    BOOTENV_RC_TITLE);
9053eb2bd662Svikram 			rv = BAM_ERROR;
9054eb2bd662Svikram 			goto done;
9055ae115bc7Smrj 		}
9056ae115bc7Smrj 		save_default_entry(mp, BAM_OLD_RC_DEF);
9057eb2bd662Svikram 		ret = set_global(mp, menu_cmds[DEFAULT_CMD], entryNum);
9058eb2bd662Svikram 		INJECT_ERROR1("GET_SET_KERNEL_SET_GLOBAL", ret = BAM_ERROR);
9059eb2bd662Svikram 		if (ret == BAM_ERROR) {
9060eb2bd662Svikram 			bam_error(GET_SET_KERNEL_SET_GLOBAL, entryNum);
9061eb2bd662Svikram 		}
9062ae115bc7Smrj 		rv = BAM_WRITE;
9063ae115bc7Smrj 		goto done;
9064ae115bc7Smrj 	}
9065ae115bc7Smrj 
9066ae115bc7Smrj 	/*
9067ae115bc7Smrj 	 * There was already an bootenv entry which we need to edit.
9068ae115bc7Smrj 	 */
9069ae115bc7Smrj 	if (optnum == KERNEL_CMD) {
9070ae115bc7Smrj 		new_str_len = strlen(new_path) + strlen(old_args) + 2;
9071ae115bc7Smrj 		new_arg = s_calloc(1, new_str_len);
9072ae115bc7Smrj 		(void) snprintf(new_arg, new_str_len, "%s %s", new_path,
9073ae115bc7Smrj 		    old_args);
9074ae115bc7Smrj 		free(kernelp->arg);
9075ae115bc7Smrj 		kernelp->arg = new_arg;
9076ae115bc7Smrj 
9077ae115bc7Smrj 		/*
9078ae115bc7Smrj 		 * If we have changed the kernel line, we may need to update
9079ae115bc7Smrj 		 * the archive line as well.
9080ae115bc7Smrj 		 */
9081ae115bc7Smrj 		set_archive_line(entryp, kernelp);
9082eb2bd662Svikram 		BAM_DPRINTF((D_GET_SET_KERNEL_REPLACED_KERNEL_SAME_ARG, fcn,
9083eb2bd662Svikram 		    kernelp->arg));
9084ae115bc7Smrj 	} else {
9085ae115bc7Smrj 		new_str_len = old_kernel_len + strlen(path) + 8;
9086ae115bc7Smrj 		new_arg = s_calloc(1, new_str_len);
9087ae115bc7Smrj 		(void) strncpy(new_arg, kernelp->arg, old_kernel_len);
9088ae115bc7Smrj 		(void) strlcat(new_arg, " ", new_str_len);
9089ae115bc7Smrj 		(void) strlcat(new_arg, path, new_str_len);
9090ae115bc7Smrj 		free(kernelp->arg);
9091ae115bc7Smrj 		kernelp->arg = new_arg;
9092eb2bd662Svikram 		BAM_DPRINTF((D_GET_SET_KERNEL_SAME_KERNEL_REPLACED_ARG, fcn,
9093eb2bd662Svikram 		    kernelp->arg));
9094ae115bc7Smrj 	}
9095ae115bc7Smrj 	rv = BAM_WRITE;
9096ae115bc7Smrj 
9097ae115bc7Smrj done:
9098ae115bc7Smrj 	if ((rv == BAM_WRITE) && kernelp)
9099ae115bc7Smrj 		update_line(kernelp);
9100ae115bc7Smrj 	if (free_new_path)
9101ae115bc7Smrj 		free(new_path);
9102eb2bd662Svikram 	if (rv == BAM_WRITE) {
9103eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
9104eb2bd662Svikram 	} else {
9105eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
9106eb2bd662Svikram 	}
9107ae115bc7Smrj 	return (rv);
9108ae115bc7Smrj }
9109ae115bc7Smrj 
9110eb2bd662Svikram static error_t
9111eb2bd662Svikram get_kernel(menu_t *mp, menu_cmd_t optnum, char *buf, size_t bufsize)
9112eb2bd662Svikram {
9113eb2bd662Svikram 	const char	*fcn = "get_kernel()";
9114eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, menu_cmds[optnum]));
9115eb2bd662Svikram 	return (get_set_kernel(mp, optnum, NULL, buf, bufsize));
9116eb2bd662Svikram }
9117eb2bd662Svikram 
9118eb2bd662Svikram static error_t
9119eb2bd662Svikram set_kernel(menu_t *mp, menu_cmd_t optnum, char *path, char *buf, size_t bufsize)
9120eb2bd662Svikram {
9121eb2bd662Svikram 	const char	*fcn = "set_kernel()";
9122eb2bd662Svikram 	assert(path != NULL);
9123eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY2, fcn, menu_cmds[optnum], path));
9124eb2bd662Svikram 	return (get_set_kernel(mp, optnum, path, buf, bufsize));
9125eb2bd662Svikram }
9126eb2bd662Svikram 
91277c478bd9Sstevel@tonic-gate /*ARGSUSED*/
91287c478bd9Sstevel@tonic-gate static error_t
9129eb2bd662Svikram set_option(menu_t *mp, char *dummy, char *opt)
91307c478bd9Sstevel@tonic-gate {
9131eb2bd662Svikram 	int		optnum;
9132eb2bd662Svikram 	int		optval;
91337c478bd9Sstevel@tonic-gate 	char		*val;
9134ae115bc7Smrj 	char		buf[BUFSIZ] = "";
9135ae115bc7Smrj 	error_t		rv;
9136eb2bd662Svikram 	const char	*fcn = "set_option()";
91377c478bd9Sstevel@tonic-gate 
91387c478bd9Sstevel@tonic-gate 	assert(mp);
91397c478bd9Sstevel@tonic-gate 	assert(opt);
9140eb2bd662Svikram 	assert(dummy == NULL);
9141eb2bd662Svikram 
9142eb2bd662Svikram 	/* opt is set from bam_argv[0] and is always non-NULL */
9143eb2bd662Svikram 	BAM_DPRINTF((D_FUNC_ENTRY1, fcn, opt));
91447c478bd9Sstevel@tonic-gate 
91457c478bd9Sstevel@tonic-gate 	val = strchr(opt, '=');
9146ae115bc7Smrj 	if (val != NULL) {
9147ae115bc7Smrj 		*val = '\0';
91487c478bd9Sstevel@tonic-gate 	}
91497c478bd9Sstevel@tonic-gate 
91507c478bd9Sstevel@tonic-gate 	if (strcmp(opt, "default") == 0) {
91517c478bd9Sstevel@tonic-gate 		optnum = DEFAULT_CMD;
91527c478bd9Sstevel@tonic-gate 	} else if (strcmp(opt, "timeout") == 0) {
91537c478bd9Sstevel@tonic-gate 		optnum = TIMEOUT_CMD;
9154ae115bc7Smrj 	} else if (strcmp(opt, menu_cmds[KERNEL_CMD]) == 0) {
9155ae115bc7Smrj 		optnum = KERNEL_CMD;
9156ae115bc7Smrj 	} else if (strcmp(opt, menu_cmds[ARGS_CMD]) == 0) {
9157ae115bc7Smrj 		optnum = ARGS_CMD;
91587c478bd9Sstevel@tonic-gate 	} else {
9159eb2bd662Svikram 		bam_error(INVALID_OPTION, opt);
91607c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
91617c478bd9Sstevel@tonic-gate 	}
91627c478bd9Sstevel@tonic-gate 
9163ae115bc7Smrj 	/*
9164ae115bc7Smrj 	 * kernel and args are allowed without "=new_value" strings.  All
9165ae115bc7Smrj 	 * others cause errors
9166ae115bc7Smrj 	 */
9167ae115bc7Smrj 	if ((val == NULL) && (optnum != KERNEL_CMD) && (optnum != ARGS_CMD)) {
9168eb2bd662Svikram 		bam_error(NO_OPTION_ARG, opt);
9169ae115bc7Smrj 		return (BAM_ERROR);
9170ae115bc7Smrj 	} else if (val != NULL) {
91717c478bd9Sstevel@tonic-gate 		*val = '=';
9172ae115bc7Smrj 	}
9173ae115bc7Smrj 
9174ae115bc7Smrj 	if ((optnum == KERNEL_CMD) || (optnum == ARGS_CMD)) {
9175eb2bd662Svikram 		BAM_DPRINTF((D_SET_OPTION, fcn, menu_cmds[optnum],
9176eb2bd662Svikram 		    val ? val + 1 : "NULL"));
9177eb2bd662Svikram 
9178eb2bd662Svikram 		if (val)
9179eb2bd662Svikram 			rv = set_kernel(mp, optnum, val + 1, buf, sizeof (buf));
9180eb2bd662Svikram 		else
9181eb2bd662Svikram 			rv = get_kernel(mp, optnum, buf, sizeof (buf));
9182ae115bc7Smrj 		if ((rv == BAM_SUCCESS) && (buf[0] != '\0'))
9183ae115bc7Smrj 			(void) printf("%s\n", buf);
9184ae115bc7Smrj 	} else {
9185ae115bc7Smrj 		optval = s_strtol(val + 1);
9186eb2bd662Svikram 		BAM_DPRINTF((D_SET_OPTION, fcn, menu_cmds[optnum], val + 1));
9187eb2bd662Svikram 		rv = set_global(mp, menu_cmds[optnum], optval);
91887c478bd9Sstevel@tonic-gate 	}
9189eb2bd662Svikram 
9190eb2bd662Svikram 	if (rv == BAM_WRITE || rv == BAM_SUCCESS) {
9191eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_SUCCESS, fcn));
9192eb2bd662Svikram 	} else {
9193eb2bd662Svikram 		BAM_DPRINTF((D_RETURN_FAILURE, fcn));
9194eb2bd662Svikram 	}
9195eb2bd662Svikram 
9196eb2bd662Svikram 	return (rv);
9197ae115bc7Smrj }
91987c478bd9Sstevel@tonic-gate 
91997c478bd9Sstevel@tonic-gate /*
92007c478bd9Sstevel@tonic-gate  * The quiet argument suppresses messages. This is used
92017c478bd9Sstevel@tonic-gate  * when invoked in the context of other commands (e.g. list_entry)
92027c478bd9Sstevel@tonic-gate  */
92037c478bd9Sstevel@tonic-gate static error_t
92047c478bd9Sstevel@tonic-gate read_globals(menu_t *mp, char *menu_path, char *globalcmd, int quiet)
92057c478bd9Sstevel@tonic-gate {
92067c478bd9Sstevel@tonic-gate 	line_t *lp;
92077c478bd9Sstevel@tonic-gate 	char *arg;
92087c478bd9Sstevel@tonic-gate 	int done, ret = BAM_SUCCESS;
92097c478bd9Sstevel@tonic-gate 
92107c478bd9Sstevel@tonic-gate 	assert(mp);
92117c478bd9Sstevel@tonic-gate 	assert(menu_path);
92127c478bd9Sstevel@tonic-gate 	assert(globalcmd);
92137c478bd9Sstevel@tonic-gate 
92147c478bd9Sstevel@tonic-gate 	if (mp->start == NULL) {
92157c478bd9Sstevel@tonic-gate 		if (!quiet)
92167c478bd9Sstevel@tonic-gate 			bam_error(NO_MENU, menu_path);
92177c478bd9Sstevel@tonic-gate 		return (BAM_ERROR);
92187c478bd9Sstevel@tonic-gate 	}
92197c478bd9Sstevel@tonic-gate 
92207c478bd9Sstevel@tonic-gate 	done = 0;
92217c478bd9Sstevel@tonic-gate 	for (lp = mp->start; lp; lp = lp->next) {
92227c478bd9Sstevel@tonic-gate 		if (lp->flags != BAM_GLOBAL)
92237c478bd9Sstevel@tonic-gate 			continue;
92247c478bd9Sstevel@tonic-gate 
92257c478bd9Sstevel@tonic-gate 		if (lp->cmd == NULL) {
92267c478bd9Sstevel@tonic-gate 			if (!quiet)
92277c478bd9Sstevel@tonic-gate 				bam_error(NO_CMD, lp->lineNum);
92287c478bd9Sstevel@tonic-gate 			continue;
92297c478bd9Sstevel@tonic-gate 		}
92307c478bd9Sstevel@tonic-gate 
92317c478bd9Sstevel@tonic-gate 		if (strcmp(globalcmd, lp->cmd) != 0)
92327c478bd9Sstevel@tonic-gate 			continue;
92337c478bd9Sstevel@tonic-gate 
92347c478bd9Sstevel@tonic-gate 		/* Found global. Check for duplicates */
92357c478bd9Sstevel@tonic-gate 		if (done && !quiet) {
92367c478bd9Sstevel@tonic-gate 			bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root);
92377c478bd9Sstevel@tonic-gate 			ret = BAM_ERROR;
92387c478bd9Sstevel@tonic-gate 		}
92397c478bd9Sstevel@tonic-gate 
92407c478bd9Sstevel@tonic-gate 		arg = lp->arg ? lp->arg : "";
92417c478bd9Sstevel@tonic-gate 		bam_print(GLOBAL_CMD, globalcmd, arg);
92427c478bd9Sstevel@tonic-gate 		done = 1;
92437c478bd9Sstevel@tonic-gate 	}
92447c478bd9Sstevel@tonic-gate 
92457c478bd9Sstevel@tonic-gate 	if (!done && bam_verbose)
92467c478bd9Sstevel@tonic-gate 		bam_print(NO_ENTRY, globalcmd);
92477c478bd9Sstevel@tonic-gate 
92487c478bd9Sstevel@tonic-gate 	return (ret);
92497c478bd9Sstevel@tonic-gate }
92507c478bd9Sstevel@tonic-gate 
92517c478bd9Sstevel@tonic-gate static error_t
92527c478bd9Sstevel@tonic-gate menu_write(char *root, menu_t *mp)
92537c478bd9Sstevel@tonic-gate {
9254eb2bd662Svikram 	const char *fcn = "menu_write()";
9255eb2bd662Svikram 
9256eb2bd662Svikram 	BAM_DPRINTF((D_MENU_WRITE_ENTER, fcn, root));
92577c478bd9Sstevel@tonic-gate 	return (list2file(root, MENU_TMP, GRUB_MENU, mp->start));
92587c478bd9Sstevel@tonic-gate }
92597c478bd9Sstevel@tonic-gate 
9260eb2bd662Svikram void
92617c478bd9Sstevel@tonic-gate line_free(line_t *lp)
92627c478bd9Sstevel@tonic-gate {
92637c478bd9Sstevel@tonic-gate 	if (lp == NULL)
92647c478bd9Sstevel@tonic-gate 		return;
92657c478bd9Sstevel@tonic-gate 
9266eac223ccSWilliam Kucharski 	if (lp->cmd != NULL)
92677c478bd9Sstevel@tonic-gate 		free(lp->cmd);
92687c478bd9Sstevel@tonic-gate 	if (lp->sep)
92697c478bd9Sstevel@tonic-gate 		free(lp->sep);
92707c478bd9Sstevel@tonic-gate 	if (lp->arg)
92717c478bd9Sstevel@tonic-gate 		free(lp->arg);
92727c478bd9Sstevel@tonic-gate 	if (lp->line)
92737c478bd9Sstevel@tonic-gate 		free(lp->line);
92747c478bd9Sstevel@tonic-gate 	free(lp);
92757c478bd9Sstevel@tonic-gate }
92767c478bd9Sstevel@tonic-gate 
92777c478bd9Sstevel@tonic-gate static void
92787c478bd9Sstevel@tonic-gate linelist_free(line_t *start)
92797c478bd9Sstevel@tonic-gate {
92807c478bd9Sstevel@tonic-gate 	line_t *lp;
92817c478bd9Sstevel@tonic-gate 
92827c478bd9Sstevel@tonic-gate 	while (start) {
92837c478bd9Sstevel@tonic-gate 		lp = start;
92847c478bd9Sstevel@tonic-gate 		start = start->next;
92857c478bd9Sstevel@tonic-gate 		line_free(lp);
92867c478bd9Sstevel@tonic-gate 	}
92877c478bd9Sstevel@tonic-gate }
92887c478bd9Sstevel@tonic-gate 
92897c478bd9Sstevel@tonic-gate static void
92907c478bd9Sstevel@tonic-gate filelist_free(filelist_t *flistp)
92917c478bd9Sstevel@tonic-gate {
92927c478bd9Sstevel@tonic-gate 	linelist_free(flistp->head);
92937c478bd9Sstevel@tonic-gate 	flistp->head = NULL;
92947c478bd9Sstevel@tonic-gate 	flistp->tail = NULL;
92957c478bd9Sstevel@tonic-gate }
92967c478bd9Sstevel@tonic-gate 
92977c478bd9Sstevel@tonic-gate static void
92987c478bd9Sstevel@tonic-gate menu_free(menu_t *mp)
92997c478bd9Sstevel@tonic-gate {
93008c1b6884Sszhou 	entry_t *ent, *tmp;
93017c478bd9Sstevel@tonic-gate 	assert(mp);
93027c478bd9Sstevel@tonic-gate 
93037c478bd9Sstevel@tonic-gate 	if (mp->start)
93047c478bd9Sstevel@tonic-gate 		linelist_free(mp->start);
93058c1b6884Sszhou 	ent = mp->entries;
93068c1b6884Sszhou 	while (ent) {
93078c1b6884Sszhou 		tmp = ent;
93088c1b6884Sszhou 		ent = tmp->next;
93098c1b6884Sszhou 		free(tmp);
93108c1b6884Sszhou 	}
93117c478bd9Sstevel@tonic-gate 
93128c1b6884Sszhou 	free(mp);
93137c478bd9Sstevel@tonic-gate }
93147c478bd9Sstevel@tonic-gate 
93157c478bd9Sstevel@tonic-gate /*
93167c478bd9Sstevel@tonic-gate  * Utility routines
93177c478bd9Sstevel@tonic-gate  */
93187c478bd9Sstevel@tonic-gate 
93197c478bd9Sstevel@tonic-gate 
93207c478bd9Sstevel@tonic-gate /*
93217c478bd9Sstevel@tonic-gate  * Returns 0 on success
93227c478bd9Sstevel@tonic-gate  * Any other value indicates an error
93237c478bd9Sstevel@tonic-gate  */
93247c478bd9Sstevel@tonic-gate static int
9325986fd29aSsetje exec_cmd(char *cmdline, filelist_t *flistp)
93267c478bd9Sstevel@tonic-gate {
93277c478bd9Sstevel@tonic-gate 	char buf[BUFSIZ];
93287c478bd9Sstevel@tonic-gate 	int ret;
93297c478bd9Sstevel@tonic-gate 	FILE *ptr;
93307c478bd9Sstevel@tonic-gate 	sigset_t set;
93317c478bd9Sstevel@tonic-gate 	void (*disp)(int);
93327c478bd9Sstevel@tonic-gate 
93337c478bd9Sstevel@tonic-gate 	/*
93347c478bd9Sstevel@tonic-gate 	 * For security
93357c478bd9Sstevel@tonic-gate 	 * - only absolute paths are allowed
93367c478bd9Sstevel@tonic-gate 	 * - set IFS to space and tab
93377c478bd9Sstevel@tonic-gate 	 */
93387c478bd9Sstevel@tonic-gate 	if (*cmdline != '/') {
93397c478bd9Sstevel@tonic-gate 		bam_error(ABS_PATH_REQ, cmdline);
93407c478bd9Sstevel@tonic-gate 		return (-1);
93417c478bd9Sstevel@tonic-gate 	}
93427c478bd9Sstevel@tonic-gate 	(void) putenv("IFS= \t");
93437c478bd9Sstevel@tonic-gate 
93447c478bd9Sstevel@tonic-gate 	/*
93457c478bd9Sstevel@tonic-gate 	 * We may have been exec'ed with SIGCHLD blocked
93467c478bd9Sstevel@tonic-gate 	 * unblock it here
93477c478bd9Sstevel@tonic-gate 	 */
93487c478bd9Sstevel@tonic-gate 	(void) sigemptyset(&set);
93497c478bd9Sstevel@tonic-gate 	(void) sigaddset(&set, SIGCHLD);
93507c478bd9Sstevel@tonic-gate 	if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) {
93517c478bd9Sstevel@tonic-gate 		bam_error(CANT_UNBLOCK_SIGCHLD, strerror(errno));
93527c478bd9Sstevel@tonic-gate 		return (-1);
93537c478bd9Sstevel@tonic-gate 	}
93547c478bd9Sstevel@tonic-gate 
93557c478bd9Sstevel@tonic-gate 	/*
93567c478bd9Sstevel@tonic-gate 	 * Set SIGCHLD disposition to SIG_DFL for popen/pclose
93577c478bd9Sstevel@tonic-gate 	 */
93587c478bd9Sstevel@tonic-gate 	disp = sigset(SIGCHLD, SIG_DFL);
93597c478bd9Sstevel@tonic-gate 	if (disp == SIG_ERR) {
93607c478bd9Sstevel@tonic-gate 		bam_error(FAILED_SIG, strerror(errno));
93617c478bd9Sstevel@tonic-gate 		return (-1);
93627c478bd9Sstevel@tonic-gate 	}
93637c478bd9Sstevel@tonic-gate 	if (disp == SIG_HOLD) {
93647c478bd9Sstevel@tonic-gate 		bam_error(BLOCKED_SIG, cmdline);
93657c478bd9Sstevel@tonic-gate 		return (-1);
93667c478bd9Sstevel@tonic-gate 	}
93677c478bd9Sstevel@tonic-gate 
93687c478bd9Sstevel@tonic-gate 	ptr = popen(cmdline, "r");
93697c478bd9Sstevel@tonic-gate 	if (ptr == NULL) {
93707c478bd9Sstevel@tonic-gate 		bam_error(POPEN_FAIL, cmdline, strerror(errno));
93717c478bd9Sstevel@tonic-gate 		return (-1);
93727c478bd9Sstevel@tonic-gate 	}
93737c478bd9Sstevel@tonic-gate 
93747c478bd9Sstevel@tonic-gate 	/*
93757c478bd9Sstevel@tonic-gate 	 * If we simply do a pclose() following a popen(), pclose()
93767c478bd9Sstevel@tonic-gate 	 * will close the reader end of the pipe immediately even
93777c478bd9Sstevel@tonic-gate 	 * if the child process has not started/exited. pclose()
93787c478bd9Sstevel@tonic-gate 	 * does wait for cmd to terminate before returning though.
93797c478bd9Sstevel@tonic-gate 	 * When the executed command writes its output to the pipe
93807c478bd9Sstevel@tonic-gate 	 * there is no reader process and the command dies with
93817c478bd9Sstevel@tonic-gate 	 * SIGPIPE. To avoid this we read repeatedly until read
93827c478bd9Sstevel@tonic-gate 	 * terminates with EOF. This indicates that the command
93837c478bd9Sstevel@tonic-gate 	 * (writer) has closed the pipe and we can safely do a
93847c478bd9Sstevel@tonic-gate 	 * pclose().
93857c478bd9Sstevel@tonic-gate 	 *
93867c478bd9Sstevel@tonic-gate 	 * Since pclose() does wait for the command to exit,
93877c478bd9Sstevel@tonic-gate 	 * we can safely reap the exit status of the command
93887c478bd9Sstevel@tonic-gate 	 * from the value returned by pclose()
93897c478bd9Sstevel@tonic-gate 	 */
9390986fd29aSsetje 	while (s_fgets(buf, sizeof (buf), ptr) != NULL) {
9391986fd29aSsetje 		if (flistp == NULL) {
9392986fd29aSsetje 			/* s_fgets strips newlines, so insert them at the end */
9393986fd29aSsetje 			bam_print(PRINT, buf);
9394986fd29aSsetje 		} else {
9395986fd29aSsetje 			append_to_flist(flistp, buf);
93967c478bd9Sstevel@tonic-gate 		}
93977c478bd9Sstevel@tonic-gate 	}
93987c478bd9Sstevel@tonic-gate 
93997c478bd9Sstevel@tonic-gate 	ret = pclose(ptr);
94007c478bd9Sstevel@tonic-gate 	if (ret == -1) {
94017c478bd9Sstevel@tonic-gate 		bam_error(PCLOSE_FAIL, cmdline, strerror(errno));
94027c478bd9Sstevel@tonic-gate 		return (-1);
94037c478bd9Sstevel@tonic-gate 	}
94047c478bd9Sstevel@tonic-gate 
94057c478bd9Sstevel@tonic-gate 	if (WIFEXITED(ret)) {
94067c478bd9Sstevel@tonic-gate 		return (WEXITSTATUS(ret));
94077c478bd9Sstevel@tonic-gate 	} else {
94087c478bd9Sstevel@tonic-gate 		bam_error(EXEC_FAIL, cmdline, ret);
94097c478bd9Sstevel@tonic-gate 		return (-1);
94107c478bd9Sstevel@tonic-gate 	}
94117c478bd9Sstevel@tonic-gate }
94127c478bd9Sstevel@tonic-gate 
94137c478bd9Sstevel@tonic-gate /*
94147c478bd9Sstevel@tonic-gate  * Since this function returns -1 on error
94157c478bd9Sstevel@tonic-gate  * it cannot be used to convert -1. However,
94167c478bd9Sstevel@tonic-gate  * that is sufficient for what we need.
94177c478bd9Sstevel@tonic-gate  */
94187c478bd9Sstevel@tonic-gate static long
94197c478bd9Sstevel@tonic-gate s_strtol(char *str)
94207c478bd9Sstevel@tonic-gate {
94217c478bd9Sstevel@tonic-gate 	long l;
94227c478bd9Sstevel@tonic-gate 	char *res = NULL;
94237c478bd9Sstevel@tonic-gate 
94247c478bd9Sstevel@tonic-gate 	if (str == NULL) {
94257c478bd9Sstevel@tonic-gate 		return (-1);
94267c478bd9Sstevel@tonic-gate 	}
94277c478bd9Sstevel@tonic-gate 
94287c478bd9Sstevel@tonic-gate 	errno = 0;
94297c478bd9Sstevel@tonic-gate 	l = strtol(str, &res, 10);
94307c478bd9Sstevel@tonic-gate 	if (errno || *res != '\0') {
94317c478bd9Sstevel@tonic-gate 		return (-1);
94327c478bd9Sstevel@tonic-gate 	}
94337c478bd9Sstevel@tonic-gate 
94347c478bd9Sstevel@tonic-gate 	return (l);
94357c478bd9Sstevel@tonic-gate }
94367c478bd9Sstevel@tonic-gate 
94377c478bd9Sstevel@tonic-gate /*
94387c478bd9Sstevel@tonic-gate  * Wrapper around fputs, that adds a newline (since fputs doesn't)
94397c478bd9Sstevel@tonic-gate  */
94407c478bd9Sstevel@tonic-gate static int
94417c478bd9Sstevel@tonic-gate s_fputs(char *str, FILE *fp)
94427c478bd9Sstevel@tonic-gate {
94437c478bd9Sstevel@tonic-gate 	char linebuf[BAM_MAXLINE];
94447c478bd9Sstevel@tonic-gate 
94457c478bd9Sstevel@tonic-gate 	(void) snprintf(linebuf, sizeof (linebuf), "%s\n", str);
94467c478bd9Sstevel@tonic-gate 	return (fputs(linebuf, fp));
94477c478bd9Sstevel@tonic-gate }
94487c478bd9Sstevel@tonic-gate 
94497c478bd9Sstevel@tonic-gate /*
94507c478bd9Sstevel@tonic-gate  * Wrapper around fgets, that strips newlines returned by fgets
94517c478bd9Sstevel@tonic-gate  */
9452ae115bc7Smrj char *
94537c478bd9Sstevel@tonic-gate s_fgets(char *buf, int buflen, FILE *fp)
94547c478bd9Sstevel@tonic-gate {
94557c478bd9Sstevel@tonic-gate 	int n;
94567c478bd9Sstevel@tonic-gate 
94577c478bd9Sstevel@tonic-gate 	buf = fgets(buf, buflen, fp);
94587c478bd9Sstevel@tonic-gate 	if (buf) {
94597c478bd9Sstevel@tonic-gate 		n = strlen(buf);
94607c478bd9Sstevel@tonic-gate 		if (n == buflen - 1 && buf[n-1] != '\n')
94617c478bd9Sstevel@tonic-gate 			bam_error(TOO_LONG, buflen - 1, buf);
94627c478bd9Sstevel@tonic-gate 		buf[n-1] = (buf[n-1] == '\n') ? '\0' : buf[n-1];
94637c478bd9Sstevel@tonic-gate 	}
94647c478bd9Sstevel@tonic-gate 
94657c478bd9Sstevel@tonic-gate 	return (buf);
94667c478bd9Sstevel@tonic-gate }
94677c478bd9Sstevel@tonic-gate 
9468ae115bc7Smrj void *
94697c478bd9Sstevel@tonic-gate s_calloc(size_t nelem, size_t sz)
94707c478bd9Sstevel@tonic-gate {
94717c478bd9Sstevel@tonic-gate 	void *ptr;
94727c478bd9Sstevel@tonic-gate 
94737c478bd9Sstevel@tonic-gate 	ptr = calloc(nelem, sz);
94747c478bd9Sstevel@tonic-gate 	if (ptr == NULL) {
94757c478bd9Sstevel@tonic-gate 		bam_error(NO_MEM, nelem*sz);
94767c478bd9Sstevel@tonic-gate 		bam_exit(1);
94777c478bd9Sstevel@tonic-gate 	}
94787c478bd9Sstevel@tonic-gate 	return (ptr);
94797c478bd9Sstevel@tonic-gate }
94807c478bd9Sstevel@tonic-gate 
9481ae115bc7Smrj void *
9482ae115bc7Smrj s_realloc(void *ptr, size_t sz)
9483ae115bc7Smrj {
9484ae115bc7Smrj 	ptr = realloc(ptr, sz);
9485ae115bc7Smrj 	if (ptr == NULL) {
9486ae115bc7Smrj 		bam_error(NO_MEM, sz);
9487ae115bc7Smrj 		bam_exit(1);
9488ae115bc7Smrj 	}
9489ae115bc7Smrj 	return (ptr);
9490ae115bc7Smrj }
9491ae115bc7Smrj 
9492eb2bd662Svikram char *
94937c478bd9Sstevel@tonic-gate s_strdup(char *str)
94947c478bd9Sstevel@tonic-gate {
94957c478bd9Sstevel@tonic-gate 	char *ptr;
94967c478bd9Sstevel@tonic-gate 
94977c478bd9Sstevel@tonic-gate 	if (str == NULL)
94987c478bd9Sstevel@tonic-gate 		return (NULL);
94997c478bd9Sstevel@tonic-gate 
95007c478bd9Sstevel@tonic-gate 	ptr = strdup(str);
95017c478bd9Sstevel@tonic-gate 	if (ptr == NULL) {
95027c478bd9Sstevel@tonic-gate 		bam_error(NO_MEM, strlen(str) + 1);
95037c478bd9Sstevel@tonic-gate 		bam_exit(1);
95047c478bd9Sstevel@tonic-gate 	}
95057c478bd9Sstevel@tonic-gate 	return (ptr);
95067c478bd9Sstevel@tonic-gate }
95077c478bd9Sstevel@tonic-gate 
95087c478bd9Sstevel@tonic-gate /*
95097c478bd9Sstevel@tonic-gate  * Returns 1 if amd64 (or sparc, for syncing x86 diskless clients)
95107c478bd9Sstevel@tonic-gate  * Returns 0 otherwise
95117c478bd9Sstevel@tonic-gate  */
95127c478bd9Sstevel@tonic-gate static int
95137c478bd9Sstevel@tonic-gate is_amd64(void)
95147c478bd9Sstevel@tonic-gate {
95157c478bd9Sstevel@tonic-gate 	static int amd64 = -1;
95167c478bd9Sstevel@tonic-gate 	char isabuf[257];	/* from sysinfo(2) manpage */
95177c478bd9Sstevel@tonic-gate 
95187c478bd9Sstevel@tonic-gate 	if (amd64 != -1)
95197c478bd9Sstevel@tonic-gate 		return (amd64);
95207c478bd9Sstevel@tonic-gate 
9521d876c67dSjg 	if (bam_alt_platform) {
9522d876c67dSjg 		if (strcmp(bam_platform, "i86pc") == 0) {
95237c478bd9Sstevel@tonic-gate 			amd64 = 1;		/* diskless server */
9524d876c67dSjg 		}
9525d876c67dSjg 	} else {
9526d876c67dSjg 		if (sysinfo(SI_ISALIST, isabuf, sizeof (isabuf)) > 0 &&
9527d876c67dSjg 		    strncmp(isabuf, "amd64 ", strlen("amd64 ")) == 0) {
9528d876c67dSjg 			amd64 = 1;
9529d876c67dSjg 		} else if (strstr(isabuf, "i386") == NULL) {
9530d876c67dSjg 			amd64 = 1;		/* diskless server */
9531d876c67dSjg 		}
9532d876c67dSjg 	}
9533d876c67dSjg 	if (amd64 == -1)
95347c478bd9Sstevel@tonic-gate 		amd64 = 0;
95357c478bd9Sstevel@tonic-gate 
95367c478bd9Sstevel@tonic-gate 	return (amd64);
95377c478bd9Sstevel@tonic-gate }
95387c478bd9Sstevel@tonic-gate 
953979755401Ssetje static char *
954079755401Ssetje get_machine(void)
9541986fd29aSsetje {
954279755401Ssetje 	static int cached = -1;
954379755401Ssetje 	static char mbuf[257];	/* from sysinfo(2) manpage */
9544986fd29aSsetje 
954579755401Ssetje 	if (cached == 0)
954679755401Ssetje 		return (mbuf);
9547d876c67dSjg 
9548d876c67dSjg 	if (bam_alt_platform) {
954979755401Ssetje 		return (bam_platform);
9550d876c67dSjg 	} else {
955179755401Ssetje 		if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0) {
955279755401Ssetje 			cached = 1;
9553d876c67dSjg 		}
9554d876c67dSjg 	}
955579755401Ssetje 	if (cached == -1) {
955679755401Ssetje 		mbuf[0] = '\0';
955779755401Ssetje 		cached = 0;
9558986fd29aSsetje 	}
9559986fd29aSsetje 
956079755401Ssetje 	return (mbuf);
9561986fd29aSsetje }
9562986fd29aSsetje 
9563eb2bd662Svikram int
9564eb2bd662Svikram is_sparc(void)
9565eb2bd662Svikram {
956679755401Ssetje 	static int issparc = -1;
956779755401Ssetje 	char mbuf[257];	/* from sysinfo(2) manpage */
956879755401Ssetje 
956979755401Ssetje 	if (issparc != -1)
957079755401Ssetje 		return (issparc);
957179755401Ssetje 
957279755401Ssetje 	if (bam_alt_platform) {
957379755401Ssetje 		if (strncmp(bam_platform, "sun4", 4) == 0) {
957479755401Ssetje 			issparc = 1;
957579755401Ssetje 		}
957679755401Ssetje 	} else {
957779755401Ssetje 		if (sysinfo(SI_ARCHITECTURE, mbuf, sizeof (mbuf)) > 0 &&
9578d7d0f93bSjg 		    strcmp(mbuf, "sparc") == 0) {
957979755401Ssetje 			issparc = 1;
958079755401Ssetje 		}
9581d7d0f93bSjg 	}
9582d7d0f93bSjg 	if (issparc == -1)
9583d7d0f93bSjg 		issparc = 0;
958479755401Ssetje 
958579755401Ssetje 	return (issparc);
9586eb2bd662Svikram }
9587986fd29aSsetje 
95887c478bd9Sstevel@tonic-gate static void
95897c478bd9Sstevel@tonic-gate append_to_flist(filelist_t *flistp, char *s)
95907c478bd9Sstevel@tonic-gate {
95917c478bd9Sstevel@tonic-gate 	line_t *lp;
95927c478bd9Sstevel@tonic-gate 
95937c478bd9Sstevel@tonic-gate 	lp = s_calloc(1, sizeof (line_t));
95947c478bd9Sstevel@tonic-gate 	lp->line = s_strdup(s);
95957c478bd9Sstevel@tonic-gate 	if (flistp->head == NULL)
95967c478bd9Sstevel@tonic-gate 		flistp->head = lp;
95977c478bd9Sstevel@tonic-gate 	else
95987c478bd9Sstevel@tonic-gate 		flistp->tail->next = lp;
95997c478bd9Sstevel@tonic-gate 	flistp->tail = lp;
96007c478bd9Sstevel@tonic-gate }
96012449e17fSsherrym 
9602986fd29aSsetje #if !defined(_OPB)
96032449e17fSsherrym 
96042449e17fSsherrym UCODE_VENDORS;
96052449e17fSsherrym 
96062449e17fSsherrym /*ARGSUSED*/
96072449e17fSsherrym static void
96082449e17fSsherrym ucode_install(char *root)
96092449e17fSsherrym {
96102449e17fSsherrym 	int i;
96112449e17fSsherrym 
96122449e17fSsherrym 	for (i = 0; ucode_vendors[i].filestr != NULL; i++) {
96132449e17fSsherrym 		int cmd_len = PATH_MAX + 256;
96142449e17fSsherrym 		char cmd[PATH_MAX + 256];
96152449e17fSsherrym 		char file[PATH_MAX];
96162449e17fSsherrym 		char timestamp[PATH_MAX];
96172449e17fSsherrym 		struct stat fstatus, tstatus;
96182449e17fSsherrym 		struct utimbuf u_times;
96192449e17fSsherrym 
9620adc586deSMark Johnson 		(void) snprintf(file, PATH_MAX, "%s/%s/%s-ucode.%s",
9621adc586deSMark Johnson 		    bam_root, UCODE_INSTALL_PATH, ucode_vendors[i].filestr,
9622adc586deSMark Johnson 		    ucode_vendors[i].extstr);
96232449e17fSsherrym 
96242449e17fSsherrym 		if (stat(file, &fstatus) != 0 || !(S_ISREG(fstatus.st_mode)))
96252449e17fSsherrym 			continue;
96262449e17fSsherrym 
96272449e17fSsherrym 		(void) snprintf(timestamp, PATH_MAX, "%s.ts", file);
96282449e17fSsherrym 
96292449e17fSsherrym 		if (stat(timestamp, &tstatus) == 0 &&
96302449e17fSsherrym 		    fstatus.st_mtime <= tstatus.st_mtime)
96312449e17fSsherrym 			continue;
96322449e17fSsherrym 
96332449e17fSsherrym 		(void) snprintf(cmd, cmd_len, "/usr/sbin/ucodeadm -i -R "
96342449e17fSsherrym 		    "%s/%s/%s %s > /dev/null 2>&1", bam_root,
96352449e17fSsherrym 		    UCODE_INSTALL_PATH, ucode_vendors[i].vendorstr, file);
96362449e17fSsherrym 		if (system(cmd) != 0)
96372449e17fSsherrym 			return;
96382449e17fSsherrym 
96392449e17fSsherrym 		if (creat(timestamp, S_IRUSR | S_IWUSR) == -1)
96402449e17fSsherrym 			return;
96412449e17fSsherrym 
96422449e17fSsherrym 		u_times.actime = fstatus.st_atime;
96432449e17fSsherrym 		u_times.modtime = fstatus.st_mtime;
96442449e17fSsherrym 		(void) utime(timestamp, &u_times);
96452449e17fSsherrym 	}
96462449e17fSsherrym }
96472449e17fSsherrym #endif
9648