installboot: fix stage2 size check for MBR

[unleashed.git] / usr / src / cmd / boot / installboot / i386 / installboot.c

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

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <locale.h>
#include <strings.h>
#include <libfdisk.h>

#include <sys/dktp/fdisk.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/multiboot.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/efi_partition.h>
#include <libfstyp.h>
#include <uuid/uuid.h>

#include "installboot.h"
#include "../../common/bblk_einfo.h"
#include "../../common/boot_utils.h"
#include "../../common/mboot_extra.h"
#include "getresponse.h"

#ifndef TEXT_DOMAIN
#define TEXT_DOMAIN     "SUNW_OST_OSCMD"
#endif

/*
 * BIOS bootblock installation:
 *
 * 1. MBR is first sector of the disk. If the file system on target is
 *    ufs or zfs, the same MBR code is installed on first sector of the
 *    partition as well; this will allow to have real MBR sector to be
 *    replaced by some other boot loader and have illumos chainloaded.
 *
 * installboot will record the start LBA and size of stage2 code in MBR code.
 * On boot, the MBR code will read the stage2 code and executes it.
 *
 * 2. Stage2 location depends on file system type;
 *    In case of zfs, installboot will store stage2 to zfs bootblk area,
 *    which is 512k bytes from partition start and size is 3.5MB.
 *
 *    In case of ufs, the stage2 location is 50 512B sectors from
 *    Solaris2 MBR partition start, within boot slice, boot slice size is
 *    one cylinder.
 *
 *    In case of pcfs, the stage2 location is 50 512B sectors from beginning
 *    of the disk, filling the space between MBR and first partition.
 *    This location assumes no other bootloader and the space is one cylinder,
 *    as first partition is starting from cylinder 1.
 *
 *    In case of GPT partitioning and if file system is not zfs, the boot
 *    support is only possible with dedicated boot partition. For GPT,
 *    the current implementation is using BOOT partition, which must exist.
 *    BOOT partition does only contain raw boot blocks, without any file system.
 *
 * Loader stage2 is created with embedded version, by using fake multiboot (MB)
 * header within first 32k and EINFO block is at the end of the actual
 * boot block. MB header load_addr is set to 0 and load_end_addr is set to
 * actual block end, so the EINFO size is (file size - load_end_addr).
 * installboot does also store the illumos boot partition LBA to MB space,
 * starting from bss_end_addr structure member location; stage2 will
 * detect the partition and file system based on this value.
 *
 * Stored location values in MBR/stage2 also mean the bootblocks must be
 * 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;

/* Versioning string, if present. */
static char             *update_str;

/*
 * Temporary buffer to store the first 32K of data looking for a multiboot
 * signature.
 */
char                    mboot_scan[MBOOT_SCAN_SIZE];

/* Function prototypes. */
static void check_options(char *);
static int get_start_sector(ib_device_t *);

static int read_stage1_from_file(char *, ib_data_t *data);
static int read_bootblock_from_file(char *, ib_data_t *data);
static int read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *,
    char **);
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 usage(char *);

static int
read_stage1_from_file(char *path, ib_data_t *dest)
{
        int     fd;

        assert(dest != 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);
        }
        (void) close(fd);
        return (BC_SUCCESS);
}

static int
read_bootblock_from_file(char *file, ib_data_t *data)
{
        ib_bootblock_t  *bblock = &data->bootblock;
        struct stat     sb;
        uint32_t        buf_size;
        uint32_t        mboot_off;
        int             fd = -1;
        int             retval = BC_ERROR;

        assert(data != NULL);
        assert(file != NULL);

        fd = open(file, O_RDONLY);
        if (fd == -1) {
                BOOT_DEBUG("Error opening %s\n", file);
                perror("open");
                goto out;
        }

        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;

        if (read(fd, bblock->file, bblock->buf_size) != bblock->buf_size) {
                BOOT_DEBUG("Read from %s failed\n", file);
                perror("read");
                goto outfd;
        }

        if (find_multiboot(bblock->file, MBOOT_SCAN_SIZE, &mboot_off)
            != BC_SUCCESS) {
                (void) fprintf(stderr,
                    gettext("Unable to find multiboot header\n"));
                goto outfd;
        }

        bblock->mboot = (multiboot_header_t *)(bblock->file + mboot_off);
        bblock->mboot_off = mboot_off;

        bblock->file_size =
            bblock->mboot->load_end_addr - bblock->mboot->load_addr;
        BOOT_DEBUG("bootblock file size is %d\n", bblock->file_size);

        bblock->extra = bblock->buf + P2ROUNDUP(bblock->file_size, 8);
        bblock->extra_size = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);

        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);

        (void) close(fd);
        return (BC_SUCCESS);

