xref: /illumos-gate/usr/src/cmd/boot/bootadm/bootadm.c (revision d876c67d)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * bootadm(1M) is a new utility for managing bootability of
 * Solaris *Newboot* environments. It has two primary tasks:
 * 	- Allow end users to manage bootability of Newboot Solaris instances
 *	- Provide services to other subsystems in Solaris (primarily Install)
 */

/* Headers */
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdarg.h>
#include <limits.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/mnttab.h>
#include <sys/statvfs.h>
#include <libnvpair.h>
#include <ftw.h>
#include <fcntl.h>
#include <strings.h>
#include <utime.h>
#include <sys/systeminfo.h>
#include <sys/dktp/fdisk.h>
#include <sys/param.h>

#if !defined(_OPB)
#include <sys/ucode.h>
#endif

#include <pwd.h>
#include <grp.h>
#include <device_info.h>
#include <locale.h>
#include <assert.h>

#include "message.h"
#include "bootadm.h"

#ifndef TEXT_DOMAIN
#define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
#endif	/* TEXT_DOMAIN */

/* Type definitions */

/* Primary subcmds */
typedef enum {
	BAM_MENU = 3,
	BAM_ARCHIVE
} subcmd_t;

typedef enum {
    OPT_ABSENT = 0,	/* No option */
    OPT_REQ,		/* option required */
    OPT_OPTIONAL	/* option may or may not be present */
} option_t;

typedef struct {
	char	*subcmd;
	option_t option;
	error_t (*handler)();
	int	unpriv;			/* is this an unprivileged command */
} subcmd_defn_t;

#define	LINE_INIT	0	/* lineNum initial value */
#define	ENTRY_INIT	-1	/* entryNum initial value */
#define	ALL_ENTRIES	-2	/* selects all boot entries */

#define	GRUB_DIR		"/boot/grub"
#define	GRUB_MENU		"/boot/grub/menu.lst"
#define	MENU_TMP		"/boot/grub/menu.lst.tmp"
#define	RAMDISK_SPECIAL		"/ramdisk"
#define	STUBBOOT		"/stubboot"

/* lock related */
#define	BAM_LOCK_FILE		"/var/run/bootadm.lock"
#define	LOCK_FILE_PERMS		(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

#define	CREATE_RAMDISK		"boot/solaris/bin/create_ramdisk"
#define	CREATE_DISKMAP		"boot/solaris/bin/create_diskmap"
#define	EXTRACT_BOOT_FILELIST	"boot/solaris/bin/extract_boot_filelist"
#define	GRUBDISK_MAP		"/var/run/solaris_grubdisk.map"

#define	GRUB_slice		"/etc/lu/GRUB_slice"
#define	GRUB_root		"/etc/lu/GRUB_root"
#define	GRUB_backup_menu	"/etc/lu/GRUB_backup_menu"
#define	GRUB_slice_mntpt	"/tmp/GRUB_slice_mntpt"
#define	LU_ACTIVATE_FILE	"/etc/lu/DelayUpdate/activate.sh"
#define	GRUB_fdisk		"/etc/lu/GRUB_fdisk"
#define	GRUB_fdisk_target	"/etc/lu/GRUB_fdisk_target"

#define	INSTALLGRUB		"/sbin/installgrub"
#define	STAGE1			"/boot/grub/stage1"
#define	STAGE2			"/boot/grub/stage2"

/*
 * The following two defines are used to detect and create the correct
 * boot archive  when safemode patching is underway.  LOFS_PATCH_FILE is a
 * contracted private interface between bootadm and the install
 * consolidation.  It is set by pdo.c when a patch with SUNW_PATCH_SAFEMODE
 * is applied.
 */

#define	LOFS_PATCH_FILE		"/var/run/.patch_loopback_mode"
#define	LOFS_PATCH_MNT		"/var/run/.patch_root_loopbackmnt"

/*
 * Default file attributes
 */
#define	DEFAULT_DEV_MODE	0644	/* default permissions */
#define	DEFAULT_DEV_UID		0	/* user root */
#define	DEFAULT_DEV_GID		3	/* group sys */

/*
 * Menu related
 * menu_cmd_t and menu_cmds must be kept in sync
 */
char *menu_cmds[] = {
	"default",	/* DEFAULT_CMD */
	"timeout",	/* TIMEOUT_CMD */
	"title",	/* TITLE_CMD */
	"root",		/* ROOT_CMD */
	"kernel",	/* KERNEL_CMD */
	"kernel$",	/* KERNEL_DOLLAR_CMD */
	"module",	/* MODULE_CMD */
	"module$",	/* MODULE_DOLLAR_CMD */
	" ",		/* SEP_CMD */
	"#",		/* COMMENT_CMD */
	"chainloader",	/* CHAINLOADER_CMD */
	"args",		/* ARGS_CMD */
	NULL
};

#define	OPT_ENTRY_NUM	"entry"

/*
 * archive related
 */
typedef struct {
	line_t *head;
	line_t *tail;
} filelist_t;

#define	BOOT_FILE_LIST	"boot/solaris/filelist.ramdisk"
#define	ETC_FILE_LIST	"etc/boot/solaris/filelist.ramdisk"

#define	FILE_STAT	"boot/solaris/filestat.ramdisk"
#define	FILE_STAT_TMP	"boot/solaris/filestat.ramdisk.tmp"
#define	DIR_PERMS	(S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
#define	FILE_STAT_MODE	(S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

/* Globals */
int bam_verbose;
int bam_force;
static char *prog;
static subcmd_t bam_cmd;
static char *bam_root;
static int bam_rootlen;
static int bam_root_readonly;
static int bam_alt_root;
static char *bam_subcmd;
static char *bam_opt;
static int bam_debug;
static char **bam_argv;
static int bam_argc;
static int bam_check;
static int bam_smf_check;
static int bam_lock_fd = -1;
static char rootbuf[PATH_MAX] = "/";
static int bam_update_all;
static int bam_alt_platform;
static char *bam_platform;

/* function prototypes */
static void parse_args_internal(int, char *[]);
static void parse_args(int, char *argv[]);
static error_t bam_menu(char *, char *, int, char *[]);
static error_t bam_archive(char *, char *);

static void bam_print(char *, ...);
static void bam_exit(int);
static void bam_lock(void);
static void bam_unlock(void);

static int exec_cmd(char *, filelist_t *);
static error_t read_globals(menu_t *, char *, char *, int);

static menu_t *menu_read(char *);
static error_t menu_write(char *, menu_t *);
static void linelist_free(line_t *);
static void menu_free(menu_t *);
static void line_free(line_t *);
static void filelist_free(filelist_t *);
static error_t list2file(char *, char *, char *, line_t *);
static error_t list_entry(menu_t *, char *, char *);
static error_t delete_all_entries(menu_t *, char *, char *);
static error_t update_entry(menu_t *, char *, char *);
static error_t update_temp(menu_t *, char *, char *);

static error_t update_archive(char *, char *);
static error_t list_archive(char *, char *);
static error_t update_all(char *, char *);
static error_t read_list(char *, filelist_t *);
static error_t set_global(menu_t *, char *, int);
static error_t set_option(menu_t *, char *, char *);
static error_t set_kernel(menu_t *, menu_cmd_t, char *, char *, size_t);
static char *expand_path(const char *);

static long s_strtol(char *);
static int s_fputs(char *, FILE *);

static char *s_strdup(char *);
static int is_readonly(char *);
static int is_amd64(void);
static int is_sun4u(void);
static int is_sun4v(void);
static void append_to_flist(filelist_t *, char *);

#if !defined(_OPB)
static void ucode_install();
#endif

/* Menu related sub commands */
static subcmd_defn_t menu_subcmds[] = {
	"set_option",		OPT_OPTIONAL,	set_option, 0,	/* PUB */
	"list_entry",		OPT_OPTIONAL,	list_entry, 1,	/* PUB */
	"delete_all_entries",	OPT_ABSENT,	delete_all_entries, 0, /* PVT */
	"update_entry",		OPT_REQ,	update_entry, 0, /* menu */
	"update_temp",		OPT_OPTIONAL,	update_temp, 0,	/* reboot */
	"upgrade",		OPT_ABSENT,	upgrade_menu, 0, /* menu */
	NULL,			0,		NULL, 0	/* must be last */
};

/* Archive related sub commands */
static subcmd_defn_t arch_subcmds[] = {
	"update",		OPT_ABSENT,	update_archive, 0, /* PUB */
	"update_all",		OPT_ABSENT,	update_all, 0,	/* PVT */
	"list",			OPT_OPTIONAL,	list_archive, 1, /* PUB */
	NULL,			0,		NULL, 0	/* must be last */
};

static struct {
	nvlist_t *new_nvlp;
	nvlist_t *old_nvlp;
	int need_update;
} walk_arg;


struct safefile {
	char *name;
	struct safefile *next;
};

static struct safefile *safefiles = NULL;
#define	NEED_UPDATE_FILE "/etc/svc/volatile/boot_archive_needs_update"

static void
usage(void)
{
	(void) fprintf(stderr, "USAGE:\n");


	/* archive usage */
	(void) fprintf(stderr,
	    "\t%s update-archive [-vn] [-R altroot [-p platform>]]\n", prog);
	(void) fprintf(stderr,
	    "\t%s list-archive [-R altroot [-p platform>]]\n", prog);
#if !defined(_OPB)
	/* x86 only */
	(void) fprintf(stderr, "\t%s set-menu [-R altroot] key=value\n", prog);
	(void) fprintf(stderr, "\t%s list-menu [-R altroot]\n", prog);
#endif
}

int
main(int argc, char *argv[])
{
	error_t ret;

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	if ((prog = strrchr(argv[0], '/')) == NULL) {
		prog = argv[0];
	} else {
		prog++;
	}


	/*
	 * Don't depend on caller's umask
	 */
	(void) umask(0022);

	parse_args(argc, argv);

	switch (bam_cmd) {
		case BAM_MENU:
			ret = bam_menu(bam_subcmd, bam_opt, bam_argc, bam_argv);
			break;
		case BAM_ARCHIVE:
			ret = bam_archive(bam_subcmd, bam_opt);
			break;
		default:
			usage();
			bam_exit(1);
	}

	if (ret != BAM_SUCCESS)
		bam_exit(1);

	bam_unlock();
	return (0);
}

/*
 * Equivalence of public and internal commands:
 *	update-archive  -- -a update
 *	list-archive	-- -a list
 *	set-menu	-- -m set_option
 *	list-menu	-- -m list_entry
 *	update-menu	-- -m update_entry
 */
static struct cmd_map {
	char *bam_cmdname;
	int bam_cmd;
	char *bam_subcmd;
} cmd_map[] = {
	{ "update-archive",	BAM_ARCHIVE,	"update"},
	{ "list-archive",	BAM_ARCHIVE,	"list"},
	{ "set-menu",		BAM_MENU,	"set_option"},
	{ "list-menu",		BAM_MENU,	"list_entry"},
	{ "update-menu",	BAM_MENU,	"update_entry"},
	{ NULL,			0,		NULL}
};

/*
 * Commands syntax published in bootadm(1M) are parsed here
 */
static void
parse_args(int argc, char *argv[])
{
	struct cmd_map *cmp = cmd_map;

	/* command conforming to the final spec */
	if (argc > 1 && argv[1][0] != '-') {
		/*
		 * Map commands to internal table.
		 */
		while (cmp->bam_cmdname) {
			if (strcmp(argv[1], cmp->bam_cmdname) == 0) {
				bam_cmd = cmp->bam_cmd;
				bam_subcmd = cmp->bam_subcmd;
				break;
			}
			cmp++;
		}
		if (cmp->bam_cmdname == NULL) {
			usage();
			bam_exit(1);
		}
		argc--;
		argv++;
	}

	parse_args_internal(argc, argv);
}

/*
 * A combination of public and private commands are parsed here.
 * The internal syntax and the corresponding functionality are:
 *	-a update	-- update-archive
 *	-a list		-- list-archive
 *	-a update-all	-- (reboot to sync all mounted OS archive)
 *	-m update_entry	-- update-menu
 *	-m list_entry	-- list-menu
 *	-m update_temp	-- (reboot -- [boot-args])
 *	-m delete_all_entries -- (called from install)
 */
static void
parse_args_internal(int argc, char *argv[])
{
	int c, error;
	extern char *optarg;
	extern int optind, opterr;

	/* Suppress error message from getopt */
	opterr = 0;

	error = 0;
	while ((c = getopt(argc, argv, "a:d:fm:no:vCR:p:")) != -1) {
		switch (c) {
		case 'a':
			if (bam_cmd) {
				error = 1;
				bam_error(MULT_CMDS, c);
			}
			bam_cmd = BAM_ARCHIVE;
			bam_subcmd = optarg;
			break;
		case 'd':
			if (bam_debug) {
				error = 1;
				bam_error(DUP_OPT, c);
			}
			bam_debug = s_strtol(optarg);
			break;
		case 'f':
			if (bam_force) {
				error = 1;
				bam_error(DUP_OPT, c);
			}
			bam_force = 1;
			break;
		case 'm':
			if (bam_cmd) {
				error = 1;
				bam_error(MULT_CMDS, c);
			}
			bam_cmd = BAM_MENU;
			bam_subcmd = optarg;
			break;
		case 'n':
			if (bam_check) {
				error = 1;
				bam_error(DUP_OPT, c);
			}
			bam_check = 1;
			break;
		case 'o':
			if (bam_opt) {
				error = 1;
				bam_error(DUP_OPT, c);
			}
			bam_opt = optarg;
			break;
		case 'v':
			if (bam_verbose) {
				error = 1;
				bam_error(DUP_OPT, c);
			}
			bam_verbose = 1;
			break;
		case 'C':
			bam_smf_check = 1;
			break;
		case 'R':
			if (bam_root) {
				error = 1;
				bam_error(DUP_OPT, c);
				break;
			} else if (realpath(optarg, rootbuf) == NULL) {
				error = 1;
				bam_error(CANT_RESOLVE, optarg,
				    strerror(errno));
				break;
			}
			bam_alt_root = 1;
			bam_root = rootbuf;
			bam_rootlen = strlen(rootbuf);
			break;
		case 'p':
			bam_alt_platform = 1;
			bam_platform = optarg;
			if ((strcmp(bam_platform, "i86pc") != 0) &&
			    (strcmp(bam_platform, "sun4u") != 0) &&
			    (strcmp(bam_platform, "sun4v") != 0)) {
				error = 1;
				bam_error(INVALID_PLAT, bam_platform);
			}
			break;
		case '?':
			error = 1;
			bam_error(BAD_OPT, optopt);
			break;
		default :
			error = 1;
			bam_error(BAD_OPT, c);
			break;
		}
	}

	/*
	 * An alternate platform requires an alternate root
	 */
	if (bam_alt_platform && bam_alt_root == 0) {
		usage();
		bam_exit(0);
	}

	/*
	 * A command option must be specfied
	 */
	if (!bam_cmd) {
		if (bam_opt && strcmp(bam_opt, "all") == 0) {
			usage();
			bam_exit(0);
		}
		bam_error(NEED_CMD);
		error = 1;
	}

	if (error) {
		usage();
		bam_exit(1);
	}

	if (optind > argc) {
		bam_error(INT_ERROR, "parse_args");
		bam_exit(1);
	} else if (optind < argc) {
		bam_argv = &argv[optind];
		bam_argc = argc - optind;
	}

	/*
	 * -n implies verbose mode
	 */
	if (bam_check)
		bam_verbose = 1;
}

static error_t
check_subcmd_and_options(
	char *subcmd,
	char *opt,
	subcmd_defn_t *table,
	error_t (**fp)())
{
	int i;

	if (subcmd == NULL) {
		bam_error(NEED_SUBCMD);
		return (BAM_ERROR);
	}

	if (bam_argc != 0 || bam_argv) {
		if (strcmp(subcmd, "set_option") != 0 || bam_argc != 1) {
			bam_error(TRAILING_ARGS);
			usage();
			return (BAM_ERROR);
		}
	}

	if (bam_root == NULL) {
		bam_root = rootbuf;
		bam_rootlen = 1;
	}

	/* verify that subcmd is valid */
	for (i = 0; table[i].subcmd != NULL; i++) {
		if (strcmp(table[i].subcmd, subcmd) == 0)
			break;
	}

	if (table[i].subcmd == NULL) {
		bam_error(INVALID_SUBCMD, subcmd);
		return (BAM_ERROR);
	}

	if (table[i].unpriv == 0 && geteuid() != 0) {
		bam_error(MUST_BE_ROOT);
		return (BAM_ERROR);
	}

	/*
	 * Currently only privileged commands need a lock
	 */
	if (table[i].unpriv == 0)
		bam_lock();

	/* subcmd verifies that opt is appropriate */
	if (table[i].option != OPT_OPTIONAL) {
		if ((table[i].option == OPT_REQ) ^ (opt != NULL)) {
			if (opt)
				bam_error(NO_OPT_REQ, subcmd);
			else
				bam_error(MISS_OPT, subcmd);
			return (BAM_ERROR);
		}
	}

	*fp = table[i].handler;

	return (BAM_SUCCESS);
}


