#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <ctype.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <limits.h>

#include <sys/param.h>

#include <sys/systeminfo.h>

#include <sys/efi_partition.h>

#include <sys/byteorder.h>

#include <sys/systeminfo.h>

#include <sys/dktp/fdisk.h>

#include <sys/dkio.h>

#include <sys/vtoc.h>

#define CLR_SCR "[1;1H[0J"

#define CLR_LIN "[0K"

#define HOME "[1;1H[0K[2;1H[0K[3;1H[0K[4;1H[0K[5;1H[0K" \

"[6;1H[0K[7;1H[0K[8;1H[0K[9;1H[0K[10;1H[0K[1;1H"

#define Q_LINE "[22;1H[0K[21;1H[0K[20;1H[0K"

#define W_LINE "[12;1H[0K[11;1H[0K"

#define E_LINE "[24;1H[0K[23;1H[0K"

#define M_LINE "[13;1H[0K[14;1H[0K[15;1H[0K[16;1H[0K[17;1H" \

"[0K[18;1H[0K[19;1H[0K[13;1H"

#define T_LINE "[1;1H[0K"

#define DEFAULT_PATH "/dev/rdsk/"

#define MAX_SECT (63)

#define MAX_CYL (1022)

#define MAX_HEAD (254)

#define DK_MAX_2TB UINT32_MAX /* Max # of sectors in 2TB */

#define OLD 0

#define NEW 1

#define VTOC_OK 0 /* Good VTOC */

#define VTOC_INVAL 1 /* invalid VTOC */

#define VTOC_NOTSUP 2 /* operation not supported - EFI label */

#define VTOC_RWERR 3 /* couldn't read or write VTOC */

#ifdef sparc

#define les(val) ((((val)&0xFF)<<8)|(((val)>>8)&0xFF))

#define lel(val) (((unsigned)(les((val)&0x0000FFFF))<<16) | \

(les((unsigned)((val)&0xffff0000)>>16)))

#else

#define les(val) (val)

#define lel(val) (val)

#endif

#if defined(_SUNOS_VTOC_16)

#define VTOC_OFFSET 1

#elif defined(_SUNOS_VTOC_8)

#define VTOC_OFFSET 0

#else

#error No VTOC format defined.

#endif

static char Usage[] = "Usage: fdisk\n"

"[ -w | r | d | n | I | B | E | g | G | R | t | T ] rdevice";

static char Usage1[] = " Partition options:\n"

" -w Write to a disk from stdin (see -o and -s).";

static char Ostr[] = "Other OS";

static char Dstr[] = "DOS12";

static char D16str[] = "DOS16";

static char DDstr[] = "DOS-DATA";

static char EDstr[] = "EXT-DOS";

static char DBstr[] = "DOS-BIG";

static char PCstr[] = "PCIX";

static char Ustr[] = "UNIX System";

static char SUstr[] = "Solaris";

static char SU2str[] = "Solaris2";

static char X86str[] = "x86 Boot";

static char DIAGstr[] = "Diagnostic";

static char IFSstr[] = "IFS: NTFS";

static char AIXstr[] = "AIX Boot";

static char AIXDstr[] = "AIX Data";

static char OS2str[] = "OS/2 Boot";

static char WINstr[] = "Win95 FAT32";

static char EWINstr[] = "Ext Win95";

static char FAT95str[] = "FAT16 LBA";

static char EXTLstr[] = "EXT LBA";

static char LINUXstr[] = "Linux";

static char CPMstr[] = "CP/M";

static char NOVstr[] = "Netware 3.x+";

static char QNXstr[] = "QNX 4.x";

static char QNX2str[] = "QNX part 2";

static char QNX3str[] = "QNX part 3";

static char LINNATstr[] = "Linux native";

static char NTFSVOL1str[] = "NT volset 1";

static char NTFSVOL2str[] = "NT volset 2";

static char BSDstr[] = "BSD OS";

static char NEXTSTEPstr[] = "NeXTSTEP";

static char BSDIFSstr[] = "BSDI FS";

static char BSDISWAPstr[] = "BSDI swap";

static char Actvstr[] = "Active";

static char EFIstr[] = "EFI";

static char NAstr[] = " ";

static char *Dfltdev; /* name of fixed disk drive */

static int io_wrt = 0; /* write stdin to disk (-w) */

static int io_rd = 0; /* read disk and write stdout (-r) */

static char *io_fatt; /* user supplied pattern (-P pattern) */

static int io_patt = 0; /* write pattern to disk (-P pattern) */

static int io_lgeom = 0; /* get label geometry (-g) */

static int io_pgeom = 0; /* get drive physical geometry (-G) */

static char *io_sgeom = 0; /* set label geometry (-S geom_file) */

static int io_readonly = 0; /* do not write to disk (-R) */

static off_t io_offset = 0; /* offset sector (-o offset) */

static off_t io_size = 0; /* size in sectors (-s size) */

static int v_flag = 0; /* virtual geometry-HBA flag (-v) */

static int stdo_flag = 0; /* stdout flag (-W -) */

static int io_fdisk = 0; /* do fdisk operation */

static int io_ifdisk = 0; /* interactive partition */

static int io_nifdisk = 0; /* non-interactive partition (-n) */

static int io_adjt = 0; /* check/adjust VTOC (truncate (-t)) */

static int io_ADJT = 0; /* check/adjust VTOC (delete (-T)) */

static char *io_ffdisk = 0; /* input fdisk file name (-F file) */

static char *io_Wfdisk = 0; /* output fdisk file name (-W file) */

static char *io_Afdisk = 0; /* add entry to partition table (-A) */

static char *io_Dfdisk = 0; /* delete entry from part. table (-D) */

static char *io_mboot = 0; /* master boot record (-b boot_file) */

static struct mboot BootCod; /* buffer for master boot record */

static int io_wholedisk = 0; /* use whole disk for Solaris (-B) */

static int io_EFIdisk = 0; /* use whole disk for EFI (-E) */

static int io_debug = 0; /* activate verbose mode (-d) */

static int io_image = 0; /* create image using geometry (-I) */

static struct mboot *Bootblk; /* pointer to cut/paste sector zero */

static char *Bootsect; /* pointer to sector zero buffer */

static char *Nullsect;

static struct extvtoc disk_vtoc; /* verify VTOC table */

static int vt_inval = 0;

static int no_virtgeom_ioctl = 0; /* ioctl for virtual geometry failed */

static int no_physgeom_ioctl = 0; /* ioctl for physical geometry failed */

static struct ipart Table[FD_NUMPART];

static struct ipart Old_Table[FD_NUMPART];

static struct dk_minfo minfo;

static struct dk_geom disk_geom;

static int Dev; /* fd for open device */

static diskaddr_t dev_capacity; /* number of blocks on device */

static diskaddr_t chs_capacity; /* Numcyl_usable * heads * sectors */

static int Numcyl_usable; /* Number of usable cylinders */

/* used to limit fdisk to 2TB */

static int Numcyl; /* number of cylinders */

static int heads; /* number of heads */

static int sectors; /* number of sectors per track */

static int acyl; /* number of alternate sectors */

static int hba_Numcyl; /* number of cylinders */

static int hba_heads; /* number of heads */

static int hba_sectors; /* number of sectors per track */

static int sectsiz; /* sector size */

#define LOADFILE 0 /* load fdisk from file */

#define LOADDEL 1 /* delete an fdisk entry */

#define LOADADD 2 /* add an fdisk entry */

#define CBUFLEN 80

static char s[CBUFLEN];

static void update_disk_and_exit(boolean_t table_changed);

int main(int argc, char *argv[]);

static int read_geom(char *sgeom);

static void dev_mboot_read(void);

static void dev_mboot_write(off_t sect, char *buff, int bootsiz);

static void mboot_read(void);

static void fill_patt(void);

static void abs_read(void);

static void abs_write(void);

static void load(int funct, char *file);

static void Set_Table_CHS_Values(int ti);

static int insert_tbl(int id, int act,

int bhead, int bsect, int bcyl,

int ehead, int esect, int ecyl,

uint32_t rsect, uint32_t numsect);

static int verify_tbl(void);

static int pars_fdisk(char *line,

int *id, int *act,

int *bhead, int *bsect, int *bcyl,

int *ehead, int *esect, int *ecyl,

uint32_t *rsect, uint32_t *numsect);