outbuf:
        (void) free(bblock->buf);
        bblock->buf = NULL;
outfd:
        (void) close(fd);
out:
        return (retval);
}

static int
read_bootblock_from_disk(ib_device_t *device, ib_bootblock_t *bblock,
    char **path)
{
        int                     dev_fd;
        uint32_t                size, offset;
        uint32_t                buf_size;
        uint32_t                mboot_off;
        multiboot_header_t      *mboot;

        assert(device != NULL);
        assert(bblock != NULL);

        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 (read_in(dev_fd, mboot_scan, sizeof (mboot_scan), offset)
            != BC_SUCCESS) {
                BOOT_DEBUG("Error reading bootblock area\n");
                perror("read");
                return (BC_ERROR);
        }

        /* 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);
        }
        mboot = (multiboot_header_t *)(mboot_scan + mboot_off);

        /*
         * make sure mboot has sane values
         */
        if (mboot->load_end_addr == 0 ||
            mboot->load_end_addr < mboot->load_addr)
                return (BC_NOEXTRA);

        /*
         * Currently, the amount of space reserved for extra information
         * is "fixed". We may have to scan for the terminating extra payload
         * in the future.
         */
        size = mboot->load_end_addr - mboot->load_addr;
        buf_size = P2ROUNDUP(size + SECTOR_SIZE, SECTOR_SIZE);
        bblock->file_size = size;

        bblock->buf = malloc(buf_size);
        if (bblock->buf == NULL) {
                BOOT_DEBUG("Unable to allocate enough memory to read"
                    " the extra bootblock from the disk\n");
                perror(gettext("Memory allocation failure"));
                return (BC_ERROR);
        }
        bblock->buf_size = buf_size;

        if (read_in(dev_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);
        }

        /* Update pointers. */
        bblock->file = bblock->buf;
        bblock->mboot_off = mboot_off;
        bblock->mboot = (multiboot_header_t *)(bblock->buf + bblock->mboot_off);
        bblock->extra = bblock->buf + P2ROUNDUP(bblock->file_size, 8);
        bblock->extra_size = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8);

        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);

        return (BC_SUCCESS);
}

static boolean_t
is_update_necessary(ib_data_t *data, char *updt_str)
{
        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;

        assert(data != NULL);

        bzero(&bblock_disk, sizeof (ib_bootblock_t));

        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);
        }

        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);
        }

        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 (!do_version || updt_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"), device->path);
                return (B_TRUE);
        }

        if (force_update) {
                BOOT_DEBUG("Forcing update of %s bootblock\n", device->path);
                return (B_TRUE);
        }

        BOOT_DEBUG("Ready to check installed version vs %s\n", updt_str);

        bblock_hs.src_buf = (unsigned char *)bblock_file->file;
        bblock_hs.src_size = bblock_file->file_size;

        return (einfo_should_update(einfo, &bblock_hs, updt_str));
}