static char *
mount_grub_slice(int *mnted, char **physlice, char **logslice, char **fs_type)
{
	struct extmnttab mnt;
	struct stat sb;
	char buf[BAM_MAXLINE], dev[PATH_MAX], phys[PATH_MAX], fstype[32];
	char cmd[PATH_MAX];
	char *mntpt;
	int p, l, f;
	FILE *fp;

	assert(mnted);
	*mnted = 0;

	/*
	 * physlice, logslice, fs_type  args may be NULL
	 */
	if (physlice)
		*physlice = NULL;
	if (logslice)
		*logslice = NULL;
	if (fs_type)
		*fs_type = NULL;

	if (stat(GRUB_slice, &sb) != 0) {
		bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno));
		return (NULL);
	}

	fp = fopen(GRUB_slice, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, GRUB_slice, strerror(errno));
		return (NULL);
	}

	dev[0] = fstype[0] = phys[0] = '\0';
	p = sizeof ("PHYS_SLICE=") - 1;
	l = sizeof ("LOG_SLICE=") - 1;
	f = sizeof ("LOG_FSTYP=") - 1;
	while (s_fgets(buf, sizeof (buf), fp) != NULL) {
		if (strncmp(buf, "PHYS_SLICE=", p) == 0) {
			(void) strlcpy(phys, buf + p, sizeof (phys));
			continue;
		}
		if (strncmp(buf, "LOG_SLICE=", l) == 0) {
			(void) strlcpy(dev, buf + l, sizeof (dev));
			continue;
		}
		if (strncmp(buf, "LOG_FSTYP=", f) == 0) {
			(void) strlcpy(fstype, buf + f, sizeof (fstype));
			continue;
		}
	}
	(void) fclose(fp);

	if (dev[0] == '\0' || fstype[0] == '\0' || phys[0] == '\0') {
		bam_error(BAD_SLICE_FILE, GRUB_slice);
		return (NULL);
	}

	if (physlice) {
		*physlice = s_strdup(phys);
	}
	if (logslice) {
		*logslice = s_strdup(dev);
	}
	if (fs_type) {
		*fs_type = s_strdup(fstype);
	}

	/*
	 * Check if the slice is already mounted
	 */
	fp = fopen(MNTTAB, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
		goto error;
	}

	resetmnttab(fp);

	mntpt = NULL;
	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
		if (strcmp(mnt.mnt_special, dev) == 0) {
			mntpt = s_strdup(mnt.mnt_mountp);
			break;
		}
	}

	(void) fclose(fp);

	if (mntpt) {
		return (mntpt);
	}


	/*
	 * GRUB slice is not mounted, we need to mount it now.
	 * First create the mountpoint
	 */
	mntpt = s_calloc(1, PATH_MAX);
	(void) snprintf(mntpt, PATH_MAX, "%s.%d", GRUB_slice_mntpt, getpid());
	if (mkdir(mntpt, 0755) == -1 && errno != EEXIST) {
		bam_error(MKDIR_FAILED, mntpt, strerror(errno));
		free(mntpt);
		goto error;
	}

	(void) snprintf(cmd, sizeof (cmd), "/sbin/mount -F %s %s %s",
	    fstype, dev, mntpt);

	if (exec_cmd(cmd, NULL) != 0) {
		bam_error(MOUNT_FAILED, dev, fstype);
		if (rmdir(mntpt) != 0) {
			bam_error(RMDIR_FAILED, mntpt, strerror(errno));
		}
		free(mntpt);
		goto error;
	}

	*mnted = 1;
	return (mntpt);

error:
	if (physlice) {
		free(*physlice);
		*physlice = NULL;
	}
	if (logslice) {
		free(*logslice);
		*logslice = NULL;
	}
	if (fs_type) {
		free(*fs_type);
		*fs_type = NULL;
	}
	return (NULL);
}

static void
umount_grub_slice(
	int mnted,
	char *mntpt,
	char *physlice,
	char *logslice,
	char *fs_type)
{
	char cmd[PATH_MAX];

	/*
	 * If we have not dealt with GRUB slice
	 * we have nothing to do - just return.
	 */
	if (mntpt == NULL)
		return;


	/*
	 * If we mounted the filesystem earlier in mount_grub_slice()
	 * unmount it now.
	 */
	if (mnted) {
		(void) snprintf(cmd, sizeof (cmd), "/sbin/umount %s",
		    mntpt);
		if (exec_cmd(cmd, NULL) != 0) {
			bam_error(UMOUNT_FAILED, mntpt);
		}
		if (rmdir(mntpt) != 0) {
			bam_error(RMDIR_FAILED, mntpt, strerror(errno));
		}
	}

	if (physlice)
		free(physlice);
	if (logslice)
		free(logslice);
	if (fs_type)
		free(fs_type);

	free(mntpt);
}

static char *
use_stubboot(void)
{
	int mnted;
	struct stat sb;
	struct extmnttab mnt;
	FILE *fp;
	char cmd[PATH_MAX];

	if (stat(STUBBOOT, &sb) != 0) {
		bam_error(STUBBOOT_DIR_NOT_FOUND);
		return (NULL);
	}

	/*
	 * Check if stubboot is mounted. If not, mount it
	 */
	fp = fopen(MNTTAB, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
		return (NULL);
	}

	resetmnttab(fp);

	mnted = 0;
	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
		if (strcmp(mnt.mnt_mountp, STUBBOOT) == 0) {
			mnted = 1;
			break;
		}
	}

	(void) fclose(fp);

	if (mnted)
		return (STUBBOOT);

	/*
	 * Stubboot is not mounted, mount it now.
	 * It should exist in /etc/vfstab
	 */
	(void) snprintf(cmd, sizeof (cmd), "/sbin/mount %s",
	    STUBBOOT);
	if (exec_cmd(cmd, NULL) != 0) {
		bam_error(MOUNT_MNTPT_FAILED, STUBBOOT);
		return (NULL);
	}

	return (STUBBOOT);
}

static void
disp_active_menu_locn(char *menu_path, char *logslice, char *fstype, int mnted)
{
	/*
	 * Check if we did a temp mount of an unmounted device.
	 * If yes, print the block device and fstype for that device
	 * else it is already mounted, so we print the path to the GRUB menu.
	 */
	if (mnted) {
		bam_print(GRUB_MENU_DEVICE, logslice);
		bam_print(GRUB_MENU_FSTYPE, fstype);
	} else {
		bam_print(GRUB_MENU_PATH, menu_path);
	}
}

/*
 * NOTE: A single "/" is also considered a trailing slash and will
 * be deleted.
 */
static void
elide_trailing_slash(const char *src, char *dst, size_t dstsize)
{
	size_t dstlen;

	assert(src);
	assert(dst);

	(void) strlcpy(dst, src, dstsize);

	dstlen = strlen(dst);
	if (dst[dstlen - 1] == '/') {
		dst[dstlen - 1] = '\0';
	}
}

static error_t
bam_menu(char *subcmd, char *opt, int largc, char *largv[])
{
	error_t ret;
	char menu_path[PATH_MAX];
	char path[PATH_MAX];
	menu_t *menu;
	char *mntpt, *menu_root, *logslice, *fstype;
	struct stat sb;
	int mnted;	/* set if we did a mount */
	error_t (*f)(menu_t *mp, char *menu_path, char *opt);
	char *rootpath;

	/*
	 * Menu sub-command only applies to GRUB (i.e. x86)
	 */
	rootpath = (bam_alt_root) ? bam_root : "/";
	if (!is_grub((const char *)rootpath)) {
		bam_error(NOT_ON_SPARC);
		return (BAM_ERROR);
	}

	/*
	 * Check arguments
	 */
	ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f);
	if (ret == BAM_ERROR) {
		return (BAM_ERROR);
	}

	mntpt = NULL;
	mnted = 0;
	logslice = fstype = NULL;

	/*
	 * Check for the menu.list file:
	 *
	 * 1. Check for a GRUB_slice file, be it on / or
	 *    on the user-provided alternate root.
	 * 2. Use the alternate root, if given.
	 * 3. Check /stubboot
	 * 4. Use /
	 */
	if (bam_alt_root) {
		(void) snprintf(path, sizeof (path), "%s%s", bam_root,
		    GRUB_slice);
	} else {
		(void) snprintf(path, sizeof (path), "%s", GRUB_slice);
	}

	if (stat(path, &sb) == 0) {
		mntpt = mount_grub_slice(&mnted, NULL, &logslice, &fstype);
		menu_root = mntpt;
	} else if (bam_alt_root) {
		menu_root = bam_root;
	} else if (stat(STUBBOOT, &sb) == 0) {
		menu_root = use_stubboot();
	} else {
		menu_root = bam_root;
	}

	if (menu_root == NULL) {
		bam_error(CANNOT_LOCATE_GRUB_MENU);
		return (BAM_ERROR);
	}

	elide_trailing_slash(menu_root, menu_path, sizeof (menu_path));
	(void) strlcat(menu_path, GRUB_MENU, sizeof (menu_path));

	/*
	 * If listing the menu, display the active menu
	 * location
	 */
	if (strcmp(subcmd, "list_entry") == 0) {
		disp_active_menu_locn(menu_path, logslice, fstype, mnted);
	}

	menu = menu_read(menu_path);
	assert(menu);

	/*
	 * Special handling for setting timeout and default
	 */
	if (strcmp(subcmd, "set_option") == 0) {
		if (largc != 1 || largv[0] == NULL) {
			usage();
			menu_free(menu);
			umount_grub_slice(mnted, mntpt, NULL, logslice, fstype);
			return (BAM_ERROR);
		}
		opt = largv[0];
	} else if (largc != 0) {
		usage();
		menu_free(menu);
		umount_grub_slice(mnted, mntpt, NULL, logslice, fstype);
		return (BAM_ERROR);
	}

	ret = dboot_or_multiboot(bam_root);
	if (ret != BAM_SUCCESS)
		return (ret);

	/*
	 * Once the sub-cmd handler has run
	 * only the line field is guaranteed to have valid values
	 */
	if ((strcmp(subcmd, "update_entry") == 0) ||
	    (strcmp(subcmd, "upgrade") == 0))
		ret = f(menu, bam_root, opt);
	else
		ret = f(menu, menu_path, opt);
	if (ret == BAM_WRITE) {
		ret = menu_write(menu_root, menu);
	}

	menu_free(menu);

	umount_grub_slice(mnted, mntpt, NULL, logslice, fstype);

	return (ret);
}


static error_t
bam_archive(
	char *subcmd,
	char *opt)
{
	error_t ret;
	error_t (*f)(char *root, char *opt);

	/*
	 * Add trailing / for archive subcommands
	 */
	if (rootbuf[strlen(rootbuf) - 1] != '/')
		(void) strcat(rootbuf, "/");
	bam_rootlen = strlen(rootbuf);

	/*
	 * Check arguments
	 */
	ret = check_subcmd_and_options(subcmd, opt, arch_subcmds, &f);
	if (ret != BAM_SUCCESS) {
		return (BAM_ERROR);
	}

	ret = dboot_or_multiboot(rootbuf);
	if (ret != BAM_SUCCESS)
		return (ret);

	/*
	 * Check archive not supported with update_all
	 * since it is awkward to display out-of-sync
	 * information for each BE.
	 */
	if (bam_check && strcmp(subcmd, "update_all") == 0) {
		bam_error(CHECK_NOT_SUPPORTED, subcmd);
		return (BAM_ERROR);
	}

	if (strcmp(subcmd, "update_all") == 0)
		bam_update_all = 1;

#if !defined(_OPB)
	ucode_install(bam_root);
#endif

	ret = f(bam_root, opt);

	bam_update_all = 0;

	return (ret);
}

/*PRINTFLIKE1*/
void
bam_error(char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	(void) fprintf(stderr, "%s: ", prog);
	(void) vfprintf(stderr, format, ap);
	va_end(ap);
}

/*PRINTFLIKE1*/
static void
bam_print(char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	(void) vfprintf(stdout, format, ap);
	va_end(ap);
}

/*PRINTFLIKE1*/
void
bam_print_stderr(char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	(void) vfprintf(stderr, format, ap);
	va_end(ap);
}

static void
bam_exit(int excode)
{
	bam_unlock();
	exit(excode);
}

