cmd/format/label.c

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

/*
 * This file contains the code relating to label manipulation.
 */

#include "global.h"
#include "label.h"
#include "misc.h"
#include "main.h"
#include "partition.h"
#include "ctlr_scsi.h"
#include "checkdev.h"
#include <string.h>
#include <stdlib.h>
#include <memory.h>
#include <sys/isa_defs.h>
#include <sys/efi_partition.h>
#include <sys/vtoc.h>
#include <sys/uuid.h>
#include <errno.h>
#include <devid.h>

#if defined(_FIRMWARE_NEEDS_FDISK)
#include <sys/dktp/fdisk.h>
#include "menu_fdisk.h"
#endif      /* defined(_FIRMWARE_NEEDS_FDISK) */

#ifndef WD_NODE
#define WD_NODE     7
#endif

#ifdef  __STDC__
/*
 * Prototypes for ANSI C compilers
 */
static int  do_geometry_sanity_check(void);
static int  vtoc_to_label(struct dk_label *label, struct extvtoc *vtoc,
        struct dk_geom *geom, struct dk_cinfo *cinfo);
extern int  read_extvtoc(int, struct extvtoc *);
extern int  write_extvtoc(int, struct extvtoc *);
static int  vtoc64_to_label(struct efi_info *, struct dk_gpt *);

#else   /* __STDC__ */

/*
 * Prototypes for non-ANSI C compilers
 */
static int  do_geometry_sanity_check();
static int  vtoc_to_label();
extern int  read_extvtoc();
extern int  write_extvtoc();
static int  vtoc64_to_label();

#endif  /* __STDC__ */

#ifdef  DEBUG
static void dump_label(struct dk_label *label);
#endif

/*
 * This routine checks the given label to see if it is valid.
 */
int
checklabel(label)
    register struct dk_label *label;
{

    /*
     * Check the magic number.
     */
    if (label->dkl_magic != DKL_MAGIC)
        return (0);
    /*
     * Check the checksum.
     */
    if (checksum(label, CK_CHECKSUM) != 0)
        return (0);
    return (1);
}

/*
 * This routine checks or calculates the label checksum, depending on
 * the mode it is called in.
 */
int
checksum(label, mode)
    struct  dk_label *label;
    int mode;
{
    register short *sp, sum = 0;
    register short count = (sizeof (struct dk_label)) / (sizeof (short));

    /*
     * If we are generating a checksum, don't include the checksum
     * in the rolling xor.
     */
    if (mode == CK_MAKESUM)
        count -= 1;
    sp = (short *)label;
    /*
     * Take the xor of all the half-words in the label.
     */
    while (count--) {
        sum ^= *sp++;
    }
    /*
     * If we are checking the checksum, the total will be zero for
     * a correct checksum, so we can just return the sum.
     */
    if (mode == CK_CHECKSUM)
        return (sum);
    /*
     * If we are generating the checksum, fill it in.
     */
    else {
        label->dkl_cksum = sum;
        return (0);
    }
}

/*
 * This routine is used to extract the id string from the string stored
 * in a disk label.  The problem is that the string in the label has
 * the physical characteristics of the drive appended to it.  The approach
 * is to find the beginning of the physical attributes portion of the string
 * and truncate it there.
 */
int
trim_id(id)
    char    *id;
{
    register char *c;

    /*
     * Start at the end of the string.  When we match the word ' cyl',
     * we are at the beginning of the attributes.
     */
    for (c = id + strlen(id); c >= id; c--) {
        if (strncmp(c, " cyl", strlen(" cyl")) == 0) {
            /*
             * Remove any white space.
             */
            for (; (((*(c - 1) == ' ') || (*(c - 1) == '\t')) &&
                (c >= id)); c--);
            break;
        }
    }
    /*
     * If we ran off the beginning of the string, something is wrong.
     */
    if (c < id)
        return (-1);
    /*
     * Truncate the string.
     */
    *c = '\0';
    return (0);
}

/*
 * This routine is used by write_label() to do a quick sanity check on the
 * supplied geometry. This is not a thorough check.
 *
 * The SCSI READ_CAPACITY command is used here to get the capacity of the
 * disk. But, the available area to store data on a disk is usually less
 * than this. So, if the specified geometry evaluates to a value which falls
 * in this margin, then such illegal geometries can slip through the cracks.
 */
static int
do_geometry_sanity_check()
{
    struct scsi_capacity_16  capacity;

    if (uscsi_read_capacity(cur_file, &capacity)) {
        err_print("Warning: Unable to get capacity."
            " Cannot check geometry\n");
        return (0); /* Just ignore this problem */
    }

    if (capacity.sc_capacity < ncyl * nhead * nsect) {
        err_print("\nWarning: Current geometry overshoots "
            "actual geometry of disk\n\n");
        if (check("Continue labelling disk") != 0)
            return (-1);
        return (0); /* Just ignore this problem */
    }

    return (0);
}