static void
add_bootblock_einfo(ib_bootblock_t *bblock, char *updt_str)
{
        bblk_hs_t       hs;
        uint32_t        avail_space;

        assert(bblock != NULL);

        if (updt_str == NULL) {
                BOOT_DEBUG("WARNING: no update string passed to "
                    "add_bootblock_einfo()\n");
                return;
        }

        /* 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 int
prepare_stage1(ib_data_t *data)
{
        ib_device_t     *device;

        assert(data != NULL);
        device = &data->device;

        /* copy BPB */
        bcopy(device->mbr + STAGE1_BPB_OFFSET,
            data->stage1 + STAGE1_BPB_OFFSET, STAGE1_BPB_SIZE);


        /* copy MBR, note STAGE1_SIG == BOOTSZ */
        bcopy(device->mbr + STAGE1_SIG, data->stage1 + STAGE1_SIG,
            SECTOR_SIZE - STAGE1_SIG);

        /* set stage2 size */
        *((uint16_t *)(data->stage1 + STAGE1_STAGE2_SIZE)) =
            (uint16_t)(data->bootblock.buf_size / SECTOR_SIZE);

        /*
         * 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;
        }

        /*
         * 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);

        return (BC_SUCCESS);
}

static int
prepare_bootblock(ib_data_t *data, char *updt_str)
{
        ib_bootblock_t          *bblock;
        ib_device_t             *device;
        uint64_t                *ptr;

        assert(data != NULL);

        bblock = &data->bootblock;
        device = &data->device;

        ptr = (uint64_t *)(&bblock->mboot->bss_end_addr);
        *ptr = device->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);

        return (BC_SUCCESS);
}

static int
write_bootblock(ib_data_t *data)
{
        ib_device_t     *device = &data->device;
        ib_bootblock_t  *bblock = &data->bootblock;
        uint64_t abs;
        int dev_fd, ret;
        off_t offset;
        char *path;

        assert(data != NULL);

        /*
         * 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);
        }

        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);
                }
        }
        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);
        }

        (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);

        return (BC_SUCCESS);
}

static int
write_stage1(ib_data_t *data)
{
        ib_device_t     *device = &data->device;

        assert(data != NULL);

        /*
         * Partition boot block or volume boot record.
         * This is essentially copy of MBR (1 sector) and we store it
         * to support multi boot setups.
         *
         * Not all combinations are supported; as pcfs does not leave
         * space, we will not write to pcfs target.
         * In addition, in VTOC setup, we will only write VBR to slice 2.
         */
        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);
                }

                (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);
        }

        /*
         * both ufs and zfs have initial 8k reserved for VTOC/boot
         * so its safe to use this area. however, only
         * write to target if we have MBR/GPT.
         */
        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);
                }

                (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);
        }

        if (write_mbr) {
                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"));
        }

        return (BC_SUCCESS);
}