static int validate_part(int id, uint32_t rsect, uint32_t numsect);

static void stage0(void);

static int pcreate(void);

static int specify(uchar_t tsystid);

static void dispmenu(void);

static int pchange(void);

static int ppartid(void);

static char pdelete(void);

static void rm_blanks(char *s);

static int getcyl(void);

static void disptbl(void);

static void print_Table(void);

static void copy_Table_to_Old_Table(void);

static void nulltbl(void);

static void copy_Bootblk_to_Table(void);

static void fill_ipart(char *bootptr, struct ipart *partp);

#ifdef sparc

uchar_t getbyte(char **bp);

uint32_t getlong(char **bp);

#endif

static void copy_Table_to_Bootblk(void);

static int TableChanged(void);

static void ffile_write(char *file);

static void fix_slice(void);

static int yesno(void);

static int readvtoc(void);

static int writevtoc(void);

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

static int clear_efi(void);

static void clear_vtoc(int table, int part);

static int lecture_and_query(char *warning, char *devname);

static void sanity_check_provided_device(char *devname, int fd);

static char *get_node(char *devname);

static void

update_disk_and_exit(boolean_t table_changed)

{

if (table_changed) {

/*

copy_Table_to_Bootblk();

dev_mboot_write(0, Bootsect, sectsiz);

}

/* If the VTOC table is wrong fix it (truncation only) */

if (io_adjt)

fix_slice();

exit(0);

}

main(int argc, char *argv[])

{

int c, i;

extern int optind;

extern char *optarg;

int errflg = 0;

int diag_cnt = 0;

int openmode;

setbuf(stderr, 0); /* so all output gets out on exit */

setbuf(stdout, 0);

/* Process the options. */

while ((c = getopt(argc, argv, "o:s:P:F:b:A:D:W:S:tTIhwvrndgGRBE"))

!= EOF) {

switch (c) {

case 'o':

io_offset = (off_t)strtoull(optarg, 0, 0);

continue;

case 's':

io_size = (off_t)strtoull(optarg, 0, 0);

continue;

case 'P':

diag_cnt++;

io_patt++;

io_fatt = optarg;

continue;

case 'w':

diag_cnt++;

io_wrt++;

continue;

case 'r':

diag_cnt++;

io_rd++;

continue;

case 'd':

io_debug++;

continue;

case 'I':

io_image++;

continue;

case 'R':

io_readonly++;

continue;

case 'S':

diag_cnt++;

io_sgeom = optarg;

continue;

case 'T':

io_ADJT++;

/* FALLTHRU */

case 't':

io_adjt++;

continue;

case 'B':

io_wholedisk++;

io_fdisk++;

continue;

case 'E':

io_EFIdisk++;

io_fdisk++;

continue;

case 'g':

diag_cnt++;

io_lgeom++;

continue;

case 'G':

diag_cnt++;

io_pgeom++;

continue;

case 'n':

io_nifdisk++;

io_fdisk++;

continue;

case 'F':

io_fdisk++;

io_ffdisk = optarg;

continue;

case 'b':

io_mboot = optarg;

continue;

case 'W':

/*

if (strncmp(optarg, "-", 1) == 0)

stdo_flag = 1;

else

io_Wfdisk = optarg;

io_fdisk++;

continue;

case 'A':

io_fdisk++;

io_Afdisk = optarg;

continue;

case 'D':

io_fdisk++;

io_Dfdisk = optarg;

continue;

case 'h':

(void) fprintf(stderr, "%s\n", Usage);

(void) fprintf(stderr, "%s\n", Usage1);

exit(0);

/* FALLTHRU */

case 'v':

v_flag = 1;

continue;

case '?':

errflg++;

break;

}

break;

}

if (io_image && io_sgeom && diag_cnt == 1) {

diag_cnt = 0;

}

/* User option checking */

/* By default, run in interactive mode */

if (!io_fdisk && !diag_cnt && !io_nifdisk) {

io_ifdisk++;

io_fdisk++;

}

if (((io_fdisk || io_adjt) && diag_cnt) || (diag_cnt > 1)) {

errflg++;

}

/* Was any error detected? */

if (errflg || argc == optind) {

(void) fprintf(stderr, "%s\n", Usage);

(void) fprintf(stderr,

"\nDetailed help is available with the -h option.\n");

exit(2);

}

/* Figure out the correct device node to open */

Dfltdev = get_node(argv[optind]);

if (io_readonly)

openmode = O_RDONLY;

else

openmode = O_RDWR|O_CREAT;

if ((Dev = open(Dfltdev, openmode, 0666)) == -1) {

(void) fprintf(stderr,

"fdisk: Cannot open device %s.\n",

Dfltdev);

exit(1);

}

/*

if (ioctl(Dev, DKIOCGMEDIAINFO, &minfo)) {

memset(&minfo, 0, sizeof (minfo));

}

/* Get the disk geometry */

if (!io_image) {

/* Get disk's HBA (virtual) geometry */

errno = 0;

if (ioctl(Dev, DKIOCG_VIRTGEOM, &disk_geom)) {

/*

if (errno == ENOTTY) {

v_flag = 0;

no_virtgeom_ioctl = 1;

} else if (errno == EINVAL) {

/*

v_flag = 0;

hba_Numcyl = hba_heads = hba_sectors = 0;

} else {

(void) fprintf(stderr,

"%s: Cannot get virtual disk geometry.\n",

argv[optind]);

exit(1);

}

} else {

/* save virtual geometry values obtained by ioctl */

hba_Numcyl = disk_geom.dkg_ncyl;

hba_heads = disk_geom.dkg_nhead;

hba_sectors = disk_geom.dkg_nsect;

}

errno = 0;

if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) {

if (errno == ENOTTY) {

no_physgeom_ioctl = 1;

} else {

(void) fprintf(stderr,

"%s: Cannot get physical disk geometry.\n",

argv[optind]);

exit(1);

}

}

/*

if (no_virtgeom_ioctl && no_physgeom_ioctl) {

errno = 0;

if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) {

(void) fprintf(stderr,

"%s: Cannot get disk label geometry.\n",

argv[optind]);

exit(1);

}

}

Numcyl = disk_geom.dkg_ncyl;

heads = disk_geom.dkg_nhead;

sectors = disk_geom.dkg_nsect;

sectsiz = 512;

acyl = disk_geom.dkg_acyl;

/*

if (no_virtgeom_ioctl ||

disk_geom.dkg_ncyl == 0 ||

disk_geom.dkg_nhead == 0 ||

disk_geom.dkg_nsect == 0 ||

disk_geom.dkg_ncyl > MAX_CYL ||

disk_geom.dkg_nhead > MAX_HEAD ||

disk_geom.dkg_nsect > MAX_SECT) {

/*

v_flag = 0;

hba_sectors = MAX_SECT;

hba_heads = MAX_HEAD + 1;

hba_Numcyl = (Numcyl * heads * sectors) /

(hba_sectors * hba_heads);

}

if (io_debug) {

(void) fprintf(stderr, "Physical Geometry:\n");

(void) fprintf(stderr,

" cylinders[%d] heads[%d] sectors[%d]\n"

" sector size[%d] blocks[%d] mbytes[%d]\n",

Numcyl,

heads,

sectors,

sectsiz,

Numcyl * heads * sectors,

(Numcyl * heads * sectors * sectsiz) / 1048576);

(void) fprintf(stderr, "Virtual (HBA) Geometry:\n");

(void) fprintf(stderr,

" cylinders[%d] heads[%d] sectors[%d]\n"

" sector size[%d] blocks[%d] mbytes[%d]\n",

hba_Numcyl,

hba_heads,

hba_sectors,

sectsiz,

hba_Numcyl * hba_heads * hba_sectors,

(hba_Numcyl * hba_heads * hba_sectors * sectsiz) /

1048576);

}

}

/* If user has requested a geometry report just do it and exit */

if (io_lgeom) {

if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) {

(void) fprintf(stderr,

"%s: Cannot get disk label geometry.\n",

argv[optind]);

exit(1);

}

Numcyl = disk_geom.dkg_ncyl;

heads = disk_geom.dkg_nhead;

sectors = disk_geom.dkg_nsect;

sectsiz = 512;

acyl = disk_geom.dkg_acyl;

(void) printf("* Label geometry for device %s\n", Dfltdev);

(void) printf(

"* PCYL NCYL ACYL BCYL NHEAD NSECT"

" SECSIZ\n");

(void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n",

Numcyl,

disk_geom.dkg_ncyl,

disk_geom.dkg_acyl,

disk_geom.dkg_bcyl,

heads,

sectors,

sectsiz);

exit(0);

} else if (io_pgeom) {

if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) {

(void) fprintf(stderr,

"%s: Cannot get physical disk geometry.\n",

argv[optind]);

exit(1);

}

(void) printf("* Physical geometry for device %s\n", Dfltdev);

(void) printf(

"* PCYL NCYL ACYL BCYL NHEAD NSECT"

" SECSIZ\n");

(void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n",

disk_geom.dkg_pcyl,

disk_geom.dkg_ncyl,

disk_geom.dkg_acyl,

disk_geom.dkg_bcyl,

disk_geom.dkg_nhead,

disk_geom.dkg_nsect,

sectsiz);

exit(0);

} else if (io_sgeom) {

if (read_geom(io_sgeom)) {

exit(1);

} else if (!io_image) {

exit(0);

}

}