static void
bam_lock(void)
{
	struct flock lock;
	pid_t pid;

	bam_lock_fd = open(BAM_LOCK_FILE, O_CREAT|O_RDWR, LOCK_FILE_PERMS);
	if (bam_lock_fd < 0) {
		/*
		 * We may be invoked early in boot for archive verification.
		 * In this case, root is readonly and /var/run may not exist.
		 * Proceed without the lock
		 */
		if (errno == EROFS || errno == ENOENT) {
			bam_root_readonly = 1;
			return;
		}

		bam_error(OPEN_FAIL, BAM_LOCK_FILE, strerror(errno));
		bam_exit(1);
	}

	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if (fcntl(bam_lock_fd, F_SETLK, &lock) == -1) {
		if (errno != EACCES && errno != EAGAIN) {
			bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
			(void) close(bam_lock_fd);
			bam_lock_fd = -1;
			bam_exit(1);
		}
		pid = 0;
		(void) pread(bam_lock_fd, &pid, sizeof (pid_t), 0);
		bam_print(FILE_LOCKED, pid);

		lock.l_type = F_WRLCK;
		lock.l_whence = SEEK_SET;
		lock.l_start = 0;
		lock.l_len = 0;
		if (fcntl(bam_lock_fd, F_SETLKW, &lock) == -1) {
			bam_error(LOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
			(void) close(bam_lock_fd);
			bam_lock_fd = -1;
			bam_exit(1);
		}
	}

	/* We own the lock now */
	pid = getpid();
	(void) write(bam_lock_fd, &pid, sizeof (pid));
}

static void
bam_unlock(void)
{
	struct flock unlock;

	/*
	 * NOP if we don't hold the lock
	 */
	if (bam_lock_fd < 0) {
		return;
	}

	unlock.l_type = F_UNLCK;
	unlock.l_whence = SEEK_SET;
	unlock.l_start = 0;
	unlock.l_len = 0;

	if (fcntl(bam_lock_fd, F_SETLK, &unlock) == -1) {
		bam_error(UNLOCK_FAIL, BAM_LOCK_FILE, strerror(errno));
	}

	if (close(bam_lock_fd) == -1) {
		bam_error(CLOSE_FAIL, BAM_LOCK_FILE, strerror(errno));
	}
	bam_lock_fd = -1;
}

static error_t
list_archive(char *root, char *opt)
{
	filelist_t flist;
	filelist_t *flistp = &flist;
	line_t *lp;

	assert(root);
	assert(opt == NULL);

	flistp->head = flistp->tail = NULL;
	if (read_list(root, flistp) != BAM_SUCCESS) {
		return (BAM_ERROR);
	}
	assert(flistp->head && flistp->tail);

	for (lp = flistp->head; lp; lp = lp->next) {
		bam_print(PRINT, lp->line);
	}

	filelist_free(flistp);

	return (BAM_SUCCESS);
}

/*
 * This routine writes a list of lines to a file.
 * The list is *not* freed
 */
static error_t
list2file(char *root, char *tmp, char *final, line_t *start)
{
	char tmpfile[PATH_MAX];
	char path[PATH_MAX];
	FILE *fp;
	int ret;
	struct stat sb;
	mode_t mode;
	uid_t root_uid;
	gid_t sys_gid;
	struct passwd *pw;
	struct group *gp;


	(void) snprintf(path, sizeof (path), "%s%s", root, final);

	if (start == NULL) {
		if (stat(path, &sb) != -1) {
			bam_print(UNLINK_EMPTY, path);
			if (unlink(path) != 0) {
				bam_error(UNLINK_FAIL, path, strerror(errno));
				return (BAM_ERROR);
			} else {
				return (BAM_SUCCESS);
			}
		}
	}

	/*
	 * Preserve attributes of existing file if possible,
	 * otherwise ask the system for uid/gid of root/sys.
	 * If all fails, fall back on hard-coded defaults.
	 */
	if (stat(path, &sb) != -1) {
		mode = sb.st_mode;
		root_uid = sb.st_uid;
		sys_gid = sb.st_gid;
	} else {
		mode = DEFAULT_DEV_MODE;
		if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
			root_uid = pw->pw_uid;
		} else {
			if (bam_verbose)
				bam_error(CANT_FIND_USER,
				    DEFAULT_DEV_USER, DEFAULT_DEV_UID);
			root_uid = (uid_t)DEFAULT_DEV_UID;
		}
		if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
			sys_gid = gp->gr_gid;
		} else {
			if (bam_verbose)
				bam_error(CANT_FIND_GROUP,
				    DEFAULT_DEV_GROUP, DEFAULT_DEV_GID);
			sys_gid = (gid_t)DEFAULT_DEV_GID;
		}
	}

	(void) snprintf(tmpfile, sizeof (tmpfile), "%s%s", root, tmp);

	/* Truncate tmpfile first */
	fp = fopen(tmpfile, "w");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}
	ret = fclose(fp);
	if (ret == EOF) {
		bam_error(CLOSE_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}

	/* Now open it in append mode */
	fp = fopen(tmpfile, "a");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}

	for (; start; start = start->next) {
		ret = s_fputs(start->line, fp);
		if (ret == EOF) {
			bam_error(WRITE_FAIL, tmpfile, strerror(errno));
			(void) fclose(fp);
			return (BAM_ERROR);
		}
	}

	ret = fclose(fp);
	if (ret == EOF) {
		bam_error(CLOSE_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}

	/*
	 * Set up desired attributes.  Ignore failures on filesystems
	 * not supporting these operations - pcfs reports unsupported
	 * operations as EINVAL.
	 */
	ret = chmod(tmpfile, mode);
	if (ret == -1 &&
	    errno != EINVAL && errno != ENOTSUP) {
		bam_error(CHMOD_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}

	ret = chown(tmpfile, root_uid, sys_gid);
	if (ret == -1 &&
	    errno != EINVAL && errno != ENOTSUP) {
		bam_error(CHOWN_FAIL, tmpfile, strerror(errno));
		return (BAM_ERROR);
	}


	/*
	 * Do an atomic rename
	 */
	ret = rename(tmpfile, path);
	if (ret != 0) {
		bam_error(RENAME_FAIL, path, strerror(errno));
		return (BAM_ERROR);
	}

	return (BAM_SUCCESS);
}

/*
 * This function should always return 0 - since we want
 * to create stat data for *all* files in the list.
 */
/*ARGSUSED*/
static int
cmpstat(
	const char *file,
	const struct stat *stat,
	int flags,
	struct FTW *ftw)
{
	uint_t sz;
	uint64_t *value;
	uint64_t filestat[2];
	int error;

	struct safefile *safefilep;
	FILE *fp;

	/*
	 * We only want regular files
	 */
	if (!S_ISREG(stat->st_mode))
		return (0);

	/*
	 * new_nvlp may be NULL if there were errors earlier
	 * but this is not fatal to update determination.
	 */
	if (walk_arg.new_nvlp) {
		filestat[0] = stat->st_size;
		filestat[1] = stat->st_mtime;
		error = nvlist_add_uint64_array(walk_arg.new_nvlp,
		    file + bam_rootlen, filestat, 2);
		if (error)
			bam_error(NVADD_FAIL, file, strerror(error));
	}

	/*
	 * The remaining steps are only required if we haven't made a
	 * decision about update or if we are checking (-n)
	 */
	if (walk_arg.need_update && !bam_check)
		return (0);

	/*
	 * If we are invoked as part of system/filesystem/boot-archive, then
	 * there are a number of things we should not worry about
	 */
	if (bam_smf_check) {
		/* ignore amd64 modules unless we are booted amd64. */
		if (!is_amd64() && strstr(file, "/amd64/") != 0)
			return (0);

		/* read in list of safe files */
		if (safefiles == NULL)
			if (fp = fopen("/boot/solaris/filelist.safe", "r")) {
				safefiles = s_calloc(1,
				    sizeof (struct safefile));
				safefilep = safefiles;
				safefilep->name = s_calloc(1, MAXPATHLEN +
				    MAXNAMELEN);
				safefilep->next = NULL;
				while (s_fgets(safefilep->name, MAXPATHLEN +
				    MAXNAMELEN, fp) != NULL) {
					safefilep->next = s_calloc(1,
					    sizeof (struct safefile));
					safefilep = safefilep->next;
					safefilep->name = s_calloc(1,
					    MAXPATHLEN + MAXNAMELEN);
					safefilep->next = NULL;
				}
				(void) fclose(fp);
			}
	}

	/*
	 * We need an update if file doesn't exist in old archive
	 */
	if (walk_arg.old_nvlp == NULL ||
	    nvlist_lookup_uint64_array(walk_arg.old_nvlp,
	    file + bam_rootlen, &value, &sz) != 0) {
		if (bam_smf_check)	/* ignore new during smf check */
			return (0);
		walk_arg.need_update = 1;
		if (bam_verbose)
			bam_print(PARSEABLE_NEW_FILE, file);
		return (0);
	}

	/*
	 * File exists in old archive. Check if file has changed
	 */
	assert(sz == 2);
	bcopy(value, filestat, sizeof (filestat));

	if (filestat[0] != stat->st_size ||
	    filestat[1] != stat->st_mtime) {
		if (bam_smf_check) {
			safefilep = safefiles;
			while (safefilep != NULL) {
				if (strcmp(file + bam_rootlen,
				    safefilep->name) == 0) {
					(void) creat(NEED_UPDATE_FILE, 0644);
					return (0);
				}
				safefilep = safefilep->next;
			}
		}
		walk_arg.need_update = 1;
		if (bam_verbose)
			if (bam_smf_check)
				bam_print("    %s\n", file);
			else
				bam_print(PARSEABLE_OUT_DATE, file);
	}

	return (0);
}

/*
 * Check flags and presence of required files.
 * The force flag and/or absence of files should
 * trigger an update.
 * Suppress stdout output if check (-n) option is set
 * (as -n should only produce parseable output.)
 */
static void
check_flags_and_files(char *root)
{
	char path[PATH_MAX];
	struct stat sb;

	/*
	 * if force, create archive unconditionally
	 */
	if (bam_force) {
		walk_arg.need_update = 1;
		if (bam_verbose && !bam_check)
			bam_print(UPDATE_FORCE);
		return;
	}

	/*
	 * If archive is missing, create archive
	 */
	if (is_sun4u()) {
		(void) snprintf(path, sizeof (path), "%s%s", root,
		    SUN4U_ARCHIVE);
	} else if (is_sun4v()) {
		(void) snprintf(path, sizeof (path), "%s%s", root,
		    SUN4V_ARCHIVE);
	} else {
		if (bam_direct == BAM_DIRECT_DBOOT) {
			(void) snprintf(path, sizeof (path), "%s%s", root,
			    DIRECT_BOOT_ARCHIVE_64);
			if (stat(path, &sb) != 0) {
				if (bam_verbose && !bam_check)
					bam_print(UPDATE_ARCH_MISS, path);
				walk_arg.need_update = 1;
				return;
			}
		}
		(void) snprintf(path, sizeof (path), "%s%s", root,
		    DIRECT_BOOT_ARCHIVE_32);
	}

	if (stat(path, &sb) != 0) {
		if (bam_verbose && !bam_check)
			bam_print(UPDATE_ARCH_MISS, path);
		walk_arg.need_update = 1;
		return;
	}
}

static error_t
read_one_list(char *root, filelist_t  *flistp, char *filelist)
{
	char path[PATH_MAX];
	FILE *fp;
	char buf[BAM_MAXLINE];

	(void) snprintf(path, sizeof (path), "%s%s", root, filelist);

	fp = fopen(path, "r");
	if (fp == NULL) {
		if (bam_debug)
			bam_error(FLIST_FAIL, path, strerror(errno));
		return (BAM_ERROR);
	}
	while (s_fgets(buf, sizeof (buf), fp) != NULL) {
		/* skip blank lines */
		if (strspn(buf, " \t") == strlen(buf))
			continue;
		append_to_flist(flistp, buf);
	}
	if (fclose(fp) != 0) {
		bam_error(CLOSE_FAIL, path, strerror(errno));
		return (BAM_ERROR);
	}
	return (BAM_SUCCESS);
}

static error_t
read_list(char *root, filelist_t  *flistp)
{
	char path[PATH_MAX];
	char cmd[PATH_MAX];
	struct stat sb;
	int n, rval;

	flistp->head = flistp->tail = NULL;

	/*
	 * build and check path to extract_boot_filelist.ksh
	 */
	n = snprintf(path, sizeof (path), "%s%s", root, EXTRACT_BOOT_FILELIST);
	if (n >= sizeof (path)) {
		bam_error(NO_FLIST);
		return (BAM_ERROR);
	}

	/*
	 * If extract_boot_filelist is present, exec it, otherwise read
	 * the filelists directly, for compatibility with older images.
	 */
	if (stat(path, &sb) == 0) {
		/*
		 * build arguments to exec extract_boot_filelist.ksh
		 */
		char *rootarg, *platarg;
		int platarglen = 1, rootarglen = 1;
		if (strlen(root) > 1)
			rootarglen += strlen(root) + strlen("-R ");
		if (bam_alt_platform)
			platarglen += strlen(bam_platform) + strlen("-p ");
		platarg = s_calloc(1, platarglen);
		rootarg = s_calloc(1, rootarglen);
		*platarg = 0;
		*rootarg = 0;

		if (strlen(root) > 1) {
			(void) snprintf(rootarg, rootarglen,
			    "-R %s", root);
		}
		if (bam_alt_platform) {
			(void) snprintf(platarg, platarglen,
			    "-p %s", bam_platform);
		}
		n = snprintf(cmd, sizeof (cmd), "%s %s %s /%s /%s",
		    path, rootarg, platarg, BOOT_FILE_LIST, ETC_FILE_LIST);
		free(platarg);
		free(rootarg);
		if (n >= sizeof (cmd)) {
			bam_error(NO_FLIST);
			return (BAM_ERROR);
		}
		if (exec_cmd(cmd, flistp) != 0) {
			if (bam_debug)
				bam_error(FLIST_FAIL, path, strerror(errno));
			return (BAM_ERROR);
		}
	} else {
		/*
		 * Read current lists of files - only the first is mandatory
		 */
		rval = read_one_list(root, flistp, BOOT_FILE_LIST);
		if (rval != BAM_SUCCESS)
			return (rval);
		(void) read_one_list(root, flistp, ETC_FILE_LIST);
	}

	if (flistp->head == NULL) {
		bam_error(NO_FLIST);
		return (BAM_ERROR);
	}

	return (BAM_SUCCESS);
}

static void
getoldstat(char *root)
{
	char path[PATH_MAX];
	int fd, error;
	struct stat sb;
	char *ostat;

	(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT);
	fd = open(path, O_RDONLY);
	if (fd == -1) {
		if (bam_verbose)
			bam_print(OPEN_FAIL, path, strerror(errno));
		walk_arg.need_update = 1;
		return;
	}

	if (fstat(fd, &sb) != 0) {
		bam_error(STAT_FAIL, path, strerror(errno));
		(void) close(fd);
		walk_arg.need_update = 1;
		return;
	}

	ostat = s_calloc(1, sb.st_size);

	if (read(fd, ostat, sb.st_size) != sb.st_size) {
		bam_error(READ_FAIL, path, strerror(errno));
		(void) close(fd);
		free(ostat);
		walk_arg.need_update = 1;
		return;
	}

	(void) close(fd);

	walk_arg.old_nvlp = NULL;
	error = nvlist_unpack(ostat, sb.st_size, &walk_arg.old_nvlp, 0);

	free(ostat);

	if (error) {
		bam_error(UNPACK_FAIL, path, strerror(error));
		walk_arg.old_nvlp = NULL;
		walk_arg.need_update = 1;
		return;
	}
}

/*
 * Checks if a file in the current (old) archive has
 * been deleted from the root filesystem. This is needed for
 * software like Trusted Extensions (TX) that switch early
 * in boot based on presence/absence of a kernel module.
 */
static void
check4stale(char *root)
{
	nvpair_t	*nvp;
	nvlist_t	*nvlp;
	char 		*file;
	char		path[PATH_MAX];
	struct stat	sb;

	/*
	 * Skip stale file check during smf check
	 */
	if (bam_smf_check)
		return;

	/* Nothing to do if no old stats */
	if ((nvlp = walk_arg.old_nvlp) == NULL)
		return;

	for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp;
	    nvp = nvlist_next_nvpair(nvlp, nvp)) {
		file = nvpair_name(nvp);
		if (file == NULL)
			continue;
		(void) snprintf(path, sizeof (path), "%s/%s",
		    root, file);
		if (stat(path, &sb) == -1) {
			walk_arg.need_update = 1;
			if (bam_verbose)
				bam_print(PARSEABLE_STALE_FILE, path);
		}
	}
}

static void
create_newstat(void)
{
	int error;

	error = nvlist_alloc(&walk_arg.new_nvlp, NV_UNIQUE_NAME, 0);
	if (error) {
		/*
		 * Not fatal - we can still create archive
		 */
		walk_arg.new_nvlp = NULL;
		bam_error(NVALLOC_FAIL, strerror(error));
	}
}

static void
walk_list(char *root, filelist_t *flistp)
{
	char path[PATH_MAX];
	line_t *lp;

	for (lp = flistp->head; lp; lp = lp->next) {
		/*
		 * Don't follow symlinks.  A symlink must refer to
		 * a file that would appear in the archive through
		 * a direct reference.  This matches the archive
		 * construction behavior.
		 */
		(void) snprintf(path, sizeof (path), "%s%s", root, lp->line);
		if (nftw(path, cmpstat, 20, FTW_PHYS) == -1) {
			/*
			 * Some files may not exist.
			 * For example: etc/rtc_config on a x86 diskless system
			 * Emit verbose message only
			 */
			if (bam_verbose)
				bam_print(NFTW_FAIL, path, strerror(errno));
		}
	}
}

static void
savenew(char *root)
{
	char path[PATH_MAX];
	char path2[PATH_MAX];
	size_t sz;
	char *nstat;
	int fd, wrote, error;

	nstat = NULL;
	sz = 0;
	error = nvlist_pack(walk_arg.new_nvlp, &nstat, &sz,
	    NV_ENCODE_XDR, 0);
	if (error) {
		bam_error(PACK_FAIL, strerror(error));
		return;
	}

	(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT_TMP);
	fd = open(path, O_RDWR|O_CREAT|O_TRUNC, FILE_STAT_MODE);
	if (fd == -1) {
		bam_error(OPEN_FAIL, path, strerror(errno));
		free(nstat);
		return;
	}
	wrote = write(fd, nstat, sz);
	if (wrote != sz) {
		bam_error(WRITE_FAIL, path, strerror(errno));
		(void) close(fd);
		free(nstat);
		return;
	}
	(void) close(fd);
	free(nstat);

	(void) snprintf(path2, sizeof (path2), "%s%s", root, FILE_STAT);
	if (rename(path, path2) != 0) {
		bam_error(RENAME_FAIL, path2, strerror(errno));
	}
}

static void
clear_walk_args(void)
{
	if (walk_arg.old_nvlp)
		nvlist_free(walk_arg.old_nvlp);
	if (walk_arg.new_nvlp)
		nvlist_free(walk_arg.new_nvlp);
	walk_arg.need_update = 0;
	walk_arg.old_nvlp = NULL;
	walk_arg.new_nvlp = NULL;
}

/*
 * Returns:
 *	0 - no update necessary
 *	1 - update required.
 *	BAM_ERROR (-1) - An error occurred
 *
 * Special handling for check (-n):
 * ================================
 * The check (-n) option produces parseable output.
 * To do this, we suppress all stdout messages unrelated
 * to out of sync files.
 * All stderr messages are still printed though.
 *
 */
static int
update_required(char *root)
{
	struct stat sb;
	char path[PATH_MAX];
	filelist_t flist;
	filelist_t *flistp = &flist;
	int need_update;

	flistp->head = flistp->tail = NULL;

	walk_arg.need_update = 0;

	/*
	 * Without consulting stat data, check if we need update
	 */
	check_flags_and_files(root);

	/*
	 * In certain deployment scenarios, filestat may not
	 * exist. Ignore it during boot-archive SMF check.
	 */
	if (bam_smf_check) {
		(void) snprintf(path, sizeof (path), "%s%s", root, FILE_STAT);
		if (stat(path, &sb) != 0)
			return (0);
	}

	/*
	 * consult stat data only if we haven't made a decision
	 * about update. If checking (-n) however, we always
	 * need stat data (since we want to compare old and new)
	 */
	if (!walk_arg.need_update || bam_check)
		getoldstat(root);

	/*
	 * Check if the archive contains files that are no longer
	 * present on the root filesystem.
	 */
	if (!walk_arg.need_update || bam_check)
		check4stale(root);

	/*
	 * read list of files
	 */
	if (read_list(root, flistp) != BAM_SUCCESS) {
		clear_walk_args();
		return (BAM_ERROR);
	}

	assert(flistp->head && flistp->tail);

	/*
	 * At this point either the update is required
	 * or the decision is pending. In either case
	 * we need to create new stat nvlist
	 */
	create_newstat();

	/*
	 * This walk does 2 things:
	 *  	- gets new stat data for every file
	 *	- (optional) compare old and new stat data
	 */
	walk_list(root, &flist);

	/* done with the file list */
	filelist_free(flistp);

	/*
	 * if we didn't succeed in  creating new stat data above
	 * just return result of update check so that archive is built.
	 */
	if (walk_arg.new_nvlp == NULL) {
		bam_error(NO_NEW_STAT);
		need_update = walk_arg.need_update;
		clear_walk_args();
		return (need_update ? 1 : 0);
	}


	/*
	 * If no update required, discard newstat
	 */
	if (!walk_arg.need_update) {
		clear_walk_args();
		return (0);
	}

	return (1);
}