/*
 * 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)
{
        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;
                }

                device->target.start =
                    vtoc->efi_parts[device->target.id].p_start;
                device->target.size =
                    vtoc->efi_parts[device->target.id].p_size;

                /* with pcfs we always write MBR */
                if (device->target.fstype == IG_FS_PCFS) {
                        force_mbr = 1;
                        write_mbr = 1;
                }

                efi_free(vtoc);
                goto found_part;
        }

        mboot = (struct mboot *)device->mbr;

        /* 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;

                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;

                /* with pcfs we always write MBR */
                if (device->target.fstype == IG_FS_PCFS) {
                        force_mbr = 1;
                        write_mbr = 1;
                }
                if (device->target.fstype == IG_FS_ZFS)
                        device->target.offset = BBLK_ZFS_BLK_OFF;

                goto found_part;
        }

        /*
         * 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) {
                        (void) fprintf(stderr, gettext("cannot get the "
                            "slice information of the disk\n"));
                        return (BC_ERROR);
                } else {
                        edkpi.p_start = dkpi.p_start;
                        edkpi.p_length = dkpi.p_length;
                }
        }

        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;

                if (part->relsect == 0) {
                        (void) fprintf(stderr, gettext("Partition %d of the "
                            "disk has an incorrect offset\n"), i+1);
                        return (BC_ERROR);
                }

                if (edkpi.p_start >= part->relsect &&
                    edkpi.p_start < (part->relsect + part->numsect)) {
                        /* Found the partition */
                        break;
                }
        }

        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);
        }

        /*
         * 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;
        }

        /*
         * 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) {
                switch (rval) {
                        /*
                         * The first 3 cases are not an error per-se, just that
                         * there is no Solaris logical partition
                         */
                        case FDISK_EBADLOGDRIVE:
                        case FDISK_ENOLOGDRIVE:
                        case FDISK_EBADMAGIC:
                                (void) fprintf(stderr, gettext("Solaris "
                                    "partition not found. "
                                    "Aborting operation.\n"));
                                return (BC_ERROR);
                        case FDISK_ENOVGEOM:
                                (void) fprintf(stderr, gettext("Could not get "
                                    "virtual geometry\n"));
                                return (BC_ERROR);
                        case FDISK_ENOPGEOM:
                                (void) fprintf(stderr, gettext("Could not get "
                                    "physical geometry\n"));
                                return (BC_ERROR);
                        case FDISK_ENOLGEOM:
                                (void) fprintf(stderr, gettext("Could not get "
                                    "label geometry\n"));
                                return (BC_ERROR);
                        default:
                                (void) fprintf(stderr, gettext("Failed to "
                                    "initialize libfdisk.\n"));
                                return (BC_ERROR);
                }
        }

        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);
        }

        device->stage.start = secnum;
        device->stage.size = numsec;
        device->stage.id = pno;
        log_part = 1;

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);
                }
        }

        /*
         * 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);
                }
        }

        return (BC_SUCCESS);
}

static int
open_device(char *path)
{
        struct stat     statbuf = {0};
        int             fd = -1;

        if (nowrite)
                fd = open(path, O_RDONLY);
        else
                fd = open(path, O_RDWR);

        if (fd == -1) {
                BOOT_DEBUG("Unable to open %s\n", path);
                perror("open");
                return (-1);
        }

        if (fstat(fd, &statbuf) != 0) {
                BOOT_DEBUG("Unable to stat %s\n", path);
                perror("stat");
                (void) close(fd);
                return (-1);
        }

        if (S_ISCHR(statbuf.st_mode) == 0) {
                (void) fprintf(stderr, gettext("%s: Not a character device\n"),
                    path);
                (void) close(fd);
                return (-1);
        }

        return (fd);
}

static int
get_boot_partition(ib_device_t *device, struct mboot *mbr)
{
        struct ipart *part;
        char *path, *ptr;
        int i;

        part = (struct ipart *) mbr->parts;
        for (i = 0; i < FD_NUMPART; i++) {
                if (part[i].systid == X86BOOT)
                        break;
        }

        /* 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) {
                        perror(gettext("Memory allocation failure"));
                        return (BC_ERROR);
                }
                device->stage.fd = dup(device->fd);
                device->stage.id = 0;
                device->stage.devtype = IG_DEV_MBR;
                device->stage.fstype = IG_FS_NONE;
                device->stage.start = 0;
                device->stage.size = part[0].relsect;
                device->stage.offset = BBLK_BLKLIST_OFF;
                return (BC_SUCCESS);
        }

        if ((path = strdup(device->path)) == NULL) {
                perror(gettext("Memory allocation failure"));
                return (BC_ERROR);
        }

        ptr = strrchr(path, 'p');
        ptr++;
        *ptr = '\0';
        (void) asprintf(&ptr, "%s%d", path, i+1); /* partitions are p1..p4 */
        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 + 1;
        device->stage.devtype = IG_DEV_MBR;
        device->stage.fstype = IG_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);
}

static int
get_boot_slice(ib_device_t *device, struct dk_gpt *vtoc)
{
        uint_t i;
        char *path, *ptr;

        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);
                }
        }
        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;

        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 */

        /* 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"));
        }

        device->target.path = strdup(path);
        if (device->target.path == NULL) {
                perror(gettext("Memory allocation failure"));
                return (BC_ERROR);
        }
        device->path = strdup(path);
        if (device->path == NULL) {
                perror(gettext("Memory allocation failure"));
                return (BC_ERROR);
        }

        /* change device name to p0 */
        device->path[pathlen - 2] = 'p';
        device->path[pathlen - 1] = '0';

        if (strstr(device->target.path, "diskette")) {
                (void) fprintf(stderr, gettext("installing loader to a floppy "
                    "disk is not supported\n"));
                return (BC_ERROR);
        }

        /* 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);
        }

        if ((device->fd = open_device(device->path)) == -1)
                return (BC_ERROR);

        /* 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"));
                perror("read");
                return (BC_ERROR);
        }

        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.
                 */
                (void) fprintf(stderr,
                    gettext("raw device must be a root slice (not s2)\n"));
                return (BC_ERROR);
        }

        /* 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);
        }

        p = strrchr(device->target.path, 'p');
        if (p == NULL)
                p = strrchr(device->target.path, 's');
        device->target.id = atoi(++p);

        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);

        if (fstyp_init(device->target.fd, 0, NULL, &fhdl) != 0)
                return (BC_ERROR);

        if (fstyp_ident(fhdl, NULL, &fident) != 0) {
                fstyp_fini(fhdl);
                (void) fprintf(stderr, gettext("Failed to detect file "
                    "system type\n"));
                return (BC_ERROR);
        }

        /* 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);
        }
        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);
        }
        fstyp_fini(fhdl);

        /* check for boot partition content */
        if (device->stage.size) {
                if (fstyp_init(device->stage.fd, 0, NULL, &fhdl) != 0)
                        return (BC_ERROR);

                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);
        }
        return (get_start_sector(device));
}