/*
 * create a clear EFI partition table when format is used
 * to convert an SMI label to an EFI label
 */
int
SMI_vtoc_to_EFI(int fd, struct dk_gpt **new_vtoc)
{
    int i;
    struct dk_gpt   *efi;

    if (efi_alloc_and_init(fd, EFI_NUMPAR, new_vtoc) != 0) {
        err_print("SMI vtoc to EFI failed\n");
        return (-1);
    }
    efi = *new_vtoc;

    /*
     * create a clear EFI partition table:
     * s0 takes the whole disk except the primary EFI lable,
     * backup EFI labels, and the reserved partition.
     * s1-s6 are unassigned slices.
     */
    efi->efi_parts[0].p_tag = V_USR;
    efi->efi_parts[0].p_start = efi->efi_first_u_lba;
    efi->efi_parts[0].p_size = efi->efi_last_u_lba - efi->efi_first_u_lba
        - EFI_MIN_RESV_SIZE + 1;

    /*
     * s1-s6 are unassigned slices
     */
    for (i = 1; i < efi->efi_nparts - 2; i++) {
        efi->efi_parts[i].p_tag = V_UNASSIGNED;
        efi->efi_parts[i].p_start = 0;
        efi->efi_parts[i].p_size = 0;
    }

    /*
     * the reserved slice
     */
    efi->efi_parts[efi->efi_nparts - 1].p_tag = V_RESERVED;
    efi->efi_parts[efi->efi_nparts - 1].p_start =
        efi->efi_last_u_lba - EFI_MIN_RESV_SIZE + 1;
    efi->efi_parts[efi->efi_nparts - 1].p_size = EFI_MIN_RESV_SIZE;

    return (0);
}

/*
 * This routine constructs and writes a label on the disk.  It writes both
 * the primary and backup labels.  It assumes that there is a current
 * partition map already defined.  It also notifies the SunOS kernel of
 * the label and partition information it has written on the disk.
 */
int
write_label()
{
    int error = 0, head, sec;
    struct dk_label label;
    struct dk_label new_label;
    struct extvtoc  vtoc;
    struct dk_geom  geom;
    struct dk_gpt   *vtoc64;
    int     nbackups;

#if defined(_SUNOS_VTOC_8)
    int i;
#endif      /* defined(_SUNOS_VTOC_8) */

    /*
     * Check to see if any partitions used for svm, vxvm or live upgrade
     * are on the disk. If so, refuse to label the disk, but only
     * if we are trying to shrink a partition in use.
     */
    if (checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1,
        (diskaddr_t)-1, 0, 1)) {
        err_print("Cannot label disk when "
            "partitions are in use as described.\n");
        return (-1);
    }

    /*
     * If EFI label, then write it out to disk
     */
    if (cur_label == L_TYPE_EFI) {
        enter_critical();
        vtoc64 = cur_parts->etoc;
        err_check(vtoc64);
        if (efi_write(cur_file, vtoc64) != 0) {
            err_print("Warning: error writing EFI.\n");
            error = -1;
            }

        cur_disk->disk_flags |= DSK_LABEL;
        exit_critical();
        return (error);
    }

    /*
     * Fill in a label structure with the geometry information.
     */
    (void) memset((char *)&label, 0, sizeof (struct dk_label));
    (void) memset((char *)&new_label, 0, sizeof (struct dk_label));
    label.dkl_pcyl = pcyl;
    label.dkl_ncyl = ncyl;
    label.dkl_acyl = acyl;

#if defined(_SUNOS_VTOC_16)
    label.dkl_bcyl = bcyl;
#endif          /* defined(_SUNOC_VTOC_16) */

    label.dkl_nhead = nhead;
    label.dkl_nsect = nsect;
    label.dkl_apc = apc;
    label.dkl_intrlv = 1;
    label.dkl_rpm = cur_dtype->dtype_rpm;

#if defined(_SUNOS_VTOC_8)
    /*
     * Also fill in the current partition information.
     */
    for (i = 0; i < NDKMAP; i++) {
        label.dkl_map[i] = cur_parts->pinfo_map[i];
    }
