OpenSolaris_b135/cmd/format/partition.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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* This file contains functions that operate on partition tables.
*/
#include "global.h"
#include "partition.h"
#include "misc.h"
#include "menu_command.h"
#include "menu_partition.h"
#include <string.h>
#include <stdlib.h>
/*
* Default vtoc information for non-SVr4 partitions
*/
struct dk_map2 default_vtoc_map[NDKMAP] = {
{ V_ROOT, 0 }, /* a - 0 */
{ V_SWAP, V_UNMNT }, /* b - 1 */
{ V_BACKUP, V_UNMNT }, /* c - 2 */
{ V_UNASSIGNED, 0 }, /* d - 3 */
{ V_UNASSIGNED, 0 }, /* e - 4 */
{ V_UNASSIGNED, 0 }, /* f - 5 */
{ V_USR, 0 }, /* g - 6 */
{ V_UNASSIGNED, 0 }, /* h - 7 */
#if defined(_SUNOS_VTOC_16)
#if defined(i386)
{ V_BOOT, V_UNMNT }, /* i - 8 */
{ V_ALTSCTR, 0 }, /* j - 9 */
#else
#error No VTOC format defined.
#endif /* defined(i386) */
{ V_UNASSIGNED, 0 }, /* k - 10 */
{ V_UNASSIGNED, 0 }, /* l - 11 */
{ V_UNASSIGNED, 0 }, /* m - 12 */
{ V_UNASSIGNED, 0 }, /* n - 13 */
{ V_UNASSIGNED, 0 }, /* o - 14 */
{ V_UNASSIGNED, 0 }, /* p - 15 */
#endif /* defined(_SUNOS_VTOC_16) */
};
/*
* This routine finds the last usable sector in the partition table.
* It skips the BACKUP partition.
*/
static uint64_t
maxofN(struct dk_gpt *map)
{
uint64_t max;
uint64_t sec_no[2], start[2], size[2];
int i;
for (i = 0; i < map->efi_nparts - 1; i++) {
start[0] = map->efi_parts[i].p_start;
size[0] = map->efi_parts[i].p_size;
sec_no[0] = start[0] + size[0];
start[1] = map->efi_parts[i+1].p_start;
size[1] = map->efi_parts[i+1].p_size;
sec_no[1] = start[1] + size[1];
if (map->efi_parts[i].p_tag == V_BACKUP) {
sec_no[0] = 0;
}
if (map->efi_parts[i+1].p_tag == V_BACKUP) {
sec_no[1] = 0;
}
if (i == 0) {
max = sec_no[1];
}
if (sec_no[0] > max) {
max = sec_no[0];
} else {
max = max;
}
}
if (max == 0)
max = 34;
return (max);
}
/*
* This routine allows the user to change the boundaries of the given
* partition in the current partition map.
*/
void
change_partition(int num)
{
uint_t i;
uint64_t i64, j64;
uint_t j;
int deflt;
part_deflt_t p_deflt;
u_ioparam_t ioparam;
int tag;
int flag;
char msg[256];
blkaddr32_t cyl_offset = 0;
efi_deflt_t efi_deflt;
/*
* check if there exists a partition table for the disk.
*/
if (cur_parts == NULL) {
err_print("Current Disk has no partition table.\n");
return;
}
if (cur_label == L_TYPE_EFI) {
if (num > cur_parts->etoc->efi_nparts - 1) {
err_print("Invalid partition for EFI label\n");
return;
}
print_efi_partition(cur_parts->etoc, num, 1);
fmt_print("\n");
/*
* Prompt for p_tag and p_flag values for this partition
*/
deflt = cur_parts->etoc->efi_parts[num].p_tag;
if (deflt == V_UNASSIGNED) {
deflt = V_USR;
}
(void) sprintf(msg, "Enter partition id tag");
ioparam.io_slist = ptag_choices;
tag = input(FIO_SLIST, msg, ':', &ioparam, &deflt, DATA_INPUT);
deflt = cur_parts->etoc->efi_parts[num].p_flag;
(void) sprintf(msg, "Enter partition permission flags");
ioparam.io_slist = pflag_choices;
flag = input(FIO_SLIST, msg, ':', &ioparam, &deflt, DATA_INPUT);
ioparam.io_bounds.lower = 34;
ioparam.io_bounds.upper = cur_parts->etoc->efi_last_u_lba;
efi_deflt.start_sector = maxofN(cur_parts->etoc);
if ((cur_parts->etoc->efi_parts[num].p_start != 0) &&
(cur_parts->etoc->efi_parts[num].p_size != 0)) {
efi_deflt.start_sector =
cur_parts->etoc->efi_parts[num].p_start;
}
efi_deflt.end_sector = ioparam.io_bounds.upper -
efi_deflt.start_sector;
i64 = input(FIO_INT64, "Enter new starting Sector", ':', &ioparam,
(int *)&efi_deflt, DATA_INPUT);
ioparam.io_bounds.lower = 0;
ioparam.io_bounds.upper = cur_parts->etoc->efi_last_u_lba;
efi_deflt.end_sector = cur_parts->etoc->efi_parts[num].p_size;
efi_deflt.start_sector = i64;
j64 = input(FIO_EFI, "Enter partition size", ':', &ioparam,
(int *)&efi_deflt, DATA_INPUT);
if (j64 == 0) {
tag = V_UNASSIGNED;
i64 = 0;
} else if ((j64 != 0) && (tag == V_UNASSIGNED)) {
tag = V_USR;
}
if (cur_parts->pinfo_name != NULL)
make_partition();
cur_parts->etoc->efi_parts[num].p_tag = tag;
cur_parts->etoc->efi_parts[num].p_flag = flag;
cur_parts->etoc->efi_parts[num].p_start = i64;
cur_parts->etoc->efi_parts[num].p_size = j64;
/*
* We are now done with EFI part, so return now
*/
return;
}
/*
* Print out the given partition so the user knows what he/she's
* getting into.
*/
print_partition(cur_parts, num, 1);
fmt_print("\n");
/*
* Prompt for p_tag and p_flag values for this partition.
*/
assert(cur_parts->vtoc.v_version == V_VERSION);
deflt = cur_parts->vtoc.v_part[num].p_tag;
(void) sprintf(msg, "Enter partition id tag");
ioparam.io_slist = ptag_choices;
tag = input(FIO_SLIST, msg, ':', &ioparam, &deflt, DATA_INPUT);
deflt = cur_parts->vtoc.v_part[num].p_flag;
(void) sprintf(msg, "Enter partition permission flags");
ioparam.io_slist = pflag_choices;
flag = input(FIO_SLIST, msg, ':', &ioparam, &deflt, DATA_INPUT);
/*
* Ask for the new values. The old values are the defaults, and
* strict bounds checking is done on the values given.
*/
#if defined(i386)
if (tag != V_UNASSIGNED && tag != V_BACKUP && tag != V_BOOT) {
/*
* Determine cyl offset for boot and alternate partitions.
* Assuming that the alternate sectors partition (slice)
* physical location immediately follows the boot
* partition and partition sizes are expressed in multiples
* of cylinder size.
*/
cyl_offset = cur_parts->pinfo_map[I_PARTITION].dkl_cylno + 1;
if (tag != V_ALTSCTR) {
if (cur_parts->pinfo_map[J_PARTITION].dkl_nblk != 0) {
cyl_offset =
cur_parts->pinfo_map[J_PARTITION].dkl_cylno +
((cur_parts->pinfo_map[J_PARTITION].dkl_nblk +
(spc()-1)) / spc());
}
}
}
#endif /* defined(i386) */
ioparam.io_bounds.lower = 0;
ioparam.io_bounds.upper = ncyl - 1;
deflt = max(cur_parts->pinfo_map[num].dkl_cylno,
cyl_offset);
i = (uint_t)input(FIO_INT, "Enter new starting cyl", ':', &ioparam,
&deflt, DATA_INPUT);
ioparam.io_bounds.lower = 0;
ioparam.io_bounds.upper = (ncyl - i) * spc();
/* fill in defaults for the current partition */
p_deflt.start_cyl = i;
p_deflt.deflt_size =
min(cur_parts->pinfo_map[num].dkl_nblk,
ioparam.io_bounds.upper);
/* call input, passing p_deflt's address, typecast to (int *) */
j = (uint_t)input(FIO_ECYL, "Enter partition size", ':', &ioparam,
(int *)&p_deflt, DATA_INPUT);
/*
* If the current partition has a size of zero change the
* tag to Unassigned and the starting cylinder to zero
*/
if (j == 0) {
tag = V_UNASSIGNED;
i = 0;
}
#if defined(i386)
if (i < cyl_offset && tag != V_UNASSIGNED && tag != V_BACKUP &&
tag != V_BOOT) {
/*
* This slice overlaps boot and/or alternates slice
* Check if it's the boot or alternates slice and warn
* accordingly
*/
if (i < cur_parts->pinfo_map[I_PARTITION].dkl_cylno + 1) {
fmt_print("\nWarning: Partition overlaps boot ");
fmt_print("partition. Specify different start cyl.\n");
return;
}
/*
* Cyl offset for alternates partition was calculated before
*/
if (i < cyl_offset) {
fmt_print("\nWarning: Partition overlaps alternates ");
fmt_print("partition. Specify different start cyl.\n");
return;
}
}
#endif /* defined(i386) */
/*
* If user has entered a V_BACKUP tag then the partition
* size should specify full disk capacity else
* return an Error.
*/
if (tag == V_BACKUP) {
uint_t fullsz;
fullsz = ncyl * nhead * nsect;
if (fullsz != j) {
/*
* V_BACKUP Tag Partition != full disk capacity.
* print useful messages.
*/
fmt_print("\nWarning: Partition with V_BACKUP tag should ");
fmt_print("specify full disk capacity. \n");
return;
}
}
/*
* If the current partition is named, we can't change it.
* We create a new current partition map instead.
*/
if (cur_parts->pinfo_name != NULL)
make_partition();
/*
* Change the values.
*/
cur_parts->pinfo_map[num].dkl_cylno = i;
cur_parts->pinfo_map[num].dkl_nblk = j;
#if defined(_SUNOS_VTOC_16)
cur_parts->vtoc.v_part[num].p_start = (daddr_t)(i * (nhead * nsect));
cur_parts->vtoc.v_part[num].p_size = (long)j;
#endif /* defined(_SUNOS_VTOC_16) */
/*
* Install the p_tag and p_flag values for this partition
*/
assert(cur_parts->vtoc.v_version == V_VERSION);
cur_parts->vtoc.v_part[num].p_tag = (ushort_t)tag;
cur_parts->vtoc.v_part[num].p_flag = (ushort_t)flag;
}
/*
* This routine picks to closest partition table which matches the
* selected disk type. It is called each time the disk type is
* changed. If no match is found, it uses the first element
* of the partition table. If no table exists, a dummy is
* created.
*/
int
get_partition()
{
register struct partition_info *pptr;
register struct partition_info *parts;
/*
* If there are no pre-defined maps for this disk type, it's
* an error.
*/
parts = cur_dtype->dtype_plist;
if (parts == NULL) {
err_print("No defined partition tables.\n");
make_partition();
return (-1);
}
/*
* Loop through the pre-defined maps searching for one which match
* disk type. If found copy it into unmamed partition.
*/
enter_critical();
for (pptr = parts; pptr != NULL; pptr = pptr->pinfo_next) {
if (cur_dtype->dtype_asciilabel) {
if (pptr->pinfo_name != NULL && strcmp(pptr->pinfo_name,
cur_dtype->dtype_asciilabel) == 0) {
/*
* Set current partition and name it.
*/
cur_disk->disk_parts = cur_parts = pptr;
cur_parts->pinfo_name = pptr->pinfo_name;
exit_critical();
return (0);
}
}
}
/*
* If we couldn't find a match, take the first one.
* Set current partition and name it.
*/
cur_disk->disk_parts = cur_parts = cur_dtype->dtype_plist;
cur_parts->pinfo_name = parts->pinfo_name;
exit_critical();
return (0);
}
/*
* This routine creates a new partition map and sets it current. If there
* was a current map, the new map starts out identical to it. Otherwise
* the new map starts out all zeroes.
*/
void
make_partition()
{
register struct partition_info *pptr, *parts;
int i;
/*
* Lock out interrupts so the lists don't get mangled.
*/
enter_critical();
/*
* Get space for for the new map and link it into the list
* of maps for the current disk type.
*/
pptr = (struct partition_info *)zalloc(sizeof (struct partition_info));
parts = cur_dtype->dtype_plist;
if (parts == NULL) {
cur_dtype->dtype_plist = pptr;
} else {
while (parts->pinfo_next != NULL) {
parts = parts->pinfo_next;
}
parts->pinfo_next = pptr;
pptr->pinfo_next = NULL;
}
/*
* If there was a current map, copy its values.
*/
if (cur_label == L_TYPE_EFI) {
struct dk_gpt *map;
int nparts;
int size;
nparts = cur_parts->etoc->efi_nparts;
size = sizeof (struct dk_part) * nparts + sizeof (struct dk_gpt);
map = zalloc(size);
(void) memcpy(map, cur_parts->etoc, size);
pptr->etoc = map;
cur_disk->disk_parts = cur_parts = pptr;
exit_critical();
return;
}
if (cur_parts != NULL) {
for (i = 0; i < NDKMAP; i++) {
pptr->pinfo_map[i] = cur_parts->pinfo_map[i];
}
pptr->vtoc = cur_parts->vtoc;
} else {
/*
* Otherwise set initial default vtoc values
*/
set_vtoc_defaults(pptr);
}
/*
* Make the new one current.
*/
cur_disk->disk_parts = cur_parts = pptr;
exit_critical();
}
/*
* This routine deletes a partition map from the list of maps for
* the given disk type.
*/
void
delete_partition(struct partition_info *parts)
{
struct partition_info *pptr;
/*
* If there isn't a current map, it's an error.
*/
if (cur_dtype->dtype_plist == NULL) {
err_print("Error: unexpected null partition list.\n");
fullabort();
}
/*
* Remove the map from the list.
*/
if (cur_dtype->dtype_plist == parts)
cur_dtype->dtype_plist = parts->pinfo_next;
else {
for (pptr = cur_dtype->dtype_plist; pptr->pinfo_next != parts;
pptr = pptr->pinfo_next)
;
pptr->pinfo_next = parts->pinfo_next;
}
/*
* Free the space it was using.
*/
destroy_data((char *)parts);
}
/*
* Set all partition vtoc fields to defaults
*/
void
set_vtoc_defaults(struct partition_info *part)
{
int i;
bzero((caddr_t)&part->vtoc, sizeof (struct dk_vtoc));
part->vtoc.v_version = V_VERSION;
part->vtoc.v_nparts = NDKMAP;
part->vtoc.v_sanity = VTOC_SANE;
for (i = 0; i < NDKMAP; i++) {
part->vtoc.v_part[i].p_tag = default_vtoc_map[i].p_tag;
part->vtoc.v_part[i].p_flag = default_vtoc_map[i].p_flag;
}
}