tools/diskomizer/vtoc.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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)vtoc.c	1.12	09/05/26 SMI"

#include <diskomizer/vtoc.h>
#include <diskomizer/log.h>
#include "args.h"
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stropts.h>
#include <dlfcn.h>
#include <errno.h>

/*
 * Shamelessly stolen from vtoc.h so that this will compile on older
 * Operating systems and be able to take advantage of the new code when
 * it is available.
 */
#ifndef V_EXTVERSION

struct extpartition {
	ushort_t p_tag;			/* ID tag of partition */
	ushort_t p_flag;		/* permission flags */
	ushort_t p_pad[2];
	diskaddr_t p_start;		/* start sector no of partition */
	diskaddr_t p_size;		/* # of blocks in partition */
};

struct extvtoc {
	uint64_t	v_bootinfo[3];	/* info needed by mboot (unsupported) */
	uint64_t	v_sanity;	/* to verify vtoc sanity */
	uint64_t	v_version;	/* layout version */
	char	v_volume[LEN_DKL_VVOL]; /* volume name */
	ushort_t	v_sectorsz;	/* sector size in bytes */
	ushort_t	v_nparts;	/* number of partitions */
	ushort_t	pad[2];
	uint64_t	v_reserved[10];
	struct extpartition v_part[V_NUMPAR]; /* partition headers */
	uint64_t timestamp[V_NUMPAR];	/* partition timestamp (unsupported) */
	char	v_asciilabel[LEN_DKL_ASCII];	/* for compatibility */
};

extern int read_extvtoc(int, struct extvtoc *);
#pragma weak read_extvtoc
#define	READ_EXTVTOC(X, F, S) (read_extvtoc != NULL && \
	(X = read_extvtoc((F), (S))) >= 0)
#else
#define	READ_EXTVTOC(X, F, S) ((X = read_extvtoc((F), (S))) >= 0)
#endif
#ifndef	DKIOCGEXTVTOC
#define	DKIOCGEXTVTOC	(DKIOC|23)	/* Get extended VTOC */
#endif
#define	VTOC_USER_LIB "VTOC_USER_LIB"

static struct disko_partition
extvtoc_part_to_diskopart(struct extpartition *p)
{
	struct disko_partition dp;

#define	P_TO_DP(A) dp.A = (uint64_t)p->A

	P_TO_DP(p_tag);
	P_TO_DP(p_flag);
	P_TO_DP(p_start);
	P_TO_DP(p_size);

#undef	P_TO_DP
	return (dp);
}

static struct disko_partition
vtoc_part_to_diskopartition(struct partition *p)
{
	struct disko_partition dp;

#define	P_TO_DP(A) dp.A = (uint64_t)p->A

	P_TO_DP(p_tag);
	P_TO_DP(p_flag);
	P_TO_DP(p_start);
	P_TO_DP(p_size);

#undef	P_TO_DP
	return (dp);
}

struct disko_vtoc *
alloc_disko_vtoc(uint_t nparts)
{
	struct disko_vtoc *d;

	d = ((struct disko_vtoc *) malloc(sizeof (struct disko_vtoc) +
	    (nparts - 1) * sizeof (d->v_part[0])));
	return (d);
}

static char *
not_null_dlerror(void)
{
	static char no_error[] = "No error";
	char *x;

	x = dlerror();
	return ((x == NULL) ? &no_error[0] : x);
}