/*

chs_capacity = (diskaddr_t)Numcyl * heads * sectors;

dev_capacity = chs_capacity;

Numcyl_usable = Numcyl;

if (chs_capacity > DK_MAX_2TB) {

/* limit to 2TB */

Numcyl_usable = DK_MAX_2TB / (heads * sectors);

chs_capacity = (diskaddr_t)Numcyl_usable * heads * sectors;

}

if (minfo.dki_capacity > 0)

dev_capacity = minfo.dki_capacity;

/* Allocate memory to hold three complete sectors */

Bootsect = (char *)malloc(3 * sectsiz);

if (Bootsect == NULL) {

(void) fprintf(stderr,

"fdisk: Unable to obtain enough buffer memory"

" (%d bytes).\n",

3 * sectsiz);

exit(1);

}

Nullsect = Bootsect + sectsiz;

/* Zero out the "NULL" sector */

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

Nullsect[i] = 0;

}

/* Find out what the user wants done */

if (io_rd) { /* abs disk read */

abs_read(); /* will not return */

} else if (io_wrt && !io_readonly) {

abs_write(); /* will not return */

} else if (io_patt && !io_readonly) {

fill_patt(); /* will not return */

}

/* This is the fdisk edit, the real reason for the program. */

sanity_check_provided_device(Dfltdev, Dev);

/* Get the new BOOT program in case we write a new fdisk table */

mboot_read();

/* Read from disk master boot */

dev_mboot_read();

/*

Bootblk = (struct mboot *)Bootsect;

copy_Bootblk_to_Table();

/* save away a copy of Table in Old_Table for sensing changes */

copy_Table_to_Old_Table();

/* Load fdisk table from specified file (-F fdisk_file) */

if (io_ffdisk) {

/* Load and verify user-specified table parameters */

load(LOADFILE, io_ffdisk);

}

/* Does user want to delete or add an entry? */

if (io_Dfdisk) {

load(LOADDEL, io_Dfdisk);

}

if (io_Afdisk) {

load(LOADADD, io_Afdisk);

}

if (!io_ffdisk && !io_Afdisk && !io_Dfdisk) {

/* Check if there is no fdisk table */

if (Table[0].systid == UNUSED || io_wholedisk || io_EFIdisk) {

if (io_ifdisk && !io_wholedisk && !io_EFIdisk) {

(void) printf(

"No fdisk table exists. The default"

" partition for the disk is:\n\n"

" a 100%% \"SOLARIS System\" "

"partition\n\n"

"Type \"y\" to accept the default "

"partition, otherwise type \"n\" to "

"edit the\n partition table.\n");

if (Numcyl > Numcyl_usable)

(void) printf("WARNING: Disk is larger"

" than 2TB. Solaris partition will"

" be limited to 2 TB.\n");

}

/* Edit the partition table as directed */

if (io_wholedisk ||(io_ifdisk && yesno())) {

/* Default scenario */

nulltbl();

/* now set up UNIX System partition */

Table[0].bootid = ACTIVE;

Table[0].relsect = lel(heads * sectors);

Table[0].numsect =

lel((ulong_t)((Numcyl_usable - 1) *

heads * sectors));

Table[0].systid = SUNIXOS2; /* Solaris */

/* calculate CHS values for table entry 0 */

Set_Table_CHS_Values(0);

update_disk_and_exit(B_TRUE);

} else if (io_EFIdisk) {

/* create an EFI partition for the whole disk */

nulltbl();

i = insert_tbl(EFI_PMBR, 0, 0, 0, 0, 0, 0, 0, 1,

(dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB :

(dev_capacity - 1));

if (i != 0) {

(void) fprintf(stderr,

"Error creating EFI partition\n");

exit(1);

}

update_disk_and_exit(B_TRUE);

}

}

}

/* Display complete fdisk table entries for debugging purposes */

if (io_debug) {

(void) fprintf(stderr, "Partition Table Entry Values:\n");

print_Table();

if (io_ifdisk) {

(void) fprintf(stderr, "\n");

(void) fprintf(stderr, "Press Enter to continue.\n");

(void) gets(s);

}

}

/* Interactive fdisk mode */

if (io_ifdisk) {

(void) printf(CLR_SCR);

disptbl();

for (;;) {

stage0();

copy_Bootblk_to_Table();

disptbl();

}

}

/* If user wants to write the table to a file, do it */

if (io_Wfdisk)

ffile_write(io_Wfdisk);

else if (stdo_flag)

ffile_write((char *)stdout);

update_disk_and_exit(TableChanged() == 1);

return (0);

}

static int

read_geom(char *sgeom)

{

char line[256];

FILE *fp;

/* open the prototype file */

if ((fp = fopen(sgeom, "r")) == NULL) {

(void) fprintf(stderr, "fdisk: Cannot open file %s.\n",

io_sgeom);

return (1);

}

/* Read a line from the file */

while (fgets(line, sizeof (line) - 1, fp)) {

if (line[0] == '\0' || line[0] == '\n' || line[0] == '*')

continue;

else {

line[strlen(line)] = '\0';

if (sscanf(line, "%hu %hu %hu %hu %hu %hu %d",

&disk_geom.dkg_pcyl,

&disk_geom.dkg_ncyl,

&disk_geom.dkg_acyl,

&disk_geom.dkg_bcyl,

&disk_geom.dkg_nhead,

&disk_geom.dkg_nsect,

&sectsiz) != 7) {

(void) fprintf(stderr,

"Syntax error:\n \"%s\".\n",

line);

return (1);

}

break;

} /* else */

} /* while (fgets(line, sizeof (line) - 1, fp)) */

if (!io_image) {

if (ioctl(Dev, DKIOCSGEOM, &disk_geom)) {

(void) fprintf(stderr,

"fdisk: Cannot set label geometry.\n");

return (1);

}

} else {

Numcyl = hba_Numcyl = disk_geom.dkg_ncyl;

heads = hba_heads = disk_geom.dkg_nhead;

sectors = hba_sectors = disk_geom.dkg_nsect;

acyl = disk_geom.dkg_acyl;

}

(void) fclose(fp);

return (0);

}

static void

dev_mboot_read(void)

{

if ((ioctl(Dev, DKIOCGMBOOT, Bootsect) < 0) && (errno != ENOTTY)) {

perror("Error in ioctl DKIOCGMBOOT");

}

if (errno == 0)

return;

if (lseek(Dev, 0, SEEK_SET) == -1) {

(void) fprintf(stderr,

"fdisk: Error seeking to partition table on %s.\n",

Dfltdev);

if (!io_image)

exit(1);

}

if (read(Dev, Bootsect, sectsiz) != sectsiz) {

(void) fprintf(stderr,

"fdisk: Error reading partition table from %s.\n",

Dfltdev);

if (!io_image)

exit(1);

}

}

static void

dev_mboot_write(off_t sect, char *buff, int bootsiz)

