/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (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 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * This file contains functions to implement the partition menu commands.

 */

#include "global.h"

#include "partition.h"

#include "menu_partition.h"

#include "menu_command.h"

#include "modify_partition.h"

#include "misc.h"

#include "label.h"

#include "auto_sense.h"

#include <stdlib.h>

#include <string.h>

#ifdef __STDC__

/* Function prototypes for ANSI C Compilers */

static void	adj_cyl_offset(struct dk_map32 *map);

static int	check_map(struct dk_map32 *map);

static void	get_user_map(struct dk_map32 *map, int float_part);

static void	get_user_map_efi(struct dk_gpt *map, int float_part);

#else	/* __STDC__ */

/* Function prototypes for non-ANSI C Compilers */

static void	adj_cyl_offset();

static int	check_map();

static void	get_user_map();

static void	get_user_map_efi();

#endif	/* __STDC__ */

static char *partn_list[] = { "0", "1", "2", "3", "4", "5", "6", "7", NULL };

static char *sel_list[] = { "0", "1", "2", "3", NULL };

#define	MBYTE	(1024*1024)

/*

 * Modify/Create a predefined partition table.

 */

int

p_modify()

{

	struct	partition_info	tmp_pinfo[1];

	struct	dk_map32	*map = tmp_pinfo->pinfo_map;

	u_ioparam_t		ioparam;

	int			inpt_dflt = 0;

	int			free_hog = -1;

	int			i;

	char			tmpstr[80];

	char			tmpstr2[300];

	int			sel_type = 0;

	/*

	 * There must be a current disk type (and therefore a current disk).

	 */

	if (cur_dtype == NULL) {

		err_print("Current Disk Type is not set.\n");

		return (-1);

	}

	/*

	 * check if there exists a partition table for the disk.

	 */

	if (cur_parts == NULL) {

		err_print("Current Disk has no partition table.\n");

		return (-1);

	}

	/*

	 * If the disk has mounted partitions, cannot modify

	 */

	if (checkmount((daddr_t)-1, (daddr_t)-1)) {

		err_print(

"Cannot modify disk partitions while it has mounted partitions.\n\n");

		return (-1);

	}

	/*

	 * If the disk has partitions currently being used for

	 * swapping, cannot modify

	 */

	if (checkswap((daddr_t)-1, (daddr_t)-1)) {

		err_print(

"Cannot modify disk partitions while it is \

currently being used for swapping.\n");

		return (-1);

	}

	/*

	 * prompt user for a partition table base

	 */

	if (cur_parts->pinfo_name != NULL) {

		(void) snprintf(tmpstr, sizeof (tmpstr),

			"\t0. Current partition table (%s)",

			cur_parts->pinfo_name);

	} else {

		(void) sprintf(tmpstr,

			"\t0. Current partition table (unnamed)");

	}

	(void) snprintf(tmpstr2, sizeof (tmpstr2),

"Select partitioning base:\n%s\n"

"\t1. All Free Hog\n"

"Choose base (enter number) ",

		tmpstr);

	ioparam.io_charlist = sel_list;

	sel_type = input(FIO_MSTR, tmpstr2, '?', &ioparam,

		&sel_type, DATA_INPUT);

	switch (cur_label) {

	case L_TYPE_SOLARIS:

	    if (sel_type == 0) {

		/*

		 * Check for invalid parameters but do

		 * not modify the table.

		 */

		if (check_map(cur_parts->pinfo_map)) {

			err_print("\

Warning: Fix, or select a different partition table.\n");

			return (0);

		}

		/*

		 * Create partition map from existing map

		 */

		tmp_pinfo->vtoc = cur_parts->vtoc;

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

			map[i].dkl_nblk = cur_parts->pinfo_map[i].dkl_nblk;

			map[i].dkl_cylno = cur_parts->pinfo_map[i].dkl_cylno;

		}

	    } else {

		/*

		 * Make an empty partition map, with all the space

		 * in the c partition.

		 */

		set_vtoc_defaults(tmp_pinfo);

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

			map[i].dkl_nblk = 0;

			map[i].dkl_cylno = 0;

		}

		map[C_PARTITION].dkl_nblk = ncyl * spc();

#if defined(i386)

		/*

		 * Adjust for the boot and possibly alternates partitions

		 */

		map[I_PARTITION].dkl_nblk = spc();

		map[I_PARTITION].dkl_cylno = 0;

		if (cur_ctype->ctype_ctype != DKC_SCSI_CCS) {

			map[J_PARTITION].dkl_nblk = 2 * spc();

			map[J_PARTITION].dkl_cylno = spc() / spc();

		}

#endif			/* defined(i386) */

	    }

	    break;

	case L_TYPE_EFI:

	    if (sel_type == 1) {

		for (i = 0; i < cur_parts->etoc->efi_nparts; i++) {

		    cur_parts->etoc->efi_parts[i].p_start = 0;

		    cur_parts->etoc->efi_parts[i].p_size = 0;

		}

	    }

	    break;

	}

	fmt_print("\n");

	if (cur_label == L_TYPE_SOLARIS) {

	    print_map(tmp_pinfo);

	} else {

	    print_map(cur_parts);

	}

	ioparam.io_charlist = confirm_list;

	if (input(FIO_MSTR,

"Do you wish to continue creating a new partition\ntable based on above table",

			'?', &ioparam, &inpt_dflt, DATA_INPUT)) {

		return (0);

	}

	/*

	 * get Free Hog partition

	 */

	inpt_dflt = 1;

	while ((free_hog < 0) && (cur_label == L_TYPE_SOLARIS)) {

		free_hog = G_PARTITION;	/* default to g partition */

		ioparam.io_charlist = partn_list;

		free_hog = input(FIO_MSTR, "Free Hog partition", '?',

			&ioparam, &free_hog, DATA_INPUT);

		/* disallow c partition */

		if (free_hog == C_PARTITION) {

			fmt_print("'%c' cannot be the 'Free Hog' partition.\n",

				C_PARTITION + PARTITION_BASE);

			free_hog = -1;

			continue;

		}

		/*

		 * If user selected all float set the

		 * float to be the whole disk.

		 */

		if (sel_type == 1) {

			map[free_hog].dkl_nblk = map[C_PARTITION].dkl_nblk;

#if defined(i386)

			map[free_hog].dkl_nblk -= map[I_PARTITION].dkl_nblk;

			if (cur_ctype->ctype_ctype != DKC_SCSI_CCS) {

				map[free_hog].dkl_nblk -=

					map[J_PARTITION].dkl_nblk;

			}

#endif			/* defined(i386) */

			break;

		}

		/*

		 * Warn the user if there is no free space in

		 * the float partition.

		 */

		if (map[free_hog].dkl_nblk == 0) {

			err_print("\

Warning: No space available from Free Hog partition.\n");

			ioparam.io_charlist = confirm_list;

			if (input(FIO_MSTR, "Continue", '?',

				&ioparam, &inpt_dflt, DATA_INPUT)) {

				free_hog = -1;

			}

		}

	}

	inpt_dflt = 0;

	if (cur_label == L_TYPE_EFI) {

	    free_hog = G_PARTITION; /* default to g partition */

	    ioparam.io_charlist = partn_list;

	    free_hog = input(FIO_MSTR, "Free Hog partition", '?',

		&ioparam, &free_hog, DATA_INPUT);

	    /* disallow c partition */

	    if (free_hog == C_PARTITION) {

		fmt_print("'%c' cannot be the 'Free Hog' partition.\n",

		    C_PARTITION + PARTITION_BASE);

		return (-1);

	    }

	    get_user_map_efi(cur_parts->etoc, free_hog);

	    print_map(cur_parts);

	    if (check("Ready to label disk, continue")) {

		return (-1);

	    }

	    fmt_print("\n");

	    if (write_label()) {

		err_print("Writing label failed\n");

		return (-1);

	    }

	    return (0);

	}

	/*

	 * get user modified partition table

	 */

	get_user_map(map, free_hog);

	/*

	 * Update cylno offsets

	 */

	adj_cyl_offset(map);

	fmt_print("\n");

	print_map(tmp_pinfo);

	ioparam.io_charlist = confirm_list;

	if (input(FIO_MSTR, "\

Okay to make this the current partition table", '?',

		&ioparam, &inpt_dflt, DATA_INPUT)) {

		return (0);

	} else {

		make_partition();

		/*

		 * Update new partition map

		 */

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

			cur_parts->pinfo_map[i].dkl_nblk = map[i].dkl_nblk;

			cur_parts->pinfo_map[i].dkl_cylno = map[i].dkl_cylno;

#ifdef i386

			cur_parts->vtoc.v_part[i].p_start =

				map[i].dkl_cylno * nhead * nsect;

			cur_parts->vtoc.v_part[i].p_size =

				map[i].dkl_nblk;

#endif

		}

		(void) p_name();

		/*

		 * Label the disk now

		 */

		if (check("Ready to label disk, continue")) {

			return (-1);

		}

		fmt_print("\n");

		if (write_label()) {

			err_print("Writing label failed\n");

			return (-1);

		}

		return (0);

	}

}

/*

 * Adjust cylinder offsets

 */

static void

adj_cyl_offset(map)

	struct	dk_map32 *map;

{

	int	i;

	int	cyloffset = 0;

	/*

	 * Update cylno offsets

	 */

#if defined(_SUNOS_VTOC_16)

	/*

	 * Correct cylinder allocation for having the boot and alternates

	 * slice in the beginning of the disk

	 */

	for (i = NDKMAP/2; i < NDKMAP; i++) {

		if (i != C_PARTITION && map[i].dkl_nblk) {

			map[i].dkl_cylno = cyloffset;

			cyloffset += (map[i].dkl_nblk + (spc()-1))/spc();

		} else if (map[i].dkl_nblk == 0) {

			map[i].dkl_cylno = 0;

		}

	}

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

#else					/* !defined(_SUNOS_VTOC_16) */

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

#endif					/* defined(_SUNOS_VTOC_16) */

		if (i != C_PARTITION && map[i].dkl_nblk) {

			map[i].dkl_cylno = cyloffset;

			cyloffset += (map[i].dkl_nblk + (spc()-1))/spc();

		} else if (map[i].dkl_nblk == 0) {

			map[i].dkl_cylno = 0;

		}

	}

}