static void *
try_efi(int fd)
{
	struct dk_gpt *efi = NULL;
	int i;
	uint_t x;
	void *handle;
	struct disko_vtoc *dv;
	short (*my_efi_alloc_and_read)(int fd, struct dk_gpt **);
	void (*my_efi_free)(struct dk_gpt *);

	if ((handle = dlopen("libefi.so.1", RTLD_NOW)) == NULL) {
		plog(LOG_DEBUG, "%s\n", not_null_dlerror());
		return (NULL);
	}
	my_efi_alloc_and_read = (short (*)(int, struct dk_gpt **))
	    dlsym(handle, "efi_alloc_and_read");
	my_efi_free = (void (*)(struct dk_gpt *))dlsym(handle,
	    "efi_free");


	if (my_efi_alloc_and_read == NULL ||
	    ((int)(x = my_efi_alloc_and_read(fd, &efi))) < 0) {
		plog(LOG_DEBUG, "%s\n", not_null_dlerror());
		dlclose(handle);
		return (NULL);
	}

	/*
	 * Work around bug 4888423.  The Current version was reduced but
	 * there could be efi labels out there with the incorrect
	 * EFI_VERSION102
	 */
	if (efi->efi_version != EFI_VERSION_CURRENT &&
	    !(efi->efi_version == EFI_VERSION102 &&
	    opts.obscure_allow_efi_102)) {
		if (efi->efi_version == EFI_VERSION102) {
			plog(LOG_ERR,
			    "EFI version mismatch. Got %#x expected %#x, "
			    "try setting option obscure_allow_efi_102\n",
			    efi->efi_version, EFI_VERSION_CURRENT);
		} else {
			plog(LOG_ERR,
			    "EFI version mismatch. Got %#x expected %#x\n",
			    efi->efi_version, EFI_VERSION_CURRENT);
		}
		dlclose(handle);
		return (NULL);
	}

	for (i = 0; i <
	    (sizeof (efi->efi_reserved) /
	    sizeof (efi->efi_reserved[0])); i++) {
		if (efi->efi_reserved[i] != 0) {
			plog(LOG_WARNING,
			    "efi->efi_reserved[%d] is not zero (%#x)\n", i,
			    efi->efi_reserved[i]);
			if (!opts.obscure_allow_non_zero_efi_reserved) {
				dlclose(handle);
				return (NULL);
			}
		}
	}

	if ((dv = alloc_disko_vtoc(efi->efi_nparts)) != NULL) {

		dv->disko_vtoc_size = sizeof (*dv);
		dv->disko_part_size = sizeof (dv->v_part[0]);

		memset(&dv->v_volume[0], 0, sizeof (dv->v_volume));
		memset(&dv->v_asciilabel[0], 0,
		    sizeof (dv->v_asciilabel));

		dv->v_sectorsz = efi->efi_lbasize;
		dv->v_nparts = efi->efi_nparts;
		dv->this_part = x;

		for (i = 0; i < efi->efi_nparts; i++) {
			dv->v_part[i].p_tag = efi->efi_parts[i].p_tag;
			dv->v_part[i].p_flag = efi->efi_parts[i].p_flag;
			dv->v_part[i].p_start =
			    efi->efi_parts[i].p_start;
			dv->v_part[i].p_size = efi->efi_parts[i].p_size;
		}
	}
	if (my_efi_free) {
		my_efi_free(efi);
	}
	dlclose(handle);
	return (dv);
}
/*
 * Try to read the vtoc using a user supplied shared library containing the
 * symbol user_read_vtoc which should be a function that is of type
 * user_read_vtoc_t. If it is not a function this code will not fail
 * gracefully.
 *
 * The path to the users library is supplied as an option to diskomizer
 * with the VTOC_USER_LIB, option. Currently this means that this option
 * is not documented automatically like the others in the main diskomizer
 * code base.
 *
 * To prevent version problems it must fill in the first three fields of
 * the structure with some known good values which are in the header file
 * user_vtoc.h which it should be compiled with.
 *
 */
static void *
try_user_vtoc(int fd)
{
	static int have_opts;
	static char *user_lib_name;

	if (have_opts == 0) {
		const struct option_ops *ops;
		ops = opts_init();

		if (ops->opt_str(VTOC_USER_LIB, &user_lib_name) == OPT_OK) {
			user_lib_name = strdup(user_lib_name);
		}
		have_opts = 1;
		opts_fini();
	}
	if (user_lib_name != NULL) {
		user_read_vtoc_t my_user_read_vtoc;
		void *handle;
		struct disko_vtoc *dv;

		if ((handle = dlopen(user_lib_name, RTLD_NOW)) == NULL) {
			return (NULL);
		}
		if ((my_user_read_vtoc = (user_read_vtoc_t)dlsym(handle,
		    "user_read_vtoc")) == NULL) {
			dlclose(handle);
			return (NULL);
		}
		dv = my_user_read_vtoc(fd);
		dlclose(handle);
		if (dv->disko_vtoc_version != DISKO_VTOC_VERSION) {
			plog(LOG_WARNING,
			    "%s:user_read_vtoc() returned incorrect version.\n",
			    user_lib_name);
			disko_vtoc_free(dv);
			return (NULL);
		}
		if (dv->disko_vtoc_size != sizeof (*dv) ||
		    dv->disko_part_size != sizeof (dv->v_part[0])) {
			plog(LOG_WARNING,
			    "%s:user_read_vtoc() returned incorrect "
			    "structure size[s].\n", user_lib_name);
			disko_vtoc_free(dv);
			return (NULL);
		}

		return (dv);
	}
	return (NULL);
}