{

int new_pt, old_pt, error;

int clr_efi = -1;

if (io_readonly)

return;

if (io_debug) {

(void) fprintf(stderr, "About to write fdisk table:\n");

print_Table();

if (io_ifdisk) {

(void) fprintf(stderr, "Press Enter to continue.\n");

(void) gets(s);

}

}

/*

for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) {

/* We only care about potential Solaris parts. */

if (Table[new_pt].systid != SUNIXOS &&

Table[new_pt].systid != SUNIXOS2)

continue;

/* Does the old table have an exact entry for the new entry? */

for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) {

/* We only care about old Solaris partitions. */

if ((Old_Table[old_pt].systid == SUNIXOS) ||

(Old_Table[old_pt].systid == SUNIXOS2)) {

/* Is this old one the same as a new one? */

if ((Old_Table[old_pt].relsect ==

Table[new_pt].relsect) &&

(Old_Table[old_pt].numsect ==

Table[new_pt].numsect))

break; /* Yes */

}

}

/* Did a solaris partition change location or size? */

if (old_pt >= FD_NUMPART) {

/* Yes clear old vtoc */

if (io_debug) {

(void) fprintf(stderr,

"Clearing VTOC labels from NEW"

" table\n");

}

clear_vtoc(NEW, new_pt);

}

}

/* see if the old table had EFI */

for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) {

if (Old_Table[old_pt].systid == EFI_PMBR) {

clr_efi = old_pt;

}

}

/* look to see if a EFI partition changed in relsect/numsect */

for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) {

if (Table[new_pt].systid != EFI_PMBR)

continue;

for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) {

if ((Old_Table[old_pt].systid ==

Table[new_pt].systid) &&

(Old_Table[old_pt].relsect ==

Table[new_pt].relsect) &&

(Old_Table[old_pt].numsect ==

Table[new_pt].numsect))

break;

}

/*

if (old_pt == FD_NUMPART && Table[new_pt].begcyl != 0) {

clr_efi = 0;

}

break;

}

/* clear labels if necessary */

if (clr_efi >= 0) {

if (io_debug) {

(void) fprintf(stderr, "Clearing EFI labels\n");

}

if ((error = clear_efi()) != 0) {

if (io_debug) {

(void) fprintf(stderr,

"\tError %d clearing EFI labels"

" (probably no EFI labels exist)\n",

error);

}

}

}

if ((ioctl(Dev, DKIOCSMBOOT, buff) == -1) && (errno != ENOTTY)) {

(void) fprintf(stderr,

"fdisk: Error in ioctl DKIOCSMBOOT on %s.\n",

Dfltdev);

}

if (errno == 0)

return;

/* write to disk drive */

if (lseek(Dev, sect, SEEK_SET) == -1) {

(void) fprintf(stderr,

"fdisk: Error seeking to master boot record on %s.\n",

Dfltdev);

exit(1);

}

if (write(Dev, buff, bootsiz) != bootsiz) {

(void) fprintf(stderr,

"fdisk: Error writing master boot record to %s.\n",

Dfltdev);

exit(1);

}

}

static void

mboot_read(void)

{

int mDev, i;

struct ipart *part;

#if defined(i386) || defined(sparc)

/*

if (io_mboot == (char *)0) {

/*

io_mboot = "/usr/lib/fs/ufs/mboot";

}

/* First read in the master boot record */

/* Open the master boot proto file */

if ((mDev = open(io_mboot, O_RDONLY, 0666)) == -1) {

(void) fprintf(stderr,

"fdisk: Cannot open master boot file %s.\n",

io_mboot);

exit(1);

}

/* Read the master boot program */

if (read(mDev, &BootCod, sizeof (struct mboot)) != sizeof

(struct mboot)) {

(void) fprintf(stderr,

"fdisk: Cannot read master boot file %s.\n",

io_mboot);

exit(1);

}

/* Is this really a master boot record? */

if (les(BootCod.signature) != MBB_MAGIC) {

(void) fprintf(stderr,

"fdisk: Invalid master boot file %s.\n", io_mboot);

(void) fprintf(stderr,

"Bad magic number: is %x, but should be %x.\n",

les(BootCod.signature), MBB_MAGIC);

exit(1);

}

(void) close(mDev);

#else

#error fdisk needs to be ported to new architecture

#endif

/* Zero out the partitions part of this record */

part = (struct ipart *)BootCod.parts;

for (i = 0; i < FD_NUMPART; i++, part++) {

(void) memset(part, 0, sizeof (struct ipart));

}

}

static void

fill_patt(void)

{

int *buff_ptr, i;

off_t *off_ptr;

int io_fpatt = 0;

int io_ipatt = 0;

if (strncmp(io_fatt, "#", 1) != 0) {

io_fpatt++;

io_ipatt = strtoul(io_fatt, 0, 0);

buff_ptr = (int *)Bootsect;

for (i = 0; i < sectsiz; i += 4, buff_ptr++)

*buff_ptr = io_ipatt;

}

/*

while (io_size--) {

off_ptr = (off_t *)Bootsect;

if (!io_fpatt) {

for (i = 0; i < sectsiz;

i += sizeof (off_t), off_ptr++)

*off_ptr = io_offset;

}

/* Write the data to disk */

if (lseek(Dev, (off_t)(sectsiz * io_offset++),

SEEK_SET) == -1) {

(void) fprintf(stderr, "fdisk: Error seeking on %s.\n",

Dfltdev);

exit(1);

}

if (write(Dev, Bootsect, sectsiz) != sectsiz) {

(void) fprintf(stderr, "fdisk: Error writing %s.\n",

Dfltdev);

exit(1);

}

} /* while (--io_size); */

}

static void

abs_read(void)

{

int c;

while (io_size--) {

if (lseek(Dev, (off_t)(sectsiz * io_offset++),

SEEK_SET) == -1) {

(void) fprintf(stderr, "fdisk: Error seeking on %s.\n",

Dfltdev);

exit(1);

}

if (read(Dev, Bootsect, sectsiz) != sectsiz) {

(void) fprintf(stderr, "fdisk: Error reading %s.\n",

Dfltdev);

exit(1);

}

/* Write to standard ouptut */

if ((c = write(1, Bootsect, (unsigned)sectsiz)) != sectsiz) {

if (c >= 0) {

if (io_debug)

(void) fprintf(stderr,

"fdisk: Output warning: %d of %d"

" characters written.\n",

c, sectsiz);

exit(2);

} else {

perror("write error on output file.");

exit(2);

}

} /* if ((c = write(1, Bootsect, (unsigned)sectsiz)) */

/* != sectsiz) */

} /* while (--io_size); */

exit(0);

}

static void

abs_write(void)

{

int c, i;

while (io_size--) {

int part_exit = 0;

/* Read from standard input */

if ((c = read(0, Bootsect, (unsigned)sectsiz)) != sectsiz) {

if (c >= 0) {

if (io_debug)

(void) fprintf(stderr,

"fdisk: WARNING: Incomplete read (%d of"

" %d characters read) on input file.\n",

c, sectsiz);

/* Fill pattern to mark partial sector in buf */

for (i = c; i < sectsiz; ) {

Bootsect[i++] = 0x41;

Bootsect[i++] = 0x62;

Bootsect[i++] = 0x65;

Bootsect[i++] = 0;

}

part_exit++;

} else {

perror("read error on input file.");

exit(2);

}

}

/* Write to disk drive */

if (lseek(Dev, (off_t)(sectsiz * io_offset++),

SEEK_SET) == -1) {

(void) fprintf(stderr, "fdisk: Error seeking on %s.\n",

Dfltdev);

exit(1);

}

if (write(Dev, Bootsect, sectsiz) != sectsiz) {

(void) fprintf(stderr, "fdisk: Error writing %s.\n",

Dfltdev);

exit(1);

}

if (part_exit)

exit(0);

} /* while (--io_size); */

exit(1);

}

static void

load(int funct, char *file)

