/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

/*

 * This file contains functions to implement automatic configuration

 * of scsi disks.

 */

#include "global.h"

#include <fcntl.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <stdlib.h>

#include <ctype.h>

#include "misc.h"

#include "param.h"

#include "ctlr_scsi.h"

#include "auto_sense.h"

#include "partition.h"

#include "label.h"

#include "startup.h"

#include "analyze.h"

#include "io.h"

#include "hardware_structs.h"

#include "menu_fdisk.h"

#define	DISK_NAME_MAX		256

extern	int			nctypes;

extern	struct	ctlr_type	ctlr_types[];

/*

 * Marker for free hog partition

 */

#define	HOG		(-1)

/*

 * Default partition tables

 *

 *	Disk capacity		root	swap	usr

 *	-------------		----	----	---

 *	0mb to 64mb		0	0	remainder

 *	64mb to 180mb		16mb	16mb	remainder

 *	180mb to 280mb		16mb	32mb	remainder

 *	280mb to 380mb		24mb	32mb	remainder

 *	380mb to 600mb		32mb	32mb	remainder

 *	600mb to 1gb		32mb	64mb	remainder

 *	1gb to 2gb		64mb	128mb	remainder

 *	2gb on up		128mb	128mb	remainder

 */

struct part_table {

	int	partitions[NDKMAP];

};

static struct part_table part_table_64mb = {