static error_t
create_ramdisk(char *root)
{
	char *cmdline, path[PATH_MAX];
	size_t len;
	struct stat sb;

	/*
	 * Setup command args for create_ramdisk.ksh
	 */
	(void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK);
	if (stat(path, &sb) != 0) {
		bam_error(ARCH_EXEC_MISS, path, strerror(errno));
		return (BAM_ERROR);
	}

	len = strlen(path) + strlen(root) + 10;	/* room for space + -R */
	if (bam_alt_platform)
		len += strlen(bam_platform) + strlen("-p ");
	cmdline = s_calloc(1, len);

	if (bam_alt_platform) {
		assert(strlen(root) > 1);
		(void) snprintf(cmdline, len, "%s -p %s -R %s",
		    path, bam_platform, root);
		/* chop off / at the end */
		cmdline[strlen(cmdline) - 1] = '\0';
	} else if (strlen(root) > 1) {
		(void) snprintf(cmdline, len, "%s -R %s", path, root);
		/* chop off / at the end */
		cmdline[strlen(cmdline) - 1] = '\0';
	} else
		(void) snprintf(cmdline, len, "%s", path);

	if (exec_cmd(cmdline, NULL) != 0) {
		bam_error(ARCHIVE_FAIL, cmdline);
		free(cmdline);
		return (BAM_ERROR);
	}
	free(cmdline);

	/*
	 * The existence of the expected archives used to be
	 * verified here. This check is done in create_ramdisk as
	 * it needs to be in sync with the altroot operated upon.
	 */

	return (BAM_SUCCESS);
}

/*
 * Checks if target filesystem is on a ramdisk
 * 1 - is miniroot
 * 0 - is not
 * When in doubt assume it is not a ramdisk.
 */
static int
is_ramdisk(char *root)
{
	struct extmnttab mnt;
	FILE *fp;
	int found;
	char mntpt[PATH_MAX];
	char *cp;

	/*
	 * There are 3 situations where creating archive is
	 * of dubious value:
	 *	- create boot_archive on a lofi-mounted boot_archive
	 *	- create it on a ramdisk which is the root filesystem
	 *	- create it on a ramdisk mounted somewhere else
	 * The first is not easy to detect and checking for it is not
	 * worth it.
	 * The other two conditions are handled here
	 */

	fp = fopen(MNTTAB, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
		return (0);
	}

	resetmnttab(fp);

	/*
	 * Remove any trailing / from the mount point
	 */
	(void) strlcpy(mntpt, root, sizeof (mntpt));
	if (strcmp(root, "/") != 0) {
		cp = mntpt + strlen(mntpt) - 1;
		if (*cp == '/')
			*cp = '\0';
	}
	found = 0;
	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
		if (strcmp(mnt.mnt_mountp, mntpt) == 0) {
			found = 1;
			break;
		}
	}

	if (!found) {
		if (bam_verbose)
			bam_error(NOT_IN_MNTTAB, mntpt);
		(void) fclose(fp);
		return (0);
	}

	if (strstr(mnt.mnt_special, RAMDISK_SPECIAL) != NULL) {
		if (bam_verbose)
			bam_error(IS_RAMDISK, bam_root);
		(void) fclose(fp);
		return (1);
	}

	(void) fclose(fp);

	return (0);
}

static int
is_boot_archive(char *root)
{
	char path[PATH_MAX];
	struct stat sb;

	/*
	 * We can't create an archive without the create_ramdisk script
	 */
	(void) snprintf(path, sizeof (path), "%s/%s", root, CREATE_RAMDISK);
	if (stat(path, &sb) == -1) {
		if (bam_verbose)
			bam_print(FILE_MISS, path);
		return (0);
	}

	return (1);
}

/*
 * Need to call this for anything that operates on the GRUB menu
 */
int
is_grub(const char *root)
{
	char path[PATH_MAX];
	struct stat sb;

	/*
	 * GRUB_DIR is required to modify the menu
	 */
	(void) snprintf(path, sizeof (path), "%s%s", root, GRUB_DIR);
	if (stat(path, &sb) == -1) {
		if (bam_debug)
			bam_print(DIR_MISS, path);
		return (0);
	}

	return (1);
}

static int
is_readonly(char *root)
{
	struct statvfs vfs;

	/*
	 * Check for RDONLY filesystem
	 * When in doubt assume it is not readonly
	 */
	if (statvfs(root, &vfs) != 0) {
		if (bam_verbose)
			bam_error(STATVFS_FAIL, root, strerror(errno));
		return (0);
	}

	if (vfs.f_flag & ST_RDONLY) {
		return (1);
	}

	return (0);
}

static error_t
update_archive(char *root, char *opt)
{
	error_t ret;

	assert(root);
	assert(opt == NULL);

	/*
	 * root must belong to a boot archive based  OS,
	 */
	if (!is_boot_archive(root)) {
		/*
		 * Emit message only if not in context of update_all.
		 * If in update_all, emit only if verbose flag is set.
		 */
		if (!bam_update_all || bam_verbose)
			bam_print(NOT_GRUB_BOOT, root);
		return (BAM_SUCCESS);
	}

	/*
	 * If smf check is requested when / is writable (can happen
	 * on first reboot following an upgrade because service
	 * dependency is messed up), skip the check.
	 */
	if (bam_smf_check && !bam_root_readonly)
		return (BAM_SUCCESS);

	/*
	 * root must be writable. This check applies to alternate
	 * root (-R option); bam_root_readonly applies to '/' only.
	 * Note: statvfs() does not always report the truth
	 */
	if (!bam_smf_check && !bam_check && is_readonly(root)) {
		if (bam_verbose)
			bam_print(RDONLY_FS, root);
		return (BAM_SUCCESS);
	}

	/*
	 * Don't generate archive on ramdisk
	 */
	if (is_ramdisk(root)) {
		if (bam_verbose)
			bam_print(SKIP_RAMDISK);
		return (BAM_SUCCESS);
	}

	/*
	 * Now check if updated is really needed
	 */
	ret = update_required(root);

	/*
	 * The check command (-n) is *not* a dry run
	 * It only checks if the archive is in sync.
	 */
	if (bam_check) {
		bam_exit((ret != 0) ? 1 : 0);
	}

	if (ret == 1) {
		/* create the ramdisk */
		ret = create_ramdisk(root);
	}

	/* if the archive is updated, save the new stat data */
	if (ret == 0 && walk_arg.new_nvlp != NULL) {
		savenew(root);
	}

	clear_walk_args();

	return (ret);
}

static void
update_fdisk(void)
{
	struct stat sb;
	char cmd[PATH_MAX];
	int ret1, ret2;

	assert(stat(GRUB_fdisk, &sb) == 0);
	assert(stat(GRUB_fdisk_target, &sb) == 0);

	(void) snprintf(cmd, sizeof (cmd), "/sbin/fdisk -F %s `/bin/cat %s`",
	    GRUB_fdisk, GRUB_fdisk_target);

	bam_print(UPDATING_FDISK);
	if (exec_cmd(cmd, NULL) != 0) {
		bam_error(FDISK_UPDATE_FAILED);
	}

	/*
	 * We are done, remove the files.
	 */
	ret1 = unlink(GRUB_fdisk);
	ret2 = unlink(GRUB_fdisk_target);
	if (ret1 != 0 || ret2 != 0) {
		bam_error(FILE_REMOVE_FAILED, GRUB_fdisk, GRUB_fdisk_target);
	}
}

static void
restore_grub_slice(void)
{
	struct stat sb;
	char *mntpt, *physlice;
	int mnted;	/* set if we did a mount */
	char menupath[PATH_MAX], cmd[PATH_MAX];

	if (stat(GRUB_slice, &sb) != 0) {
		bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno));
		return;
	}

	/*
	 * If we are doing an luactivate, don't attempt to restore GRUB or else
	 * we may not be able to get to DCA boot environments. Let luactivate
	 * handle GRUB/DCA installation
	 */
	if (stat(LU_ACTIVATE_FILE, &sb) == 0) {
		return;
	}

	mnted = 0;
	physlice = NULL;
	mntpt = mount_grub_slice(&mnted, &physlice, NULL, NULL);
	if (mntpt == NULL) {
		bam_error(CANNOT_RESTORE_GRUB_SLICE);
		return;
	}

	(void) snprintf(menupath, sizeof (menupath), "%s%s", mntpt, GRUB_MENU);
	if (stat(menupath, &sb) == 0) {
		umount_grub_slice(mnted, mntpt, physlice, NULL, NULL);
		return;
	}

	/*
	 * The menu is missing - we need to do a restore
	 */
	bam_print(RESTORING_GRUB);

	(void) snprintf(cmd, sizeof (cmd), "%s %s %s %s",
	    INSTALLGRUB, STAGE1, STAGE2, physlice);

	if (exec_cmd(cmd, NULL) != 0) {
		bam_error(RESTORE_GRUB_FAILED);
		umount_grub_slice(mnted, mntpt, physlice, NULL, NULL);
		return;
	}

	if (stat(GRUB_backup_menu, &sb) != 0) {
		bam_error(MISSING_BACKUP_MENU,
		    GRUB_backup_menu, strerror(errno));
		umount_grub_slice(mnted, mntpt, physlice, NULL, NULL);
		return;
	}

	(void) snprintf(cmd, sizeof (cmd), "/bin/cp %s %s",
	    GRUB_backup_menu, menupath);

	if (exec_cmd(cmd, NULL) != 0) {
		bam_error(RESTORE_MENU_FAILED, menupath);
		umount_grub_slice(mnted, mntpt, physlice, NULL, NULL);
		return;
	}

	/* Success */
	umount_grub_slice(mnted, mntpt, physlice, NULL, NULL);
}

static error_t
update_all(char *root, char *opt)
{
	struct extmnttab mnt;
	struct stat sb;
	FILE *fp;
	char multibt[PATH_MAX];
	char creatram[PATH_MAX];
	error_t ret = BAM_SUCCESS;
	int ret1, ret2;

	assert(root);
	assert(opt == NULL);

	if (bam_rootlen != 1 || *root != '/') {
		elide_trailing_slash(root, multibt, sizeof (multibt));
		bam_error(ALT_ROOT_INVALID, multibt);
		return (BAM_ERROR);
	}

	/*
	 * Check to see if we are in the midst of safemode patching
	 * If so skip building the archive for /. Instead build it
	 * against the latest bits obtained by creating a fresh lofs
	 * mount of root.
	 */
	if (stat(LOFS_PATCH_FILE, &sb) == 0)  {
		if (mkdir(LOFS_PATCH_MNT, 0755) == -1 &&
		    errno != EEXIST) {
			bam_error(MKDIR_FAILED, "%s", LOFS_PATCH_MNT,
			    strerror(errno));
			ret = BAM_ERROR;
			goto out;
		}
		(void) snprintf(multibt, sizeof (multibt),
		    "/sbin/mount -F lofs -o nosub /  %s", LOFS_PATCH_MNT);
		if (exec_cmd(multibt, NULL) != 0) {
			bam_error(MOUNT_FAILED, LOFS_PATCH_MNT, "lofs");
			ret = BAM_ERROR;
		}
		if (ret != BAM_ERROR) {
			(void) snprintf(rootbuf, sizeof (rootbuf), "%s/",
			    LOFS_PATCH_MNT);
			bam_rootlen = strlen(rootbuf);
			if (update_archive(rootbuf, opt) != BAM_SUCCESS)
				ret = BAM_ERROR;
			/*
			 * unmount the lofs mount since there could be
			 * multiple invocations of bootadm -a update_all
			 */
			(void) snprintf(multibt, sizeof (multibt),
			    "/sbin/umount %s", LOFS_PATCH_MNT);
			if (exec_cmd(multibt, NULL) != 0) {
				bam_error(UMOUNT_FAILED, LOFS_PATCH_MNT);
				ret = BAM_ERROR;
			}
		}
	} else {
		/*
		 * First update archive for current root
		 */
		if (update_archive(root, opt) != BAM_SUCCESS)
			ret = BAM_ERROR;
	}

	if (ret == BAM_ERROR)
		goto out;

	/*
	 * Now walk the mount table, performing archive update
	 * for all mounted Newboot root filesystems
	 */
	fp = fopen(MNTTAB, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, MNTTAB, strerror(errno));
		ret = BAM_ERROR;
		goto out;
	}

	resetmnttab(fp);

	while (getextmntent(fp, &mnt, sizeof (mnt)) == 0) {
		if (mnt.mnt_special == NULL)
			continue;
		if (strncmp(mnt.mnt_special, "/dev/", strlen("/dev/")) != 0)
			continue;
		if (strcmp(mnt.mnt_mountp, "/") == 0)
			continue;

		(void) snprintf(creatram, sizeof (creatram), "%s/%s",
		    mnt.mnt_mountp, CREATE_RAMDISK);

		if (stat(creatram, &sb) == -1)
			continue;

		/*
		 * We put a trailing slash to be consistent with root = "/"
		 * case, such that we don't have to print // in some cases.
		 */
		(void) snprintf(rootbuf, sizeof (rootbuf), "%s/",
		    mnt.mnt_mountp);
		bam_rootlen = strlen(rootbuf);

		/*
		 * It's possible that other mounts may be an alternate boot
		 * architecture, so check it again.
		 */
		if ((dboot_or_multiboot(rootbuf) != BAM_SUCCESS) ||
		    (update_archive(rootbuf, opt) != BAM_SUCCESS))
			ret = BAM_ERROR;
	}

	(void) fclose(fp);

out:
	if (stat(GRUB_slice, &sb) == 0) {
		restore_grub_slice();
	}

	/*
	 * Update fdisk table as we go down. Updating it when
	 * the system is running will confuse biosdev.
	 */
	ret1 = stat(GRUB_fdisk, &sb);
	ret2 = stat(GRUB_fdisk_target, &sb);
	if ((ret1 == 0) && (ret2 == 0)) {
		update_fdisk();
	} else if ((ret1 == 0) ^ (ret2 == 0)) {
		/*
		 * It is an error for one file to be
		 * present and the other absent.
		 * It is normal for both files to be
		 * absent - it indicates that no fdisk
		 * update is required.
		 */
		bam_error(MISSING_FDISK_FILE,
		    ret1 ? GRUB_fdisk : GRUB_fdisk_target);
		ret = BAM_ERROR;
	}

	return (ret);
}

static void
append_line(menu_t *mp, line_t *lp)
{
	if (mp->start == NULL) {
		mp->start = lp;
	} else {
		mp->end->next = lp;
		lp->prev = mp->end;
	}
	mp->end = lp;
}

static void
unlink_line(menu_t *mp, line_t *lp)
{
	/* unlink from list */
	if (lp->prev)
		lp->prev->next = lp->next;
	else
		mp->start = lp->next;
	if (lp->next)
		lp->next->prev = lp->prev;
	else
		mp->end = lp->prev;
}

static entry_t *
boot_entry_new(menu_t *mp, line_t *start, line_t *end)
{
	entry_t *ent, *prev;

	ent = s_calloc(1, sizeof (entry_t));
	ent->start = start;
	ent->end = end;

	if (mp->entries == NULL) {
		mp->entries = ent;
		return (ent);
	}

	prev = mp->entries;
	while (prev->next)
		prev = prev-> next;
	prev->next = ent;
	ent->prev = prev;
	return (ent);
}

static void
boot_entry_addline(entry_t *ent, line_t *lp)
{
	if (ent)
		ent->end = lp;
}

/*
 * Check whether cmd matches the one indexed by which, and whether arg matches
 * str.  which must be either KERNEL_CMD or MODULE_CMD, and a match to the
 * respective *_DOLLAR_CMD is also acceptable.  The arg is searched using
 * strstr(), so it can be a partial match.
 */