{

int id;

int act;

int bhead;

int bsect;

int bcyl;

int ehead;

int esect;

int ecyl;

uint32_t rsect;

uint32_t numsect;

char line[256];

int i = 0;

int j;

FILE *fp;

switch (funct) {

case LOADFILE:

/*

nulltbl();

/* Open the prototype file */

if ((fp = fopen(file, "r")) == NULL) {

(void) fprintf(stderr,

"fdisk: Cannot open prototype partition file %s.\n",

file);

exit(1);

}

/* Read a line from the file */

while (fgets(line, sizeof (line) - 1, fp)) {

if (pars_fdisk(line, &id, &act, &bhead, &bsect,

&bcyl, &ehead, &esect, &ecyl, &rsect, &numsect)) {

continue;

}

/*

if (validate_part(id, rsect, numsect) < 0) {

(void) fprintf(stderr,

"fdisk: Error on entry \"%s\".\n",

line);

exit(1);

}

/*

if (insert_tbl(id, act, bhead, bsect, bcyl, ehead,

esect, ecyl, rsect, numsect) < 0) {

(void) fprintf(stderr,

"fdisk: Error on entry \"%s\".\n",

line);

exit(1);

}

} /* while (fgets(line, sizeof (line) - 1, fp)) */

if (verify_tbl() < 0) {

(void) fprintf(stderr,

"fdisk: Cannot create partition table\n");

exit(1);

}

(void) fclose(fp);

return;

case LOADDEL:

/* Parse the user-supplied deletion line (-D) */

if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl,

&ehead, &esect, &ecyl, &rsect, &numsect)) {

(void) fprintf(stderr,

"fdisk: Syntax error \"%s\"\n", file);

exit(1);

}

/* Find the exact entry in the table */

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

if (Table[i].systid == id &&

Table[i].bootid == act &&

Table[i].beghead == bhead &&

Table[i].begsect == ((bsect & 0x3f) |

(uchar_t)((bcyl>>2) & 0xc0)) &&

Table[i].begcyl == (uchar_t)(bcyl & 0xff) &&

Table[i].endhead == ehead &&

Table[i].endsect == ((esect & 0x3f) |

(uchar_t)((ecyl>>2) & 0xc0)) &&

Table[i].endcyl == (uchar_t)(ecyl & 0xff) &&

Table[i].relsect == lel(rsect) &&

Table[i].numsect == lel(numsect)) {

/*

for (j = i; j < FD_NUMPART - 1; j++) {

Table[j].systid = Table[j + 1].systid;

Table[j].bootid = Table[j + 1].bootid;

Table[j].beghead = Table[j + 1].beghead;

Table[j].begsect = Table[j + 1].begsect;

Table[j].begcyl = Table[j + 1].begcyl;

Table[j].endhead = Table[j + 1].endhead;

Table[j].endsect = Table[j + 1].endsect;

Table[j].endcyl = Table[j + 1].endcyl;

Table[j].relsect = Table[j + 1].relsect;

Table[j].numsect = Table[j + 1].numsect;

}

/*

Table[FD_NUMPART - 1].systid = UNUSED;

Table[FD_NUMPART - 1].bootid = 0;

return;

}

}

(void) fprintf(stderr,

"fdisk: Entry does not match any existing partition:\n"

" \"%s\"\n",

file);

exit(1);

/* FALLTHRU */

case LOADADD:

/* Parse the user-supplied addition line (-A) */

if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl, &ehead,

&esect, &ecyl, &rsect, &numsect)) {

(void) fprintf(stderr,

"fdisk: Syntax error \"%s\"\n", file);

exit(1);

}

/* Validate the partition. It cannot start at sector 0 */

if (rsect == 0) {

(void) fprintf(stderr,

"fdisk: New partition cannot start at sector 0:\n"

" \"%s\".\n",

file);

exit(1);

}

/*

if (id == EFI_PMBR) {

if (rsect != 1) {

(void) fprintf(stderr,

"fdisk: EFI partitions must start at sector"

" 1 (input rsect = %d)\n", rsect);

exit(1);

}

if (dev_capacity > DK_MAX_2TB) {

if (numsect != DK_MAX_2TB) {

(void) fprintf(stderr,

"fdisk: EFI partitions must "

"encompass the entire maximum 2 TB "

"(input numsect: %u - max: %llu)\n",

numsect, (diskaddr_t)DK_MAX_2TB);

exit(1);

}

} else if (numsect != dev_capacity - 1) {

(void) fprintf(stderr,

"fdisk: EFI partitions must encompass the "

"entire disk\n"

"(input numsect: %u - avail: %llu)\n",

numsect,

dev_capacity - 1);

exit(1);

}

}

/* Find unused entry for use and put entry in table */

if (insert_tbl(id, act, bhead, bsect, bcyl, ehead, esect,

ecyl, rsect, numsect) < 0) {

(void) fprintf(stderr,

"fdisk: Invalid entry could not be inserted:\n"

" \"%s\"\n",

file);

exit(1);

}

/* Make sure new entry does not overlap existing entry */

if (verify_tbl() < 0) {

(void) fprintf(stderr,

"fdisk: Cannot create partition \"%s\"\n", file);

exit(1);

}

} /* switch funct */

}

static void

Set_Table_CHS_Values(int ti)

{

uint32_t lba, cy, hd, sc;

lba = (uint32_t)Table[ti].relsect;

if (lba >= hba_heads * hba_sectors * MAX_CYL) {

/*

cy = MAX_CYL + 1;

hd = MAX_HEAD;

sc = MAX_SECT;

} else {

cy = lba / hba_sectors / hba_heads;

hd = lba / hba_sectors % hba_heads;

sc = lba % hba_sectors + 1;

}

Table[ti].begcyl = cy & 0xff;

Table[ti].beghead = (uchar_t)hd;

Table[ti].begsect = (uchar_t)(((cy >> 2) & 0xc0) | sc);

/*

lba = (uint32_t)(Table[ti].relsect + Table[ti].numsect - 1);

if (lba >= hba_heads * hba_sectors * MAX_CYL) {

cy = MAX_CYL + 1;

hd = MAX_HEAD;

sc = MAX_SECT;

} else {

cy = lba / hba_sectors / hba_heads;

hd = lba / hba_sectors % hba_heads;

sc = lba % hba_sectors + 1;

}

Table[ti].endcyl = cy & 0xff;

Table[ti].endhead = (uchar_t)hd;

Table[ti].endsect = (uchar_t)(((cy >> 2) & 0xc0) | sc);

}

static int

insert_tbl(

int id, int act,

int bhead, int bsect, int bcyl,

int ehead, int esect, int ecyl,

uint32_t rsect, uint32_t numsect)

{

int i;

/* validate partition size */

if (((diskaddr_t)rsect + numsect) > dev_capacity) {

(void) fprintf(stderr,

"fdisk: Partition table exceeds the size of the disk.\n");

return (-1);

}

/* find UNUSED partition table entry */

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

if (Table[i].systid == UNUSED) {

break;

}

}

if (i >= FD_NUMPART) {

(void) fprintf(stderr, "fdisk: Partition table is full.\n");

return (-1);

}

Table[i].systid = (uchar_t)id;

Table[i].bootid = (uchar_t)act;

Table[i].numsect = lel(numsect);

Table[i].relsect = lel(rsect);

/*

if (0 < bsect && bsect <= MAX_SECT &&

0 <= bhead && bhead <= MAX_HEAD &&

0 < esect && esect <= MAX_SECT &&

0 <= ehead && ehead <= MAX_HEAD) {

if (bcyl > MAX_CYL)

bcyl = MAX_CYL + 1;

if (ecyl > MAX_CYL)

ecyl = MAX_CYL + 1;

Table[i].begcyl = bcyl & 0xff;

Table[i].endcyl = ecyl & 0xff;

Table[i].beghead = (uchar_t)bhead;

Table[i].endhead = (uchar_t)ehead;

Table[i].begsect = (uchar_t)(((bcyl >> 2) & 0xc0) | bsect);

Table[i].endsect = ((ecyl >> 2) & 0xc0) | esect;

} else {

/*

Set_Table_CHS_Values(i);

}

/*

return (i);

}

static int

verify_tbl(void)

{

uint32_t i, j, rsect, numsect;

int noMoreParts = 0;

int numParts = 0;

/* Make sure new entry does not overlap an existing entry */

for (i = 0; i < FD_NUMPART - 1; i++) {

if (Table[i].systid != UNUSED) {

numParts++;

/*

if (noMoreParts) {

return (-1);

}

/*

if (Table[i].systid == EFI_PMBR) {

if (i == 0) {

noMoreParts = 1;

} else {

return (-1);

}

if (Table[i].relsect != 1) {

(void) fprintf(stderr, "ERROR: "

"Invalid starting sector "

"for EFI_PMBR partition:\n"

"relsect %d "

"(should be 1)\n",

Table[i].relsect);

return (-1);

}

if (Table[i].numsect != dev_capacity - 1) {

(void) fprintf(stderr, "ERROR: "

"EFI_PMBR partition must "

"encompass the entire "

"disk.\n numsect %d - "

"actual %llu\n",

Table[i].numsect,

dev_capacity - 1);

return (-1);

}

}

/* make sure the partition isn't larger than the disk */

rsect = lel(Table[i].relsect);

numsect = lel(Table[i].numsect);

if ((((diskaddr_t)rsect + numsect) > dev_capacity) ||

(((diskaddr_t)rsect + numsect) > DK_MAX_2TB)) {

return (-1);

}

for (j = i + 1; j < FD_NUMPART; j++) {

if (Table[j].systid != UNUSED) {

uint32_t t_relsect =

lel(Table[j].relsect);

uint32_t t_numsect =

lel(Table[j].numsect);

if (noMoreParts) {

(void) fprintf(stderr,

"Cannot add partition to "

"table; no more partitions "

"allowed\n");

if (io_debug) {

(void) fprintf(stderr,

"DEBUG: Current "

"partition:\t"

"%d:%d:%d:%d:%d:"

"%d:%d:%d:%d:%d\n"

" Next "

"partition:\t\t"

"%d:%d:%d:%d:%d:"

"%d:%d:%d:%d:%d\n",

Table[i].systid,

Table[i].bootid,

Table[i].begcyl,

Table[i].beghead,

Table[i].begsect,

Table[i].endcyl,

Table[i].endhead,

Table[i].endsect,

Table[i].relsect,

Table[i].numsect,

Table[j].systid,

Table[j].bootid,

Table[j].begcyl,

Table[j].beghead,

Table[j].begsect,

Table[j].endcyl,

Table[j].endhead,

Table[j].endsect,

Table[j].relsect,

Table[j].numsect);

}

return (-1);

}

if ((rsect >=

(t_relsect + t_numsect)) ||

((rsect + numsect) <= t_relsect)) {

continue;

} else {

(void) fprintf(stderr, "ERROR: "

"current partition overlaps"

" following partition\n");

return (-1);

}

}

}

} else {

noMoreParts = 1;

}

}

if (Table[i].systid != UNUSED) {

if (noMoreParts ||

(((diskaddr_t)lel(Table[i].relsect) +

lel(Table[i].numsect)) > dev_capacity) ||

(((diskaddr_t)lel(Table[i].relsect) +

lel(Table[i].numsect)) > DK_MAX_2TB)) {

return (-1);

}

}

return (numParts);

}