/*

 * Check partition table

 */

static int

check_map(map)

	struct	dk_map32 *map;

{

	int	i;

	int	cyloffset = 0;

	int	tot_blks = 0;

#ifdef i386

	/*

	 * On x86, we must account for the boot and alternates

	 */

	cyloffset = map[0].dkl_cylno;

	tot_blks = map[0].dkl_nblk;

#endif

	/*

	 * Do some checks for invalid parameters but do

	 * not modify the table.

	 */

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

		if (map[i].dkl_cylno < 0 ||

				map[i].dkl_cylno > (daddr_t)ncyl-1) {

			err_print("\

Warning: Partition %c starting cylinder %d is out of range.\n",

				(PARTITION_BASE+i), map[i].dkl_cylno);

			return (-1);

		}

		if (map[i].dkl_nblk < 0 || map[i].dkl_nblk > (daddr_t)(ncyl -

			map[i].dkl_cylno) * spc()) {

			err_print("\

Warning: Partition %c, specified # of blocks, %d, is out of range.\n",

				(PARTITION_BASE+i), map[i].dkl_nblk);

			return (-1);

		}

		if (i != C_PARTITION && map[i].dkl_nblk) {

#ifdef	i386

			if (i == I_PARTITION || i == J_PARTITION)

				continue;

#endif

			if (map[i].dkl_cylno < cyloffset) {

				err_print(

"Warning: Overlapping partition (%c) in table.\n", PARTITION_BASE+i);

				return (-1);

			} else if (map[i].dkl_cylno > cyloffset) {

				err_print(

"Warning: Non-contiguous partition (%c) in table.\n", PARTITION_BASE+i);

			}

			cyloffset += (map[i].dkl_nblk + (spc()-1))/spc();

			tot_blks = map[i].dkl_nblk;

		}

	}

	if (tot_blks > map[C_PARTITION].dkl_nblk) {

		err_print("\

Warning: Total blocks used is greater than number of blocks in '%c'\n\

\tpartition.\n", C_PARTITION + PARTITION_BASE);

	return (-1);

	}

	return (0);

}

