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

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 *	Two output fields under the -i option will always be
 *	output as zero, since they are not supported by Sun:
 *		Software version, and
 *		Drive id number.
 *	AT&T filled these 2 fields with data from their "pdsector",
 *	which Sun doesn't support per se.
 */


#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/dkio.h>
#include <sys/efi_partition.h>
#include <sys/vtoc.h>
#include <sys/mkdev.h>
#include <errno.h>

#define	DRERR	2
#define	OPENERR	2

/*
 * Standard I/O file descriptors.
 */
#define	STDOUT	1		/* Standard output */
#define	STDERR	2		/* Standard error */

static	void	partinfo(int fd, char *device);
static	void	devinfo(struct dk_geom *geom, int fd, char *device);
static	int	readvtoc(int fd, char *name, struct extvtoc *vtoc);
static	int	warn(char *what, char *why);
static	void	usage(void);

int
main(int argc, char **argv)
{
	struct dk_geom  geom;
	int errflg, iflg, pflg, fd, c;
	char *device;

	iflg = 0;
	pflg = 0;
	errflg = 0;
	while ((c = getopt(argc, argv, "i:p:")) != EOF) {
		switch (c) {
			case 'i':
				iflg++;
				device = optarg;
				break;
			case 'p':
				pflg++;
				device = optarg;
				break;
			case '?':
				errflg++;
				break;
			default:
				errflg++;
				break;
		}
		if (errflg)
			usage();
	}
	if ((optind > argc) || (optind == 1) || (pflg && iflg))
		usage();

	if ((fd = open(device, O_RDONLY)) < 0) {
		(void) fprintf(stderr, "devinfo: %s: %s\n",
			device, strerror(errno));
		exit(OPENERR);
	}

	if (iflg) {
		if (ioctl(fd, DKIOCGGEOM, &geom) == -1) {
			if (errno == ENOTSUP) {
				(void) warn(device,
"This operation is not supported on EFI labeled devices");
			} else {
				(void) warn(device,
"Unable to read Disk geometry");
			}
			(void) close(fd);
			exit(DRERR);
		}
		devinfo(&geom, fd, device);
	}
	if (pflg)
		partinfo(fd, device);
	(void) close(fd);
	return (0);
}

static void
partinfo(int fd, char *device)
{
	int i;
	int	slice;
	major_t maj;
	minor_t min;
	struct stat64 statbuf;
	struct extvtoc vtdata;
	struct dk_gpt *efi;

	i = stat64(device, &statbuf);
	if (i < 0)
		exit(DRERR);
	maj = major(statbuf.st_rdev);
	min = minor(statbuf.st_rdev);

	if ((slice = readvtoc(fd, device, &vtdata)) >= 0) {

		(void) printf("%s\t%0lx\t%0lx\t%llu\t%llu\t%x\t%x\n",
			device, maj, min,
			vtdata.v_part[slice].p_start,
			vtdata.v_part[slice].p_size,
			vtdata.v_part[slice].p_flag,
			vtdata.v_part[slice].p_tag);
	} else if ((slice == VT_ENOTSUP) &&
	    (slice = efi_alloc_and_read(fd, &efi)) >= 0) {
		(void) printf("%s\t%lx\t%lx\t%lld\t%lld\t%hx\t%hx\n",
			device, maj, min,
			efi->efi_parts[slice].p_start,
			efi->efi_parts[slice].p_size,
			efi->efi_parts[slice].p_flag,
			efi->efi_parts[slice].p_tag);
	} else {
		exit(DRERR);
	}
}

static void
devinfo(struct dk_geom *geom, int fd, char *device)
{
	int i;
	unsigned int nopartitions, sectorcyl, bytes;
	struct extvtoc vtdata;
/*
 *	unsigned int version = 0;
 *	unsigned int driveid = 0;
 */

	nopartitions = 0;
	sectorcyl = 0;
	bytes = 0;

	if (readvtoc(fd, device, &vtdata) < 0)
		exit(DRERR);
	sectorcyl = geom->dkg_nhead  *  geom->dkg_nsect;
	bytes = vtdata.v_sectorsz;
/*
 *	these are not supported by Sun.
 *
 *	driveid = osect0->newsect0.pdinfo.driveid;
 *	version = osect0->newsect0.pdinfo.version;
 */
	for (i = 0; i < V_NUMPAR; i++)	{
		if (vtdata.v_part[i].p_size != 0x00)
			nopartitions++;
	}
/*
 *	(void) printf("%s	%0x	%0x	%d	%d	%d\n",
 *		device, version, driveid, sectorcyl, bytes, nopartitions);
 */
	(void) printf("%s	%0x	%0x	%d	%d	%d\n",
		device, 0, 0, sectorcyl, bytes, nopartitions);
}


/*
 * readvtoc()
 *
 * Read a partition map.
 */
static int
readvtoc(int fd, char *name, struct extvtoc *vtoc)
{
	int	retval;

	retval = read_extvtoc(fd, vtoc);

	switch (retval) {
		case (VT_ERROR):
			return (warn(name, strerror(errno)));
		case (VT_EIO):
			return (warn(name, "I/O error accessing VTOC"));
		case (VT_EINVAL):
			return (warn(name, "Invalid field in VTOC"));
		}

	return (retval);
}


/*
 * warn()
 *
 * Print an error message. Always returns -1.
 */
static int
warn(char *what, char *why)
{
	static char	myname[]  = "devinfo";
	static char	between[] = ": ";
	static char	after[]   = "\n";

	(void) write(STDERR, myname, (uint_t)strlen(myname));
	(void) write(STDERR, between, (uint_t)strlen(between));
	(void) write(STDERR, what, (uint_t)strlen(what));
	(void) write(STDERR, between, (uint_t)strlen(between));
	(void) write(STDERR, why, (uint_t)strlen(why));
	(void) write(STDERR, after, (uint_t)strlen(after));
	return (-1);
}

static void
usage(void)
{
	(void) fprintf(stderr, "Usage: devinfo -p device\n"
		"       devinfo -i device \n");
	exit(2);
}