static int

pars_fdisk(

char *line,

int *id, int *act,

int *bhead, int *bsect, int *bcyl,

int *ehead, int *esect, int *ecyl,

uint32_t *rsect, uint32_t *numsect)

{

int i;

if (line[0] == '\0' || line[0] == '\n' || line[0] == '*')

return (1);

line[strlen(line)] = '\0';

for (i = 0; i < strlen(line); i++) {

if (line[i] == '\0') {

break;

} else if (line[i] == ':') {

line[i] = ' ';

}

}

if (sscanf(line, "%d %d %d %d %d %d %d %d %u %u",

id, act, bhead, bsect, bcyl, ehead, esect, ecyl,

rsect, numsect) != 10) {

(void) fprintf(stderr, "Syntax error:\n \"%s\".\n", line);

exit(1);

}

return (0);

}

static int

validate_part(int id, uint32_t rsect, uint32_t numsect)

{

int i;

if ((id != UNUSED) && (rsect == 0)) {

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

if ((Old_Table[i].systid == id) &&

(Old_Table[i].relsect == lel(rsect)) &&

(Old_Table[i].numsect == lel(numsect)))

return (0);

}

(void) fprintf(stderr,

"New partition cannot start at sector 0\n");

return (-1);

}

return (0);

}

static void

stage0(void)

{

dispmenu();

for (;;) {

(void) printf(Q_LINE);

(void) printf("Enter Selection: ");

(void) gets(s);

rm_blanks(s);

while (!((s[0] > '0') && (s[0] < '7') && (s[1] == 0))) {

(void) printf(E_LINE); /* Clear any previous error */

(void) printf(

"Enter a one-digit number between 1 and 6.");

(void) printf(Q_LINE);

(void) printf("Enter Selection: ");

(void) gets(s);

rm_blanks(s);

}

(void) printf(E_LINE);

switch (s[0]) {

case '1':

if (pcreate() == -1)

return;

break;

case '2':

if (pchange() == -1)

return;

break;

case '3':

if (pdelete() == -1)

return;

break;

case '4':

if (ppartid() == -1)

return;

break;

case '5':

/* update disk partition table, if changed */

if (TableChanged() == 1) {

copy_Table_to_Bootblk();

dev_mboot_write(0, Bootsect, sectsiz);

}

/*

if (io_adjt) {

fix_slice();

}

(void) close(Dev);

exit(0);

/* FALLTHRU */

case '6':

/*

if (io_adjt) {

fix_slice();

}

(void) close(Dev);

exit(0);

/* FALLTHRU */

default:

break;

}

copy_Table_to_Bootblk();

disptbl();

dispmenu();

}

}

static int

pcreate(void)

{

uchar_t tsystid = 'z';

int i, j;

uint32_t numsect;

int retCode = 0;

i = 0;

for (;;) {

if (i == FD_NUMPART) {

(void) printf(E_LINE);

(void) printf(

"The partition table is full!\n"

"You must delete a partition before creating"

" a new one.\n");

return (-1);

}

if (Table[i].systid == UNUSED) {

break;

}

i++;

}

numsect = 0;

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

if (Table[i].systid != UNUSED) {

numsect += lel(Table[i].numsect);

}

if (numsect >= chs_capacity) {

(void) printf(E_LINE);

(void) printf("There is no more room on the disk for"

" another partition.\n");

(void) printf(

"You must delete a partition before creating"

" a new one.\n");

return (-1);

}

}

while (tsystid == 'z') {

/*

(void) printf(W_LINE);

(void) printf(Q_LINE);

(void) printf(

"Select the partition type to create:\n"

" 1=SOLARIS2 2=UNIX 3=PCIXOS 4=Other\n"

" 5=DOS12 6=DOS16 7=DOSEXT 8=DOSBIG\n"

" 9=DOS16LBA A=x86 Boot B=Diagnostic C=FAT32\n"

" D=FAT32LBA E=DOSEXTLBA F=EFI 0=Exit? ");

(void) gets(s);

rm_blanks(s);

if (s[1] != 0) {

(void) printf(E_LINE);

(void) printf("Invalid selection, try again.");

continue;

}

switch (s[0]) {

case '0': /* exit */

(void) printf(E_LINE);

return (-1);

case '1': /* Solaris partition */

tsystid = SUNIXOS2;

break;

case '2': /* UNIX partition */

tsystid = UNIXOS;

break;

case '3': /* PCIXOS partition */

tsystid = PCIXOS;

break;

case '4': /* OTHEROS System partition */

tsystid = OTHEROS;

break;

case '5':

tsystid = DOSOS12; /* DOS 12 bit fat */

break;

case '6':

tsystid = DOSOS16; /* DOS 16 bit fat */

break;

case '7':

tsystid = EXTDOS;

break;

case '8':

tsystid = DOSHUGE;

break;

case '9':

tsystid = FDISK_FAT95; /* FAT16, need extended int13 */

break;

case 'a': /* x86 Boot partition */

case 'A':

tsystid = X86BOOT;

break;

case 'b': /* Diagnostic boot partition */

case 'B':

tsystid = DIAGPART;

break;

case 'c': /* FAT32 */

case 'C':

tsystid = FDISK_WINDOWS;

break;

case 'd': /* FAT32 and need extended int13 */

case 'D':

tsystid = FDISK_EXT_WIN;

break;

case 'e': /* Extended partition, need extended int13 */

case 'E':

tsystid = FDISK_EXTLBA;

break;

case 'f':

case 'F':

tsystid = EFI_PMBR;

break;

default:

(void) printf(E_LINE);

(void) printf("Invalid selection, try again.");

continue;

}

}

(void) printf(E_LINE);

