installboot: remove installboot script from i386 platform

[unleashed.git] / usr / src / cmd / boot / installboot / 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.
 */

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <locale.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/multiboot.h>
#include <sys/sysmacros.h>

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

#ifndef TEXT_DOMAIN
#define TEXT_DOMAIN     "SUNW_OST_OSCMD"
#endif

/*
 * SPARC bootblock installation:
 *
 * The bootblock resides in blocks 1 to 15 (disk label is at block 0).
 * The ZFS boot block is larger than what will fit into these first 7.5K so we
 * break it up and write the remaining portion into the ZFS provided boot block
 * region at offset 512K. If versioning is requested, we add a multiboot
 * header at the end of the bootblock, followed by the extra payload area and
 * place the extended information structure within the latter.
 */

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 char             *update_str;
static int              tgt_fs_type = TARGET_IS_UFS;
char                    mboot_scan[MBOOT_SCAN_SIZE];

/* Function prototypes. */
static int read_bootblock_from_file(char *, ib_data_t *data);
static int read_bootblock_from_disk(int, ib_bootblock_t *);
static void add_bootblock_einfo(ib_bootblock_t *, char *);
static int prepare_bootblock(ib_data_t *, char *);
static int write_zfs_bootblock(ib_data_t *);
static int write_bootblock(ib_data_t *);
static int open_device(ib_device_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_bootblock_from_file(char *file, ib_data_t *data)
{
        ib_device_t     *device = &data->device;
        ib_bootblock_t  *bblock = &data->bootblock;
        struct stat     sb;
        uint32_t        buf_size;
        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;
        }

        bblock->file_size = sb.st_size;
        BOOT_DEBUG("bootblock file size is %x\n", bblock->file_size);

        /* UFS and HSFS bootblocks need to fit in the reserved 7.5K. */
        if (!is_zfs(device->type)) {
                buf_size = P2ROUNDUP(bblock->file_size, SECTOR_SIZE);
                if (buf_size > BBLK_DATA_RSVD_SIZE) {
                        BOOT_DEBUG("boot block size is bigger than allowed\n");
                        goto outfd;
                }
        } else {
                buf_size = P2ROUNDUP(bblock->file_size + SECTOR_SIZE,
                    SECTOR_SIZE);
                if (buf_size > BBLK_DATA_RSVD_SIZE + MBOOT_SCAN_SIZE) {
                        (void) fprintf(stderr, gettext("WARNING, bootblock size"
                            " does not allow to place extended versioning "
                            "information.. skipping\n"));
                        do_version = B_FALSE;
                }
        }

        bblock->buf_size = buf_size;
        BOOT_DEBUG("bootblock in-memory buffer size is %x\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->file_size) != bblock->file_size) {
                BOOT_DEBUG("Read from %s failed\n", file);
                perror("read");
                goto outfd;
        }

        /* If not on ZFS, we are done here. */
        if (!is_zfs(device->type)) {
                BOOT_DEBUG("Reading of the bootblock done\n");
                retval = BC_SUCCESS;
                goto outfd;
        }
        /*
         * We place the multiboot header right after the file, followed by
         * the extended information structure.
         */
        bblock->mboot = (multiboot_header_t *)(bblock->file +
            P2ROUNDUP(bblock->file_size, 8));
        bblock->extra = (char *)bblock->mboot + sizeof (multiboot_header_t);
        BOOT_DEBUG("mboot at %p, extra at %p, buf=%p (size=%d)\n",
            bblock->mboot, bblock->extra, 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(int dev_fd, ib_bootblock_t *bblock)
{
        char                    *dest;
        uint32_t                size;
        uint32_t                buf_size;
        uint32_t                mboot_off;
        multiboot_header_t      *mboot;

        assert(bblock != NULL);
        assert(dev_fd != -1);

        /*
         * The ZFS bootblock is divided in two parts, but the fake multiboot
         * header can only be in the second part (the one contained in the ZFS
         * reserved area).
         */
        if (read_in(dev_fd, mboot_scan, sizeof (mboot_scan),
            BBLK_ZFS_EXTRA_OFF) != BC_SUCCESS) {
                BOOT_DEBUG("Error reading ZFS reserved 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);

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

        dest = bblock->buf;
        size = BBLK_DATA_RSVD_SIZE;

        if (read_in(dev_fd, dest, size, SECTOR_SIZE) != BC_SUCCESS) {
                BOOT_DEBUG("Error reading first %d bytes of the bootblock\n",
                    size);
                (void) free(bblock->buf);
                bblock->buf = NULL;
                return (BC_ERROR);
        }

        dest += BBLK_DATA_RSVD_SIZE;
        size = bblock->buf_size - BBLK_DATA_RSVD_SIZE;

        if (read_in(dev_fd, dest, size, BBLK_ZFS_EXTRA_OFF) != BC_SUCCESS) {
                BOOT_DEBUG("Error reading ZFS reserved area the second time\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
            + BBLK_DATA_RSVD_SIZE);
        bblock->extra = (char *)bblock->mboot + sizeof (multiboot_header_t);
        bblock->extra_size = bblock->buf_size - bblock->mboot_off
            - BBLK_DATA_RSVD_SIZE - sizeof (multiboot_header_t);
        return (BC_SUCCESS);
}

static boolean_t
is_update_necessary(ib_data_t *data, char *updt_str)
{
        bblk_einfo_t    *einfo;
        bblk_hs_t       bblock_hs;
        ib_bootblock_t  bblock_disk;
        ib_bootblock_t  *bblock_file = &data->bootblock;
        ib_device_t     *device = &data->device;
        int             dev_fd = device->fd;

        assert(data != NULL);
        assert(device->fd != -1);

        /* Nothing to do if we are not updating a ZFS bootblock. */
        if (!is_zfs(device->type))
                return (B_TRUE);

        bzero(&bblock_disk, sizeof (ib_bootblock_t));

        if (read_bootblock_from_disk(dev_fd, &bblock_disk) != BC_SUCCESS) {
                BOOT_DEBUG("Unable to read bootblock from %s\n", device->path);
                return (B_TRUE);
        }

        einfo = find_einfo(bblock_disk.extra, bblock_disk.extra_size);
        if (einfo == NULL) {
                BOOT_DEBUG("No extended information available\n");
                return (B_TRUE);
        }

        if (!do_version || updt_str == NULL) {
                (void) fprintf(stdout, "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);
}


static int
prepare_bootblock(ib_data_t *data, char *updt_str)
{
        ib_device_t             *device = &data->device;
        ib_bootblock_t          *bblock = &data->bootblock;
        multiboot_header_t      *mboot;

        assert(data != NULL);

        /* Nothing to do if we are not on ZFS. */
        if (!is_zfs(device->type))
                return (BC_SUCCESS);

        /*
         * Write the fake multiboot structure followed by the extra information
         * data. Both mboot and extra pointers have already been filled up to
         * point to the right location in the buffer. We prepare the fake
         * multiboot regardless if versioning was requested or not because
         * we need it for mirroring support.
         */
        assert(bblock->mboot != NULL);
        assert(bblock->extra != NULL);

        mboot = bblock->mboot;

        mboot->magic = MB_HEADER_MAGIC;
        mboot->flags = MB_HEADER_FLAGS_64;
        mboot->checksum = -(mboot->flags + mboot->magic);
        /*
         * Flags include the AOUT_KLUDGE and we use the extra members to specify
         * the size of the bootblock.
         */
        mboot->header_addr = bblock->mboot_off;
        mboot->load_addr = 0;
        mboot->load_end_addr = bblock->file_size;

        /*
         * Now that we have the mboot header in place, we can add the extended
         * versioning information. Since the multiboot header has been placed
         * after the file image, the hashing will still reflect the one of the
         * file on the disk.
         */
        if (do_version)
                add_bootblock_einfo(bblock, updt_str);

        return (BC_SUCCESS);
}

static int
write_zfs_bootblock(ib_data_t *data)
{
        ib_device_t     *device = &data->device;
        ib_bootblock_t  *bblock = &data->bootblock;
        char            *bufptr;
        uint32_t        size;

        assert(data != NULL);
        assert(device->fd != -1);

        /*
         * In the ZFS case we actually perform two different steps:
         * - write the first 15 blocks of the bootblock to the reserved disk
         *   blocks.
         * - write the remaining blocks in the ZFS reserved area at offset
         *   512K.
         */
        bufptr = bblock->buf;
        size = BBLK_DATA_RSVD_SIZE;

        if (write_out(device->fd, bufptr, size, SECTOR_SIZE) != BC_SUCCESS) {
                BOOT_DEBUG("Error writing first 15 blocks of %s\n",
                    device->path);
                perror("write");
                return (BC_ERROR);
        }

        bufptr += BBLK_DATA_RSVD_SIZE;
        size = bblock->buf_size - BBLK_DATA_RSVD_SIZE;

        if (write_out(device->fd, bufptr, size, BBLK_ZFS_EXTRA_OFF)
            != BC_SUCCESS) {
                BOOT_DEBUG("Error writing the second part of ZFS bootblock "
                    "to %s at offset %d\n", device->path, BBLK_ZFS_EXTRA_OFF);
                return (BC_ERROR);
        }
        return (BC_SUCCESS);
}

static int
write_bootblock(ib_data_t *data)
{
        ib_device_t     *device = &data->device;
        ib_bootblock_t  *bblock = &data->bootblock;
        int             ret;

        assert(data != NULL);

        /*
         * If we are on UFS or HSFS we simply write out to the reserved
         * blocks (1 to 15) the boot block.
         */
        if (!is_zfs(device->type)) {
                if (write_out(device->fd, bblock->buf, bblock->buf_size,
                    SECTOR_SIZE) != BC_SUCCESS) {
                        BOOT_DEBUG("Error writing bootblock to %s\n",
                            device->path);
                        return (BC_ERROR);
                } else {
                        return (BC_SUCCESS);
                }
        } else {
                ret = write_zfs_bootblock(data);
                return (ret);
        }
}

static int
open_device(ib_device_t *device)
{
        struct stat     statbuf;

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

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

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

        return (BC_SUCCESS);
}

static int
init_device(ib_device_t *device, char *path)
{
        bzero(device, sizeof (*device));
        device->fd = -1;

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

        device->type = tgt_fs_type;
        if (open_device(device) != BC_SUCCESS)
                return (BC_ERROR);

        return (BC_SUCCESS);
}

static void
cleanup_device(ib_device_t *device)
{
        free(device->path);
        bzero(device, sizeof (*device));

        if (device->fd != -1)
                (void) close(device->fd);
}

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;
        uint32_t        buf_size;

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

        cleanup_bootblock(dest_bblock);

        if (updt_str != NULL) {
                do_version = B_TRUE;
        } else {
                do_version = B_FALSE;
        }

        buf_size = src_bblock->file_size + SECTOR_SIZE;

        dest_bblock->buf_size = P2ROUNDUP(buf_size, SECTOR_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->file, src_bblock->file,
            dest_bblock->file_size);

        dest_bblock->mboot = (multiboot_header_t *)(dest_bblock->file +
            P2ROUNDUP(dest_bblock->file_size, 8));
        dest_bblock->extra = (char *)dest_bblock->mboot +
            sizeof (multiboot_header_t);

        (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 (write_bootblock(data) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error writing bootblock to "
                    "disk\n"));
                return (BC_ERROR);
        }

        return (BC_SUCCESS);
}


/*
 * Install a new bootblock on the given device. handle_install() expects argv
 * to contain 2 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            *bootblock = NULL;
        char            *device_path = NULL;
        int             ret = BC_ERROR;

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

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

        BOOT_DEBUG("device path: %s, bootblock file path: %s\n", device_path,
            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_bootblock_from_file(bootblock, &install_data) != BC_SUCCESS) {
                (void) fprintf(stderr, gettext("Error reading %s\n"),
                    bootblock);
                goto out_dev;
        }
        /* Versioning is only supported for the ZFS bootblock. */
        if (do_version && !is_zfs(install_data.device.type)) {
                (void) fprintf(stderr, gettext("Versioning is only supported on"
                    " ZFS... skipping.\n"));
                do_version = B_FALSE;
        }

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

/*
 * Retrieves from a device the extended information (einfo) associated to the
 * installed bootblock.
 * 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;
        uint32_t        size;
        char            *device_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;
        }

        if (!is_zfs(device->type)) {
                (void) fprintf(stderr, gettext("Versioning only supported on "
                    "ZFS\n"));
                goto out_dev;
        }

        ret = read_bootblock_from_disk(device->fd, bblock);
        if (ret == BC_ERROR) {
                (void) fprintf(stderr, gettext("Error reading bootblock from "
                    "%s\n"), device_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;

        size = bblock->buf_size - P2ROUNDUP(bblock->file_size, 8) -
            sizeof (multiboot_header_t);
        print_einfo(flags, einfo, 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;
        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 (tgt_fs_type != TARGET_IS_ZFS) {
                (void) fprintf(stderr, gettext("Mirroring is only supported on "
                    "ZFS\n"));
                return (BC_ERROR);
        }

        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->fd, bblock_curr);
        if (ret == BC_ERROR) {
                BOOT_DEBUG("Error reading bootblock from %s\n",
                    curr_device->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", curr_device->path);
                retval = BC_NOEXTRA;
                goto out_devs;
        }

        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: %s [-h|-f|-F fstype|-u verstr] bootblk "       \
                        "raw-device\n"                                         \
                        "\t%s [-e|-V] -i -F zfs raw-device\n"                  \
                        "\t%s -M -F zfs raw-device attach-raw-device\n"        \
                        "\tfstype is one of: 'ufs', 'hsfs' or 'zfs'\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 = 2;
        int     ret;
        char    *progname;
        char    **handle_args;

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

        while ((opt = getopt(argc, argv, "F:efiVMndhu:")) != EOF) {
                switch (opt) {
                case 'F':
                        if (strcmp(optarg, "ufs") == 0) {
                                tgt_fs_type = TARGET_IS_UFS;
                        } else if (strcmp(optarg, "hsfs") == 0) {
                                tgt_fs_type = TARGET_IS_HSFS;
                        } else if (strcmp(optarg, "zfs") == 0) {
                                tgt_fs_type = TARGET_IS_ZFS;
                        } else {
                                (void) fprintf(stderr, gettext("Wrong "
                                    "filesystem specified\n\n"));
                                usage(argv[0]);
                                exit(BC_ERROR);
                        }
                        break;
                case 'e':
                        strip = B_TRUE;
                        break;
                case 'f':
                        force_update = B_TRUE;
                        break;
                case 'V':
                        verbose_dump = B_TRUE;
                        break;
                case 'i':
                        do_getinfo = B_TRUE;
                        params = 1;
                        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 'M':
                        do_mirror_bblk = B_TRUE;
                        break;
                case 'h':
                        usage(argv[0]);
                        exit(BC_SUCCESS);
                        break;
                case 'd':
                        boot_debug = B_TRUE;
                        break;
                case 'n':
                        nowrite = 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];
        handle_args = argv + optind;

        /* check options. */
        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 (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);
}