#endif          /* defined(_SUNOS_VTOC_8) */

    label.dkl_magic = DKL_MAGIC;

    /*
     * Fill in the vtoc information
     */
    label.dkl_vtoc = cur_parts->vtoc;

    /*
     * Use the current label
     */
    bcopy(cur_disk->v_volume, label.dkl_vtoc.v_volume, LEN_DKL_VVOL);

    /*
     * Put asciilabel in; on x86 it's in the vtoc, not the label.
     */
    (void) snprintf(label.dkl_asciilabel, sizeof (label.dkl_asciilabel),
        "%s cyl %d alt %d hd %d sec %d",
        cur_dtype->dtype_asciilabel, ncyl, acyl, nhead, nsect);

#if defined(_SUNOS_VTOC_16)
    /*
     * Also add in v_sectorsz, as the driver will.  Everyone
     * else is assuming DEV_BSIZE, so we do the same.
     */
    label.dkl_vtoc.v_sectorsz = DEV_BSIZE;
#endif          /* defined(_SUNOS_VTOC_16) */

    /*
     * Generate the correct checksum.
     */
    (void) checksum(&label, CK_MAKESUM);
    /*
     * Convert the label into a vtoc
     */
    if (label_to_vtoc(&vtoc, &label) == -1) {
        return (-1);
    }
    /*
     * Fill in the geometry info.  This is critical that
     * we do this before writing the vtoc.
     */
    bzero((caddr_t)&geom, sizeof (struct dk_geom));
    geom.dkg_ncyl = ncyl;
    geom.dkg_acyl = acyl;

#if defined(_SUNOS_VTOC_16)
    geom.dkg_bcyl = bcyl;
#endif          /* defined(_SUNOS_VTOC_16) */

    geom.dkg_nhead = nhead;
    geom.dkg_nsect = nsect;
    geom.dkg_intrlv = 1;
    geom.dkg_apc = apc;
    geom.dkg_rpm = cur_dtype->dtype_rpm;
    geom.dkg_pcyl = pcyl;

    /*
     * Make a quick check to see that the geometry is being
     * written now is not way off from the actual capacity
     * of the disk. This is only an appoximate check and
     * is only for SCSI disks.
     */
    if (SCSI && do_geometry_sanity_check() != 0) {
        return (-1);
    }

    /*
     * Lock out interrupts so we do things in sync.
     */
    enter_critical();
    /*
     * Do the ioctl to tell the kernel the geometry.
     */
    if (ioctl(cur_file, DKIOCSGEOM, &geom) == -1) {
        err_print("Warning: error setting drive geometry.\n");
        error = -1;
    }
    /*
     * Write the vtoc.  At the time of this writing, our
     * drivers convert the vtoc back to a label, and
     * then write both the primary and backup labels.
     * This is not a requirement, however, as we
     * always use an ioctl to read the vtoc from the
     * driver, so it can do as it likes.
     */
    if (write_extvtoc(cur_file, &vtoc) != 0) {
        err_print("Warning: error writing VTOC.\n");
        error = -1;
    }

    /*
     * Calculate where the backup labels went.  They are always on
     * the last alternate cylinder, but some older drives put them
     * on head 2 instead of the last head.  They are always on the
     * first 5 odd sectors of the appropriate track.
     */
    if (cur_ctype->ctype_flags & CF_BLABEL)
        head  = 2;
    else
        head = nhead - 1;
    /*
     * Read and verify the backup labels.
     */
    nbackups = 0;
    for (sec = 1; ((sec < BAD_LISTCNT * 2 + 1) && (sec < nsect));
        sec += 2) {
        if ((*cur_ops->op_rdwr)(DIR_READ, cur_file, (diskaddr_t)
            ((chs2bn(ncyl + acyl - 1, head, sec)) + solaris_offset),
            1, (caddr_t)&new_label, F_NORMAL, NULL)) {
            err_print("Warning: error reading backup label.\n");
            error = -1;
        } else {
            if (bcmp((char *)&label, (char *)&new_label,
                sizeof (struct dk_label)) == 0) {
                    nbackups++;
            }
        }
    }
    if (nbackups != BAD_LISTCNT) {
        err_print("Warning: %s\n", nbackups == 0 ?
            "no backup labels" : "some backup labels incorrect");
    }
    /*
     * Mark the current disk as labelled and notify the kernel of what
     * has happened.
     */
    cur_disk->disk_flags |= DSK_LABEL;

    exit_critical();
    return (error);
}


/*
 * Read the label from the disk.
 * Do this via the read_extvtoc() library routine, then convert it to a label.
 * We also need a DKIOCGGEOM ioctl to get the disk's geometry.
 */
int
read_label(int fd, struct dk_label *label)
{
    struct extvtoc  vtoc;
    struct dk_geom  geom;
    struct dk_cinfo dkinfo;

    if (read_extvtoc(fd, &vtoc) < 0     ||
        ioctl(fd, DKIOCGGEOM, &geom) == -1  ||
        ioctl(fd, DKIOCINFO, &dkinfo) == -1) {
        return (-1);
    }

    return (vtoc_to_label(label, &vtoc, &geom, &dkinfo));
}