if (tsystid != EFI_PMBR) {

(void) printf(W_LINE);

if ((dev_capacity > DK_MAX_2TB))

(void) printf("WARNING: Disk is larger than 2 TB. "

"Upper limit is 2 TB for non-EFI partition ID\n");

/* create the new partition */

i = specify(tsystid);

if (i != -1) {

/* see if it should be the active partition */

(void) printf(E_LINE);

(void) printf(Q_LINE);

(void) printf(

"Should this become the active partition? If "

"yes, it will be activated\n"

"each time the computer is reset or turned on.\n"

"Please type \"y\" or \"n\". ");

if (yesno()) {

(void) printf(E_LINE);

for (j = 0; j < FD_NUMPART; j++) {

if (j == i) {

Table[j].bootid = ACTIVE;

(void) printf(E_LINE);

(void) printf(

"Partition %d is now "

"the active partition.",

j + 1);

} else {

Table[j].bootid = 0;

}

}

} else {

Table[i].bootid = 0;

}

/* set up the return code */

i = 1;

}

} else {

/*

retCode = verify_tbl();

if (retCode < 0) {

(void) fprintf(stderr,

"fdisk: Cannot create EFI partition table; \n"

"current partition table is invalid.\n");

return (-1);

} else if (retCode > 0) {

(void) printf(

"An EFI partition must be the only partition on "

"disk. You may manually delete existing\n"

"partitions, or fdisk can do it.\n"

"Do you want fdisk to destroy existing "

"partitions?\n"

"Please type \"y\" or \"n\". ");

if (yesno()) {

nulltbl();

} else {

return (-1);

}

}

/* create the table entry - i should be 0 */

i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 1,

(dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB:

(dev_capacity - 1));

if (i != 0) {

(void) printf("Error creating EFI partition!!!\n");

i = -1;

} else {

/* EFI partitions are currently never active */

Table[i].bootid = 0;

/* set up the return code */

i = 1;

}

}

return (i);

}

static int

specify(uchar_t tsystid)

{

int i, j, percent = -1;

int cyl, cylen;

diskaddr_t first_free, size_free;

diskaddr_t max_free;

int cyl_size;

struct ipart *partition[FD_NUMPART];

cyl_size = heads * sectors;

/*

for (i = 0; i < FD_NUMPART; i++)

partition[i] = &Table[i];

for (i = 0; i < FD_NUMPART - 1; i++) {

if (partition[i]->systid == UNUSED)

break;

for (j = i + 1; j < FD_NUMPART; j++) {

if (partition[j]->systid == UNUSED)

break;

if (lel(partition[j]->relsect) <

lel(partition[i]->relsect)) {

struct ipart *temp = partition[i];

partition[i] = partition[j];

partition[j] = temp;

}

}

}

(void) printf(Q_LINE);

(void) printf(

"Specify the percentage of disk to use for this partition\n"

"(or type \"c\" to specify the size in cylinders). ");

(void) gets(s);

rm_blanks(s);

if (s[0] != 'c') { /* Specify size in percentage of disk */

i = 0;

while (s[i] != '\0') {

if (s[i] < '0' || s[i] > '9') {

(void) printf(E_LINE);

(void) printf("Invalid percentage value "

"specified; retry the operation.");

return (-1);

}

i++;

if (i > 3) {

(void) printf(E_LINE);

(void) printf("Invalid percentage value "

"specified; retry the operation.");

return (-1);

}

}

if ((percent = atoi(s)) > 100) {

(void) printf(E_LINE);

(void) printf(

"Percentage value is too large. The value must be"

" between 1 and 100;\nretry the operation.\n");

return (-1);

}

if (percent < 1) {

(void) printf(E_LINE);

(void) printf(

"Percentage value is too small. The value must be"

" between 1 and 100;\nretry the operation.\n");

return (-1);

}

if (percent == 100)

cylen = Numcyl_usable - 1;

else

cylen = (Numcyl_usable * percent) / 100;

/* Verify DOS12 partition doesn't exceed max size of 32MB. */

if ((tsystid == DOSOS12) &&

((long)((long)cylen * cyl_size) > MAXDOS)) {

int n;

n = MAXDOS * 100 / (int)(cyl_size) / Numcyl_usable;

(void) printf(E_LINE);

(void) printf("Maximum size for a DOS partition "

"is %d%%; retry the operation.",

n <= 100 ? n : 100);

return (-1);

}

max_free = 0;

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

/*

if (i) {

/* Not an empty table */

first_free = lel(partition[i - 1]->relsect) +

lel(partition[i - 1]->numsect);

} else {

first_free = cyl_size;

}

/*

if (partition[i]->systid == UNUSED) {

size_free = chs_capacity - first_free;

} else {

/*

size_free =

(lel(partition[i]->relsect > first_free)) ?

(lel(partition[i]->relsect) - first_free) :

0;

}

/* save largest free space */

if (max_free < size_free)

max_free = size_free;

if (((uint64_t)cylen * cyl_size) <= size_free) {

/* We found a place to use */

break;

}

if (partition[i]->systid == UNUSED) {

(void) printf(E_LINE);

max_free /= (cyl_size);

(void) fprintf(stderr, "fdisk: "

"Maximum percentage available is %lld\n",

100 * max_free / Numcyl_usable);

return (-1);

}

}

(void) printf(E_LINE);

if (i >= FD_NUMPART) {

(void) fprintf(stderr,

"fdisk: Partition table is full.\n");

return (-1);

}

if ((i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0,

first_free, cylen * cyl_size)) >= 0) {

return (i);

}

return (-1);

} else {

/* Specifying size in cylinders */

(void) printf(E_LINE);

(void) printf(Q_LINE);

(void) printf("Enter starting cylinder number: ");

if ((cyl = getcyl()) == -1) {

(void) printf(E_LINE);

(void) printf("Invalid number; retry the operation.");

return (-1);

}

if (cyl == 0) {

(void) printf(E_LINE);

(void) printf(

"New partition cannot start at cylinder 0.\n");

return (-1);

}

if (cyl >= Numcyl_usable) {

(void) printf(E_LINE);

(void) printf(

"Cylinder %d is out of bounds, "

"the maximum is %d.\n",

cyl, Numcyl_usable - 1);

return (-1);

}

(void) printf(Q_LINE);

(void) printf("Enter partition size in cylinders: ");

if ((cylen = getcyl()) == -1) {

(void) printf(E_LINE);

(void) printf("Invalid number, retry the operation.");

return (-1);

}

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

uint32_t t_relsect, t_numsect;

if (partition[i]->systid == UNUSED)

break;

t_relsect = lel(partition[i]->relsect);

t_numsect = lel(partition[i]->numsect);

if (cyl * cyl_size >= t_relsect &&

cyl * cyl_size < t_relsect + t_numsect) {

(void) printf(E_LINE);

(void) printf(

"Cylinder %d is already allocated"

"\nretry the operation.",

cyl);

return (-1);

}

if (cyl * cyl_size < t_relsect &&

(cyl + cylen - 1) * cyl_size > t_relsect) {

(void) printf(E_LINE);

(void) printf(

"Maximum size for partition is %u cylinders"

"\nretry the operation.",

(t_relsect - cyl * cyl_size) / cyl_size);

return (-1);

}

}

/* Verify partition doesn't exceed disk size or 2 TB */

if (cyl + cylen > Numcyl_usable) {

(void) printf(E_LINE);

if (Numcyl > Numcyl_usable) {

(void) printf(

"Maximum size for partition is %d "

"cylinders; \nretry the operation.",

Numcyl_usable - cyl);

} else {

(void) printf(

"Maximum size for partition is %d "

"cylinders; \nretry the operation.",

Numcyl_usable - cyl);

}

return (-1);

}

/* Verify DOS12 partition doesn't exceed max size of 32MB. */

if ((tsystid == DOSOS12) &&

((long)((long)cylen * cyl_size) > MAXDOS)) {

(void) printf(E_LINE);

(void) printf(

"Maximum size for a %s partition is %ld cylinders;"

"\nretry the operation.",

Dstr, MAXDOS / (int)(cyl_size));

return (-1);

}

(void) printf(E_LINE);

i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0,

cyl * cyl_size, cylen * cyl_size);

if (i < 0)

return (-1);

if (verify_tbl() < 0) {

(void) printf(E_LINE);

(void) printf("fdisk: Cannot create partition table\n");

return (-1);

}

return (i);

}

}

static void

dispmenu(void)

{

(void) printf(M_LINE);

(void) printf(

"SELECT ONE OF THE FOLLOWING:\n"

" 1. Create a partition\n"

" 2. Specify the active partition\n"

" 3. Delete a partition\n"

" 4. Change between Solaris and Solaris2 Partition IDs\n"

" 5. Exit (update disk configuration and exit)\n"

" 6. Cancel (exit without updating disk configuration)\n");

}

static int

pchange(void)