/*

 * get user defined partitions

 */

static void

get_user_map(map, float_part)

	struct	dk_map32 *map;

	int	float_part;

{

	int		i;

	int		newsize;

	int		deflt;

	char		tmpstr[80];

	u_ioparam_t	ioparam;

	/*

	 * Get partition sizes

	 */

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

		if (partn_list[i] == NULL)

			break;

		if ((i == C_PARTITION) || (i == float_part))

			continue;

		else {

			ioparam.io_bounds.lower = 0;

			ioparam.io_bounds.upper = map[i].dkl_nblk +

				map[float_part].dkl_nblk;

			deflt = map[i].dkl_nblk;

			if (ioparam.io_bounds.upper == 0) {

				err_print("\

Warning: no space available for '%s' from Free Hog partition\n",

					partn_list[i]);

				continue;

			}

			(void) snprintf(tmpstr, sizeof (tmpstr),

				"Enter size of partition '%s' ",

				partn_list[i]);

			newsize = input(FIO_CYL, tmpstr, ':',

				&ioparam, &deflt, DATA_INPUT);

			map[float_part].dkl_nblk -= (newsize - map[i].dkl_nblk);

			map[i].dkl_nblk = newsize;

		}

	}

}

static struct partition_info *

build_partition(tptr)

struct disk_type *tptr;

{

	struct partition_info	*part;

	struct dk_label		*label;

	int			i;

#ifdef DEBUG

	fmt_print("Creating Default Partition for the disk \n");

#endif

	/*

	 * construct a label and pass it on to

	 * build_default_partition() which builds the

	 * default partition list.

	 */

	label = zalloc(sizeof (struct dk_label));

	label->dkl_pcyl = tptr->dtype_pcyl;

	label->dkl_ncyl = tptr->dtype_ncyl;

	label->dkl_acyl = tptr->dtype_acyl;

	label->dkl_nhead = tptr->dtype_nhead;

	label->dkl_nsect = tptr->dtype_nsect;

	label->dkl_apc = apc;

	label->dkl_intrlv = 1;

	label->dkl_rpm	= tptr->dtype_rpm;

	if (!build_default_partition(label, cur_ctype->ctype_ctype))

		return (NULL);

	part = (struct partition_info *)

		    zalloc(sizeof (struct partition_info));

	part->pinfo_name = alloc_string(tptr->dtype_asciilabel);

	/*

	 * Fill in the partition info from the label

	 */

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

#if defined(_SUNOS_VTOC_8)

	    part->pinfo_map[i] = label->dkl_map[i];

#else