17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 51237e847Slclee * Common Development and Distribution License (the "License"). 61237e847Slclee * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 211237e847Slclee 227c478bd9Sstevel@tonic-gate /* 232b26c6eeSbharding * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ 287c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ 297c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate /* Copyright (c) 1987, 1988 Microsoft Corporation */ 327c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 337c478bd9Sstevel@tonic-gate 347c478bd9Sstevel@tonic-gate /* 357c478bd9Sstevel@tonic-gate * PROGRAM: fdisk(1M) 367c478bd9Sstevel@tonic-gate * This program reads the partition table on the specified device and 377c478bd9Sstevel@tonic-gate * also reads the drive parameters. The user can perform various 387c478bd9Sstevel@tonic-gate * operations from a supplied menu or from the command line. Diagnostic 397c478bd9Sstevel@tonic-gate * options are also available. 407c478bd9Sstevel@tonic-gate */ 417c478bd9Sstevel@tonic-gate 427c478bd9Sstevel@tonic-gate #include <stdio.h> 437c478bd9Sstevel@tonic-gate #include <stdlib.h> 447c478bd9Sstevel@tonic-gate #include <string.h> 457c478bd9Sstevel@tonic-gate #include <unistd.h> 467c478bd9Sstevel@tonic-gate #include <errno.h> 477c478bd9Sstevel@tonic-gate #include <fcntl.h> 487c478bd9Sstevel@tonic-gate #include <ctype.h> 497c478bd9Sstevel@tonic-gate #include <sys/stat.h> 507c478bd9Sstevel@tonic-gate #include <sys/types.h> 51*342440ecSPrasad Singamsetty #include <limits.h> 527c478bd9Sstevel@tonic-gate #include <sys/param.h> 537c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 547c478bd9Sstevel@tonic-gate #include <sys/efi_partition.h> 557c478bd9Sstevel@tonic-gate #include <sys/byteorder.h> 567c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate #include <sys/dktp/fdisk.h> 597c478bd9Sstevel@tonic-gate #include <sys/dkio.h> 607c478bd9Sstevel@tonic-gate #include <sys/vtoc.h> 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate #define CLR_SCR "[1;1H[0J" 637c478bd9Sstevel@tonic-gate #define CLR_LIN "[0K" 647c478bd9Sstevel@tonic-gate #define HOME "[1;1H[0K[2;1H[0K[3;1H[0K[4;1H[0K[5;1H[0K" \ 657c478bd9Sstevel@tonic-gate "[6;1H[0K[7;1H[0K[8;1H[0K[9;1H[0K[10;1H[0K[1;1H" 667c478bd9Sstevel@tonic-gate #define Q_LINE "[22;1H[0K[21;1H[0K[20;1H[0K" 677c478bd9Sstevel@tonic-gate #define W_LINE "[12;1H[0K[11;1H[0K" 687c478bd9Sstevel@tonic-gate #define E_LINE "[24;1H[0K[23;1H[0K" 697c478bd9Sstevel@tonic-gate #define M_LINE "[13;1H[0K[14;1H[0K[15;1H[0K[16;1H[0K[17;1H" \ 707c478bd9Sstevel@tonic-gate "[0K[18;1H[0K[19;1H[0K[13;1H" 717c478bd9Sstevel@tonic-gate #define T_LINE "[1;1H[0K" 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate #define DEFAULT_PATH "/dev/rdsk/" 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate /* XXX - should be in fdisk.h, used by sd as well */ 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate /* 787c478bd9Sstevel@tonic-gate * the MAX values are the maximum usable values for BIOS chs values 797c478bd9Sstevel@tonic-gate * The MAX_CYL value of 1022 is the maximum usable value 807c478bd9Sstevel@tonic-gate * the value of 1023 is a fence value, 817c478bd9Sstevel@tonic-gate * indicating no CHS geometry exists for the corresponding LBA value. 827c478bd9Sstevel@tonic-gate * HEAD range [ 0 .. MAX_HEAD ], so number of heads is (MAX_HEAD + 1) 837c478bd9Sstevel@tonic-gate * SECT range [ 1 .. MAX_SECT ], so number of sectors is (MAX_SECT) 847c478bd9Sstevel@tonic-gate */ 857c478bd9Sstevel@tonic-gate #define MAX_SECT (63) 867c478bd9Sstevel@tonic-gate #define MAX_CYL (1022) 877c478bd9Sstevel@tonic-gate #define MAX_HEAD (254) 887c478bd9Sstevel@tonic-gate 89*342440ecSPrasad Singamsetty #define DK_MAX_2TB UINT32_MAX /* Max # of sectors in 2TB */ 90*342440ecSPrasad Singamsetty 917c478bd9Sstevel@tonic-gate /* for clear_vtoc() */ 927c478bd9Sstevel@tonic-gate #define OLD 0 937c478bd9Sstevel@tonic-gate #define NEW 1 947c478bd9Sstevel@tonic-gate 957c478bd9Sstevel@tonic-gate /* readvtoc/writevtoc return codes */ 967c478bd9Sstevel@tonic-gate #define VTOC_OK 0 /* Good VTOC */ 977c478bd9Sstevel@tonic-gate #define VTOC_INVAL 1 /* invalid VTOC */ 987c478bd9Sstevel@tonic-gate #define VTOC_NOTSUP 2 /* operation not supported - EFI label */ 997c478bd9Sstevel@tonic-gate #define VTOC_RWERR 3 /* couldn't read or write VTOC */ 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate /* 1027c478bd9Sstevel@tonic-gate * Support for fdisk(1M) on the SPARC platform 1037c478bd9Sstevel@tonic-gate * In order to convert little endian values to big endian for SPARC, 1047c478bd9Sstevel@tonic-gate * byte/short and long values must be swapped. 1057c478bd9Sstevel@tonic-gate * These swapping macros will be used to access information in the 1067c478bd9Sstevel@tonic-gate * mboot and ipart structures. 1077c478bd9Sstevel@tonic-gate */ 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate #ifdef sparc 1107c478bd9Sstevel@tonic-gate #define les(val) ((((val)&0xFF)<<8)|(((val)>>8)&0xFF)) 1117c478bd9Sstevel@tonic-gate #define lel(val) (((unsigned)(les((val)&0x0000FFFF))<<16) | \ 1127c478bd9Sstevel@tonic-gate (les((unsigned)((val)&0xffff0000)>>16))) 1137c478bd9Sstevel@tonic-gate #else 1147c478bd9Sstevel@tonic-gate #define les(val) (val) 1157c478bd9Sstevel@tonic-gate #define lel(val) (val) 1167c478bd9Sstevel@tonic-gate #endif 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate #if defined(_SUNOS_VTOC_16) 1199d5d1945Sbharding #define VTOC_OFFSET 1 1207c478bd9Sstevel@tonic-gate #elif defined(_SUNOS_VTOC_8) 1217c478bd9Sstevel@tonic-gate #define VTOC_OFFSET 0 1227c478bd9Sstevel@tonic-gate #else 1237c478bd9Sstevel@tonic-gate #error No VTOC format defined. 1247c478bd9Sstevel@tonic-gate #endif 1257c478bd9Sstevel@tonic-gate 126bb16350dSlclee static char Usage[] = "Usage: fdisk\n" 1277c478bd9Sstevel@tonic-gate "[ -A id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect ]\n" 1287c478bd9Sstevel@tonic-gate "[ -b masterboot ]\n" 1297c478bd9Sstevel@tonic-gate "[ -D id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect ]\n" 1307c478bd9Sstevel@tonic-gate "[ -F fdisk_file ] [ -h ] [ -o offset ] [ -P fill_patt ] [ -s size ]\n" 1317c478bd9Sstevel@tonic-gate "[ -S geom_file ] [ [ -v ] -W { creat_fdisk_file | - } ]\n" 1327c478bd9Sstevel@tonic-gate "[ -w | r | d | n | I | B | E | g | G | R | t | T ] rdevice"; 1337c478bd9Sstevel@tonic-gate 134bb16350dSlclee static char Usage1[] = " Partition options:\n" 1357c478bd9Sstevel@tonic-gate " -A id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect\n" 1367c478bd9Sstevel@tonic-gate " Create a partition with specific attributes:\n" 1377c478bd9Sstevel@tonic-gate " id = system id number (fdisk.h) for the partition type\n" 1387c478bd9Sstevel@tonic-gate " act = active partition flag (0 is off and 128 is on)\n" 1397c478bd9Sstevel@tonic-gate " bhead = beginning head for start of partition\n" 1407c478bd9Sstevel@tonic-gate " bsect = beginning sector for start of partition\n" 1417c478bd9Sstevel@tonic-gate " bcyl = beginning cylinder for start of partition\n" 1427c478bd9Sstevel@tonic-gate " ehead = ending head for end of partition\n" 1437c478bd9Sstevel@tonic-gate " esect = ending sector for end of partition\n" 1447c478bd9Sstevel@tonic-gate " ecyl = ending cylinder for end of partition\n" 1457c478bd9Sstevel@tonic-gate " rsect = sector number from start of disk for\n" 1467c478bd9Sstevel@tonic-gate " start of partition\n" 1477c478bd9Sstevel@tonic-gate " numsect = partition size in sectors\n" 1487c478bd9Sstevel@tonic-gate " -b master_boot\n" 1497c478bd9Sstevel@tonic-gate " Use master_boot as the master boot file.\n" 1507c478bd9Sstevel@tonic-gate " -B Create one Solaris partition that uses the entire disk.\n" 1517c478bd9Sstevel@tonic-gate " -E Create one EFI partition that uses the entire disk.\n" 1527c478bd9Sstevel@tonic-gate " -D id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect\n" 1537c478bd9Sstevel@tonic-gate " Delete a partition. See attribute definitions for -A.\n" 1547c478bd9Sstevel@tonic-gate " -F fdisk_file\n" 1557c478bd9Sstevel@tonic-gate " Use fdisk_file to initialize on-line fdisk table.\n" 1567c478bd9Sstevel@tonic-gate " -I Forego device checks. Generate a file image of what would go\n" 1577c478bd9Sstevel@tonic-gate " on a disk using the geometry specified with the -S option.\n" 1587c478bd9Sstevel@tonic-gate " -n Do not run in interactive mode.\n" 1597c478bd9Sstevel@tonic-gate " -R Open the disk device as read-only.\n" 1607c478bd9Sstevel@tonic-gate " -t Check and adjust VTOC to be consistent with fdisk table.\n" 1617c478bd9Sstevel@tonic-gate " VTOC slices exceeding the partition size will be truncated.\n" 1627c478bd9Sstevel@tonic-gate " -T Check and adjust VTOC to be consistent with fdisk table.\n" 1637c478bd9Sstevel@tonic-gate " VTOC slices exceeding the partition size will be removed.\n" 1647c478bd9Sstevel@tonic-gate " -W fdisk_file\n" 1657c478bd9Sstevel@tonic-gate " Write on-disk table to fdisk_file.\n" 1667c478bd9Sstevel@tonic-gate " -W - Write on-disk table to standard output.\n" 1677c478bd9Sstevel@tonic-gate " -v Display virtual geometry. Must be used with the -W option.\n" 1687c478bd9Sstevel@tonic-gate " Diagnostic options:\n" 1697c478bd9Sstevel@tonic-gate " -d Activate debug information about progress.\n" 1707c478bd9Sstevel@tonic-gate " -g Write label geometry to standard output:\n" 1717c478bd9Sstevel@tonic-gate " PCYL number of physical cylinders\n" 1727c478bd9Sstevel@tonic-gate " NCYL number of usable cylinders\n" 1737c478bd9Sstevel@tonic-gate " ACYL number of alternate cylinders\n" 1747c478bd9Sstevel@tonic-gate " BCYL cylinder offset\n" 1757c478bd9Sstevel@tonic-gate " NHEADS number of heads\n" 1767c478bd9Sstevel@tonic-gate " NSECTORS number of sectors per track\n" 1777c478bd9Sstevel@tonic-gate " SECTSIZ size of a sector in bytes\n" 1787c478bd9Sstevel@tonic-gate " -G Write physical geometry to standard output (see -g).\n" 1797c478bd9Sstevel@tonic-gate " -h Issue this verbose help message.\n" 1807c478bd9Sstevel@tonic-gate " -o offset\n" 1817c478bd9Sstevel@tonic-gate " Block offset from start of disk (default 0). Ignored if\n" 1827c478bd9Sstevel@tonic-gate " -P # specified.\n" 1837c478bd9Sstevel@tonic-gate " -P fill_patt\n" 1847c478bd9Sstevel@tonic-gate " Fill disk with pattern fill_patt. fill_patt can be decimal or\n" 1857c478bd9Sstevel@tonic-gate " hexadecimal and is used as number for constant long word\n" 1867c478bd9Sstevel@tonic-gate " pattern. If fill_patt is \"#\" then pattern of block #\n" 1877c478bd9Sstevel@tonic-gate " for each block. Pattern is put in each block as long words\n" 1887c478bd9Sstevel@tonic-gate " and fills each block (see -o and -s).\n" 1897c478bd9Sstevel@tonic-gate " -r Read from a disk to stdout (see -o and -s).\n" 1907c478bd9Sstevel@tonic-gate " -s size Number of blocks on which to perform operation (see -o).\n" 1917c478bd9Sstevel@tonic-gate " -S geom_file\n" 1927c478bd9Sstevel@tonic-gate " Use geom_file to set the label geometry (see -g).\n" 1937c478bd9Sstevel@tonic-gate " -w Write to a disk from stdin (see -o and -s)."; 1947c478bd9Sstevel@tonic-gate 195bb16350dSlclee static char Ostr[] = "Other OS"; 196bb16350dSlclee static char Dstr[] = "DOS12"; 197bb16350dSlclee static char D16str[] = "DOS16"; 198bb16350dSlclee static char DDstr[] = "DOS-DATA"; 199bb16350dSlclee static char EDstr[] = "EXT-DOS"; 200bb16350dSlclee static char DBstr[] = "DOS-BIG"; 201bb16350dSlclee static char PCstr[] = "PCIX"; 202bb16350dSlclee static char Ustr[] = "UNIX System"; 203bb16350dSlclee static char SUstr[] = "Solaris"; 204bb16350dSlclee static char SU2str[] = "Solaris2"; 205bb16350dSlclee static char X86str[] = "x86 Boot"; 206bb16350dSlclee static char DIAGstr[] = "Diagnostic"; 207bb16350dSlclee static char IFSstr[] = "IFS: NTFS"; 208bb16350dSlclee static char AIXstr[] = "AIX Boot"; 209bb16350dSlclee static char AIXDstr[] = "AIX Data"; 210bb16350dSlclee static char OS2str[] = "OS/2 Boot"; 211bb16350dSlclee static char WINstr[] = "Win95 FAT32"; 212bb16350dSlclee static char EWINstr[] = "Ext Win95"; 213bb16350dSlclee static char FAT95str[] = "FAT16 LBA"; 214bb16350dSlclee static char EXTLstr[] = "EXT LBA"; 215bb16350dSlclee static char LINUXstr[] = "Linux"; 216bb16350dSlclee static char CPMstr[] = "CP/M"; 217bb16350dSlclee static char NOVstr[] = "Netware 3.x+"; 218bb16350dSlclee static char QNXstr[] = "QNX 4.x"; 219bb16350dSlclee static char QNX2str[] = "QNX part 2"; 220bb16350dSlclee static char QNX3str[] = "QNX part 3"; 221bb16350dSlclee static char LINNATstr[] = "Linux native"; 222bb16350dSlclee static char NTFSVOL1str[] = "NT volset 1"; 223bb16350dSlclee static char NTFSVOL2str[] = "NT volset 2"; 224bb16350dSlclee static char BSDstr[] = "BSD OS"; 225bb16350dSlclee static char NEXTSTEPstr[] = "NeXTSTEP"; 226bb16350dSlclee static char BSDIFSstr[] = "BSDI FS"; 227bb16350dSlclee static char BSDISWAPstr[] = "BSDI swap"; 228bb16350dSlclee static char Actvstr[] = "Active"; 229bb16350dSlclee static char EFIstr[] = "EFI"; 230bb16350dSlclee static char NAstr[] = " "; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate /* All the user options and flags */ 233bb16350dSlclee static char *Dfltdev; /* name of fixed disk drive */ 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate /* Diagnostic options */ 236bb16350dSlclee static int io_wrt = 0; /* write stdin to disk (-w) */ 237bb16350dSlclee static int io_rd = 0; /* read disk and write stdout (-r) */ 238bb16350dSlclee static char *io_fatt; /* user supplied pattern (-P pattern) */ 239bb16350dSlclee static int io_patt = 0; /* write pattern to disk (-P pattern) */ 240bb16350dSlclee static int io_lgeom = 0; /* get label geometry (-g) */ 241bb16350dSlclee static int io_pgeom = 0; /* get drive physical geometry (-G) */ 242bb16350dSlclee static char *io_sgeom = 0; /* set label geometry (-S geom_file) */ 243bb16350dSlclee static int io_readonly = 0; /* do not write to disk (-R) */ 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate /* The -o offset and -s size options specify the area of the disk on */ 2467c478bd9Sstevel@tonic-gate /* which to perform the particular operation; i.e., -P, -r, or -w. */ 2479d5d1945Sbharding static off_t io_offset = 0; /* offset sector (-o offset) */ 2489d5d1945Sbharding static off_t io_size = 0; /* size in sectors (-s size) */ 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate /* Partition table flags */ 251bb16350dSlclee static int v_flag = 0; /* virtual geometry-HBA flag (-v) */ 252bb16350dSlclee static int stdo_flag = 0; /* stdout flag (-W -) */ 253bb16350dSlclee static int io_fdisk = 0; /* do fdisk operation */ 254bb16350dSlclee static int io_ifdisk = 0; /* interactive partition */ 255bb16350dSlclee static int io_nifdisk = 0; /* non-interactive partition (-n) */ 256bb16350dSlclee 257bb16350dSlclee static int io_adjt = 0; /* check/adjust VTOC (truncate (-t)) */ 258bb16350dSlclee static int io_ADJT = 0; /* check/adjust VTOC (delete (-T)) */ 259bb16350dSlclee static char *io_ffdisk = 0; /* input fdisk file name (-F file) */ 260bb16350dSlclee static char *io_Wfdisk = 0; /* output fdisk file name (-W file) */ 261bb16350dSlclee static char *io_Afdisk = 0; /* add entry to partition table (-A) */ 262bb16350dSlclee static char *io_Dfdisk = 0; /* delete entry from part. table (-D) */ 263bb16350dSlclee 264bb16350dSlclee static char *io_mboot = 0; /* master boot record (-b boot_file) */ 265bb16350dSlclee 266bb16350dSlclee static struct mboot BootCod; /* buffer for master boot record */ 267bb16350dSlclee 268bb16350dSlclee static int io_wholedisk = 0; /* use whole disk for Solaris (-B) */ 269bb16350dSlclee static int io_EFIdisk = 0; /* use whole disk for EFI (-E) */ 270bb16350dSlclee static int io_debug = 0; /* activate verbose mode (-d) */ 271bb16350dSlclee static int io_image = 0; /* create image using geometry (-I) */ 272bb16350dSlclee 273bb16350dSlclee static struct mboot *Bootblk; /* pointer to cut/paste sector zero */ 274bb16350dSlclee static char *Bootsect; /* pointer to sector zero buffer */ 275bb16350dSlclee static char *Nullsect; 276*342440ecSPrasad Singamsetty static struct extvtoc disk_vtoc; /* verify VTOC table */ 277bb16350dSlclee static int vt_inval = 0; 278bb16350dSlclee static int no_virtgeom_ioctl = 0; /* ioctl for virtual geometry failed */ 279bb16350dSlclee static int no_physgeom_ioctl = 0; /* ioctl for physical geometry failed */ 280bb16350dSlclee 281bb16350dSlclee static struct ipart Table[FD_NUMPART]; 282bb16350dSlclee static struct ipart Old_Table[FD_NUMPART]; 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate /* Disk geometry information */ 2851237e847Slclee static struct dk_minfo minfo; 286bb16350dSlclee static struct dk_geom disk_geom; 2877c478bd9Sstevel@tonic-gate 288*342440ecSPrasad Singamsetty static int Dev; /* fd for open device */ 289*342440ecSPrasad Singamsetty 2901237e847Slclee static diskaddr_t dev_capacity; /* number of blocks on device */ 291*342440ecSPrasad Singamsetty static diskaddr_t chs_capacity; /* Numcyl_usable * heads * sectors */ 292*342440ecSPrasad Singamsetty 293*342440ecSPrasad Singamsetty static int Numcyl_usable; /* Number of usable cylinders */ 294*342440ecSPrasad Singamsetty /* used to limit fdisk to 2TB */ 2951237e847Slclee 2967c478bd9Sstevel@tonic-gate /* Physical geometry for the drive */ 297bb16350dSlclee static int Numcyl; /* number of cylinders */ 298bb16350dSlclee static int heads; /* number of heads */ 299bb16350dSlclee static int sectors; /* number of sectors per track */ 300bb16350dSlclee static int acyl; /* number of alternate sectors */ 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate /* HBA (virtual) geometry for the drive */ 303bb16350dSlclee static int hba_Numcyl; /* number of cylinders */ 304bb16350dSlclee static int hba_heads; /* number of heads */ 305bb16350dSlclee static int hba_sectors; /* number of sectors per track */ 3067c478bd9Sstevel@tonic-gate 307bb16350dSlclee static int sectsiz; /* sector size */ 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate /* Load functions for fdisk table modification */ 3107c478bd9Sstevel@tonic-gate #define LOADFILE 0 /* load fdisk from file */ 3117c478bd9Sstevel@tonic-gate #define LOADDEL 1 /* delete an fdisk entry */ 3127c478bd9Sstevel@tonic-gate #define LOADADD 2 /* add an fdisk entry */ 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate #define CBUFLEN 80 315bb16350dSlclee static char s[CBUFLEN]; 316bb16350dSlclee 317bb16350dSlclee static void update_disk_and_exit(boolean_t table_changed); 318bb16350dSlclee int main(int argc, char *argv[]); 319bb16350dSlclee static int read_geom(char *sgeom); 320bb16350dSlclee static void dev_mboot_read(void); 3219d5d1945Sbharding static void dev_mboot_write(off_t sect, char *buff, int bootsiz); 322bb16350dSlclee static void mboot_read(void); 323bb16350dSlclee static void fill_patt(void); 324bb16350dSlclee static void abs_read(void); 325bb16350dSlclee static void abs_write(void); 326bb16350dSlclee static void load(int funct, char *file); 327bb16350dSlclee static void Set_Table_CHS_Values(int ti); 328bb16350dSlclee static int insert_tbl(int id, int act, 329bb16350dSlclee int bhead, int bsect, int bcyl, 330bb16350dSlclee int ehead, int esect, int ecyl, 331*342440ecSPrasad Singamsetty uint32_t rsect, uint32_t numsect); 332bb16350dSlclee static int verify_tbl(void); 333bb16350dSlclee static int pars_fdisk(char *line, 334bb16350dSlclee int *id, int *act, 335bb16350dSlclee int *bhead, int *bsect, int *bcyl, 336bb16350dSlclee int *ehead, int *esect, int *ecyl, 337*342440ecSPrasad Singamsetty uint32_t *rsect, uint32_t *numsect); 338*342440ecSPrasad Singamsetty static int validate_part(int id, uint32_t rsect, uint32_t numsect); 339bb16350dSlclee static void stage0(void); 340bb16350dSlclee static int pcreate(void); 341bb16350dSlclee static int specify(uchar_t tsystid); 342bb16350dSlclee static void dispmenu(void); 343bb16350dSlclee static int pchange(void); 344bb16350dSlclee static int ppartid(void); 345bb16350dSlclee static char pdelete(void); 346bb16350dSlclee static void rm_blanks(char *s); 347bb16350dSlclee static int getcyl(void); 348bb16350dSlclee static void disptbl(void); 349bb16350dSlclee static void print_Table(void); 350bb16350dSlclee static void copy_Table_to_Old_Table(void); 351bb16350dSlclee static void nulltbl(void); 352bb16350dSlclee static void copy_Bootblk_to_Table(void); 353bb16350dSlclee static void fill_ipart(char *bootptr, struct ipart *partp); 354bb16350dSlclee #ifdef sparc 355bb16350dSlclee uchar_t getbyte(char **bp); 356bb16350dSlclee uint32_t getlong(char **bp); 357bb16350dSlclee #endif 358bb16350dSlclee static void copy_Table_to_Bootblk(void); 359bb16350dSlclee static int TableChanged(void); 360bb16350dSlclee static void ffile_write(char *file); 361bb16350dSlclee static void fix_slice(void); 362bb16350dSlclee static int yesno(void); 363bb16350dSlclee static int readvtoc(void); 364bb16350dSlclee static int writevtoc(void); 365bb16350dSlclee static int efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc); 366bb16350dSlclee static int clear_efi(void); 367bb16350dSlclee static void clear_vtoc(int table, int part); 368bb16350dSlclee static int lecture_and_query(char *warning, char *devname); 369bb16350dSlclee static void sanity_check_provided_device(char *devname, int fd); 370bb16350dSlclee static char *get_node(char *devname); 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate static void 3737c478bd9Sstevel@tonic-gate update_disk_and_exit(boolean_t table_changed) 3747c478bd9Sstevel@tonic-gate { 3757c478bd9Sstevel@tonic-gate if (table_changed) { 3767c478bd9Sstevel@tonic-gate /* 3777c478bd9Sstevel@tonic-gate * Copy the new table back to the sector buffer 3787c478bd9Sstevel@tonic-gate * and write it to disk 3797c478bd9Sstevel@tonic-gate */ 3807c478bd9Sstevel@tonic-gate copy_Table_to_Bootblk(); 3817c478bd9Sstevel@tonic-gate dev_mboot_write(0, Bootsect, sectsiz); 3827c478bd9Sstevel@tonic-gate } 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate /* If the VTOC table is wrong fix it (truncation only) */ 3857c478bd9Sstevel@tonic-gate if (io_adjt) 3867c478bd9Sstevel@tonic-gate fix_slice(); 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate exit(0); 3897c478bd9Sstevel@tonic-gate } 3907c478bd9Sstevel@tonic-gate 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* 3947c478bd9Sstevel@tonic-gate * main 3957c478bd9Sstevel@tonic-gate * Process command-line options. 3967c478bd9Sstevel@tonic-gate */ 397bb16350dSlclee int 3987c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 3997c478bd9Sstevel@tonic-gate { 400bb16350dSlclee int c, i; 4017c478bd9Sstevel@tonic-gate extern int optind; 4027c478bd9Sstevel@tonic-gate extern char *optarg; 4037c478bd9Sstevel@tonic-gate int errflg = 0; 4047c478bd9Sstevel@tonic-gate int diag_cnt = 0; 4057c478bd9Sstevel@tonic-gate int openmode; 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate setbuf(stderr, 0); /* so all output gets out on exit */ 4087c478bd9Sstevel@tonic-gate setbuf(stdout, 0); 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* Process the options. */ 4117c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "o:s:P:F:b:A:D:W:S:tTIhwvrndgGRBE")) 4127c478bd9Sstevel@tonic-gate != EOF) { 4137c478bd9Sstevel@tonic-gate switch (c) { 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate case 'o': 4169d5d1945Sbharding io_offset = (off_t)strtoull(optarg, 0, 0); 4177c478bd9Sstevel@tonic-gate continue; 4187c478bd9Sstevel@tonic-gate case 's': 4199d5d1945Sbharding io_size = (off_t)strtoull(optarg, 0, 0); 4207c478bd9Sstevel@tonic-gate continue; 4217c478bd9Sstevel@tonic-gate case 'P': 4227c478bd9Sstevel@tonic-gate diag_cnt++; 4237c478bd9Sstevel@tonic-gate io_patt++; 4247c478bd9Sstevel@tonic-gate io_fatt = optarg; 4257c478bd9Sstevel@tonic-gate continue; 4267c478bd9Sstevel@tonic-gate case 'w': 4277c478bd9Sstevel@tonic-gate diag_cnt++; 4287c478bd9Sstevel@tonic-gate io_wrt++; 4297c478bd9Sstevel@tonic-gate continue; 4307c478bd9Sstevel@tonic-gate case 'r': 4317c478bd9Sstevel@tonic-gate diag_cnt++; 4327c478bd9Sstevel@tonic-gate io_rd++; 4337c478bd9Sstevel@tonic-gate continue; 4347c478bd9Sstevel@tonic-gate case 'd': 4357c478bd9Sstevel@tonic-gate io_debug++; 4367c478bd9Sstevel@tonic-gate continue; 4377c478bd9Sstevel@tonic-gate case 'I': 4387c478bd9Sstevel@tonic-gate io_image++; 4397c478bd9Sstevel@tonic-gate continue; 4407c478bd9Sstevel@tonic-gate case 'R': 4417c478bd9Sstevel@tonic-gate io_readonly++; 4427c478bd9Sstevel@tonic-gate continue; 4437c478bd9Sstevel@tonic-gate case 'S': 4447c478bd9Sstevel@tonic-gate diag_cnt++; 4457c478bd9Sstevel@tonic-gate io_sgeom = optarg; 4467c478bd9Sstevel@tonic-gate continue; 4477c478bd9Sstevel@tonic-gate case 'T': 4487c478bd9Sstevel@tonic-gate io_ADJT++; 449bb16350dSlclee /* FALLTHRU */ 4507c478bd9Sstevel@tonic-gate case 't': 4517c478bd9Sstevel@tonic-gate io_adjt++; 4527c478bd9Sstevel@tonic-gate continue; 4537c478bd9Sstevel@tonic-gate case 'B': 4547c478bd9Sstevel@tonic-gate io_wholedisk++; 4557c478bd9Sstevel@tonic-gate io_fdisk++; 4567c478bd9Sstevel@tonic-gate continue; 4577c478bd9Sstevel@tonic-gate case 'E': 4587c478bd9Sstevel@tonic-gate io_EFIdisk++; 4597c478bd9Sstevel@tonic-gate io_fdisk++; 4607c478bd9Sstevel@tonic-gate continue; 4617c478bd9Sstevel@tonic-gate case 'g': 4627c478bd9Sstevel@tonic-gate diag_cnt++; 4637c478bd9Sstevel@tonic-gate io_lgeom++; 4647c478bd9Sstevel@tonic-gate continue; 4657c478bd9Sstevel@tonic-gate case 'G': 4667c478bd9Sstevel@tonic-gate diag_cnt++; 4677c478bd9Sstevel@tonic-gate io_pgeom++; 4687c478bd9Sstevel@tonic-gate continue; 4697c478bd9Sstevel@tonic-gate case 'n': 4707c478bd9Sstevel@tonic-gate io_nifdisk++; 4717c478bd9Sstevel@tonic-gate io_fdisk++; 4727c478bd9Sstevel@tonic-gate continue; 4737c478bd9Sstevel@tonic-gate case 'F': 4747c478bd9Sstevel@tonic-gate io_fdisk++; 4757c478bd9Sstevel@tonic-gate io_ffdisk = optarg; 4767c478bd9Sstevel@tonic-gate continue; 4777c478bd9Sstevel@tonic-gate case 'b': 4787c478bd9Sstevel@tonic-gate io_mboot = optarg; 4797c478bd9Sstevel@tonic-gate continue; 4807c478bd9Sstevel@tonic-gate case 'W': 4817c478bd9Sstevel@tonic-gate /* 4827c478bd9Sstevel@tonic-gate * If '-' is the -W argument, then write 4837c478bd9Sstevel@tonic-gate * to standard output, otherwise write 4847c478bd9Sstevel@tonic-gate * to the specified file. 4857c478bd9Sstevel@tonic-gate */ 4867c478bd9Sstevel@tonic-gate if (strncmp(optarg, "-", 1) == 0) 4877c478bd9Sstevel@tonic-gate stdo_flag = 1; 4887c478bd9Sstevel@tonic-gate else 4897c478bd9Sstevel@tonic-gate io_Wfdisk = optarg; 4907c478bd9Sstevel@tonic-gate io_fdisk++; 4917c478bd9Sstevel@tonic-gate continue; 4927c478bd9Sstevel@tonic-gate case 'A': 4937c478bd9Sstevel@tonic-gate io_fdisk++; 4947c478bd9Sstevel@tonic-gate io_Afdisk = optarg; 4957c478bd9Sstevel@tonic-gate continue; 4967c478bd9Sstevel@tonic-gate case 'D': 4977c478bd9Sstevel@tonic-gate io_fdisk++; 4987c478bd9Sstevel@tonic-gate io_Dfdisk = optarg; 4997c478bd9Sstevel@tonic-gate continue; 5007c478bd9Sstevel@tonic-gate case 'h': 501bb16350dSlclee (void) fprintf(stderr, "%s\n", Usage); 502bb16350dSlclee (void) fprintf(stderr, "%s\n", Usage1); 5037c478bd9Sstevel@tonic-gate exit(0); 504bb16350dSlclee /* FALLTHRU */ 5057c478bd9Sstevel@tonic-gate case 'v': 5067c478bd9Sstevel@tonic-gate v_flag = 1; 5077c478bd9Sstevel@tonic-gate continue; 5087c478bd9Sstevel@tonic-gate case '?': 5097c478bd9Sstevel@tonic-gate errflg++; 5107c478bd9Sstevel@tonic-gate break; 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate break; 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate if (io_image && io_sgeom && diag_cnt == 1) { 5167c478bd9Sstevel@tonic-gate diag_cnt = 0; 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate /* User option checking */ 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* By default, run in interactive mode */ 5227c478bd9Sstevel@tonic-gate if (!io_fdisk && !diag_cnt && !io_nifdisk) { 5237c478bd9Sstevel@tonic-gate io_ifdisk++; 5247c478bd9Sstevel@tonic-gate io_fdisk++; 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate if (((io_fdisk || io_adjt) && diag_cnt) || (diag_cnt > 1)) { 5277c478bd9Sstevel@tonic-gate errflg++; 5287c478bd9Sstevel@tonic-gate } 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate /* Was any error detected? */ 5317c478bd9Sstevel@tonic-gate if (errflg || argc == optind) { 532bb16350dSlclee (void) fprintf(stderr, "%s\n", Usage); 533bb16350dSlclee (void) fprintf(stderr, 5347c478bd9Sstevel@tonic-gate "\nDetailed help is available with the -h option.\n"); 5357c478bd9Sstevel@tonic-gate exit(2); 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate /* Figure out the correct device node to open */ 5407c478bd9Sstevel@tonic-gate Dfltdev = get_node(argv[optind]); 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate if (io_readonly) 5437c478bd9Sstevel@tonic-gate openmode = O_RDONLY; 5447c478bd9Sstevel@tonic-gate else 5457c478bd9Sstevel@tonic-gate openmode = O_RDWR|O_CREAT; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate if ((Dev = open(Dfltdev, openmode, 0666)) == -1) { 548bb16350dSlclee (void) fprintf(stderr, 549bb16350dSlclee "fdisk: Cannot open device %s.\n", 550bb16350dSlclee Dfltdev); 5517c478bd9Sstevel@tonic-gate exit(1); 5527c478bd9Sstevel@tonic-gate } 5531237e847Slclee /* 5541237e847Slclee * not all disk (or disklike) drivers support DKIOCGMEDIAINFO 5551237e847Slclee * in that case leave the minfo structure zeroed 5561237e847Slclee */ 5571237e847Slclee if (ioctl(Dev, DKIOCGMEDIAINFO, &minfo)) { 5581237e847Slclee memset(&minfo, 0, sizeof (minfo)); 5591237e847Slclee } 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate /* Get the disk geometry */ 5627c478bd9Sstevel@tonic-gate if (!io_image) { 5637c478bd9Sstevel@tonic-gate /* Get disk's HBA (virtual) geometry */ 5647c478bd9Sstevel@tonic-gate errno = 0; 5657c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCG_VIRTGEOM, &disk_geom)) { 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate /* 5687c478bd9Sstevel@tonic-gate * If ioctl isn't implemented on this platform, then 5697c478bd9Sstevel@tonic-gate * turn off flag to print out virtual geometry (-v), 5707c478bd9Sstevel@tonic-gate * otherwise use the virtual geometry. 5717c478bd9Sstevel@tonic-gate */ 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate if (errno == ENOTTY) { 5747c478bd9Sstevel@tonic-gate v_flag = 0; 5757c478bd9Sstevel@tonic-gate no_virtgeom_ioctl = 1; 5767c478bd9Sstevel@tonic-gate } else if (errno == EINVAL) { 5777c478bd9Sstevel@tonic-gate /* 5787c478bd9Sstevel@tonic-gate * This means that the ioctl exists, but 5797c478bd9Sstevel@tonic-gate * is invalid for this disk, meaning the 5807c478bd9Sstevel@tonic-gate * disk doesn't have an HBA geometry 5817c478bd9Sstevel@tonic-gate * (like, say, it's larger than 8GB). 5827c478bd9Sstevel@tonic-gate */ 5837c478bd9Sstevel@tonic-gate v_flag = 0; 5847c478bd9Sstevel@tonic-gate hba_Numcyl = hba_heads = hba_sectors = 0; 5857c478bd9Sstevel@tonic-gate } else { 5867c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 5877c478bd9Sstevel@tonic-gate "%s: Cannot get virtual disk geometry.\n", 5887c478bd9Sstevel@tonic-gate argv[optind]); 5897c478bd9Sstevel@tonic-gate exit(1); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate } else { 5927c478bd9Sstevel@tonic-gate /* save virtual geometry values obtained by ioctl */ 5937c478bd9Sstevel@tonic-gate hba_Numcyl = disk_geom.dkg_ncyl; 5947c478bd9Sstevel@tonic-gate hba_heads = disk_geom.dkg_nhead; 5957c478bd9Sstevel@tonic-gate hba_sectors = disk_geom.dkg_nsect; 5967c478bd9Sstevel@tonic-gate } 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate errno = 0; 5997c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) { 6007c478bd9Sstevel@tonic-gate if (errno == ENOTTY) { 6017c478bd9Sstevel@tonic-gate no_physgeom_ioctl = 1; 6027c478bd9Sstevel@tonic-gate } else { 6037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6047c478bd9Sstevel@tonic-gate "%s: Cannot get physical disk geometry.\n", 6057c478bd9Sstevel@tonic-gate argv[optind]); 6067c478bd9Sstevel@tonic-gate exit(1); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate } 6107c478bd9Sstevel@tonic-gate /* 6117c478bd9Sstevel@tonic-gate * Call DKIOCGGEOM if the ioctls for physical and virtual 6127c478bd9Sstevel@tonic-gate * geometry fail. Get both from this generic call. 6137c478bd9Sstevel@tonic-gate */ 6147c478bd9Sstevel@tonic-gate if (no_virtgeom_ioctl && no_physgeom_ioctl) { 6157c478bd9Sstevel@tonic-gate errno = 0; 6167c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) { 6177c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6187c478bd9Sstevel@tonic-gate "%s: Cannot get disk label geometry.\n", 6197c478bd9Sstevel@tonic-gate argv[optind]); 6207c478bd9Sstevel@tonic-gate exit(1); 6217c478bd9Sstevel@tonic-gate } 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate Numcyl = disk_geom.dkg_ncyl; 6257c478bd9Sstevel@tonic-gate heads = disk_geom.dkg_nhead; 6267c478bd9Sstevel@tonic-gate sectors = disk_geom.dkg_nsect; 6277c478bd9Sstevel@tonic-gate sectsiz = 512; 6287c478bd9Sstevel@tonic-gate acyl = disk_geom.dkg_acyl; 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate /* 6317c478bd9Sstevel@tonic-gate * if hba geometry was not set by DKIOC_VIRTGEOM 6327c478bd9Sstevel@tonic-gate * or we got an invalid hba geometry 6337c478bd9Sstevel@tonic-gate * then set hba geometry based on max values 6347c478bd9Sstevel@tonic-gate */ 6357c478bd9Sstevel@tonic-gate if (no_virtgeom_ioctl || 636bb16350dSlclee disk_geom.dkg_ncyl == 0 || 637bb16350dSlclee disk_geom.dkg_nhead == 0 || 638bb16350dSlclee disk_geom.dkg_nsect == 0 || 6397c478bd9Sstevel@tonic-gate disk_geom.dkg_ncyl > MAX_CYL || 6407c478bd9Sstevel@tonic-gate disk_geom.dkg_nhead > MAX_HEAD || 6417c478bd9Sstevel@tonic-gate disk_geom.dkg_nsect > MAX_SECT) { 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate /* 6447c478bd9Sstevel@tonic-gate * turn off flag to print out virtual geometry (-v) 6457c478bd9Sstevel@tonic-gate */ 6467c478bd9Sstevel@tonic-gate v_flag = 0; 6477c478bd9Sstevel@tonic-gate hba_sectors = MAX_SECT; 6487c478bd9Sstevel@tonic-gate hba_heads = MAX_HEAD + 1; 6497c478bd9Sstevel@tonic-gate hba_Numcyl = (Numcyl * heads * sectors) / 6507c478bd9Sstevel@tonic-gate (hba_sectors * hba_heads); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate if (io_debug) { 654bb16350dSlclee (void) fprintf(stderr, "Physical Geometry:\n"); 655bb16350dSlclee (void) fprintf(stderr, 6567c478bd9Sstevel@tonic-gate " cylinders[%d] heads[%d] sectors[%d]\n" 6577c478bd9Sstevel@tonic-gate " sector size[%d] blocks[%d] mbytes[%d]\n", 6587c478bd9Sstevel@tonic-gate Numcyl, 6597c478bd9Sstevel@tonic-gate heads, 6607c478bd9Sstevel@tonic-gate sectors, 6617c478bd9Sstevel@tonic-gate sectsiz, 662bb16350dSlclee Numcyl * heads * sectors, 663bb16350dSlclee (Numcyl * heads * sectors * sectsiz) / 1048576); 664bb16350dSlclee (void) fprintf(stderr, "Virtual (HBA) Geometry:\n"); 665bb16350dSlclee (void) fprintf(stderr, 6667c478bd9Sstevel@tonic-gate " cylinders[%d] heads[%d] sectors[%d]\n" 6677c478bd9Sstevel@tonic-gate " sector size[%d] blocks[%d] mbytes[%d]\n", 6687c478bd9Sstevel@tonic-gate hba_Numcyl, 6697c478bd9Sstevel@tonic-gate hba_heads, 6707c478bd9Sstevel@tonic-gate hba_sectors, 6717c478bd9Sstevel@tonic-gate sectsiz, 672bb16350dSlclee hba_Numcyl * hba_heads * hba_sectors, 673bb16350dSlclee (hba_Numcyl * hba_heads * hba_sectors * sectsiz) / 674bb16350dSlclee 1048576); 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate /* If user has requested a geometry report just do it and exit */ 6797c478bd9Sstevel@tonic-gate if (io_lgeom) { 6807c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) { 6817c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 6827c478bd9Sstevel@tonic-gate "%s: Cannot get disk label geometry.\n", 6837c478bd9Sstevel@tonic-gate argv[optind]); 6847c478bd9Sstevel@tonic-gate exit(1); 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate Numcyl = disk_geom.dkg_ncyl; 6877c478bd9Sstevel@tonic-gate heads = disk_geom.dkg_nhead; 6887c478bd9Sstevel@tonic-gate sectors = disk_geom.dkg_nsect; 6897c478bd9Sstevel@tonic-gate sectsiz = 512; 6907c478bd9Sstevel@tonic-gate acyl = disk_geom.dkg_acyl; 691bb16350dSlclee (void) printf("* Label geometry for device %s\n", Dfltdev); 692bb16350dSlclee (void) printf( 693bb16350dSlclee "* PCYL NCYL ACYL BCYL NHEAD NSECT" 6947c478bd9Sstevel@tonic-gate " SECSIZ\n"); 695bb16350dSlclee (void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n", 6967c478bd9Sstevel@tonic-gate Numcyl, 6977c478bd9Sstevel@tonic-gate disk_geom.dkg_ncyl, 6987c478bd9Sstevel@tonic-gate disk_geom.dkg_acyl, 6997c478bd9Sstevel@tonic-gate disk_geom.dkg_bcyl, 7007c478bd9Sstevel@tonic-gate heads, 7017c478bd9Sstevel@tonic-gate sectors, 7027c478bd9Sstevel@tonic-gate sectsiz); 7037c478bd9Sstevel@tonic-gate exit(0); 7047c478bd9Sstevel@tonic-gate } else if (io_pgeom) { 7057c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) { 7067c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7077c478bd9Sstevel@tonic-gate "%s: Cannot get physical disk geometry.\n", 7087c478bd9Sstevel@tonic-gate argv[optind]); 7097c478bd9Sstevel@tonic-gate exit(1); 7107c478bd9Sstevel@tonic-gate } 711bb16350dSlclee (void) printf("* Physical geometry for device %s\n", Dfltdev); 712bb16350dSlclee (void) printf( 713bb16350dSlclee "* PCYL NCYL ACYL BCYL NHEAD NSECT" 7147c478bd9Sstevel@tonic-gate " SECSIZ\n"); 715bb16350dSlclee (void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n", 7167c478bd9Sstevel@tonic-gate disk_geom.dkg_pcyl, 7177c478bd9Sstevel@tonic-gate disk_geom.dkg_ncyl, 7187c478bd9Sstevel@tonic-gate disk_geom.dkg_acyl, 7197c478bd9Sstevel@tonic-gate disk_geom.dkg_bcyl, 7207c478bd9Sstevel@tonic-gate disk_geom.dkg_nhead, 7217c478bd9Sstevel@tonic-gate disk_geom.dkg_nsect, 7227c478bd9Sstevel@tonic-gate sectsiz); 7237c478bd9Sstevel@tonic-gate exit(0); 7247c478bd9Sstevel@tonic-gate } else if (io_sgeom) { 7257c478bd9Sstevel@tonic-gate if (read_geom(io_sgeom)) { 7267c478bd9Sstevel@tonic-gate exit(1); 7277c478bd9Sstevel@tonic-gate } else if (!io_image) { 7287c478bd9Sstevel@tonic-gate exit(0); 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7321237e847Slclee /* 7331237e847Slclee * some drivers may not support DKIOCGMEDIAINFO 7341237e847Slclee * in that case use CHS 7351237e847Slclee */ 736*342440ecSPrasad Singamsetty chs_capacity = (diskaddr_t)Numcyl * heads * sectors; 7371237e847Slclee dev_capacity = chs_capacity; 738*342440ecSPrasad Singamsetty Numcyl_usable = Numcyl; 739*342440ecSPrasad Singamsetty 740*342440ecSPrasad Singamsetty if (chs_capacity > DK_MAX_2TB) { 741*342440ecSPrasad Singamsetty /* limit to 2TB */ 742*342440ecSPrasad Singamsetty Numcyl_usable = DK_MAX_2TB / (heads * sectors); 743*342440ecSPrasad Singamsetty chs_capacity = (diskaddr_t)Numcyl_usable * heads * sectors; 744*342440ecSPrasad Singamsetty } 745*342440ecSPrasad Singamsetty 7461237e847Slclee if (minfo.dki_capacity > 0) 7471237e847Slclee dev_capacity = minfo.dki_capacity; 7481237e847Slclee 7497c478bd9Sstevel@tonic-gate /* Allocate memory to hold three complete sectors */ 7507c478bd9Sstevel@tonic-gate Bootsect = (char *)malloc(3 * sectsiz); 7517c478bd9Sstevel@tonic-gate if (Bootsect == NULL) { 752bb16350dSlclee (void) fprintf(stderr, 7537c478bd9Sstevel@tonic-gate "fdisk: Unable to obtain enough buffer memory" 7547c478bd9Sstevel@tonic-gate " (%d bytes).\n", 755bb16350dSlclee 3 * sectsiz); 7567c478bd9Sstevel@tonic-gate exit(1); 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate Nullsect = Bootsect + sectsiz; 7607c478bd9Sstevel@tonic-gate /* Zero out the "NULL" sector */ 7617c478bd9Sstevel@tonic-gate for (i = 0; i < sectsiz; i++) { 7627c478bd9Sstevel@tonic-gate Nullsect[i] = 0; 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate /* Find out what the user wants done */ 7667c478bd9Sstevel@tonic-gate if (io_rd) { /* abs disk read */ 7677c478bd9Sstevel@tonic-gate abs_read(); /* will not return */ 7687c478bd9Sstevel@tonic-gate } else if (io_wrt && !io_readonly) { 7697c478bd9Sstevel@tonic-gate abs_write(); /* will not return */ 7707c478bd9Sstevel@tonic-gate } else if (io_patt && !io_readonly) { 7717c478bd9Sstevel@tonic-gate fill_patt(); /* will not return */ 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate 7757c478bd9Sstevel@tonic-gate /* This is the fdisk edit, the real reason for the program. */ 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate sanity_check_provided_device(Dfltdev, Dev); 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate /* Get the new BOOT program in case we write a new fdisk table */ 7807c478bd9Sstevel@tonic-gate mboot_read(); 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /* Read from disk master boot */ 7837c478bd9Sstevel@tonic-gate dev_mboot_read(); 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate /* 7867c478bd9Sstevel@tonic-gate * Verify and copy the device's fdisk table. This will be used 7877c478bd9Sstevel@tonic-gate * as the prototype mboot if the device's mboot looks invalid. 7887c478bd9Sstevel@tonic-gate */ 7897c478bd9Sstevel@tonic-gate Bootblk = (struct mboot *)Bootsect; 7907c478bd9Sstevel@tonic-gate copy_Bootblk_to_Table(); 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate /* save away a copy of Table in Old_Table for sensing changes */ 7937c478bd9Sstevel@tonic-gate copy_Table_to_Old_Table(); 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate /* Load fdisk table from specified file (-F fdisk_file) */ 7967c478bd9Sstevel@tonic-gate if (io_ffdisk) { 7977c478bd9Sstevel@tonic-gate /* Load and verify user-specified table parameters */ 7987c478bd9Sstevel@tonic-gate load(LOADFILE, io_ffdisk); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* Does user want to delete or add an entry? */ 8027c478bd9Sstevel@tonic-gate if (io_Dfdisk) { 8037c478bd9Sstevel@tonic-gate load(LOADDEL, io_Dfdisk); 8047c478bd9Sstevel@tonic-gate } 8057c478bd9Sstevel@tonic-gate if (io_Afdisk) { 8067c478bd9Sstevel@tonic-gate load(LOADADD, io_Afdisk); 8077c478bd9Sstevel@tonic-gate } 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate if (!io_ffdisk && !io_Afdisk && !io_Dfdisk) { 8107c478bd9Sstevel@tonic-gate /* Check if there is no fdisk table */ 8117c478bd9Sstevel@tonic-gate if (Table[0].systid == UNUSED || io_wholedisk || io_EFIdisk) { 8127c478bd9Sstevel@tonic-gate if (io_ifdisk && !io_wholedisk && !io_EFIdisk) { 813bb16350dSlclee (void) printf( 814bb16350dSlclee "No fdisk table exists. The default" 815bb16350dSlclee " partition for the disk is:\n\n" 816bb16350dSlclee " a 100%% \"SOLARIS System\" " 817bb16350dSlclee "partition\n\n" 818bb16350dSlclee "Type \"y\" to accept the default " 8197c478bd9Sstevel@tonic-gate "partition, otherwise type \"n\" to " 8207c478bd9Sstevel@tonic-gate "edit the\n partition table.\n"); 821*342440ecSPrasad Singamsetty 822*342440ecSPrasad Singamsetty if (Numcyl > Numcyl_usable) 823*342440ecSPrasad Singamsetty (void) printf("WARNING: Disk is larger" 824*342440ecSPrasad Singamsetty " than 2TB. Solaris partition will" 825*342440ecSPrasad Singamsetty " be limited to 2 TB.\n"); 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate /* Edit the partition table as directed */ 8297c478bd9Sstevel@tonic-gate if (io_wholedisk ||(io_ifdisk && yesno())) { 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate /* Default scenario */ 8327c478bd9Sstevel@tonic-gate nulltbl(); 8337c478bd9Sstevel@tonic-gate /* now set up UNIX System partition */ 8347c478bd9Sstevel@tonic-gate Table[0].bootid = ACTIVE; 8357c478bd9Sstevel@tonic-gate Table[0].relsect = lel(heads * sectors); 836*342440ecSPrasad Singamsetty 837*342440ecSPrasad Singamsetty Table[0].numsect = 838*342440ecSPrasad Singamsetty lel((ulong_t)((Numcyl_usable - 1) * 8397c478bd9Sstevel@tonic-gate heads * sectors)); 840*342440ecSPrasad Singamsetty 8417c478bd9Sstevel@tonic-gate Table[0].systid = SUNIXOS2; /* Solaris */ 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate /* calculate CHS values for table entry 0 */ 8447c478bd9Sstevel@tonic-gate Set_Table_CHS_Values(0); 8457c478bd9Sstevel@tonic-gate update_disk_and_exit(B_TRUE); 8467c478bd9Sstevel@tonic-gate } else if (io_EFIdisk) { 8477c478bd9Sstevel@tonic-gate /* create an EFI partition for the whole disk */ 8487c478bd9Sstevel@tonic-gate nulltbl(); 8497c478bd9Sstevel@tonic-gate i = insert_tbl(EFI_PMBR, 0, 0, 0, 0, 0, 0, 0, 1, 850*342440ecSPrasad Singamsetty (dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB : 851*342440ecSPrasad Singamsetty (dev_capacity - 1)); 8527c478bd9Sstevel@tonic-gate if (i != 0) { 853bb16350dSlclee (void) fprintf(stderr, 854bb16350dSlclee "Error creating EFI partition\n"); 8557c478bd9Sstevel@tonic-gate exit(1); 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate update_disk_and_exit(B_TRUE); 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate } 8617c478bd9Sstevel@tonic-gate 8627c478bd9Sstevel@tonic-gate /* Display complete fdisk table entries for debugging purposes */ 8637c478bd9Sstevel@tonic-gate if (io_debug) { 864bb16350dSlclee (void) fprintf(stderr, "Partition Table Entry Values:\n"); 8657c478bd9Sstevel@tonic-gate print_Table(); 8667c478bd9Sstevel@tonic-gate if (io_ifdisk) { 867bb16350dSlclee (void) fprintf(stderr, "\n"); 868bb16350dSlclee (void) fprintf(stderr, "Press Enter to continue.\n"); 869bb16350dSlclee (void) gets(s); 8707c478bd9Sstevel@tonic-gate } 8717c478bd9Sstevel@tonic-gate } 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate /* Interactive fdisk mode */ 8747c478bd9Sstevel@tonic-gate if (io_ifdisk) { 875bb16350dSlclee (void) printf(CLR_SCR); 8767c478bd9Sstevel@tonic-gate disptbl(); 877bb16350dSlclee for (;;) { 878bb16350dSlclee stage0(); 8797c478bd9Sstevel@tonic-gate copy_Bootblk_to_Table(); 8807c478bd9Sstevel@tonic-gate disptbl(); 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate } 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate /* If user wants to write the table to a file, do it */ 8857c478bd9Sstevel@tonic-gate if (io_Wfdisk) 8867c478bd9Sstevel@tonic-gate ffile_write(io_Wfdisk); 8877c478bd9Sstevel@tonic-gate else if (stdo_flag) 8887c478bd9Sstevel@tonic-gate ffile_write((char *)stdout); 8897c478bd9Sstevel@tonic-gate 8907c478bd9Sstevel@tonic-gate update_disk_and_exit(TableChanged() == 1); 891bb16350dSlclee return (0); 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate /* 8957c478bd9Sstevel@tonic-gate * read_geom 8967c478bd9Sstevel@tonic-gate * Read geometry from specified file (-S). 8977c478bd9Sstevel@tonic-gate */ 8987c478bd9Sstevel@tonic-gate 899bb16350dSlclee static int 900bb16350dSlclee read_geom(char *sgeom) 9017c478bd9Sstevel@tonic-gate { 9027c478bd9Sstevel@tonic-gate char line[256]; 9037c478bd9Sstevel@tonic-gate FILE *fp; 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate /* open the prototype file */ 9067c478bd9Sstevel@tonic-gate if ((fp = fopen(sgeom, "r")) == NULL) { 9077c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: Cannot open file %s.\n", 9087c478bd9Sstevel@tonic-gate io_sgeom); 9097c478bd9Sstevel@tonic-gate return (1); 9107c478bd9Sstevel@tonic-gate } 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate /* Read a line from the file */ 9137c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line) - 1, fp)) { 9147c478bd9Sstevel@tonic-gate if (line[0] == '\0' || line[0] == '\n' || line[0] == '*') 9157c478bd9Sstevel@tonic-gate continue; 9167c478bd9Sstevel@tonic-gate else { 9177c478bd9Sstevel@tonic-gate line[strlen(line)] = '\0'; 918bb16350dSlclee if (sscanf(line, "%hu %hu %hu %hu %hu %hu %d", 9197c478bd9Sstevel@tonic-gate &disk_geom.dkg_pcyl, 9207c478bd9Sstevel@tonic-gate &disk_geom.dkg_ncyl, 9217c478bd9Sstevel@tonic-gate &disk_geom.dkg_acyl, 9227c478bd9Sstevel@tonic-gate &disk_geom.dkg_bcyl, 9237c478bd9Sstevel@tonic-gate &disk_geom.dkg_nhead, 9247c478bd9Sstevel@tonic-gate &disk_geom.dkg_nsect, 9257c478bd9Sstevel@tonic-gate §siz) != 7) { 9267c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9277c478bd9Sstevel@tonic-gate "Syntax error:\n \"%s\".\n", 9287c478bd9Sstevel@tonic-gate line); 9297c478bd9Sstevel@tonic-gate return (1); 9307c478bd9Sstevel@tonic-gate } 9317c478bd9Sstevel@tonic-gate break; 9327c478bd9Sstevel@tonic-gate } /* else */ 9337c478bd9Sstevel@tonic-gate } /* while (fgets(line, sizeof (line) - 1, fp)) */ 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate if (!io_image) { 9367c478bd9Sstevel@tonic-gate if (ioctl(Dev, DKIOCSGEOM, &disk_geom)) { 9377c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9387c478bd9Sstevel@tonic-gate "fdisk: Cannot set label geometry.\n"); 9397c478bd9Sstevel@tonic-gate return (1); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate } else { 9427c478bd9Sstevel@tonic-gate Numcyl = hba_Numcyl = disk_geom.dkg_ncyl; 9437c478bd9Sstevel@tonic-gate heads = hba_heads = disk_geom.dkg_nhead; 9447c478bd9Sstevel@tonic-gate sectors = hba_sectors = disk_geom.dkg_nsect; 9457c478bd9Sstevel@tonic-gate acyl = disk_geom.dkg_acyl; 9467c478bd9Sstevel@tonic-gate } 9477c478bd9Sstevel@tonic-gate 948bb16350dSlclee (void) fclose(fp); 9497c478bd9Sstevel@tonic-gate return (0); 9507c478bd9Sstevel@tonic-gate } 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * dev_mboot_read 9547c478bd9Sstevel@tonic-gate * Read the master boot sector from the device. 9557c478bd9Sstevel@tonic-gate */ 956bb16350dSlclee static void 957bb16350dSlclee dev_mboot_read(void) 9587c478bd9Sstevel@tonic-gate { 9597c478bd9Sstevel@tonic-gate if ((ioctl(Dev, DKIOCGMBOOT, Bootsect) < 0) && (errno != ENOTTY)) { 9607c478bd9Sstevel@tonic-gate perror("Error in ioctl DKIOCGMBOOT"); 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate if (errno == 0) 9637c478bd9Sstevel@tonic-gate return; 9647c478bd9Sstevel@tonic-gate if (lseek(Dev, 0, SEEK_SET) == -1) { 965bb16350dSlclee (void) fprintf(stderr, 9667c478bd9Sstevel@tonic-gate "fdisk: Error seeking to partition table on %s.\n", 9677c478bd9Sstevel@tonic-gate Dfltdev); 9687c478bd9Sstevel@tonic-gate if (!io_image) 9697c478bd9Sstevel@tonic-gate exit(1); 9707c478bd9Sstevel@tonic-gate } 9717c478bd9Sstevel@tonic-gate if (read(Dev, Bootsect, sectsiz) != sectsiz) { 972bb16350dSlclee (void) fprintf(stderr, 9737c478bd9Sstevel@tonic-gate "fdisk: Error reading partition table from %s.\n", 9747c478bd9Sstevel@tonic-gate Dfltdev); 9757c478bd9Sstevel@tonic-gate if (!io_image) 9767c478bd9Sstevel@tonic-gate exit(1); 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate } 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate /* 9817c478bd9Sstevel@tonic-gate * dev_mboot_write 9827c478bd9Sstevel@tonic-gate * Write the master boot sector to the device. 9837c478bd9Sstevel@tonic-gate */ 984bb16350dSlclee static void 9859d5d1945Sbharding dev_mboot_write(off_t sect, char *buff, int bootsiz) 9867c478bd9Sstevel@tonic-gate { 9877c478bd9Sstevel@tonic-gate int new_pt, old_pt, error; 988a4a653edSbharding int clr_efi = -1; 9897c478bd9Sstevel@tonic-gate 9907c478bd9Sstevel@tonic-gate if (io_readonly) 991bb16350dSlclee return; 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate if (io_debug) { 994bb16350dSlclee (void) fprintf(stderr, "About to write fdisk table:\n"); 9957c478bd9Sstevel@tonic-gate print_Table(); 9967c478bd9Sstevel@tonic-gate if (io_ifdisk) { 997bb16350dSlclee (void) fprintf(stderr, "Press Enter to continue.\n"); 998bb16350dSlclee (void) gets(s); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate 1002a4a653edSbharding /* 1003a4a653edSbharding * If the new table has any Solaris partitions and the old 1004a4a653edSbharding * table does not have an entry that describes it 1005a4a653edSbharding * exactly then clear the old vtoc (if any). 1006a4a653edSbharding */ 10077c478bd9Sstevel@tonic-gate for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) { 10087c478bd9Sstevel@tonic-gate 1009a4a653edSbharding /* We only care about potential Solaris parts. */ 10107c478bd9Sstevel@tonic-gate if (Table[new_pt].systid != SUNIXOS && 10117c478bd9Sstevel@tonic-gate Table[new_pt].systid != SUNIXOS2) 10127c478bd9Sstevel@tonic-gate continue; 10137c478bd9Sstevel@tonic-gate 1014a4a653edSbharding /* Does the old table have an exact entry for the new entry? */ 1015a4a653edSbharding for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 1016a4a653edSbharding 1017a4a653edSbharding /* We only care about old Solaris partitions. */ 1018a4a653edSbharding if ((Old_Table[old_pt].systid == SUNIXOS) || 1019a4a653edSbharding (Old_Table[old_pt].systid == SUNIXOS2)) { 1020a4a653edSbharding 1021a4a653edSbharding /* Is this old one the same as a new one? */ 1022a4a653edSbharding if ((Old_Table[old_pt].relsect == 1023a4a653edSbharding Table[new_pt].relsect) && 1024a4a653edSbharding (Old_Table[old_pt].numsect == 1025a4a653edSbharding Table[new_pt].numsect)) 1026a4a653edSbharding break; /* Yes */ 1027a4a653edSbharding } 1028a4a653edSbharding } 1029a4a653edSbharding 1030a4a653edSbharding /* Did a solaris partition change location or size? */ 1031a4a653edSbharding if (old_pt >= FD_NUMPART) { 1032a4a653edSbharding /* Yes clear old vtoc */ 1033a4a653edSbharding if (io_debug) { 1034a4a653edSbharding (void) fprintf(stderr, 1035a4a653edSbharding "Clearing VTOC labels from NEW" 1036a4a653edSbharding " table\n"); 1037a4a653edSbharding } 1038a4a653edSbharding clear_vtoc(NEW, new_pt); 1039a4a653edSbharding } 1040a4a653edSbharding } 1041a4a653edSbharding 1042a4a653edSbharding 1043a4a653edSbharding /* see if the old table had EFI */ 1044a4a653edSbharding for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 1045a4a653edSbharding if (Old_Table[old_pt].systid == EFI_PMBR) { 1046a4a653edSbharding clr_efi = old_pt; 10477c478bd9Sstevel@tonic-gate } 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate /* look to see if a EFI partition changed in relsect/numsect */ 10517c478bd9Sstevel@tonic-gate for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) { 10527c478bd9Sstevel@tonic-gate if (Table[new_pt].systid != EFI_PMBR) 10537c478bd9Sstevel@tonic-gate continue; 10547c478bd9Sstevel@tonic-gate for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 10551237e847Slclee if ((Old_Table[old_pt].systid == 10561237e847Slclee Table[new_pt].systid) && 10571237e847Slclee (Old_Table[old_pt].relsect == 10581237e847Slclee Table[new_pt].relsect) && 10591237e847Slclee (Old_Table[old_pt].numsect == 10601237e847Slclee Table[new_pt].numsect)) 10611237e847Slclee break; 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate /* 10657c478bd9Sstevel@tonic-gate * if EFI partition changed, set the flag to clear 10667c478bd9Sstevel@tonic-gate * the EFI GPT 10677c478bd9Sstevel@tonic-gate */ 10687c478bd9Sstevel@tonic-gate if (old_pt == FD_NUMPART && Table[new_pt].begcyl != 0) { 10697c478bd9Sstevel@tonic-gate clr_efi = 0; 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate break; 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate /* clear labels if necessary */ 10757c478bd9Sstevel@tonic-gate if (clr_efi >= 0) { 10767c478bd9Sstevel@tonic-gate if (io_debug) { 1077bb16350dSlclee (void) fprintf(stderr, "Clearing EFI labels\n"); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate if ((error = clear_efi()) != 0) { 10807c478bd9Sstevel@tonic-gate if (io_debug) { 1081bb16350dSlclee (void) fprintf(stderr, 1082bb16350dSlclee "\tError %d clearing EFI labels" 10837c478bd9Sstevel@tonic-gate " (probably no EFI labels exist)\n", 10847c478bd9Sstevel@tonic-gate error); 10857c478bd9Sstevel@tonic-gate } 10867c478bd9Sstevel@tonic-gate } 10877c478bd9Sstevel@tonic-gate } 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate if ((ioctl(Dev, DKIOCSMBOOT, buff) == -1) && (errno != ENOTTY)) { 1090bb16350dSlclee (void) fprintf(stderr, 10917c478bd9Sstevel@tonic-gate "fdisk: Error in ioctl DKIOCSMBOOT on %s.\n", 10927c478bd9Sstevel@tonic-gate Dfltdev); 10937c478bd9Sstevel@tonic-gate } 10947c478bd9Sstevel@tonic-gate if (errno == 0) 10957c478bd9Sstevel@tonic-gate return; 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate /* write to disk drive */ 10987c478bd9Sstevel@tonic-gate if (lseek(Dev, sect, SEEK_SET) == -1) { 1099bb16350dSlclee (void) fprintf(stderr, 11007c478bd9Sstevel@tonic-gate "fdisk: Error seeking to master boot record on %s.\n", 11017c478bd9Sstevel@tonic-gate Dfltdev); 11027c478bd9Sstevel@tonic-gate exit(1); 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate if (write(Dev, buff, bootsiz) != bootsiz) { 1105bb16350dSlclee (void) fprintf(stderr, 11067c478bd9Sstevel@tonic-gate "fdisk: Error writing master boot record to %s.\n", 11077c478bd9Sstevel@tonic-gate Dfltdev); 11087c478bd9Sstevel@tonic-gate exit(1); 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate /* 11137c478bd9Sstevel@tonic-gate * mboot_read 11147c478bd9Sstevel@tonic-gate * Read the prototype boot records from the files. 11157c478bd9Sstevel@tonic-gate */ 1116bb16350dSlclee static void 1117bb16350dSlclee mboot_read(void) 11187c478bd9Sstevel@tonic-gate { 11197c478bd9Sstevel@tonic-gate int mDev, i; 11207c478bd9Sstevel@tonic-gate struct ipart *part; 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate #if defined(i386) || defined(sparc) 11237c478bd9Sstevel@tonic-gate /* 11247c478bd9Sstevel@tonic-gate * If the master boot file hasn't been specified, use the 11257c478bd9Sstevel@tonic-gate * implementation architecture name to generate the default one. 11267c478bd9Sstevel@tonic-gate */ 11277c478bd9Sstevel@tonic-gate if (io_mboot == (char *)0) { 11287c478bd9Sstevel@tonic-gate /* 11297c478bd9Sstevel@tonic-gate * Bug ID 1249035: 11307c478bd9Sstevel@tonic-gate * The mboot file must be delivered on all platforms 11317c478bd9Sstevel@tonic-gate * and installed in a non-platform-dependent 11327c478bd9Sstevel@tonic-gate * directory; i.e., /usr/lib/fs/ufs. 11337c478bd9Sstevel@tonic-gate */ 11347c478bd9Sstevel@tonic-gate io_mboot = "/usr/lib/fs/ufs/mboot"; 11357c478bd9Sstevel@tonic-gate } 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate /* First read in the master boot record */ 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* Open the master boot proto file */ 11407c478bd9Sstevel@tonic-gate if ((mDev = open(io_mboot, O_RDONLY, 0666)) == -1) { 1141bb16350dSlclee (void) fprintf(stderr, 11427c478bd9Sstevel@tonic-gate "fdisk: Cannot open master boot file %s.\n", 11437c478bd9Sstevel@tonic-gate io_mboot); 11447c478bd9Sstevel@tonic-gate exit(1); 11457c478bd9Sstevel@tonic-gate } 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate /* Read the master boot program */ 11487c478bd9Sstevel@tonic-gate if (read(mDev, &BootCod, sizeof (struct mboot)) != sizeof 11497c478bd9Sstevel@tonic-gate (struct mboot)) { 1150bb16350dSlclee (void) fprintf(stderr, 11517c478bd9Sstevel@tonic-gate "fdisk: Cannot read master boot file %s.\n", 11527c478bd9Sstevel@tonic-gate io_mboot); 11537c478bd9Sstevel@tonic-gate exit(1); 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* Is this really a master boot record? */ 11577c478bd9Sstevel@tonic-gate if (les(BootCod.signature) != MBB_MAGIC) { 1158bb16350dSlclee (void) fprintf(stderr, 11597c478bd9Sstevel@tonic-gate "fdisk: Invalid master boot file %s.\n", io_mboot); 1160bb16350dSlclee (void) fprintf(stderr, 1161bb16350dSlclee "Bad magic number: is %x, but should be %x.\n", 11627c478bd9Sstevel@tonic-gate les(BootCod.signature), MBB_MAGIC); 11637c478bd9Sstevel@tonic-gate exit(1); 11647c478bd9Sstevel@tonic-gate } 11657c478bd9Sstevel@tonic-gate 1166bb16350dSlclee (void) close(mDev); 11677c478bd9Sstevel@tonic-gate #else 11687c478bd9Sstevel@tonic-gate #error fdisk needs to be ported to new architecture 11697c478bd9Sstevel@tonic-gate #endif 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate /* Zero out the partitions part of this record */ 11727c478bd9Sstevel@tonic-gate part = (struct ipart *)BootCod.parts; 11737c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++, part++) { 1174bb16350dSlclee (void) memset(part, 0, sizeof (struct ipart)); 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate } 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate /* 11807c478bd9Sstevel@tonic-gate * fill_patt 11817c478bd9Sstevel@tonic-gate * Fill the disk with user/sector number pattern. 11827c478bd9Sstevel@tonic-gate */ 1183bb16350dSlclee static void 1184bb16350dSlclee fill_patt(void) 11857c478bd9Sstevel@tonic-gate { 1186bb16350dSlclee int *buff_ptr, i; 11879d5d1945Sbharding off_t *off_ptr; 11887c478bd9Sstevel@tonic-gate int io_fpatt = 0; 11897c478bd9Sstevel@tonic-gate int io_ipatt = 0; 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate if (strncmp(io_fatt, "#", 1) != 0) { 11927c478bd9Sstevel@tonic-gate io_fpatt++; 11937c478bd9Sstevel@tonic-gate io_ipatt = strtoul(io_fatt, 0, 0); 11947c478bd9Sstevel@tonic-gate buff_ptr = (int *)Bootsect; 11957c478bd9Sstevel@tonic-gate for (i = 0; i < sectsiz; i += 4, buff_ptr++) 11961237e847Slclee *buff_ptr = io_ipatt; 11977c478bd9Sstevel@tonic-gate } 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate /* 12007c478bd9Sstevel@tonic-gate * Fill disk with pattern based on block number. 12017c478bd9Sstevel@tonic-gate * Write to the disk at absolute relative block io_offset 12027c478bd9Sstevel@tonic-gate * for io_size blocks. 12037c478bd9Sstevel@tonic-gate */ 12047c478bd9Sstevel@tonic-gate while (io_size--) { 12059d5d1945Sbharding off_ptr = (off_t *)Bootsect; 12067c478bd9Sstevel@tonic-gate if (!io_fpatt) { 12079d5d1945Sbharding for (i = 0; i < sectsiz; 12089d5d1945Sbharding i += sizeof (off_t), off_ptr++) 12099d5d1945Sbharding *off_ptr = io_offset; 12107c478bd9Sstevel@tonic-gate } 12117c478bd9Sstevel@tonic-gate /* Write the data to disk */ 12129d5d1945Sbharding if (lseek(Dev, (off_t)(sectsiz * io_offset++), 12139d5d1945Sbharding SEEK_SET) == -1) { 1214bb16350dSlclee (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 12151237e847Slclee Dfltdev); 12167c478bd9Sstevel@tonic-gate exit(1); 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate if (write(Dev, Bootsect, sectsiz) != sectsiz) { 1219bb16350dSlclee (void) fprintf(stderr, "fdisk: Error writing %s.\n", 12201237e847Slclee Dfltdev); 12217c478bd9Sstevel@tonic-gate exit(1); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate } /* while (--io_size); */ 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate /* 12277c478bd9Sstevel@tonic-gate * abs_read 12287c478bd9Sstevel@tonic-gate * Read from the disk at absolute relative block io_offset for 12297c478bd9Sstevel@tonic-gate * io_size blocks. Write the data to standard ouput (-r). 12307c478bd9Sstevel@tonic-gate */ 1231bb16350dSlclee static void 1232bb16350dSlclee abs_read(void) 1233bb16350dSlclee { 12347c478bd9Sstevel@tonic-gate int c; 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate while (io_size--) { 12379d5d1945Sbharding if (lseek(Dev, (off_t)(sectsiz * io_offset++), 12389d5d1945Sbharding SEEK_SET) == -1) { 1239bb16350dSlclee (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 12407c478bd9Sstevel@tonic-gate Dfltdev); 12417c478bd9Sstevel@tonic-gate exit(1); 12427c478bd9Sstevel@tonic-gate } 12437c478bd9Sstevel@tonic-gate if (read(Dev, Bootsect, sectsiz) != sectsiz) { 1244bb16350dSlclee (void) fprintf(stderr, "fdisk: Error reading %s.\n", 12457c478bd9Sstevel@tonic-gate Dfltdev); 12467c478bd9Sstevel@tonic-gate exit(1); 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate /* Write to standard ouptut */ 1250bb16350dSlclee if ((c = write(1, Bootsect, (unsigned)sectsiz)) != sectsiz) { 12517c478bd9Sstevel@tonic-gate if (c >= 0) { 12527c478bd9Sstevel@tonic-gate if (io_debug) 1253bb16350dSlclee (void) fprintf(stderr, 1254bb16350dSlclee "fdisk: Output warning: %d of %d" 1255bb16350dSlclee " characters written.\n", 1256bb16350dSlclee c, sectsiz); 12577c478bd9Sstevel@tonic-gate exit(2); 12587c478bd9Sstevel@tonic-gate } else { 12597c478bd9Sstevel@tonic-gate perror("write error on output file."); 12607c478bd9Sstevel@tonic-gate exit(2); 12617c478bd9Sstevel@tonic-gate } 12627c478bd9Sstevel@tonic-gate } /* if ((c = write(1, Bootsect, (unsigned)sectsiz)) */ 12637c478bd9Sstevel@tonic-gate /* != sectsiz) */ 12647c478bd9Sstevel@tonic-gate } /* while (--io_size); */ 12657c478bd9Sstevel@tonic-gate exit(0); 12667c478bd9Sstevel@tonic-gate } 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate /* 12697c478bd9Sstevel@tonic-gate * abs_write 12707c478bd9Sstevel@tonic-gate * Read the data from standard input. Write to the disk at 12717c478bd9Sstevel@tonic-gate * absolute relative block io_offset for io_size blocks (-w). 12727c478bd9Sstevel@tonic-gate */ 1273bb16350dSlclee static void 1274bb16350dSlclee abs_write(void) 12757c478bd9Sstevel@tonic-gate { 12767c478bd9Sstevel@tonic-gate int c, i; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate while (io_size--) { 12797c478bd9Sstevel@tonic-gate int part_exit = 0; 12807c478bd9Sstevel@tonic-gate /* Read from standard input */ 12817c478bd9Sstevel@tonic-gate if ((c = read(0, Bootsect, (unsigned)sectsiz)) != sectsiz) { 12827c478bd9Sstevel@tonic-gate if (c >= 0) { 12837c478bd9Sstevel@tonic-gate if (io_debug) 1284bb16350dSlclee (void) fprintf(stderr, 12857c478bd9Sstevel@tonic-gate "fdisk: WARNING: Incomplete read (%d of" 12867c478bd9Sstevel@tonic-gate " %d characters read) on input file.\n", 12871237e847Slclee c, sectsiz); 12887c478bd9Sstevel@tonic-gate /* Fill pattern to mark partial sector in buf */ 12897c478bd9Sstevel@tonic-gate for (i = c; i < sectsiz; ) { 12907c478bd9Sstevel@tonic-gate Bootsect[i++] = 0x41; 12917c478bd9Sstevel@tonic-gate Bootsect[i++] = 0x62; 12927c478bd9Sstevel@tonic-gate Bootsect[i++] = 0x65; 12937c478bd9Sstevel@tonic-gate Bootsect[i++] = 0; 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate part_exit++; 12967c478bd9Sstevel@tonic-gate } else { 12977c478bd9Sstevel@tonic-gate perror("read error on input file."); 12987c478bd9Sstevel@tonic-gate exit(2); 12997c478bd9Sstevel@tonic-gate } 13007c478bd9Sstevel@tonic-gate 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate /* Write to disk drive */ 13039d5d1945Sbharding if (lseek(Dev, (off_t)(sectsiz * io_offset++), 13049d5d1945Sbharding SEEK_SET) == -1) { 1305bb16350dSlclee (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 13067c478bd9Sstevel@tonic-gate Dfltdev); 13077c478bd9Sstevel@tonic-gate exit(1); 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate if (write(Dev, Bootsect, sectsiz) != sectsiz) { 1310bb16350dSlclee (void) fprintf(stderr, "fdisk: Error writing %s.\n", 13117c478bd9Sstevel@tonic-gate Dfltdev); 13127c478bd9Sstevel@tonic-gate exit(1); 13137c478bd9Sstevel@tonic-gate } 13147c478bd9Sstevel@tonic-gate if (part_exit) 13157c478bd9Sstevel@tonic-gate exit(0); 13167c478bd9Sstevel@tonic-gate } /* while (--io_size); */ 13177c478bd9Sstevel@tonic-gate exit(1); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 1320bb16350dSlclee 13217c478bd9Sstevel@tonic-gate /* 13227c478bd9Sstevel@tonic-gate * load 13237c478bd9Sstevel@tonic-gate * Load will either read the fdisk table from a file or add or 13247c478bd9Sstevel@tonic-gate * delete an entry (-A, -D, -F). 13257c478bd9Sstevel@tonic-gate */ 13267c478bd9Sstevel@tonic-gate 1327bb16350dSlclee static void 1328bb16350dSlclee load(int funct, char *file) 13297c478bd9Sstevel@tonic-gate { 13307c478bd9Sstevel@tonic-gate int id; 13317c478bd9Sstevel@tonic-gate int act; 13327c478bd9Sstevel@tonic-gate int bhead; 13337c478bd9Sstevel@tonic-gate int bsect; 13347c478bd9Sstevel@tonic-gate int bcyl; 13357c478bd9Sstevel@tonic-gate int ehead; 13367c478bd9Sstevel@tonic-gate int esect; 13377c478bd9Sstevel@tonic-gate int ecyl; 1338*342440ecSPrasad Singamsetty uint32_t rsect; 1339*342440ecSPrasad Singamsetty uint32_t numsect; 13407c478bd9Sstevel@tonic-gate char line[256]; 13417c478bd9Sstevel@tonic-gate int i = 0; 13427c478bd9Sstevel@tonic-gate int j; 13437c478bd9Sstevel@tonic-gate FILE *fp; 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate switch (funct) { 13467c478bd9Sstevel@tonic-gate 13471237e847Slclee case LOADFILE: 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate /* 13507c478bd9Sstevel@tonic-gate * Zero out the table before loading it, which will 13517c478bd9Sstevel@tonic-gate * force it to be updated on disk later (-F 13527c478bd9Sstevel@tonic-gate * fdisk_file). 13537c478bd9Sstevel@tonic-gate */ 13547c478bd9Sstevel@tonic-gate nulltbl(); 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate /* Open the prototype file */ 13577c478bd9Sstevel@tonic-gate if ((fp = fopen(file, "r")) == NULL) { 13587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13597c478bd9Sstevel@tonic-gate "fdisk: Cannot open prototype partition file %s.\n", 13607c478bd9Sstevel@tonic-gate file); 13617c478bd9Sstevel@tonic-gate exit(1); 13627c478bd9Sstevel@tonic-gate } 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate /* Read a line from the file */ 13657c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line) - 1, fp)) { 13667c478bd9Sstevel@tonic-gate if (pars_fdisk(line, &id, &act, &bhead, &bsect, 13677c478bd9Sstevel@tonic-gate &bcyl, &ehead, &esect, &ecyl, &rsect, &numsect)) { 13687c478bd9Sstevel@tonic-gate continue; 13697c478bd9Sstevel@tonic-gate } 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate /* 13727c478bd9Sstevel@tonic-gate * Validate the partition. It cannot start at sector 13737c478bd9Sstevel@tonic-gate * 0 unless it is UNUSED or already exists 13747c478bd9Sstevel@tonic-gate */ 13757c478bd9Sstevel@tonic-gate if (validate_part(id, rsect, numsect) < 0) { 13767c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13777c478bd9Sstevel@tonic-gate "fdisk: Error on entry \"%s\".\n", 13787c478bd9Sstevel@tonic-gate line); 13797c478bd9Sstevel@tonic-gate exit(1); 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate /* 13827c478bd9Sstevel@tonic-gate * Find an unused entry to use and put the entry 13837c478bd9Sstevel@tonic-gate * in table 13847c478bd9Sstevel@tonic-gate */ 13857c478bd9Sstevel@tonic-gate if (insert_tbl(id, act, bhead, bsect, bcyl, ehead, 13867c478bd9Sstevel@tonic-gate esect, ecyl, rsect, numsect) < 0) { 13877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13887c478bd9Sstevel@tonic-gate "fdisk: Error on entry \"%s\".\n", 13897c478bd9Sstevel@tonic-gate line); 13907c478bd9Sstevel@tonic-gate exit(1); 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate } /* while (fgets(line, sizeof (line) - 1, fp)) */ 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate if (verify_tbl() < 0) { 1395bb16350dSlclee (void) fprintf(stderr, 13967c478bd9Sstevel@tonic-gate "fdisk: Cannot create partition table\n"); 13977c478bd9Sstevel@tonic-gate exit(1); 13987c478bd9Sstevel@tonic-gate } 13997c478bd9Sstevel@tonic-gate 1400bb16350dSlclee (void) fclose(fp); 14017c478bd9Sstevel@tonic-gate return; 14027c478bd9Sstevel@tonic-gate 14031237e847Slclee case LOADDEL: 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate /* Parse the user-supplied deletion line (-D) */ 1406bb16350dSlclee if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl, 1407bb16350dSlclee &ehead, &esect, &ecyl, &rsect, &numsect)) { 1408bb16350dSlclee (void) fprintf(stderr, 1409bb16350dSlclee "fdisk: Syntax error \"%s\"\n", file); 1410bb16350dSlclee exit(1); 1411bb16350dSlclee } 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate /* Find the exact entry in the table */ 14147c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 14157c478bd9Sstevel@tonic-gate if (Table[i].systid == id && 14167c478bd9Sstevel@tonic-gate Table[i].bootid == act && 14177c478bd9Sstevel@tonic-gate Table[i].beghead == bhead && 14187c478bd9Sstevel@tonic-gate Table[i].begsect == ((bsect & 0x3f) | 14191237e847Slclee (uchar_t)((bcyl>>2) & 0xc0)) && 1420bb16350dSlclee Table[i].begcyl == (uchar_t)(bcyl & 0xff) && 14217c478bd9Sstevel@tonic-gate Table[i].endhead == ehead && 14227c478bd9Sstevel@tonic-gate Table[i].endsect == ((esect & 0x3f) | 14231237e847Slclee (uchar_t)((ecyl>>2) & 0xc0)) && 1424bb16350dSlclee Table[i].endcyl == (uchar_t)(ecyl & 0xff) && 14257c478bd9Sstevel@tonic-gate Table[i].relsect == lel(rsect) && 14267c478bd9Sstevel@tonic-gate Table[i].numsect == lel(numsect)) { 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * Found the entry. Now move rest of 14307c478bd9Sstevel@tonic-gate * entries up toward the top of the 14317c478bd9Sstevel@tonic-gate * table, leaving available entries at 14327c478bd9Sstevel@tonic-gate * the end of the fdisk table. 14337c478bd9Sstevel@tonic-gate */ 1434bb16350dSlclee for (j = i; j < FD_NUMPART - 1; j++) { 1435bb16350dSlclee Table[j].systid = Table[j + 1].systid; 1436bb16350dSlclee Table[j].bootid = Table[j + 1].bootid; 1437bb16350dSlclee Table[j].beghead = Table[j + 1].beghead; 1438bb16350dSlclee Table[j].begsect = Table[j + 1].begsect; 1439bb16350dSlclee Table[j].begcyl = Table[j + 1].begcyl; 1440bb16350dSlclee Table[j].endhead = Table[j + 1].endhead; 1441bb16350dSlclee Table[j].endsect = Table[j + 1].endsect; 1442bb16350dSlclee Table[j].endcyl = Table[j + 1].endcyl; 1443bb16350dSlclee Table[j].relsect = Table[j + 1].relsect; 1444bb16350dSlclee Table[j].numsect = Table[j + 1].numsect; 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate /* 14487c478bd9Sstevel@tonic-gate * Mark the last entry as unused in case 14497c478bd9Sstevel@tonic-gate * all table entries were in use prior 14507c478bd9Sstevel@tonic-gate * to the deletion. 14517c478bd9Sstevel@tonic-gate */ 14527c478bd9Sstevel@tonic-gate 1453bb16350dSlclee Table[FD_NUMPART - 1].systid = UNUSED; 1454bb16350dSlclee Table[FD_NUMPART - 1].bootid = 0; 14557c478bd9Sstevel@tonic-gate return; 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate } 1458bb16350dSlclee (void) fprintf(stderr, 14597c478bd9Sstevel@tonic-gate "fdisk: Entry does not match any existing partition:\n" 14607c478bd9Sstevel@tonic-gate " \"%s\"\n", 14617c478bd9Sstevel@tonic-gate file); 14627c478bd9Sstevel@tonic-gate exit(1); 1463bb16350dSlclee /* FALLTHRU */ 14647c478bd9Sstevel@tonic-gate 14651237e847Slclee case LOADADD: 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate /* Parse the user-supplied addition line (-A) */ 1468bb16350dSlclee if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl, &ehead, 1469bb16350dSlclee &esect, &ecyl, &rsect, &numsect)) { 1470bb16350dSlclee (void) fprintf(stderr, 1471bb16350dSlclee "fdisk: Syntax error \"%s\"\n", file); 1472bb16350dSlclee exit(1); 1473bb16350dSlclee } 14747c478bd9Sstevel@tonic-gate 14757c478bd9Sstevel@tonic-gate /* Validate the partition. It cannot start at sector 0 */ 14767c478bd9Sstevel@tonic-gate if (rsect == 0) { 14777c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14787c478bd9Sstevel@tonic-gate "fdisk: New partition cannot start at sector 0:\n" 14797c478bd9Sstevel@tonic-gate " \"%s\".\n", 14807c478bd9Sstevel@tonic-gate file); 14817c478bd9Sstevel@tonic-gate exit(1); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate /* 14857c478bd9Sstevel@tonic-gate * if the user wishes to add an EFI partition, we need 14867c478bd9Sstevel@tonic-gate * more extensive validation. rsect should be 1, and 14877c478bd9Sstevel@tonic-gate * numsect should equal the entire disk capacity - 1 14887c478bd9Sstevel@tonic-gate */ 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate if (id == EFI_PMBR) { 14917c478bd9Sstevel@tonic-gate if (rsect != 1) { 14927c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14937c478bd9Sstevel@tonic-gate "fdisk: EFI partitions must start at sector" 14947c478bd9Sstevel@tonic-gate " 1 (input rsect = %d)\n", rsect); 14957c478bd9Sstevel@tonic-gate exit(1); 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate 1498*342440ecSPrasad Singamsetty 1499*342440ecSPrasad Singamsetty if (dev_capacity > DK_MAX_2TB) { 1500*342440ecSPrasad Singamsetty if (numsect != DK_MAX_2TB) { 1501*342440ecSPrasad Singamsetty (void) fprintf(stderr, 1502*342440ecSPrasad Singamsetty "fdisk: EFI partitions must " 1503*342440ecSPrasad Singamsetty "encompass the entire maximum 2 TB " 1504*342440ecSPrasad Singamsetty "(input numsect: %u - max: %llu)\n", 1505*342440ecSPrasad Singamsetty numsect, (diskaddr_t)DK_MAX_2TB); 1506*342440ecSPrasad Singamsetty exit(1); 1507*342440ecSPrasad Singamsetty } 1508*342440ecSPrasad Singamsetty } else if (numsect != dev_capacity - 1) { 15097c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 15107c478bd9Sstevel@tonic-gate "fdisk: EFI partitions must encompass the " 1511bb16350dSlclee "entire disk\n" 1512*342440ecSPrasad Singamsetty "(input numsect: %u - avail: %llu)\n", 1513bb16350dSlclee numsect, 15141237e847Slclee dev_capacity - 1); 15157c478bd9Sstevel@tonic-gate exit(1); 15167c478bd9Sstevel@tonic-gate } 15177c478bd9Sstevel@tonic-gate } 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate /* Find unused entry for use and put entry in table */ 15207c478bd9Sstevel@tonic-gate if (insert_tbl(id, act, bhead, bsect, bcyl, ehead, esect, 15217c478bd9Sstevel@tonic-gate ecyl, rsect, numsect) < 0) { 15227c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 15237c478bd9Sstevel@tonic-gate "fdisk: Invalid entry could not be inserted:\n" 15247c478bd9Sstevel@tonic-gate " \"%s\"\n", 15257c478bd9Sstevel@tonic-gate file); 15267c478bd9Sstevel@tonic-gate exit(1); 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate /* Make sure new entry does not overlap existing entry */ 15307c478bd9Sstevel@tonic-gate if (verify_tbl() < 0) { 1531bb16350dSlclee (void) fprintf(stderr, 1532bb16350dSlclee "fdisk: Cannot create partition \"%s\"\n", file); 15337c478bd9Sstevel@tonic-gate exit(1); 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate } /* switch funct */ 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate /* 15397c478bd9Sstevel@tonic-gate * Set_Table_CHS_Values 15407c478bd9Sstevel@tonic-gate * 15417c478bd9Sstevel@tonic-gate * This will calculate the CHS values for beginning and ending CHS 15427c478bd9Sstevel@tonic-gate * for a single partition table entry (ti) based on the relsect 15437c478bd9Sstevel@tonic-gate * and numsect values contained in the partion table entry. 15447c478bd9Sstevel@tonic-gate * 15457c478bd9Sstevel@tonic-gate * hba_heads and hba_sectors contain the number of heads and sectors. 15467c478bd9Sstevel@tonic-gate * 15477c478bd9Sstevel@tonic-gate * If the number of cylinders exceeds the MAX_CYL, 15487c478bd9Sstevel@tonic-gate * then maximum values will be placed in the corresponding chs entry. 15497c478bd9Sstevel@tonic-gate */ 15507c478bd9Sstevel@tonic-gate static void 15517c478bd9Sstevel@tonic-gate Set_Table_CHS_Values(int ti) 15527c478bd9Sstevel@tonic-gate { 15537c478bd9Sstevel@tonic-gate uint32_t lba, cy, hd, sc; 15547c478bd9Sstevel@tonic-gate 15557c478bd9Sstevel@tonic-gate lba = (uint32_t)Table[ti].relsect; 15567c478bd9Sstevel@tonic-gate if (lba >= hba_heads * hba_sectors * MAX_CYL) { 15577c478bd9Sstevel@tonic-gate /* 15587c478bd9Sstevel@tonic-gate * the lba address cannot be expressed in CHS value 15597c478bd9Sstevel@tonic-gate * so store the maximum CHS field values in the CHS fields. 15607c478bd9Sstevel@tonic-gate */ 15617c478bd9Sstevel@tonic-gate cy = MAX_CYL + 1; 15627c478bd9Sstevel@tonic-gate hd = MAX_HEAD; 15637c478bd9Sstevel@tonic-gate sc = MAX_SECT; 15647c478bd9Sstevel@tonic-gate } else { 15657c478bd9Sstevel@tonic-gate cy = lba / hba_sectors / hba_heads; 15667c478bd9Sstevel@tonic-gate hd = lba / hba_sectors % hba_heads; 15677c478bd9Sstevel@tonic-gate sc = lba % hba_sectors + 1; 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate Table[ti].begcyl = cy & 0xff; 1570bb16350dSlclee Table[ti].beghead = (uchar_t)hd; 1571bb16350dSlclee Table[ti].begsect = (uchar_t)(((cy >> 2) & 0xc0) | sc); 15727c478bd9Sstevel@tonic-gate 15737c478bd9Sstevel@tonic-gate /* 15747c478bd9Sstevel@tonic-gate * This code is identical to the code above 15757c478bd9Sstevel@tonic-gate * except that it works on ending CHS values 15767c478bd9Sstevel@tonic-gate */ 15777c478bd9Sstevel@tonic-gate lba = (uint32_t)(Table[ti].relsect + Table[ti].numsect - 1); 15787c478bd9Sstevel@tonic-gate if (lba >= hba_heads * hba_sectors * MAX_CYL) { 15797c478bd9Sstevel@tonic-gate cy = MAX_CYL + 1; 15807c478bd9Sstevel@tonic-gate hd = MAX_HEAD; 15817c478bd9Sstevel@tonic-gate sc = MAX_SECT; 15827c478bd9Sstevel@tonic-gate } else { 15837c478bd9Sstevel@tonic-gate cy = lba / hba_sectors / hba_heads; 15847c478bd9Sstevel@tonic-gate hd = lba / hba_sectors % hba_heads; 15857c478bd9Sstevel@tonic-gate sc = lba % hba_sectors + 1; 15867c478bd9Sstevel@tonic-gate } 15877c478bd9Sstevel@tonic-gate Table[ti].endcyl = cy & 0xff; 1588bb16350dSlclee Table[ti].endhead = (uchar_t)hd; 1589bb16350dSlclee Table[ti].endsect = (uchar_t)(((cy >> 2) & 0xc0) | sc); 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate /* 15937c478bd9Sstevel@tonic-gate * insert_tbl 15947c478bd9Sstevel@tonic-gate * Insert entry into fdisk table. Check all user-supplied values 15957c478bd9Sstevel@tonic-gate * for the entry, but not the validity relative to other table 15967c478bd9Sstevel@tonic-gate * entries! 15977c478bd9Sstevel@tonic-gate */ 1598bb16350dSlclee static int 1599bb16350dSlclee insert_tbl( 1600bb16350dSlclee int id, int act, 1601bb16350dSlclee int bhead, int bsect, int bcyl, 1602bb16350dSlclee int ehead, int esect, int ecyl, 1603*342440ecSPrasad Singamsetty uint32_t rsect, uint32_t numsect) 16047c478bd9Sstevel@tonic-gate { 16057c478bd9Sstevel@tonic-gate int i; 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate /* validate partition size */ 1608*342440ecSPrasad Singamsetty if (((diskaddr_t)rsect + numsect) > dev_capacity) { 1609bb16350dSlclee (void) fprintf(stderr, 16107c478bd9Sstevel@tonic-gate "fdisk: Partition table exceeds the size of the disk.\n"); 16117c478bd9Sstevel@tonic-gate return (-1); 16127c478bd9Sstevel@tonic-gate } 16137c478bd9Sstevel@tonic-gate 1614*342440ecSPrasad Singamsetty 16157c478bd9Sstevel@tonic-gate /* find UNUSED partition table entry */ 16167c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 16177c478bd9Sstevel@tonic-gate if (Table[i].systid == UNUSED) { 16187c478bd9Sstevel@tonic-gate break; 16197c478bd9Sstevel@tonic-gate } 16207c478bd9Sstevel@tonic-gate } 16217c478bd9Sstevel@tonic-gate if (i >= FD_NUMPART) { 1622bb16350dSlclee (void) fprintf(stderr, "fdisk: Partition table is full.\n"); 16237c478bd9Sstevel@tonic-gate return (-1); 16247c478bd9Sstevel@tonic-gate } 16257c478bd9Sstevel@tonic-gate 16267c478bd9Sstevel@tonic-gate 1627bb16350dSlclee Table[i].systid = (uchar_t)id; 1628bb16350dSlclee Table[i].bootid = (uchar_t)act; 16297c478bd9Sstevel@tonic-gate Table[i].numsect = lel(numsect); 16307c478bd9Sstevel@tonic-gate Table[i].relsect = lel(rsect); 16317c478bd9Sstevel@tonic-gate 16327c478bd9Sstevel@tonic-gate /* 16337c478bd9Sstevel@tonic-gate * If we have been called with a valid geometry, use it 16347c478bd9Sstevel@tonic-gate * valid means non-zero values that fit in the BIOS fields 16357c478bd9Sstevel@tonic-gate */ 16367c478bd9Sstevel@tonic-gate if (0 < bsect && bsect <= MAX_SECT && 16377c478bd9Sstevel@tonic-gate 0 <= bhead && bhead <= MAX_HEAD && 16387c478bd9Sstevel@tonic-gate 0 < esect && esect <= MAX_SECT && 16397c478bd9Sstevel@tonic-gate 0 <= ehead && ehead <= MAX_HEAD) { 16407c478bd9Sstevel@tonic-gate if (bcyl > MAX_CYL) 16417c478bd9Sstevel@tonic-gate bcyl = MAX_CYL + 1; 16427c478bd9Sstevel@tonic-gate if (ecyl > MAX_CYL) 16437c478bd9Sstevel@tonic-gate ecyl = MAX_CYL + 1; 16447c478bd9Sstevel@tonic-gate Table[i].begcyl = bcyl & 0xff; 16457c478bd9Sstevel@tonic-gate Table[i].endcyl = ecyl & 0xff; 1646bb16350dSlclee Table[i].beghead = (uchar_t)bhead; 1647bb16350dSlclee Table[i].endhead = (uchar_t)ehead; 1648bb16350dSlclee Table[i].begsect = (uchar_t)(((bcyl >> 2) & 0xc0) | bsect); 16497c478bd9Sstevel@tonic-gate Table[i].endsect = ((ecyl >> 2) & 0xc0) | esect; 16507c478bd9Sstevel@tonic-gate } else { 16517c478bd9Sstevel@tonic-gate 16527c478bd9Sstevel@tonic-gate /* 16537c478bd9Sstevel@tonic-gate * The specified values are invalid, 16547c478bd9Sstevel@tonic-gate * so calculate the values based on hba_heads, hba_sectors 16557c478bd9Sstevel@tonic-gate */ 16567c478bd9Sstevel@tonic-gate Set_Table_CHS_Values(i); 16577c478bd9Sstevel@tonic-gate } 16587c478bd9Sstevel@tonic-gate 16597c478bd9Sstevel@tonic-gate /* 16607c478bd9Sstevel@tonic-gate * return partition index 16617c478bd9Sstevel@tonic-gate */ 16627c478bd9Sstevel@tonic-gate return (i); 16637c478bd9Sstevel@tonic-gate } 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate /* 16667c478bd9Sstevel@tonic-gate * verify_tbl 16677c478bd9Sstevel@tonic-gate * Verify that no partition entries overlap or exceed the size of 16687c478bd9Sstevel@tonic-gate * the disk. 16697c478bd9Sstevel@tonic-gate */ 1670bb16350dSlclee static int 1671bb16350dSlclee verify_tbl(void) 16727c478bd9Sstevel@tonic-gate { 1673*342440ecSPrasad Singamsetty uint32_t i, j, rsect, numsect; 16747c478bd9Sstevel@tonic-gate int noMoreParts = 0; 16757c478bd9Sstevel@tonic-gate int numParts = 0; 16767c478bd9Sstevel@tonic-gate 16777c478bd9Sstevel@tonic-gate /* Make sure new entry does not overlap an existing entry */ 1678bb16350dSlclee for (i = 0; i < FD_NUMPART - 1; i++) { 16797c478bd9Sstevel@tonic-gate if (Table[i].systid != UNUSED) { 16807c478bd9Sstevel@tonic-gate numParts++; 16817c478bd9Sstevel@tonic-gate /* 16827c478bd9Sstevel@tonic-gate * No valid partitions allowed after an UNUSED or 16837c478bd9Sstevel@tonic-gate * EFI_PMBR part 16847c478bd9Sstevel@tonic-gate */ 16857c478bd9Sstevel@tonic-gate if (noMoreParts) { 16867c478bd9Sstevel@tonic-gate return (-1); 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate /* 16907c478bd9Sstevel@tonic-gate * EFI_PMBR partitions must be the only partition 16917c478bd9Sstevel@tonic-gate * and must be Table entry 0 16927c478bd9Sstevel@tonic-gate */ 16937c478bd9Sstevel@tonic-gate if (Table[i].systid == EFI_PMBR) { 16947c478bd9Sstevel@tonic-gate if (i == 0) { 16957c478bd9Sstevel@tonic-gate noMoreParts = 1; 16967c478bd9Sstevel@tonic-gate } else { 16977c478bd9Sstevel@tonic-gate return (-1); 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate 17007c478bd9Sstevel@tonic-gate if (Table[i].relsect != 1) { 1701bb16350dSlclee (void) fprintf(stderr, "ERROR: " 17027c478bd9Sstevel@tonic-gate "Invalid starting sector " 17037c478bd9Sstevel@tonic-gate "for EFI_PMBR partition:\n" 17047c478bd9Sstevel@tonic-gate "relsect %d " 17057c478bd9Sstevel@tonic-gate "(should be 1)\n", 17067c478bd9Sstevel@tonic-gate Table[i].relsect); 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate return (-1); 17097c478bd9Sstevel@tonic-gate } 17107c478bd9Sstevel@tonic-gate 17111237e847Slclee if (Table[i].numsect != dev_capacity - 1) { 1712bb16350dSlclee (void) fprintf(stderr, "ERROR: " 17137c478bd9Sstevel@tonic-gate "EFI_PMBR partition must " 17147c478bd9Sstevel@tonic-gate "encompass the entire " 1715bb16350dSlclee "disk.\n numsect %d - " 17161237e847Slclee "actual %llu\n", 17177c478bd9Sstevel@tonic-gate Table[i].numsect, 17181237e847Slclee dev_capacity - 1); 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate return (-1); 17217c478bd9Sstevel@tonic-gate } 17227c478bd9Sstevel@tonic-gate } 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate /* make sure the partition isn't larger than the disk */ 17257c478bd9Sstevel@tonic-gate rsect = lel(Table[i].relsect); 17267c478bd9Sstevel@tonic-gate numsect = lel(Table[i].numsect); 1727*342440ecSPrasad Singamsetty 1728*342440ecSPrasad Singamsetty if ((((diskaddr_t)rsect + numsect) > dev_capacity) || 1729*342440ecSPrasad Singamsetty (((diskaddr_t)rsect + numsect) > DK_MAX_2TB)) { 17307c478bd9Sstevel@tonic-gate return (-1); 17317c478bd9Sstevel@tonic-gate } 17327c478bd9Sstevel@tonic-gate 1733bb16350dSlclee for (j = i + 1; j < FD_NUMPART; j++) { 17347c478bd9Sstevel@tonic-gate if (Table[j].systid != UNUSED) { 1735*342440ecSPrasad Singamsetty uint32_t t_relsect = 1736*342440ecSPrasad Singamsetty lel(Table[j].relsect); 1737*342440ecSPrasad Singamsetty uint32_t t_numsect = 1738*342440ecSPrasad Singamsetty lel(Table[j].numsect); 17397c478bd9Sstevel@tonic-gate 17407c478bd9Sstevel@tonic-gate if (noMoreParts) { 1741bb16350dSlclee (void) fprintf(stderr, 17427c478bd9Sstevel@tonic-gate "Cannot add partition to " 17437c478bd9Sstevel@tonic-gate "table; no more partitions " 17447c478bd9Sstevel@tonic-gate "allowed\n"); 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate if (io_debug) { 1747bb16350dSlclee (void) fprintf(stderr, 17487c478bd9Sstevel@tonic-gate "DEBUG: Current " 17497c478bd9Sstevel@tonic-gate "partition:\t" 17507c478bd9Sstevel@tonic-gate "%d:%d:%d:%d:%d:" 1751bb16350dSlclee "%d:%d:%d:%d:%d\n" 17527c478bd9Sstevel@tonic-gate " Next " 17537c478bd9Sstevel@tonic-gate "partition:\t\t" 17547c478bd9Sstevel@tonic-gate "%d:%d:%d:%d:%d:" 1755bb16350dSlclee "%d:%d:%d:%d:%d\n", 17567c478bd9Sstevel@tonic-gate Table[i].systid, 17577c478bd9Sstevel@tonic-gate Table[i].bootid, 17587c478bd9Sstevel@tonic-gate Table[i].begcyl, 17597c478bd9Sstevel@tonic-gate Table[i].beghead, 17607c478bd9Sstevel@tonic-gate Table[i].begsect, 17617c478bd9Sstevel@tonic-gate Table[i].endcyl, 17627c478bd9Sstevel@tonic-gate Table[i].endhead, 17637c478bd9Sstevel@tonic-gate Table[i].endsect, 17647c478bd9Sstevel@tonic-gate Table[i].relsect, 17657c478bd9Sstevel@tonic-gate Table[i].numsect, 17667c478bd9Sstevel@tonic-gate Table[j].systid, 17677c478bd9Sstevel@tonic-gate Table[j].bootid, 17687c478bd9Sstevel@tonic-gate Table[j].begcyl, 17697c478bd9Sstevel@tonic-gate Table[j].beghead, 17707c478bd9Sstevel@tonic-gate Table[j].begsect, 17717c478bd9Sstevel@tonic-gate Table[j].endcyl, 17727c478bd9Sstevel@tonic-gate Table[j].endhead, 17737c478bd9Sstevel@tonic-gate Table[j].endsect, 17747c478bd9Sstevel@tonic-gate Table[j].relsect, 17757c478bd9Sstevel@tonic-gate Table[j].numsect); 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate return (-1); 17797c478bd9Sstevel@tonic-gate } 17807c478bd9Sstevel@tonic-gate if ((rsect >= 17817c478bd9Sstevel@tonic-gate (t_relsect + t_numsect)) || 1782bb16350dSlclee ((rsect + numsect) <= t_relsect)) { 17837c478bd9Sstevel@tonic-gate continue; 17847c478bd9Sstevel@tonic-gate } else { 1785bb16350dSlclee (void) fprintf(stderr, "ERROR: " 17867c478bd9Sstevel@tonic-gate "current partition overlaps" 17877c478bd9Sstevel@tonic-gate " following partition\n"); 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate return (-1); 17907c478bd9Sstevel@tonic-gate } 17917c478bd9Sstevel@tonic-gate } 17927c478bd9Sstevel@tonic-gate } 17937c478bd9Sstevel@tonic-gate } else { 17947c478bd9Sstevel@tonic-gate noMoreParts = 1; 17957c478bd9Sstevel@tonic-gate } 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate if (Table[i].systid != UNUSED) { 17987c478bd9Sstevel@tonic-gate if (noMoreParts || 1799*342440ecSPrasad Singamsetty (((diskaddr_t)lel(Table[i].relsect) + 1800*342440ecSPrasad Singamsetty lel(Table[i].numsect)) > dev_capacity) || 1801*342440ecSPrasad Singamsetty (((diskaddr_t)lel(Table[i].relsect) + 1802*342440ecSPrasad Singamsetty lel(Table[i].numsect)) > DK_MAX_2TB)) { 18037c478bd9Sstevel@tonic-gate return (-1); 18047c478bd9Sstevel@tonic-gate } 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate return (numParts); 18087c478bd9Sstevel@tonic-gate } 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate /* 18117c478bd9Sstevel@tonic-gate * pars_fdisk 18127c478bd9Sstevel@tonic-gate * Parse user-supplied data to set up fdisk partitions 18137c478bd9Sstevel@tonic-gate * (-A, -D, -F). 18147c478bd9Sstevel@tonic-gate */ 1815bb16350dSlclee static int 1816bb16350dSlclee pars_fdisk( 1817bb16350dSlclee char *line, 1818bb16350dSlclee int *id, int *act, 1819bb16350dSlclee int *bhead, int *bsect, int *bcyl, 1820bb16350dSlclee int *ehead, int *esect, int *ecyl, 1821*342440ecSPrasad Singamsetty uint32_t *rsect, uint32_t *numsect) 18227c478bd9Sstevel@tonic-gate { 18237c478bd9Sstevel@tonic-gate int i; 18247c478bd9Sstevel@tonic-gate if (line[0] == '\0' || line[0] == '\n' || line[0] == '*') 18251237e847Slclee return (1); 18267c478bd9Sstevel@tonic-gate line[strlen(line)] = '\0'; 18277c478bd9Sstevel@tonic-gate for (i = 0; i < strlen(line); i++) { 18287c478bd9Sstevel@tonic-gate if (line[i] == '\0') { 18297c478bd9Sstevel@tonic-gate break; 18307c478bd9Sstevel@tonic-gate } else if (line[i] == ':') { 18317c478bd9Sstevel@tonic-gate line[i] = ' '; 18327c478bd9Sstevel@tonic-gate } 18337c478bd9Sstevel@tonic-gate } 1834*342440ecSPrasad Singamsetty if (sscanf(line, "%d %d %d %d %d %d %d %d %u %u", 18357c478bd9Sstevel@tonic-gate id, act, bhead, bsect, bcyl, ehead, esect, ecyl, 18367c478bd9Sstevel@tonic-gate rsect, numsect) != 10) { 18377c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Syntax error:\n \"%s\".\n", line); 18387c478bd9Sstevel@tonic-gate exit(1); 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate return (0); 18417c478bd9Sstevel@tonic-gate } 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate /* 18447c478bd9Sstevel@tonic-gate * validate_part 18457c478bd9Sstevel@tonic-gate * Validate that a new partition does not start at sector 0. Only UNUSED 18467c478bd9Sstevel@tonic-gate * partitions and previously existing partitions are allowed to start at 0. 18477c478bd9Sstevel@tonic-gate */ 1848bb16350dSlclee static int 1849*342440ecSPrasad Singamsetty validate_part(int id, uint32_t rsect, uint32_t numsect) 18507c478bd9Sstevel@tonic-gate { 18517c478bd9Sstevel@tonic-gate int i; 18527c478bd9Sstevel@tonic-gate if ((id != UNUSED) && (rsect == 0)) { 18537c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 18547c478bd9Sstevel@tonic-gate if ((Old_Table[i].systid == id) && 18557c478bd9Sstevel@tonic-gate (Old_Table[i].relsect == lel(rsect)) && 18561237e847Slclee (Old_Table[i].numsect == lel(numsect))) 18571237e847Slclee return (0); 18587c478bd9Sstevel@tonic-gate } 1859bb16350dSlclee (void) fprintf(stderr, 1860bb16350dSlclee "New partition cannot start at sector 0\n"); 18617c478bd9Sstevel@tonic-gate return (-1); 18627c478bd9Sstevel@tonic-gate } 18637c478bd9Sstevel@tonic-gate return (0); 18647c478bd9Sstevel@tonic-gate } 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate /* 18677c478bd9Sstevel@tonic-gate * stage0 18687c478bd9Sstevel@tonic-gate * Print out interactive menu and process user input. 18697c478bd9Sstevel@tonic-gate */ 1870bb16350dSlclee static void 1871bb16350dSlclee stage0(void) 18727c478bd9Sstevel@tonic-gate { 1873bb16350dSlclee dispmenu(); 1874bb16350dSlclee for (;;) { 1875bb16350dSlclee (void) printf(Q_LINE); 1876bb16350dSlclee (void) printf("Enter Selection: "); 1877bb16350dSlclee (void) gets(s); 18787c478bd9Sstevel@tonic-gate rm_blanks(s); 18797c478bd9Sstevel@tonic-gate while (!((s[0] > '0') && (s[0] < '7') && (s[1] == 0))) { 1880bb16350dSlclee (void) printf(E_LINE); /* Clear any previous error */ 1881bb16350dSlclee (void) printf( 1882bb16350dSlclee "Enter a one-digit number between 1 and 6."); 1883bb16350dSlclee (void) printf(Q_LINE); 1884bb16350dSlclee (void) printf("Enter Selection: "); 1885bb16350dSlclee (void) gets(s); 18867c478bd9Sstevel@tonic-gate rm_blanks(s); 18877c478bd9Sstevel@tonic-gate } 1888bb16350dSlclee (void) printf(E_LINE); 18897c478bd9Sstevel@tonic-gate switch (s[0]) { 18907c478bd9Sstevel@tonic-gate case '1': 18917c478bd9Sstevel@tonic-gate if (pcreate() == -1) 18927c478bd9Sstevel@tonic-gate return; 18937c478bd9Sstevel@tonic-gate break; 18947c478bd9Sstevel@tonic-gate case '2': 18957c478bd9Sstevel@tonic-gate if (pchange() == -1) 18967c478bd9Sstevel@tonic-gate return; 18977c478bd9Sstevel@tonic-gate break; 18987c478bd9Sstevel@tonic-gate case '3': 18997c478bd9Sstevel@tonic-gate if (pdelete() == -1) 19007c478bd9Sstevel@tonic-gate return; 19017c478bd9Sstevel@tonic-gate break; 19027c478bd9Sstevel@tonic-gate case '4': 19037c478bd9Sstevel@tonic-gate if (ppartid() == -1) 19047c478bd9Sstevel@tonic-gate return; 19057c478bd9Sstevel@tonic-gate break; 19067c478bd9Sstevel@tonic-gate case '5': 19077c478bd9Sstevel@tonic-gate /* update disk partition table, if changed */ 19087c478bd9Sstevel@tonic-gate if (TableChanged() == 1) { 19097c478bd9Sstevel@tonic-gate copy_Table_to_Bootblk(); 19107c478bd9Sstevel@tonic-gate dev_mboot_write(0, Bootsect, sectsiz); 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate /* 19137c478bd9Sstevel@tonic-gate * If the VTOC table is wrong fix it 19147c478bd9Sstevel@tonic-gate * (truncate only) 19157c478bd9Sstevel@tonic-gate */ 19167c478bd9Sstevel@tonic-gate if (io_adjt) { 19177c478bd9Sstevel@tonic-gate fix_slice(); 19187c478bd9Sstevel@tonic-gate } 1919bb16350dSlclee (void) close(Dev); 19207c478bd9Sstevel@tonic-gate exit(0); 1921bb16350dSlclee /* FALLTHRU */ 19227c478bd9Sstevel@tonic-gate case '6': 19237c478bd9Sstevel@tonic-gate /* 19247c478bd9Sstevel@tonic-gate * If the VTOC table is wrong fix it 19257c478bd9Sstevel@tonic-gate * (truncate only) 19267c478bd9Sstevel@tonic-gate */ 19277c478bd9Sstevel@tonic-gate if (io_adjt) { 19287c478bd9Sstevel@tonic-gate fix_slice(); 19297c478bd9Sstevel@tonic-gate } 1930bb16350dSlclee (void) close(Dev); 19317c478bd9Sstevel@tonic-gate exit(0); 1932bb16350dSlclee /* FALLTHRU */ 19337c478bd9Sstevel@tonic-gate default: 19347c478bd9Sstevel@tonic-gate break; 19357c478bd9Sstevel@tonic-gate } 19367c478bd9Sstevel@tonic-gate copy_Table_to_Bootblk(); 19377c478bd9Sstevel@tonic-gate disptbl(); 1938bb16350dSlclee dispmenu(); 19397c478bd9Sstevel@tonic-gate } 19407c478bd9Sstevel@tonic-gate } 19417c478bd9Sstevel@tonic-gate 19427c478bd9Sstevel@tonic-gate /* 19437c478bd9Sstevel@tonic-gate * pcreate 19447c478bd9Sstevel@tonic-gate * Create partition entry in the table (interactive mode). 19457c478bd9Sstevel@tonic-gate */ 1946bb16350dSlclee static int 1947bb16350dSlclee pcreate(void) 19487c478bd9Sstevel@tonic-gate { 1949bb16350dSlclee uchar_t tsystid = 'z'; 19507c478bd9Sstevel@tonic-gate int i, j; 1951*342440ecSPrasad Singamsetty uint32_t numsect; 19527c478bd9Sstevel@tonic-gate int retCode = 0; 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate i = 0; 1955bb16350dSlclee for (;;) { 19567c478bd9Sstevel@tonic-gate if (i == FD_NUMPART) { 1957bb16350dSlclee (void) printf(E_LINE); 1958bb16350dSlclee (void) printf( 1959bb16350dSlclee "The partition table is full!\n" 1960bb16350dSlclee "You must delete a partition before creating" 19617c478bd9Sstevel@tonic-gate " a new one.\n"); 19627c478bd9Sstevel@tonic-gate return (-1); 19637c478bd9Sstevel@tonic-gate } 19647c478bd9Sstevel@tonic-gate if (Table[i].systid == UNUSED) { 19657c478bd9Sstevel@tonic-gate break; 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate i++; 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate 1970*342440ecSPrasad Singamsetty numsect = 0; 19717c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 19727c478bd9Sstevel@tonic-gate if (Table[i].systid != UNUSED) { 1973*342440ecSPrasad Singamsetty numsect += lel(Table[i].numsect); 19747c478bd9Sstevel@tonic-gate } 1975*342440ecSPrasad Singamsetty if (numsect >= chs_capacity) { 1976bb16350dSlclee (void) printf(E_LINE); 1977bb16350dSlclee (void) printf("There is no more room on the disk for" 19787c478bd9Sstevel@tonic-gate " another partition.\n"); 1979bb16350dSlclee (void) printf( 1980bb16350dSlclee "You must delete a partition before creating" 19817c478bd9Sstevel@tonic-gate " a new one.\n"); 19827c478bd9Sstevel@tonic-gate return (-1); 19837c478bd9Sstevel@tonic-gate } 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate while (tsystid == 'z') { 1986*342440ecSPrasad Singamsetty 1987*342440ecSPrasad Singamsetty /* 1988*342440ecSPrasad Singamsetty * The question here is expanding to more than what is 1989*342440ecSPrasad Singamsetty * allocated for question lines (Q_LINE) which garbles 1990*342440ecSPrasad Singamsetty * at least warning line. Clearing warning line as workaround 1991*342440ecSPrasad Singamsetty * for now. 1992*342440ecSPrasad Singamsetty */ 1993*342440ecSPrasad Singamsetty 1994*342440ecSPrasad Singamsetty (void) printf(W_LINE); 1995bb16350dSlclee (void) printf(Q_LINE); 1996bb16350dSlclee (void) printf( 1997bb16350dSlclee "Select the partition type to create:\n" 1998bb16350dSlclee " 1=SOLARIS2 2=UNIX 3=PCIXOS 4=Other\n" 1999bb16350dSlclee " 5=DOS12 6=DOS16 7=DOSEXT 8=DOSBIG\n" 2000bb16350dSlclee " 9=DOS16LBA A=x86 Boot B=Diagnostic C=FAT32\n" 2001bb16350dSlclee " D=FAT32LBA E=DOSEXTLBA F=EFI 0=Exit? "); 2002bb16350dSlclee (void) gets(s); 20037c478bd9Sstevel@tonic-gate rm_blanks(s); 20047c478bd9Sstevel@tonic-gate if (s[1] != 0) { 2005bb16350dSlclee (void) printf(E_LINE); 2006bb16350dSlclee (void) printf("Invalid selection, try again."); 20077c478bd9Sstevel@tonic-gate continue; 20087c478bd9Sstevel@tonic-gate } 20097c478bd9Sstevel@tonic-gate switch (s[0]) { 20107c478bd9Sstevel@tonic-gate case '0': /* exit */ 20111237e847Slclee (void) printf(E_LINE); 20121237e847Slclee return (-1); 20137c478bd9Sstevel@tonic-gate case '1': /* Solaris partition */ 20141237e847Slclee tsystid = SUNIXOS2; 20151237e847Slclee break; 20167c478bd9Sstevel@tonic-gate case '2': /* UNIX partition */ 20171237e847Slclee tsystid = UNIXOS; 20181237e847Slclee break; 20197c478bd9Sstevel@tonic-gate case '3': /* PCIXOS partition */ 20201237e847Slclee tsystid = PCIXOS; 20211237e847Slclee break; 20227c478bd9Sstevel@tonic-gate case '4': /* OTHEROS System partition */ 20231237e847Slclee tsystid = OTHEROS; 20241237e847Slclee break; 20257c478bd9Sstevel@tonic-gate case '5': 20261237e847Slclee tsystid = DOSOS12; /* DOS 12 bit fat */ 20271237e847Slclee break; 20287c478bd9Sstevel@tonic-gate case '6': 20291237e847Slclee tsystid = DOSOS16; /* DOS 16 bit fat */ 20301237e847Slclee break; 20317c478bd9Sstevel@tonic-gate case '7': 20321237e847Slclee tsystid = EXTDOS; 20331237e847Slclee break; 20347c478bd9Sstevel@tonic-gate case '8': 20351237e847Slclee tsystid = DOSHUGE; 20361237e847Slclee break; 20377c478bd9Sstevel@tonic-gate case '9': 20381237e847Slclee tsystid = FDISK_FAT95; /* FAT16, need extended int13 */ 20391237e847Slclee break; 20407c478bd9Sstevel@tonic-gate case 'a': /* x86 Boot partition */ 20417c478bd9Sstevel@tonic-gate case 'A': 20421237e847Slclee tsystid = X86BOOT; 20431237e847Slclee break; 20447c478bd9Sstevel@tonic-gate case 'b': /* Diagnostic boot partition */ 20457c478bd9Sstevel@tonic-gate case 'B': 20461237e847Slclee tsystid = DIAGPART; 20471237e847Slclee break; 20487c478bd9Sstevel@tonic-gate case 'c': /* FAT32 */ 20497c478bd9Sstevel@tonic-gate case 'C': 20501237e847Slclee tsystid = FDISK_WINDOWS; 20511237e847Slclee break; 20527c478bd9Sstevel@tonic-gate case 'd': /* FAT32 and need extended int13 */ 20537c478bd9Sstevel@tonic-gate case 'D': 20541237e847Slclee tsystid = FDISK_EXT_WIN; 20551237e847Slclee break; 20567c478bd9Sstevel@tonic-gate case 'e': /* Extended partition, need extended int13 */ 20577c478bd9Sstevel@tonic-gate case 'E': 20581237e847Slclee tsystid = FDISK_EXTLBA; 20591237e847Slclee break; 20607c478bd9Sstevel@tonic-gate case 'f': 20617c478bd9Sstevel@tonic-gate case 'F': 20621237e847Slclee tsystid = EFI_PMBR; 20631237e847Slclee break; 20647c478bd9Sstevel@tonic-gate default: 20651237e847Slclee (void) printf(E_LINE); 20661237e847Slclee (void) printf("Invalid selection, try again."); 20671237e847Slclee continue; 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate } 20707c478bd9Sstevel@tonic-gate 2071bb16350dSlclee (void) printf(E_LINE); 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate if (tsystid != EFI_PMBR) { 2074*342440ecSPrasad Singamsetty (void) printf(W_LINE); 2075*342440ecSPrasad Singamsetty if ((dev_capacity > DK_MAX_2TB)) 2076*342440ecSPrasad Singamsetty (void) printf("WARNING: Disk is larger than 2 TB. " 2077*342440ecSPrasad Singamsetty "Upper limit is 2 TB for non-EFI partition ID\n"); 2078*342440ecSPrasad Singamsetty 20797c478bd9Sstevel@tonic-gate /* create the new partition */ 20807c478bd9Sstevel@tonic-gate i = specify(tsystid); 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate if (i != -1) { 20837c478bd9Sstevel@tonic-gate /* see if it should be the active partition */ 2084bb16350dSlclee (void) printf(E_LINE); 2085bb16350dSlclee (void) printf(Q_LINE); 20867c478bd9Sstevel@tonic-gate 2087bb16350dSlclee (void) printf( 2088bb16350dSlclee "Should this become the active partition? If " 2089bb16350dSlclee "yes, it will be activated\n" 2090bb16350dSlclee "each time the computer is reset or turned on.\n" 2091bb16350dSlclee "Please type \"y\" or \"n\". "); 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate if (yesno()) { 2094bb16350dSlclee (void) printf(E_LINE); 20957c478bd9Sstevel@tonic-gate for (j = 0; j < FD_NUMPART; j++) { 20967c478bd9Sstevel@tonic-gate if (j == i) { 20977c478bd9Sstevel@tonic-gate Table[j].bootid = ACTIVE; 2098bb16350dSlclee (void) printf(E_LINE); 2099bb16350dSlclee (void) printf( 2100bb16350dSlclee "Partition %d is now " 21017c478bd9Sstevel@tonic-gate "the active partition.", 2102bb16350dSlclee j + 1); 21037c478bd9Sstevel@tonic-gate } else { 21047c478bd9Sstevel@tonic-gate Table[j].bootid = 0; 21057c478bd9Sstevel@tonic-gate } 21067c478bd9Sstevel@tonic-gate } 21077c478bd9Sstevel@tonic-gate } else { 21087c478bd9Sstevel@tonic-gate Table[i].bootid = 0; 21097c478bd9Sstevel@tonic-gate } 21107c478bd9Sstevel@tonic-gate 21117c478bd9Sstevel@tonic-gate /* set up the return code */ 21127c478bd9Sstevel@tonic-gate i = 1; 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate } else { 21157c478bd9Sstevel@tonic-gate /* 21167c478bd9Sstevel@tonic-gate * partitions of type EFI_PMBR must be the only partitions in 21177c478bd9Sstevel@tonic-gate * the table 21187c478bd9Sstevel@tonic-gate * 21197c478bd9Sstevel@tonic-gate * First, make sure there were no errors the table is 21207c478bd9Sstevel@tonic-gate * empty 21217c478bd9Sstevel@tonic-gate */ 21227c478bd9Sstevel@tonic-gate retCode = verify_tbl(); 21237c478bd9Sstevel@tonic-gate 21247c478bd9Sstevel@tonic-gate if (retCode < 0) { 2125bb16350dSlclee (void) fprintf(stderr, 21267c478bd9Sstevel@tonic-gate "fdisk: Cannot create EFI partition table; \n" 21277c478bd9Sstevel@tonic-gate "current partition table is invalid.\n"); 21287c478bd9Sstevel@tonic-gate return (-1); 21297c478bd9Sstevel@tonic-gate } else if (retCode > 0) { 2130bb16350dSlclee (void) printf( 2131bb16350dSlclee "An EFI partition must be the only partition on " 2132bb16350dSlclee "disk. You may manually delete existing\n" 2133bb16350dSlclee "partitions, or fdisk can do it.\n" 2134bb16350dSlclee "Do you want fdisk to destroy existing " 2135bb16350dSlclee "partitions?\n" 2136bb16350dSlclee "Please type \"y\" or \"n\". "); 21377c478bd9Sstevel@tonic-gate 21387c478bd9Sstevel@tonic-gate if (yesno()) { 21397c478bd9Sstevel@tonic-gate nulltbl(); 21407c478bd9Sstevel@tonic-gate } else { 21417c478bd9Sstevel@tonic-gate return (-1); 21427c478bd9Sstevel@tonic-gate } 21437c478bd9Sstevel@tonic-gate } 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate /* create the table entry - i should be 0 */ 2146*342440ecSPrasad Singamsetty i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 1, 2147*342440ecSPrasad Singamsetty (dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB: 2148*342440ecSPrasad Singamsetty (dev_capacity - 1)); 21497c478bd9Sstevel@tonic-gate 21507c478bd9Sstevel@tonic-gate if (i != 0) { 2151bb16350dSlclee (void) printf("Error creating EFI partition!!!\n"); 21527c478bd9Sstevel@tonic-gate i = -1; 21537c478bd9Sstevel@tonic-gate } else { 21547c478bd9Sstevel@tonic-gate 21557c478bd9Sstevel@tonic-gate /* EFI partitions are currently never active */ 21567c478bd9Sstevel@tonic-gate Table[i].bootid = 0; 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate /* set up the return code */ 21597c478bd9Sstevel@tonic-gate i = 1; 21607c478bd9Sstevel@tonic-gate } 21617c478bd9Sstevel@tonic-gate } 21627c478bd9Sstevel@tonic-gate 21637c478bd9Sstevel@tonic-gate return (i); 21647c478bd9Sstevel@tonic-gate } 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate /* 21677c478bd9Sstevel@tonic-gate * specify 21687c478bd9Sstevel@tonic-gate * Query the user to specify the size of the new partition in 21697c478bd9Sstevel@tonic-gate * terms of percentage of the disk or by specifying the starting 21707c478bd9Sstevel@tonic-gate * cylinder and length in cylinders. 21717c478bd9Sstevel@tonic-gate */ 2172bb16350dSlclee static int 2173bb16350dSlclee specify(uchar_t tsystid) 21747c478bd9Sstevel@tonic-gate { 21751237e847Slclee int i, j, percent = -1; 2176*342440ecSPrasad Singamsetty int cyl, cylen; 2177*342440ecSPrasad Singamsetty diskaddr_t first_free, size_free; 2178*342440ecSPrasad Singamsetty diskaddr_t max_free; 21791237e847Slclee int cyl_size; 21807c478bd9Sstevel@tonic-gate struct ipart *partition[FD_NUMPART]; 21817c478bd9Sstevel@tonic-gate 21821237e847Slclee cyl_size = heads * sectors; 21831237e847Slclee 21841237e847Slclee /* 21851237e847Slclee * make a local copy of the partition table 21861237e847Slclee * and sort it into relsect order 21871237e847Slclee */ 21881237e847Slclee for (i = 0; i < FD_NUMPART; i++) 21891237e847Slclee partition[i] = &Table[i]; 21901237e847Slclee 21911237e847Slclee for (i = 0; i < FD_NUMPART - 1; i++) { 21921237e847Slclee if (partition[i]->systid == UNUSED) 21931237e847Slclee break; 21941237e847Slclee for (j = i + 1; j < FD_NUMPART; j++) { 21951237e847Slclee if (partition[j]->systid == UNUSED) 21961237e847Slclee break; 21971237e847Slclee if (lel(partition[j]->relsect) < 21981237e847Slclee lel(partition[i]->relsect)) { 21991237e847Slclee struct ipart *temp = partition[i]; 22001237e847Slclee partition[i] = partition[j]; 22011237e847Slclee partition[j] = temp; 22021237e847Slclee } 22031237e847Slclee } 22041237e847Slclee } 22051237e847Slclee 2206*342440ecSPrasad Singamsetty 2207bb16350dSlclee (void) printf(Q_LINE); 2208bb16350dSlclee (void) printf( 2209bb16350dSlclee "Specify the percentage of disk to use for this partition\n" 2210bb16350dSlclee "(or type \"c\" to specify the size in cylinders). "); 2211bb16350dSlclee (void) gets(s); 22127c478bd9Sstevel@tonic-gate rm_blanks(s); 22137c478bd9Sstevel@tonic-gate if (s[0] != 'c') { /* Specify size in percentage of disk */ 22141237e847Slclee i = 0; 22151237e847Slclee while (s[i] != '\0') { 22161237e847Slclee if (s[i] < '0' || s[i] > '9') { 22171237e847Slclee (void) printf(E_LINE); 22181237e847Slclee (void) printf("Invalid percentage value " 22191237e847Slclee "specified; retry the operation."); 22201237e847Slclee return (-1); 22211237e847Slclee } 22221237e847Slclee i++; 22231237e847Slclee if (i > 3) { 22241237e847Slclee (void) printf(E_LINE); 22251237e847Slclee (void) printf("Invalid percentage value " 22261237e847Slclee "specified; retry the operation."); 22271237e847Slclee return (-1); 22281237e847Slclee } 22297c478bd9Sstevel@tonic-gate } 22301237e847Slclee if ((percent = atoi(s)) > 100) { 22311237e847Slclee (void) printf(E_LINE); 22321237e847Slclee (void) printf( 22331237e847Slclee "Percentage value is too large. The value must be" 22341237e847Slclee " between 1 and 100;\nretry the operation.\n"); 22351237e847Slclee return (-1); 22361237e847Slclee } 22371237e847Slclee if (percent < 1) { 22381237e847Slclee (void) printf(E_LINE); 22391237e847Slclee (void) printf( 22401237e847Slclee "Percentage value is too small. The value must be" 22411237e847Slclee " between 1 and 100;\nretry the operation.\n"); 22421237e847Slclee return (-1); 22431237e847Slclee } 22441237e847Slclee 22451237e847Slclee if (percent == 100) 2246*342440ecSPrasad Singamsetty cylen = Numcyl_usable - 1; 22471237e847Slclee else 2248*342440ecSPrasad Singamsetty cylen = (Numcyl_usable * percent) / 100; 22491237e847Slclee 22501237e847Slclee /* Verify DOS12 partition doesn't exceed max size of 32MB. */ 22511237e847Slclee if ((tsystid == DOSOS12) && 22521237e847Slclee ((long)((long)cylen * cyl_size) > MAXDOS)) { 22531237e847Slclee int n; 2254*342440ecSPrasad Singamsetty n = MAXDOS * 100 / (int)(cyl_size) / Numcyl_usable; 22551237e847Slclee (void) printf(E_LINE); 22561237e847Slclee (void) printf("Maximum size for a DOS partition " 22571237e847Slclee "is %d%%; retry the operation.", 22581237e847Slclee n <= 100 ? n : 100); 22591237e847Slclee return (-1); 22601237e847Slclee } 22611237e847Slclee 22621237e847Slclee 22631237e847Slclee max_free = 0; 22641237e847Slclee for (i = 0; i < FD_NUMPART; i++) { 22651237e847Slclee 22661237e847Slclee /* 22671237e847Slclee * check for free space before partition i 22681237e847Slclee * where i varies from 0 to 3 22691237e847Slclee * 22701237e847Slclee * freespace after partition 3 is unusable 22711237e847Slclee * because there are no free partitions 22721237e847Slclee * 22731237e847Slclee * freespace begins at the end of previous partition 22741237e847Slclee * or cylinder 1 22751237e847Slclee */ 22761237e847Slclee if (i) { 22771237e847Slclee /* Not an empty table */ 22781237e847Slclee first_free = lel(partition[i - 1]->relsect) + 22791237e847Slclee lel(partition[i - 1]->numsect); 22801237e847Slclee } else { 22811237e847Slclee first_free = cyl_size; 22821237e847Slclee } 22831237e847Slclee 22841237e847Slclee /* 22851237e847Slclee * freespace ends before the current partition 22861237e847Slclee * or the end of the disk (chs end) 22871237e847Slclee */ 22881237e847Slclee if (partition[i]->systid == UNUSED) { 22891237e847Slclee size_free = chs_capacity - first_free; 22901237e847Slclee } else { 22911237e847Slclee size_free = 22921237e847Slclee lel(partition[i]->relsect) - first_free; 22931237e847Slclee } 22941237e847Slclee 22951237e847Slclee /* save largest free space */ 22961237e847Slclee if (max_free < size_free) 22971237e847Slclee max_free = size_free; 22981237e847Slclee 2299*342440ecSPrasad Singamsetty if (((uint64_t)cylen * cyl_size) <= size_free) { 23001237e847Slclee /* We found a place to use */ 23011237e847Slclee break; 23021237e847Slclee } 23031237e847Slclee if (partition[i]->systid == UNUSED) { 23041237e847Slclee (void) printf(E_LINE); 23051237e847Slclee max_free /= (cyl_size); 23061237e847Slclee (void) fprintf(stderr, "fdisk: " 2307*342440ecSPrasad Singamsetty "Maximum percentage available is %lld\n", 2308*342440ecSPrasad Singamsetty 100 * max_free / Numcyl_usable); 23091237e847Slclee return (-1); 23101237e847Slclee } 23111237e847Slclee } 23121237e847Slclee 2313bb16350dSlclee (void) printf(E_LINE); 23141237e847Slclee if (i >= FD_NUMPART) { 23151237e847Slclee (void) fprintf(stderr, 23161237e847Slclee "fdisk: Partition table is full.\n"); 23171237e847Slclee return (-1); 23181237e847Slclee } 23191237e847Slclee 23201237e847Slclee if ((i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 23211237e847Slclee first_free, cylen * cyl_size)) >= 0) { 23221237e847Slclee return (i); 23231237e847Slclee } 23247c478bd9Sstevel@tonic-gate return (-1); 23251237e847Slclee } else { 23267c478bd9Sstevel@tonic-gate 23271237e847Slclee /* Specifying size in cylinders */ 2328bb16350dSlclee (void) printf(E_LINE); 23291237e847Slclee (void) printf(Q_LINE); 23301237e847Slclee (void) printf("Enter starting cylinder number: "); 23311237e847Slclee if ((cyl = getcyl()) == -1) { 23321237e847Slclee (void) printf(E_LINE); 23331237e847Slclee (void) printf("Invalid number; retry the operation."); 23341237e847Slclee return (-1); 23351237e847Slclee } 23361237e847Slclee if (cyl == 0) { 23371237e847Slclee (void) printf(E_LINE); 23381237e847Slclee (void) printf( 23391237e847Slclee "New partition cannot start at cylinder 0.\n"); 23401237e847Slclee return (-1); 23411237e847Slclee } 2342*342440ecSPrasad Singamsetty 2343*342440ecSPrasad Singamsetty 2344*342440ecSPrasad Singamsetty if (cyl >= Numcyl_usable) { 23451237e847Slclee (void) printf(E_LINE); 23461237e847Slclee (void) printf( 23471237e847Slclee "Cylinder %d is out of bounds, " 23481237e847Slclee "the maximum is %d.\n", 2349*342440ecSPrasad Singamsetty cyl, Numcyl_usable - 1); 23501237e847Slclee return (-1); 23511237e847Slclee } 2352*342440ecSPrasad Singamsetty 23531237e847Slclee (void) printf(Q_LINE); 23541237e847Slclee (void) printf("Enter partition size in cylinders: "); 23551237e847Slclee if ((cylen = getcyl()) == -1) { 23561237e847Slclee (void) printf(E_LINE); 23571237e847Slclee (void) printf("Invalid number, retry the operation."); 23581237e847Slclee return (-1); 23591237e847Slclee } 23601237e847Slclee 23611237e847Slclee for (i = 0; i < FD_NUMPART; i++) { 23621237e847Slclee uint32_t t_relsect, t_numsect; 23631237e847Slclee 23641237e847Slclee if (partition[i]->systid == UNUSED) 23651237e847Slclee break; 23661237e847Slclee t_relsect = lel(partition[i]->relsect); 23671237e847Slclee t_numsect = lel(partition[i]->numsect); 23681237e847Slclee 23691237e847Slclee if (cyl * cyl_size >= t_relsect && 23701237e847Slclee cyl * cyl_size < t_relsect + t_numsect) { 23711237e847Slclee (void) printf(E_LINE); 23721237e847Slclee (void) printf( 23731237e847Slclee "Cylinder %d is already allocated" 23741237e847Slclee "\nretry the operation.", 23751237e847Slclee cyl); 23761237e847Slclee return (-1); 23771237e847Slclee } 23781237e847Slclee 23791237e847Slclee if (cyl * cyl_size < t_relsect && 23801237e847Slclee (cyl + cylen - 1) * cyl_size > t_relsect) { 23811237e847Slclee (void) printf(E_LINE); 23821237e847Slclee (void) printf( 23831237e847Slclee "Maximum size for partition is %u cylinders" 23841237e847Slclee "\nretry the operation.", 23851237e847Slclee (t_relsect - cyl * cyl_size) / cyl_size); 23861237e847Slclee return (-1); 23871237e847Slclee } 23881237e847Slclee } 23897c478bd9Sstevel@tonic-gate 2390*342440ecSPrasad Singamsetty /* Verify partition doesn't exceed disk size or 2 TB */ 2391*342440ecSPrasad Singamsetty if (cyl + cylen > Numcyl_usable) { 23921237e847Slclee (void) printf(E_LINE); 2393*342440ecSPrasad Singamsetty if (Numcyl > Numcyl_usable) { 2394*342440ecSPrasad Singamsetty (void) printf( 2395*342440ecSPrasad Singamsetty "Maximum size for partition is %d " 2396*342440ecSPrasad Singamsetty "cylinders; \nretry the operation.", 2397*342440ecSPrasad Singamsetty Numcyl_usable - cyl); 2398*342440ecSPrasad Singamsetty } else { 2399*342440ecSPrasad Singamsetty (void) printf( 2400*342440ecSPrasad Singamsetty "Maximum size for partition is %d " 2401*342440ecSPrasad Singamsetty "cylinders; \nretry the operation.", 2402*342440ecSPrasad Singamsetty Numcyl_usable - cyl); 2403*342440ecSPrasad Singamsetty } 24041237e847Slclee return (-1); 24051237e847Slclee } 24061237e847Slclee 24071237e847Slclee /* Verify DOS12 partition doesn't exceed max size of 32MB. */ 24081237e847Slclee if ((tsystid == DOSOS12) && 24091237e847Slclee ((long)((long)cylen * cyl_size) > MAXDOS)) { 24101237e847Slclee (void) printf(E_LINE); 24111237e847Slclee (void) printf( 24121237e847Slclee "Maximum size for a %s partition is %ld cylinders;" 24131237e847Slclee "\nretry the operation.", 24141237e847Slclee Dstr, MAXDOS / (int)(cyl_size)); 24151237e847Slclee return (-1); 24161237e847Slclee } 24177c478bd9Sstevel@tonic-gate 2418bb16350dSlclee (void) printf(E_LINE); 24191237e847Slclee i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 24201237e847Slclee cyl * cyl_size, cylen * cyl_size); 24211237e847Slclee if (i < 0) 24221237e847Slclee return (-1); 24231237e847Slclee 24241237e847Slclee if (verify_tbl() < 0) { 24251237e847Slclee (void) printf(E_LINE); 24261237e847Slclee (void) printf("fdisk: Cannot create partition table\n"); 24271237e847Slclee return (-1); 24281237e847Slclee } 24297c478bd9Sstevel@tonic-gate 24301237e847Slclee return (i); 24317c478bd9Sstevel@tonic-gate } 24327c478bd9Sstevel@tonic-gate } 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate /* 24357c478bd9Sstevel@tonic-gate * dispmenu 24367c478bd9Sstevel@tonic-gate * Display command menu (interactive mode). 24377c478bd9Sstevel@tonic-gate */ 2438bb16350dSlclee static void 2439bb16350dSlclee dispmenu(void) 24407c478bd9Sstevel@tonic-gate { 2441bb16350dSlclee (void) printf(M_LINE); 2442bb16350dSlclee (void) printf( 2443bb16350dSlclee "SELECT ONE OF THE FOLLOWING:\n" 2444bb16350dSlclee " 1. Create a partition\n" 2445bb16350dSlclee " 2. Specify the active partition\n" 2446bb16350dSlclee " 3. Delete a partition\n" 2447bb16350dSlclee " 4. Change between Solaris and Solaris2 Partition IDs\n" 2448bb16350dSlclee " 5. Exit (update disk configuration and exit)\n" 2449bb16350dSlclee " 6. Cancel (exit without updating disk configuration)\n"); 24507c478bd9Sstevel@tonic-gate } 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate /* 24537c478bd9Sstevel@tonic-gate * pchange 24547c478bd9Sstevel@tonic-gate * Change the ACTIVE designation of a partition. 24557c478bd9Sstevel@tonic-gate */ 2456bb16350dSlclee static int 2457bb16350dSlclee pchange(void) 24587c478bd9Sstevel@tonic-gate { 24597c478bd9Sstevel@tonic-gate char s[80]; 24607c478bd9Sstevel@tonic-gate int i, j; 24617c478bd9Sstevel@tonic-gate 2462bb16350dSlclee for (;;) { 2463bb16350dSlclee (void) printf(Q_LINE); 24647c478bd9Sstevel@tonic-gate { 2465bb16350dSlclee (void) printf( 2466bb16350dSlclee "Specify the partition number to boot from" 24677c478bd9Sstevel@tonic-gate " (or specify 0 for none): "); 24687c478bd9Sstevel@tonic-gate } 2469bb16350dSlclee (void) gets(s); 24707c478bd9Sstevel@tonic-gate rm_blanks(s); 24717c478bd9Sstevel@tonic-gate if ((s[1] != 0) || (s[0] < '0') || (s[0] > '4')) { 2472bb16350dSlclee (void) printf(E_LINE); 2473bb16350dSlclee (void) printf( 2474bb16350dSlclee "Invalid response, please specify a number" 24757c478bd9Sstevel@tonic-gate " between 0 and 4.\n"); 24767c478bd9Sstevel@tonic-gate } else { 24777c478bd9Sstevel@tonic-gate break; 24787c478bd9Sstevel@tonic-gate } 24797c478bd9Sstevel@tonic-gate } 24807c478bd9Sstevel@tonic-gate if (s[0] == '0') { /* No active partitions */ 24817c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 24827c478bd9Sstevel@tonic-gate if (Table[i].systid != UNUSED && 24837c478bd9Sstevel@tonic-gate Table[i].bootid == ACTIVE) 24847c478bd9Sstevel@tonic-gate Table[i].bootid = 0; 24857c478bd9Sstevel@tonic-gate } 2486bb16350dSlclee (void) printf(E_LINE); 2487bb16350dSlclee (void) printf( 2488bb16350dSlclee "No partition is currently marked as active."); 24897c478bd9Sstevel@tonic-gate return (0); 24907c478bd9Sstevel@tonic-gate } else { /* User has selected a partition to be active */ 24917c478bd9Sstevel@tonic-gate i = s[0] - '1'; 24927c478bd9Sstevel@tonic-gate if (Table[i].systid == UNUSED) { 2493bb16350dSlclee (void) printf(E_LINE); 2494bb16350dSlclee (void) printf("Partition does not exist."); 24957c478bd9Sstevel@tonic-gate return (-1); 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate /* a DOS-DATA or EXT-DOS partition cannot be active */ 24987c478bd9Sstevel@tonic-gate else if ((Table[i].systid == DOSDATA) || 24997c478bd9Sstevel@tonic-gate (Table[i].systid == EXTDOS) || 25007c478bd9Sstevel@tonic-gate (Table[i].systid == FDISK_EXTLBA)) { 2501bb16350dSlclee (void) printf(E_LINE); 2502bb16350dSlclee (void) printf( 2503bb16350dSlclee "DOS-DATA, EXT_DOS and EXT_DOS_LBA partitions " 25047c478bd9Sstevel@tonic-gate "cannot be made active.\n"); 2505bb16350dSlclee (void) printf("Select another partition."); 25067c478bd9Sstevel@tonic-gate return (-1); 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate Table[i].bootid = ACTIVE; 25097c478bd9Sstevel@tonic-gate for (j = 0; j < FD_NUMPART; j++) { 25107c478bd9Sstevel@tonic-gate if (j != i) 25117c478bd9Sstevel@tonic-gate Table[j].bootid = 0; 25127c478bd9Sstevel@tonic-gate } 25137c478bd9Sstevel@tonic-gate } 2514bb16350dSlclee (void) printf(E_LINE); 25157c478bd9Sstevel@tonic-gate { 2516bb16350dSlclee (void) printf( 2517bb16350dSlclee "Partition %d is now active. The system will start up" 2518bb16350dSlclee " from this\n", i + 1); 2519bb16350dSlclee (void) printf("partition after the next reboot."); 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate return (1); 25227c478bd9Sstevel@tonic-gate } 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate /* 25257c478bd9Sstevel@tonic-gate * Change between SOLARIS and SOLARIS2 partition id 25267c478bd9Sstevel@tonic-gate */ 2527bb16350dSlclee static int 2528bb16350dSlclee ppartid(void) 25297c478bd9Sstevel@tonic-gate { 25307c478bd9Sstevel@tonic-gate char *p, s[80]; 25317c478bd9Sstevel@tonic-gate int i; 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate for (;;) { 2534bb16350dSlclee (void) printf(Q_LINE); 2535bb16350dSlclee (void) printf("Specify the partition number to change" 25361237e847Slclee " (or enter 0 to exit): "); 2537bb16350dSlclee if (!fgets(s, sizeof (s), stdin)) 2538bb16350dSlclee return (1); 25397c478bd9Sstevel@tonic-gate i = strtol(s, &p, 10); 25407c478bd9Sstevel@tonic-gate 25417c478bd9Sstevel@tonic-gate if (*p != '\n' || i < 0 || i > FD_NUMPART) { 2542bb16350dSlclee (void) printf(E_LINE); 2543bb16350dSlclee (void) printf( 2544bb16350dSlclee "Invalid response, retry the operation.\n"); 25457c478bd9Sstevel@tonic-gate continue; 25467c478bd9Sstevel@tonic-gate } 25477c478bd9Sstevel@tonic-gate 25487c478bd9Sstevel@tonic-gate if (i == 0) { 25497c478bd9Sstevel@tonic-gate /* exit delete command */ 2550bb16350dSlclee (void) printf(E_LINE); /* clear error message */ 25517c478bd9Sstevel@tonic-gate return (1); 25527c478bd9Sstevel@tonic-gate } 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate i -= 1; 25557c478bd9Sstevel@tonic-gate if (Table[i].systid == SUNIXOS) { 25567c478bd9Sstevel@tonic-gate Table[i].systid = SUNIXOS2; 25577c478bd9Sstevel@tonic-gate } else if (Table[i].systid == SUNIXOS2) { 25587c478bd9Sstevel@tonic-gate Table[i].systid = SUNIXOS; 25597c478bd9Sstevel@tonic-gate } else { 2560bb16350dSlclee (void) printf(E_LINE); 2561bb16350dSlclee (void) printf( 2562bb16350dSlclee "Partition %d is not a Solaris partition.", 25637c478bd9Sstevel@tonic-gate i + 1); 25647c478bd9Sstevel@tonic-gate continue; 25657c478bd9Sstevel@tonic-gate } 25667c478bd9Sstevel@tonic-gate 2567bb16350dSlclee (void) printf(E_LINE); 2568bb16350dSlclee (void) printf("Partition %d has been changed.", i + 1); 25697c478bd9Sstevel@tonic-gate return (1); 25707c478bd9Sstevel@tonic-gate } 25717c478bd9Sstevel@tonic-gate } 25727c478bd9Sstevel@tonic-gate 25737c478bd9Sstevel@tonic-gate /* 25747c478bd9Sstevel@tonic-gate * pdelete 25757c478bd9Sstevel@tonic-gate * Remove partition entry from the table (interactive mode). 25767c478bd9Sstevel@tonic-gate */ 2577bb16350dSlclee static char 2578bb16350dSlclee pdelete(void) 25797c478bd9Sstevel@tonic-gate { 25807c478bd9Sstevel@tonic-gate char s[80]; 25817c478bd9Sstevel@tonic-gate int i, j; 25827c478bd9Sstevel@tonic-gate char pactive; 25837c478bd9Sstevel@tonic-gate 2584bb16350dSlclee DEL1: (void) printf(Q_LINE); 2585bb16350dSlclee (void) printf("Specify the partition number to delete" 25867c478bd9Sstevel@tonic-gate " (or enter 0 to exit): "); 2587bb16350dSlclee (void) gets(s); 25887c478bd9Sstevel@tonic-gate rm_blanks(s); 25897c478bd9Sstevel@tonic-gate if ((s[0] == '0')) { /* exit delete command */ 2590bb16350dSlclee (void) printf(E_LINE); /* clear error message */ 25917c478bd9Sstevel@tonic-gate return (1); 25927c478bd9Sstevel@tonic-gate } 25937c478bd9Sstevel@tonic-gate /* Accept only a single digit between 1 and 4 */ 25947c478bd9Sstevel@tonic-gate if (s[1] != 0 || (i = atoi(s)) < 1 || i > FD_NUMPART) { 2595bb16350dSlclee (void) printf(E_LINE); 2596bb16350dSlclee (void) printf("Invalid response, retry the operation.\n"); 25977c478bd9Sstevel@tonic-gate goto DEL1; 25987c478bd9Sstevel@tonic-gate } else { /* Found a digit between 1 and 4 */ 25997c478bd9Sstevel@tonic-gate --i; /* Structure begins with element 0 */ 26007c478bd9Sstevel@tonic-gate } 26017c478bd9Sstevel@tonic-gate 26027c478bd9Sstevel@tonic-gate if (Table[i].systid == UNUSED) { 2603bb16350dSlclee (void) printf(E_LINE); 2604bb16350dSlclee (void) printf("Partition %d does not exist.", i + 1); 26057c478bd9Sstevel@tonic-gate return (-1); 26067c478bd9Sstevel@tonic-gate } 26077c478bd9Sstevel@tonic-gate 2608bb16350dSlclee (void) printf(Q_LINE); 2609bb16350dSlclee (void) printf("Are you sure you want to delete partition %d?" 2610bb16350dSlclee " This will make all files and \n", i + 1); 2611bb16350dSlclee (void) printf("programs in this partition inaccessible (type" 26127c478bd9Sstevel@tonic-gate " \"y\" or \"n\"). "); 26137c478bd9Sstevel@tonic-gate 2614bb16350dSlclee (void) printf(E_LINE); 26157c478bd9Sstevel@tonic-gate if (! yesno()) { 26167c478bd9Sstevel@tonic-gate return (1); 26177c478bd9Sstevel@tonic-gate } 26187c478bd9Sstevel@tonic-gate 26197c478bd9Sstevel@tonic-gate if (Table[i].bootid == ACTIVE) { 26207c478bd9Sstevel@tonic-gate pactive = 1; 26217c478bd9Sstevel@tonic-gate } else { 26227c478bd9Sstevel@tonic-gate pactive = 0; 26237c478bd9Sstevel@tonic-gate } 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate for (j = i; j < FD_NUMPART - 1; j++) { 26261237e847Slclee Table[j] = Table[j + 1]; 26277c478bd9Sstevel@tonic-gate } 26287c478bd9Sstevel@tonic-gate 26297c478bd9Sstevel@tonic-gate Table[j].systid = UNUSED; 26307c478bd9Sstevel@tonic-gate Table[j].numsect = 0; 26317c478bd9Sstevel@tonic-gate Table[j].relsect = 0; 26327c478bd9Sstevel@tonic-gate Table[j].bootid = 0; 2633bb16350dSlclee (void) printf(E_LINE); 2634bb16350dSlclee (void) printf("Partition %d has been deleted.", i + 1); 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate if (pactive) { 26371237e847Slclee (void) printf(" This was the active partition."); 26387c478bd9Sstevel@tonic-gate } 26397c478bd9Sstevel@tonic-gate 26407c478bd9Sstevel@tonic-gate return (1); 26417c478bd9Sstevel@tonic-gate } 26427c478bd9Sstevel@tonic-gate 26437c478bd9Sstevel@tonic-gate /* 26447c478bd9Sstevel@tonic-gate * rm_blanks 26457c478bd9Sstevel@tonic-gate * Remove blanks from strings of user responses. 26467c478bd9Sstevel@tonic-gate */ 2647bb16350dSlclee static void 2648bb16350dSlclee rm_blanks(char *s) 26497c478bd9Sstevel@tonic-gate { 26507c478bd9Sstevel@tonic-gate register int i, j; 26517c478bd9Sstevel@tonic-gate 26527c478bd9Sstevel@tonic-gate for (i = 0; i < CBUFLEN; i++) { 26537c478bd9Sstevel@tonic-gate if ((s[i] == ' ') || (s[i] == '\t')) 26547c478bd9Sstevel@tonic-gate continue; 26557c478bd9Sstevel@tonic-gate else 26567c478bd9Sstevel@tonic-gate /* Found first non-blank character of the string */ 26577c478bd9Sstevel@tonic-gate break; 26587c478bd9Sstevel@tonic-gate } 26597c478bd9Sstevel@tonic-gate for (j = 0; i < CBUFLEN; j++, i++) { 26607c478bd9Sstevel@tonic-gate if ((s[j] = s[i]) == '\0') { 26617c478bd9Sstevel@tonic-gate /* Reached end of string */ 26627c478bd9Sstevel@tonic-gate return; 26637c478bd9Sstevel@tonic-gate } 26647c478bd9Sstevel@tonic-gate } 26657c478bd9Sstevel@tonic-gate } 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate /* 26687c478bd9Sstevel@tonic-gate * getcyl 26697c478bd9Sstevel@tonic-gate * Take the user-specified cylinder number and convert it from a 26707c478bd9Sstevel@tonic-gate * string to a decimal value. 26717c478bd9Sstevel@tonic-gate */ 2672bb16350dSlclee static int 2673bb16350dSlclee getcyl(void) 26747c478bd9Sstevel@tonic-gate { 26757c478bd9Sstevel@tonic-gate int slen, i, j; 26767c478bd9Sstevel@tonic-gate unsigned int cyl; 2677bb16350dSlclee (void) gets(s); 26787c478bd9Sstevel@tonic-gate rm_blanks(s); 26797c478bd9Sstevel@tonic-gate slen = strlen(s); 26807c478bd9Sstevel@tonic-gate j = 1; 26817c478bd9Sstevel@tonic-gate cyl = 0; 2682bb16350dSlclee for (i = slen - 1; i >= 0; i--) { 26837c478bd9Sstevel@tonic-gate if (s[i] < '0' || s[i] > '9') { 26847c478bd9Sstevel@tonic-gate return (-1); 26857c478bd9Sstevel@tonic-gate } 2686bb16350dSlclee cyl += (j * (s[i] - '0')); 26877c478bd9Sstevel@tonic-gate j *= 10; 26887c478bd9Sstevel@tonic-gate } 26897c478bd9Sstevel@tonic-gate return (cyl); 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate 26927c478bd9Sstevel@tonic-gate /* 26937c478bd9Sstevel@tonic-gate * disptbl 26947c478bd9Sstevel@tonic-gate * Display the current fdisk table; determine percentage 26957c478bd9Sstevel@tonic-gate * of the disk used for each partition. 26967c478bd9Sstevel@tonic-gate */ 2697bb16350dSlclee static void 2698bb16350dSlclee disptbl(void) 26997c478bd9Sstevel@tonic-gate { 27007c478bd9Sstevel@tonic-gate int i; 27017c478bd9Sstevel@tonic-gate unsigned int startcyl, endcyl, length, percent, remainder; 27027c478bd9Sstevel@tonic-gate char *stat, *type; 2703*342440ecSPrasad Singamsetty int is_pmbr = 0; 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate if ((heads == 0) || (sectors == 0)) { 2706bb16350dSlclee (void) printf("WARNING: critical disk geometry information" 27071237e847Slclee " missing!\n"); 2708bb16350dSlclee (void) printf("\theads = %d, sectors = %d\n", heads, sectors); 27097c478bd9Sstevel@tonic-gate exit(1); 27107c478bd9Sstevel@tonic-gate } 27117c478bd9Sstevel@tonic-gate 2712bb16350dSlclee (void) printf(HOME); 2713bb16350dSlclee (void) printf(T_LINE); 2714bb16350dSlclee (void) printf(" Total disk size is %d cylinders\n", Numcyl); 2715bb16350dSlclee (void) printf(" Cylinder size is %d (512 byte) blocks\n\n", 2716bb16350dSlclee heads * sectors); 2717bb16350dSlclee (void) printf( 2718bb16350dSlclee " Cylinders\n"); 2719bb16350dSlclee (void) printf( 2720bb16350dSlclee " Partition Status Type Start End Length" 27217c478bd9Sstevel@tonic-gate " %%\n"); 2722bb16350dSlclee (void) printf( 2723bb16350dSlclee " ========= ====== ============ ===== === ======" 27247c478bd9Sstevel@tonic-gate " ==="); 27257c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 27267c478bd9Sstevel@tonic-gate if (Table[i].systid == UNUSED) { 2727bb16350dSlclee (void) printf("\n"); 2728bb16350dSlclee (void) printf(CLR_LIN); 27297c478bd9Sstevel@tonic-gate continue; 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate if (Table[i].bootid == ACTIVE) 27321237e847Slclee stat = Actvstr; 27337c478bd9Sstevel@tonic-gate else 27341237e847Slclee stat = NAstr; 27357c478bd9Sstevel@tonic-gate switch (Table[i].systid) { 27367c478bd9Sstevel@tonic-gate case UNIXOS: 27371237e847Slclee type = Ustr; 27381237e847Slclee break; 27397c478bd9Sstevel@tonic-gate case SUNIXOS: 27401237e847Slclee type = SUstr; 27411237e847Slclee break; 27427c478bd9Sstevel@tonic-gate case SUNIXOS2: 27431237e847Slclee type = SU2str; 27441237e847Slclee break; 27457c478bd9Sstevel@tonic-gate case X86BOOT: 27461237e847Slclee type = X86str; 27471237e847Slclee break; 27487c478bd9Sstevel@tonic-gate case DOSOS12: 27491237e847Slclee type = Dstr; 27501237e847Slclee break; 27517c478bd9Sstevel@tonic-gate case DOSOS16: 27521237e847Slclee type = D16str; 27531237e847Slclee break; 27547c478bd9Sstevel@tonic-gate case EXTDOS: 27551237e847Slclee type = EDstr; 27561237e847Slclee break; 27577c478bd9Sstevel@tonic-gate case DOSDATA: 27581237e847Slclee type = DDstr; 27591237e847Slclee break; 27607c478bd9Sstevel@tonic-gate case DOSHUGE: 27611237e847Slclee type = DBstr; 27621237e847Slclee break; 27637c478bd9Sstevel@tonic-gate case PCIXOS: 27641237e847Slclee type = PCstr; 27651237e847Slclee break; 27667c478bd9Sstevel@tonic-gate case DIAGPART: 27671237e847Slclee type = DIAGstr; 27681237e847Slclee break; 27697c478bd9Sstevel@tonic-gate case FDISK_IFS: 27701237e847Slclee type = IFSstr; 27711237e847Slclee break; 27727c478bd9Sstevel@tonic-gate case FDISK_AIXBOOT: 27731237e847Slclee type = AIXstr; 27741237e847Slclee break; 27757c478bd9Sstevel@tonic-gate case FDISK_AIXDATA: 27761237e847Slclee type = AIXDstr; 27771237e847Slclee break; 27787c478bd9Sstevel@tonic-gate case FDISK_OS2BOOT: 27791237e847Slclee type = OS2str; 27801237e847Slclee break; 27817c478bd9Sstevel@tonic-gate case FDISK_WINDOWS: 27821237e847Slclee type = WINstr; 27831237e847Slclee break; 27847c478bd9Sstevel@tonic-gate case FDISK_EXT_WIN: 27851237e847Slclee type = EWINstr; 27861237e847Slclee break; 27877c478bd9Sstevel@tonic-gate case FDISK_FAT95: 27881237e847Slclee type = FAT95str; 27891237e847Slclee break; 27907c478bd9Sstevel@tonic-gate case FDISK_EXTLBA: 27911237e847Slclee type = EXTLstr; 27921237e847Slclee break; 27937c478bd9Sstevel@tonic-gate case FDISK_LINUX: 27941237e847Slclee type = LINUXstr; 27951237e847Slclee break; 27967c478bd9Sstevel@tonic-gate case FDISK_CPM: 27971237e847Slclee type = CPMstr; 27981237e847Slclee break; 27997c478bd9Sstevel@tonic-gate case FDISK_NOVELL3: 28001237e847Slclee type = NOVstr; 28011237e847Slclee break; 28027c478bd9Sstevel@tonic-gate case FDISK_QNX4: 28031237e847Slclee type = QNXstr; 28041237e847Slclee break; 28057c478bd9Sstevel@tonic-gate case FDISK_QNX42: 28061237e847Slclee type = QNX2str; 28071237e847Slclee break; 28087c478bd9Sstevel@tonic-gate case FDISK_QNX43: 28091237e847Slclee type = QNX3str; 28101237e847Slclee break; 28117c478bd9Sstevel@tonic-gate case FDISK_LINUXNAT: 28121237e847Slclee type = LINNATstr; 28131237e847Slclee break; 28147c478bd9Sstevel@tonic-gate case FDISK_NTFSVOL1: 28151237e847Slclee type = NTFSVOL1str; 28161237e847Slclee break; 28177c478bd9Sstevel@tonic-gate case FDISK_NTFSVOL2: 28181237e847Slclee type = NTFSVOL2str; 28191237e847Slclee break; 28207c478bd9Sstevel@tonic-gate case FDISK_BSD: 28211237e847Slclee type = BSDstr; 28221237e847Slclee break; 28237c478bd9Sstevel@tonic-gate case FDISK_NEXTSTEP: 28241237e847Slclee type = NEXTSTEPstr; 28251237e847Slclee break; 28267c478bd9Sstevel@tonic-gate case FDISK_BSDIFS: 28271237e847Slclee type = BSDIFSstr; 28281237e847Slclee break; 28297c478bd9Sstevel@tonic-gate case FDISK_BSDISWAP: 28301237e847Slclee type = BSDISWAPstr; 28311237e847Slclee break; 28327c478bd9Sstevel@tonic-gate case EFI_PMBR: 28331237e847Slclee type = EFIstr; 2834*342440ecSPrasad Singamsetty if (lel(Table[i].numsect) == DK_MAX_2TB) 2835*342440ecSPrasad Singamsetty is_pmbr = 1; 2836*342440ecSPrasad Singamsetty 28371237e847Slclee break; 28387c478bd9Sstevel@tonic-gate default: 28391237e847Slclee type = Ostr; 28401237e847Slclee break; 28417c478bd9Sstevel@tonic-gate } 28422b26c6eeSbharding startcyl = lel(Table[i].relsect) / 28432b26c6eeSbharding (unsigned long)(heads * sectors); 2844*342440ecSPrasad Singamsetty 2845*342440ecSPrasad Singamsetty if (lel(Table[i].numsect) == DK_MAX_2TB) { 2846*342440ecSPrasad Singamsetty endcyl = Numcyl - 1; 2847*342440ecSPrasad Singamsetty length = endcyl - startcyl + 1; 2848*342440ecSPrasad Singamsetty } else { 2849*342440ecSPrasad Singamsetty length = lel(Table[i].numsect) / 2850*342440ecSPrasad Singamsetty (unsigned long)(heads * sectors); 2851*342440ecSPrasad Singamsetty if (lel(Table[i].numsect) % 2852*342440ecSPrasad Singamsetty (unsigned long)(heads * sectors)) 2853*342440ecSPrasad Singamsetty length++; 2854*342440ecSPrasad Singamsetty endcyl = startcyl + length - 1; 2855*342440ecSPrasad Singamsetty } 2856*342440ecSPrasad Singamsetty 2857*342440ecSPrasad Singamsetty percent = length * 100 / Numcyl_usable; 2858*342440ecSPrasad Singamsetty if ((remainder = (length * 100 % Numcyl_usable)) != 0) { 2859*342440ecSPrasad Singamsetty if ((remainder * 100 / Numcyl_usable) > 50) { 28607c478bd9Sstevel@tonic-gate /* round up */ 28617c478bd9Sstevel@tonic-gate percent++; 28627c478bd9Sstevel@tonic-gate } 28637c478bd9Sstevel@tonic-gate /* Else leave the percent as is since it's already */ 28647c478bd9Sstevel@tonic-gate /* rounded down */ 28657c478bd9Sstevel@tonic-gate } 28667c478bd9Sstevel@tonic-gate if (percent > 100) 28677c478bd9Sstevel@tonic-gate percent = 100; 2868bb16350dSlclee (void) printf( 2869bb16350dSlclee "\n %d %s %-12.12s %4d %4d %4d" 2870bb16350dSlclee " %3d", 2871bb16350dSlclee i + 1, stat, type, startcyl, endcyl, length, percent); 28727c478bd9Sstevel@tonic-gate } 2873*342440ecSPrasad Singamsetty 28747c478bd9Sstevel@tonic-gate /* Print warning message if table is empty */ 28757c478bd9Sstevel@tonic-gate if (Table[0].systid == UNUSED) { 2876bb16350dSlclee (void) printf(W_LINE); 2877bb16350dSlclee (void) printf("WARNING: no partitions are defined!"); 28787c478bd9Sstevel@tonic-gate } else { 28797c478bd9Sstevel@tonic-gate /* Clear the warning line */ 2880bb16350dSlclee (void) printf(W_LINE); 2881*342440ecSPrasad Singamsetty 2882*342440ecSPrasad Singamsetty /* Print warning if disk > 2TB and is not EFI PMBR */ 2883*342440ecSPrasad Singamsetty if (!is_pmbr && (dev_capacity > DK_MAX_2TB)) 2884*342440ecSPrasad Singamsetty (void) printf("WARNING: Disk is larger than 2 TB. " 2885*342440ecSPrasad Singamsetty "Upper limit is 2 TB for non-EFI partition ID\n"); 28867c478bd9Sstevel@tonic-gate } 28877c478bd9Sstevel@tonic-gate } 28887c478bd9Sstevel@tonic-gate 28897c478bd9Sstevel@tonic-gate /* 28907c478bd9Sstevel@tonic-gate * print_Table 28917c478bd9Sstevel@tonic-gate * Write the detailed fdisk table to standard error for 28927c478bd9Sstevel@tonic-gate * the selected disk device. 28937c478bd9Sstevel@tonic-gate */ 2894bb16350dSlclee static void 2895bb16350dSlclee print_Table(void) 2896bb16350dSlclee { 28977c478bd9Sstevel@tonic-gate int i; 28987c478bd9Sstevel@tonic-gate 2899bb16350dSlclee (void) fprintf(stderr, 29007c478bd9Sstevel@tonic-gate " SYSID ACT BHEAD BSECT BEGCYL EHEAD ESECT ENDCYL RELSECT" 29017c478bd9Sstevel@tonic-gate " NUMSECT\n"); 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 2904bb16350dSlclee (void) fprintf(stderr, " %-5d ", Table[i].systid); 2905bb16350dSlclee (void) fprintf(stderr, "%-3d ", Table[i].bootid); 2906bb16350dSlclee (void) fprintf(stderr, "%-5d ", Table[i].beghead); 2907bb16350dSlclee (void) fprintf(stderr, "%-5d ", Table[i].begsect & 0x3f); 29081237e847Slclee (void) fprintf(stderr, "%-8d ", 29091237e847Slclee (((uint_t)Table[i].begsect & 0xc0) << 2) + Table[i].begcyl); 29107c478bd9Sstevel@tonic-gate 2911bb16350dSlclee (void) fprintf(stderr, "%-5d ", Table[i].endhead); 2912bb16350dSlclee (void) fprintf(stderr, "%-5d ", Table[i].endsect & 0x3f); 29131237e847Slclee (void) fprintf(stderr, "%-8d ", 29141237e847Slclee (((uint_t)Table[i].endsect & 0xc0) << 2) + Table[i].endcyl); 2915*342440ecSPrasad Singamsetty (void) fprintf(stderr, "%-10u ", lel(Table[i].relsect)); 2916*342440ecSPrasad Singamsetty (void) fprintf(stderr, "%-10u\n", lel(Table[i].numsect)); 29177c478bd9Sstevel@tonic-gate 29187c478bd9Sstevel@tonic-gate } 29197c478bd9Sstevel@tonic-gate } 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate /* 29227c478bd9Sstevel@tonic-gate * copy_Table_to_Old_Table 29237c478bd9Sstevel@tonic-gate * Copy Table into Old_Table. The function only copies the systid, 29247c478bd9Sstevel@tonic-gate * numsect, relsect, and bootid values because they are the only 29257c478bd9Sstevel@tonic-gate * ones compared when determining if Table has changed. 29267c478bd9Sstevel@tonic-gate */ 2927bb16350dSlclee static void 2928bb16350dSlclee copy_Table_to_Old_Table(void) 29297c478bd9Sstevel@tonic-gate { 29307c478bd9Sstevel@tonic-gate int i; 29317c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 29321237e847Slclee (void) memcpy(&Old_Table[i], &Table[i], sizeof (Table[0])); 29337c478bd9Sstevel@tonic-gate } 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate /* 29377c478bd9Sstevel@tonic-gate * nulltbl 29387c478bd9Sstevel@tonic-gate * Zero out the systid, numsect, relsect, and bootid values in the 29397c478bd9Sstevel@tonic-gate * fdisk table. 29407c478bd9Sstevel@tonic-gate */ 2941bb16350dSlclee static void 2942bb16350dSlclee nulltbl(void) 29437c478bd9Sstevel@tonic-gate { 29447c478bd9Sstevel@tonic-gate int i; 29457c478bd9Sstevel@tonic-gate 29467c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 29471237e847Slclee Table[i].systid = UNUSED; 29481237e847Slclee Table[i].numsect = lel(UNUSED); 29491237e847Slclee Table[i].relsect = lel(UNUSED); 29501237e847Slclee Table[i].bootid = 0; 29517c478bd9Sstevel@tonic-gate } 29527c478bd9Sstevel@tonic-gate } 29537c478bd9Sstevel@tonic-gate 29547c478bd9Sstevel@tonic-gate /* 29557c478bd9Sstevel@tonic-gate * copy_Bootblk_to_Table 29567c478bd9Sstevel@tonic-gate * Copy the bytes from the boot record to an internal "Table". 29577c478bd9Sstevel@tonic-gate * All unused are padded with zeros starting at offset 446. 29587c478bd9Sstevel@tonic-gate */ 2959bb16350dSlclee static void 2960bb16350dSlclee copy_Bootblk_to_Table(void) 29617c478bd9Sstevel@tonic-gate { 29627c478bd9Sstevel@tonic-gate int i, j; 29637c478bd9Sstevel@tonic-gate char *bootptr; 29647c478bd9Sstevel@tonic-gate struct ipart iparts[FD_NUMPART]; 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate /* Get an aligned copy of the partition tables */ 2967bb16350dSlclee (void) memcpy(iparts, Bootblk->parts, sizeof (iparts)); 29687c478bd9Sstevel@tonic-gate bootptr = (char *)iparts; /* Points to start of partition table */ 29697c478bd9Sstevel@tonic-gate if (les(Bootblk->signature) != MBB_MAGIC) { 29707c478bd9Sstevel@tonic-gate /* Signature is missing */ 29717c478bd9Sstevel@tonic-gate nulltbl(); 2972bb16350dSlclee (void) memcpy(Bootblk->bootinst, &BootCod, BOOTSZ); 29737c478bd9Sstevel@tonic-gate return; 29747c478bd9Sstevel@tonic-gate } 29757c478bd9Sstevel@tonic-gate /* 29767c478bd9Sstevel@tonic-gate * When the DOS fdisk command deletes a partition, it is not 29777c478bd9Sstevel@tonic-gate * recognized by the old algorithm. The algorithm that 29787c478bd9Sstevel@tonic-gate * follows looks at each entry in the Bootrec and copies all 29797c478bd9Sstevel@tonic-gate * those that are valid. 29807c478bd9Sstevel@tonic-gate */ 29817c478bd9Sstevel@tonic-gate j = 0; 29827c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 29837c478bd9Sstevel@tonic-gate if (iparts[i].systid == 0) { 29847c478bd9Sstevel@tonic-gate /* Null entry */ 29857c478bd9Sstevel@tonic-gate bootptr += sizeof (struct ipart); 29867c478bd9Sstevel@tonic-gate } else { 2987bb16350dSlclee fill_ipart(bootptr, &Table[j]); 29887c478bd9Sstevel@tonic-gate j++; 29897c478bd9Sstevel@tonic-gate bootptr += sizeof (struct ipart); 29907c478bd9Sstevel@tonic-gate } 29917c478bd9Sstevel@tonic-gate } 29927c478bd9Sstevel@tonic-gate for (i = j; i < FD_NUMPART; i++) { 29937c478bd9Sstevel@tonic-gate Table[i].systid = UNUSED; 29947c478bd9Sstevel@tonic-gate Table[i].numsect = lel(UNUSED); 29957c478bd9Sstevel@tonic-gate Table[i].relsect = lel(UNUSED); 29967c478bd9Sstevel@tonic-gate Table[i].bootid = 0; 29977c478bd9Sstevel@tonic-gate 29987c478bd9Sstevel@tonic-gate } 29997c478bd9Sstevel@tonic-gate /* For now, always replace the bootcode with ours */ 3000bb16350dSlclee (void) memcpy(Bootblk->bootinst, &BootCod, BOOTSZ); 30017c478bd9Sstevel@tonic-gate copy_Table_to_Bootblk(); 30027c478bd9Sstevel@tonic-gate } 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate /* 30057c478bd9Sstevel@tonic-gate * fill_ipart 30067c478bd9Sstevel@tonic-gate * Initialize ipart structure values. 30077c478bd9Sstevel@tonic-gate */ 3008bb16350dSlclee static void 30097c478bd9Sstevel@tonic-gate fill_ipart(char *bootptr, struct ipart *partp) 30107c478bd9Sstevel@tonic-gate { 30117c478bd9Sstevel@tonic-gate #ifdef sparc 30127c478bd9Sstevel@tonic-gate /* Packing struct ipart for Sparc */ 3013bb16350dSlclee partp->bootid = getbyte(&bootptr); 3014bb16350dSlclee partp->beghead = getbyte(&bootptr); 3015bb16350dSlclee partp->begsect = getbyte(&bootptr); 3016bb16350dSlclee partp->begcyl = getbyte(&bootptr); 3017bb16350dSlclee partp->systid = getbyte(&bootptr); 3018bb16350dSlclee partp->endhead = getbyte(&bootptr); 3019bb16350dSlclee partp->endsect = getbyte(&bootptr); 3020bb16350dSlclee partp->endcyl = getbyte(&bootptr); 3021bb16350dSlclee partp->relsect = (int32_t)getlong(&bootptr); 3022bb16350dSlclee partp->numsect = (int32_t)getlong(&bootptr); 30237c478bd9Sstevel@tonic-gate #else 30247c478bd9Sstevel@tonic-gate *partp = *(struct ipart *)bootptr; 30257c478bd9Sstevel@tonic-gate #endif 30267c478bd9Sstevel@tonic-gate } 30277c478bd9Sstevel@tonic-gate 30287c478bd9Sstevel@tonic-gate /* 3029bb16350dSlclee * getbyte, getlong 30307c478bd9Sstevel@tonic-gate * Get a byte, a short, or a long (SPARC only). 30317c478bd9Sstevel@tonic-gate */ 30327c478bd9Sstevel@tonic-gate #ifdef sparc 3033bb16350dSlclee uchar_t 3034bb16350dSlclee getbyte(char **bp) 30357c478bd9Sstevel@tonic-gate { 3036bb16350dSlclee uchar_t b; 30377c478bd9Sstevel@tonic-gate 3038bb16350dSlclee b = (uchar_t)**bp; 30397c478bd9Sstevel@tonic-gate *bp = *bp + 1; 30407c478bd9Sstevel@tonic-gate return (b); 30417c478bd9Sstevel@tonic-gate } 30427c478bd9Sstevel@tonic-gate 3043bb16350dSlclee uint32_t 3044bb16350dSlclee getlong(char **bp) 30457c478bd9Sstevel@tonic-gate { 3046bb16350dSlclee int32_t b, bh, bl; 30477c478bd9Sstevel@tonic-gate 30487c478bd9Sstevel@tonic-gate bh = ((**bp) << 8) | *(*bp + 1); 30497c478bd9Sstevel@tonic-gate *bp += 2; 30507c478bd9Sstevel@tonic-gate bl = ((**bp) << 8) | *(*bp + 1); 30517c478bd9Sstevel@tonic-gate *bp += 2; 30527c478bd9Sstevel@tonic-gate 30537c478bd9Sstevel@tonic-gate b = (bh << 16) | bl; 3054bb16350dSlclee return ((uint32_t)b); 30557c478bd9Sstevel@tonic-gate } 30567c478bd9Sstevel@tonic-gate #endif 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate /* 30597c478bd9Sstevel@tonic-gate * copy_Table_to_Bootblk 30607c478bd9Sstevel@tonic-gate * Copy the table into the 512 boot record. Note that the unused 30617c478bd9Sstevel@tonic-gate * entries will always be the last ones in the table and they are 30627c478bd9Sstevel@tonic-gate * marked with 100 in sysind. The the unused portion of the table 30637c478bd9Sstevel@tonic-gate * is padded with zeros in the bytes after the used entries. 30647c478bd9Sstevel@tonic-gate */ 3065bb16350dSlclee static void 3066bb16350dSlclee copy_Table_to_Bootblk(void) 30677c478bd9Sstevel@tonic-gate { 30687c478bd9Sstevel@tonic-gate struct ipart *boot_ptr, *tbl_ptr; 30697c478bd9Sstevel@tonic-gate 30707c478bd9Sstevel@tonic-gate boot_ptr = (struct ipart *)Bootblk->parts; 30717c478bd9Sstevel@tonic-gate tbl_ptr = (struct ipart *)&Table[0].bootid; 30727c478bd9Sstevel@tonic-gate for (; tbl_ptr < (struct ipart *)&Table[FD_NUMPART].bootid; 30737c478bd9Sstevel@tonic-gate tbl_ptr++, boot_ptr++) { 30741237e847Slclee if (tbl_ptr->systid == UNUSED) 30751237e847Slclee (void) memset(boot_ptr, 0, sizeof (struct ipart)); 30761237e847Slclee else 30771237e847Slclee (void) memcpy(boot_ptr, tbl_ptr, sizeof (struct ipart)); 30787c478bd9Sstevel@tonic-gate } 30797c478bd9Sstevel@tonic-gate Bootblk->signature = les(MBB_MAGIC); 30807c478bd9Sstevel@tonic-gate } 30817c478bd9Sstevel@tonic-gate 30827c478bd9Sstevel@tonic-gate /* 30837c478bd9Sstevel@tonic-gate * TableChanged 30847c478bd9Sstevel@tonic-gate * Check for any changes in the partition table. 30857c478bd9Sstevel@tonic-gate */ 3086bb16350dSlclee static int 3087bb16350dSlclee TableChanged(void) 30887c478bd9Sstevel@tonic-gate { 30897c478bd9Sstevel@tonic-gate int i, changed; 30907c478bd9Sstevel@tonic-gate 30917c478bd9Sstevel@tonic-gate changed = 0; 30927c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 30931237e847Slclee if (memcmp(&Old_Table[i], &Table[i], sizeof (Table[0])) != 0) { 30941237e847Slclee /* Partition table changed, write back to disk */ 30951237e847Slclee changed = 1; 30961237e847Slclee } 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate 30997c478bd9Sstevel@tonic-gate return (changed); 31007c478bd9Sstevel@tonic-gate } 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate /* 31037c478bd9Sstevel@tonic-gate * ffile_write 31047c478bd9Sstevel@tonic-gate * Display contents of partition table to standard output or 31057c478bd9Sstevel@tonic-gate * another file name without writing it to the disk (-W file). 31067c478bd9Sstevel@tonic-gate */ 3107bb16350dSlclee static void 3108bb16350dSlclee ffile_write(char *file) 31097c478bd9Sstevel@tonic-gate { 31107c478bd9Sstevel@tonic-gate register int i; 31117c478bd9Sstevel@tonic-gate FILE *fp; 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate /* 31147c478bd9Sstevel@tonic-gate * If file isn't standard output, then it's a file name. 31157c478bd9Sstevel@tonic-gate * Open file and write it. 31167c478bd9Sstevel@tonic-gate */ 31177c478bd9Sstevel@tonic-gate if (file != (char *)stdout) { 31181237e847Slclee if ((fp = fopen(file, "w")) == NULL) { 31191237e847Slclee (void) fprintf(stderr, 31201237e847Slclee "fdisk: Cannot open output file %s.\n", 31211237e847Slclee file); 31221237e847Slclee exit(1); 31231237e847Slclee } 31247c478bd9Sstevel@tonic-gate } 31257c478bd9Sstevel@tonic-gate else 31261237e847Slclee fp = stdout; 31277c478bd9Sstevel@tonic-gate 31287c478bd9Sstevel@tonic-gate /* 31297c478bd9Sstevel@tonic-gate * Write the fdisk table information 31307c478bd9Sstevel@tonic-gate */ 3131bb16350dSlclee (void) fprintf(fp, "\n* %s default fdisk table\n", Dfltdev); 3132bb16350dSlclee (void) fprintf(fp, "* Dimensions:\n"); 3133bb16350dSlclee (void) fprintf(fp, "* %4d bytes/sector\n", sectsiz); 3134bb16350dSlclee (void) fprintf(fp, "* %4d sectors/track\n", sectors); 3135bb16350dSlclee (void) fprintf(fp, "* %4d tracks/cylinder\n", heads); 3136bb16350dSlclee (void) fprintf(fp, "* %4d cylinders\n", Numcyl); 3137bb16350dSlclee (void) fprintf(fp, "*\n"); 31387c478bd9Sstevel@tonic-gate /* Write virtual (HBA) geometry, if required */ 31397c478bd9Sstevel@tonic-gate if (v_flag) { 3140bb16350dSlclee (void) fprintf(fp, "* HBA Dimensions:\n"); 3141bb16350dSlclee (void) fprintf(fp, "* %4d bytes/sector\n", sectsiz); 3142bb16350dSlclee (void) fprintf(fp, "* %4d sectors/track\n", hba_sectors); 3143bb16350dSlclee (void) fprintf(fp, "* %4d tracks/cylinder\n", hba_heads); 3144bb16350dSlclee (void) fprintf(fp, "* %4d cylinders\n", hba_Numcyl); 3145bb16350dSlclee (void) fprintf(fp, "*\n"); 3146bb16350dSlclee } 3147bb16350dSlclee (void) fprintf(fp, "* systid:\n"); 3148bb16350dSlclee (void) fprintf(fp, "* 1: DOSOS12\n"); 3149bb16350dSlclee (void) fprintf(fp, "* 2: PCIXOS\n"); 3150bb16350dSlclee (void) fprintf(fp, "* 4: DOSOS16\n"); 3151bb16350dSlclee (void) fprintf(fp, "* 5: EXTDOS\n"); 3152bb16350dSlclee (void) fprintf(fp, "* 6: DOSBIG\n"); 3153bb16350dSlclee (void) fprintf(fp, "* 7: FDISK_IFS\n"); 3154bb16350dSlclee (void) fprintf(fp, "* 8: FDISK_AIXBOOT\n"); 3155bb16350dSlclee (void) fprintf(fp, "* 9: FDISK_AIXDATA\n"); 3156bb16350dSlclee (void) fprintf(fp, "* 10: FDISK_0S2BOOT\n"); 3157bb16350dSlclee (void) fprintf(fp, "* 11: FDISK_WINDOWS\n"); 3158bb16350dSlclee (void) fprintf(fp, "* 12: FDISK_EXT_WIN\n"); 3159bb16350dSlclee (void) fprintf(fp, "* 14: FDISK_FAT95\n"); 3160bb16350dSlclee (void) fprintf(fp, "* 15: FDISK_EXTLBA\n"); 3161bb16350dSlclee (void) fprintf(fp, "* 18: DIAGPART\n"); 3162bb16350dSlclee (void) fprintf(fp, "* 65: FDISK_LINUX\n"); 3163bb16350dSlclee (void) fprintf(fp, "* 82: FDISK_CPM\n"); 3164bb16350dSlclee (void) fprintf(fp, "* 86: DOSDATA\n"); 3165bb16350dSlclee (void) fprintf(fp, "* 98: OTHEROS\n"); 3166bb16350dSlclee (void) fprintf(fp, "* 99: UNIXOS\n"); 3167bb16350dSlclee (void) fprintf(fp, "* 101: FDISK_NOVELL3\n"); 3168bb16350dSlclee (void) fprintf(fp, "* 119: FDISK_QNX4\n"); 3169bb16350dSlclee (void) fprintf(fp, "* 120: FDISK_QNX42\n"); 3170bb16350dSlclee (void) fprintf(fp, "* 121: FDISK_QNX43\n"); 3171bb16350dSlclee (void) fprintf(fp, "* 130: SUNIXOS\n"); 3172bb16350dSlclee (void) fprintf(fp, "* 131: FDISK_LINUXNAT\n"); 3173bb16350dSlclee (void) fprintf(fp, "* 134: FDISK_NTFSVOL1\n"); 3174bb16350dSlclee (void) fprintf(fp, "* 135: FDISK_NTFSVOL2\n"); 3175bb16350dSlclee (void) fprintf(fp, "* 165: FDISK_BSD\n"); 3176bb16350dSlclee (void) fprintf(fp, "* 167: FDISK_NEXTSTEP\n"); 3177bb16350dSlclee (void) fprintf(fp, "* 183: FDISK_BSDIFS\n"); 3178bb16350dSlclee (void) fprintf(fp, "* 184: FDISK_BSDISWAP\n"); 3179bb16350dSlclee (void) fprintf(fp, "* 190: X86BOOT\n"); 3180bb16350dSlclee (void) fprintf(fp, "* 191: SUNIXOS2\n"); 3181bb16350dSlclee (void) fprintf(fp, "* 238: EFI_PMBR\n"); 3182bb16350dSlclee (void) fprintf(fp, "* 239: EFI_FS\n"); 3183bb16350dSlclee (void) fprintf(fp, "*\n"); 3184bb16350dSlclee (void) fprintf(fp, 31857c478bd9Sstevel@tonic-gate "\n* Id Act Bhead Bsect Bcyl Ehead Esect Ecyl" 3186*342440ecSPrasad Singamsetty " Rsect Numsect\n"); 3187*342440ecSPrasad Singamsetty 31887c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 31897c478bd9Sstevel@tonic-gate if (Table[i].systid != UNUSED) 3190bb16350dSlclee (void) fprintf(fp, 3191*342440ecSPrasad Singamsetty " %-5d %-4d %-6d %-6d %-7d %-6d %-6d %-7d %-10u" 3192*342440ecSPrasad Singamsetty " %-10u\n", 31937c478bd9Sstevel@tonic-gate Table[i].systid, 31947c478bd9Sstevel@tonic-gate Table[i].bootid, 31957c478bd9Sstevel@tonic-gate Table[i].beghead, 31967c478bd9Sstevel@tonic-gate Table[i].begsect & 0x3f, 31977c478bd9Sstevel@tonic-gate ((Table[i].begcyl & 0xff) | ((Table[i].begsect & 31981237e847Slclee 0xc0) << 2)), 31997c478bd9Sstevel@tonic-gate Table[i].endhead, 32007c478bd9Sstevel@tonic-gate Table[i].endsect & 0x3f, 32017c478bd9Sstevel@tonic-gate ((Table[i].endcyl & 0xff) | ((Table[i].endsect & 32021237e847Slclee 0xc0) << 2)), 32037c478bd9Sstevel@tonic-gate lel(Table[i].relsect), 32047c478bd9Sstevel@tonic-gate lel(Table[i].numsect)); 32057c478bd9Sstevel@tonic-gate } 32067c478bd9Sstevel@tonic-gate if (fp != stdout) 3207bb16350dSlclee (void) fclose(fp); 32087c478bd9Sstevel@tonic-gate } 32097c478bd9Sstevel@tonic-gate 32107c478bd9Sstevel@tonic-gate /* 32117c478bd9Sstevel@tonic-gate * fix_slice 32127c478bd9Sstevel@tonic-gate * Read the VTOC table on the Solaris partition and check that no 32137c478bd9Sstevel@tonic-gate * slices exist that extend past the end of the Solaris partition. 32147c478bd9Sstevel@tonic-gate * If no Solaris partition exists, nothing is done. 32157c478bd9Sstevel@tonic-gate */ 3216bb16350dSlclee static void 3217bb16350dSlclee fix_slice(void) 32187c478bd9Sstevel@tonic-gate { 32197c478bd9Sstevel@tonic-gate int i; 3220*342440ecSPrasad Singamsetty uint32_t numsect; 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate if (io_image) { 3223bb16350dSlclee return; 32247c478bd9Sstevel@tonic-gate } 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate for (i = 0; i < FD_NUMPART; i++) { 32277c478bd9Sstevel@tonic-gate if (Table[i].systid == SUNIXOS || Table[i].systid == SUNIXOS2) { 32287c478bd9Sstevel@tonic-gate /* 32297c478bd9Sstevel@tonic-gate * Only the size matters (not starting point), since 32307c478bd9Sstevel@tonic-gate * VTOC entries are relative to the start of 32317c478bd9Sstevel@tonic-gate * the partition. 32327c478bd9Sstevel@tonic-gate */ 32337c478bd9Sstevel@tonic-gate numsect = lel(Table[i].numsect); 32347c478bd9Sstevel@tonic-gate break; 32357c478bd9Sstevel@tonic-gate } 32367c478bd9Sstevel@tonic-gate } 32377c478bd9Sstevel@tonic-gate 32387c478bd9Sstevel@tonic-gate if (i >= FD_NUMPART) { 32397c478bd9Sstevel@tonic-gate if (!io_nifdisk) { 32407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 32417c478bd9Sstevel@tonic-gate "fdisk: No Solaris partition found - VTOC not" 32427c478bd9Sstevel@tonic-gate " checked.\n"); 32437c478bd9Sstevel@tonic-gate } 3244bb16350dSlclee return; 32457c478bd9Sstevel@tonic-gate } 32467c478bd9Sstevel@tonic-gate 3247bb16350dSlclee if (readvtoc() != VTOC_OK) { 32487c478bd9Sstevel@tonic-gate exit(1); /* Failed to read the VTOC */ 32491237e847Slclee } 32501237e847Slclee for (i = 0; i < V_NUMPAR; i++) { 32511237e847Slclee /* Special case for slice two (entire disk) */ 32521237e847Slclee if (i == 2) { 32531237e847Slclee if (disk_vtoc.v_part[i].p_start != 0) { 32541237e847Slclee (void) fprintf(stderr, 3255*342440ecSPrasad Singamsetty "slice %d starts at %llu, is not at" 32561237e847Slclee " start of partition", 32571237e847Slclee i, disk_vtoc.v_part[i].p_start); 32581237e847Slclee if (!io_nifdisk) { 32591237e847Slclee (void) printf(" adjust ?:"); 32601237e847Slclee if (yesno()) 32617c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_start = 0; 32621237e847Slclee } else { 32631237e847Slclee disk_vtoc.v_part[i].p_start = 0; 32641237e847Slclee (void) fprintf(stderr, " adjusted!\n"); 32657c478bd9Sstevel@tonic-gate } 32661237e847Slclee 32671237e847Slclee } 32681237e847Slclee if (disk_vtoc.v_part[i].p_size != numsect) { 32691237e847Slclee (void) fprintf(stderr, 3270*342440ecSPrasad Singamsetty "slice %d size %llu does not cover" 32711237e847Slclee " complete partition", 32721237e847Slclee i, disk_vtoc.v_part[i].p_size); 32731237e847Slclee if (!io_nifdisk) { 32741237e847Slclee (void) printf(" adjust ?:"); 32751237e847Slclee if (yesno()) 32767c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_size = 32777c478bd9Sstevel@tonic-gate numsect; 32781237e847Slclee } else { 32791237e847Slclee disk_vtoc.v_part[i].p_size = numsect; 32801237e847Slclee (void) fprintf(stderr, " adjusted!\n"); 32817c478bd9Sstevel@tonic-gate } 32821237e847Slclee } 32831237e847Slclee if (disk_vtoc.v_part[i].p_tag != V_BACKUP) { 32841237e847Slclee (void) fprintf(stderr, 32851237e847Slclee "slice %d tag was %d should be %d", 32861237e847Slclee i, disk_vtoc.v_part[i].p_tag, 32871237e847Slclee V_BACKUP); 32881237e847Slclee if (!io_nifdisk) { 3289bb16350dSlclee (void) printf(" fix ?:"); 32901237e847Slclee if (yesno()) 32917c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_tag = 32927c478bd9Sstevel@tonic-gate V_BACKUP; 32931237e847Slclee } else { 32947c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_tag = V_BACKUP; 32957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, " fixed!\n"); 32967c478bd9Sstevel@tonic-gate } 32971237e847Slclee } 32981237e847Slclee continue; 32991237e847Slclee } 33001237e847Slclee if (io_ADJT) { 33011237e847Slclee if (disk_vtoc.v_part[i].p_start > numsect || 33021237e847Slclee disk_vtoc.v_part[i].p_start + 33031237e847Slclee disk_vtoc.v_part[i].p_size > numsect) { 33041237e847Slclee (void) fprintf(stderr, 3305*342440ecSPrasad Singamsetty "slice %d (start %llu, end %llu)" 33061237e847Slclee " is larger than the partition", 33071237e847Slclee i, disk_vtoc.v_part[i].p_start, 33081237e847Slclee disk_vtoc.v_part[i].p_start + 33091237e847Slclee disk_vtoc.v_part[i].p_size); 33101237e847Slclee if (!io_nifdisk) { 33111237e847Slclee (void) printf(" remove ?:"); 33121237e847Slclee if (yesno()) { 33137c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_size = 0; 33147c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_start = 0; 33157c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_tag = 0; 33167c478bd9Sstevel@tonic-gate disk_vtoc.v_part[i].p_flag = 0; 33177c478bd9Sstevel@tonic-gate } 33187c478bd9Sstevel@tonic-gate } else { 33191237e847Slclee disk_vtoc.v_part[i].p_size = 0; 33201237e847Slclee disk_vtoc.v_part[i].p_start = 0; 33211237e847Slclee disk_vtoc.v_part[i].p_tag = 0; 33221237e847Slclee disk_vtoc.v_part[i].p_flag = 0; 33237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 33241237e847Slclee " removed!\n"); 33257c478bd9Sstevel@tonic-gate } 33267c478bd9Sstevel@tonic-gate } 33271237e847Slclee continue; 33281237e847Slclee } 33291237e847Slclee if (disk_vtoc.v_part[i].p_start > numsect) { 33301237e847Slclee (void) fprintf(stderr, 3331*342440ecSPrasad Singamsetty "slice %d (start %llu) is larger than the " 3332*342440ecSPrasad Singamsetty "partition", i, disk_vtoc.v_part[i].p_start); 33331237e847Slclee if (!io_nifdisk) { 33341237e847Slclee (void) printf(" remove ?:"); 33351237e847Slclee if (yesno()) { 33361237e847Slclee disk_vtoc.v_part[i].p_size = 0; 33371237e847Slclee disk_vtoc.v_part[i].p_start = 0; 33381237e847Slclee disk_vtoc.v_part[i].p_tag = 0; 33391237e847Slclee disk_vtoc.v_part[i].p_flag = 0; 33401237e847Slclee } 33411237e847Slclee } else { 33421237e847Slclee disk_vtoc.v_part[i].p_size = 0; 33431237e847Slclee disk_vtoc.v_part[i].p_start = 0; 33441237e847Slclee disk_vtoc.v_part[i].p_tag = 0; 33451237e847Slclee disk_vtoc.v_part[i].p_flag = 0; 33461237e847Slclee (void) fprintf(stderr, 33471237e847Slclee " removed!\n"); 33481237e847Slclee } 33491237e847Slclee } else if (disk_vtoc.v_part[i].p_start 33501237e847Slclee + disk_vtoc.v_part[i].p_size > numsect) { 33511237e847Slclee (void) fprintf(stderr, 3352*342440ecSPrasad Singamsetty "slice %d (end %llu) is larger" 33531237e847Slclee " than the partition", 33541237e847Slclee i, 33551237e847Slclee disk_vtoc.v_part[i].p_start + 33561237e847Slclee disk_vtoc.v_part[i].p_size); 33571237e847Slclee if (!io_nifdisk) { 33581237e847Slclee (void) printf(" adjust ?:"); 33591237e847Slclee if (yesno()) { 33601237e847Slclee disk_vtoc.v_part[i].p_size = numsect; 33611237e847Slclee } 33621237e847Slclee } else { 33631237e847Slclee disk_vtoc.v_part[i].p_size = numsect; 33641237e847Slclee (void) fprintf(stderr, " adjusted!\n"); 33651237e847Slclee } 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate } 33687c478bd9Sstevel@tonic-gate #if 1 /* bh for now */ 33697c478bd9Sstevel@tonic-gate /* Make the VTOC look sane - ha ha */ 33707c478bd9Sstevel@tonic-gate disk_vtoc.v_version = V_VERSION; 33717c478bd9Sstevel@tonic-gate disk_vtoc.v_sanity = VTOC_SANE; 33727c478bd9Sstevel@tonic-gate disk_vtoc.v_nparts = V_NUMPAR; 33737c478bd9Sstevel@tonic-gate if (disk_vtoc.v_sectorsz == 0) 33747c478bd9Sstevel@tonic-gate disk_vtoc.v_sectorsz = NBPSCTR; 33757c478bd9Sstevel@tonic-gate #endif 33767c478bd9Sstevel@tonic-gate 33777c478bd9Sstevel@tonic-gate /* Write the VTOC back to the disk */ 33787c478bd9Sstevel@tonic-gate if (!io_readonly) 3379bb16350dSlclee (void) writevtoc(); 33807c478bd9Sstevel@tonic-gate } 33817c478bd9Sstevel@tonic-gate 33827c478bd9Sstevel@tonic-gate /* 33837c478bd9Sstevel@tonic-gate * yesno 33847c478bd9Sstevel@tonic-gate * Get yes or no answer. Return 1 for yes and 0 for no. 33857c478bd9Sstevel@tonic-gate */ 33867c478bd9Sstevel@tonic-gate 3387bb16350dSlclee static int 3388bb16350dSlclee yesno(void) 33897c478bd9Sstevel@tonic-gate { 33907c478bd9Sstevel@tonic-gate char s[80]; 33917c478bd9Sstevel@tonic-gate 33927c478bd9Sstevel@tonic-gate for (;;) { 3393bb16350dSlclee (void) gets(s); 33947c478bd9Sstevel@tonic-gate rm_blanks(s); 33957c478bd9Sstevel@tonic-gate if ((s[1] != 0) || ((s[0] != 'y') && (s[0] != 'n'))) { 3396bb16350dSlclee (void) printf(E_LINE); 3397bb16350dSlclee (void) printf("Please answer with \"y\" or \"n\": "); 33987c478bd9Sstevel@tonic-gate continue; 33997c478bd9Sstevel@tonic-gate } 34007c478bd9Sstevel@tonic-gate if (s[0] == 'y') 34017c478bd9Sstevel@tonic-gate return (1); 34027c478bd9Sstevel@tonic-gate else 34037c478bd9Sstevel@tonic-gate return (0); 34047c478bd9Sstevel@tonic-gate } 34057c478bd9Sstevel@tonic-gate } 34067c478bd9Sstevel@tonic-gate 34077c478bd9Sstevel@tonic-gate /* 34087c478bd9Sstevel@tonic-gate * readvtoc 34097c478bd9Sstevel@tonic-gate * Read the VTOC from the Solaris partition of the device. 34107c478bd9Sstevel@tonic-gate */ 3411bb16350dSlclee static int 3412bb16350dSlclee readvtoc(void) 34137c478bd9Sstevel@tonic-gate { 34147c478bd9Sstevel@tonic-gate int i; 34157c478bd9Sstevel@tonic-gate int retval = VTOC_OK; 34167c478bd9Sstevel@tonic-gate 3417*342440ecSPrasad Singamsetty if ((i = read_extvtoc(Dev, &disk_vtoc)) < VTOC_OK) { 34187c478bd9Sstevel@tonic-gate if (i == VT_EINVAL) { 34197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: Invalid VTOC.\n"); 34207c478bd9Sstevel@tonic-gate vt_inval++; 34217c478bd9Sstevel@tonic-gate retval = VTOC_INVAL; 34227c478bd9Sstevel@tonic-gate } else if (i == VT_ENOTSUP) { 34237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: partition may have EFI " 34241237e847Slclee "GPT\n"); 34257c478bd9Sstevel@tonic-gate retval = VTOC_NOTSUP; 34267c478bd9Sstevel@tonic-gate } else { 34277c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: Cannot read VTOC.\n"); 34287c478bd9Sstevel@tonic-gate retval = VTOC_RWERR; 34297c478bd9Sstevel@tonic-gate } 34307c478bd9Sstevel@tonic-gate } 34317c478bd9Sstevel@tonic-gate return (retval); 34327c478bd9Sstevel@tonic-gate } 34337c478bd9Sstevel@tonic-gate 34347c478bd9Sstevel@tonic-gate /* 34357c478bd9Sstevel@tonic-gate * writevtoc 34367c478bd9Sstevel@tonic-gate * Write the VTOC to the Solaris partition on the device. 34377c478bd9Sstevel@tonic-gate */ 3438bb16350dSlclee static int 3439bb16350dSlclee writevtoc(void) 34407c478bd9Sstevel@tonic-gate { 34417c478bd9Sstevel@tonic-gate int i; 34427c478bd9Sstevel@tonic-gate int retval = 0; 34437c478bd9Sstevel@tonic-gate 3444*342440ecSPrasad Singamsetty if ((i = write_extvtoc(Dev, &disk_vtoc)) != 0) { 34457c478bd9Sstevel@tonic-gate if (i == VT_EINVAL) { 34467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 34477c478bd9Sstevel@tonic-gate "fdisk: Invalid entry exists in VTOC.\n"); 34487c478bd9Sstevel@tonic-gate retval = VTOC_INVAL; 34497c478bd9Sstevel@tonic-gate } else if (i == VT_ENOTSUP) { 34507c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: partition may have EFI " 34511237e847Slclee "GPT\n"); 34527c478bd9Sstevel@tonic-gate retval = VTOC_NOTSUP; 34537c478bd9Sstevel@tonic-gate } else { 34547c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "fdisk: Cannot write VTOC.\n"); 34557c478bd9Sstevel@tonic-gate retval = VTOC_RWERR; 34567c478bd9Sstevel@tonic-gate } 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate return (retval); 34597c478bd9Sstevel@tonic-gate } 34607c478bd9Sstevel@tonic-gate 34617c478bd9Sstevel@tonic-gate /* 34627c478bd9Sstevel@tonic-gate * efi_ioctl 34637c478bd9Sstevel@tonic-gate * issues DKIOCSETEFI IOCTL 34647c478bd9Sstevel@tonic-gate * (duplicate of private efi_ioctl() in rdwr_efi.c 34657c478bd9Sstevel@tonic-gate */ 34667c478bd9Sstevel@tonic-gate static int 34677c478bd9Sstevel@tonic-gate efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc) 34687c478bd9Sstevel@tonic-gate { 34697c478bd9Sstevel@tonic-gate void *data = dk_ioc->dki_data; 34707c478bd9Sstevel@tonic-gate int error; 34717c478bd9Sstevel@tonic-gate 34727c478bd9Sstevel@tonic-gate dk_ioc->dki_data_64 = (uintptr_t)data; 34737c478bd9Sstevel@tonic-gate error = ioctl(fd, cmd, (void *)dk_ioc); 34747c478bd9Sstevel@tonic-gate 34757c478bd9Sstevel@tonic-gate return (error); 34767c478bd9Sstevel@tonic-gate } 34777c478bd9Sstevel@tonic-gate 34787c478bd9Sstevel@tonic-gate /* 34797c478bd9Sstevel@tonic-gate * clear_efi 34807c478bd9Sstevel@tonic-gate * Clear EFI labels from the EFI_PMBR partition on the device 34817c478bd9Sstevel@tonic-gate * This function is modeled on the libefi(3LIB) call efi_write() 34827c478bd9Sstevel@tonic-gate */ 3483bb16350dSlclee static int 3484bb16350dSlclee clear_efi(void) 34857c478bd9Sstevel@tonic-gate { 34867c478bd9Sstevel@tonic-gate struct dk_gpt *efi_vtoc; 34877c478bd9Sstevel@tonic-gate dk_efi_t dk_ioc; 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate /* 34907c478bd9Sstevel@tonic-gate * see if we can read the EFI label 34917c478bd9Sstevel@tonic-gate */ 34927c478bd9Sstevel@tonic-gate if (efi_alloc_and_read(Dev, &efi_vtoc) < 0) { 34937c478bd9Sstevel@tonic-gate return (VT_ERROR); 34947c478bd9Sstevel@tonic-gate } 34957c478bd9Sstevel@tonic-gate 34967c478bd9Sstevel@tonic-gate /* 34977c478bd9Sstevel@tonic-gate * set up the dk_ioc structure for writing 34987c478bd9Sstevel@tonic-gate */ 34997c478bd9Sstevel@tonic-gate dk_ioc.dki_lba = 1; 35007c478bd9Sstevel@tonic-gate dk_ioc.dki_length = EFI_MIN_ARRAY_SIZE + efi_vtoc->efi_lbasize; 35017c478bd9Sstevel@tonic-gate 35027c478bd9Sstevel@tonic-gate if ((dk_ioc.dki_data = calloc(dk_ioc.dki_length, 1)) == NULL) { 35037c478bd9Sstevel@tonic-gate return (VT_ERROR); 35047c478bd9Sstevel@tonic-gate } 35057c478bd9Sstevel@tonic-gate 35067c478bd9Sstevel@tonic-gate /* 35077c478bd9Sstevel@tonic-gate * clear the primary label 35087c478bd9Sstevel@tonic-gate */ 35097c478bd9Sstevel@tonic-gate if (io_debug) { 3510bb16350dSlclee (void) fprintf(stderr, 3511bb16350dSlclee "\tClearing primary EFI label at block %lld\n", 3512bb16350dSlclee dk_ioc.dki_lba); 35137c478bd9Sstevel@tonic-gate } 35147c478bd9Sstevel@tonic-gate 35157c478bd9Sstevel@tonic-gate if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 35167c478bd9Sstevel@tonic-gate free(dk_ioc.dki_data); 35177c478bd9Sstevel@tonic-gate switch (errno) { 35187c478bd9Sstevel@tonic-gate case EIO: 35197c478bd9Sstevel@tonic-gate return (VT_EIO); 35207c478bd9Sstevel@tonic-gate case EINVAL: 35217c478bd9Sstevel@tonic-gate return (VT_EINVAL); 35227c478bd9Sstevel@tonic-gate default: 35237c478bd9Sstevel@tonic-gate return (VT_ERROR); 35247c478bd9Sstevel@tonic-gate } 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate /* 35287c478bd9Sstevel@tonic-gate * clear the backup partition table 35297c478bd9Sstevel@tonic-gate */ 35307c478bd9Sstevel@tonic-gate dk_ioc.dki_lba = efi_vtoc->efi_last_u_lba + 1; 35317c478bd9Sstevel@tonic-gate dk_ioc.dki_length -= efi_vtoc->efi_lbasize; 35327c478bd9Sstevel@tonic-gate dk_ioc.dki_data++; 35337c478bd9Sstevel@tonic-gate if (io_debug) { 3534bb16350dSlclee (void) fprintf(stderr, 3535bb16350dSlclee "\tClearing backup partition table at block %lld\n", 3536bb16350dSlclee dk_ioc.dki_lba); 35377c478bd9Sstevel@tonic-gate } 35387c478bd9Sstevel@tonic-gate 35397c478bd9Sstevel@tonic-gate if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 35407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\tUnable to clear backup EFI label at " 35411237e847Slclee "block %llu; errno %d\n", efi_vtoc->efi_last_u_lba + 1, 35421237e847Slclee errno); 35437c478bd9Sstevel@tonic-gate } 35447c478bd9Sstevel@tonic-gate 35457c478bd9Sstevel@tonic-gate /* 35467c478bd9Sstevel@tonic-gate * clear the backup label 35477c478bd9Sstevel@tonic-gate */ 35487c478bd9Sstevel@tonic-gate dk_ioc.dki_lba = efi_vtoc->efi_last_lba; 35497c478bd9Sstevel@tonic-gate dk_ioc.dki_length = efi_vtoc->efi_lbasize; 35507c478bd9Sstevel@tonic-gate dk_ioc.dki_data--; 35517c478bd9Sstevel@tonic-gate if (io_debug) { 3552bb16350dSlclee (void) fprintf(stderr, "\tClearing backup label at block " 3553bb16350dSlclee "%lld\n", dk_ioc.dki_lba); 35547c478bd9Sstevel@tonic-gate } 35557c478bd9Sstevel@tonic-gate 35567c478bd9Sstevel@tonic-gate if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 3557bb16350dSlclee (void) fprintf(stderr, 3558bb16350dSlclee "\tUnable to clear backup EFI label at " 3559bb16350dSlclee "block %llu; errno %d\n", 3560bb16350dSlclee efi_vtoc->efi_last_lba, 3561bb16350dSlclee errno); 35627c478bd9Sstevel@tonic-gate } 35637c478bd9Sstevel@tonic-gate 35647c478bd9Sstevel@tonic-gate free(dk_ioc.dki_data); 35657c478bd9Sstevel@tonic-gate efi_free(efi_vtoc); 35667c478bd9Sstevel@tonic-gate 35677c478bd9Sstevel@tonic-gate return (0); 35687c478bd9Sstevel@tonic-gate } 35697c478bd9Sstevel@tonic-gate 35707c478bd9Sstevel@tonic-gate /* 35717c478bd9Sstevel@tonic-gate * clear_vtoc 35727c478bd9Sstevel@tonic-gate * Clear the VTOC from the current or previous Solaris partition on the 35737c478bd9Sstevel@tonic-gate * device. 35747c478bd9Sstevel@tonic-gate */ 3575bb16350dSlclee static void 35767c478bd9Sstevel@tonic-gate clear_vtoc(int table, int part) 35777c478bd9Sstevel@tonic-gate { 35787c478bd9Sstevel@tonic-gate struct ipart *clr_table; 35797c478bd9Sstevel@tonic-gate struct dk_label disk_label; 3580*342440ecSPrasad Singamsetty uint32_t pcyl, ncyl, count; 3581*342440ecSPrasad Singamsetty diskaddr_t backup_block, solaris_offset; 3582*342440ecSPrasad Singamsetty ssize_t bytes; 35839d5d1945Sbharding off_t seek_byte; 35847c478bd9Sstevel@tonic-gate 35857c478bd9Sstevel@tonic-gate #ifdef DEBUG 35867c478bd9Sstevel@tonic-gate struct dk_label read_label; 35877c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate if (table == OLD) { 35907c478bd9Sstevel@tonic-gate clr_table = &Old_Table[part]; 35917c478bd9Sstevel@tonic-gate } else { 35927c478bd9Sstevel@tonic-gate clr_table = &Table[part]; 35937c478bd9Sstevel@tonic-gate } 35947c478bd9Sstevel@tonic-gate 3595bb16350dSlclee (void) memset(&disk_label, 0, sizeof (struct dk_label)); 35967c478bd9Sstevel@tonic-gate 35979d5d1945Sbharding seek_byte = (off_t)(lel(clr_table->relsect) + VTOC_OFFSET) * sectsiz; 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate if (io_debug) { 36009d5d1945Sbharding (void) fprintf(stderr, 36019d5d1945Sbharding "\tClearing primary VTOC at byte %llu (block %llu)\n", 36029d5d1945Sbharding (uint64_t)seek_byte, 36039d5d1945Sbharding (uint64_t)(lel(clr_table->relsect) + VTOC_OFFSET)); 36047c478bd9Sstevel@tonic-gate } 36057c478bd9Sstevel@tonic-gate 36067c478bd9Sstevel@tonic-gate if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 3607bb16350dSlclee (void) fprintf(stderr, 36089d5d1945Sbharding "\tError seeking to primary label at byte %llu\n", 36099d5d1945Sbharding (uint64_t)seek_byte); 3610bb16350dSlclee return; 36117c478bd9Sstevel@tonic-gate } 36127c478bd9Sstevel@tonic-gate 36137c478bd9Sstevel@tonic-gate bytes = write(Dev, &disk_label, sizeof (struct dk_label)); 36147c478bd9Sstevel@tonic-gate 36157c478bd9Sstevel@tonic-gate if (bytes != sizeof (struct dk_label)) { 3616bb16350dSlclee (void) fprintf(stderr, 3617*342440ecSPrasad Singamsetty "\tWarning: only %d bytes written to clear primary" 3618*342440ecSPrasad Singamsetty " VTOC!\n", bytes); 36197c478bd9Sstevel@tonic-gate } 36207c478bd9Sstevel@tonic-gate 36217c478bd9Sstevel@tonic-gate #ifdef DEBUG 36227c478bd9Sstevel@tonic-gate if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 3623bb16350dSlclee (void) fprintf(stderr, 36249d5d1945Sbharding "DEBUG: Error seeking to primary label at byte %llu\n", 36259d5d1945Sbharding (uint64_t)seek_byte); 3626bb16350dSlclee return; 36277c478bd9Sstevel@tonic-gate } else { 36289d5d1945Sbharding (void) fprintf(stderr, 36299d5d1945Sbharding "DEBUG: Successful lseek() to byte %llu\n", 36309d5d1945Sbharding (uint64_t)seek_byte); 36317c478bd9Sstevel@tonic-gate } 36327c478bd9Sstevel@tonic-gate 36337c478bd9Sstevel@tonic-gate bytes = read(Dev, &read_label, sizeof (struct dk_label)); 36347c478bd9Sstevel@tonic-gate 36357c478bd9Sstevel@tonic-gate if (bytes != sizeof (struct dk_label)) { 3636bb16350dSlclee (void) fprintf(stderr, 3637bb16350dSlclee "DEBUG: Warning: only %d bytes read of label\n", 36387c478bd9Sstevel@tonic-gate bytes); 36397c478bd9Sstevel@tonic-gate } 36407c478bd9Sstevel@tonic-gate 36417c478bd9Sstevel@tonic-gate if (memcmp(&disk_label, &read_label, sizeof (struct dk_label)) != 0) { 3642bb16350dSlclee (void) fprintf(stderr, 3643bb16350dSlclee "DEBUG: Warning: disk_label and read_label differ!!!\n"); 36447c478bd9Sstevel@tonic-gate } else { 3645bb16350dSlclee (void) fprintf(stderr, "DEBUG Good compare of disk_label and " 36467c478bd9Sstevel@tonic-gate "read_label\n"); 36477c478bd9Sstevel@tonic-gate } 36487c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 36497c478bd9Sstevel@tonic-gate 36507c478bd9Sstevel@tonic-gate /* Clear backup label */ 36517c478bd9Sstevel@tonic-gate pcyl = lel(clr_table->numsect) / (heads * sectors); 36527c478bd9Sstevel@tonic-gate solaris_offset = lel(clr_table->relsect); 36537c478bd9Sstevel@tonic-gate ncyl = pcyl - acyl; 36547c478bd9Sstevel@tonic-gate 36557c478bd9Sstevel@tonic-gate backup_block = ((ncyl + acyl - 1) * 36567c478bd9Sstevel@tonic-gate (heads * sectors)) + ((heads - 1) * sectors) + 1; 36577c478bd9Sstevel@tonic-gate 36587c478bd9Sstevel@tonic-gate for (count = 1; count < 6; count++) { 36599d5d1945Sbharding seek_byte = (off_t)(solaris_offset + backup_block) * 512; 36607c478bd9Sstevel@tonic-gate 36617c478bd9Sstevel@tonic-gate if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 3662bb16350dSlclee (void) fprintf(stderr, 36639d5d1945Sbharding "\tError seeking to backup label at byte %llu on " 36649d5d1945Sbharding "%s.\n", (uint64_t)seek_byte, Dfltdev); 3665bb16350dSlclee return; 36667c478bd9Sstevel@tonic-gate } 36677c478bd9Sstevel@tonic-gate 36687c478bd9Sstevel@tonic-gate if (io_debug) { 3669bb16350dSlclee (void) fprintf(stderr, "\tClearing backup VTOC at" 36709d5d1945Sbharding " byte %llu (block %llu)\n", 36719d5d1945Sbharding (uint64_t)seek_byte, 36729d5d1945Sbharding (uint64_t)(solaris_offset + backup_block)); 36737c478bd9Sstevel@tonic-gate } 36747c478bd9Sstevel@tonic-gate 36757c478bd9Sstevel@tonic-gate bytes = write(Dev, &disk_label, sizeof (struct dk_label)); 36767c478bd9Sstevel@tonic-gate 36777c478bd9Sstevel@tonic-gate if (bytes != sizeof (struct dk_label)) { 3678bb16350dSlclee (void) fprintf(stderr, 3679bb16350dSlclee "\t\tWarning: only %d bytes written to " 36809d5d1945Sbharding "clear backup VTOC at block %llu!\n", bytes, 36819d5d1945Sbharding (uint64_t)(solaris_offset + backup_block)); 36827c478bd9Sstevel@tonic-gate } 36837c478bd9Sstevel@tonic-gate 36847c478bd9Sstevel@tonic-gate #ifdef DEBUG 36857c478bd9Sstevel@tonic-gate if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 3686bb16350dSlclee (void) fprintf(stderr, 36879d5d1945Sbharding "DEBUG: Error seeking to backup label at byte %llu\n", 36889d5d1945Sbharding (uint64_t)seek_byte); 3689bb16350dSlclee return; 36907c478bd9Sstevel@tonic-gate } else { 36919d5d1945Sbharding (void) fprintf(stderr, 36929d5d1945Sbharding "DEBUG: Successful lseek() to byte %llu\n", 36939d5d1945Sbharding (uint64_t)seek_byte); 36947c478bd9Sstevel@tonic-gate } 36957c478bd9Sstevel@tonic-gate 36967c478bd9Sstevel@tonic-gate bytes = read(Dev, &read_label, sizeof (struct dk_label)); 36977c478bd9Sstevel@tonic-gate 36987c478bd9Sstevel@tonic-gate if (bytes != sizeof (struct dk_label)) { 3699bb16350dSlclee (void) fprintf(stderr, 3700bb16350dSlclee "DEBUG: Warning: only %d bytes read of backup label\n", 3701bb16350dSlclee bytes); 37027c478bd9Sstevel@tonic-gate } 37037c478bd9Sstevel@tonic-gate 37047c478bd9Sstevel@tonic-gate if (memcmp(&disk_label, &read_label, sizeof (struct dk_label)) != 0) { 3705bb16350dSlclee (void) fprintf(stderr, 3706bb16350dSlclee "DEBUG: Warning: disk_label and read_label differ!!!\n"); 37077c478bd9Sstevel@tonic-gate } else { 3708bb16350dSlclee (void) fprintf(stderr, 3709bb16350dSlclee "DEBUG: Good compare of disk_label and backup " 37107c478bd9Sstevel@tonic-gate "read_label\n"); 37117c478bd9Sstevel@tonic-gate } 37127c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 37137c478bd9Sstevel@tonic-gate 37147c478bd9Sstevel@tonic-gate backup_block += 2; 37157c478bd9Sstevel@tonic-gate } 37167c478bd9Sstevel@tonic-gate } 37177c478bd9Sstevel@tonic-gate 37187c478bd9Sstevel@tonic-gate #define FDISK_STANDARD_LECTURE \ 37197c478bd9Sstevel@tonic-gate "Fdisk is normally used with the device that " \ 37207c478bd9Sstevel@tonic-gate "represents the entire fixed disk.\n" \ 37217c478bd9Sstevel@tonic-gate "(For example, /dev/rdsk/c0d0p0 on x86 or " \ 37227c478bd9Sstevel@tonic-gate "/dev/rdsk/c0t5d0s2 on sparc).\n" 37237c478bd9Sstevel@tonic-gate 37247c478bd9Sstevel@tonic-gate #define FDISK_LECTURE_NOT_SECTOR_ZERO \ 37257c478bd9Sstevel@tonic-gate "The device does not appear to include absolute\n" \ 37267c478bd9Sstevel@tonic-gate "sector 0 of the PHYSICAL disk " \ 37277c478bd9Sstevel@tonic-gate "(the normal location for an fdisk table).\n" 37287c478bd9Sstevel@tonic-gate 37297c478bd9Sstevel@tonic-gate #define FDISK_LECTURE_NOT_FULL \ 37307c478bd9Sstevel@tonic-gate "The device does not appear to encompass the entire PHYSICAL disk.\n" 37317c478bd9Sstevel@tonic-gate 37327c478bd9Sstevel@tonic-gate #define FDISK_LECTURE_NO_VTOC \ 37337c478bd9Sstevel@tonic-gate "Unable to find a volume table of contents.\n" \ 37347c478bd9Sstevel@tonic-gate "Cannot verify the device encompasses the full PHYSICAL disk.\n" 37357c478bd9Sstevel@tonic-gate 37367c478bd9Sstevel@tonic-gate #define FDISK_LECTURE_NO_GEOM \ 37377c478bd9Sstevel@tonic-gate "Unable to get geometry from device.\n" \ 37387c478bd9Sstevel@tonic-gate "Cannot verify the device encompasses the full PHYSICAL disk.\n" 37397c478bd9Sstevel@tonic-gate 37407c478bd9Sstevel@tonic-gate #define FDISK_SHALL_I_CONTINUE \ 37417c478bd9Sstevel@tonic-gate "Are you sure you want to continue? (y/n) " 37427c478bd9Sstevel@tonic-gate 37437c478bd9Sstevel@tonic-gate /* 37447c478bd9Sstevel@tonic-gate * lecture_and_query 37457c478bd9Sstevel@tonic-gate * Called when a sanity check fails. This routine gives a warning 37467c478bd9Sstevel@tonic-gate * specific to the check that fails, followed by a generic lecture 37477c478bd9Sstevel@tonic-gate * about the "right" device to supply as input. Then, if appropriate, 37487c478bd9Sstevel@tonic-gate * it will prompt the user on whether or not they want to continue. 37497c478bd9Sstevel@tonic-gate * Inappropriate times for prompting are when the user has selected 37507c478bd9Sstevel@tonic-gate * non-interactive mode or read-only mode. 37517c478bd9Sstevel@tonic-gate */ 3752bb16350dSlclee static int 37537c478bd9Sstevel@tonic-gate lecture_and_query(char *warning, char *devname) 37547c478bd9Sstevel@tonic-gate { 37557c478bd9Sstevel@tonic-gate if (io_nifdisk) 37567c478bd9Sstevel@tonic-gate return (0); 37577c478bd9Sstevel@tonic-gate 3758bb16350dSlclee (void) fprintf(stderr, "WARNING: Device %s: \n", devname); 3759bb16350dSlclee (void) fprintf(stderr, "%s", warning); 3760bb16350dSlclee (void) fprintf(stderr, FDISK_STANDARD_LECTURE); 3761bb16350dSlclee (void) fprintf(stderr, FDISK_SHALL_I_CONTINUE); 37627c478bd9Sstevel@tonic-gate 37637c478bd9Sstevel@tonic-gate return (yesno()); 37647c478bd9Sstevel@tonic-gate } 37657c478bd9Sstevel@tonic-gate 3766bb16350dSlclee static void 37677c478bd9Sstevel@tonic-gate sanity_check_provided_device(char *devname, int fd) 37687c478bd9Sstevel@tonic-gate { 3769*342440ecSPrasad Singamsetty struct extvtoc v; 37707c478bd9Sstevel@tonic-gate struct dk_geom d; 37717c478bd9Sstevel@tonic-gate struct part_info pi; 3772*342440ecSPrasad Singamsetty struct extpart_info extpi; 3773*342440ecSPrasad Singamsetty diskaddr_t totsize; 37747c478bd9Sstevel@tonic-gate int idx = -1; 37757c478bd9Sstevel@tonic-gate 37767c478bd9Sstevel@tonic-gate /* 37777c478bd9Sstevel@tonic-gate * First try the PARTINFO ioctl. If it works, we will be able 37787c478bd9Sstevel@tonic-gate * to tell if they've specified the full disk partition by checking 37797c478bd9Sstevel@tonic-gate * to see if they've specified a partition that starts at sector 0. 37807c478bd9Sstevel@tonic-gate */ 3781*342440ecSPrasad Singamsetty if (ioctl(fd, DKIOCEXTPARTINFO, &extpi) != -1) { 3782*342440ecSPrasad Singamsetty if (extpi.p_start != 0) { 3783*342440ecSPrasad Singamsetty if (!lecture_and_query(FDISK_LECTURE_NOT_SECTOR_ZERO, 3784*342440ecSPrasad Singamsetty devname)) { 3785*342440ecSPrasad Singamsetty (void) close(fd); 3786*342440ecSPrasad Singamsetty exit(1); 3787*342440ecSPrasad Singamsetty } 3788*342440ecSPrasad Singamsetty } 3789*342440ecSPrasad Singamsetty } else if (ioctl(fd, DKIOCPARTINFO, &pi) != -1) { 37907c478bd9Sstevel@tonic-gate if (pi.p_start != 0) { 37917c478bd9Sstevel@tonic-gate if (!lecture_and_query(FDISK_LECTURE_NOT_SECTOR_ZERO, 37927c478bd9Sstevel@tonic-gate devname)) { 37937c478bd9Sstevel@tonic-gate (void) close(fd); 37947c478bd9Sstevel@tonic-gate exit(1); 37957c478bd9Sstevel@tonic-gate } 37967c478bd9Sstevel@tonic-gate } 37977c478bd9Sstevel@tonic-gate } else { 3798*342440ecSPrasad Singamsetty if ((idx = read_extvtoc(fd, &v)) < 0) { 37997c478bd9Sstevel@tonic-gate if (!lecture_and_query(FDISK_LECTURE_NO_VTOC, 38007c478bd9Sstevel@tonic-gate devname)) { 38017c478bd9Sstevel@tonic-gate (void) close(fd); 38027c478bd9Sstevel@tonic-gate exit(1); 38037c478bd9Sstevel@tonic-gate } 38047c478bd9Sstevel@tonic-gate return; 38057c478bd9Sstevel@tonic-gate } 38067c478bd9Sstevel@tonic-gate if (ioctl(fd, DKIOCGGEOM, &d) == -1) { 38077c478bd9Sstevel@tonic-gate perror(devname); 38087c478bd9Sstevel@tonic-gate if (!lecture_and_query(FDISK_LECTURE_NO_GEOM, 38097c478bd9Sstevel@tonic-gate devname)) { 38107c478bd9Sstevel@tonic-gate (void) close(fd); 38117c478bd9Sstevel@tonic-gate exit(1); 38127c478bd9Sstevel@tonic-gate } 38137c478bd9Sstevel@tonic-gate return; 38147c478bd9Sstevel@tonic-gate } 3815*342440ecSPrasad Singamsetty totsize = (diskaddr_t)d.dkg_ncyl * d.dkg_nhead * d.dkg_nsect; 38167c478bd9Sstevel@tonic-gate if (v.v_part[idx].p_size != totsize) { 38177c478bd9Sstevel@tonic-gate if (!lecture_and_query(FDISK_LECTURE_NOT_FULL, 38187c478bd9Sstevel@tonic-gate devname)) { 38197c478bd9Sstevel@tonic-gate (void) close(fd); 38207c478bd9Sstevel@tonic-gate exit(1); 38217c478bd9Sstevel@tonic-gate } 38227c478bd9Sstevel@tonic-gate } 38237c478bd9Sstevel@tonic-gate } 38247c478bd9Sstevel@tonic-gate } 38257c478bd9Sstevel@tonic-gate 38267c478bd9Sstevel@tonic-gate 38277c478bd9Sstevel@tonic-gate /* 38287c478bd9Sstevel@tonic-gate * get_node 38297c478bd9Sstevel@tonic-gate * Called from main to construct the name of the device node to open. 38307c478bd9Sstevel@tonic-gate * Initially tries to stat the node exactly as provided, if that fails 38317c478bd9Sstevel@tonic-gate * we prepend the default path (/dev/rdsk/). 38327c478bd9Sstevel@tonic-gate */ 38337c478bd9Sstevel@tonic-gate static char * 38347c478bd9Sstevel@tonic-gate get_node(char *devname) 38357c478bd9Sstevel@tonic-gate { 38367c478bd9Sstevel@tonic-gate char *node; 38377c478bd9Sstevel@tonic-gate struct stat statbuf; 38387c478bd9Sstevel@tonic-gate size_t space; 38397c478bd9Sstevel@tonic-gate 38407c478bd9Sstevel@tonic-gate /* Don't do anything if we are skipping device checks */ 38417c478bd9Sstevel@tonic-gate if (io_image) 38427c478bd9Sstevel@tonic-gate return (devname); 38437c478bd9Sstevel@tonic-gate 38447c478bd9Sstevel@tonic-gate node = devname; 38457c478bd9Sstevel@tonic-gate 38467c478bd9Sstevel@tonic-gate /* Try the node as provided first */ 38477c478bd9Sstevel@tonic-gate if (stat(node, (struct stat *)&statbuf) == -1) { 38487c478bd9Sstevel@tonic-gate /* 38497c478bd9Sstevel@tonic-gate * Copy the passed in string to a new buffer, prepend the 38507c478bd9Sstevel@tonic-gate * default path and try again. 38517c478bd9Sstevel@tonic-gate */ 38527c478bd9Sstevel@tonic-gate space = strlen(DEFAULT_PATH) + strlen(devname) + 1; 38537c478bd9Sstevel@tonic-gate 38547c478bd9Sstevel@tonic-gate if ((node = malloc(space)) == NULL) { 3855bb16350dSlclee (void) fprintf(stderr, "fdisk: Unable to obtain memory " 38567c478bd9Sstevel@tonic-gate "for device node.\n"); 38577c478bd9Sstevel@tonic-gate exit(1); 38587c478bd9Sstevel@tonic-gate } 38597c478bd9Sstevel@tonic-gate 38607c478bd9Sstevel@tonic-gate /* Copy over the default path and the provided node */ 38617c478bd9Sstevel@tonic-gate (void) strncpy(node, DEFAULT_PATH, strlen(DEFAULT_PATH)); 38627c478bd9Sstevel@tonic-gate space -= strlen(DEFAULT_PATH); 38637c478bd9Sstevel@tonic-gate (void) strlcpy(node + strlen(DEFAULT_PATH), devname, space); 38647c478bd9Sstevel@tonic-gate 38657c478bd9Sstevel@tonic-gate /* Try to stat it again */ 38667c478bd9Sstevel@tonic-gate if (stat(node, (struct stat *)&statbuf) == -1) { 38677c478bd9Sstevel@tonic-gate /* Failed all options, give up */ 3868bb16350dSlclee (void) fprintf(stderr, 3869bb16350dSlclee "fdisk: Cannot stat device %s.\n", 38707c478bd9Sstevel@tonic-gate devname); 38717c478bd9Sstevel@tonic-gate exit(1); 38727c478bd9Sstevel@tonic-gate } 38737c478bd9Sstevel@tonic-gate } 38747c478bd9Sstevel@tonic-gate 38757c478bd9Sstevel@tonic-gate /* Make sure the device specified is the raw device */ 38767c478bd9Sstevel@tonic-gate if ((statbuf.st_mode & S_IFMT) != S_IFCHR) { 3877bb16350dSlclee (void) fprintf(stderr, 3878bb16350dSlclee "fdisk: %s must be a raw device.\n", node); 38797c478bd9Sstevel@tonic-gate exit(1); 38807c478bd9Sstevel@tonic-gate } 38817c478bd9Sstevel@tonic-gate 38827c478bd9Sstevel@tonic-gate return (node); 38837c478bd9Sstevel@tonic-gate } 3884