{

char s[80];

int i, j;

for (;;) {

(void) printf(Q_LINE);

{

(void) printf(

"Specify the partition number to boot from"

" (or specify 0 for none): ");

}

(void) gets(s);

rm_blanks(s);

if ((s[1] != 0) || (s[0] < '0') || (s[0] > '4')) {

(void) printf(E_LINE);

(void) printf(

"Invalid response, please specify a number"

" between 0 and 4.\n");

} else {

break;

}

}

if (s[0] == '0') { /* No active partitions */

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

if (Table[i].systid != UNUSED &&

Table[i].bootid == ACTIVE)

Table[i].bootid = 0;

}

(void) printf(E_LINE);

(void) printf(

"No partition is currently marked as active.");

return (0);

} else { /* User has selected a partition to be active */

i = s[0] - '1';

if (Table[i].systid == UNUSED) {

(void) printf(E_LINE);

(void) printf("Partition does not exist.");

return (-1);

}

/* a DOS-DATA or EXT-DOS partition cannot be active */

else if ((Table[i].systid == DOSDATA) ||

(Table[i].systid == EXTDOS) ||

(Table[i].systid == FDISK_EXTLBA)) {

(void) printf(E_LINE);

(void) printf(

"DOS-DATA, EXT_DOS and EXT_DOS_LBA partitions "

"cannot be made active.\n");

(void) printf("Select another partition.");

return (-1);

}

Table[i].bootid = ACTIVE;

for (j = 0; j < FD_NUMPART; j++) {

if (j != i)

Table[j].bootid = 0;

}

}

(void) printf(E_LINE);

{

(void) printf(

"Partition %d is now active. The system will start up"

" from this\n", i + 1);

(void) printf("partition after the next reboot.");

}

return (1);

}

static int

ppartid(void)

{

char *p, s[80];

int i;

for (;;) {

(void) printf(Q_LINE);

(void) printf("Specify the partition number to change"

" (or enter 0 to exit): ");

if (!fgets(s, sizeof (s), stdin))

return (1);

i = strtol(s, &p, 10);

if (*p != '\n' || i < 0 || i > FD_NUMPART) {

(void) printf(E_LINE);

(void) printf(

"Invalid response, retry the operation.\n");

continue;

}

if (i == 0) {

/* exit delete command */

(void) printf(E_LINE); /* clear error message */

return (1);

}

i -= 1;

if (Table[i].systid == SUNIXOS) {

Table[i].systid = SUNIXOS2;

} else if (Table[i].systid == SUNIXOS2) {

Table[i].systid = SUNIXOS;

} else {

(void) printf(E_LINE);

(void) printf(

"Partition %d is not a Solaris partition.",

i + 1);

continue;

}

(void) printf(E_LINE);

(void) printf("Partition %d has been changed.", i + 1);

return (1);

}

}

static char

pdelete(void)

{

char s[80];

int i, j;

char pactive;

DEL1: (void) printf(Q_LINE);

(void) printf("Specify the partition number to delete"

" (or enter 0 to exit): ");

(void) gets(s);

rm_blanks(s);

if ((s[0] == '0')) { /* exit delete command */

(void) printf(E_LINE); /* clear error message */

return (1);

}

/* Accept only a single digit between 1 and 4 */

if (s[1] != 0 || (i = atoi(s)) < 1 || i > FD_NUMPART) {

(void) printf(E_LINE);

(void) printf("Invalid response, retry the operation.\n");

goto DEL1;

} else { /* Found a digit between 1 and 4 */

--i; /* Structure begins with element 0 */

}

if (Table[i].systid == UNUSED) {

(void) printf(E_LINE);

(void) printf("Partition %d does not exist.", i + 1);

return (-1);

}

(void) printf(Q_LINE);

(void) printf("Are you sure you want to delete partition %d?"

" This will make all files and \n", i + 1);

(void) printf("programs in this partition inaccessible (type"

" \"y\" or \"n\"). ");

(void) printf(E_LINE);

if (! yesno()) {

return (1);

}

if (Table[i].bootid == ACTIVE) {

pactive = 1;

} else {

pactive = 0;

}

for (j = i; j < FD_NUMPART - 1; j++) {

Table[j] = Table[j + 1];

}

Table[j].systid = UNUSED;

Table[j].numsect = 0;

Table[j].relsect = 0;

Table[j].bootid = 0;

(void) printf(E_LINE);

(void) printf("Partition %d has been deleted.", i + 1);

if (pactive) {

(void) printf(" This was the active partition.");

}

return (1);

}

static void

rm_blanks(char *s)

{

register int i, j;

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

if ((s[i] == ' ') || (s[i] == '\t'))

continue;

else

/* Found first non-blank character of the string */

break;

}

for (j = 0; i < CBUFLEN; j++, i++) {

if ((s[j] = s[i]) == '\0') {

/* Reached end of string */

return;

}

}

}

static int

getcyl(void)

{

int slen, i, j;

unsigned int cyl;

(void) gets(s);

rm_blanks(s);

slen = strlen(s);

j = 1;

cyl = 0;

for (i = slen - 1; i >= 0; i--) {

if (s[i] < '0' || s[i] > '9') {

return (-1);

}

cyl += (j * (s[i] - '0'));

j *= 10;

}

return (cyl);

}

static void

disptbl(void)

{

int i;

unsigned int startcyl, endcyl, length, percent, remainder;

char *stat, *type;

int is_pmbr = 0;

if ((heads == 0) || (sectors == 0)) {

(void) printf("WARNING: critical disk geometry information"

" missing!\n");

(void) printf("\theads = %d, sectors = %d\n", heads, sectors);

exit(1);

}

(void) printf(HOME);

(void) printf(T_LINE);

(void) printf(" Total disk size is %d cylinders\n", Numcyl);

(void) printf(" Cylinder size is %d (512 byte) blocks\n\n",

heads * sectors);

(void) printf(

" Cylinders\n");

(void) printf(

" Partition Status Type Start End Length"

" %%\n");

(void) printf(

" ========= ====== ============ ===== === ======"

" ===");

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

if (Table[i].systid == UNUSED) {

(void) printf("\n");

(void) printf(CLR_LIN);

continue;

}

if (Table[i].bootid == ACTIVE)

stat = Actvstr;

else

stat = NAstr;

switch (Table[i].systid) {

case UNIXOS:

type = Ustr;

break;

case SUNIXOS:

type = SUstr;

break;

case SUNIXOS2:

type = SU2str;

break;

case X86BOOT:

type = X86str;

break;

case DOSOS12:

type = Dstr;

break;

case DOSOS16:

type = D16str;

break;

case EXTDOS:

type = EDstr;

break;

case DOSDATA:

type = DDstr;

break;

case DOSHUGE:

type = DBstr;

break;

case PCIXOS:

type = PCstr;

break;

case DIAGPART:

type = DIAGstr;

break;

case FDISK_IFS:

type = IFSstr;

break;

case FDISK_AIXBOOT:

type = AIXstr;

break;

case FDISK_AIXDATA:

type = AIXDstr;

break;

case FDISK_OS2BOOT:

type = OS2str;

break;

case FDISK_WINDOWS:

type = WINstr;

break;

case FDISK_EXT_WIN:

type = EWINstr;

break;

case FDISK_FAT95:

type = FAT95str;

break;

case FDISK_EXTLBA:

type = EXTLstr;

break;

case FDISK_LINUX:

type = LINUXstr;

break;

case FDISK_CPM:

type = CPMstr;

break;

case FDISK_NOVELL3:

type = NOVstr;

break;

case FDISK_QNX4:

type = QNXstr;

break;

case FDISK_QNX42:

type = QNX2str;

break;

case FDISK_QNX43:

type = QNX3str;

break;

case FDISK_LINUXNAT:

type = LINNATstr;

break;

case FDISK_NTFSVOL1:

type = NTFSVOL1str;

break;

case FDISK_NTFSVOL2:

type = NTFSVOL2str;

break;

case FDISK_BSD:

type = BSDstr;

break;

case FDISK_NEXTSTEP:

type = NEXTSTEPstr;

break;

case FDISK_BSDIFS:

type = BSDIFSstr;

break;

case FDISK_BSDISWAP:

type = BSDISWAPstr;

break;

case EFI_PMBR:

type = EFIstr;

if (lel(Table[i].numsect) == DK_MAX_2TB)