static void
cleanup_device(ib_device_t *device)
{
        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));
}

static void
cleanup_bootblock(ib_bootblock_t *bblock)
{
        free(bblock->buf);
        bzero(bblock, sizeof (ib_bootblock_t));
}

/*
 * 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)
{
        ib_bootblock_t  *src_bblock = &src->bootblock;
        ib_bootblock_t  *dest_bblock = &dest->bootblock;

        assert(src != NULL);
        assert(dest != NULL);

        /* 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);
        }

        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);
        }
        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);

        return (commit_to_disk(dest, updt_str));
}

static int
commit_to_disk(ib_data_t *data, char *update_str)
{
        assert(data != NULL);

        if (prepare_bootblock(data, update_str) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error updating the bootblock "
                    "image\n"));
                return (BC_ERROR);
        }

        if (prepare_stage1(data) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error updating the stage1 "
                    "image\n"));
                return (BC_ERROR);
        }

        if (write_bootblock(data) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error writing bootblock to "
                    "disk\n"));
                return (BC_ERROR);
        }

        return (write_stage1(data));
}

/*
 * Install a new bootblock on the given device. handle_install() expects argv
 * to contain 3 parameters (the target device path and the path to the
 * bootblock.
 *
 * Returns:     BC_SUCCESS - if the installation is successful
 *              BC_ERROR   - if the installation failed
 *              BC_NOUPDT  - if no installation was performed because the
 *                           version currently installed is more recent than the
 *                           supplied one.
 *
 */
static int
handle_install(char *progname, char **argv)
{
        ib_data_t       install_data;
        char            *stage1 = NULL;
        char            *bootblock = NULL;
        char            *device_path = NULL;
        int             ret = BC_ERROR;

        stage1 = strdup(argv[0]);
        bootblock = strdup(argv[1]);
        device_path = strdup(argv[2]);

        if (!device_path || !bootblock || !stage1) {
                (void) fprintf(stderr, gettext("Missing parameter"));
                usage(progname);
                goto out;
        }

        BOOT_DEBUG("device path: %s, stage1 path: %s bootblock path: %s\n",
            device_path, stage1, bootblock);
        bzero(&install_data, sizeof (ib_data_t));

        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 (read_bootblock_from_file(bootblock, &install_data) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error reading %s\n"),
                    bootblock);
                goto out_dev;
        }

        /*
         * 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;
        }

        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(stage1);
        free(bootblock);
        free(device_path);
        return (ret);
}

/*
 * Retrieves from a device the extended information (einfo) associated to the
 * installed stage2.
 * Expects one parameter, the device path, in the form: /dev/rdsk/c?[t?]d?s0.
 * Returns:
 *        - BC_SUCCESS (and prints out einfo contents depending on 'flags')
 *        - BC_ERROR (on error)
 *        - BC_NOEINFO (no extended information available)
 */
static int
handle_getinfo(char *progname, char **argv)
{

        ib_data_t       data;
        ib_bootblock_t  *bblock = &data.bootblock;
        ib_device_t     *device = &data.device;
        bblk_einfo_t    *einfo;
        uint8_t         flags = 0;
        char            *device_path, *path;
        int             retval = BC_ERROR;
        int             ret;

        device_path = strdup(argv[0]);
        if (!device_path) {
                (void) fprintf(stderr, gettext("Missing parameter"));
                usage(progname);
                goto out;
        }

        bzero(&data, sizeof (ib_data_t));
        BOOT_DEBUG("device path: %s\n", device_path);

        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 (ret == BC_ERROR) {
                (void) fprintf(stderr, gettext("Error reading bootblock from "
                    "%s\n"), path);
                goto out_dev;
        }

        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;
        }

        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;
        }

        /* 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:
        cleanup_device(&data.device);
out:
        free(device_path);
        return (retval);
}

/*
 * Attempt to mirror (propagate) the current bootblock over the attaching disk.
 *
 * Returns:
 *      - BC_SUCCESS (a successful propagation happened)
 *      - BC_ERROR (an error occurred)
 *      - BC_NOEXTRA (it is not possible to dump the current bootblock since
 *                      there is no multiboot information)
 */