int
get_disk_info_from_devid(int fd, struct efi_info *label)
{
    ddi_devid_t devid;
    char        *s;
    int     n;
    char        *vid, *pid;
    int     nvid, npid;
    struct dk_minfo minf;
    struct dk_cinfo dkinfo;

    if (devid_get(fd, &devid)) {
        if (option_msg && diag_msg)
            err_print("devid_get failed\n");
        return (-1);
    }

    n = devid_sizeof(devid);
    s = (char *)devid;

    if (ioctl(fd, DKIOCINFO, &dkinfo) == -1) {
        if (option_msg && diag_msg)
            err_print("DKIOCINFO failed\n");
        return (-1);
    }

    if (dkinfo.dki_ctype != DKC_DIRECT)
        return (-1);

    vid = s+12;
    if (!(pid = strchr(vid, '=')))
        return (-1);
    nvid = pid - vid;
    pid += 1;
    npid = n - nvid - 13;

    if (nvid > 9)
        nvid = 9;
    if (npid > 17) {
        pid = pid + npid - 17;
        npid = 17;
    }

    if (ioctl(fd, DKIOCGMEDIAINFO, &minf) == -1) {
        devid_free(devid);
        return (-1);
    }

    (void) strlcpy(label->vendor, vid, nvid);
    (void) strlcpy(label->product, pid, npid);
    (void) strlcpy(label->revision, "0001", 5);
    label->capacity = minf.dki_capacity * minf.dki_lbsize / 512;

    devid_free(devid);
    return (0);
}

/*
 * Issue uscsi_inquiry and read_capacity commands to
 * retrieve the disk's Vendor, Product, Revision and
 * Capacity information.
 */
int
get_disk_info(int fd, struct efi_info *label)
{
    struct scsi_inquiry inquiry;
    struct scsi_capacity_16 capacity;
    struct dk_minfo     minf;

    if (!get_disk_info_from_devid(fd, label))
        return (0);

    if (uscsi_inquiry(fd, (char *)&inquiry, sizeof (inquiry))) {
        (void) strlcpy(label->vendor, "Unknown", 8);
        (void) strlcpy(label->product, "Unknown", 8);
        (void) strlcpy(label->revision, "0001", 5);
    } else {
        (void) strlcpy(label->vendor, inquiry.inq_vid, 9);
        (void) strlcpy(label->product, inquiry.inq_pid, 17);
        (void) strlcpy(label->revision, inquiry.inq_revision, 5);
    }

    if (uscsi_read_capacity(fd, &capacity)) {
        if (ioctl(fd, DKIOCGMEDIAINFO, &minf) == -1) {
            err_print("Fetch Capacity failed\n");
            return (-1);
        }
        label->capacity = minf.dki_capacity * minf.dki_lbsize / 512;
    } else {
        label->capacity = capacity.sc_capacity;

        /* Since we are counting from zero, add 1 to capacity */
        label->capacity++;
    }

    return (0);
}

int
read_efi_label(int fd, struct efi_info *label)
{
    struct dk_gpt   *vtoc64;

    /* This could fail if there is no label already */
    if (efi_alloc_and_read(fd, &vtoc64) < 0) {
        return (-1);
    }
    if (vtoc64_to_label(label, vtoc64) != 0) {
        err_print("vtoc64_to_label failed\n");
        return (-1);
    }
    efi_free(vtoc64);
    if (get_disk_info(fd, label) != 0) {
        return (-1);
    }
    return (0);
}


/*
 * We've read a 64-bit label which has no geometry information.  Use
 * some heuristics to fake up a geometry that would match the disk in
 * order to make the rest of format(1M) happy.
 */
