11634 installboot should support ESP updates

Reviewed by: Alexander Eremin <a.eremin@nexenta.com>
Reviewed by: Andy Fiddaman <andy@omniosce.org>
Approved by: Dan McDonald <danmcd@joyent.com>

6 files changed, 1921 insertions, 1014 deletions

diff --git a/usr/src/cmd/boot/installboot/i386/Makefile b/usr/src/cmd/boot/installboot/i386/Makefile
index ce2e4eb7be..6df94cc543 100644
--- a/usr/src/cmd/boot/installboot/i386/Makefile
+++ b/usr/src/cmd/boot/installboot/i386/Makefile
@@ -17,7 +17,7 @@ OBJS +=		getresponse.o
 SRCS +=		$(SRC)/common/util/getresponse.c
 
 CPPFLAGS +=	-I../../common -I$(SRC)/common/util
-LDLIBS +=	-lfdisk -lefi -lfstyp -luuid
+LDLIBS +=	-ladm -lfdisk -lefi -lfstyp -luuid -lumem
 
 # getresponse.c and libfdisk.c need this
 LINTFLAGS += \
diff --git a/usr/src/cmd/boot/installboot/i386/installboot.c b/usr/src/cmd/boot/installboot/i386/installboot.c
index 80066b1430..c6c2829f76 100644
--- a/usr/src/cmd/boot/installboot/i386/installboot.c
+++ b/usr/src/cmd/boot/installboot/i386/installboot.c
@@ -21,10 +21,11 @@
 /*
  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
- * Copyright 2017 Toomas Soome <tsoome@me.com>
+ * Copyright 2019 Toomas Soome <tsoome@me.com>
  */
 
 #include <stdio.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -33,6 +34,8 @@
 #include <strings.h>
 #include <libfdisk.h>
 #include <err.h>
+#include <time.h>
+#include <spawn.h>
 
 #include <sys/dktp/fdisk.h>
 #include <sys/dkio.h>
@@ -42,6 +45,11 @@
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
 #include <sys/efi_partition.h>
+#include <sys/queue.h>
+#include <sys/mount.h>
+#include <sys/mntent.h>
+#include <sys/mnttab.h>
+#include <sys/wait.h>
 #include <libfstyp.h>
 #include <libgen.h>
 #include <uuid/uuid.h>
@@ -97,18 +105,50 @@
  * reinstalled in case the partition content is relocated.
  */
 
-static boolean_t	write_mbr = B_FALSE;
-static boolean_t	force_mbr = B_FALSE;
-static boolean_t	force_update = B_FALSE;
-static boolean_t	do_getinfo = B_FALSE;
-static boolean_t	do_version = B_FALSE;
-static boolean_t	do_mirror_bblk = B_FALSE;
-static boolean_t	strip = B_FALSE;
-static boolean_t	verbose_dump = B_FALSE;
+static bool	write_mbr = false;
+static bool	force_mbr = false;
+static bool	force_update = false;
+static bool	do_getinfo = false;
+static bool	do_version = false;
+static bool	do_mirror_bblk = false;
+static bool	strip = false;
+static bool	verbose_dump = false;
+static size_t	sector_size = SECTOR_SIZE;
 
 /* Versioning string, if present. */
 static char		*update_str;
 
+/* Default location of boot programs. */
+static char		*boot_dir = "/boot";
+
+/* Our boot programs */
+#define	STAGE1		"pmbr"
+#define	STAGE2		"gptzfsboot"
+#define	BOOTIA32	"bootia32.efi"
+#define	BOOTX64		"bootx64.efi"
+#define	LOADER32	"loader32.efi"
+#define	LOADER64	"loader64.efi"
+
+static char *stage1;
+static char *stage2;
+static char *efi32;
+static char *efi64;
+
+#define	GRUB_VERSION_OFF (0x3e)
+#define	GRUB_COMPAT_VERSION_MAJOR 3
+#define	GRUB_COMPAT_VERSION_MINOR 2
+#define	GRUB_VERSION (2 << 8 | 3) /* 3.2 */
+
+#define	LOADER_VERSION (1)
+#define	LOADER_JOYENT_VERSION (2)
+
+typedef enum {
+	MBR_TYPE_UNKNOWN,
+	MBR_TYPE_GRUB1,
+	MBR_TYPE_LOADER,
+	MBR_TYPE_LOADER_JOYENT,
+} mbr_type_t;
+
 /*
  * Temporary buffer to store the first 32K of data looking for a multiboot
  * signature.
@@ -117,159 +157,469 @@ char			mboot_scan[MBOOT_SCAN_SIZE];
 
 /* Function prototypes. */
 static void check_options(char *);
-static int get_start_sector(ib_device_t *);
+static int open_device(const char *);
+static char *make_blkdev(const char *);
 
-static int read_stage1_from_file(char *, ib_data_t *);
-static int read_bootblock_from_file(char *, ib_bootblock_t *);
-static int read_bootblock_from_disk(ib_device_t *, ib_bootblock_t *, char **);
+static int read_bootblock_from_file(const char *, ib_bootblock_t *);
 static void add_bootblock_einfo(ib_bootblock_t *, char *);
-static int prepare_stage1(ib_data_t *);
-static int prepare_bootblock(ib_data_t *, char *);
-static int write_stage1(ib_data_t *);
-static int write_bootblock(ib_data_t *);
-static int init_device(ib_device_t *, char *);
-static void cleanup_device(ib_device_t *);
-static int commit_to_disk(ib_data_t *, char *);
-static int handle_install(char *, char **);
-static int handle_getinfo(char *, char **);
-static int handle_mirror(char *, char **);
-static boolean_t is_update_necessary(ib_data_t *, char *);
-static int propagate_bootblock(ib_data_t *, ib_data_t *, char *);
+static void prepare_bootblock(ib_data_t *, struct partlist *, char *);
+static int handle_install(char *, int, char **);
+static int handle_getinfo(char *, int, char **);
+static int handle_mirror(char *, int, char **);
 static void usage(char *, int) __NORETURN;
 