void *
read_disko_vtoc(int fd)
{
	int x;
	union {
		struct vtoc vtoc;
		struct extvtoc extvtoc;
	} u;

	if (READ_EXTVTOC(x, fd, &u.extvtoc) ||
	    (x = ioctl(fd, DKIOCGEXTVTOC, &u.extvtoc)) >= 0) {
		struct disko_vtoc *dv;
		int i;

		if ((dv = alloc_disko_vtoc(u.extvtoc.v_nparts)) == NULL) {
			return (NULL);
		}

		dv->disko_vtoc_size = sizeof (*dv);
		dv->disko_part_size = sizeof (dv->v_part[0]);

		memcpy(dv->v_volume, u.extvtoc.v_volume, LEN_DKL_VVOL);
		dv->v_volume[LEN_DKL_VVOL] = NULL;
		memcpy(dv->v_asciilabel, u.extvtoc.v_asciilabel, LEN_DKL_ASCII);
		dv->v_asciilabel[LEN_DKL_ASCII] = NULL;
		dv->v_sectorsz = u.extvtoc.v_sectorsz;
		dv->v_nparts = u.extvtoc.v_nparts;
		dv->this_part = x;

		for (i = 0; i < u.extvtoc.v_nparts; i++) {
			dv->v_part[i] =
			    extvtoc_part_to_diskopart(&u.extvtoc.v_part[i]);
		}
		return (dv);
	} else if ((x = read_vtoc(fd, &u.vtoc)) >= 0 ||
	    (x = ioctl(fd, DKIOCGVTOC, &u.vtoc)) >= 0) {
		struct disko_vtoc *dv;
		int i;

		if ((dv = alloc_disko_vtoc(u.vtoc.v_nparts)) == NULL) {
			return (NULL);
		}

		dv->disko_vtoc_size = sizeof (*dv);
		dv->disko_part_size = sizeof (dv->v_part[0]);

		memcpy(dv->v_volume, u.vtoc.v_volume, LEN_DKL_VVOL);
		dv->v_volume[LEN_DKL_VVOL] = NULL;
		memcpy(dv->v_asciilabel, u.vtoc.v_asciilabel, LEN_DKL_ASCII);
		dv->v_asciilabel[LEN_DKL_ASCII] = NULL;
		dv->v_sectorsz = u.vtoc.v_sectorsz;
		dv->v_nparts = u.vtoc.v_nparts;
		dv->this_part = x;

		for (i = 0; i < u.vtoc.v_nparts; i++) {
			dv->v_part[i] =
			    vtoc_part_to_diskopartition(&u.vtoc.v_part[i]);
		}
		return (dv);
	} else if ((x == -1) && (errno == ENOTSUP || errno == ENOTTY)) {
		void * handle;

		handle = try_efi(fd);
		if (handle == NULL) {
			handle = try_user_vtoc(fd);
		}
		return (handle);
	} else {
		return (NULL);
	}
}

const char *
disko_vtoc_volume(void *handle)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (vt->v_volume);
}

const char *
disko_vtoc_asciilabel(void *handle)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (vt->v_asciilabel);
}

uint_t
disko_vtoc_sectorsz(void *handle)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (vt->v_sectorsz);
}

uint_t
disko_vtoc_nparts(void *handle)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (vt->v_nparts);
}

const struct disko_partition *
disko_vtoc_parts(void *handle, uint_t part)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (&vt->v_part[part]);
}

uint_t
disko_vtoc_this_part(void *handle)
{
	struct disko_vtoc *vt = (struct disko_vtoc *)handle;

	return (vt->this_part);
}

const struct disko_partition *
disko_vtoc_this_partition(void *handle)
{
	return (disko_vtoc_parts(handle, disko_vtoc_this_part(handle)));
}

void
disko_vtoc_free(void *handle)
{
	free(handle);
}