static int
vtoc64_to_label(struct efi_info *label, struct dk_gpt *vtoc)
{
    int     i, nparts = 0;
    struct dk_gpt   *lmap;

    (void) memset((char *)label, 0, sizeof (struct efi_info));

    /* XXX do a sanity check here for nparts */
    nparts = vtoc->efi_nparts;
    lmap = (struct dk_gpt *) calloc(1, (sizeof (struct dk_part) *
        nparts) + sizeof (struct dk_gpt));
    if (lmap == NULL) {
        err_print("vtoc64_to_label: unable to allocate lmap\n");
        fullabort();
    }
    label->e_parts = lmap;

    /*
     * Copy necessary portions
     * XXX Maybe we can use memcpy() ??
     */
    lmap->efi_version = vtoc->efi_version;
    lmap->efi_nparts = vtoc->efi_nparts;
    lmap->efi_part_size = vtoc->efi_part_size;
    lmap->efi_lbasize = vtoc->efi_lbasize;
    lmap->efi_last_lba = vtoc->efi_last_lba;
    lmap->efi_first_u_lba = vtoc->efi_first_u_lba;
    lmap->efi_last_u_lba = vtoc->efi_last_u_lba;
    lmap->efi_altern_lba = vtoc->efi_altern_lba;
    lmap->efi_flags = vtoc->efi_flags;
    (void) memcpy((uchar_t *)&lmap->efi_disk_uguid,
        (uchar_t *)&vtoc->efi_disk_uguid, sizeof (struct uuid));

    for (i = 0; i < nparts; i++) {
        lmap->efi_parts[i].p_tag = vtoc->efi_parts[i].p_tag;
        lmap->efi_parts[i].p_flag = vtoc->efi_parts[i].p_flag;
        lmap->efi_parts[i].p_start = vtoc->efi_parts[i].p_start;
        lmap->efi_parts[i].p_size = vtoc->efi_parts[i].p_size;
        (void) memcpy((uchar_t *)&lmap->efi_parts[i].p_uguid,
            (uchar_t *)&vtoc->efi_parts[i].p_uguid,
            sizeof (struct uuid));
        if (vtoc->efi_parts[i].p_tag == V_RESERVED) {
            bcopy(vtoc->efi_parts[i].p_name,
                lmap->efi_parts[i].p_name, LEN_DKL_VVOL);
        }
    }
    return (0);
}

/*
 * Convert vtoc/geom to label.
 */
static int
vtoc_to_label(struct dk_label *label, struct extvtoc *vtoc,
    struct dk_geom *geom, struct dk_cinfo *cinfo)
{
#if defined(_SUNOS_VTOC_8)
    struct dk_map32     *lmap;
#elif defined(_SUNOS_VTOC_16)
    struct dkl_partition    *lmap;
#else
#error No VTOC format defined.
#endif          /* defined(_SUNOS_VTOC_8) */

    struct extpartition *vpart;
    ulong_t         nblks;
    int         i;

    (void) memset((char *)label, 0, sizeof (struct dk_label));

    /*
     * Sanity-check the vtoc
     */
    if (vtoc->v_sanity != VTOC_SANE || vtoc->v_sectorsz != DEV_BSIZE ||
        vtoc->v_nparts != V_NUMPAR) {
        return (-1);
    }

    /*
     * Sanity check of geometry
     */
    if (geom->dkg_ncyl == 0 || geom->dkg_nhead == 0 ||
        geom->dkg_nsect == 0) {
        return (-1);
    }

    label->dkl_magic = DKL_MAGIC;

    /*
     * Copy necessary portions of the geometry information
     */
    label->dkl_rpm = geom->dkg_rpm;
    label->dkl_pcyl = geom->dkg_pcyl;
    label->dkl_apc = geom->dkg_apc;
    label->dkl_intrlv = geom->dkg_intrlv;
    label->dkl_ncyl = geom->dkg_ncyl;
    label->dkl_acyl = geom->dkg_acyl;

#if defined(_SUNOS_VTOC_16)
    label->dkl_bcyl = geom->dkg_bcyl;
#endif          /* defined(_SUNOS_VTOC_16) */

    label->dkl_nhead = geom->dkg_nhead;
    label->dkl_nsect = geom->dkg_nsect;

#if defined(_SUNOS_VTOC_8)
    label->dkl_obs1 = geom->dkg_obs1;
    label->dkl_obs2 = geom->dkg_obs2;
    label->dkl_obs3 = geom->dkg_obs3;
#endif          /* defined(_SUNOS_VTOC_8) */

    label->dkl_write_reinstruct = geom->dkg_write_reinstruct;
    label->dkl_read_reinstruct = geom->dkg_read_reinstruct;

    /*
     * Copy vtoc structure fields into the disk label dk_vtoc
     */
    label->dkl_vtoc.v_sanity = vtoc->v_sanity;
    label->dkl_vtoc.v_nparts = vtoc->v_nparts;
    label->dkl_vtoc.v_version = vtoc->v_version;

    (void) memcpy(label->dkl_vtoc.v_volume, vtoc->v_volume,
        LEN_DKL_VVOL);
    for (i = 0; i < V_NUMPAR; i++) {
        label->dkl_vtoc.v_part[i].p_tag = vtoc->v_part[i].p_tag;
        label->dkl_vtoc.v_part[i].p_flag = vtoc->v_part[i].p_flag;
        label->dkl_vtoc.v_timestamp[i] = vtoc->timestamp[i];
    }