static int
check_cmd(const char *cmd, const int which, const char *arg, const char *str)
{
	if ((strcmp(cmd, menu_cmds[which]) != 0) &&
	    (strcmp(cmd, menu_cmds[which + 1]) != 0)) {
		return (0);
	}
	return (strstr(arg, str) != NULL);
}

/*
 * A line in menu.lst looks like
 * [ ]*<cmd>[ \t=]*<arg>*
 */
static void
line_parser(menu_t *mp, char *str, int *lineNum, int *entryNum)
{
	/*
	 * save state across calls. This is so that
	 * header gets the right entry# after title has
	 * been processed
	 */
	static line_t *prev = NULL;
	static entry_t *curr_ent = NULL;
	static int in_liveupgrade = 0;

	line_t	*lp;
	char *cmd, *sep, *arg;
	char save, *cp, *line;
	menu_flag_t flag = BAM_INVALID;

	if (str == NULL) {
		return;
	}

	/*
	 * First save a copy of the entire line.
	 * We use this later to set the line field.
	 */
	line = s_strdup(str);

	/* Eat up leading whitespace */
	while (*str == ' ' || *str == '\t')
		str++;

	if (*str == '#') {		/* comment */
		cmd = s_strdup("#");
		sep = NULL;
		arg = s_strdup(str + 1);
		flag = BAM_COMMENT;
		if (strstr(arg, BAM_LU_HDR) != NULL) {
			in_liveupgrade = 1;
		} else if (strstr(arg, BAM_LU_FTR) != NULL) {
			in_liveupgrade = 0;
		}
	} else if (*str == '\0') {	/* blank line */
		cmd = sep = arg = NULL;
		flag = BAM_EMPTY;
	} else {
		/*
		 * '=' is not a documented separator in grub syntax.
		 * However various development bits use '=' as a
		 * separator. In addition, external users also
		 * use = as a separator. So we will allow that usage.
		 */
		cp = str;
		while (*str != ' ' && *str != '\t' && *str != '=') {
			if (*str == '\0') {
				cmd = s_strdup(cp);
				sep = arg = NULL;
				break;
			}
			str++;
		}

		if (*str != '\0') {
			save = *str;
			*str = '\0';
			cmd = s_strdup(cp);
			*str = save;

			str++;
			save = *str;
			*str = '\0';
			sep = s_strdup(str - 1);
			*str = save;

			while (*str == ' ' || *str == '\t')
				str++;
			if (*str == '\0')
				arg = NULL;
			else
				arg = s_strdup(str);
		}
	}

	lp = s_calloc(1, sizeof (line_t));

	lp->cmd = cmd;
	lp->sep = sep;
	lp->arg = arg;
	lp->line = line;
	lp->lineNum = ++(*lineNum);
	if (cmd && strcmp(cmd, menu_cmds[TITLE_CMD]) == 0) {
		lp->entryNum = ++(*entryNum);
		lp->flags = BAM_TITLE;
		if (prev && prev->flags == BAM_COMMENT &&
		    prev->arg && strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) {
			prev->entryNum = lp->entryNum;
			curr_ent = boot_entry_new(mp, prev, lp);
			curr_ent->flags = BAM_ENTRY_BOOTADM;
		} else {
			curr_ent = boot_entry_new(mp, lp, lp);
			if (in_liveupgrade) {
				curr_ent->flags = BAM_ENTRY_LU;
			}
		}
		curr_ent->entryNum = *entryNum;
	} else if (flag != BAM_INVALID) {
		/*
		 * For header comments, the entry# is "fixed up"
		 * by the subsequent title
		 */
		lp->entryNum = *entryNum;
		lp->flags = flag;
	} else {
		lp->entryNum = *entryNum;

		if (*entryNum == ENTRY_INIT) {
			lp->flags = BAM_GLOBAL;
		} else {
			lp->flags = BAM_ENTRY;

			if (cmd && arg) {
				/*
				 * We only compare for the length of "module"
				 * so that "module$" will also match.
				 */
				if (check_cmd(cmd, MODULE_CMD, arg, MINIROOT))
					curr_ent->flags |= BAM_ENTRY_MINIROOT;
				else if (check_cmd(cmd, KERNEL_CMD, arg,
				    "xen.gz"))
					curr_ent->flags |= BAM_ENTRY_HV;
				else if (strcmp(cmd, menu_cmds[ROOT_CMD]) == 0)
					curr_ent->flags |= BAM_ENTRY_ROOT;
				else if (strcmp(cmd,
				    menu_cmds[CHAINLOADER_CMD]) == 0)
					curr_ent->flags |=
					    BAM_ENTRY_CHAINLOADER;
			}
		}
	}

	/* record default, old default, and entry line ranges */
	if (lp->flags == BAM_GLOBAL &&
	    strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0) {
		mp->curdefault = lp;
	} else if (lp->flags == BAM_COMMENT &&
	    strncmp(lp->arg, BAM_OLDDEF, strlen(BAM_OLDDEF)) == 0) {
		mp->olddefault = lp;
	} else if (lp->flags == BAM_COMMENT &&
	    strncmp(lp->arg, BAM_OLD_RC_DEF, strlen(BAM_OLD_RC_DEF)) == 0) {
		mp->old_rc_default = lp;
	} else if (lp->flags == BAM_ENTRY ||
	    (lp->flags == BAM_COMMENT &&
	    strcmp(lp->arg, BAM_BOOTADM_FTR) == 0)) {
		boot_entry_addline(curr_ent, lp);
	}
	append_line(mp, lp);

	prev = lp;
}

static void
update_numbering(menu_t *mp)
{
	int lineNum;
	int entryNum;
	int old_default_value;
	line_t *lp, *prev, *default_lp, *default_entry;
	char buf[PATH_MAX];

	if (mp->start == NULL) {
		return;
	}

	lineNum = LINE_INIT;
	entryNum = ENTRY_INIT;
	old_default_value = ENTRY_INIT;
	lp = default_lp = default_entry = NULL;

	prev = NULL;
	for (lp = mp->start; lp; prev = lp, lp = lp->next) {
		lp->lineNum = ++lineNum;

		/*
		 * Get the value of the default command
		 */
		if (lp->entryNum == ENTRY_INIT && lp->cmd &&
		    strcmp(lp->cmd, menu_cmds[DEFAULT_CMD]) == 0 &&
		    lp->arg) {
			old_default_value = atoi(lp->arg);
			default_lp = lp;
		}

		/*
		 * If not boot entry, nothing else to fix for this
		 * entry
		 */
		if (lp->entryNum == ENTRY_INIT)
			continue;

		/*
		 * Record the position of the default entry.
		 * The following works because global
		 * commands like default and timeout should precede
		 * actual boot entries, so old_default_value
		 * is already known (or default cmd is missing).
		 */
		if (default_entry == NULL &&
		    old_default_value != ENTRY_INIT &&
		    lp->entryNum == old_default_value) {
			default_entry = lp;
		}

		/*
		 * Now fixup the entry number
		 */
		if (lp->cmd && strcmp(lp->cmd, menu_cmds[TITLE_CMD]) == 0) {
			lp->entryNum = ++entryNum;
			/* fixup the bootadm header */
			if (prev && prev->flags == BAM_COMMENT &&
			    prev->arg &&
			    strcmp(prev->arg, BAM_BOOTADM_HDR) == 0) {
				prev->entryNum = lp->entryNum;
			}
		} else {
			lp->entryNum = entryNum;
		}
	}

	/*
	 * No default command in menu, simply return
	 */
	if (default_lp == NULL) {
		return;
	}

	free(default_lp->arg);
	free(default_lp->line);

	if (default_entry == NULL) {
		default_lp->arg = s_strdup("0");
	} else {
		(void) snprintf(buf, sizeof (buf), "%d",
		    default_entry->entryNum);
		default_lp->arg = s_strdup(buf);
	}

	/*
	 * The following is required since only the line field gets
	 * written back to menu.lst
	 */
	(void) snprintf(buf, sizeof (buf), "%s%s%s",
	    menu_cmds[DEFAULT_CMD], menu_cmds[SEP_CMD], default_lp->arg);
	default_lp->line = s_strdup(buf);
}


static menu_t *
menu_read(char *menu_path)
{
	FILE *fp;
	char buf[BAM_MAXLINE], *cp;
	menu_t *mp;
	int line, entry, len, n;

	mp = s_calloc(1, sizeof (menu_t));

	fp = fopen(menu_path, "r");
	if (fp == NULL) { /* Let the caller handle this error */
		return (mp);
	}


	/* Note: GRUB boot entry number starts with 0 */
	line = LINE_INIT;
	entry = ENTRY_INIT;
	cp = buf;
	len = sizeof (buf);
	while (s_fgets(cp, len, fp) != NULL) {
		n = strlen(cp);
		if (cp[n - 1] == '\\') {
			len -= n - 1;
			assert(len >= 2);
			cp += n - 1;
			continue;
		}
		line_parser(mp, buf, &line, &entry);
		cp = buf;
		len = sizeof (buf);
	}

	if (fclose(fp) == EOF) {
		bam_error(CLOSE_FAIL, menu_path, strerror(errno));
	}

	return (mp);
}

static error_t
selector(menu_t *mp, char *opt, int *entry, char **title)
{
	char *eq;
	char *opt_dup;
	int entryNum;

	assert(mp);
	assert(mp->start);
	assert(opt);

	opt_dup = s_strdup(opt);

	if (entry)
		*entry = ENTRY_INIT;
	if (title)
		*title = NULL;

	eq = strchr(opt_dup, '=');
	if (eq == NULL) {
		bam_error(INVALID_OPT, opt);
		free(opt_dup);
		return (BAM_ERROR);
	}

	*eq = '\0';
	if (entry && strcmp(opt_dup, OPT_ENTRY_NUM) == 0) {
		assert(mp->end);
		entryNum = s_strtol(eq + 1);
		if (entryNum < 0 || entryNum > mp->end->entryNum) {
			bam_error(INVALID_ENTRY, eq + 1);
			free(opt_dup);
			return (BAM_ERROR);
		}
		*entry = entryNum;
	} else if (title && strcmp(opt_dup, menu_cmds[TITLE_CMD]) == 0) {
		*title = opt + (eq - opt_dup) + 1;
	} else {
		bam_error(INVALID_OPT, opt);
		free(opt_dup);
		return (BAM_ERROR);
	}

	free(opt_dup);
	return (BAM_SUCCESS);
}

/*
 * If invoked with no titles/entries (opt == NULL)
 * only title lines in file are printed.
 *
 * If invoked with a title or entry #, all
 * lines in *every* matching entry are listed
 */
static error_t
list_entry(menu_t *mp, char *menu_path, char *opt)
{
	line_t *lp;
	int entry = ENTRY_INIT;
	int found;
	char *title = NULL;

	assert(mp);
	assert(menu_path);

	if (mp->start == NULL) {
		bam_error(NO_MENU, menu_path);
		return (BAM_ERROR);
	}

	if (opt != NULL) {
		if (selector(mp, opt, &entry, &title) != BAM_SUCCESS) {
			return (BAM_ERROR);
		}
		assert((entry != ENTRY_INIT) ^ (title != NULL));
	} else {
		(void) read_globals(mp, menu_path, menu_cmds[DEFAULT_CMD], 0);
		(void) read_globals(mp, menu_path, menu_cmds[TIMEOUT_CMD], 0);
	}

	found = 0;
	for (lp = mp->start; lp; lp = lp->next) {
		if (lp->flags == BAM_COMMENT || lp->flags == BAM_EMPTY)
			continue;
		if (opt == NULL && lp->flags == BAM_TITLE) {
			bam_print(PRINT_TITLE, lp->entryNum,
			    lp->arg);
			found = 1;
			continue;
		}
		if (entry != ENTRY_INIT && lp->entryNum == entry) {
			bam_print(PRINT, lp->line);
			found = 1;
			continue;
		}

		/*
		 * We set the entry value here so that all lines
		 * in entry get printed. If we subsequently match
		 * title in other entries, all lines in those
		 * entries get printed as well.
		 */
		if (title && lp->flags == BAM_TITLE && lp->arg &&
		    strncmp(title, lp->arg, strlen(title)) == 0) {
			bam_print(PRINT, lp->line);
			entry = lp->entryNum;
			found = 1;
			continue;
		}
	}

	if (!found) {
		bam_error(NO_MATCH_ENTRY);
		return (BAM_ERROR);
	}

	return (BAM_SUCCESS);
}

int
add_boot_entry(menu_t *mp,
	char *title,
	char *root,
	char *kernel,
	char *mod_kernel,
	char *module)
{
	int lineNum, entryNum;
	char linebuf[BAM_MAXLINE];
	menu_cmd_t k_cmd, m_cmd;

	assert(mp);

	if (title == NULL) {
		title = "Solaris";	/* default to Solaris */
	}
	if (kernel == NULL) {
		bam_error(SUBOPT_MISS, menu_cmds[KERNEL_CMD]);
		return (BAM_ERROR);
	}
	if (module == NULL) {
		if (bam_direct != BAM_DIRECT_DBOOT) {
			bam_error(SUBOPT_MISS, menu_cmds[MODULE_CMD]);
			return (BAM_ERROR);
		}

		/* Figure the commands out from the kernel line */
		if (strstr(kernel, "$ISADIR") != NULL) {
			module = DIRECT_BOOT_ARCHIVE;
			k_cmd = KERNEL_DOLLAR_CMD;
			m_cmd = MODULE_DOLLAR_CMD;
		} else if (strstr(kernel, "amd64") != NULL) {
			module = DIRECT_BOOT_ARCHIVE_64;
			k_cmd = KERNEL_CMD;
			m_cmd = MODULE_CMD;
		} else {
			module = DIRECT_BOOT_ARCHIVE_32;
			k_cmd = KERNEL_CMD;
			m_cmd = MODULE_CMD;
		}
	} else if ((bam_direct == BAM_DIRECT_DBOOT) &&
	    (strstr(kernel, "$ISADIR") != NULL)) {
		/*
		 * If it's a non-failsafe dboot kernel, use the "kernel$"
		 * command.  Otherwise, use "kernel".
		 */
		k_cmd = KERNEL_DOLLAR_CMD;
		m_cmd = MODULE_DOLLAR_CMD;
	} else {
		k_cmd = KERNEL_CMD;
		m_cmd = MODULE_CMD;
	}

	if (mp->start) {
		lineNum = mp->end->lineNum;
		entryNum = mp->end->entryNum;
	} else {
		lineNum = LINE_INIT;
		entryNum = ENTRY_INIT;
	}

	/*
	 * No separator for comment (HDR/FTR) commands
	 * The syntax for comments is #<comment>
	 */
	(void) snprintf(linebuf, sizeof (linebuf), "%s%s",
	    menu_cmds[COMMENT_CMD], BAM_BOOTADM_HDR);
	line_parser(mp, linebuf, &lineNum, &entryNum);

	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
	    menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title);
	line_parser(mp, linebuf, &lineNum, &entryNum);

	if (root) {
		(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
		    menu_cmds[ROOT_CMD], menu_cmds[SEP_CMD], root);
		line_parser(mp, linebuf, &lineNum, &entryNum);
	}

	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
	    menu_cmds[k_cmd], menu_cmds[SEP_CMD], kernel);
	line_parser(mp, linebuf, &lineNum, &entryNum);

	if (mod_kernel != NULL) {
		(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
		    menu_cmds[m_cmd], menu_cmds[SEP_CMD], mod_kernel);
		line_parser(mp, linebuf, &lineNum, &entryNum);
	}

	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
	    menu_cmds[m_cmd], menu_cmds[SEP_CMD], module);
	line_parser(mp, linebuf, &lineNum, &entryNum);

	(void) snprintf(linebuf, sizeof (linebuf), "%s%s",
	    menu_cmds[COMMENT_CMD], BAM_BOOTADM_FTR);
	line_parser(mp, linebuf, &lineNum, &entryNum);

	return (entryNum);
}

static error_t
do_delete(menu_t *mp, int entryNum)
{
	line_t *lp, *freed;
	entry_t *ent, *tmp;
	int deleted;

	assert(entryNum != ENTRY_INIT);

	ent = mp->entries;
	while (ent) {
		lp = ent->start;
		/* check entry number and make sure it's a bootadm entry */
		if (lp->flags != BAM_COMMENT ||
		    strcmp(lp->arg, BAM_BOOTADM_HDR) != 0 ||
		    (entryNum != ALL_ENTRIES && lp->entryNum != entryNum)) {
			ent = ent->next;
			continue;
		}

		/* free the entry content */
		do {
			freed = lp;
			lp = lp->next;	/* prev stays the same */
			unlink_line(mp, freed);
			line_free(freed);
		} while (freed != ent->end);

		/* free the entry_t structure */
		tmp = ent;
		ent = ent->next;
		if (tmp->prev)
			tmp->prev->next = ent;
		else
			mp->entries = ent;
		if (ent)
			ent->prev = tmp->prev;
		deleted = 1;
	}

	if (!deleted && entryNum != ALL_ENTRIES) {
		bam_error(NO_BOOTADM_MATCH);
		return (BAM_ERROR);
	}

	/*
	 * Now that we have deleted an entry, update
	 * the entry numbering and the default cmd.
	 */
	update_numbering(mp);

	return (BAM_SUCCESS);
}