static int
handle_mirror(char *progname, 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;
        int             retval = BC_ERROR;
        int             ret;

        curr_device_path = strdup(argv[0]);
        attach_device_path = strdup(argv[1]);

        if (!curr_device_path || !attach_device_path) {
                (void) fprintf(stderr, gettext("Missing parameter"));
                usage(progname);
                goto out;
        }
        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));

        if (init_device(curr_device, curr_device_path) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Unable to gather device "
                    "information from %s (current device)\n"),
                    curr_device_path);
                goto out_currdev;
        }

        if (init_device(attach_device, 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;
        }

        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;
        }

        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;
        }

        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);

        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);
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\n"

#define CANON_USAGE_STR gettext(USAGE_STRING)

static void
usage(char *progname)
{
        (void) fprintf(stdout, CANON_USAGE_STR, progname, progname, progname);
}

int
main(int argc, char **argv)
{
        int     opt;
        int     params = 3;
        int     ret;
        char    *progname;
        char    **handle_args;

        (void) setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);
        if (init_yes() < 0) {
                (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
                    strerror(errno));
                exit(BC_ERROR);
        }

        while ((opt = getopt(argc, argv, "deFfhiMmnu:V")) != EOF) {
                switch (opt) {
                case 'd':
                        boot_debug = B_TRUE;
                        break;
                case 'e':
                        strip = B_TRUE;
                        break;
                case 'F':
                        force_update = B_TRUE;
                        break;
                case 'f':
                        force_mbr = B_TRUE;
                        break;
                case 'h':
                        usage(argv[0]);
                        exit(BC_SUCCESS);
                        break;
                case 'i':
                        do_getinfo = B_TRUE;
                        params = 1;
                        break;
                case 'M':
                        do_mirror_bblk = B_TRUE;
                        params = 2;
                        break;
                case 'm':
                        write_mbr = B_TRUE;
                        break;
                case 'n':
                        nowrite = B_TRUE;
                        break;
                case 'u':
                        do_version = B_TRUE;

                        update_str = malloc(strlen(optarg) + 1);
                        if (update_str == NULL) {
                                perror(gettext("Memory allocation failure"));
                                exit(BC_ERROR);
                        }
                        (void) strlcpy(update_str, optarg, strlen(optarg) + 1);
                        break;
                case 'V':
                        verbose_dump = B_TRUE;
                        break;
                default:
                        /* fall through to process non-optional args */
                        break;
                }
        }

        /* check arguments */
        if (argc != optind + params) {
                usage(argv[0]);
                exit(BC_ERROR);
        }
        progname = argv[0];
        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);
        } else if (do_mirror_bblk) {
                ret = handle_mirror(progname, handle_args);
        } else {
                ret = handle_install(progname, handle_args);
        }
        return (ret);
}

#define MEANINGLESS_OPT gettext("%s specified but meaningless, ignoring\n")
static void
check_options(char *progname)
{
        if (do_getinfo && do_mirror_bblk) {
                (void) fprintf(stderr, gettext("Only one of -M and -i can be "
                    "specified at the same time\n"));
                usage(progname);
                exit(BC_ERROR);
        }

        if (do_mirror_bblk) {
                /*
                 * -u and -F may actually reflect a user intent that is not
                 * correct with this command (mirror can be interpreted
                 * "similar" to install. Emit a message and continue.
                 * -e and -V have no meaning, be quiet here and only report the
                 * incongruence if a debug output is requested.
                 */
                if (do_version) {
                        (void) fprintf(stderr, MEANINGLESS_OPT, "-u");
                        do_version = B_FALSE;
                }
                if (force_update) {
                        (void) fprintf(stderr, MEANINGLESS_OPT, "-F");
                        force_update = B_FALSE;
                }
                if (strip || verbose_dump) {
                        BOOT_DEBUG(MEANINGLESS_OPT, "-e|-V");
                        strip = B_FALSE;
                        verbose_dump = B_FALSE;
                }
        }

        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;
                }
        }
}