    for (i = 0; i < 10; i++)
        label->dkl_vtoc.v_reserved[i] = vtoc->v_reserved[i];

    label->dkl_vtoc.v_bootinfo[0] = vtoc->v_bootinfo[0];
    label->dkl_vtoc.v_bootinfo[1] = vtoc->v_bootinfo[1];
    label->dkl_vtoc.v_bootinfo[2] = vtoc->v_bootinfo[2];

    (void) memcpy(label->dkl_asciilabel, vtoc->v_asciilabel,
        LEN_DKL_ASCII);

    /*
     * Note the conversion from starting sector number
     * to starting cylinder number.
     * Return error if division results in a remainder.
     *
     * Note: don't check, if probing virtual disk in Xen
     * for that virtual disk will use fabricated # of headers
     * and sectors per track which may cause the capacity
     * not multiple of # of blocks per cylinder
     */
#if defined(_SUNOS_VTOC_8)
    lmap = label->dkl_map;

#elif defined(_SUNOS_VTOC_16)
    lmap = label->dkl_vtoc.v_part;
#else
#error No VTOC format defined.
#endif          /* defined(_SUNOS_VTOC_8) */

    vpart = vtoc->v_part;

    nblks = label->dkl_nsect * label->dkl_nhead;

    for (i = 0; i < NDKMAP; i++, lmap++, vpart++) {
        if (cinfo->dki_ctype != DKC_VBD) {
            if ((vpart->p_start % nblks) != 0 ||
                (vpart->p_size % nblks) != 0) {
                return (-1);
            }
        }
#if defined(_SUNOS_VTOC_8)
        lmap->dkl_cylno = (blkaddr32_t)(vpart->p_start / nblks);
        lmap->dkl_nblk = (blkaddr32_t)vpart->p_size;

#elif defined(_SUNOS_VTOC_16)
        lmap->p_start = (blkaddr32_t)vpart->p_start;
        lmap->p_size = (blkaddr32_t)vpart->p_size;
#else
#error No VTOC format defined.
#endif          /* defined(_SUNOS_VTOC_8) */
    }

    /*
     * Finally, make a checksum
     */
    (void) checksum(label, CK_MAKESUM);

#ifdef DEBUG
    if (option_msg && diag_msg)
        dump_label(label);
#endif
    return (0);
}


/*
 * Extract a vtoc structure out of a valid label
 */
int
label_to_vtoc(struct extvtoc *vtoc, struct dk_label *label)
{
#if defined(_SUNOS_VTOC_8)
    struct dk_map2      *lpart;
    struct dk_map32     *lmap;
    ulong_t         nblks;

#elif defined(_SUNOS_VTOC_16)
    struct dkl_partition    *lpart;
#else
#error No VTOC format defined.
#endif              /* defined(_SUNOS_VTOC_8) */

    struct extpartition *vpart;
    int         i;

    (void) memset((char *)vtoc, 0, sizeof (struct extvtoc));

    switch (label->dkl_vtoc.v_version) {
    case 0:
        /*
         * No valid vtoc information in the label.
         * Construct default p_flags and p_tags.
         */
        vpart = vtoc->v_part;
        for (i = 0; i < V_NUMPAR; i++, vpart++) {
            vpart->p_tag = default_vtoc_map[i].p_tag;
            vpart->p_flag = default_vtoc_map[i].p_flag;
        }
        break;

    case V_VERSION:
        vpart = vtoc->v_part;
        lpart = label->dkl_vtoc.v_part;
        for (i = 0; i < V_NUMPAR; i++, vpart++, lpart++) {
            vpart->p_tag = lpart->p_tag;
            vpart->p_flag = lpart->p_flag;

#if defined(_SUNOS_VTOC_16)
            vpart->p_start = (diskaddr_t)lpart->p_start;
            vpart->p_size = (diskaddr_t)lpart->p_size;
#endif  /* defined(_SUNOS_VTOC_16) */
            vtoc->timestamp[i] = label->dkl_vtoc.v_timestamp[i];
        }
        (void) memcpy(vtoc->v_volume, label->dkl_vtoc.v_volume,
            LEN_DKL_VVOL);

        for (i = 0; i < 10; i++)
            vtoc->v_reserved[i] = label->dkl_vtoc.v_reserved[i];

        vtoc->v_bootinfo[0] = label->dkl_vtoc.v_bootinfo[0];
        vtoc->v_bootinfo[1] = label->dkl_vtoc.v_bootinfo[1];
        vtoc->v_bootinfo[2] = label->dkl_vtoc.v_bootinfo[2];
        break;

    default:
        return (-1);
    }

    /*
     * XXX - this looks wrong to me....
     * why are these values hardwired, rather than returned from
     * the real disk label?
     */
    vtoc->v_sanity = VTOC_SANE;
    vtoc->v_version = V_VERSION;
    vtoc->v_sectorsz = DEV_BSIZE;
    vtoc->v_nparts = V_NUMPAR;

    (void) memcpy(vtoc->v_asciilabel, label->dkl_asciilabel,
        LEN_DKL_ASCII);

#if defined(_SUNOS_VTOC_8)
    /*
     * Convert partitioning information.
     * Note the conversion from starting cylinder number
     * to starting sector number.
     */
    lmap = label->dkl_map;
    vpart = vtoc->v_part;
    nblks = label->dkl_nsect * label->dkl_nhead;
    for (i = 0; i < V_NUMPAR; i++, vpart++, lmap++) {
        vpart->p_start = (diskaddr_t)(lmap->dkl_cylno * nblks);
        vpart->p_size = (diskaddr_t)lmap->dkl_nblk;
    }
#endif          /* defined(_SUNOS_VTOC_8) */

    return (0);
}