static error_t
delete_all_entries(menu_t *mp, char *menu_path, char *opt)
{
	assert(mp);
	assert(opt == NULL);

	if (mp->start == NULL) {
		bam_print(EMPTY_FILE, menu_path);
		return (BAM_SUCCESS);
	}

	if (do_delete(mp, ALL_ENTRIES) != BAM_SUCCESS) {
		return (BAM_ERROR);
	}

	return (BAM_WRITE);
}

static FILE *
open_diskmap(char *root)
{
	FILE *fp;
	char cmd[PATH_MAX];

	/* make sure we have a map file */
	fp = fopen(GRUBDISK_MAP, "r");
	if (fp == NULL) {
		(void) snprintf(cmd, sizeof (cmd),
		    "%s/%s > /dev/null", root, CREATE_DISKMAP);
		(void) system(cmd);
		fp = fopen(GRUBDISK_MAP, "r");
	}
	return (fp);
}

#define	SECTOR_SIZE	512

static int
get_partition(char *device)
{
	int i, fd, is_pcfs, partno = -1;
	struct mboot *mboot;
	char boot_sect[SECTOR_SIZE];
	char *wholedisk, *slice;

	/* form whole disk (p0) */
	slice = device + strlen(device) - 2;
	is_pcfs = (*slice != 's');
	if (!is_pcfs)
		*slice = '\0';
	wholedisk = s_calloc(1, strlen(device) + 3);
	(void) snprintf(wholedisk, strlen(device) + 3, "%sp0", device);
	if (!is_pcfs)
		*slice = 's';

	/* read boot sector */
	fd = open(wholedisk, O_RDONLY);
	free(wholedisk);
	if (fd == -1 || read(fd, boot_sect, SECTOR_SIZE) != SECTOR_SIZE) {
		return (partno);
	}
	(void) close(fd);

	/* parse fdisk table */
	mboot = (struct mboot *)((void *)boot_sect);
	for (i = 0; i < FD_NUMPART; i++) {
		struct ipart *part =
		    (struct ipart *)(uintptr_t)mboot->parts + i;
		if (is_pcfs) {	/* looking for solaris boot part */
			if (part->systid == 0xbe) {
				partno = i;
				break;
			}
		} else {	/* look for solaris partition, old and new */
			if (part->systid == SUNIXOS ||
			    part->systid == SUNIXOS2) {
				partno = i;
				break;
			}
		}
	}
	return (partno);
}

static char *
get_grubdisk(char *rootdev, FILE *fp, int on_bootdev)
{
	char *grubdisk;	/* (hd#,#,#) */
	char *slice;
	char *grubhd;
	int fdiskpart;
	int found = 0;
	char *devname, *ctdname = strstr(rootdev, "dsk/");
	char linebuf[PATH_MAX];

	if (ctdname == NULL)
		return (NULL);

	ctdname += strlen("dsk/");
	slice = strrchr(ctdname, 's');
	if (slice)
		*slice = '\0';

	rewind(fp);
	while (s_fgets(linebuf, sizeof (linebuf), fp) != NULL) {
		grubhd = strtok(linebuf, " \t\n");
		if (grubhd)
			devname = strtok(NULL, " \t\n");
		else
			devname = NULL;
		if (devname && strcmp(devname, ctdname) == 0) {
			found = 1;
			break;
		}
	}

	if (slice)
		*slice = 's';

	if (found == 0) {
		if (bam_verbose)
			bam_print(DISKMAP_FAIL_NONFATAL, rootdev);
		grubhd = "0";	/* assume disk 0 if can't match */
	}

	fdiskpart = get_partition(rootdev);
	if (fdiskpart == -1)
		return (NULL);

	grubdisk = s_calloc(1, 10);
	if (slice) {
		(void) snprintf(grubdisk, 10, "(hd%s,%d,%c)",
		    grubhd, fdiskpart, slice[1] + 'a' - '0');
	} else
		(void) snprintf(grubdisk, 10, "(hd%s,%d)",
		    grubhd, fdiskpart);

	/* if root not on bootdev, change GRUB disk to 0 */
	if (!on_bootdev)
		grubdisk[3] = '0';
	return (grubdisk);
}

static char *
get_title(char *rootdir)
{
	static char title[80];	/* from /etc/release */
	char *cp = NULL, release[PATH_MAX];
	FILE *fp;

	/* open the /etc/release file */
	(void) snprintf(release, sizeof (release), "%s/etc/release", rootdir);

	fp = fopen(release, "r");
	if (fp == NULL)
		return (NULL);

	while (s_fgets(title, sizeof (title), fp) != NULL) {
		cp = strstr(title, "Solaris");
		if (cp)
			break;
	}
	(void) fclose(fp);
	return (cp == NULL ? "Solaris" : cp);
}

char *
get_special(char *mountp)
{
	FILE *mntfp;
	struct mnttab mp = {0}, mpref = {0};

	mntfp = fopen(MNTTAB, "r");
	if (mntfp == NULL) {
		return (0);
	}

	if (*mountp == '\0')
		mpref.mnt_mountp = "/";
	else
		mpref.mnt_mountp = mountp;
	if (getmntany(mntfp, &mp, &mpref) != 0) {
		(void) fclose(mntfp);
		return (NULL);
	}
	(void) fclose(mntfp);

	return (s_strdup(mp.mnt_special));
}

char *
os_to_grubdisk(char *osdisk, int on_bootdev)
{
	FILE *fp;
	char *grubdisk;

	/* translate /dev/dsk name to grub disk name */
	fp = open_diskmap("");
	if (fp == NULL) {
		bam_error(DISKMAP_FAIL, osdisk);
		return (NULL);
	}
	grubdisk = get_grubdisk(osdisk, fp, on_bootdev);
	(void) fclose(fp);
	return (grubdisk);
}

/*
 * Check if root is on the boot device
 * Return 0 (false) on error
 */
static int
menu_on_bootdev(char *menu_root, FILE *fp)
{
	int ret;
	char *grubhd, *bootp, *special;

	special = get_special(menu_root);
	if (special == NULL)
		return (0);
	bootp = strstr(special, "p0:boot");
	if (bootp)
		*bootp = '\0';
	grubhd = get_grubdisk(special, fp, 1);
	free(special);

	if (grubhd == NULL)
		return (0);
	ret = grubhd[3] == '0';
	free(grubhd);
	return (ret);
}

/*
 * look for matching bootadm entry with specified parameters
 * Here are the rules (based on existing usage):
 * - If title is specified, match on title only
 * - Else, match on kernel, grubdisk and module.  Note that, if root_opt is
 *   non-zero, the absence of root line is considered a match.
 */
static entry_t *
find_boot_entry(menu_t *mp, char *title, char *kernel, char *root,
    char *module, int root_opt, int *entry_num)
{
	int i;
	line_t *lp;
	entry_t *ent;

	/* find matching entry */
	for (i = 0, ent = mp->entries; ent; i++, ent = ent->next) {
		lp = ent->start;

		/* first line of entry must be bootadm comment */
		lp = ent->start;
		if (lp->flags != BAM_COMMENT ||
		    strcmp(lp->arg, BAM_BOOTADM_HDR) != 0) {
			continue;
		}

		/* advance to title line */
		lp = lp->next;
		if (title) {
			if (lp->flags == BAM_TITLE && lp->arg &&
			    strcmp(lp->arg, title) == 0)
				break;
			continue;	/* check title only */
		}

		lp = lp->next;	/* advance to root line */
		if (lp == NULL) {
			continue;
		} else if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) {
			/* root command found, match grub disk */
			if (strcmp(lp->arg, root) != 0) {
				continue;
			}
			lp = lp->next;	/* advance to kernel line */
		} else {
			/* no root command, see if root is optional */
			if (root_opt == 0) {
				continue;
			}
		}

		if (lp == NULL || lp->next == NULL) {
			continue;
		}

		if (kernel &&
		    (!check_cmd(lp->cmd, KERNEL_CMD, lp->arg, kernel))) {
			continue;
		}

		/*
		 * Check for matching module entry (failsafe or normal).
		 * If it fails to match, we go around the loop again.
		 * For xpv entries, there are two module lines, so we
		 * do the check twice.
		 */
		lp = lp->next;	/* advance to module line */
		if (check_cmd(lp->cmd, MODULE_CMD, lp->arg, module) ||
		    (((lp = lp->next) != NULL) &&
		    check_cmd(lp->cmd, MODULE_CMD, lp->arg, module))) {
			/* match found */
			break;
		}
	}

	if (entry_num && ent) {
		*entry_num = i;
	}
	return (ent);
}

static int
update_boot_entry(menu_t *mp, char *title, char *root, char *kernel,
    char *mod_kernel, char *module, int root_opt)
{
	int i, change_kernel = 0;
	entry_t *ent;
	line_t *lp;
	char linebuf[BAM_MAXLINE];

	/* note: don't match on title, it's updated on upgrade */
	ent = find_boot_entry(mp, NULL, kernel, root, module, root_opt, &i);
	if ((ent == NULL) && (bam_direct == BAM_DIRECT_DBOOT)) {
		/*
		 * We may be upgrading a kernel from multiboot to
		 * directboot.  Look for a multiboot entry.
		 */
		ent = find_boot_entry(mp, NULL, "multiboot", root,
		    MULTI_BOOT_ARCHIVE, root_opt, NULL);
		if (ent != NULL) {
			change_kernel = 1;
		}
	}
	if (ent == NULL)
		return (add_boot_entry(mp, title, root_opt ? NULL : root,
		    kernel, mod_kernel, module));

	/* replace title of exiting entry and delete root line */
	lp = ent->start;
	lp = lp->next;	/* title line */
	(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
	    menu_cmds[TITLE_CMD], menu_cmds[SEP_CMD], title);
	free(lp->arg);
	free(lp->line);
	lp->arg = s_strdup(title);
	lp->line = s_strdup(linebuf);

	lp = lp->next;	/* root line */
	if (strcmp(lp->cmd, menu_cmds[ROOT_CMD]) == 0) {
		if (root_opt) {		/* root line not needed */
			line_t *tmp = lp;
			lp = lp->next;
			unlink_line(mp, tmp);
			line_free(tmp);
		} else
			lp = lp->next;
	}

	if (change_kernel) {
		/*
		 * We're upgrading from multiboot to directboot.
		 */
		if (strcmp(lp->cmd, menu_cmds[KERNEL_CMD]) == 0) {
			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
			    menu_cmds[KERNEL_DOLLAR_CMD], menu_cmds[SEP_CMD],
			    kernel);
			free(lp->arg);
			free(lp->line);
			lp->arg = s_strdup(kernel);
			lp->line = s_strdup(linebuf);
			lp = lp->next;
		}
		if (strcmp(lp->cmd, menu_cmds[MODULE_CMD]) == 0) {
			(void) snprintf(linebuf, sizeof (linebuf), "%s%s%s",
			    menu_cmds[MODULE_DOLLAR_CMD], menu_cmds[SEP_CMD],
			    module);
			free(lp->arg);
			free(lp->line);
			lp->arg = s_strdup(module);
			lp->line = s_strdup(linebuf);
			lp = lp->next;
		}
	}
	return (i);
}

/*ARGSUSED*/
static error_t
update_entry(menu_t *mp, char *menu_root, char *opt)
{
	FILE *fp;
	int entry;
	char *grubdisk, *title, *osdev, *osroot, *failsafe_kernel = NULL;
	struct stat sbuf;
	char failsafe[256];

	assert(mp);
	assert(opt);

	osdev = strtok(opt, ",");
	osroot = strtok(NULL, ",");
	if (osroot == NULL)
		osroot = menu_root;
	title = get_title(osroot);

	/* translate /dev/dsk name to grub disk name */
	fp = open_diskmap(osroot);
	if (fp == NULL) {
		bam_error(DISKMAP_FAIL, osdev);
		return (BAM_ERROR);
	}
	grubdisk = get_grubdisk(osdev, fp, menu_on_bootdev(menu_root, fp));
	(void) fclose(fp);
	if (grubdisk == NULL) {
		bam_error(DISKMAP_FAIL, osdev);
		return (BAM_ERROR);
	}

	/* add the entry for normal Solaris */
	if (bam_direct == BAM_DIRECT_DBOOT) {
		entry = update_boot_entry(mp, title, grubdisk,
		    DIRECT_BOOT_KERNEL, NULL, DIRECT_BOOT_ARCHIVE,
		    osroot == menu_root);
		if ((entry != BAM_ERROR) && (bam_is_hv == BAM_HV_PRESENT)) {
			(void) update_boot_entry(mp, NEW_HV_ENTRY, grubdisk,
			    XEN_MENU, KERNEL_MODULE_LINE, DIRECT_BOOT_ARCHIVE,
			    osroot == menu_root);
		}
	} else {
		entry = update_boot_entry(mp, title, grubdisk, MULTI_BOOT,
		    NULL, MULTI_BOOT_ARCHIVE, osroot == menu_root);
	}

	/*
	 * Add the entry for failsafe archive.  On a bfu'd system, the
	 * failsafe may be different than the installed kernel.
	 */
	(void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot, MINIROOT);
	if (stat(failsafe, &sbuf) == 0) {

		/* Figure out where the kernel line should point */
		(void) snprintf(failsafe, sizeof (failsafe), "%s%s", osroot,
		    DIRECT_BOOT_FAILSAFE_KERNEL);
		if (stat(failsafe, &sbuf) == 0) {
			failsafe_kernel = DIRECT_BOOT_FAILSAFE_LINE;
		} else {
			(void) snprintf(failsafe, sizeof (failsafe), "%s%s",
			    osroot, MULTI_BOOT_FAILSAFE);
			if (stat(failsafe, &sbuf) == 0) {
				failsafe_kernel = MULTI_BOOT_FAILSAFE_LINE;
			}
		}
		if (failsafe_kernel != NULL) {
			(void) update_boot_entry(mp, FAILSAFE_TITLE, grubdisk,
			    failsafe_kernel, NULL, MINIROOT,
			    osroot == menu_root);
		}
	}
	free(grubdisk);

	if (entry == BAM_ERROR) {
		return (BAM_ERROR);
	}
	(void) set_global(mp, menu_cmds[DEFAULT_CMD], entry);
	return (BAM_WRITE);
}

static char *
read_grub_root(void)
{
	FILE *fp;
	struct stat sb;
	char buf[BAM_MAXLINE];
	char *rootstr;

	if (stat(GRUB_slice, &sb) != 0) {
		bam_error(MISSING_SLICE_FILE, GRUB_slice, strerror(errno));
		return (NULL);
	}

	if (stat(GRUB_root, &sb) != 0) {
		bam_error(MISSING_ROOT_FILE, GRUB_root, strerror(errno));
		return (NULL);
	}

	fp = fopen(GRUB_root, "r");
	if (fp == NULL) {
		bam_error(OPEN_FAIL, GRUB_root, strerror(errno));
		return (NULL);
	}

	if (s_fgets(buf, sizeof (buf), fp) == NULL) {
		bam_error(EMPTY_FILE, GRUB_root, strerror(errno));
		(void) fclose(fp);
		return (NULL);
	}

	/*
	 * Copy buf here as check below may trash the buffer
	 */
	rootstr = s_strdup(buf);

	if (s_fgets(buf, sizeof (buf), fp) != NULL) {
		bam_error(BAD_ROOT_FILE, GRUB_root);
		free(rootstr);
		rootstr = NULL;
	}

	(void) fclose(fp);

	return (rootstr);
}

static void
save_default_entry(menu_t *mp, const char *which)
{
	int lineNum, entryNum;
	int entry = 0;	/* default is 0 */
	char linebuf[BAM_MAXLINE];
	line_t *lp = mp->curdefault;

	if (mp->start) {
		lineNum = mp->end->lineNum;
		entryNum = mp->end->entryNum;
	} else {
		lineNum = LINE_INIT;
		entryNum = ENTRY_INIT;
	}

	if (lp)
		entry = s_strtol(lp->arg);

	(void) snprintf(linebuf, sizeof (linebuf), "#%s%d", which, entry);
	line_parser(mp, linebuf, &lineNum, &entryNum);
}