	{ 0,	0,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_180mb = {

	{ 16,	16,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_280mb = {

	{ 16,	32,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_380mb = {

	{ 24,	32,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_600mb = {

	{ 32,	32,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_1gb = {

	{ 32,	64,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_2gb = {

	{ 64,	128,	0,	0,	0,	0,	HOG,	0}

};

static struct part_table part_table_infinity = {

	{ 128,	128,	0,	0,	0,	0,	HOG,	0}

};

static struct default_partitions {

	diskaddr_t		min_capacity;

	diskaddr_t		max_capacity;

	struct part_table	*part_table;

} default_partitions[] = {

	{ 0,	64,		&part_table_64mb },	/* 0 to 64 mb */

	{ 64,	180,		&part_table_180mb },	/* 64 to 180 mb */

	{ 180,	280,		&part_table_280mb },	/* 180 to 280 mb */

	{ 280,	380,		&part_table_380mb },	/* 280 to 380 mb */

	{ 380,	600,		&part_table_600mb },	/* 380 to 600 mb */

	{ 600,	1024,		&part_table_1gb },	/* 600 to 1 gb */

	{ 1024,	2048,		&part_table_2gb },	/* 1 to 2 gb */

	{ 2048,	INFINITY,	&part_table_infinity },	/* 2 gb on up */

};

#define	DEFAULT_PARTITION_TABLE_SIZE	\

	(sizeof (default_partitions) / sizeof (struct default_partitions))

/*

 * msgs for check()

 */

#define	FORMAT_MSG	"Auto configuration via format.dat"

#define	GENERIC_MSG	"Auto configuration via generic SCSI-2"

/*

 * Disks on symbios(Hardwire raid controller) return a fixed number

 * of heads(64)/cylinders(64) and adjust the cylinders depending

 * capacity of the configured lun.

 * In such a case we get number of physical cylinders < 3 which

 * is the minimum required by solaris(2 reserved + 1 data cylinders).

 * Hence try to adjust the cylinders by reducing the "nsect/nhead".

 *

 */

/*

 * assuming a minimum of 32 block cylinders.

 */

#define	MINIMUM_NO_HEADS	2

#define	MINIMUM_NO_SECTORS	16

#define	MINIMUM_NO_CYLINDERS	128

#if defined(_SUNOS_VTOC_8)

/* These are 16-bit fields */

#define	MAXIMUM_NO_HEADS	65535

#define	MAXIMUM_NO_SECTORS	65535

#define	MAXIMUM_NO_CYLINDERS	65535

#endif	/* defined(_SUNOS_VTOC_8) */

/*

 * minimum number of cylinders required by Solaris.

 */

#define	SUN_MIN_CYL		3

/*

 * ANSI prototypes for local static functions

 */

static struct disk_type	*generic_disk_sense(

				int		fd,

				int		can_prompt,

				struct dk_label	*label,

				struct scsi_inquiry *inquiry,

				struct scsi_capacity_16 *capacity,

				char		*disk_name);

static int		use_existing_disk_type(

				int		fd,

				int		can_prompt,

				struct dk_label	*label,

				struct scsi_inquiry *inquiry,

				struct disk_type *disk_type,

				struct scsi_capacity_16 *capacity);

int			build_default_partition(struct dk_label *label,

				int ctrl_type);

static struct disk_type	*find_scsi_disk_type(

				char		*disk_name,

				struct dk_label	*label);

static struct disk_type	*find_scsi_disk_by_name(

				char		*disk_name);

static struct ctlr_type	*find_scsi_ctlr_type(void);

static struct ctlr_info	*find_scsi_ctlr_info(

				struct dk_cinfo	*dkinfo);

static struct disk_type	*new_scsi_disk_type(

				int		fd,

				char		*disk_name,

				struct dk_label	*label);

static struct disk_info	*find_scsi_disk_info(

				struct dk_cinfo	*dkinfo);

static struct disk_type *new_direct_disk_type(int fd, char *disk_name,

    struct dk_label *label);

static struct disk_info *find_direct_disk_info(struct dk_cinfo *dkinfo);

static int efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc);

static int auto_label_init(struct dk_label *label);

static struct ctlr_type *find_direct_ctlr_type(void);

static struct ctlr_info *find_direct_ctlr_info(struct dk_cinfo	*dkinfo);

static  struct disk_info *find_direct_disk_info(struct dk_cinfo *dkinfo);

static struct ctlr_type *find_vbd_ctlr_type(void);

static struct ctlr_info *find_vbd_ctlr_info(struct dk_cinfo *dkinfo);

static struct disk_info *find_vbd_disk_info(struct dk_cinfo *dkinfo);

static char		*get_sun_disk_name(

				char		*disk_name,

				struct scsi_inquiry *inquiry);

static char		*get_generic_disk_name(

				char		*disk_name,

				struct scsi_inquiry *inquiry);

static char		*strcopy(

				char	*dst,

				char	*src,

				int	n);

static	int		adjust_disk_geometry(diskaddr_t capacity, uint_t *cyl,

				uint_t *nsect, uint_t *nhead);

static void 		compute_chs_values(diskaddr_t total_capacity,

				diskaddr_t usable_capacity, uint_t *pcylp,

				uint_t *nheadp, uint_t *nsectp);

#if defined(_SUNOS_VTOC_8)

static diskaddr_t square_box(

			diskaddr_t capacity,

			uint_t *dim1, uint_t lim1,

			uint_t *dim2, uint_t lim2,

			uint_t *dim3, uint_t lim3);

#endif	/* defined(_SUNOS_VTOC_8) */

/*

 * We need to get information necessary to construct a *new* efi

 * label type

 */

struct disk_type *

auto_efi_sense(int fd, struct efi_info *label)

{

	struct dk_gpt	*vtoc;

	int		i;

	struct disk_type *disk, *dp;

	struct disk_info *disk_info;

	struct ctlr_info *ctlr;

	struct dk_cinfo dkinfo;

	struct partition_info *part;

	/*

	 * get vendor, product, revision and capacity info.

	 */

	if (get_disk_info(fd, label) == -1) {

		return ((struct disk_type *)NULL);

	}

	/*

	 * Now build the default partition table

	 */

	if (efi_alloc_and_init(fd, EFI_NUMPAR, &vtoc) != 0) {

		err_print("efi_alloc_and_init failed. \n");

		return ((struct disk_type *)NULL);

	}

	label->e_parts = vtoc;

	/*

	 * Create a whole hog EFI partition table:

	 * S0 takes the whole disk except the primary EFI label,

	 * backup EFI label, and the reserved partition.

	 */

	vtoc->efi_parts[0].p_tag = V_USR;

	vtoc->efi_parts[0].p_start = vtoc->efi_first_u_lba;

	vtoc->efi_parts[0].p_size = vtoc->efi_last_u_lba - vtoc->efi_first_u_lba

	    - EFI_MIN_RESV_SIZE + 1;

	/*

	 * S1-S6 are unassigned slices.

	 */

	for (i = 1; i < vtoc->efi_nparts - 2; i ++) {

		vtoc->efi_parts[i].p_tag = V_UNASSIGNED;

		vtoc->efi_parts[i].p_start = 0;

		vtoc->efi_parts[i].p_size = 0;

	}

	/*

	 * The reserved slice

	 */

	vtoc->efi_parts[vtoc->efi_nparts - 1].p_tag = V_RESERVED;

	vtoc->efi_parts[vtoc->efi_nparts - 1].p_start =

	    vtoc->efi_last_u_lba - EFI_MIN_RESV_SIZE + 1;

	vtoc->efi_parts[vtoc->efi_nparts - 1].p_size = EFI_MIN_RESV_SIZE;

	/*

	 * Now stick all of it into the disk_type struct

	 */

	if (ioctl(fd, DKIOCINFO, &dkinfo) == -1) {

		if (option_msg && diag_msg) {

			err_print("DKIOCINFO failed\n");

		}

		return (NULL);

	}

	if ((cur_ctype != NULL) && (cur_ctype->ctype_ctype == DKC_DIRECT)) {

		ctlr = find_direct_ctlr_info(&dkinfo);

		disk_info = find_direct_disk_info(&dkinfo);

	} else if ((cur_ctype != NULL) && (cur_ctype->ctype_ctype == DKC_VBD)) {

		ctlr = find_vbd_ctlr_info(&dkinfo);

		disk_info = find_vbd_disk_info(&dkinfo);

	} else {

		ctlr = find_scsi_ctlr_info(&dkinfo);

		disk_info = find_scsi_disk_info(&dkinfo);

	}

	disk = (struct disk_type *)zalloc(sizeof (struct disk_type));

	assert(disk_info->disk_ctlr == ctlr);

	dp = ctlr->ctlr_ctype->ctype_dlist;

	if (dp == NULL) {

		ctlr->ctlr_ctype->ctype_dlist = dp;

	} else {

		while (dp->dtype_next != NULL) {

			dp = dp->dtype_next;

		}

		dp->dtype_next = disk;

	}

	disk->dtype_next = NULL;

	(void) strlcpy(disk->vendor, label->vendor,

	    sizeof (disk->vendor));

	(void) strlcpy(disk->product, label->product,

	    sizeof (disk->product));

	(void) strlcpy(disk->revision, label->revision,

	    sizeof (disk->revision));

	disk->capacity = label->capacity;

	part = (struct partition_info *)

	    zalloc(sizeof (struct partition_info));

	disk->dtype_plist = part;

	part->pinfo_name = alloc_string("default");

	part->pinfo_next = NULL;

	part->etoc = vtoc;

	bzero(disk_info->v_volume, LEN_DKL_VVOL);

	disk_info->disk_parts = part;

	return (disk);

}

static int

efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)

{

	void *data = dk_ioc->dki_data;

	int error;

	dk_ioc->dki_data_64 = (uint64_t)(uintptr_t)data;

	error = ioctl(fd, cmd, (void *)dk_ioc);

	dk_ioc->dki_data = data;

	return (error);

}

static struct ctlr_type *

find_direct_ctlr_type()

{

	struct	mctlr_list	*mlp;

	mlp = controlp;

	while (mlp != NULL) {

		if (mlp->ctlr_type->ctype_ctype == DKC_DIRECT) {

			return (mlp->ctlr_type);

		}

		mlp = mlp->next;

	}

	impossible("no DIRECT controller type");

	return ((struct ctlr_type *)NULL);

}

static struct ctlr_type *

find_vbd_ctlr_type()

{

	struct	mctlr_list	*mlp;

	mlp = controlp;

	while (mlp != NULL) {

		if (mlp->ctlr_type->ctype_ctype == DKC_VBD) {

			return (mlp->ctlr_type);

		}

		mlp = mlp->next;

	}

	impossible("no VBD controller type");

	return ((struct ctlr_type *)NULL);

}

static struct ctlr_info *

find_direct_ctlr_info(

	struct dk_cinfo		*dkinfo)

{

	struct ctlr_info	*ctlr;

	if (dkinfo->dki_ctype != DKC_DIRECT)

		return (NULL);

	for (ctlr = ctlr_list; ctlr != NULL; ctlr = ctlr->ctlr_next) {

		if (ctlr->ctlr_addr == dkinfo->dki_addr &&

		    ctlr->ctlr_space == dkinfo->dki_space &&

		    ctlr->ctlr_ctype->ctype_ctype == DKC_DIRECT) {

			return (ctlr);

		}

	}

	impossible("no DIRECT controller info");

	/*NOTREACHED*/

}

static struct ctlr_info *

find_vbd_ctlr_info(

	struct dk_cinfo		*dkinfo)

{

	struct ctlr_info	*ctlr;

	if (dkinfo->dki_ctype != DKC_VBD)

		return (NULL);

	for (ctlr = ctlr_list; ctlr != NULL; ctlr = ctlr->ctlr_next) {

		if (ctlr->ctlr_addr == dkinfo->dki_addr &&

		    ctlr->ctlr_space == dkinfo->dki_space &&

		    ctlr->ctlr_ctype->ctype_ctype == DKC_VBD) {

			return (ctlr);

		}

	}

	impossible("no VBD controller info");

	/*NOTREACHED*/

}

static  struct disk_info *

find_direct_disk_info(

	struct dk_cinfo		*dkinfo)

{

	struct disk_info	*disk;

	struct dk_cinfo		*dp;

	for (disk = disk_list; disk != NULL; disk = disk->disk_next) {

		assert(dkinfo->dki_ctype == DKC_DIRECT);

		dp = &disk->disk_dkinfo;

		if (dp->dki_ctype == dkinfo->dki_ctype &&

		    dp->dki_cnum == dkinfo->dki_cnum &&

		    dp->dki_unit == dkinfo->dki_unit &&

		    strcmp(dp->dki_dname, dkinfo->dki_dname) == 0) {

			return (disk);

		}

	}

	impossible("No DIRECT disk info instance\n");

	/*NOTREACHED*/

}

static  struct disk_info *

find_vbd_disk_info(

	struct dk_cinfo		*dkinfo)

{

	struct disk_info	*disk;

	struct dk_cinfo		*dp;

	for (disk = disk_list; disk != NULL; disk = disk->disk_next) {

		assert(dkinfo->dki_ctype == DKC_VBD);

		dp = &disk->disk_dkinfo;

		if (dp->dki_ctype == dkinfo->dki_ctype &&

		    dp->dki_cnum == dkinfo->dki_cnum &&

		    dp->dki_unit == dkinfo->dki_unit &&

		    strcmp(dp->dki_dname, dkinfo->dki_dname) == 0) {

			return (disk);

		}

	}

	impossible("No VBD disk info instance\n");

	/*NOTREACHED*/

}

/*

 * To convert EFI to SMI labels, we need to get label geometry.

 * Unfortunately at this time there is no good way to do so.

 * DKIOCGGEOM will fail if disk is EFI labeled. So we hack around

 * it and clear EFI label, do a DKIOCGGEOM and put the EFI label

 * back on disk.

 * This routine gets the label geometry and initializes the label

 * It uses cur_file as opened device.

 * returns 0 if succeeds or -1 if failed.

 */

static int

auto_label_init(struct dk_label *label)

{

	dk_efi_t	dk_ioc;

	dk_efi_t	dk_ioc_back;

	efi_gpt_t	*data = NULL;

	efi_gpt_t	*databack = NULL;