-static int
-read_stage1_from_file(char *path, ib_data_t *dest)
+static char *
+stagefs_mount(char *blkdev, struct partlist *plist)
 {
-	int	fd;
+	char *path;
+	char optbuf[MAX_MNTOPT_STR] = { '\0', };
+	char *template = strdup("/tmp/ibootXXXXXX");
+	int ret;
 
-	assert(dest != NULL);
+	if (template == NULL)
+		return (NULL);
 
-	/* read the stage1 file from filesystem */
-	fd = open(path, O_RDONLY);
-	if (fd == -1 ||
-	    read(fd, dest->stage1, SECTOR_SIZE) != SECTOR_SIZE) {
-		(void) fprintf(stderr, gettext("cannot read stage1 file %s\n"),
-		    path);
-		return (BC_ERROR);
+	if ((path = mkdtemp(template)) == NULL) {
+		free(template);
+		return (NULL);
 	}
-	(void) close(fd);
-	return (BC_SUCCESS);
+
+	(void) snprintf(optbuf, MAX_MNTOPT_STR, "timezone=%d",
+	    timezone);
+	ret = mount(blkdev, path, MS_OPTIONSTR,
+	    MNTTYPE_PCFS, NULL, 0, optbuf, MAX_MNTOPT_STR);
+	if (ret != 0) {
+		(void) rmdir(path);
+		free(path);
+		path = NULL;
+	}
+	plist->pl_device->stage.mntpnt = path;
+	return (path);
 }
 
-static int
-read_bootblock_from_file(char *file, ib_bootblock_t *bblock)
+static void
+install_stage1_cb(void *data, struct partlist *plist)
 {
-	struct stat	sb;
-	uint32_t	buf_size;
-	uint32_t	mboot_off;
-	int		fd = -1;
-	int		retval = BC_ERROR;
+	int rv, fd;
+	ib_device_t *device = plist->pl_device;
 
-	assert(bblock != NULL);
-	assert(file != NULL);
+	if (plist->pl_type == IB_BBLK_MBR && !write_mbr)
+		return;
 
-	fd = open(file, O_RDONLY);
-	if (fd == -1) {
-		BOOT_DEBUG("Error opening %s\n", file);
+	if ((fd = open_device(plist->pl_devname)) == -1) {
+		(void) fprintf(stdout, gettext("cannot open "
+		    "device %s\n"), plist->pl_devname);
 		perror("open");
-		goto out;
+		return;
 	}
 
-	if (fstat(fd, &sb) == -1) {
-		BOOT_DEBUG("Error getting information (stat) about %s", file);
-		perror("stat");
-		goto outfd;
+	rv = write_out(fd, plist->pl_stage, sector_size, 0);
+	if (rv != BC_SUCCESS) {
+		(void) fprintf(stdout, gettext("cannot write "
+		    "partition boot sector\n"));
+		perror("write");
+	} else {
+		(void) fprintf(stdout, gettext("stage1 written to "
+		    "%s %d sector 0 (abs %d)\n"),
+		    device->devtype == IB_DEV_MBR? "partition" : "slice",
+		    device->stage.id, device->stage.start);
 	}
+}
 
-	/* loader bootblock has version built in */
-	buf_size = sb.st_size;
+static void
+install_stage2_cb(void *data, struct partlist *plist)
+{
+	ib_bootblock_t *bblock = plist->pl_src_data;
+	int fd, ret;
+	off_t offset;
+	uint64_t abs;
 
-	bblock->buf_size = buf_size;
-	BOOT_DEBUG("bootblock in-memory buffer size is %d\n",
-	    bblock->buf_size);
+	/*
+	 * ZFS bootblock area is 3.5MB, make sure we can fit.
+	 * buf_size is size of bootblk+EINFO.
+	 */
+	if (bblock->buf_size > BBLK_ZFS_BLK_SIZE) {
+		(void) fprintf(stderr, gettext("bootblock is too large\n"));
+		return;
+	}
 
-	bblock->buf = malloc(buf_size);
-	if (bblock->buf == NULL) {
+	abs = plist->pl_device->stage.start + plist->pl_device->stage.offset;
+
+	if ((fd = open_device(plist->pl_devname)) == -1) {
+		(void) fprintf(stdout, gettext("cannot open "
+		    "device %s\n"), plist->pl_devname);
+		perror("open");
+		return;
+	}
+	offset = plist->pl_device->stage.offset * SECTOR_SIZE;
+	ret = write_out(fd, bblock->buf, bblock->buf_size, offset);
+	(void) close(fd);
+	if (ret != BC_SUCCESS) {
+		BOOT_DEBUG("Error writing the ZFS bootblock "
+		    "to %s at offset %d\n", plist->pl_devname, offset);
+		return;
+	}
+	(void) fprintf(stdout, gettext("bootblock written for %s,"
+	    " %d sectors starting at %d (abs %lld)\n"), plist->pl_devname,
+	    (bblock->buf_size / SECTOR_SIZE) + 1, offset / SECTOR_SIZE, abs);
+}
+
+static bool
+mkfs_pcfs(const char *dev)
+{
+	pid_t pid, w;
+	posix_spawnattr_t attr;
+	posix_spawn_file_actions_t file_actions;
+	int status;
+	char *cmd[7];
+
+	if (posix_spawnattr_init(&attr))
+		return (false);
+	if (posix_spawn_file_actions_init(&file_actions)) {
+		(void) posix_spawnattr_destroy(&attr);
+		return (false);
+	}
+
+	if (posix_spawnattr_setflags(&attr,
+	    POSIX_SPAWN_NOSIGCHLD_NP | POSIX_SPAWN_WAITPID_NP)) {
+		(void) posix_spawnattr_destroy(&attr);
+		(void) posix_spawn_file_actions_destroy(&file_actions);
+		return (false);
+	}
+	if (posix_spawn_file_actions_addopen(&file_actions, 0, "/dev/null",
+	    O_RDONLY, 0)) {
+		(void) posix_spawnattr_destroy(&attr);
+		(void) posix_spawn_file_actions_destroy(&file_actions);
+		return (false);
+	}
+
+	cmd[0] = "/usr/sbin/mkfs";
+	cmd[1] = "-F";
+	cmd[2] = "pcfs";
+	cmd[3] = "-o";
+	cmd[4] = "fat=32";
+	cmd[5] = (char *)dev;
+	cmd[6] = NULL;
+
+	if (posix_spawn(&pid, cmd[0], &file_actions, &attr, cmd, NULL))
+		return (false);
+	(void) posix_spawnattr_destroy(&attr);
+	(void) posix_spawn_file_actions_destroy(&file_actions);
+
+	do {
+		w = waitpid(pid, &status, 0);
+	} while (w == -1 && errno == EINTR);
+	if (w == -1)
+		status = -1;
+
+	return (status != -1);
+}
+
+static void
+install_esp_cb(void *data, struct partlist *plist)
+{
+	fstyp_handle_t fhdl;
+	const char *fident;
+	bool pcfs;
+	char *blkdev, *path, *file;
+	FILE *fp;
+	struct mnttab mp, mpref = { 0 };
+	ib_bootblock_t *bblock = plist->pl_src_data;
+	int fd, ret;
+
+	if ((fd = open_device(plist->pl_devname)) == -1)
+		return;
+
+	if (fstyp_init(fd, 0, NULL, &fhdl) != 0) {
+		(void) close(fd);
+		return;
+	}
+
+	pcfs = false;
+	if (fstyp_ident(fhdl, NULL, &fident) == 0) {
+		if (strcmp(fident, MNTTYPE_PCFS) == 0)
+			pcfs = true;
+	}
+	fstyp_fini(fhdl);
+	(void) close(fd);
+
+	if (!pcfs) {
+		(void) printf(gettext("Creating pcfs on ESP %s\n"),
+		    plist->pl_devname);
+
+		if (!mkfs_pcfs(plist->pl_devname)) {
+			(void) fprintf(stderr, gettext("mkfs -F pcfs failed "
+			    "on %s\n"), plist->pl_devname);
+			return;
+		}
+	}
+	blkdev = make_blkdev(plist->pl_devname);
+	if (blkdev == NULL)
+		return;
+
+	fp = fopen(MNTTAB, "r");
+	if (fp == NULL) {
+		perror("fopen");
+		free(blkdev);
+		return;
+	}
+
+	mpref.mnt_special = blkdev;
+	ret = getmntany(fp, &mp, &mpref);
+	(void) fclose(fp);
+	if (ret == 0)
+		path = mp.mnt_mountp;
+	else
+		path = stagefs_mount(blkdev, plist);
+
+	free(blkdev);
+	if (path == NULL)
+		return;
+
+	if (asprintf(&file, "%s%s", path, "/EFI") < 0) {
 		perror(gettext("Memory allocation failure"));
-		goto outbuf;
+		return;
 	}
-	bblock->file = bblock->buf;
 
-	if (read(fd, bblock->file, bblock->buf_size) != bblock->buf_size) {
-		BOOT_DEBUG("Read from %s failed\n", file);
-		perror("read");
-		goto outfd;
+	ret = mkdir(file, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+	if (ret == 0 || errno == EEXIST) {
+		free(file);
+		if (asprintf(&file, "%s%s", path, "/EFI/Boot") < 0) {
+			perror(gettext("Memory allocation failure"));
+			return;
+		}
+		ret = mkdir(file,
+		    S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+		if (errno == EEXIST)
+			ret = 0;
+	}
+	free(file);
+	if (ret < 0) {
+		perror("mkdir");
+		return;
 	}
 
-	buf_size = MIN(buf_size, MBOOT_SCAN_SIZE);
-	if (find_multiboot(bblock->file, buf_size, &mboot_off)
-	    != BC_SUCCESS) {
+	if (asprintf(&file, "%s%s", path, plist->pl_device->stage.path) < 0) {
+		perror(gettext("Memory allocation failure"));
+		return;
+	}
+
+	/* Write stage file. Should create temp file and rename. */
+	(void) chmod(file, S_IRUSR | S_IWUSR);
+	fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+	if (fd != -1) {
+		ret = write_out(fd, bblock->buf, bblock->buf_size, 0);
+		if (ret == BC_SUCCESS) {
+			(void) fprintf(stdout,
+			    gettext("bootblock written to %s\n"), file);
+		} else {
+			(void) fprintf(stdout,
+			    gettext("error while writing %s\n"), file);
+		}
+		(void) fchmod(fd, S_IRUSR | S_IRGRP | S_IROTH);
+		(void) close(fd);
+	}
+	free(file);
+}
+
+/*
+ * MBR setup only depends on write_mbr toggle.
+ */
+static bool
+compare_mbr_cb(struct partlist *plist)
+{
+	/* get confirmation for -m */
+	if (write_mbr && !force_mbr) {
+		(void) fprintf(stdout, gettext("Updating master boot sector "
+		    "destroys existing boot managers (if any).\n"
+		    "continue (y/n)? "));
+		if (!yes()) {
+			write_mbr = false;
+			(void) fprintf(stdout, gettext("master boot sector "
+			    "not updated\n"));
+		}
+	}
+	if (write_mbr)
+		(void) printf("%s is newer than one in %s\n",
+		    plist->pl_src_name, plist->pl_devname);
+	return (write_mbr);
+}
+
+/*
+ * VBR setup is always done.
+ */
+static bool
+compare_stage1_cb(struct partlist *plist)
+{
+	(void) printf("%s will be written to %s\n", plist->pl_src_name,
+	    plist->pl_devname);
+	return (true);
+}
+
+/*
+ * Return true if we can update, false if not.
+ */
+static bool
+compare_einfo_cb(struct partlist *plist)
+{
+	ib_bootblock_t *bblock, *bblock_file;
+	bblk_einfo_t *einfo, *einfo_file;
+	bblk_hs_t bblock_hs;
+	bool rv;
+
+	bblock = plist->pl_stage;
+	if (bblock == NULL || bblock->extra == NULL || bblock->extra_size == 0)
+		return (true);
+
+	einfo = find_einfo(bblock->extra, bblock->extra_size);
+	if (einfo == NULL) {
+		BOOT_DEBUG("No extended information available on disk\n");
+		return (true);
+	}
+
+	bblock_file = plist->pl_src_data;
+	einfo_file = find_einfo(bblock_file->extra, bblock_file->extra_size);
+	if (einfo_file == NULL) {
+		/*
+		 * loader bootblock is versioned. missing version means
+		 * probably incompatible block. installboot can not install
+		 * grub, for example.
+		 */
 		(void) fprintf(stderr,
-		    gettext("Unable to find multiboot header\n"));
-		goto outfd;
+		    gettext("ERROR: non versioned bootblock in file\n"));
+		return (false);
+	} else {
+		if (update_str == NULL) {
+			update_str = einfo_get_string(einfo_file);
+			do_version = true;
+		}
 	}
 
-	bblock->mboot = (multiboot_header_t *)(bblock->file + mboot_off);
-	bblock->mboot_off = mboot_off;
+	if (!do_version || update_str == NULL) {
+		(void) fprintf(stderr,
+		    gettext("WARNING: target device %s has a "
+		    "versioned bootblock that is going to be overwritten by a "
+		    "non versioned one\n"), plist->pl_devname);
+		return (true);
+	}
 
-	bblock->file_size =
-	    bblock->mboot->load_end_addr - bblock->mboot->load_addr;
-	BOOT_DEBUG("bootblock file size is %d\n", bblock->file_size);
+	if (force_update) {
+		BOOT_DEBUG("Forcing update of %s bootblock\n",
+		    plist->pl_devname);
+		return (true);
+	}
 
-	bblock->extra = bblock->buf + P2ROUNDUP(bblock->file_size, 8);
-	bblock->extra_size = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);
+	BOOT_DEBUG("Ready to check installed version vs %s\n", update_str);
 
-	BOOT_DEBUG("mboot at %p offset %d, extra at %p size %d, buf=%p "
-	    "(size=%d)\n", bblock->mboot, bblock->mboot_off, bblock->extra,
-	    bblock->extra_size, bblock->buf, bblock->buf_size);
+	bblock_hs.src_buf = (unsigned char *)bblock_file->file;
+	bblock_hs.src_size = bblock_file->file_size;
+
+	rv = einfo_should_update(einfo, &bblock_hs, update_str);
+	if (rv == false) {
+		(void) fprintf(stderr, gettext("\nBootblock version installed "
+		    "on %s is more recent or identical to\n%s\n"
+		    "Use -F to override or install without the -u option.\n"),
+		    plist->pl_devname, plist->pl_src_name);
+	} else {
+		(void) printf("%s is newer than one in %s\n",
+		    plist->pl_src_name, plist->pl_devname);
+	}
+	return (rv);
+}
+
+static bool
+read_stage1_cb(struct partlist *plist)
+{
+	int fd;
+	bool rv = false;
+
+	if ((fd = open_device(plist->pl_devname)) == -1)
+		return (rv);
+
+	if (plist->pl_stage == NULL)
+		plist->pl_stage = calloc(1, sector_size);
 
+	if (plist->pl_stage == NULL) {
+		perror("calloc");
+		goto done;
+	}
+
+	if (pread(fd, plist->pl_stage, sector_size, 0) == -1) {
+		perror("pread");
+		goto done;
+	}
+	rv = true;
+done:
 	(void) close(fd);
-	return (BC_SUCCESS);
+	return (rv);
+}
 
-outbuf:
-	(void) free(bblock->buf);
-	bblock->buf = NULL;
-outfd:
+static bool
+read_stage1_bbl_cb(struct partlist *plist)
+{
+	int fd;
+	void *data;
+	bool rv = false;
+
+	data = malloc(SECTOR_SIZE);
+	if (data == NULL)
+		return (rv);
+
+	/* read the stage1 file from filesystem */
+	fd = open(plist->pl_src_name, O_RDONLY);
+	if (fd == -1 ||
+	    read(fd, data, SECTOR_SIZE) != SECTOR_SIZE) {
+		(void) fprintf(stderr, gettext("cannot read stage1 file %s\n"),
+		    plist->pl_src_name);
+		free(data);
+		if (fd != -1)
+			(void) close(fd);
+		return (rv);
+	}
+
+	plist->pl_src_data = data;
 	(void) close(fd);
-out:
-	return (retval);
+	return (true);
 }
 
-static int
-read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *bblock,
-    char **path)
+static bool
+read_stage2_cb(struct partlist *plist)
 {
-	int			dev_fd;
+	ib_device_t		*device;
+	ib_bootblock_t		*bblock;
+	int			fd;
 	uint32_t		size, offset;
 	uint32_t		buf_size;
 	uint32_t		mboot_off;
 	multiboot_header_t	*mboot;
 
-	assert(device != NULL);
-	assert(bblock != NULL);
+	bblock = calloc(1, sizeof (ib_bootblock_t));
+	if (bblock == NULL)
+		return (false);
 
-	if (device->target.fstype == IG_FS_ZFS) {
-		dev_fd = device->target.fd;
-		offset = BBLK_ZFS_BLK_OFF * SECTOR_SIZE;
-		*path = device->target.path;
-	} else {
-		dev_fd = device->stage.fd;
-		offset = device->stage.offset * SECTOR_SIZE;
-		*path = device->stage.path;
+	if ((fd = open_device(plist->pl_devname)) == -1) {
+		free(bblock);
+		return (false);
 	}
 
-	if (read_in(dev_fd, mboot_scan, sizeof (mboot_scan), offset)
+	device = plist->pl_device;
+	plist->pl_stage = bblock;
+	offset = device->stage.offset * SECTOR_SIZE;
+
+	if (read_in(fd, mboot_scan, sizeof (mboot_scan), offset)
 	    != BC_SUCCESS) {
 		BOOT_DEBUG("Error reading bootblock area\n");
 		perror("read");
-		return (BC_ERROR);
+		(void) close(fd);
+		return (false);
 	}
 
 	/* No multiboot means no chance of knowing bootblock size */
 	if (find_multiboot(mboot_scan, sizeof (mboot_scan), &mboot_off)
 	    != BC_SUCCESS) {
 		BOOT_DEBUG("Unable to find multiboot header\n");
-		return (BC_NOEXTRA);
+		(void) close(fd);
+		return (false);
 	}
 	mboot = (multiboot_header_t *)(mboot_scan + mboot_off);
 
@@ -277,8 +627,10 @@ read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *bblock,
 	 * make sure mboot has sane values
 	 */
 	if (mboot->load_end_addr == 0 ||
-	    mboot->load_end_addr < mboot->load_addr)
-		return (BC_NOEXTRA);
+	    mboot->load_end_addr < mboot->load_addr) {
+		(void) close(fd);
+		return (false);
+	}
 
 	/*
 	 * Currently, the amount of space reserved for extra information
@@ -294,15 +646,17 @@ read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *bblock,
 		BOOT_DEBUG("Unable to allocate enough memory to read"
 		    " the extra bootblock from the disk\n");
 		perror(gettext("Memory allocation failure"));
-		return (BC_ERROR);
+		(void) close(fd);
+		return (false);
 	}
 	bblock->buf_size = buf_size;
 
-	if (read_in(dev_fd, bblock->buf, buf_size, offset) != BC_SUCCESS) {
+	if (read_in(fd, bblock->buf, buf_size, offset) != BC_SUCCESS) {
 		BOOT_DEBUG("Error reading the bootblock\n");
 		(void) free(bblock->buf);
 		bblock->buf = NULL;
-		return (BC_ERROR);
+		(void) close(fd);
+		return (false);
 	}
 
 	/* Update pointers. */
@@ -316,468 +670,643 @@ read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *bblock,
 	    "(size=%d)\n", bblock->mboot, bblock->mboot_off, bblock->extra,
 	    bblock->extra_size, bblock->buf, bblock->buf_size);
 
-	return (BC_SUCCESS);
+	return (true);
 }
 
-static boolean_t
-is_update_necessary(ib_data_t *data, char *updt_str)
+static bool
+read_einfo_file_cb(struct partlist *plist)
 {
-	bblk_einfo_t	*einfo;
-	bblk_einfo_t	*einfo_file;
-	bblk_hs_t	bblock_hs;
-	ib_bootblock_t	bblock_disk;
-	ib_bootblock_t	*bblock_file = &data->bootblock;
-	ib_device_t	*device = &data->device;
-	int		ret;
-	char		*path;
+	plist->pl_stage = calloc(1, sizeof (ib_bootblock_t));
+	if (plist->pl_stage == NULL)
+		return (false);
 
-	assert(data != NULL);
+	return (read_bootblock_from_file(plist->pl_devname,
+	    plist->pl_stage) == BC_SUCCESS);
+}
 
-	bzero(&bblock_disk, sizeof (ib_bootblock_t));
+static bool
+read_stage2_file_cb(struct partlist *plist)
+{
+	plist->pl_src_data = calloc(1, sizeof (ib_bootblock_t));
+	if (plist->pl_src_data == NULL)
+		return (false);
 
-	ret = read_bootblock_from_disk(device, &bblock_disk, &path);
-	if (ret != BC_SUCCESS) {
-		BOOT_DEBUG("Unable to read bootblock from %s\n", path);
-		return (B_TRUE);
+	return (read_bootblock_from_file(plist->pl_src_name,
+	    plist->pl_src_data) == BC_SUCCESS);
+}
+
+/*
+ * convert /dev/rdsk/... to /dev/dsk/...
+ */
+static char *
+make_blkdev(const char *path)
+{
+	char *tmp;
+	char *ptr = strdup(path);
+
+	if (ptr == NULL)
+		return (ptr);
+
+	tmp = strstr(ptr, "rdsk");
+	if (tmp == NULL) {
+		free(ptr);
+		return (NULL); /* Something is very wrong */
 	}
+	/* This is safe because we do shorten the string */
+	(void) memmove(tmp, tmp + 1, strlen(tmp));
+	return (ptr);
+}
 
-	einfo = find_einfo(bblock_disk.extra, bblock_disk.extra_size);
-	if (einfo == NULL) {
-		BOOT_DEBUG("No extended information available on disk\n");
-		return (B_TRUE);
+/*
+ * Try to mount ESP and read boot program.
+ */
+static bool
+read_einfo_esp_cb(struct partlist *plist)
+{
+	fstyp_handle_t fhdl;
+	const char *fident;
+	char *blkdev, *path, *file;
+	bool rv = false;
+	FILE *fp;
+	struct mnttab mp, mpref = { 0 };
+	int fd, ret;
+
+	if ((fd = open_device(plist->pl_devname)) == -1)
+		return (rv);
+
+	if (fstyp_init(fd, 0, NULL, &fhdl) != 0) {
+		(void) close(fd);
+		return (rv);
 	}
 
-	einfo_file = find_einfo(bblock_file->extra, bblock_file->extra_size);
-	if (einfo_file == NULL) {
-		/*
-		 * loader bootblock is versioned. missing version means
-		 * probably incompatible block. installboot can not install
-		 * grub, for example.
-		 */
-		(void) fprintf(stderr,
-		    gettext("ERROR: non versioned bootblock in file\n"));
-		return (B_FALSE);
-	} else {
-		if (updt_str == NULL) {
-			updt_str = einfo_get_string(einfo_file);
-			do_version = B_TRUE;
-		}
+	if (fstyp_ident(fhdl, NULL, &fident) != 0) {
+		fstyp_fini(fhdl);
+		(void) close(fd);
+		(void) fprintf(stderr, gettext("Failed to detect file "
+		    "system type\n"));
+		return (rv);
 	}
 
-	if (!do_version || updt_str == NULL) {
+	/* We only do expect pcfs. */
+	if (strcmp(fident, MNTTYPE_PCFS) != 0) {
 		(void) fprintf(stderr,
-		    gettext("WARNING: target device %s has a "
-		    "versioned bootblock that is going to be overwritten by a "
-		    "non versioned one\n"), device->path);
-		return (B_TRUE);
+		    gettext("File system %s is not supported.\n"), fident);
+		fstyp_fini(fhdl);
+		(void) close(fd);
+		return (rv);
 	}
+	fstyp_fini(fhdl);
+	(void) close(fd);
 
-	if (force_update) {
-		BOOT_DEBUG("Forcing update of %s bootblock\n", device->path);
-		return (B_TRUE);
+	blkdev = make_blkdev(plist->pl_devname);
+	if (blkdev == NULL)
+		return (rv);
+
+	/* mount ESP if needed, read boot program(s) and unmount. */
+	fp = fopen(MNTTAB, "r");
+	if (fp == NULL) {
+		perror("fopen");
+		free(blkdev);
+		return (rv);
 	}
 
-	BOOT_DEBUG("Ready to check installed version vs %s\n", updt_str);
+	mpref.mnt_special = blkdev;
+	ret = getmntany(fp, &mp, &mpref);
+	(void) fclose(fp);
+	if (ret == 0)
+		path = mp.mnt_mountp;
+	else
+		path = stagefs_mount(blkdev, plist);
 
-	bblock_hs.src_buf = (unsigned char *)bblock_file->file;
-	bblock_hs.src_size = bblock_file->file_size;
+	free(blkdev);
+	if (path == NULL)
+		return (rv);
+
+	if (asprintf(&file, "%s%s", path, plist->pl_device->stage.path) < 0) {
+		return (rv);
+	}
 
-	return (einfo_should_update(einfo, &bblock_hs, updt_str));
+	plist->pl_stage = calloc(1, sizeof (ib_bootblock_t));
+	if (plist->pl_stage == NULL) {
+		free(file);
+		return (rv);
+	}
+	if (read_bootblock_from_file(file, plist->pl_stage) != BC_SUCCESS) {
+		free(plist->pl_stage);
+		plist->pl_stage = NULL;
+	} else {
+		rv = true;
+	}
+
+	free(file);
+	return (rv);
 }
 
 static void
-add_bootblock_einfo(ib_bootblock_t *bblock, char *updt_str)
+print_stage1_cb(struct partlist *plist)
 {
-	bblk_hs_t	hs;
-	uint32_t	avail_space;
+	struct mboot *mbr;
+	struct ipart *part;
+	mbr_type_t type = MBR_TYPE_UNKNOWN;
+	bool pmbr = false;
+	char *label;
 
-	assert(bblock != NULL);
+	mbr = plist->pl_stage;
 
-	if (updt_str == NULL) {
-		BOOT_DEBUG("WARNING: no update string passed to "
-		    "add_bootblock_einfo()\n");
-		return;
+	if (*((uint16_t *)&mbr->bootinst[GRUB_VERSION_OFF]) == GRUB_VERSION) {
+		type = MBR_TYPE_GRUB1;
+	} else if (mbr->bootinst[STAGE1_MBR_VERSION] == LOADER_VERSION) {
+		type = MBR_TYPE_LOADER;
+	} else if (mbr->bootinst[STAGE1_MBR_VERSION] == LOADER_JOYENT_VERSION) {
+		type = MBR_TYPE_LOADER_JOYENT;
 	}
 
-	/* Fill bootblock hashing source information. */
-	hs.src_buf = (unsigned char *)bblock->file;
-	hs.src_size = bblock->file_size;
-	/* How much space for the extended information structure? */
-	avail_space = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);
-	/* Place the extended information structure. */
-	add_einfo(bblock->extra, updt_str, &hs, avail_space);
-}
+	part = (struct ipart *)mbr->parts;
+	for (int i = 0; i < FD_NUMPART; i++) {
+		if (part[i].systid == EFI_PMBR)
+			pmbr = true;
+	}
 
-/*
- * set up data for case stage1 is installed as MBR
- * set up location and size of bootblock
- * set disk guid to provide unique information for biosdev command
- */
-static int
-prepare_stage1(ib_data_t *data)
-{
-	ib_device_t	*device;
+	if (plist->pl_type == IB_BBLK_MBR)
+		label = pmbr ? "PMBR" : "MBR";
+	else
+		label = "VBR";
 
-	assert(data != NULL);
-	device = &data->device;
+	printf("%s block from %s:\n", label, plist->pl_devname);
 
-	/* copy BPB */
-	bcopy(device->mbr + STAGE1_BPB_OFFSET,
-	    data->stage1 + STAGE1_BPB_OFFSET, STAGE1_BPB_SIZE);
+	switch (type) {
+	case MBR_TYPE_UNKNOWN:
+		printf("Format: unknown\n");
+		break;
+	case MBR_TYPE_GRUB1:
+		printf("Format: grub1\n");
+		break;
+	case MBR_TYPE_LOADER:
+		printf("Format: loader (illumos)\n");
+		break;
+	case MBR_TYPE_LOADER_JOYENT:
+		printf("Format: loader (joyent)\n");
+		break;
+	}
 
+	printf("Signature: 0x%hx (%s)\n", mbr->signature,
+	    mbr->signature == MBB_MAGIC ? "valid" : "invalid");
 
-	/* copy MBR, note STAGE1_SIG == BOOTSZ */
-	bcopy(device->mbr + STAGE1_SIG, data->stage1 + STAGE1_SIG,
-	    SECTOR_SIZE - STAGE1_SIG);
+	printf("UniqueMBRDiskSignature: %#lx\n",
+	    *(uint32_t *)&mbr->bootinst[STAGE1_SIG]);
 
-	/* set stage2 size */
-	*((uint16_t *)(data->stage1 + STAGE1_STAGE2_SIZE)) =
-	    (uint16_t)(data->bootblock.buf_size / SECTOR_SIZE);
+	if (type == MBR_TYPE_LOADER || type == MBR_TYPE_LOADER_JOYENT) {
+		char uuid[UUID_PRINTABLE_STRING_LENGTH];
 
-	/*
-	 * set stage2 location.
-	 * for zfs always use zfs embedding, for ufs/pcfs use partition_start
-	 * as base for stage2 location, for ufs/pcfs in MBR partition, use
-	 * free space after MBR record.
-	 */
-	if (device->target.fstype == IG_FS_ZFS)
-		*((uint64_t *)(data->stage1 + STAGE1_STAGE2_LBA)) =
-		    device->target.start + device->target.offset;
-	else {
-		*((uint64_t *)(data->stage1 + STAGE1_STAGE2_LBA)) =
-		    device->stage.start + device->stage.offset;
-	}
+		printf("Loader STAGE1_STAGE2_LBA: %llu\n",
+		    *(uint64_t *)&mbr->bootinst[STAGE1_STAGE2_LBA]);
 
-	/*
-	 * set disk uuid. we only need reasonable amount of uniqueness
-	 * to allow biosdev to identify disk based on mbr differences.
-	 */
-	uuid_generate(data->stage1 + STAGE1_STAGE2_UUID);
+		printf("Loader STAGE1_STAGE2_SIZE: %hu\n",
+		    *(uint16_t *)&mbr->bootinst[STAGE1_STAGE2_SIZE]);
 
-	return (BC_SUCCESS);
+		uuid_unparse((uchar_t *)&mbr->bootinst[STAGE1_STAGE2_UUID],
+		    uuid);
+
+		printf("Loader STAGE1_STAGE2_UUID: %s\n", uuid);
+	}
+	printf("\n");
 }
 
-static int
-prepare_bootblock(ib_data_t *data, char *updt_str)
+static void
+print_einfo_cb(struct partlist *plist)
 {
-	ib_bootblock_t		*bblock;
-	ib_device_t		*device;
-	uint64_t		*ptr;
+	uint8_t flags = 0;
+	ib_bootblock_t *bblock;
+	bblk_einfo_t *einfo = NULL;
+	const char *filepath;
+
+	/* No stage, get out. */
+	bblock = plist->pl_stage;
+	if (bblock == NULL)
+		return;
 
-	assert(data != NULL);
+	if (plist->pl_device->stage.path == NULL)
+		filepath = "";
+	else
+		filepath = plist->pl_device->stage.path;
 
-	bblock = &data->bootblock;
-	device = &data->device;
+	printf("Boot block from %s:%s\n", plist->pl_devname, filepath);
 
-	ptr = (uint64_t *)(&bblock->mboot->bss_end_addr);
-	*ptr = device->target.start;
+	if (bblock->extra != NULL)
+		einfo = find_einfo(bblock->extra, bblock->extra_size);
 
-	/*
-	 * the loader bootblock has built in version, if custom
-	 * version was provided, update it.
-	 */
-	if (do_version)
-		add_bootblock_einfo(bblock, updt_str);
+	if (einfo == NULL) {
+		(void) fprintf(stderr,
+		    gettext("No extended information found.\n\n"));
+		return;
+	}
 
-	return (BC_SUCCESS);
+	/* Print the extended information. */
+	if (strip)
+		flags |= EINFO_EASY_PARSE;
+	if (verbose_dump)
+		flags |= EINFO_PRINT_HEADER;
+
+	print_einfo(flags, einfo, bblock->extra_size);
+	printf("\n");
 }
 
-static int
-write_bootblock(ib_data_t *data)
+static size_t
+get_media_info(int fd)
 {
-	ib_device_t	*device = &data->device;
-	ib_bootblock_t	*bblock = &data->bootblock;
-	uint64_t abs;
-	int dev_fd, ret;
-	off_t offset;
-	char *path;
+	struct dk_minfo disk_info;
 
-	assert(data != NULL);
+	if ((ioctl(fd, DKIOCGMEDIAINFO, (caddr_t)&disk_info)) == -1)
+		return (SECTOR_SIZE);
 
-	/*
-	 * ZFS bootblock area is 3.5MB, make sure we can fit.
-	 * buf_size is size of bootblk+EINFO.
-	 */
-	if (bblock->buf_size > BBLK_ZFS_BLK_SIZE) {
-		(void) fprintf(stderr, gettext("bootblock is too large\n"));
-		return (BC_ERROR);
+	return (disk_info.dki_lbsize);
+}
+
+static struct partlist *
+partlist_alloc(void)
+{
+	struct partlist *pl;
+
+	if ((pl = calloc(1, sizeof (*pl))) == NULL) {
+		perror("calloc");
+		return (NULL);
 	}
 
-	if (device->target.fstype == IG_FS_ZFS) {
-		dev_fd = device->target.fd;
-		abs = device->target.start + device->target.offset;
-		offset = BBLK_ZFS_BLK_OFF * SECTOR_SIZE;
-		path = device->target.path;
-	} else {
-		dev_fd = device->stage.fd;
-		abs = device->stage.start + device->stage.offset;
-		offset = device->stage.offset * SECTOR_SIZE;
-		path = device->stage.path;
-		if (bblock->buf_size >
-		    (device->stage.size - device->stage.offset) * SECTOR_SIZE) {
-			(void) fprintf(stderr, gettext("Device %s is "
-			    "too small to fit the stage2\n"), path);
-			return (BC_ERROR);
+	pl->pl_device = calloc(1, sizeof (*pl->pl_device));
+	if (pl->pl_device == NULL) {
+		perror("calloc");
+		free(pl);
+		return (NULL);
+	}
+
+	return (pl);
+}
+
+static void
+partlist_free(struct partlist *pl)
+{
+	ib_bootblock_t *bblock;
+	ib_device_t *device;
+
+	switch (pl->pl_type) {
+	case IB_BBLK_MBR:
+	case IB_BBLK_STAGE1:
+		free(pl->pl_stage);
+		break;
+	default:
+		if (pl->pl_stage != NULL) {
+			bblock = pl->pl_stage;
+			free(bblock->buf);
+			free(bblock);
 		}
 	}
-	ret = write_out(dev_fd, bblock->buf, bblock->buf_size, offset);
-	if (ret != BC_SUCCESS) {
-		BOOT_DEBUG("Error writing the ZFS bootblock "
-		    "to %s at offset %d\n", path, offset);
-		return (BC_ERROR);
+
+	/* umount the stage fs. */
+	if (pl->pl_device->stage.mntpnt != NULL) {
+		if (umount(pl->pl_device->stage.mntpnt) == 0)
+			(void) rmdir(pl->pl_device->stage.mntpnt);
+		free(pl->pl_device->stage.mntpnt);
 	}
+	device = pl->pl_device;
+	free(device->target.path);
+	free(pl->pl_device);
 
-	(void) fprintf(stdout, gettext("bootblock written for %s,"
-	    " %d sectors starting at %d (abs %lld)\n"), path,
-	    (bblock->buf_size / SECTOR_SIZE) + 1, offset / SECTOR_SIZE, abs);
+	free(pl->pl_src_data);
+	free(pl->pl_devname);
+	free(pl);
+}
 
-	return (BC_SUCCESS);
+static bool
+probe_fstyp(ib_data_t *data)
+{
+	fstyp_handle_t fhdl;
+	const char *fident;
+	char *ptr;
+	int fd;
+	bool rv = false;
+
+	/* Record partition id */
+	ptr = strrchr(data->target.path, 'p');
+	if (ptr == NULL)
+		ptr = strrchr(data->target.path, 's');
+	data->target.id = atoi(++ptr);
+	if ((fd = open_device(data->target.path)) == -1)
+		return (rv);
+
+	if (fstyp_init(fd, 0, NULL, &fhdl) != 0) {
+		(void) close(fd);
+		return (rv);
+	}
+
+	if (fstyp_ident(fhdl, NULL, &fident) != 0) {
+		fstyp_fini(fhdl);
+		(void) fprintf(stderr, gettext("Failed to detect file "
+		    "system type\n"));
+		(void) close(fd);
+		return (rv);
+	}
+
+	rv = true;
+	if (strcmp(fident, MNTTYPE_ZFS) == 0)
+		data->target.fstype = IB_FS_ZFS;
+	else if (strcmp(fident, MNTTYPE_UFS) == 0) {
+		data->target.fstype = IB_FS_UFS;
+	} else if (strcmp(fident, MNTTYPE_PCFS) == 0) {
+		data->target.fstype = IB_FS_PCFS;
+	} else {
+		(void) fprintf(stderr, gettext("File system %s is not "
+		    "supported by loader\n"), fident);
+		rv = false;
+	}
+	fstyp_fini(fhdl);
+	(void) close(fd);
+	return (rv);
 }
 
-/*
- * Partition boot block or volume boot record (VBR). The VBR is
- * stored on partition relative sector 0 and allows chainloading
- * to read boot program from partition.
- *
- * As the VBR will use the first sector of the partition,
- * this means, we need to be sure the space is not used.
- * We do support three partitioning chemes:
- * 1. GPT: zfs and ufs have reserved space for first 8KB, but
- *	only zfs does have space for boot2. The pcfs has support
- *	for VBR, but no space for boot2. So with GPT, to support
- *	ufs or pcfs boot, we must have separate dedicated boot
- *	partition and we will store VBR on it.
- * 2. MBR: we have almost the same situation as with GPT, except that
- *	if the partitions start from cylinder 1, we will have space
- *	between MBR and cylinder 0. If so, we do not require separate
- *	boot partition.
- * 3. MBR+VTOC: with this combination we store VBR in sector 0 of the
- *	solaris2 MBR partition. The slice 0 will start from cylinder 1,
- *	and we do have space for boot2, so we do not require separate
- *	boot partition.
- */
-static int
-write_stage1(ib_data_t *data)
+static bool
+get_slice(ib_data_t *data, struct partlist *pl, struct dk_gpt *vtoc,
+    uint16_t tag)
 {
-	ib_device_t	*device = &data->device;
-	uint64_t	start = 0;
+	uint_t i;
+	ib_device_t *device = pl->pl_device;
+	char *path, *ptr;
 
-	assert(data != NULL);
+	if (tag != V_BOOT && tag != V_SYSTEM)
+		return (false);
 
-	/*
-	 * We have separate partition for boot programs and the stage1
-	 * location is not absolute sector 0.
-	 * We will write VBR and trigger MBR to read 1 sector from VBR.
-	 * This case does also cover MBR+VTOC case, as the solaris 2 partition
-	 * name and the root file system slice names are different.
-	 */
-	if (device->stage.start != 0 &&
-	    strcmp(device->target.path, device->stage.path)) {
-		/* we got separate stage area, use it */
-		if (write_out(device->stage.fd, data->stage1,
-		    sizeof (data->stage1), 0) != BC_SUCCESS) {
-			(void) fprintf(stdout, gettext("cannot write "
-			    "partition boot sector\n"));
-			perror("write");
-			return (BC_ERROR);
+	for (i = 0; i < vtoc->efi_nparts; i++) {
+		if (vtoc->efi_parts[i].p_tag == tag) {
+			if ((path = strdup(data->target.path)) == NULL) {
+				perror(gettext("Memory allocation failure"));
+				return (false);
+			}
+			ptr = strrchr(path, 's');
+			ptr++;
+			*ptr = '\0';
+			(void) asprintf(&ptr, "%s%d", path, i);
+			free(path);
+			if (ptr == NULL) {
+				perror(gettext("Memory allocation failure"));
+				return (false);
+			}
+			pl->pl_devname = ptr;
+			device->stage.id = i;
+			device->stage.devtype = IB_DEV_EFI;
+			switch (vtoc->efi_parts[i].p_tag) {
+			case V_BOOT:
+				device->stage.fstype = IB_FS_NONE;
+				/* leave sector 0 for VBR */
+				device->stage.offset = 1;
+				break;
+			case V_SYSTEM:
+				device->stage.fstype = IB_FS_PCFS;
+				break;
+			}
+			device->stage.tag = vtoc->efi_parts[i].p_tag;
+			device->stage.start = vtoc->efi_parts[i].p_start;
+			device->stage.size = vtoc->efi_parts[i].p_size;
+			break;
 		}
-
-		(void) fprintf(stdout, gettext("stage1 written to "
-		    "%s %d sector 0 (abs %d)\n"),
-		    device->devtype == IG_DEV_MBR? "partition":"slice",
-		    device->stage.id, device->stage.start);
-		start = device->stage.start;
 	}
+	return (true);
+}
 
-	/*
-	 * We have either GPT or MBR (without VTOC) and if the root
-	 * file system is not pcfs, we can store VBR. Also trigger
-	 * MBR to read 1 sector from VBR.
-	 */
-	if (device->devtype != IG_DEV_VTOC &&
-	    device->target.fstype != IG_FS_PCFS) {
-		if (write_out(device->target.fd, data->stage1,
-		    sizeof (data->stage1), 0) != BC_SUCCESS) {
-			(void) fprintf(stdout, gettext("cannot write "
-			    "partition boot sector\n"));
-			perror("write");
-			return (BC_ERROR);
-		}
+static bool
+allocate_slice(ib_data_t *data, struct dk_gpt *vtoc, uint16_t tag,
+    struct partlist **plp)
+{
+	struct partlist *pl;
 
-		(void) fprintf(stdout, gettext("stage1 written to "
-		    "%s %d sector 0 (abs %d)\n"),
-		    device->devtype == IG_DEV_MBR? "partition":"slice",
-		    device->target.id, device->target.start);
-		start = device->target.start;
-	}
+	*plp = NULL;
+	if ((pl = partlist_alloc()) == NULL)
+		return (false);
 
-	if (write_mbr) {
-		/*
-		 * If we did write partition boot block, update MBR to
-		 * read partition boot block, not boot2.
-		 */
-		if (start != 0) {
-			*((uint16_t *)(data->stage1 + STAGE1_STAGE2_SIZE)) = 1;
-			*((uint64_t *)(data->stage1 + STAGE1_STAGE2_LBA)) =
-			    start;
-		}
-		if (write_out(device->fd, data->stage1,
-		    sizeof (data->stage1), 0) != BC_SUCCESS) {
-			(void) fprintf(stdout,
-			    gettext("cannot write master boot sector\n"));
-			perror("write");
-			return (BC_ERROR);
-		}
-		(void) fprintf(stdout,
-		    gettext("stage1 written to master boot sector\n"));
+	pl->pl_device = calloc(1, sizeof (*pl->pl_device));
+	if (pl->pl_device == NULL) {
+		perror("calloc");
+		partlist_free(pl);
+		return (false);
+	}
+	if (!get_slice(data, pl, vtoc, tag)) {
+		partlist_free(pl);
+		return (false);
 	}
 
-	return (BC_SUCCESS);
+	/* tag was not found */
+	if (pl->pl_devname == NULL)
+		partlist_free(pl);
+	else
+		*plp = pl;
+
+	return (true);
 }
 
-/*
- * find partition/slice start sector. will be recorded in stage2 and used
- * by stage2 to identify partition with boot file system.
- */
-static int
-get_start_sector(ib_device_t *device)
+static bool
+probe_gpt(ib_data_t *data)
 {
-	uint32_t		secnum = 0, numsec = 0;
-	int			i, pno, rval, log_part = 0;
-	struct mboot		*mboot;
-	struct ipart		*part = NULL;
-	ext_part_t		*epp;
-	struct part_info	dkpi;
-	struct extpart_info	edkpi;
-
-	if (device->devtype == IG_DEV_EFI) {
-		struct dk_gpt *vtoc;
-
-		if (efi_alloc_and_read(device->fd, &vtoc) < 0)
-			return (BC_ERROR);
-
-		if (device->stage.start == 0) {
-			/* zero size means the fstype must be zfs */
-			assert(device->target.fstype == IG_FS_ZFS);
-
-			device->stage.start =
-			    vtoc->efi_parts[device->stage.id].p_start;
-			device->stage.size =
-			    vtoc->efi_parts[device->stage.id].p_size;
-			device->stage.offset = BBLK_ZFS_BLK_OFF;
-			device->target.offset = BBLK_ZFS_BLK_OFF;
-		}
+	struct partlist *pl;
+	struct dk_gpt *vtoc;
+	ib_device_t *device;
+	int slice, fd;
+	bool rv = false;
 
-		device->target.start =
-		    vtoc->efi_parts[device->target.id].p_start;
-		device->target.size =
-		    vtoc->efi_parts[device->target.id].p_size;
+	if ((fd = open_device(data->target.path)) < 0)
+		return (rv);
 
-		/* with pcfs we always write MBR */
-		if (device->target.fstype == IG_FS_PCFS) {
-			force_mbr = 1;
-			write_mbr = 1;
-		}
+	slice = efi_alloc_and_read(fd, &vtoc);
+	(void) close(fd);
+	if (slice < 0)
+		return (rv);
+
+	data->device.devtype = IB_DEV_EFI;
+	data->target.start = vtoc->efi_parts[slice].p_start;
+	data->target.size = vtoc->efi_parts[slice].p_size;
+
+	/* Always update PMBR. */
+	force_mbr = 1;
+	write_mbr = 1;
 
-		efi_free(vtoc);
-		goto found_part;
+	/*
+	 * With GPT we can have boot partition and ESP.
+	 * Boot partition can have both stage 1 and stage 2.
+	 */
+	if (!allocate_slice(data, vtoc, V_BOOT, &pl))
+		goto done;
+	if (pl != NULL) {
+		pl->pl_src_name = stage1;
+		pl->pl_type = IB_BBLK_STAGE1;
+		pl->pl_cb.compare = compare_stage1_cb;
+		pl->pl_cb.install = install_stage1_cb;
+		pl->pl_cb.read = read_stage1_cb;
+		pl->pl_cb.read_bbl = read_stage1_bbl_cb;
+		pl->pl_cb.print = print_stage1_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	} else if (data->target.fstype != IB_FS_ZFS) {
+		(void) fprintf(stderr, gettext("Booting %s from EFI "
+		    "labeled disks requires the boot partition.\n"),
+		    data->target.fstype == IB_FS_UFS?
+		    MNTTYPE_UFS : MNTTYPE_PCFS);
+		goto done;
+	}
+	/* Add stage 2 */
+	if (!allocate_slice(data, vtoc, V_BOOT, &pl))
+		goto done;
+	if (pl != NULL) {
+		pl->pl_src_name = stage2;
+		pl->pl_type = IB_BBLK_STAGE2;
+		pl->pl_cb.compare = compare_einfo_cb;
+		pl->pl_cb.install = install_stage2_cb;
+		pl->pl_cb.read = read_stage2_cb;
+		pl->pl_cb.read_bbl = read_stage2_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	}
+
+	/* ESP can have 32- and 64-bit boot code. */
+	if (!allocate_slice(data, vtoc, V_SYSTEM, &pl))
+		goto done;
+	if (pl != NULL) {
+		pl->pl_device->stage.path = "/EFI/Boot/" BOOTIA32;
+		pl->pl_src_name = efi32;
+		pl->pl_type = IB_BBLK_EFI;
+		pl->pl_cb.compare = compare_einfo_cb;
+		pl->pl_cb.install = install_esp_cb;
+		pl->pl_cb.read = read_einfo_esp_cb;
+		pl->pl_cb.read_bbl = read_stage2_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	}
+	if (!allocate_slice(data, vtoc, V_SYSTEM, &pl))
+		goto done;
+	if (pl != NULL) {
+		pl->pl_device->stage.path = "/EFI/Boot/" BOOTX64;
+		pl->pl_src_name = efi64;
+		pl->pl_type = IB_BBLK_EFI;
+		pl->pl_cb.compare = compare_einfo_cb;
+		pl->pl_cb.install = install_esp_cb;
+		pl->pl_cb.read = read_einfo_esp_cb;
+		pl->pl_cb.read_bbl = read_stage2_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	}
+
+	/* add stage for our target file system slice */
+	pl = partlist_alloc();
+	if (pl == NULL)
+		goto done;
+
+	device = pl->pl_device;
+	device->stage.devtype = data->device.devtype;
+	if ((pl->pl_devname = strdup(data->target.path)) == NULL) {
+		perror(gettext("Memory allocation failure"));
+		partlist_free(pl);
+		goto done;
 	}
 
-	mboot = (struct mboot *)device->mbr;
+	device->stage.id = slice;
+	device->stage.start = vtoc->efi_parts[slice].p_start;
+	device->stage.size = vtoc->efi_parts[slice].p_size;
 
-	/* For MBR we have device->stage filled already. */
-	if (device->devtype == IG_DEV_MBR) {
-		/* MBR partition starts from 0 */
-		pno = device->target.id - 1;
-		part = (struct ipart *)mboot->parts + pno;
+	/* ZFS and UFS can have stage1 in boot area. */
+	if (data->target.fstype == IB_FS_ZFS ||
+	    data->target.fstype == IB_FS_UFS) {
+		pl->pl_src_name = stage1;
+		pl->pl_type = IB_BBLK_STAGE1;
+		pl->pl_cb.compare = compare_stage1_cb;
+		pl->pl_cb.install = install_stage1_cb;
+		pl->pl_cb.read = read_stage1_cb;
+		pl->pl_cb.read_bbl = read_stage1_bbl_cb;
+		pl->pl_cb.print = print_stage1_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	}
 
-		if (part->relsect == 0) {
-			(void) fprintf(stderr, gettext("Partition %d of the "
-			    "disk has an incorrect offset\n"),
-			    device->target.id);
-			return (BC_ERROR);
-		}
-		device->target.start = part->relsect;
-		device->target.size = part->numsect;
+	if (data->target.fstype == IB_FS_ZFS) {
+		pl = partlist_alloc();
+		if (pl == NULL)
+			goto done;
 
-		/* with pcfs we always write MBR */
-		if (device->target.fstype == IG_FS_PCFS) {
-			force_mbr = 1;
-			write_mbr = 1;
+		device = pl->pl_device;
+		device->stage.devtype = data->device.devtype;
+
+		if ((pl->pl_devname = strdup(data->target.path)) == NULL) {
+			perror(gettext("Memory allocation failure"));
+			goto done;
 		}
-		if (device->target.fstype == IG_FS_ZFS)
-			device->target.offset = BBLK_ZFS_BLK_OFF;
 
-		goto found_part;
-	}
+		device->stage.id = slice;
+		device->stage.start = vtoc->efi_parts[slice].p_start;
+		device->stage.size = vtoc->efi_parts[slice].p_size;
+
+		device->stage.offset = BBLK_ZFS_BLK_OFF;
+		pl->pl_src_name = stage2;
+		pl->pl_type = IB_BBLK_STAGE2;
+		pl->pl_cb.compare = compare_einfo_cb;
+		pl->pl_cb.install = install_stage2_cb;
+		pl->pl_cb.read = read_stage2_cb;
+		pl->pl_cb.read_bbl = read_stage2_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+	}
+	rv = true;
+done:
+	efi_free(vtoc);
+	return (rv);
+}
 
-	/*
-	 * Search for Solaris fdisk partition
-	 * Get the solaris partition information from the device
-	 * and compare the offset of S2 with offset of solaris partition
-	 * from fdisk partition table.
-	 */
-	if (ioctl(device->target.fd, DKIOCEXTPARTINFO, &edkpi) < 0) {
-		if (ioctl(device->target.fd, DKIOCPARTINFO, &dkpi) < 0) {
+static bool
+get_start_sector(ib_data_t *data, struct extpartition *v_part,
+    diskaddr_t *start)
+{
+	struct partlist *pl;
+	struct mboot *mbr;
+	struct ipart *part;
+	struct part_info dkpi;
+	struct extpart_info edkpi;
+	uint32_t secnum, numsec;
+	ext_part_t *epp;
+	ushort_t i;
+	int fd, rval, pno;
+
+	if ((fd = open_device(data->target.path)) < 0)
+		return (false);
+
+	if (ioctl(fd, DKIOCEXTPARTINFO, &edkpi) < 0) {
+		if (ioctl(fd, DKIOCPARTINFO, &dkpi) < 0) {
 			(void) fprintf(stderr, gettext("cannot get the "
 			    "slice information of the disk\n"));
-			return (BC_ERROR);
+			(void) close(fd);
+			return (false);
 		} else {
 			edkpi.p_start = dkpi.p_start;
 			edkpi.p_length = dkpi.p_length;
 		}
 	}
+	(void) close(fd);
 
-	device->target.start = edkpi.p_start;
-	device->target.size = edkpi.p_length;
-	if (device->target.fstype == IG_FS_ZFS)
-		device->target.offset = BBLK_ZFS_BLK_OFF;
-
-	for (i = 0; i < FD_NUMPART; i++) {
-		part = (struct ipart *)mboot->parts + i;
+	/* Set target file system start and size */
+	data->target.start = edkpi.p_start;
+	data->target.size = edkpi.p_length;
 
-		if (part->relsect == 0) {
-			(void) fprintf(stderr, gettext("Partition %d of the "
-			    "disk has an incorrect offset\n"), i+1);
-			return (BC_ERROR);
-		}
+	/* This is our MBR partition start. */
+	edkpi.p_start -= v_part->p_start;
 
-		if (edkpi.p_start >= part->relsect &&
-		    edkpi.p_start < (part->relsect + part->numsect)) {
-			/* Found the partition */
-			break;
-		}
-	}
+	/* Head is always MBR */
+	pl = STAILQ_FIRST(data->plist);
+	if (!read_stage1_cb(pl))
+		return (false);
 
-	if (i == FD_NUMPART) {
-		/* No solaris fdisk partitions (primary or logical) */
-		(void) fprintf(stderr, gettext("Solaris partition not found. "
-		    "Aborting operation.\n"));
-		return (BC_ERROR);
-	}
+	mbr = (struct mboot *)pl->pl_stage;
+	part = (struct ipart *)mbr->parts;
 
-	/*
-	 * We have found a Solaris fdisk partition (primary or extended)
-	 * Handle the simple case first: Solaris in a primary partition
-	 */
-	if (!fdisk_is_dos_extended(part->systid)) {
-		device->stage.start = part->relsect;
-		device->stage.size = part->numsect;
-		if (device->target.fstype == IG_FS_ZFS)
-			device->stage.offset = BBLK_ZFS_BLK_OFF;
-		else
-			device->stage.offset = BBLK_BLKLIST_OFF;
-		device->stage.id = i + 1;
-		goto found_part;
+	for (i = 0; i < FD_NUMPART; i++) {
+		if (part[i].relsect == edkpi.p_start) {
+			*start = part[i].relsect;
+			return (true);
+		}
 	}
 
-	/*
-	 * Solaris in a logical partition. Find that partition in the
-	 * extended part.
-	 */
-
-	if ((rval = libfdisk_init(&epp, device->path, NULL, FDISK_READ_DISK))
-	    != FDISK_SUCCESS) {
+	rval = libfdisk_init(&epp, pl->pl_devname, part, FDISK_READ_DISK);
+	if (rval != FDISK_SUCCESS) {
 		switch (rval) {
 			/*
 			 * The first 3 cases are not an error per-se, just that
@@ -788,454 +1317,695 @@ get_start_sector(ib_device_t *device)
 			case FDISK_EBADMAGIC:
 				(void) fprintf(stderr, gettext("Solaris "
 				    "partition not found. "
-				    "Aborting operation.\n"));
-				return (BC_ERROR);
+				    "Aborting operation. %d\n"), rval);
+				return (false);
 			case FDISK_ENOVGEOM:
 				(void) fprintf(stderr, gettext("Could not get "
 				    "virtual geometry\n"));
-				return (BC_ERROR);
+				return (false);
 			case FDISK_ENOPGEOM:
 				(void) fprintf(stderr, gettext("Could not get "
 				    "physical geometry\n"));
-				return (BC_ERROR);
+				return (false);
 			case FDISK_ENOLGEOM:
 				(void) fprintf(stderr, gettext("Could not get "
 				    "label geometry\n"));
-				return (BC_ERROR);
+				return (false);
 			default:
 				(void) fprintf(stderr, gettext("Failed to "
 				    "initialize libfdisk.\n"));
-				return (BC_ERROR);
+				return (false);
 		}
 	}
-
 	rval = fdisk_get_solaris_part(epp, &pno, &secnum, &numsec);
 	libfdisk_fini(&epp);
 	if (rval != FDISK_SUCCESS) {
 		/* No solaris logical partition */
 		(void) fprintf(stderr, gettext("Solaris partition not found. "
 		    "Aborting operation.\n"));
-		return (BC_ERROR);
+		return (false);
 	}
+	*start = secnum;
+	return (true);
+}
 
-	device->stage.start = secnum;
-	device->stage.size = numsec;
-	device->stage.id = pno;
-	log_part = 1;
+/*
+ * On x86 the VTOC table is inside MBR partition and to get
+ * absolute sectors, we need to add MBR partition start to VTOC slice start.
+ */
+static bool
+probe_vtoc(ib_data_t *data)
+{
+	struct partlist *pl;
+	struct extvtoc exvtoc;
+	ib_device_t *device;
+	char *path, *ptr;
+	ushort_t i;
+	int slice, fd;
+	diskaddr_t start;
+	bool rv;
 
-found_part:
-	/* get confirmation for -m */
-	if (write_mbr && !force_mbr) {
-		(void) fprintf(stdout, gettext("Updating master boot sector "
-		    "destroys existing boot managers (if any).\n"
-		    "continue (y/n)? "));
-		if (!yes()) {
-			write_mbr = 0;
-			(void) fprintf(stdout, gettext("master boot sector "
-			    "not updated\n"));
-			return (BC_ERROR);
-		}
-	}
+	rv = false;
 
-	/*
-	 * warn, if illumos in primary partition and loader not in MBR and
-	 * partition is not active
-	 */
-	if (device->devtype != IG_DEV_EFI) {
-		if (!log_part && part->bootid != 128 && !write_mbr) {
-			(void) fprintf(stdout, gettext("Solaris fdisk "
-			    "partition is inactive.\n"), device->stage.id);
-		}
-	}
+	if ((fd = open_device(data->target.path)) < 0)
+		return (rv);
 
-	return (BC_SUCCESS);
-}
+	slice = read_extvtoc(fd, &exvtoc);
+	(void) close(fd);
+	if (slice < 0)
+		return (rv);
+	data->device.devtype = IB_DEV_VTOC;
 
-static int
-open_device(char *path)
-{
-	struct stat	statbuf = {0};
-	int		fd = -1;
+	if (!get_start_sector(data, exvtoc.v_part + slice, &start))
+		return (rv);
 
-	if (nowrite)
-		fd = open(path, O_RDONLY);
-	else
-		fd = open(path, O_RDWR);
+	if (exvtoc.v_part[slice].p_tag == V_BACKUP) {
+		/*
+		 * NOTE: we could relax there and allow zfs boot on
+		 * slice 2, but lets keep traditional limits.
+		 */
+		(void) fprintf(stderr, gettext(
+		    "raw device must be a root slice (not backup)\n"));
+		return (rv);
+	}
 
-	if (fd == -1) {
-		BOOT_DEBUG("Unable to open %s\n", path);
-		perror("open");
-		return (-1);
+	if ((path = strdup(data->target.path)) == NULL) {
+		perror(gettext("Memory allocation failure"));
+		return (false);
 	}
 
-	if (fstat(fd, &statbuf) != 0) {
-		BOOT_DEBUG("Unable to stat %s\n", path);
-		perror("stat");
-		(void) close(fd);
-		return (-1);
+	data->target.start = start + exvtoc.v_part[slice].p_start;
+	data->target.size = exvtoc.v_part[slice].p_size;
+
+	/* Search for boot slice. */
+	for (i = 0; i < exvtoc.v_nparts; i++) {
+		if (exvtoc.v_part[i].p_tag == V_BOOT)
+			break;
 	}
 
-	if (S_ISCHR(statbuf.st_mode) == 0) {
-		(void) fprintf(stderr, gettext("%s: Not a character device\n"),
-		    path);
-		(void) close(fd);
-		return (-1);
+	if (i == exvtoc.v_nparts ||
+	    exvtoc.v_part[i].p_size == 0) {
+		/* fall back to slice V_BACKUP */
+		for (i = 0; i < exvtoc.v_nparts; i++) {
+			if (exvtoc.v_part[i].p_tag == V_BACKUP)
+				break;
+		}
+		/* Still nothing? Error out. */
+		if (i == exvtoc.v_nparts ||
+		    exvtoc.v_part[i].p_size == 0) {
+			free(path);
+			return (false);
+		}
 	}
 
-	return (fd);
+	/* Create path. */
+	ptr = strrchr(path, 's');
+	ptr++;
+	*ptr = '\0';
+	(void) asprintf(&ptr, "%s%d", path, i);
+	free(path);
+	if (ptr == NULL) {
+		perror(gettext("Memory allocation failure"));
+		return (false);
+	}
+
+	pl = partlist_alloc();
+	if (pl == NULL) {
+		free(ptr);
+		return (false);
+	}
+	pl->pl_devname = ptr;
+	device = pl->pl_device;
+	device->stage.devtype = data->device.devtype;
+	device->stage.id = i;
+	device->stage.tag = exvtoc.v_part[i].p_tag;
+	device->stage.start = start + exvtoc.v_part[i].p_start;
+	device->stage.size = exvtoc.v_part[i].p_size;
+
+	/* Fix size if this slice is in fact V_BACKUP */
+	if (exvtoc.v_part[i].p_tag == V_BACKUP) {
+		for (i = 0; i < exvtoc.v_nparts; i++) {
+			if (exvtoc.v_part[i].p_start == 0)
+				continue;
+			if (exvtoc.v_part[i].p_size == 0)
+				continue;
+			if (exvtoc.v_part[i].p_start <
+			    device->stage.size)
+				device->stage.size =
+				    exvtoc.v_part[i].p_start;
+		}
+	}
+
+	pl->pl_src_name = stage1;
+	pl->pl_type = IB_BBLK_STAGE1;
+	pl->pl_cb.compare = compare_stage1_cb;
+	pl->pl_cb.install = install_stage1_cb;
+	pl->pl_cb.read = read_stage1_cb;
+	pl->pl_cb.read_bbl = read_stage1_bbl_cb;
+	pl->pl_cb.print = print_stage1_cb;
+	STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+	/* Create instance for stage 2 */
+	pl = partlist_alloc();
+	if (pl == NULL) {
+		free(ptr);
+		return (false);
+	}
+	pl->pl_devname = strdup(ptr);
+	if (pl->pl_devname == NULL) {
+		partlist_free(pl);
+		return (false);
+	}
+	pl->pl_device->stage.devtype = data->device.devtype;
+	pl->pl_device->stage.id = device->stage.id;
+	pl->pl_device->stage.offset = BBLK_BLKLIST_OFF;
+	pl->pl_device->stage.tag = device->stage.tag;
+	pl->pl_device->stage.start = device->stage.start;
+	pl->pl_device->stage.size = device->stage.size;
+	pl->pl_src_name = stage2;
+	pl->pl_type = IB_BBLK_STAGE2;
+	pl->pl_cb.compare = compare_einfo_cb;
+	pl->pl_cb.install = install_stage2_cb;
+	pl->pl_cb.read = read_stage2_cb;
+	pl->pl_cb.read_bbl = read_stage2_file_cb;
+	pl->pl_cb.print = print_einfo_cb;
+	STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+	/* And we are done. */
+	rv = true;
+	return (rv);
 }
 
-static int
-get_boot_partition(ib_device_t *device, struct mboot *mbr)
+static bool
+probe_mbr(ib_data_t *data)
 {
+	struct partlist *pl;
 	struct ipart *part;
+	struct mboot *mbr;
+	ib_device_t *device;
 	char *path, *ptr;
-	int i;
+	int i, rv;
 
+	data->device.devtype = IB_DEV_MBR;
+
+	/* Head is always MBR */
+	pl = STAILQ_FIRST(data->plist);
+	if (!read_stage1_cb(pl))
+		return (false);
+
+	mbr = (struct mboot *)pl->pl_stage;
 	part = (struct ipart *)mbr->parts;
+
+	/* Set target file system start and size */
+	data->target.start = part[data->target.id - 1].relsect;
+	data->target.size = part[data->target.id - 1].numsect;
+
+	/* Use X86BOOT partition if we have one. */
 	for (i = 0; i < FD_NUMPART; i++) {
 		if (part[i].systid == X86BOOT)
 			break;
 	}
 
-	/* no X86BOOT, try to use space between MBR and first partition */
+	/* Keep device name of whole disk device. */
+	path = (char *)pl->pl_devname;
+	if ((pl = partlist_alloc()) == NULL)
+		return (false);
+	device = pl->pl_device;
+
+	/*
+	 * No X86BOOT, try to use space between MBR and first
+	 * partition.
+	 */
 	if (i == FD_NUMPART) {
-		device->stage.path = strdup(device->path);
-		if (device->stage.path == NULL) {
+		/* with pcfs we always write MBR */
+		if (data->target.fstype == IB_FS_PCFS) {
+			force_mbr = true;
+			write_mbr = true;
+		}
+
+		pl->pl_devname = strdup(path);
+		if (pl->pl_devname == NULL) {
 			perror(gettext("Memory allocation failure"));
-			return (BC_ERROR);
+			partlist_free(pl);
+			return (false);
 		}
-		device->stage.fd = dup(device->fd);
 		device->stage.id = 0;
-		device->stage.devtype = IG_DEV_MBR;
-		device->stage.fstype = IG_FS_NONE;
+		device->stage.devtype = IB_DEV_MBR;
+		device->stage.fstype = IB_FS_NONE;
 		device->stage.start = 0;
 		device->stage.size = part[0].relsect;
 		device->stage.offset = BBLK_BLKLIST_OFF;
-		return (BC_SUCCESS);
+		pl->pl_src_name = stage2;
+		pl->pl_type = IB_BBLK_STAGE2;
+		pl->pl_cb.compare = compare_einfo_cb;
+		pl->pl_cb.install = install_stage2_cb;
+		pl->pl_cb.read = read_stage2_cb;
+		pl->pl_cb.read_bbl = read_stage2_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+		/* We have MBR for stage1 and gap for stage2, we are done. */
+		return (true);
 	}
 
-	if ((path = strdup(device->path)) == NULL) {
+	if ((path = strdup(path)) == NULL) {
 		perror(gettext("Memory allocation failure"));
-		return (BC_ERROR);
+		partlist_free(pl);
+		return (false);
 	}
-
 	ptr = strrchr(path, 'p');
 	ptr++;
 	*ptr = '\0';
-	(void) asprintf(&ptr, "%s%d", path, i+1); /* partitions are p1..p4 */
+	/* partitions are p1..p4 */
+	rv = asprintf(&ptr, "%s%d", path, i + 1);
 	free(path);
-	if (ptr == NULL) {
+	if (rv < 0) {
 		perror(gettext("Memory allocation failure"));
-		return (BC_ERROR);
+		partlist_free(pl);
+		return (false);
 	}
-	device->stage.path = ptr;
-	device->stage.fd = open_device(ptr);
+	pl->pl_devname = ptr;
 	device->stage.id = i + 1;
-	device->stage.devtype = IG_DEV_MBR;
-	device->stage.fstype = IG_FS_NONE;
+	device->stage.devtype = IB_DEV_MBR;
+	device->stage.fstype = IB_FS_NONE;
 	device->stage.start = part[i].relsect;
 	device->stage.size = part[i].numsect;
-	device->stage.offset = 1; /* leave sector 0 for VBR */
-	return (BC_SUCCESS);
+	pl->pl_src_name = stage1;
+	pl->pl_type = IB_BBLK_STAGE1;
+	pl->pl_cb.compare = compare_stage1_cb;
+	pl->pl_cb.install = install_stage1_cb;
+	pl->pl_cb.read = read_stage1_cb;
+	pl->pl_cb.read_bbl = read_stage1_bbl_cb;
+	pl->pl_cb.print = print_stage1_cb;
+	STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+	pl = partlist_alloc();
+	if (pl == NULL)
+		return (false);
+	device = pl->pl_device;
+	pl->pl_devname = strdup(ptr);
+	if (pl->pl_devname == NULL) {
+		perror(gettext("Memory allocation failure"));
+		partlist_free(pl);
+		return (false);
+	}
+	device->stage.id = i + 1;
+	device->stage.devtype = IB_DEV_MBR;
+	device->stage.fstype = IB_FS_NONE;
+	device->stage.start = part[i].relsect;
+	device->stage.size = part[i].numsect;
+	device->stage.offset = 1;
+	/* This is boot partition */
+	device->stage.tag = V_BOOT;
+	pl->pl_src_name = stage2;
+	pl->pl_type = IB_BBLK_STAGE2;
+	pl->pl_cb.compare = compare_einfo_cb;
+	pl->pl_cb.install = install_stage2_cb;
+	pl->pl_cb.read = read_stage2_cb;
+	pl->pl_cb.read_bbl = read_stage2_file_cb;
+	pl->pl_cb.print = print_einfo_cb;
+	STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+	return (true);
 }
 
-static int
-get_boot_slice(ib_device_t *device, struct dk_gpt *vtoc)
+static bool
+probe_device(ib_data_t *data, const char *dev)
 {
-	uint_t i;
-	char *path, *ptr;
+	struct partlist *pl;
+	struct stat sb;
+	const char *ptr;
+	char *p0;
+	int fd, len;
 
-	for (i = 0; i < vtoc->efi_nparts; i++) {
-		if (vtoc->efi_parts[i].p_tag == V_BOOT) {
-			if ((path = strdup(device->target.path)) == NULL) {
-				perror(gettext("Memory allocation failure"));
-				return (BC_ERROR);
-			}
-			ptr = strrchr(path, 's');
-			ptr++;
-			*ptr = '\0';
-			(void) asprintf(&ptr, "%s%d", path, i);
-			free(path);
-			if (ptr == NULL) {
-				perror(gettext("Memory allocation failure"));
-				return (BC_ERROR);
-			}
-			device->stage.path = ptr;
-			device->stage.fd = open_device(ptr);
-			device->stage.id = i;
-			device->stage.devtype = IG_DEV_EFI;
-			device->stage.fstype = IG_FS_NONE;
-			device->stage.start = vtoc->efi_parts[i].p_start;
-			device->stage.size = vtoc->efi_parts[i].p_size;
-			device->stage.offset = 1; /* leave sector 0 for VBR */
-			return (BC_SUCCESS);
-		}
+	if (dev == NULL)
+		return (NULL);
+
+	len = strlen(dev);
+
+	if ((pl = partlist_alloc()) == NULL)
+		return (false);
+
+	if (stat(dev, &sb) == -1) {
+		perror("stat");
+		partlist_free(pl);
+		return (false);
 	}
-	return (BC_SUCCESS);
-}
 
-static int
-init_device(ib_device_t *device, char *path)
-{
-	struct dk_gpt *vtoc;
-	fstyp_handle_t fhdl;
-	const char *fident;
-	char *p;
-	int pathlen = strlen(path);
-	int ret;
+	/* We have regular file, register it and we are done. */
+	if (S_ISREG(sb.st_mode) != 0) {
+		pl->pl_devname = (char *)dev;
 
-	bzero(device, sizeof (*device));
-	device->fd = -1;	/* whole disk fd */
-	device->stage.fd = -1;	/* bootblock partition fd */
-	device->target.fd = -1;	/* target fs partition fd */
+		pl->pl_type = IB_BBLK_FILE;
+		pl->pl_cb.read = read_einfo_file_cb;
+		pl->pl_cb.print = print_einfo_cb;
+		STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+		return (true);
+	}
 
-	/* basic check, whole disk is not allowed */
-	if ((p = strrchr(path, '/')) == NULL)
-		p = path;
-	if ((strrchr(p, 'p') == NULL && strrchr(p, 's') == NULL) ||
-	    (path[pathlen-2] == 'p' && path[pathlen-1] == '0')) {
-		(void) fprintf(stderr, gettext("installing loader to "
-		    "whole disk device is not supported\n"));
+	/*
+	 * This is block device.
+	 * We do not allow to specify whole disk device (cXtYdZp0 or cXtYdZ).
+	 */
+	if ((ptr = strrchr(dev, '/')) == NULL)
+		ptr = dev;
+	if ((strrchr(ptr, 'p') == NULL && strrchr(ptr, 's') == NULL) ||
+	    (dev[len - 2] == 'p' && dev[len - 1] == '0')) {
+		(void) fprintf(stderr,
+		    gettext("whole disk device is not supported\n"));
+		partlist_free(pl);
+		return (false);
 	}
 
-	device->target.path = strdup(path);
-	if (device->target.path == NULL) {
-		perror(gettext("Memory allocation failure"));
-		return (BC_ERROR);
+	data->target.path = (char *)dev;
+	if (!probe_fstyp(data)) {
+		partlist_free(pl);
+		return (false);
 	}
-	device->path = strdup(path);
-	if (device->path == NULL) {
-		perror(gettext("Memory allocation failure"));
-		return (BC_ERROR);
+
+	/* We start from identifying the whole disk. */
+	if ((p0 = strdup(dev)) == NULL) {
+		perror("calloc");
+		partlist_free(pl);
+		return (false);
 	}
 
-	/* change device name to p0 */
-	device->path[pathlen - 2] = 'p';
-	device->path[pathlen - 1] = '0';
+	pl->pl_devname = p0;
+	/* Change device name to p0 */
+	if ((ptr = strrchr(p0, 'p')) == NULL)
+		ptr = strrchr(p0, 's');
+	p0 = (char *)ptr;
+	p0[0] = 'p';
+	p0[1] = '0';
+	p0[2] = '\0';
 
-	if (strstr(device->target.path, "diskette")) {
-		(void) fprintf(stderr, gettext("installing loader to a floppy "
-		    "disk is not supported\n"));
-		return (BC_ERROR);
+	if ((fd = open_device(pl->pl_devname)) == -1) {
+		partlist_free(pl);
+		return (false);
 	}
 
-	/* Detect if the target device is a pcfs partition. */
-	if (strstr(device->target.path, "p0:boot")) {
-		(void) fprintf(stderr, gettext("installing loader to x86 boot "
-		    "partition is not supported\n"));
-		return (BC_ERROR);
+	sector_size = get_media_info(fd);
+	(void) close(fd);
+
+	pl->pl_src_name = stage1;
+	pl->pl_type = IB_BBLK_MBR;
+	pl->pl_cb.compare = compare_mbr_cb;
+	pl->pl_cb.install = install_stage1_cb;
+	pl->pl_cb.read = read_stage1_cb;
+	pl->pl_cb.read_bbl = read_stage1_bbl_cb;
+	pl->pl_cb.print = print_stage1_cb;
+	STAILQ_INSERT_TAIL(data->plist, pl, pl_next);
+
+	if (probe_gpt(data))
+		return (true);
+
+	if (data->device.devtype == IB_DEV_UNKNOWN)
+		if (probe_vtoc(data))
+			return (true);
+
+	if (data->device.devtype == IB_DEV_UNKNOWN)
+		return (probe_mbr(data));
+
+	return (false);
+}
+
+static int
+read_bootblock_from_file(const char *file, ib_bootblock_t *bblock)
+{
+	struct stat	sb;
+	uint32_t	buf_size;
+	uint32_t	mboot_off;
+	int		fd = -1;
+	int		retval = BC_ERROR;
+
+	assert(bblock != NULL);
+	assert(file != NULL);
+
+	fd = open(file, O_RDONLY);
+	if (fd == -1) {
+		BOOT_DEBUG("Error opening %s\n", file);
+		goto out;
 	}
 
-	if ((device->fd = open_device(device->path)) == -1)
-		return (BC_ERROR);
+	if (fstat(fd, &sb) == -1) {
+		BOOT_DEBUG("Error getting information (stat) about %s", file);
+		perror("stat");
+		goto outfd;
+	}
+
+	/* loader bootblock has version built in */
+	buf_size = sb.st_size;
+
+	bblock->buf_size = buf_size;
+	BOOT_DEBUG("bootblock in-memory buffer size is %d\n",
+	    bblock->buf_size);
+
+	bblock->buf = malloc(buf_size);
+	if (bblock->buf == NULL) {
+		perror(gettext("Memory allocation failure"));
+		goto outbuf;
+	}
+	bblock->file = bblock->buf;
 
-	/* read in the device boot sector. */
-	if (read(device->fd, device->mbr, SECTOR_SIZE) != SECTOR_SIZE) {
-		(void) fprintf(stderr, gettext("Error reading boot sector\n"));
+	if (read(fd, bblock->file, bblock->buf_size) != bblock->buf_size) {
+		BOOT_DEBUG("Read from %s failed\n", file);
 		perror("read");
-		return (BC_ERROR);
+		goto outfd;
 	}
 
-	device->devtype = IG_DEV_VTOC;
-	if (efi_alloc_and_read(device->fd, &vtoc) >= 0) {
-		ret = get_boot_slice(device, vtoc);
-		device->devtype = IG_DEV_EFI;
-		efi_free(vtoc);
-		if (ret == BC_ERROR)
-			return (BC_ERROR);
-	} else if (device->target.path[pathlen - 2] == 'p') {
-		device->devtype = IG_DEV_MBR;
-		ret = get_boot_partition(device, (struct mboot *)device->mbr);
-		if (ret == BC_ERROR)
-			return (BC_ERROR);
-	} else if (device->target.path[pathlen - 1] == '2') {
-		/*
-		 * NOTE: we could relax there and allow zfs boot on
-		 * slice 2 for instance, but lets keep traditional limits.
-		 */
+	buf_size = MIN(buf_size, MBOOT_SCAN_SIZE);
+	if (find_multiboot(bblock->file, buf_size, &mboot_off)
+	    != BC_SUCCESS) {
 		(void) fprintf(stderr,
-		    gettext("raw device must be a root slice (not s2)\n"));
-		return (BC_ERROR);
+		    gettext("Unable to find multiboot header\n"));
+		goto outfd;
 	}
 
-	/* fill stage partition for case there is no boot partition */
-	if (device->stage.path == NULL) {
-		if ((device->stage.path = strdup(path)) == NULL) {
-			perror(gettext("Memory allocation failure"));
-			return (BC_ERROR);
-		}
-		if (device->devtype == IG_DEV_VTOC) {
-			/* use slice 2 */
-			device->stage.path[pathlen - 2] = 's';
-			device->stage.path[pathlen - 1] = '2';
-			device->stage.id = 2;
-		} else {
-			p = strrchr(device->stage.path, 'p');
-			if (p == NULL)
-				p = strrchr(device->stage.path, 's');
-			device->stage.id = atoi(++p);
-		}
-		device->stage.devtype = device->devtype;
-		device->stage.fd = open_device(device->stage.path);
-	}
+	bblock->mboot = (multiboot_header_t *)(bblock->file + mboot_off);
+	bblock->mboot_off = mboot_off;
 
-	p = strrchr(device->target.path, 'p');
-	if (p == NULL)
-		p = strrchr(device->target.path, 's');
-	device->target.id = atoi(++p);
+	bblock->file_size =
+	    bblock->mboot->load_end_addr - bblock->mboot->load_addr;
+	BOOT_DEBUG("bootblock file size is %d\n", bblock->file_size);
 
-	if (strcmp(device->stage.path, device->target.path) == 0)
-		device->target.fd = dup(device->stage.fd);
-	else
-		device->target.fd = open_device(device->target.path);
+	bblock->extra = bblock->buf + P2ROUNDUP(bblock->file_size, 8);
+	bblock->extra_size = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);
 
-	if (fstyp_init(device->target.fd, 0, NULL, &fhdl) != 0)
-		return (BC_ERROR);
+	BOOT_DEBUG("mboot at %p offset %d, extra at %p size %d, buf=%p "
+	    "(size=%d)\n", bblock->mboot, bblock->mboot_off, bblock->extra,
+	    bblock->extra_size, bblock->buf, bblock->buf_size);
 
-	if (fstyp_ident(fhdl, NULL, &fident) != 0) {
-		fstyp_fini(fhdl);
-		(void) fprintf(stderr, gettext("Failed to detect file "
-		    "system type\n"));
-		return (BC_ERROR);
-	}
+	(void) close(fd);
+	return (BC_SUCCESS);
 
-	/* at this moment non-boot partition has no size set, use this fact */
-	if (device->devtype == IG_DEV_EFI && strcmp(fident, "zfs") &&
-	    device->stage.size == 0) {
-		fstyp_fini(fhdl);
-		(void) fprintf(stderr, gettext("Booting %s of EFI labeled "
-		    "disks requires the boot partition.\n"), fident);
-		return (BC_ERROR);
+outbuf:
+	(void) free(bblock->buf);
+	bblock->buf = NULL;
+outfd:
+	(void) close(fd);
+out:
+	if (retval == BC_ERROR) {
+		(void) fprintf(stderr,
+		    gettext("Error reading bootblock from %s\n"),
+		    file);
 	}
-	if (strcmp(fident, "zfs") == 0)
-		device->target.fstype = IG_FS_ZFS;
-	else if (strcmp(fident, "ufs") == 0) {
-		device->target.fstype = IG_FS_UFS;
-	} else if (strcmp(fident, "pcfs") == 0) {
-		device->target.fstype = IG_FS_PCFS;
-	} else {
-		(void) fprintf(stderr, gettext("File system %s is not "
-		    "supported by loader\n"), fident);
-		fstyp_fini(fhdl);
-		return (BC_ERROR);
+
+	if (retval == BC_NOEXTRA) {
+		BOOT_DEBUG("No multiboot header found on %s, unable to "
+		    "locate extra information area (old/non versioned "
+		    "bootblock?) \n", file);
+		(void) fprintf(stderr, gettext("No extended information"
+		    " found\n"));
 	}
-	fstyp_fini(fhdl);
+	return (retval);
+}
 
-	/* check for boot partition content */
-	if (device->stage.size) {
-		if (fstyp_init(device->stage.fd, 0, NULL, &fhdl) != 0)
-			return (BC_ERROR);
+static void
+add_bootblock_einfo(ib_bootblock_t *bblock, char *updt_str)
+{
+	bblk_hs_t	hs;
+	uint32_t	avail_space;
 
-		if (fstyp_ident(fhdl, NULL, &fident) == 0) {
-			(void) fprintf(stderr, gettext("Unexpected %s file "
-			    "system on boot partition\n"), fident);
-			fstyp_fini(fhdl);
-			return (BC_ERROR);
-		}
-		fstyp_fini(fhdl);
+	assert(bblock != NULL);
+
+	if (updt_str == NULL) {
+		BOOT_DEBUG("WARNING: no update string passed to "
+		    "add_bootblock_einfo()\n");
+		return;
 	}
-	return (get_start_sector(device));
+
+	/* Fill bootblock hashing source information. */
+	hs.src_buf = (unsigned char *)bblock->file;
+	hs.src_size = bblock->file_size;
+	/* How much space for the extended information structure? */
+	avail_space = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);
+	/* Place the extended information structure. */
+	add_einfo(bblock->extra, updt_str, &hs, avail_space);
 }
 
+/*
+ * set up data for case stage1 is installed as MBR
+ * set up location and size of bootblock
+ * set disk guid to provide unique information for biosdev command
+ */
 static void
-cleanup_device(ib_device_t *device)
+prepare_stage1(struct partlist *stage1, struct partlist *stage2, uuid_t uuid)
 {
-	if (device->path)
-		free(device->path);
-	if (device->stage.path)
-		free(device->stage.path);
-	if (device->target.path)
-		free(device->target.path);
-
-	if (device->fd != -1)
-		(void) close(device->fd);
-	if (device->stage.fd != -1)
-		(void) close(device->stage.fd);
-	if (device->target.fd != -1)
-		(void) close(device->target.fd);
-	bzero(device, sizeof (*device));
+	char *src, *dest;
+	ib_bootblock_t *bblk;
+	ib_device_t *device;
+	uint16_t size;
+	struct mboot *mbr;
+
+	src = stage1->pl_stage;
+	dest = stage1->pl_src_data;
+	device = stage2->pl_device;
+
+	/* Only copy from valid source. */
+	mbr = stage1->pl_stage;
+	if (mbr->signature == MBB_MAGIC) {
+		/* copy BPB */
+		bcopy(src + STAGE1_BPB_OFFSET, dest + STAGE1_BPB_OFFSET,
+		    STAGE1_BPB_SIZE);
+
+		/* copy MBR, note STAGE1_SIG == BOOTSZ */
+		bcopy(src + STAGE1_SIG, dest + STAGE1_SIG,
+		    SECTOR_SIZE - STAGE1_SIG);
+	}
+
+	bcopy(uuid, dest + STAGE1_STAGE2_UUID, UUID_LEN);
+
+	/* set stage2 size */
+	bblk = stage2->pl_src_data;
+	size = bblk->buf_size / SECTOR_SIZE;
+	*((uint16_t *)(dest + STAGE1_STAGE2_SIZE)) = size;
+
+	/* set stage2 LBA */
+	*((uint64_t *)(dest + STAGE1_STAGE2_LBA)) =
+	    device->stage.start + device->stage.offset;
+
+	/* Copy prepared data to stage1 block read from the disk. */
+	bcopy(dest, src, SECTOR_SIZE);
 }
 
 static void
-cleanup_bootblock(ib_bootblock_t *bblock)
+prepare_bootblock(ib_data_t *data, struct partlist *pl, char *updt_str)
 {
-	free(bblock->buf);
-	bzero(bblock, sizeof (ib_bootblock_t));
+	ib_bootblock_t		*bblock;
+	uint64_t		*ptr;
+
+	assert(pl != NULL);
+
+	bblock = pl->pl_src_data;
+
+	ptr = (uint64_t *)(&bblock->mboot->bss_end_addr);
+	*ptr = data->target.start;
+
+	/*
+	 * the loader bootblock has built in version, if custom
+	 * version was provided, update it.
+	 */
+	if (do_version)
+		add_bootblock_einfo(bblock, updt_str);
 }
 
-/*
- * Propagate the bootblock on the source disk to the destination disk and
- * version it with 'updt_str' in the process. Since we cannot trust any data
- * on the attaching disk, we do not perform any specific check on a potential
- * target extended information structure and we just blindly update.
- */
 static int
-propagate_bootblock(ib_data_t *src, ib_data_t *dest, char *updt_str)
+open_device(const char *path)
 {
-	ib_bootblock_t	*src_bblock = &src->bootblock;
-	ib_bootblock_t	*dest_bblock = &dest->bootblock;
+	struct stat	statbuf = {0};
+	int		fd = -1;
 
-	assert(src != NULL);
-	assert(dest != NULL);
+	if (nowrite)
+		fd = open(path, O_RDONLY);
+	else
+		fd = open(path, O_RDWR);
 
-	/* read the stage1 file from source disk */
-	if (read(src->device.fd, dest->stage1, SECTOR_SIZE) != SECTOR_SIZE) {
-		(void) fprintf(stderr, gettext("cannot read stage1 from %s\n"),
-		    src->device.path);
-		return (BC_ERROR);
+	if (fd == -1) {
+		BOOT_DEBUG("Unable to open %s\n", path);
+		perror("open");
+		return (-1);
 	}
 
-	cleanup_bootblock(dest_bblock);
-
-	dest_bblock->buf_size = src_bblock->buf_size;
-	dest_bblock->buf = malloc(dest_bblock->buf_size);
-	if (dest_bblock->buf == NULL) {
-		perror(gettext("Memory Allocation Failure"));
-		return (BC_ERROR);
+	if (fstat(fd, &statbuf) != 0) {
+		BOOT_DEBUG("Unable to stat %s\n", path);
+		perror("stat");
+		(void) close(fd);
+		return (-1);
 	}
-	dest_bblock->file = dest_bblock->buf;
-	dest_bblock->file_size = src_bblock->file_size;
-	(void) memcpy(dest_bblock->buf, src_bblock->buf,
-	    dest_bblock->buf_size);
 
-	dest_bblock->mboot = (multiboot_header_t *)(dest_bblock->file +
-	    src_bblock->mboot_off);
-	dest_bblock->mboot_off = src_bblock->mboot_off;
-	dest_bblock->extra = (char *)dest_bblock->file +
-	    P2ROUNDUP(dest_bblock->file_size, 8);
-	dest_bblock->extra_size = src_bblock->extra_size;
-
-	(void) fprintf(stdout, gettext("Propagating %s bootblock to %s\n"),
-	    src->device.path, dest->device.path);
+	if (S_ISCHR(statbuf.st_mode) == 0) {
+		(void) fprintf(stderr, gettext("%s: Not a character device\n"),
+		    path);
+		(void) close(fd);
+		return (-1);
+	}
 
-	return (commit_to_disk(dest, updt_str));
+	return (fd);
 }
 
-static int
-commit_to_disk(ib_data_t *data, char *update_str)
+/*
+ * We need to record stage2 location and size into pmbr/vbr.
+ * We need to record target partiton LBA to stage2.
+ */
+static void
+prepare_bblocks(ib_data_t *data)
 {
-	assert(data != NULL);
+	struct partlist *pl;
+	struct partlist *mbr, *stage1, *stage2;
+	uuid_t uuid;
 
-	if (prepare_bootblock(data, update_str) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Error updating the bootblock "
-		    "image\n"));
-		return (BC_ERROR);
+	mbr = stage1 = stage2 = NULL;
+	/*
+	 * Walk list and pick up BIOS boot blocks. EFI boot programs
+	 * can be set in place.
+	 */
+	STAILQ_FOREACH(pl, data->plist, pl_next) {
+		switch (pl->pl_type) {
+		case IB_BBLK_MBR:
+			mbr = pl;
+			break;
+		case IB_BBLK_STAGE1:
+			stage1 = pl;
+			break;
+		case IB_BBLK_STAGE2:
+			stage2 = pl;
+			/* FALLTHROUGH */
+		case IB_BBLK_EFI:
+			prepare_bootblock(data, pl, update_str);
+			break;
+		default:
+			break;
+		}
 	}
 
-	if (prepare_stage1(data) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Error updating the stage1 "
-		    "image\n"));
-		return (BC_ERROR);
-	}
+	/* If stage2 is missing, we are done. */
+	if (stage2 == NULL)
+		return;
 
-	if (write_bootblock(data) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Error writing bootblock to "
-		    "disk\n"));
-		return (BC_ERROR);
+	/*
+	 * Create disk uuid. We only need reasonable amount of uniqueness
+	 * to allow biosdev to identify disk based on mbr differences.
+	 */
+	uuid_generate(uuid);
+
+	if (mbr != NULL) {
+		prepare_stage1(mbr, stage2, uuid);
+
+		/*
+		 * If we have stage1, we point MBR to read stage 1.
+		 */
+		if (stage1 != NULL) {
+			char *dest = mbr->pl_stage;
+
+			*((uint16_t *)(dest + STAGE1_STAGE2_SIZE)) = 1;
+			*((uint64_t *)(dest + STAGE1_STAGE2_LBA)) =
+			    stage1->pl_device->stage.start;
+		}
 	}
 
-	return (write_stage1(data));
+	if (stage1 != NULL) {
+		prepare_stage1(stage1, stage2, uuid);
+	}
 }
 
 /*
@@ -1251,67 +2021,116 @@ commit_to_disk(ib_data_t *data, char *update_str)
  *
  */
 static int
-handle_install(char *progname, char **argv)
+handle_install(char *progname, int argc, char **argv)
 {
-	ib_data_t	install_data;
-	ib_bootblock_t	*bblock = &install_data.bootblock;
-	char		*stage1 = NULL;
-	char		*bootblock = NULL;
+	struct partlist	*pl;
+	ib_data_t	data = { 0 };
 	char		*device_path = NULL;
 	int		ret = BC_ERROR;
 
-	stage1 = strdup(argv[0]);
-	bootblock = strdup(argv[1]);
-	device_path = strdup(argv[2]);
+	switch (argc) {
+	case 1:
+		if ((device_path = strdup(argv[0])) == NULL) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&stage1, "%s/%s", boot_dir, STAGE1) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&stage2, "%s/%s", boot_dir, STAGE2) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&efi32, "%s/%s", boot_dir, LOADER32) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&efi64, "%s/%s", boot_dir, LOADER64) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		break;
+	case 3:
+		if ((stage1 = strdup(argv[0])) == NULL) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if ((stage2 = strdup(argv[1])) == NULL) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if ((device_path = strdup(argv[2])) == NULL) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&efi32, "%s/%s", boot_dir, LOADER32) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		if (asprintf(&efi64, "%s/%s", boot_dir, LOADER64) < 0) {
+			perror(gettext("Memory Allocation Failure"));
+			goto done;
+		}
+		break;
+	default:
+		usage(progname, ret);
+	}
 
-	if (!device_path || !bootblock || !stage1) {
-		(void) fprintf(stderr, gettext("Missing parameter"));
-		usage(progname, BC_ERROR);
+	data.plist = malloc(sizeof (*data.plist));
+	if (data.plist == NULL) {
+		perror(gettext("Memory Allocation Failure"));
+		goto done;
 	}
+	STAILQ_INIT(data.plist);
 
 	BOOT_DEBUG("device path: %s, stage1 path: %s bootblock path: %s\n",
-	    device_path, stage1, bootblock);
-	bzero(&install_data, sizeof (ib_data_t));
+	    device_path, stage1, stage2);
 
-	if (init_device(&install_data.device, device_path) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Unable to open device %s\n"),
-		    device_path);
-		goto out;
-	}
-
-	if (read_stage1_from_file(stage1, &install_data) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Error opening %s\n"), stage1);
-		goto out_dev;
-	}
+	if (probe_device(&data, device_path)) {
+		/* Read all data. */
+		STAILQ_FOREACH(pl, data.plist, pl_next) {
+			if (!pl->pl_cb.read(pl)) {
+				printf("\n");
+			}
+			if (!pl->pl_cb.read_bbl(pl)) {
+				(void) fprintf(stderr,
+				    gettext("Error reading %s\n"),
+				    pl->pl_src_name);
+				goto cleanup;
+			}
+		}
 
-	if (read_bootblock_from_file(bootblock, bblock) != BC_SUCCESS) {
-		(void) fprintf(stderr, gettext("Error reading %s\n"),
-		    bootblock);
-		goto out_dev;
+		/* Prepare data. */
+		prepare_bblocks(&data);
+
+		/* Commit data to disk. */
+		while ((pl = STAILQ_LAST(data.plist, partlist, pl_next)) !=
+		    NULL) {
+			if (pl->pl_cb.compare != NULL &&
+			    pl->pl_cb.compare(pl)) {
+				if (pl->pl_cb.install != NULL)
+					pl->pl_cb.install(&data, pl);
+			} else {
+				printf("\n");
+			}
+			STAILQ_REMOVE(data.plist, pl, partlist, pl_next);
+			partlist_free(pl);
+		}
 	}
+	ret = BC_SUCCESS;
 
-	/*
-	 * is_update_necessary() will take care of checking if versioning and/or
-	 * forcing the update have been specified. It will also emit a warning
-	 * if a non-versioned update is attempted over a versioned bootblock.
-	 */
-	if (!is_update_necessary(&install_data, update_str)) {
-		(void) fprintf(stderr, gettext("bootblock version installed "
-		    "on %s is more recent or identical\n"
-		    "Use -F to override or install without the -u option\n"),
-		    device_path);
-		ret = BC_NOUPDT;
-		goto out_dev;
+cleanup:
+	while ((pl = STAILQ_LAST(data.plist, partlist, pl_next)) != NULL) {
+		STAILQ_REMOVE(data.plist, pl, partlist, pl_next);
+		partlist_free(pl);
 	}
-
-	BOOT_DEBUG("Ready to commit to disk\n");
-	ret = commit_to_disk(&install_data, update_str);
-
-out_dev:
-	cleanup_device(&install_data.device);
-out:
+	free(data.plist);
+done:
 	free(stage1);
-	free(bootblock);
+	free(stage2);
+	free(efi32);
+	free(efi64);
 	free(device_path);
 	return (ret);
 }
@@ -1327,83 +2146,46 @@ out:
  *        - BC_NOEINFO (no extended information available)
  */
 static int
-handle_getinfo(char *progname, char **argv)
+handle_getinfo(char *progname, int argc, char **argv)
 {
-	struct stat	sb;
-	ib_bootblock_t	bblock;
-	ib_device_t	device;
-	bblk_einfo_t	*einfo;
-	uint8_t		flags = 0;
-	char		*device_path, *path;
-	int		retval = BC_ERROR;
-	int		ret;
+	struct partlist	*pl;
+	ib_data_t	data = { 0 };
+	char		*device_path;
 
-	device_path = strdup(argv[0]);
-	if (!device_path) {
+	if (argc != 1) {
 		(void) fprintf(stderr, gettext("Missing parameter"));
 		usage(progname, BC_ERROR);
 	}
 
-	if (stat(device_path, &sb) == -1) {
-		perror("stat");
-		goto out;
-	}
-
-	bzero(&bblock, sizeof (bblock));
-	bzero(&device, sizeof (device));
-	BOOT_DEBUG("device path: %s\n", device_path);
-
-	if (S_ISREG(sb.st_mode) != 0) {
-		path = device_path;
-		ret = read_bootblock_from_file(device_path, &bblock);
-	} else {
-		if (init_device(&device, device_path) != BC_SUCCESS) {
-			(void) fprintf(stderr, gettext("Unable to gather "
-			    "device information from %s\n"), device_path);
-			goto out_dev;
-		}
-		ret = read_bootblock_from_disk(&device, &bblock, &path);
+	if ((device_path = strdup(argv[0])) == NULL) {
+		perror(gettext("Memory Allocation Failure"));
+		return (BC_ERROR);
 	}
 
-	if (ret == BC_ERROR) {
-		(void) fprintf(stderr, gettext("Error reading bootblock from "
-		    "%s\n"), path);
-		goto out_dev;
+	data.plist = malloc(sizeof (*data.plist));
+	if (data.plist == NULL) {
+		perror("malloc");
+		free(device_path);
+		return (BC_ERROR);
 	}
+	STAILQ_INIT(data.plist);
 
-	if (ret == BC_NOEXTRA) {
-		BOOT_DEBUG("No multiboot header found on %s, unable "
-		    "to locate extra information area (old/non versioned "
-		    "bootblock?) \n", device_path);
-		(void) fprintf(stderr, gettext("No extended information "
-		    "found\n"));
-		retval = BC_NOEINFO;
-		goto out_dev;
+	if (probe_device(&data, device_path)) {
+		STAILQ_FOREACH(pl, data.plist, pl_next) {
+			if (pl->pl_cb.read(pl))
+				pl->pl_cb.print(pl);
+			else
+				printf("\n");
+		}
 	}
 
-	einfo = find_einfo(bblock.extra, bblock.extra_size);
-	if (einfo == NULL) {
-		retval = BC_NOEINFO;
-		(void) fprintf(stderr, gettext("No extended information "
-		    "found\n"));
-		goto out_dev;
+	while ((pl = STAILQ_LAST(data.plist, partlist, pl_next)) != NULL) {
+		STAILQ_REMOVE(data.plist, pl, partlist, pl_next);
+		partlist_free(pl);
 	}
+	free(data.plist);
 
-	/* Print the extended information. */
-	if (strip)
-		flags |= EINFO_EASY_PARSE;
-	if (verbose_dump)
-		flags |= EINFO_PRINT_HEADER;
-
-	print_einfo(flags, einfo, bblock.extra_size);
-	retval = BC_SUCCESS;
-
-out_dev:
-	if (S_ISREG(sb.st_mode) == 0)
-		cleanup_device(&device);
-out:
-	free(device_path);
-	return (retval);
+	return (BC_SUCCESS);
 }
 
 /*
@@ -1416,85 +2198,124 @@ out:
  *			there is no multiboot information)
  */
 static int
-handle_mirror(char *progname, char **argv)
+handle_mirror(char *progname, int argc, char **argv)
 {
-	ib_data_t	curr_data;
-	ib_data_t	attach_data;
-	ib_device_t	*curr_device = &curr_data.device;
-	ib_device_t	*attach_device = &attach_data.device;
-	ib_bootblock_t	*bblock_curr = &curr_data.bootblock;
-	ib_bootblock_t	*bblock_attach = &attach_data.bootblock;
-	bblk_einfo_t	*einfo_curr = NULL;
-	char		*curr_device_path;
-	char		*attach_device_path;
-	char		*updt_str = NULL;
-	char		*path;
+	ib_data_t src = { 0 };
+	ib_data_t dest = { 0 };
+	struct partlist *pl_src, *pl_dest;
+	char		*curr_device_path = NULL;
+	char		*attach_device_path = NULL;
 	int		retval = BC_ERROR;
-	int		ret;
 
-	curr_device_path = strdup(argv[0]);
-	attach_device_path = strdup(argv[1]);
+	if (argc == 2) {
+		curr_device_path = strdup(argv[0]);
+		attach_device_path = strdup(argv[1]);
+	}
 
 	if (!curr_device_path || !attach_device_path) {
+		free(curr_device_path);
+		free(attach_device_path);
 		(void) fprintf(stderr, gettext("Missing parameter"));
 		usage(progname, BC_ERROR);
 	}
 	BOOT_DEBUG("Current device path is: %s, attaching device path is: "
 	    " %s\n", curr_device_path, attach_device_path);
 
-	bzero(&curr_data, sizeof (ib_data_t));
-	bzero(&attach_data, sizeof (ib_data_t));
+	src.plist = malloc(sizeof (*src.plist));
+	if (src.plist == NULL) {
+		perror("malloc");
+		return (BC_ERROR);
+	}
+	STAILQ_INIT(src.plist);
 
-	if (init_device(curr_device, curr_device_path) != BC_SUCCESS) {
+	dest.plist = malloc(sizeof (*dest.plist));
+	if (dest.plist == NULL) {
+		perror("malloc");
+		goto out;
+	}
+	STAILQ_INIT(dest.plist);
+
+	if (!probe_device(&src, curr_device_path)) {
 		(void) fprintf(stderr, gettext("Unable to gather device "
 		    "information from %s (current device)\n"),
 		    curr_device_path);
-		goto out_currdev;
+		goto out;
 	}
 
-	if (init_device(attach_device, attach_device_path) != BC_SUCCESS) {
+	if (!probe_device(&dest, attach_device_path) != BC_SUCCESS) {
 		(void) fprintf(stderr, gettext("Unable to gather device "
 		    "information from %s (attaching device)\n"),
 		    attach_device_path);
-		goto out_devs;
+		goto cleanup_src;
 	}
 
-	ret = read_bootblock_from_disk(curr_device, bblock_curr, &path);
-	if (ret == BC_ERROR) {
-		BOOT_DEBUG("Error reading bootblock from %s\n", path);
-		retval = BC_ERROR;
-		goto out_devs;
-	}
+	write_mbr = true;
+	force_mbr = true;
 
-	if (ret == BC_NOEXTRA) {
-		BOOT_DEBUG("No multiboot header found on %s, unable to retrieve"
-		    " the bootblock\n", path);
-		retval = BC_NOEXTRA;
-		goto out_devs;
+	pl_dest = STAILQ_FIRST(dest.plist);
+	STAILQ_FOREACH(pl_src, src.plist, pl_next) {
+		if (pl_dest == NULL) {
+			(void) fprintf(stderr,
+			    gettext("Destination disk layout is different "
+			    "from source, can not mirror.\n"));
+			goto cleanup;
+		}
+		if (!pl_src->pl_cb.read(pl_src)) {
+			(void) fprintf(stderr, gettext("Failed to read "
+			    "boot block from %s\n"), pl_src->pl_devname);
+			goto cleanup;
+		}
+		if (!pl_dest->pl_cb.read(pl_dest)) {
+			(void) fprintf(stderr, gettext("Failed to read "
+			    "boot block from %s\n"), pl_dest->pl_devname);
+		}
+
+		/* Set source pl_stage to destination source data */
+		pl_dest->pl_src_data = pl_src->pl_stage;
+		pl_src->pl_stage = NULL;
+
+		pl_dest = STAILQ_NEXT(pl_dest, pl_next);
 	}
 
-	write_mbr = B_TRUE;
-	force_mbr = B_TRUE;
-	einfo_curr = find_einfo(bblock_curr->extra, bblock_curr->extra_size);
-	if (einfo_curr != NULL)
-		updt_str = einfo_get_string(einfo_curr);
+	/* Prepare data. */
+	prepare_bblocks(&dest);
+
+	/* Commit data to disk. */
+	while ((pl_dest = STAILQ_LAST(dest.plist, partlist, pl_next)) != NULL) {
+		pl_dest->pl_cb.install(&dest, pl_dest);
+		STAILQ_REMOVE(dest.plist, pl_dest, partlist, pl_next);
+		partlist_free(pl_dest);
+
+		/* Free source list */
+		pl_src = STAILQ_LAST(src.plist, partlist, pl_next);
+		STAILQ_REMOVE(src.plist, pl_src, partlist, pl_next);
+		partlist_free(pl_src);
+	}
+	retval = BC_SUCCESS;
 
-	retval = propagate_bootblock(&curr_data, &attach_data, updt_str);
-	cleanup_bootblock(bblock_curr);
-	cleanup_bootblock(bblock_attach);
-out_devs:
-	cleanup_device(attach_device);
-out_currdev:
-	cleanup_device(curr_device);
+cleanup:
+	while ((pl_dest = STAILQ_LAST(dest.plist, partlist, pl_next)) != NULL) {
+		STAILQ_REMOVE(dest.plist, pl_dest, partlist, pl_next);
+		partlist_free(pl_dest);
+	}
+	free(dest.plist);
+cleanup_src:
+	while ((pl_src = STAILQ_LAST(src.plist, partlist, pl_next)) != NULL) {
+		STAILQ_REMOVE(src.plist, pl_src, partlist, pl_next);
+		partlist_free(pl_src);
+	}
+	free(src.plist);
+out:
 	free(curr_device_path);
 	free(attach_device_path);
 	return (retval);
 }
 
-#define	USAGE_STRING	"Usage:\t%s [-h|-m|-f|-n|-F|-u verstr] stage1 stage2 " \
-			"raw-device\n"				\
-			"\t%s -M [-n] raw-device attach-raw-device\n"	\
-			"\t%s [-e|-V] -i raw-device | file\n"
+#define	USAGE_STRING	\
+"Usage:\t%s [-fFmn] [-b boot_dir] [-u verstr]\n"	\
+"\t\t[stage1 stage2] raw-device\n"			\
+"\t%s -M [-n] raw-device attach-raw-device\n"		\
+"\t%s [-e|-V] -i raw-device | file\n"
 
 #define	CANON_USAGE_STR	gettext(USAGE_STRING)
 
@@ -1502,6 +2323,7 @@ static void
 usage(char *progname, int rc)
 {
 	(void) fprintf(stdout, CANON_USAGE_STR, progname, progname, progname);
+	fini_yes();
 	exit(rc);
 }
 
@@ -1509,52 +2331,66 @@ int
 main(int argc, char **argv)
 {
 	int	opt;
-	int	params = 3;
 	int	ret;
 	char	*progname;
-	char	**handle_args;
+	struct stat sb;
 
 	(void) setlocale(LC_ALL, "");
 	(void) textdomain(TEXT_DOMAIN);
 	if (init_yes() < 0)
 		errx(BC_ERROR, gettext(ERR_MSG_INIT_YES), strerror(errno));
 
+	/* Needed for mount pcfs. */
+	tzset();
+
 	/* Determine our name */
 	progname = basename(argv[0]);
 
-	while ((opt = getopt(argc, argv, "deFfhiMmnu:V")) != EOF) {
+	while ((opt = getopt(argc, argv, "b:deFfhiMmnu:V")) != EOF) {
 		switch (opt) {
+		case 'b':
+			boot_dir = strdup(optarg);
+			if (boot_dir == NULL) {
+				err(BC_ERROR,
+				    gettext("Memory allocation failure"));
+			}
+			if (lstat(boot_dir, &sb) != 0) {
+				err(BC_ERROR, boot_dir);
+			}
+			if (!S_ISDIR(sb.st_mode)) {
+				errx(BC_ERROR, gettext("%s: not a directory"),
+				    boot_dir);
+			}
+			break;
 		case 'd':
-			boot_debug = B_TRUE;
+			boot_debug = true;
 			break;
 		case 'e':
-			strip = B_TRUE;
+			strip = true;
 			break;
 		case 'F':
-			force_update = B_TRUE;
+			force_update = true;
 			break;
 		case 'f':
-			force_mbr = B_TRUE;
+			force_mbr = true;
 			break;
 		case 'h':
 			usage(progname, BC_SUCCESS);
 			break;
 		case 'i':
-			do_getinfo = B_TRUE;
-			params = 1;
+			do_getinfo = true;
 			break;
 		case 'M':
-			do_mirror_bblk = B_TRUE;
-			params = 2;
+			do_mirror_bblk = true;
 			break;
 		case 'm':
-			write_mbr = B_TRUE;
+			write_mbr = true;
 			break;
 		case 'n':
-			nowrite = B_TRUE;
+			nowrite = true;
 			break;
 		case 'u':
-			do_version = B_TRUE;
+			do_version = true;
 
 			update_str = strdup(optarg);
 			if (update_str == NULL) {
@@ -1563,7 +2399,7 @@ main(int argc, char **argv)
 			}
 			break;
 		case 'V':
-			verbose_dump = B_TRUE;
+			verbose_dump = true;
 			break;
 		default:
 			/* fall through to process non-optional args */
@@ -1572,23 +2408,20 @@ main(int argc, char **argv)
 	}
 
 	/* check arguments */
-	if (argc != optind + params) {
-		usage(progname, BC_ERROR);
-	}
 	check_options(progname);
-	handle_args = argv + optind;
 
 	if (nowrite)
 		(void) fprintf(stdout, gettext("Dry run requested. Nothing will"
 		    " be written to disk.\n"));
 
 	if (do_getinfo) {
-		ret = handle_getinfo(progname, handle_args);
+		ret = handle_getinfo(progname, argc - optind, argv + optind);
 	} else if (do_mirror_bblk) {
-		ret = handle_mirror(progname, handle_args);
+		ret = handle_mirror(progname, argc - optind, argv + optind);
 	} else {
-		ret = handle_install(progname, handle_args);
+		ret = handle_install(progname, argc - optind, argv + optind);
 	}
+	fini_yes();
 	return (ret);
 }
 
@@ -1612,24 +2445,27 @@ check_options(char *progname)
 		 */
 		if (do_version) {
 			(void) fprintf(stderr, MEANINGLESS_OPT, "-u");
-			do_version = B_FALSE;
+			do_version = false;
 		}
 		if (force_update) {
 			(void) fprintf(stderr, MEANINGLESS_OPT, "-F");
-			force_update = B_FALSE;
+			force_update = false;
 		}
 		if (strip || verbose_dump) {
 			BOOT_DEBUG(MEANINGLESS_OPT, "-e|-V");
-			strip = B_FALSE;
-			verbose_dump = B_FALSE;
+			strip = false;
+			verbose_dump = false;
 		}
 	}
 
+	if ((strip || verbose_dump) && !do_getinfo)
+		usage(progname, BC_ERROR);
+
 	if (do_getinfo) {
 		if (write_mbr || force_mbr || do_version || force_update) {
 			BOOT_DEBUG(MEANINGLESS_OPT, "-m|-f|-u|-F");
-			write_mbr = force_mbr = do_version = B_FALSE;
-			force_update = B_FALSE;
+			write_mbr = force_mbr = do_version = false;
+			force_update = false;
 		}
 	}
 }
diff --git a/usr/src/cmd/boot/installboot/i386/installboot.h b/usr/src/cmd/boot/installboot/i386/installboot.h
index 741f1cb682..eef7d651c4 100644
--- a/usr/src/cmd/boot/installboot/i386/installboot.h
+++ b/usr/src/cmd/boot/installboot/i386/installboot.h
@@ -31,33 +31,46 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
 #include <sys/multiboot.h>
 #include <sys/types.h>
+#include <sys/queue.h>
 
 #define	SECTOR_SIZE	(512)
 
 /* partitioning type for device */
-enum ig_devtype_t {
-	IG_DEV_VTOC = 0,
-	IG_DEV_MBR,
-	IG_DEV_EFI
-};
+typedef enum ib_devtype {
+	IB_DEV_UNKNOWN = 0,
+	IB_DEV_VTOC,
+	IB_DEV_MBR,
+	IB_DEV_EFI
+} ib_devtype_t;
 
 /* file system type */
-enum ig_fstype_t {
-	IG_FS_NONE = 0,
-	IG_FS_ZFS,
-	IG_FS_UFS,
-	IG_FS_PCFS
-};
+typedef enum ib_fstype {
+	IB_FS_NONE = 0,
+	IB_FS_ZFS,
+	IB_FS_UFS,
+	IB_FS_PCFS
+} ib_fstype_t;
+
+/* boot block type */
+typedef enum ib_bblktype {
+	IB_BBLK_FILE,
+	IB_BBLK_MBR,		/* MBR/PMBR */
+	IB_BBLK_STAGE1,		/* BIOS stage 1 */
+	IB_BBLK_STAGE2,		/* BIOS stage 2 */
+	IB_BBLK_EFI		/* EFI Boot Program */
+} ib_bblktype_t;
 
 /* partition info for boot block location. */
 struct stage_part {
 	char *path;			/* device name */
-	int fd;				/* open file descriptor */
+	char *mntpnt;			/* mountpoint for stage fs */
 	int id;				/* partition/slice number */
-	enum ig_devtype_t devtype;	/* partitioning type */
-	enum ig_fstype_t fstype;	/* none or pcfs */
+	ib_devtype_t devtype;		/* partitioning type */
+	ib_fstype_t fstype;
+	uint16_t tag;			/* partition tag */
 	uint64_t start;			/* partition LBA */
 	uint64_t size;			/* partition size */
 	uint64_t offset;		/* block offset */
@@ -65,12 +78,9 @@ struct stage_part {
 
 /* boot device data */
 typedef struct _ib_device {
-	char		*path;			/* whole disk */
-	int		fd;			/* whole disk fd */
-	enum ig_devtype_t devtype;
+	ib_devtype_t devtype;
 	struct stage_part stage;		/* location of boot block */
 	struct stage_part target;		/* target file system */
-	char		mbr[SECTOR_SIZE];
 } ib_device_t;
 
 /* stage 2 location */
@@ -85,10 +95,39 @@ typedef struct _ib_bootblock {
 	uint32_t		extra_size;
 } ib_bootblock_t;
 
+struct partlist;
+
+struct part_cb {
+	bool (*read)(struct partlist *);
+	bool (*read_bbl)(struct partlist *);
+	bool (*compare)(struct partlist *);
+	void (*install)(void *, struct partlist *);
+	void (*print)(struct partlist *);
+};
+
+struct partlist {
+	char			*pl_devname;
+	ib_device_t		*pl_device;
+
+	/* boot block type */
+	ib_bblktype_t		pl_type;
+	/* stage from target disk, either stage1 or stage2 */
+	void			*pl_stage;
+	/* name of the source file */
+	const char		*pl_src_name;
+	/* stage data from source file. */
+	void			*pl_src_data;
+	struct part_cb		pl_cb;
+	STAILQ_ENTRY(partlist)	pl_next;
+};
+
+typedef STAILQ_HEAD(part_list, partlist) part_list_t;
+
 typedef struct _ib_data {
-	unsigned char	stage1[SECTOR_SIZE];	/* partition boot block */
 	ib_device_t	device;			/* boot device */
 	ib_bootblock_t	bootblock;		/* stage 2 */
+	struct stage_part target;		/* target file system */
+	part_list_t	*plist;			/* boot blocks */
 } ib_data_t;
 
 #define	BBLK_BLKLIST_OFF	50	/* vtoc/disk boot offset */
diff --git a/usr/src/lib/libbe/common/be_activate.c b/usr/src/lib/libbe/common/be_activate.c
index 9fd95e1e8a..1c2454991d 100644
--- a/usr/src/lib/libbe/common/be_activate.c
+++ b/usr/src/lib/libbe/common/be_activate.c
@@ -961,9 +961,13 @@ be_do_installboot_helper(zpool_handle_t *zphp, nvlist_t *child, char *stage1,
 			    "%s %s %s %s %s", BE_INSTALL_GRUB, flag,
 			    stage1, stage2, diskname);
 		} else {
+			/*
+			 * With updated installboot, we only need boot
+			 * directory.
+			 */
 			(void) snprintf(install_cmd, sizeof (install_cmd),
-			    "%s %s %s %s %s", BE_INSTALL_BOOT, flag,
-			    stage1, stage2, diskname);
+			    "%s %s -b %s %s", BE_INSTALL_BOOT, flag,
+			    stage1, diskname);
 		}
 	} else if (be_is_isa("sparc")) {
 		if ((flags & BE_INSTALLBOOT_FLAG_FORCE) ==
@@ -1326,9 +1330,8 @@ be_do_installboot(be_transaction_data_t *bt, uint16_t flags)
 			    tmp_mntpt, BE_GRUB_STAGE_2);
 		} else {
 			(void) snprintf(stage1, sizeof (stage1), "%s%s",
-			    tmp_mntpt, BE_LOADER_STAGE_1);
-			(void) snprintf(stage2, sizeof (stage2), "%s%s",
-			    tmp_mntpt, BE_LOADER_STAGE_2);
+			    tmp_mntpt, BE_LOADER_STAGES);
+			/* Skip stage2 */
 		}
 	} else if (be_is_isa("sparc")) {
 		char *platform = be_get_platform();
diff --git a/usr/src/lib/libbe/common/libbe_priv.h b/usr/src/lib/libbe/common/libbe_priv.h
index cdae3a7413..cbd382242b 100644
--- a/usr/src/lib/libbe/common/libbe_priv.h
+++ b/usr/src/lib/libbe/common/libbe_priv.h
@@ -63,8 +63,7 @@ extern "C" {
 #define	BE_GRUB_STAGE_1		"/boot/grub/stage1"
 #define	BE_GRUB_STAGE_2		"/boot/grub/stage2"
 #define	BE_INSTALL_BOOT		"/usr/sbin/installboot"
-#define	BE_LOADER_STAGE_1	"/boot/pmbr"
-#define	BE_LOADER_STAGE_2	"/boot/gptzfsboot"
+#define	BE_LOADER_STAGES	"/boot"
 #define	BE_SPARC_BOOTBLK	"/lib/fs/zfs/bootblk"
 
 #define	ZFS_CLOSE(_zhp) \
diff --git a/usr/src/man/man1m/installboot.1m b/usr/src/man/man1m/installboot.1m
index bbc6bdb188..6c4e9d035e 100644
--- a/usr/src/man/man1m/installboot.1m
+++ b/usr/src/man/man1m/installboot.1m
@@ -9,9 +9,9 @@
 .\" http://www.illumos.org/license/CDDL.
 .\"
 .\"
-.\" Copyright 2018 Toomas Soome <tsoome@me.com>
+.\" Copyright 2019 Toomas Soome <tsoome@me.com>
 .\"
-.Dd July 20, 2018
+.Dd Aug 28, 2019
 .Dt INSTALLBOOT 1M
 .Os
 .Sh NAME
@@ -37,8 +37,10 @@
 .Ss x86
 .Nm
 .Op Fl fFmn
+.Op Fl b Ar boot_dir
 .Op Fl u Ar verstr
-.Ar stage1 stage2 raw-device
+.Op Ar stage1 stage2
+raw-device
 .Nm
 .Op Fl enV
 .Fl i
@@ -61,7 +63,7 @@ the disk slice,
 command will split the zfs boot loader between disk slice boot area, and zfs
 pool boot area.
 .Pp
-The x86 systems have boot loader implemented as three stages:
+The x86 BIOS systems have boot loader implemented as three stages:
 .Bl -tag -width Ds
 .It Sy stage1
 .Pa /boot/pmbr
@@ -116,11 +118,39 @@ tag in
 .Xr format 1M
 partition menu.
 .El
+.Pp
+The x86 UEFI systems load and start boot loader program from
+.Sy /EFI/Boot
+directory of the EFI System Partition (ESP).
+The boot loader program in ESP is named
+.Sy bootx86.efi
+for AMD64 system and
+.Sy bootia32.efi
+for i386 system.
+Note, only a 64-bit kernel is supported, even on i386 systems.
+The
+.Sy bootia32.efi
+boot program is only provided to support systems with 32-bit UEFI firmware,
+but which can support 64-bit mode.
+.Pp
+The
+.Sy bootx86.efi
+is copied from
+.Sy /boot/loader64.efi
+and
+.Sy bootia32.efi
+is copied from
+.Sy /boot/loader32.efi .
 .Ss Options
 The
 .Nm
 command accepts the following options:
 .Bl -tag -width Ds
+.It Fl b Ar boot_dir
+Provide path to the directory, where loader boot programs are located.
+.Nm
+will automatically pick the needed programs and will install to the
+specified disk device.
 .It Fl h
 Prints short usage message.
 .It Fl m