static void
restore_default_entry(menu_t *mp, const char *which, line_t *lp)
{
	int entry;
	char *str;

	if (lp == NULL)
		return;		/* nothing to restore */

	str = lp->arg + strlen(which);
	entry = s_strtol(str);
	(void) set_global(mp, menu_cmds[DEFAULT_CMD], entry);

	/* delete saved old default line */
	unlink_line(mp, lp);
	line_free(lp);
}

/*
 * This function is for supporting reboot with args.
 * The opt value can be:
 * NULL		delete temp entry, if present
 * entry=#	switches default entry to 1
 * else		treated as boot-args and setup a temperary menu entry
 *		and make it the default
 */
#define	REBOOT_TITLE	"Solaris_reboot_transient"

/*ARGSUSED*/
static error_t
update_temp(menu_t *mp, char *menupath, char *opt)
{
	int entry;
	char *grubdisk, *rootdev, *path, *opt_ptr;
	char kernbuf[BUFSIZ];
	char args_buf[BUFSIZ];
	struct stat sb;

	assert(mp);

	/* If no option, delete exiting reboot menu entry */
	if (opt == NULL) {
		entry_t *ent = find_boot_entry(mp, REBOOT_TITLE, NULL, NULL,
		    NULL, 0, &entry);
		if (ent == NULL)	/* not found is ok */
			return (BAM_SUCCESS);
		(void) do_delete(mp, entry);
		restore_default_entry(mp, BAM_OLDDEF, mp->olddefault);
		mp->olddefault = NULL;
		return (BAM_WRITE);
	}

	/* if entry= is specified, set the default entry */
	if (strncmp(opt, "entry=", strlen("entry=")) == 0 &&
	    selector(mp, opt, &entry, NULL) == BAM_SUCCESS) {
		/* this is entry=# option */
		return (set_global(mp, menu_cmds[DEFAULT_CMD], entry));
	}

	/*
	 * add a new menu entry base on opt and make it the default
	 */
	grubdisk = NULL;
	if (stat(GRUB_slice, &sb) != 0) {
		/*
		 * 1. First get root disk name from mnttab
		 * 2. Translate disk name to grub name
		 * 3. Add the new menu entry
		 */
		rootdev = get_special("/");
		if (rootdev) {
			grubdisk = os_to_grubdisk(rootdev, 1);
			free(rootdev);
		}
	} else {
		/*
		 * This is an LU BE. The GRUB_root file
		 * contains entry for GRUB's "root" cmd.
		 */
		grubdisk = read_grub_root();
	}
	if (grubdisk == NULL) {
		bam_error(REBOOT_WITH_ARGS_FAILED);
		return (BAM_ERROR);
	}

	/* add an entry for Solaris reboot */
	if (bam_direct == BAM_DIRECT_DBOOT) {
		if (opt[0] == '-') {
			/* It's an option - first see if boot-file is set */
			if (set_kernel(mp, KERNEL_CMD, NULL, kernbuf, BUFSIZ)
			    != BAM_SUCCESS)
				return (BAM_ERROR);
			if (kernbuf[0] == '\0')
				(void) strncpy(kernbuf, DIRECT_BOOT_KERNEL,
				    BUFSIZ);
			(void) strlcat(kernbuf, " ", BUFSIZ);
			(void) strlcat(kernbuf, opt, BUFSIZ);
		} else if (opt[0] == '/') {
			/* It's a full path, so write it out. */
			(void) strlcpy(kernbuf, opt, BUFSIZ);

			/*
			 * If someone runs:
			 *
			 *	# eeprom boot-args='-kd'
			 *	# reboot /platform/i86pc/kernel/unix
			 *
			 * we want to use the boot-args as part of the boot
			 * line.  On the other hand, if someone runs:
			 *
			 *	# reboot "/platform/i86pc/kernel/unix -kd"
			 *
			 * we don't need to mess with boot-args.  If there's
			 * no space in the options string, assume we're in the
			 * first case.
			 */
			if (strchr(opt, ' ') == NULL) {
				if (set_kernel(mp, ARGS_CMD, NULL, args_buf,
				    BUFSIZ) != BAM_SUCCESS)
					return (BAM_ERROR);

				if (args_buf[0] != '\0') {
					(void) strlcat(kernbuf, " ", BUFSIZ);
					(void) strlcat(kernbuf, args_buf,
					    BUFSIZ);
				}
			}
		} else {
			/*
			 * It may be a partial path, or it may be a partial
			 * path followed by options.  Assume that only options
			 * follow a space.  If someone sends us a kernel path
			 * that includes a space, they deserve to be broken.
			 */
			opt_ptr = strchr(opt, ' ');
			if (opt_ptr != NULL) {
				*opt_ptr = '\0';
			}

			path = expand_path(opt);
			if (path != NULL) {
				(void) strlcpy(kernbuf, path, BUFSIZ);
				free(path);

				/*
				 * If there were options given, use those.
				 * Otherwise, copy over the default options.
				 */
				if (opt_ptr != NULL) {
					/* Restore the space in opt string */
					*opt_ptr = ' ';
					(void) strlcat(kernbuf, opt_ptr,
					    BUFSIZ);
				} else {
					if (set_kernel(mp, ARGS_CMD, NULL,
					    args_buf, BUFSIZ) != BAM_SUCCESS)
						return (BAM_ERROR);

					if (args_buf[0] != '\0') {
						(void) strlcat(kernbuf, " ",
						    BUFSIZ);
						(void) strlcat(kernbuf,
						    args_buf, BUFSIZ);
					}
				}
			} else {
				bam_error(UNKNOWN_KERNEL, opt);
				bam_print_stderr(UNKNOWN_KERNEL_REBOOT);
				return (BAM_ERROR);
			}
		}
		entry = add_boot_entry(mp, REBOOT_TITLE, grubdisk, kernbuf,
		    NULL, NULL);
	} else {
		(void) snprintf(kernbuf, sizeof (kernbuf), "%s %s",
		    MULTI_BOOT, opt);
		entry = add_boot_entry(mp, REBOOT_TITLE, grubdisk, kernbuf,
		    NULL, MULTI_BOOT_ARCHIVE);
	}
	free(grubdisk);

	if (entry == BAM_ERROR) {
		bam_error(REBOOT_WITH_ARGS_FAILED);
		return (BAM_ERROR);
	}

	save_default_entry(mp, BAM_OLDDEF);
	(void) set_global(mp, menu_cmds[DEFAULT_CMD], entry);
	return (BAM_WRITE);
}

static error_t
set_global(menu_t *mp, char *globalcmd, int val)
{
	line_t *lp, *found, *last;
	char *cp, *str;
	char prefix[BAM_MAXLINE];
	size_t len;

	assert(mp);
	assert(globalcmd);

	if (strcmp(globalcmd, menu_cmds[DEFAULT_CMD]) == 0) {
		if (val < 0 || mp->end == NULL || val > mp->end->entryNum) {
			(void) snprintf(prefix, sizeof (prefix), "%d", val);
			bam_error(INVALID_ENTRY, prefix);
			return (BAM_ERROR);
		}
	}

	found = last = NULL;
	for (lp = mp->start; lp; lp = lp->next) {
		if (lp->flags != BAM_GLOBAL)
			continue;

		last = lp; /* track the last global found */

		if (lp->cmd == NULL) {
			bam_error(NO_CMD, lp->lineNum);
			continue;
		}
		if (strcmp(globalcmd, lp->cmd) != 0)
			continue;

		if (found) {
			bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root);
		}
		found = lp;
	}

	if (found == NULL) {
		lp = s_calloc(1, sizeof (line_t));
		if (last == NULL) {
			lp->next = mp->start;
			mp->start = lp;
			mp->end = (mp->end) ? mp->end : lp;
		} else {
			lp->next = last->next;
			last->next = lp;
			if (lp->next == NULL)
				mp->end = lp;
		}
		lp->flags = BAM_GLOBAL; /* other fields not needed for writes */
		len = strlen(globalcmd) + strlen(menu_cmds[SEP_CMD]);
		len += 10;	/* val < 10 digits */
		lp->line = s_calloc(1, len);
		(void) snprintf(lp->line, len, "%s%s%d",
		    globalcmd, menu_cmds[SEP_CMD], val);
		return (BAM_WRITE);
	}

	/*
	 * We are changing an existing entry. Retain any prefix whitespace,
	 * but overwrite everything else. This preserves tabs added for
	 * readability.
	 */
	str = found->line;
	cp = prefix;
	while (*str == ' ' || *str == '\t')
		*(cp++) = *(str++);
	*cp = '\0'; /* Terminate prefix */
	len = strlen(prefix) + strlen(globalcmd);
	len += strlen(menu_cmds[SEP_CMD]) + 10;

	free(found->line);
	found->line = s_calloc(1, len);
	(void) snprintf(found->line, len,
	    "%s%s%s%d", prefix, globalcmd, menu_cmds[SEP_CMD], val);

	return (BAM_WRITE); /* need a write to menu */
}

/*
 * partial_path may be anything like "kernel/unix" or "kmdb".  Try to
 * expand it to a full unix path.  The calling function is expected to
 * output a message if an error occurs and NULL is returned.
 */
static char *
expand_path(const char *partial_path)
{
	int new_path_len;
	char *new_path, new_path2[PATH_MAX];
	struct stat sb;

	new_path_len = strlen(partial_path) + 64;
	new_path = s_calloc(1, new_path_len);

	/* First, try the simplest case - something like "kernel/unix" */
	(void) snprintf(new_path, new_path_len, "/platform/i86pc/%s",
	    partial_path);
	if (stat(new_path, &sb) == 0) {
		return (new_path);
	}

	if (strcmp(partial_path, "kmdb") == 0) {
		(void) snprintf(new_path, new_path_len, "%s -k",
		    DIRECT_BOOT_KERNEL);
		return (new_path);
	}

	/*
	 * We've quickly reached unsupported usage.  Try once more to
	 * see if we were just given a glom name.
	 */
	(void) snprintf(new_path, new_path_len, "/platform/i86pc/%s/unix",
	    partial_path);
	(void) snprintf(new_path2, PATH_MAX, "/platform/i86pc/%s/amd64/unix",
	    partial_path);
	if (stat(new_path, &sb) == 0) {
		if (stat(new_path2, &sb) == 0) {
			/*
			 * We matched both, so we actually
			 * want to write the $ISADIR version.
			 */
			(void) snprintf(new_path, new_path_len,
			    "/platform/i86pc/kernel/%s/$ISADIR/unix",
			    partial_path);
		}
		return (new_path);
	}

	free(new_path);
	return (NULL);
}

/*
 * The kernel cmd and arg have been changed, so
 * check whether the archive line needs to change.
 */
static void
set_archive_line(entry_t *entryp, line_t *kernelp)
{
	line_t *lp = entryp->start;
	char *new_archive;
	menu_cmd_t m_cmd;

	for (; lp != NULL; lp = lp->next) {
		if (strncmp(lp->cmd, menu_cmds[MODULE_CMD],
		    sizeof (menu_cmds[MODULE_CMD]) - 1) == 0) {
			break;
		}
		if (lp == entryp->end)
			return;
	}
	if (lp == NULL)
		return;

	if (strstr(kernelp->arg, "$ISADIR") != NULL) {
		new_archive = DIRECT_BOOT_ARCHIVE;
		m_cmd = MODULE_DOLLAR_CMD;
	} else if (strstr(kernelp->arg, "amd64") != NULL) {
		new_archive = DIRECT_BOOT_ARCHIVE_64;
		m_cmd = MODULE_CMD;
	} else {
		new_archive = DIRECT_BOOT_ARCHIVE_32;
		m_cmd = MODULE_CMD;
	}

	if (strcmp(lp->arg, new_archive) == 0)
		return;

	if (strcmp(lp->cmd, menu_cmds[m_cmd]) != 0) {
		free(lp->cmd);
		lp->cmd = s_strdup(menu_cmds[m_cmd]);
	}

	free(lp->arg);
	lp->arg = s_strdup(new_archive);
	update_line(lp);
}

/*
 * Title for an entry to set properties that once went in bootenv.rc.
 */
#define	BOOTENV_RC_TITLE	"Solaris bootenv rc"

/*
 * If path is NULL, return the kernel (optnum == KERNEL_CMD) or arguments
 * (optnum == ARGS_CMD) in the argument buf.  If path is a zero-length
 * string, reset the value to the default.  If path is a non-zero-length
 * string, set the kernel or arguments.
 */
static error_t
set_kernel(menu_t *mp, menu_cmd_t optnum, char *path, char *buf, size_t bufsize)
{
	int entryNum, rv = BAM_SUCCESS, free_new_path = 0;
	entry_t *entryp;
	line_t *ptr, *kernelp;
	char *new_arg, *old_args, *space;
	char *grubdisk, *rootdev, *new_path;
	char old_space;
	size_t old_kernel_len, new_str_len;
	struct stat sb;

	assert(bufsize > 0);

	ptr = kernelp = NULL;
	new_arg = old_args = space = NULL;
	grubdisk = rootdev = new_path = NULL;
	buf[0] = '\0';

	if (bam_direct != BAM_DIRECT_DBOOT) {
		bam_error(NOT_DBOOT, optnum == KERNEL_CMD ? "kernel" : "args");
		return (BAM_ERROR);
	}

	/*
	 * If a user changed the default entry to a non-bootadm controlled
	 * one, we don't want to mess with it.  Just print an error and
	 * return.
	 */
	if (mp->curdefault) {
		entryNum = s_strtol(mp->curdefault->arg);
		for (entryp = mp->entries; entryp; entryp = entryp->next) {
			if (entryp->entryNum == entryNum)
				break;
		}
		if ((entryp != NULL) &&
		    ((entryp->flags & (BAM_ENTRY_BOOTADM|BAM_ENTRY_LU)) == 0)) {
			bam_error(DEFAULT_NOT_BAM);
			return (BAM_ERROR);
		}
	}

	entryNum = -1;
	entryp = find_boot_entry(mp, BOOTENV_RC_TITLE, NULL, NULL, NULL, 0,
	    &entryNum);

	if (entryp != NULL) {
		for (ptr = entryp->start; ptr && ptr != entryp->end;
		    ptr = ptr->next) {
			if (strncmp(ptr->cmd, menu_cmds[KERNEL_CMD],
			    sizeof (menu_cmds[KERNEL_CMD]) - 1) == 0) {
				kernelp = ptr;
				break;
			}
		}
		if (kernelp == NULL) {
			bam_error(NO_KERNEL, entryNum);
			return (BAM_ERROR);
		}

		old_kernel_len = strcspn(kernelp->arg, " \t");
		space = old_args = kernelp->arg + old_kernel_len;
		while ((*old_args == ' ') || (*old_args == '\t'))
			old_args++;
	}

	if (path == NULL) {
		/* Simply report what was found */
		if (kernelp == NULL)
			return (BAM_SUCCESS);

		if (optnum == ARGS_CMD) {
			if (old_args[0] != '\0')
				(void) strlcpy(buf, old_args, bufsize);
		} else {
			/*
			 * We need to print the kernel, so we just turn the
			 * first space into a '\0' and print the beginning.
			 * We don't print anything if it's the default kernel.
			 */
			old_space = *space;
			*space = '\0';
			if (strcmp(kernelp->arg, DIRECT_BOOT_KERNEL) != 0)
				(void) strlcpy(buf, kernelp->arg, bufsize);
			*space = old_space;
		}
		return (BAM_SUCCESS);
	}

	/*
	 * First, check if we're resetting an entry to the default.
	 */
	if ((path[0] == '\0') ||
	    ((optnum == KERNEL_CMD) &&
	    (strcmp(path, DIRECT_BOOT_KERNEL) == 0))) {
		if ((entryp == NULL) || (kernelp == NULL)) {
			/* No previous entry, it's already the default */
			return (BAM_SUCCESS);
		}

		/*
		 * Check if we can delete the entry.  If we're resetting the
		 * kernel command, and the args is already empty, or if we're
		 * resetting the args command, and the kernel is already the
		 * default, we can restore the old default and delete the entry.
		 */
		if (((optnum == KERNEL_CMD) &&
		    ((old_args == NULL) || (old_args[0] == '\0'))) ||
		    ((optnum == ARGS_CMD) &&
		    (strncmp(kernelp->arg, DIRECT_BOOT_KERNEL,
		    sizeof (DIRECT_BOOT_KERNEL) - 1) == 0))) {
			kernelp = NULL;
			(void) do_delete(mp, entryNum);
			restore_default_entry(mp, BAM_OLD_RC_DEF,
			    mp->old_rc_default);
			mp->old_rc_default = NULL;
			rv = BAM_WRITE;
			goto done;
		}

		if (optnum == KERNEL_CMD) {
			/*
			 * At this point, we've already checked that old_args
			 * and entryp are valid pointers.  The "+ 2" is for
			 * a space a the string termination character.
			 */
			new_str_len = (sizeof (DIRECT_BOOT_KERNEL) - 1) +
			    strlen(old_args) + 2;
			new_arg = s_calloc(1, new_str_len);
			(void) snprintf(new_arg, new_str_len, "%s %s",
			    DIRECT_BOOT_KERNEL, old_args);
			free(kernelp->arg);
			kernelp->arg = new_arg;

			/*
			 * We have changed the kernel line, so we may need
			 * to update the archive line as well.
			 */
			set_archive_line(entryp, kernelp);
		} else {
			/*
			 * We're resetting the boot args to nothing, so
			 * we only need to copy the kernel.  We've already
			 * checked that the kernel is not the default.
			 */
			new_arg = s_calloc(1, old_kernel_len + 1);
			(void) snprintf(new_arg, old_kernel_len + 1, "%s",
			    kernelp->arg);
			free(kernelp->arg);
			kernelp->arg = new_arg;
		}
		rv = BAM_WRITE;
		goto done;
	}

	/*
	 * Expand the kernel file to a full path, if necessary
	 */
	if ((optnum == KERNEL_CMD) && (path[0] != '/')) {
		new_path = expand_path(path);
		if (new_path == NULL) {
			bam_error(UNKNOWN_KERNEL, path);
			return (BAM_ERROR);
		}
		free_new_path = 1;
	} else {
		new_path = path;
		free_new_path = 0;
	}

	/*
	 * At this point, we know we're setting a new value.  First, take care
	 * of the case where there was no previous entry.
	 */
	if (entryp == NULL) {
		/* Similar to code in update_temp */
		if (stat(GRUB_slice, &sb) != 0) {
			/*
			 * 1. First get root disk name from mnttab
			 * 2. Translate disk name to grub name
			 * 3. Add the new menu entry
			 */
			rootdev = get_special("/");
			if (rootdev) {
				grubdisk = os_to_grubdisk(rootdev, 1);
				free(rootdev);
			}
		} else {
			/*
			 * This is an LU BE. The GRUB_root file
			 * contains entry for GRUB's "root" cmd.
			 */
			grubdisk = read_grub_root();
		}
		if (grubdisk == NULL) {
			bam_error(REBOOT_WITH_ARGS_FAILED);
			rv = BAM_ERROR;
			goto done;
		}
		if (optnum == KERNEL_CMD) {
			entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE,
			    grubdisk, new_path, NULL, NULL);
		} else {
			new_str_len = strlen(DIRECT_BOOT_KERNEL) +
			    strlen(path) + 8;
			new_arg = s_calloc(1, new_str_len);

			(void) snprintf(new_arg, new_str_len, "%s %s",
			    DIRECT_BOOT_KERNEL, path);
			entryNum = add_boot_entry(mp, BOOTENV_RC_TITLE,
			    grubdisk, new_arg, NULL, DIRECT_BOOT_ARCHIVE);
		}
		save_default_entry(mp, BAM_OLD_RC_DEF);
		(void) set_global(mp, menu_cmds[DEFAULT_CMD], entryNum);
		rv = BAM_WRITE;
		goto done;
	}

	/*
	 * There was already an bootenv entry which we need to edit.
	 */
	if (optnum == KERNEL_CMD) {
		new_str_len = strlen(new_path) + strlen(old_args) + 2;
		new_arg = s_calloc(1, new_str_len);
		(void) snprintf(new_arg, new_str_len, "%s %s", new_path,
		    old_args);
		free(kernelp->arg);
		kernelp->arg = new_arg;

		/*
		 * If we have changed the kernel line, we may need to update
		 * the archive line as well.
		 */
		set_archive_line(entryp, kernelp);
	} else {
		new_str_len = old_kernel_len + strlen(path) + 8;
		new_arg = s_calloc(1, new_str_len);
		(void) strncpy(new_arg, kernelp->arg, old_kernel_len);
		(void) strlcat(new_arg, " ", new_str_len);
		(void) strlcat(new_arg, path, new_str_len);
		free(kernelp->arg);
		kernelp->arg = new_arg;
	}
	rv = BAM_WRITE;