/*
 * Input: File descriptor
 * Output: 1 if disk has an EFI label, 0 otherwise.
 */

int
is_efi_type(int fd)
{
    struct extvtoc vtoc;

    if (read_extvtoc(fd, &vtoc) == VT_ENOTSUP) {
        /* assume the disk has EFI label */
        return (1);
    }
    return (0);
}

/* make sure the user specified something reasonable */
void
err_check(struct dk_gpt *vtoc)
{
    int         resv_part = -1;
    int         i, j;
    diskaddr_t      istart, jstart, isize, jsize, endsect;
    int         overlap = 0;

    /*
     * make sure no partitions overlap
     */
    for (i = 0; i < vtoc->efi_nparts; i++) {
        /* It can't be unassigned and have an actual size */
        if ((vtoc->efi_parts[i].p_tag == V_UNASSIGNED) &&
            (vtoc->efi_parts[i].p_size != 0)) {
            (void) fprintf(stderr,
"partition %d is \"unassigned\" but has a size of %llu\n", i,
                vtoc->efi_parts[i].p_size);
        }
        if (vtoc->efi_parts[i].p_tag == V_UNASSIGNED) {
            continue;
        }
        if (vtoc->efi_parts[i].p_tag == V_RESERVED) {
            if (resv_part != -1) {
                (void) fprintf(stderr,
"found duplicate reserved partition at %d\n", i);
            }
            resv_part = i;
            if (vtoc->efi_parts[i].p_size != EFI_MIN_RESV_SIZE)
                (void) fprintf(stderr,
"Warning: reserved partition size must be %d sectors\n",
                    EFI_MIN_RESV_SIZE);
        }
        if ((vtoc->efi_parts[i].p_start < vtoc->efi_first_u_lba) ||
            (vtoc->efi_parts[i].p_start > vtoc->efi_last_u_lba)) {
            (void) fprintf(stderr,
                "Partition %d starts at %llu\n",
                i,
                vtoc->efi_parts[i].p_start);
            (void) fprintf(stderr,
                "It must be between %llu and %llu.\n",
                vtoc->efi_first_u_lba,
                vtoc->efi_last_u_lba);
        }
        if ((vtoc->efi_parts[i].p_start +
            vtoc->efi_parts[i].p_size <
            vtoc->efi_first_u_lba) ||
            (vtoc->efi_parts[i].p_start +
            vtoc->efi_parts[i].p_size >
            vtoc->efi_last_u_lba + 1)) {
            (void) fprintf(stderr,
                "Partition %d ends at %llu\n",
                i,
                vtoc->efi_parts[i].p_start +
                vtoc->efi_parts[i].p_size);
            (void) fprintf(stderr,
                "It must be between %llu and %llu.\n",
                vtoc->efi_first_u_lba,
                vtoc->efi_last_u_lba);
        }

        for (j = 0; j < vtoc->efi_nparts; j++) {
            isize = vtoc->efi_parts[i].p_size;
            jsize = vtoc->efi_parts[j].p_size;
            istart = vtoc->efi_parts[i].p_start;
            jstart = vtoc->efi_parts[j].p_start;
            if ((i != j) && (isize != 0) && (jsize != 0)) {
                endsect = jstart + jsize -1;
                if ((jstart <= istart) &&
                    (istart <= endsect)) {
                    if (!overlap) {
                    (void) fprintf(stderr,
"label error: EFI Labels do not support overlapping partitions\n");
                    }
                    (void) fprintf(stderr,
"Partition %d overlaps partition %d.\n", i, j);
                    overlap = 1;
                }
            }
        }
    }
    /* make sure there is a reserved partition */
    if (resv_part == -1) {
        (void) fprintf(stderr,
            "no reserved partition found\n");
    }
}