done:
	if ((rv == BAM_WRITE) && kernelp)
		update_line(kernelp);
	if (free_new_path)
		free(new_path);
	return (rv);
}

/*ARGSUSED*/
static error_t
set_option(menu_t *mp, char *menu_path, char *opt)
{
	int optnum, optval;
	char *val;
	char buf[BUFSIZ] = "";
	error_t rv;

	assert(mp);
	assert(opt);

	val = strchr(opt, '=');
	if (val != NULL) {
		*val = '\0';
	}

	if (strcmp(opt, "default") == 0) {
		optnum = DEFAULT_CMD;
	} else if (strcmp(opt, "timeout") == 0) {
		optnum = TIMEOUT_CMD;
	} else if (strcmp(opt, menu_cmds[KERNEL_CMD]) == 0) {
		optnum = KERNEL_CMD;
	} else if (strcmp(opt, menu_cmds[ARGS_CMD]) == 0) {
		optnum = ARGS_CMD;
	} else {
		bam_error(INVALID_ENTRY, opt);
		return (BAM_ERROR);
	}

	/*
	 * kernel and args are allowed without "=new_value" strings.  All
	 * others cause errors
	 */
	if ((val == NULL) && (optnum != KERNEL_CMD) && (optnum != ARGS_CMD)) {
		bam_error(INVALID_ENTRY, opt);
		return (BAM_ERROR);
	} else if (val != NULL) {
		*val = '=';
	}

	if ((optnum == KERNEL_CMD) || (optnum == ARGS_CMD)) {
		rv = set_kernel(mp, optnum, val ? val + 1 : NULL, buf, BUFSIZ);
		if ((rv == BAM_SUCCESS) && (buf[0] != '\0'))
			(void) printf("%s\n", buf);
		return (rv);
	} else {
		optval = s_strtol(val + 1);
		return (set_global(mp, menu_cmds[optnum], optval));
	}
}

/*
 * The quiet argument suppresses messages. This is used
 * when invoked in the context of other commands (e.g. list_entry)
 */
static error_t
read_globals(menu_t *mp, char *menu_path, char *globalcmd, int quiet)
{
	line_t *lp;
	char *arg;
	int done, ret = BAM_SUCCESS;

	assert(mp);
	assert(menu_path);
	assert(globalcmd);

	if (mp->start == NULL) {
		if (!quiet)
			bam_error(NO_MENU, menu_path);
		return (BAM_ERROR);
	}

	done = 0;
	for (lp = mp->start; lp; lp = lp->next) {
		if (lp->flags != BAM_GLOBAL)
			continue;

		if (lp->cmd == NULL) {
			if (!quiet)
				bam_error(NO_CMD, lp->lineNum);
			continue;
		}

		if (strcmp(globalcmd, lp->cmd) != 0)
			continue;

		/* Found global. Check for duplicates */
		if (done && !quiet) {
			bam_error(DUP_CMD, globalcmd, lp->lineNum, bam_root);
			ret = BAM_ERROR;
		}

		arg = lp->arg ? lp->arg : "";
		bam_print(GLOBAL_CMD, globalcmd, arg);
		done = 1;
	}

	if (!done && bam_verbose)
		bam_print(NO_ENTRY, globalcmd);

	return (ret);
}

static error_t
menu_write(char *root, menu_t *mp)
{
	return (list2file(root, MENU_TMP, GRUB_MENU, mp->start));
}

static void
line_free(line_t *lp)
{
	if (lp == NULL)
		return;

	if (lp->cmd)
		free(lp->cmd);
	if (lp->sep)
		free(lp->sep);
	if (lp->arg)
		free(lp->arg);
	if (lp->line)
		free(lp->line);
	free(lp);
}

static void
linelist_free(line_t *start)
{
	line_t *lp;

	while (start) {
		lp = start;
		start = start->next;
		line_free(lp);
	}
}

static void
filelist_free(filelist_t *flistp)
{
	linelist_free(flistp->head);
	flistp->head = NULL;
	flistp->tail = NULL;
}

static void
menu_free(menu_t *mp)
{
	entry_t *ent, *tmp;
	assert(mp);

	if (mp->start)
		linelist_free(mp->start);
	ent = mp->entries;
	while (ent) {
		tmp = ent;
		ent = tmp->next;
		free(tmp);
	}

	free(mp);
}

/*
 * Utility routines
 */


/*
 * Returns 0 on success
 * Any other value indicates an error
 */
static int
exec_cmd(char *cmdline, filelist_t *flistp)
{
	char buf[BUFSIZ];
	int ret;
	FILE *ptr;
	sigset_t set;
	void (*disp)(int);

	/*
	 * For security
	 * - only absolute paths are allowed
	 * - set IFS to space and tab
	 */
	if (*cmdline != '/') {
		bam_error(ABS_PATH_REQ, cmdline);
		return (-1);
	}
	(void) putenv("IFS= \t");

	/*
	 * We may have been exec'ed with SIGCHLD blocked
	 * unblock it here
	 */
	(void) sigemptyset(&set);
	(void) sigaddset(&set, SIGCHLD);
	if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) {
		bam_error(CANT_UNBLOCK_SIGCHLD, strerror(errno));
		return (-1);
	}

	/*
	 * Set SIGCHLD disposition to SIG_DFL for popen/pclose
	 */
	disp = sigset(SIGCHLD, SIG_DFL);
	if (disp == SIG_ERR) {
		bam_error(FAILED_SIG, strerror(errno));
		return (-1);
	}
	if (disp == SIG_HOLD) {
		bam_error(BLOCKED_SIG, cmdline);
		return (-1);
	}

	ptr = popen(cmdline, "r");
	if (ptr == NULL) {
		bam_error(POPEN_FAIL, cmdline, strerror(errno));
		return (-1);
	}

	/*
	 * If we simply do a pclose() following a popen(), pclose()
	 * will close the reader end of the pipe immediately even
	 * if the child process has not started/exited. pclose()
	 * does wait for cmd to terminate before returning though.
	 * When the executed command writes its output to the pipe
	 * there is no reader process and the command dies with
	 * SIGPIPE. To avoid this we read repeatedly until read
	 * terminates with EOF. This indicates that the command
	 * (writer) has closed the pipe and we can safely do a
	 * pclose().
	 *
	 * Since pclose() does wait for the command to exit,
	 * we can safely reap the exit status of the command
	 * from the value returned by pclose()
	 */
	while (s_fgets(buf, sizeof (buf), ptr) != NULL) {
		if (flistp == NULL) {
			/* s_fgets strips newlines, so insert them at the end */
			bam_print(PRINT, buf);
		} else {
			append_to_flist(flistp, buf);
		}
	}

	ret = pclose(ptr);
	if (ret == -1) {
		bam_error(PCLOSE_FAIL, cmdline, strerror(errno));
		return (-1);
	}

	if (WIFEXITED(ret)) {
		return (WEXITSTATUS(ret));
	} else {
		bam_error(EXEC_FAIL, cmdline, ret);
		return (-1);
	}
}

/*
 * Since this function returns -1 on error
 * it cannot be used to convert -1. However,
 * that is sufficient for what we need.
 */
static long
s_strtol(char *str)
{
	long l;
	char *res = NULL;

	if (str == NULL) {
		return (-1);
	}

	errno = 0;
	l = strtol(str, &res, 10);
	if (errno || *res != '\0') {
		return (-1);
	}

	return (l);
}

/*
 * Wrapper around fputs, that adds a newline (since fputs doesn't)
 */
static int
s_fputs(char *str, FILE *fp)
{
	char linebuf[BAM_MAXLINE];

	(void) snprintf(linebuf, sizeof (linebuf), "%s\n", str);
	return (fputs(linebuf, fp));
}

/*
 * Wrapper around fgets, that strips newlines returned by fgets
 */
char *
s_fgets(char *buf, int buflen, FILE *fp)
{
	int n;

	buf = fgets(buf, buflen, fp);
	if (buf) {
		n = strlen(buf);
		if (n == buflen - 1 && buf[n-1] != '\n')
			bam_error(TOO_LONG, buflen - 1, buf);
		buf[n-1] = (buf[n-1] == '\n') ? '\0' : buf[n-1];
	}

	return (buf);
}

void *
s_calloc(size_t nelem, size_t sz)
{
	void *ptr;

	ptr = calloc(nelem, sz);
	if (ptr == NULL) {
		bam_error(NO_MEM, nelem*sz);
		bam_exit(1);
	}
	return (ptr);
}

void *
s_realloc(void *ptr, size_t sz)
{
	ptr = realloc(ptr, sz);
	if (ptr == NULL) {
		bam_error(NO_MEM, sz);
		bam_exit(1);
	}
	return (ptr);
}

static char *
s_strdup(char *str)
{
	char *ptr;

	if (str == NULL)
		return (NULL);

	ptr = strdup(str);
	if (ptr == NULL) {
		bam_error(NO_MEM, strlen(str) + 1);
		bam_exit(1);
	}
	return (ptr);
}

/*
 * Returns 1 if amd64 (or sparc, for syncing x86 diskless clients)
 * Returns 0 otherwise
 */
static int
is_amd64(void)
{
	static int amd64 = -1;
	char isabuf[257];	/* from sysinfo(2) manpage */

	if (amd64 != -1)
		return (amd64);

	if (bam_alt_platform) {
		if (strcmp(bam_platform, "i86pc") == 0) {
			amd64 = 1;		/* diskless server */
		}
	} else {
		if (sysinfo(SI_ISALIST, isabuf, sizeof (isabuf)) > 0 &&
		    strncmp(isabuf, "amd64 ", strlen("amd64 ")) == 0) {
			amd64 = 1;
		} else if (strstr(isabuf, "i386") == NULL) {
			amd64 = 1;		/* diskless server */
		}
	}
	if (amd64 == -1)
		amd64 = 0;

	return (amd64);
}

static int
is_sun4u(void)
{
	static int sun4u = -1;
	char mbuf[257];	/* from sysinfo(2) manpage */

	if (sun4u != -1)
		return (sun4u);

	if (bam_alt_platform) {
		if (strcmp(bam_platform, "sun4u") == 0) {
			sun4u = 1;
		}
	} else {
		if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0 &&
		    strncmp(mbuf, "sun4u", strlen("sun4u")) == 0) {
			sun4u = 1;
		}
	}
	if (sun4u == -1)
		sun4u = 0;

	return (sun4u);
}

static int
is_sun4v(void)
{
	static int sun4v = -1;
	char mbuf[257];	/* from sysinfo(2) manpage */

	if (sun4v != -1)
		return (sun4v);

	if (bam_alt_platform) {
		if (strcmp(bam_platform, "sun4v") == 0) {
			sun4v = 1;
		}
	} else {
		if (sysinfo(SI_MACHINE, mbuf, sizeof (mbuf)) > 0 &&
		    strncmp(mbuf, "sun4v", strlen("sun4v")) == 0) {
			sun4v = 1;
		}
	}
	if (sun4v == -1)
		sun4v = 0;

	return (sun4v);
}


static void
append_to_flist(filelist_t *flistp, char *s)
{
	line_t *lp;

	lp = s_calloc(1, sizeof (line_t));
	lp->line = s_strdup(s);
	if (flistp->head == NULL)
		flistp->head = lp;
	else
		flistp->tail->next = lp;
	flistp->tail = lp;
}

#if !defined(_OPB)

UCODE_VENDORS;

/*ARGSUSED*/
static void
ucode_install(char *root)
{
	int i;

	for (i = 0; ucode_vendors[i].filestr != NULL; i++) {
		int cmd_len = PATH_MAX + 256;
		char cmd[PATH_MAX + 256];
		char file[PATH_MAX];
		char timestamp[PATH_MAX];
		struct stat fstatus, tstatus;
		struct utimbuf u_times;

		(void) snprintf(file, PATH_MAX, "%s/%s/%s-ucode.txt",
		    bam_root, UCODE_INSTALL_PATH, ucode_vendors[i].filestr);

		if (stat(file, &fstatus) != 0 || !(S_ISREG(fstatus.st_mode)))
			continue;

		(void) snprintf(timestamp, PATH_MAX, "%s.ts", file);

		if (stat(timestamp, &tstatus) == 0 &&
		    fstatus.st_mtime <= tstatus.st_mtime)
			continue;

		(void) snprintf(cmd, cmd_len, "/usr/sbin/ucodeadm -i -R "
		    "%s/%s/%s %s > /dev/null 2>&1", bam_root,
		    UCODE_INSTALL_PATH, ucode_vendors[i].vendorstr, file);
		if (system(cmd) != 0)
			return;

		if (creat(timestamp, S_IRUSR | S_IWUSR) == -1)
			return;

		u_times.actime = fstatus.st_atime;
		u_times.modtime = fstatus.st_mtime;
		(void) utime(timestamp, &u_times);
	}
}
#endif