#ifdef  DEBUG
static void
dump_label(label)
    struct dk_label *label;
{
    int     i;

    fmt_print("%s\n", label->dkl_asciilabel);

    fmt_print("version:  %d\n", label->dkl_vtoc.v_version);
    fmt_print("volume:   ");
    for (i = 0; i < LEN_DKL_VVOL; i++) {
        if (label->dkl_vtoc.v_volume[i] == 0)
            break;
        fmt_print("%c", label->dkl_vtoc.v_volume[i]);
    }
    fmt_print("\n");
    fmt_print("v_nparts: %d\n", label->dkl_vtoc.v_nparts);
    fmt_print("v_sanity: %lx\n", label->dkl_vtoc.v_sanity);

#if defined(_SUNOS_VTOC_8)
    fmt_print("rpm:      %d\n", label->dkl_rpm);
    fmt_print("pcyl:     %d\n", label->dkl_pcyl);
    fmt_print("apc:      %d\n", label->dkl_apc);
    fmt_print("obs1:     %d\n", label->dkl_obs1);
    fmt_print("obs2:     %d\n", label->dkl_obs2);
    fmt_print("intrlv:   %d\n", label->dkl_intrlv);
    fmt_print("ncyl:     %d\n", label->dkl_ncyl);
    fmt_print("acyl:     %d\n", label->dkl_acyl);
    fmt_print("nhead:    %d\n", label->dkl_nhead);
    fmt_print("nsect:    %d\n", label->dkl_nsect);
    fmt_print("obs3:     %d\n", label->dkl_obs3);
    fmt_print("obs4:     %d\n", label->dkl_obs4);

#elif defined(_SUNOS_VTOC_16)
    fmt_print("rpm:      %d\n", label->dkl_rpm);
    fmt_print("pcyl:     %d\n", label->dkl_pcyl);
    fmt_print("apc:      %d\n", label->dkl_apc);
    fmt_print("intrlv:   %d\n", label->dkl_intrlv);
    fmt_print("ncyl:     %d\n", label->dkl_ncyl);
    fmt_print("acyl:     %d\n", label->dkl_acyl);
    fmt_print("nhead:    %d\n", label->dkl_nhead);
    fmt_print("nsect:    %d\n", label->dkl_nsect);
    fmt_print("bcyl:     %d\n", label->dkl_bcyl);
    fmt_print("skew:     %d\n", label->dkl_skew);
#else
#error No VTOC format defined.
#endif              /* defined(_SUNOS_VTOC_8) */
    fmt_print("magic:    %0x\n", label->dkl_magic);
    fmt_print("cksum:    %0x\n", label->dkl_cksum);

    for (i = 0; i < NDKMAP; i++) {

#if defined(_SUNOS_VTOC_8)
        fmt_print("%c:        cyl=%d, blocks=%d", i+'a',
            label->dkl_map[i].dkl_cylno,
            label->dkl_map[i].dkl_nblk);

#elif defined(_SUNOS_VTOC_16)
        fmt_print("%c:        start=%u, blocks=%u", i+'a',
            label->dkl_vtoc.v_part[i].p_start,
            label->dkl_vtoc.v_part[i].p_size);
#else
#error No VTOC format defined.
#endif              /* defined(_SUNOS_VTOC_8) */

        fmt_print(",  tag=%d,  flag=%d",
            label->dkl_vtoc.v_part[i].p_tag,
            label->dkl_vtoc.v_part[i].p_flag);
        fmt_print("\n");
    }

    fmt_print("read_reinstruct:  %d\n", label->dkl_read_reinstruct);
    fmt_print("write_reinstruct: %d\n", label->dkl_write_reinstruct);

    fmt_print("bootinfo: ");
    for (i = 0; i < 3; i++) {
        fmt_print("0x%x ", label->dkl_vtoc.v_bootinfo[i]);
    }
    fmt_print("\n");

    fmt_print("reserved: ");
    for (i = 0; i < 10; i++) {
        if ((i % 4) == 3)
            fmt_print("\n");
        fmt_print("0x%x ", label->dkl_vtoc.v_reserved[i]);
    }
    fmt_print("\n");

    fmt_print("timestamp:\n");
    for (i = 0; i < NDKMAP; i++) {
        if ((i % 4) == 3)
            fmt_print("\n");
        fmt_print("0x%x ", label->dkl_vtoc.v_timestamp[i]);
    }
    fmt_print("\n");

    fmt_print("pad:\n");
    dump("", label->dkl_pad, LEN_DKL_PAD, HEX_ONLY);

    fmt_print("\n\n");
}
#endif  /* DEBUG */