1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 25 */ 26 27 /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ 28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ 29 /* All Rights Reserved */ 30 31 /* Copyright (c) 1987, 1988 Microsoft Corporation */ 32 /* All Rights Reserved */ 33 34 /* 35 * PROGRAM: fdisk(8) 36 * This program reads the partition table on the specified device and 37 * also reads the drive parameters. The user can perform various 38 * operations from a supplied menu or from the command line. Diagnostic 39 * options are also available. 40 */ 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 #include <errno.h> 46 #include <fcntl.h> 47 #include <ctype.h> 48 #include <sys/stat.h> 49 #include <sys/types.h> 50 #include <limits.h> 51 #include <sys/param.h> 52 #include <sys/systeminfo.h> 53 #include <sys/efi_partition.h> 54 #include <sys/byteorder.h> 55 #include <sys/systeminfo.h> 56 57 #include <sys/dktp/fdisk.h> 58 #include <sys/dkio.h> 59 #include <sys/vtoc.h> 60 #ifdef i386 61 #include <sys/tty.h> 62 #include <libfdisk.h> 63 #endif 64 65 #define CLR_SCR "[1;1H[0J" 66 #define CLR_LIN "[0K" 67 #define HOME "[1;1H[0K[2;1H[0K[3;1H[0K[4;1H[0K[5;1H[0K" \ 68 "[6;1H[0K[7;1H[0K[8;1H[0K[9;1H[0K[10;1H[0K[1;1H" 69 #define Q_LINE "[22;1H[0K[21;1H[0K[20;1H[0K" 70 71 #ifdef i386 72 #define W_LINE "[11;1H[0K" 73 #else 74 #define W_LINE "[12;1H[0K[11;1H[0K" 75 #endif 76 77 #define E_LINE "[24;1H[0K[23;1H[0K" 78 79 #ifdef i386 80 #define M_LINE "[12;1H[0K[13;1H[0K[14;1H[0K[15;1H[0K" \ 81 "[16;1H[0K[17;1H[0K[18;1H[0K[19;1H[0K[12;1H" 82 #else 83 #define M_LINE "[13;1H[0K[14;1H[0K[15;1H[0K[16;1H[0K[17;1H" \ 84 "[0K[18;1H[0K[19;1H[0K[13;1H" 85 #endif 86 87 #define T_LINE "[1;1H[0K" 88 89 #define DEFAULT_PATH "/dev/rdsk/" 90 #define DEFAULT_MASTER_BOOT_FILE "/boot/pmbr" 91 92 #define DK_MAX_2TB UINT32_MAX /* Max # of sectors in 2TB */ 93 94 /* for clear_vtoc() */ 95 #define OLD 0 96 #define NEW 1 97 98 /* readvtoc/writevtoc return codes */ 99 #define VTOC_OK 0 /* Good VTOC */ 100 #define VTOC_INVAL 1 /* invalid VTOC */ 101 #define VTOC_NOTSUP 2 /* operation not supported - EFI label */ 102 #define VTOC_RWERR 3 /* couldn't read or write VTOC */ 103 104 /* 105 * Support for fdisk(8) on the SPARC platform 106 * In order to convert little endian values to big endian for SPARC, 107 * byte/short and long values must be swapped. 108 * These swapping macros will be used to access information in the 109 * mboot and ipart structures. 110 */ 111 112 #ifdef sparc 113 #define les(val) ((((val)&0xFF)<<8)|(((val)>>8)&0xFF)) 114 #define lel(val) (((unsigned)(les((val)&0x0000FFFF))<<16) | \ 115 (les((unsigned)((val)&0xffff0000)>>16))) 116 #else 117 #define les(val) (val) 118 #define lel(val) (val) 119 #endif 120 121 #if defined(_SUNOS_VTOC_16) 122 #define VTOC_OFFSET 1 123 #elif defined(_SUNOS_VTOC_8) 124 #define VTOC_OFFSET 0 125 #else 126 #error No VTOC format defined. 127 #endif 128 129 #ifdef i386 130 #define FDISK_KB (1024) 131 #define FDISK_MB (FDISK_KB * 1024) 132 #define FDISK_GB (FDISK_MB * 1024) 133 #define TRUE 1 134 135 #define FDISK_MAX_VALID_PART_ID 255 136 #define FDISK_MAX_VALID_PART_NUM_DIGITS 2 137 #define FDISK_MAX_VALID_PART_ID_DIGITS 3 138 139 /* Maximum number of digits for a valid partition size */ 140 #define FDISK_MAX_VALID_CYL_NUM_DIGITS 10 141 142 /* Minimum partition size in cylinders */ 143 #define FDISK_MIN_PART_SIZE 1 144 #endif 145 146 static char Usage[] = "Usage: fdisk\n" 147 "[ -A id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect ]\n" 148 "[ -b masterboot ]\n" 149 "[ -D id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect ]\n" 150 "[ -E [slot:active] ]\n" 151 "[ -F fdisk_file ] [ -h ] [ -o offset ] [ -P fill_patt ] [ -s size ]\n" 152 "[ -S geom_file ] [ [ -v ] -W { creat_fdisk_file | - } ]\n" 153 "[ -w | r | d | n | I | B | g | G | R | t | T ] rdevice"; 154 155 static char Usage1[] = " Partition options:\n" 156 " -A id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect\n" 157 " Create a partition with specific attributes:\n" 158 " id = system id number (fdisk.h) for the partition type\n" 159 " act = active partition flag (0 is off and 128 is on)\n" 160 " bhead = beginning head for start of partition\n" 161 " bsect = beginning sector for start of partition\n" 162 " bcyl = beginning cylinder for start of partition\n" 163 " ehead = ending head for end of partition\n" 164 " esect = ending sector for end of partition\n" 165 " ecyl = ending cylinder for end of partition\n" 166 " rsect = sector number from start of disk for\n" 167 " start of partition\n" 168 " numsect = partition size in sectors\n" 169 " -b master_boot\n" 170 " Use master_boot as the master boot file.\n" 171 " -B Create one Solaris partition that uses the entire disk.\n" 172 " -D id:act:bhead:bsect:bcyl:ehead:esect:ecyl:rsect:numsect\n" 173 " Delete a partition. See attribute definitions for -A.\n" 174 " -E [slot:active]\n" 175 " Create an EFI partition that uses the entire disk.\n" 176 " -F fdisk_file\n" 177 " Use fdisk_file to initialize on-line fdisk table.\n" 178 " -I Forego device checks. Generate a file image of what would go\n" 179 " on a disk using the geometry specified with the -S option.\n" 180 " -n Do not run in interactive mode.\n" 181 " -R Open the disk device as read-only.\n" 182 " -t Check and adjust VTOC to be consistent with fdisk table.\n" 183 " VTOC slices exceeding the partition size will be truncated.\n" 184 " -T Check and adjust VTOC to be consistent with fdisk table.\n" 185 " VTOC slices exceeding the partition size will be removed.\n" 186 " -W fdisk_file\n" 187 " Write on-disk table to fdisk_file.\n" 188 " -W - Write on-disk table to standard output.\n" 189 " -v Display virtual geometry. Must be used with the -W option.\n" 190 " Diagnostic options:\n" 191 " -d Activate debug information about progress.\n" 192 " -g Write label geometry to standard output:\n" 193 " PCYL number of physical cylinders\n" 194 " NCYL number of usable cylinders\n" 195 " ACYL number of alternate cylinders\n" 196 " BCYL cylinder offset\n" 197 " NHEADS number of heads\n" 198 " NSECTORS number of sectors per track\n" 199 " SECTSIZ size of a sector in bytes\n" 200 " -G Write physical geometry to standard output (see -g).\n" 201 " -h Issue this verbose help message.\n" 202 " -o offset\n" 203 " Block offset from start of disk (default 0). Ignored if\n" 204 " -P # specified.\n" 205 " -P fill_patt\n" 206 " Fill disk with pattern fill_patt. fill_patt can be decimal or\n" 207 " hexadecimal and is used as number for constant long word\n" 208 " pattern. If fill_patt is \"#\" then pattern of block #\n" 209 " for each block. Pattern is put in each block as long words\n" 210 " and fills each block (see -o and -s).\n" 211 " -r Read from a disk to stdout (see -o and -s).\n" 212 " -s size Number of blocks on which to perform operation (see -o).\n" 213 " -S geom_file\n" 214 " Use geom_file to set the label geometry (see -g).\n" 215 " -w Write to a disk from stdin (see -o and -s)."; 216 217 static char Ostr[] = "Other OS"; 218 static char Dstr[] = "DOS12"; 219 static char D16str[] = "DOS16"; 220 static char DDstr[] = "DOS-DATA"; 221 static char EDstr[] = "EXT-DOS"; 222 static char DBstr[] = "DOS-BIG"; 223 static char PCstr[] = "PCIX"; 224 static char Ustr[] = "UNIX System"; 225 static char SUstr[] = "Solaris"; 226 static char SU2str[] = "Solaris2"; 227 static char X86str[] = "x86 Boot"; 228 static char DIAGstr[] = "Diagnostic"; 229 static char IFSstr[] = "IFS: NTFS"; 230 static char AIXstr[] = "AIX Boot"; 231 static char AIXDstr[] = "AIX Data"; 232 static char OS2str[] = "OS/2 Boot"; 233 static char WINstr[] = "Win95 FAT32"; 234 static char EWINstr[] = "Ext Win95"; 235 static char FAT95str[] = "FAT16 LBA"; 236 static char EXTLstr[] = "EXT LBA"; 237 static char LINUXstr[] = "Linux"; 238 static char CPMstr[] = "CP/M"; 239 static char NOV2str[] = "Netware 286"; 240 static char NOVstr[] = "Netware 3.x+"; 241 static char QNXstr[] = "QNX 4.x"; 242 static char QNX2str[] = "QNX part 2"; 243 static char QNX3str[] = "QNX part 3"; 244 static char LINNATstr[] = "Linux native"; 245 #ifdef i386 246 static char LINSWAPstr[] = "Linux swap"; 247 #endif 248 static char NTFSVOL1str[] = "NT volset 1"; 249 static char NTFSVOL2str[] = "NT volset 2"; 250 static char BSDstr[] = "BSD OS"; 251 static char NEXTSTEPstr[] = "NeXTSTEP"; 252 static char BSDIFSstr[] = "BSDI FS"; 253 static char BSDISWAPstr[] = "BSDI swap"; 254 static char Actvstr[] = "Active"; 255 static char EFIstr[] = "EFI"; 256 static char NAstr[] = " "; 257 258 /* All the user options and flags */ 259 static char *Dfltdev; /* name of fixed disk drive */ 260 261 /* Diagnostic options */ 262 static int io_wrt = 0; /* write stdin to disk (-w) */ 263 static int io_rd = 0; /* read disk and write stdout (-r) */ 264 static char *io_fatt; /* user supplied pattern (-P pattern) */ 265 static int io_patt = 0; /* write pattern to disk (-P pattern) */ 266 static int io_lgeom = 0; /* get label geometry (-g) */ 267 static int io_pgeom = 0; /* get drive physical geometry (-G) */ 268 static char *io_sgeom = 0; /* set label geometry (-S geom_file) */ 269 static int io_readonly = 0; /* do not write to disk (-R) */ 270 271 /* The -o offset and -s size options specify the area of the disk on */ 272 /* which to perform the particular operation; i.e., -P, -r, or -w. */ 273 static off_t io_offset = 0; /* offset sector (-o offset) */ 274 static off_t io_size = 0; /* size in sectors (-s size) */ 275 276 /* Partition table flags */ 277 static int v_flag = 0; /* virtual geometry-HBA flag (-v) */ 278 static int stdo_flag = 0; /* stdout flag (-W -) */ 279 static int io_fdisk = 0; /* do fdisk operation */ 280 static int io_ifdisk = 0; /* interactive partition */ 281 static int io_nifdisk = 0; /* non-interactive partition (-n) */ 282 283 static int io_adjt = 0; /* check/adjust VTOC (truncate (-t)) */ 284 static int io_ADJT = 0; /* check/adjust VTOC (delete (-T)) */ 285 static char *io_ffdisk = 0; /* input fdisk file name (-F file) */ 286 static char *io_Wfdisk = 0; /* output fdisk file name (-W file) */ 287 static char *io_Afdisk = 0; /* add entry to partition table (-A) */ 288 static char *io_Dfdisk = 0; /* delete entry from part. table (-D) */ 289 290 static char *io_mboot = 0; /* master boot record (-b boot_file) */ 291 292 static struct mboot BootCod; /* buffer for master boot record */ 293 294 static int io_wholedisk = 0; /* use whole disk for Solaris (-B) */ 295 static int io_EFIdisk = 0; /* use whole disk for EFI (-E) */ 296 static int io_EFIslot = 0; /* slot in which to place EFI entry */ 297 static int io_EFIactive = 0; /* mark EFI entry as active */ 298 static int io_debug = 0; /* activate verbose mode (-d) */ 299 static int io_image = 0; /* create image using geometry (-I) */ 300 301 static struct mboot *Bootblk; /* pointer to cut/paste sector zero */ 302 static char *Bootsect; /* pointer to sector zero buffer */ 303 static char *Nullsect; 304 static struct extvtoc disk_vtoc; /* verify VTOC table */ 305 static int vt_inval = 0; 306 static int no_virtgeom_ioctl = 0; /* ioctl for virtual geometry failed */ 307 static int no_physgeom_ioctl = 0; /* ioctl for physical geometry failed */ 308 309 static struct ipart Table[FD_NUMPART]; 310 static struct ipart Old_Table[FD_NUMPART]; 311 static int skip_verify[FD_NUMPART]; /* special case skip sz chk */ 312 313 /* Disk geometry information */ 314 static struct dk_minfo minfo; 315 static struct dk_geom disk_geom; 316 317 static int Dev; /* fd for open device */ 318 319 static diskaddr_t dev_capacity; /* number of blocks on device */ 320 static diskaddr_t chs_capacity; /* Numcyl_usable * heads * sectors */ 321 322 static int Numcyl_usable; /* Number of usable cylinders */ 323 /* used to limit fdisk to 2TB */ 324 325 /* Physical geometry for the drive */ 326 static int Numcyl; /* number of cylinders */ 327 static int heads; /* number of heads */ 328 static int sectors; /* number of sectors per track */ 329 static int acyl; /* number of alternate sectors */ 330 331 /* HBA (virtual) geometry for the drive */ 332 static int hba_Numcyl; /* number of cylinders */ 333 static int hba_heads; /* number of heads */ 334 static int hba_sectors; /* number of sectors per track */ 335 336 static int sectsiz; /* sector size */ 337 338 /* Load functions for fdisk table modification */ 339 #define LOADFILE 0 /* load fdisk from file */ 340 #define LOADDEL 1 /* delete an fdisk entry */ 341 #define LOADADD 2 /* add an fdisk entry */ 342 343 #define CBUFLEN 80 344 static char s[CBUFLEN]; 345 346 #ifdef i386 347 /* 348 * Complete list of all the 255 partition types. Some are unknown types 349 * and some entries are known to be unused. 350 * 351 * Courtesy of http://www.win.tue.nl/~aeb/partitions/partition_types-1.html 352 */ 353 char *fdisk_part_types[] = { 354 "Empty", /* 0 */ 355 "FAT12", /* 1 */ 356 "XENIX /", /* 2 */ 357 "XENIX /usr", /* 3 */ 358 "FAT16 (Upto 32M)", /* 4 */ 359 "DOS Extended", /* 5 */ 360 "FAT16 (>32M, HUGEDOS)", /* 6 */ 361 "IFS: NTFS", /* 7 */ 362 "AIX Boot/QNX(qny)", /* 8 */ 363 "AIX Data/QNX(qnz)", /* 9 */ 364 "OS/2 Boot/Coherent swap", /* 10 */ 365 "WIN95 FAT32(Upto 2047GB)", /* 11 */ 366 "WIN95 FAT32(LBA)", /* 12 */ 367 "Unused", /* 13 */ 368 "WIN95 FAT16(LBA)", /* 14 */ 369 "WIN95 Extended(LBA)", /* 15 */ 370 "OPUS", /* 16 */ 371 "Hidden FAT12", /* 17 */ 372 "Diagnostic", /* 18 */ 373 "Unknown", /* 19 */ 374 "Hidden FAT16(Upto 32M)", /* 20 */ 375 "Unknown", /* 21 */ 376 "Hidden FAT16(>=32M)", /* 22 */ 377 "Hidden IFS: HPFS", /* 23 */ 378 "AST SmartSleep Partition", /* 24 */ 379 "Unused/Willowtech Photon", /* 25 */ 380 "Unknown", /* 26 */ 381 "Hidden FAT32", /* 27 */ 382 "Hidden FAT32(LBA)", /* 28 */ 383 "Unused", /* 29 */ 384 "Hidden FAT16(LBA)", /* 30 */ 385 "Unknown", /* 31 */ 386 "Unused/OSF1", /* 32 */ 387 "Reserved/FSo2(Oxygen FS)", /* 33 */ 388 "Unused/(Oxygen EXT)", /* 34 */ 389 "Reserved", /* 35 */ 390 "NEC DOS 3.x", /* 36 */ 391 "Unknown", /* 37 */ 392 "Reserved", /* 38 */ 393 "Unknown", /* 39 */ 394 "Unknown", /* 40 */ 395 "Unknown", /* 41 */ 396 "AtheOS File System", /* 42 */ 397 "SyllableSecure", /* 43 */ 398 "Unknown", /* 44 */ 399 "Unknown", /* 45 */ 400 "Unknown", /* 46 */ 401 "Unknown", /* 47 */ 402 "Unknown", /* 48 */ 403 "Reserved", /* 49 */ 404 "NOS", /* 50 */ 405 "Reserved", /* 51 */ 406 "Reserved", /* 52 */ 407 "JFS on OS/2", /* 53 */ 408 "Reserved", /* 54 */ 409 "Unknown", /* 55 */ 410 "THEOS 3.2 2GB", /* 56 */ 411 "Plan9/THEOS 4", /* 57 */ 412 "THEOS 4 4GB", /* 58 */ 413 "THEOS 4 Extended", /* 59 */ 414 "PartitionMagic Recovery", /* 60 */ 415 "Hidden NetWare", /* 61 */ 416 "Unknown", /* 62 */ 417 "Unknown", /* 63 */ 418 "Venix 80286", /* 64 */ 419 "MINIX/PPC PReP Boot", /* 65 */ 420 "Win2K Dynamic Disk/SFS(DOS)", /* 66 */ 421 "Linux+DRDOS shared", /* 67 */ 422 "GoBack partition", /* 68 */ 423 "Boot-US boot manager", /* 69 */ 424 "EUMEL/Elan", /* 70 */ 425 "EUMEL/Elan", /* 71 */ 426 "EUMEL/Elan", /* 72 */ 427 "Unknown", /* 73 */ 428 "ALFS/THIN FS for DOS", /* 74 */ 429 "Unknown", /* 75 */ 430 "Oberon partition", /* 76 */ 431 "QNX 4,x", /* 77 */ 432 "QNX 4,x 2nd Part", /* 78 */ 433 "QNX 4,x 3rd Part", /* 79 */ 434 "OnTrack DM R/O, Lynx RTOS", /* 80 */ 435 "OnTrack DM R/W, Novell", /* 81 */ 436 "CP/M", /* 82 */ 437 "Disk Manager 6.0 Aux3", /* 83 */ 438 "Disk Manager 6.0 DDO", /* 84 */ 439 "EZ-Drive", /* 85 */ 440 "Golden Bow VFeature/AT&T MS-DOS", /* 86 */ 441 "DrivePro", /* 87 */ 442 "Unknown", /* 88 */ 443 "Unknown", /* 89 */ 444 "Unknown", /* 90 */ 445 "Unknown", /* 91 */ 446 "Priam EDisk", /* 92 */ 447 "Unknown", /* 93 */ 448 "Unknown", /* 94 */ 449 "Unknown", /* 95 */ 450 "Unknown", /* 96 */ 451 "SpeedStor", /* 97 */ 452 "Unknown", /* 98 */ 453 "Unix SysV, Mach, GNU Hurd", /* 99 */ 454 "PC-ARMOUR, Netware 286", /* 100 */ 455 "Netware 386", /* 101 */ 456 "Netware SMS", /* 102 */ 457 "Novell", /* 103 */ 458 "Novell", /* 104 */ 459 "Netware NSS", /* 105 */ 460 "Unknown", /* 106 */ 461 "Unknown", /* 107 */ 462 "Unknown", /* 108 */ 463 "Unknown", /* 109 */ 464 "Unknown", /* 110 */ 465 "Unknown", /* 111 */ 466 "DiskSecure Multi-Boot", /* 112 */ 467 "Reserved", /* 113 */ 468 "Unknown", /* 114 */ 469 "Reserved", /* 115 */ 470 "Scramdisk partition", /* 116 */ 471 "IBM PC/IX", /* 117 */ 472 "Reserved", /* 118 */ 473 "M2FS/M2CS,Netware VNDI", /* 119 */ 474 "XOSL FS", /* 120 */ 475 "Unknown", /* 121 */ 476 "Unknown", /* 122 */ 477 "Unknown", /* 123 */ 478 "Unknown", /* 124 */ 479 "Unknown", /* 125 */ 480 "Unused", /* 126 */ 481 "Unused", /* 127 */ 482 "MINIX until 1.4a", /* 128 */ 483 "MINIX since 1.4b, early Linux", /* 129 */ 484 "Solaris/Linux swap", /* 130 */ 485 "Linux native", /* 131 */ 486 "OS/2 hidden,Win Hibernation", /* 132 */ 487 "Linux extended", /* 133 */ 488 "Old Linux RAID,NT FAT16 RAID", /* 134 */ 489 "NTFS volume set", /* 135 */ 490 "Linux plaintext part table", /* 136 */ 491 "Unknown", /* 137 */ 492 "Linux Kernel Partition", /* 138 */ 493 "Fault Tolerant FAT32 volume", /* 139 */ 494 "Fault Tolerant FAT32 volume", /* 140 */ 495 "Free FDISK hidden PDOS FAT12", /* 141 */ 496 "Linux LVM partition", /* 142 */ 497 "Unknown", /* 143 */ 498 "Free FDISK hidden PDOS FAT16", /* 144 */ 499 "Free FDISK hidden DOS EXT", /* 145 */ 500 "Free FDISK hidden FAT16 Large", /* 146 */ 501 "Hidden Linux native, Amoeba", /* 147 */ 502 "Amoeba Bad Block Table", /* 148 */ 503 "MIT EXOPC Native", /* 149 */ 504 "Unknown", /* 150 */ 505 "Free FDISK hidden PDOS FAT32", /* 151 */ 506 "Free FDISK hidden FAT32 LBA", /* 152 */ 507 "DCE376 logical drive", /* 153 */ 508 "Free FDISK hidden FAT16 LBA", /* 154 */ 509 "Free FDISK hidden DOS EXT", /* 155 */ 510 "Unknown", /* 156 */ 511 "Unknown", /* 157 */ 512 "Unknown", /* 158 */ 513 "BSD/OS", /* 159 */ 514 "Laptop hibernation", /* 160 */ 515 "Laptop hibernate,HP SpeedStor", /* 161 */ 516 "Unknown", /* 162 */ 517 "HP SpeedStor", /* 163 */ 518 "HP SpeedStor", /* 164 */ 519 "BSD/386,386BSD,NetBSD,FreeBSD", /* 165 */ 520 "OpenBSD,HP SpeedStor", /* 166 */ 521 "NeXTStep", /* 167 */ 522 "Mac OS-X", /* 168 */ 523 "NetBSD", /* 169 */ 524 "Olivetti FAT12 1.44MB Service", /* 170 */ 525 "Mac OS-X Boot", /* 171 */ 526 "Unknown", /* 172 */ 527 "Unknown", /* 173 */ 528 "ShagOS filesystem", /* 174 */ 529 "ShagOS swap", /* 175 */ 530 "BootStar Dummy", /* 176 */ 531 "HP SpeedStor", /* 177 */ 532 "Unknown", /* 178 */ 533 "HP SpeedStor", /* 179 */ 534 "HP SpeedStor", /* 180 */ 535 "Unknown", /* 181 */ 536 "Corrupted FAT16 NT Mirror Set", /* 182 */ 537 "Corrupted NTFS NT Mirror Set", /* 183 */ 538 "Old BSDI BSD/386 swap", /* 184 */ 539 "Unknown", /* 185 */ 540 "Unknown", /* 186 */ 541 "Boot Wizard hidden", /* 187 */ 542 "Unknown", /* 188 */ 543 "Unknown", /* 189 */ 544 "Solaris x86 boot", /* 190 */ 545 "Solaris2", /* 191 */ 546 "REAL/32 or Novell DOS secured", /* 192 */ 547 "DRDOS/secured(FAT12)", /* 193 */ 548 "Hidden Linux", /* 194 */ 549 "Hidden Linux swap", /* 195 */ 550 "DRDOS/secured(FAT16,< 32M)", /* 196 */ 551 "DRDOS/secured(Extended)", /* 197 */ 552 "NT corrupted FAT16 volume", /* 198 */ 553 "NT corrupted NTFS volume", /* 199 */ 554 "DRDOS8.0+", /* 200 */ 555 "DRDOS8.0+", /* 201 */ 556 "DRDOS8.0+", /* 202 */ 557 "DRDOS7.04+ secured FAT32(CHS)", /* 203 */ 558 "DRDOS7.04+ secured FAT32(LBA)", /* 204 */ 559 "CTOS Memdump", /* 205 */ 560 "DRDOS7.04+ FAT16X(LBA)", /* 206 */ 561 "DRDOS7.04+ secure EXT DOS(LBA)", /* 207 */ 562 "REAL/32 secure big, MDOS", /* 208 */ 563 "Old MDOS secure FAT12", /* 209 */ 564 "Unknown", /* 210 */ 565 "Unknown", /* 211 */ 566 "Old MDOS secure FAT16 <32M", /* 212 */ 567 "Old MDOS secure EXT", /* 213 */ 568 "Old MDOS secure FAT16 >=32M", /* 214 */ 569 "Unknown", /* 215 */ 570 "CP/M-86", /* 216 */ 571 "Unknown", /* 217 */ 572 "Non-FS Data", /* 218 */ 573 "CP/M,Concurrent DOS,CTOS", /* 219 */ 574 "Unknown", /* 220 */ 575 "Hidden CTOS memdump", /* 221 */ 576 "Dell PowerEdge utilities(FAT)", /* 222 */ 577 "DG/UX virtual disk manager", /* 223 */ 578 "ST AVFS(STMicroelectronics)", /* 224 */ 579 "SpeedStor 12-bit FAT EXT", /* 225 */ 580 "Unknown", /* 226 */ 581 "SpeedStor", /* 227 */ 582 "SpeedStor 16-bit FAT EXT", /* 228 */ 583 "Tandy MSDOS", /* 229 */ 584 "Storage Dimensions SpeedStor", /* 230 */ 585 "Unknown", /* 231 */ 586 "Unknown", /* 232 */ 587 "Unknown", /* 233 */ 588 "Unknown", /* 234 */ 589 "BeOS BFS", /* 235 */ 590 "SkyOS SkyFS", /* 236 */ 591 "Unused", /* 237 */ 592 "EFI Header Indicator", /* 238 */ 593 "EFI Filesystem", /* 239 */ 594 "Linux/PA-RISC boot loader", /* 240 */ 595 "SpeedStor", /* 241 */ 596 "DOS 3.3+ secondary", /* 242 */ 597 "SpeedStor Reserved", /* 243 */ 598 "SpeedStor Large", /* 244 */ 599 "Prologue multi-volume", /* 245 */ 600 "SpeedStor", /* 246 */ 601 "Unused", /* 247 */ 602 "Unknown", /* 248 */ 603 "pCache", /* 249 */ 604 "Bochs", /* 250 */ 605 "VMware File System", /* 251 */ 606 "VMware swap", /* 252 */ 607 "Linux raid autodetect", /* 253 */ 608 "NT Disk Administrator hidden", /* 254 */ 609 "Xenix Bad Block Table" /* 255 */ 610 }; 611 612 /* Allowed extended partition menu options */ 613 static char ext_part_menu_opts[] = "adhipr"; 614 615 /* 616 * Structure holding all information about the extended partition 617 * NOTE : As of now, there will be just one instance of ext_part_t, since most 618 * known systems allow only one extended dos partition per disk. 619 */ 620 static ext_part_t *epp; 621 #endif 622 623 static void update_disk_and_exit(boolean_t table_changed); 624 int main(int argc, char *argv[]); 625 static int read_geom(char *sgeom); 626 static void dev_mboot_read(void); 627 static void dev_mboot_write(off_t sect, char *buff, int bootsiz); 628 static void mboot_read(void); 629 static void fill_patt(void); 630 static void abs_read(void); 631 static void abs_write(void); 632 static void load(int funct, char *file); 633 static void Set_Table_CHS_Values(int ti); 634 static int nopartdefined(); 635 static int insert_tbl(int id, int act, 636 int bhead, int bsect, int bcyl, 637 int ehead, int esect, int ecyl, 638 uint32_t rsect, uint32_t numsect, int startindex); 639 static int entry_from_old_table(int id, int act, 640 int bhead, int bsect, int bcyl, 641 int ehead, int esect, int ecyl, 642 uint32_t rsect, uint32_t numsect, int startindex); 643 static int verify_tbl(void); 644 static int pars_fdisk(char *line, 645 int *id, int *act, 646 int *bhead, int *bsect, int *bcyl, 647 int *ehead, int *esect, int *ecyl, 648 uint32_t *rsect, uint32_t *numsect); 649 static int validate_part(int id, uint32_t rsect, uint32_t numsect); 650 static void stage0(void); 651 static int pcreate(void); 652 static int specify(uchar_t tsystid); 653 static void dispmenu(void); 654 static int pchange(void); 655 static int ppartid(void); 656 static char pdelete(void); 657 static void rm_blanks(char *s); 658 static int getcyl(void); 659 static void disptbl(void); 660 static void print_Table(void); 661 static void copy_Table_to_Old_Table(void); 662 static void nulltbl(void); 663 static void copy_Bootblk_to_Table(void); 664 static void fill_ipart(char *bootptr, struct ipart *partp); 665 #ifdef sparc 666 uchar_t getbyte(char **bp); 667 uint32_t getlong(char **bp); 668 #endif 669 static void copy_Table_to_Bootblk(void); 670 static int TableChanged(void); 671 static void ffile_write(char *file); 672 static void fix_slice(void); 673 static int yesno(void); 674 static int readvtoc(void); 675 static int writevtoc(void); 676 static int efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc); 677 static int clear_efi(void); 678 static void clear_vtoc(int table, int part); 679 static int lecture_and_query(char *warning, char *devname); 680 static void sanity_check_provided_device(char *devname, int fd); 681 static char *get_node(char *devname); 682 static int efi_create(void); 683 684 #ifdef i386 685 static void id_to_name(uchar_t sysid, char *buffer); 686 static void ext_read_input(char *buf); 687 static int ext_read_options(char *buf); 688 static int ext_invalid_option(char ch); 689 static void ext_read_valid_part_num(int *pno); 690 static void ext_read_valid_part_id(uchar_t *partid); 691 static int ext_read_valid_partition_start(uint32_t *begsec); 692 static void ext_read_valid_partition_size(uint32_t begsec, uint32_t *endsec); 693 static void ext_part_menu(); 694 static void add_logical_drive(); 695 static void delete_logical_drive(); 696 static void ext_print_help_menu(); 697 static void ext_change_logical_drive_id(); 698 static void ext_print_part_types(); 699 static void ext_print_logical_drive_layout(); 700 static void preach_and_continue(); 701 #ifdef DEBUG 702 static void ext_print_logdrive_layout_debug(); 703 #endif /* DEBUG */ 704 #endif /* i386 */ 705 706 /* 707 * This function is called only during the non-interactive mode. 708 * It is touchy and does not tolerate any errors. If there are 709 * mounted logical drives, changes to the partition table 710 * are disallowed. 711 */ 712 static void 713 update_disk_and_exit(boolean_t table_changed) 714 { 715 #ifdef i386 716 int rval; 717 #endif 718 if (table_changed) { 719 /* 720 * Copy the new table back to the sector buffer 721 * and write it to disk 722 */ 723 copy_Table_to_Bootblk(); 724 dev_mboot_write(0, Bootsect, sectsiz); 725 } 726 727 /* If the VTOC table is wrong fix it (truncation only) */ 728 if (io_adjt) 729 fix_slice(); 730 731 #ifdef i386 732 if (!io_readonly) { 733 rval = fdisk_commit_ext_part(epp); 734 switch (rval) { 735 case FDISK_SUCCESS: 736 /* Success */ 737 break; 738 case FDISK_ENOEXTPART: 739 /* Nothing to do */ 740 break; 741 default: 742 (void) fprintf(stderr, "Error in" 743 " fdisk_commit_ext_part\n"); 744 exit(rval); 745 } 746 } 747 libfdisk_fini(&epp); 748 #endif 749 exit(0); 750 } 751 752 /* 753 * main 754 * Process command-line options. 755 */ 756 int 757 main(int argc, char *argv[]) 758 { 759 int c, i; 760 extern int optind; 761 extern char *optarg; 762 int errflg = 0; 763 int diag_cnt = 0; 764 int openmode; 765 #ifdef i386 766 int rval; 767 int lf_op_flag = 0; 768 #endif 769 770 setbuf(stderr, 0); /* so all output gets out on exit */ 771 setbuf(stdout, 0); 772 773 /* Process the options. */ 774 while ((c = getopt(argc, argv, "o:s:P:F:b:A:D:W:S:tTIhwvrndgGRBE:")) 775 != EOF) { 776 switch (c) { 777 778 case 'o': 779 io_offset = (off_t)strtoull(optarg, 0, 0); 780 continue; 781 case 's': 782 io_size = (off_t)strtoull(optarg, 0, 0); 783 continue; 784 case 'P': 785 diag_cnt++; 786 io_patt++; 787 io_fatt = optarg; 788 continue; 789 case 'w': 790 diag_cnt++; 791 io_wrt++; 792 continue; 793 case 'r': 794 diag_cnt++; 795 io_rd++; 796 continue; 797 case 'd': 798 io_debug++; 799 continue; 800 case 'I': 801 io_image++; 802 continue; 803 case 'R': 804 io_readonly++; 805 continue; 806 case 'S': 807 diag_cnt++; 808 io_sgeom = optarg; 809 continue; 810 case 'T': 811 io_ADJT++; 812 /* FALLTHROUGH */ 813 case 't': 814 io_adjt++; 815 continue; 816 case 'B': 817 io_wholedisk++; 818 io_fdisk++; 819 continue; 820 case 'E': 821 if (sscanf(optarg, "%d:%d", 822 &io_EFIslot, &io_EFIactive) != 2) { 823 io_EFIslot = io_EFIactive = 0; 824 optind--; 825 } 826 io_EFIdisk++; 827 io_fdisk++; 828 continue; 829 case 'g': 830 diag_cnt++; 831 io_lgeom++; 832 continue; 833 case 'G': 834 diag_cnt++; 835 io_pgeom++; 836 continue; 837 case 'n': 838 io_nifdisk++; 839 io_fdisk++; 840 continue; 841 case 'F': 842 io_fdisk++; 843 io_ffdisk = optarg; 844 continue; 845 case 'b': 846 io_mboot = optarg; 847 continue; 848 case 'W': 849 /* 850 * If '-' is the -W argument, then write 851 * to standard output, otherwise write 852 * to the specified file. 853 */ 854 if (strncmp(optarg, "-", 1) == 0) 855 stdo_flag = 1; 856 else 857 io_Wfdisk = optarg; 858 io_fdisk++; 859 continue; 860 case 'A': 861 io_fdisk++; 862 io_Afdisk = optarg; 863 continue; 864 case 'D': 865 io_fdisk++; 866 io_Dfdisk = optarg; 867 continue; 868 case 'h': 869 (void) fprintf(stderr, "%s\n", Usage); 870 (void) fprintf(stderr, "%s\n", Usage1); 871 exit(0); 872 /* FALLTHROUGH */ 873 case 'v': 874 v_flag = 1; 875 continue; 876 case '?': 877 errflg++; 878 break; 879 } 880 break; 881 } 882 883 if (io_image && io_sgeom && diag_cnt == 1) { 884 diag_cnt = 0; 885 } 886 887 /* User option checking */ 888 889 /* By default, run in interactive mode */ 890 if (!io_fdisk && !diag_cnt && !io_nifdisk) { 891 io_ifdisk++; 892 io_fdisk++; 893 } 894 if (((io_fdisk || io_adjt) && diag_cnt) || (diag_cnt > 1)) { 895 errflg++; 896 } 897 898 /* Was any error detected? */ 899 if (errflg || argc == optind) { 900 (void) fprintf(stderr, "%s\n", Usage); 901 (void) fprintf(stderr, 902 "\nDetailed help is available with the -h option.\n"); 903 exit(2); 904 } 905 906 /* Figure out the correct device node to open */ 907 Dfltdev = get_node(argv[optind]); 908 909 if (io_readonly) 910 openmode = O_RDONLY; 911 else 912 openmode = O_RDWR|O_CREAT; 913 914 if ((Dev = open(Dfltdev, openmode, 0666)) == -1) { 915 (void) fprintf(stderr, 916 "fdisk: Cannot open device %s.\n", 917 Dfltdev); 918 exit(1); 919 } 920 /* 921 * not all disk (or disklike) drivers support DKIOCGMEDIAINFO 922 * in that case leave the minfo structure zeroed 923 */ 924 if (ioctl(Dev, DKIOCGMEDIAINFO, &minfo)) { 925 (void) memset(&minfo, 0, sizeof (minfo)); 926 } 927 928 /* Get the disk geometry */ 929 if (!io_image) { 930 /* Get disk's HBA (virtual) geometry */ 931 errno = 0; 932 if (ioctl(Dev, DKIOCG_VIRTGEOM, &disk_geom)) { 933 934 /* 935 * If ioctl isn't implemented on this platform, then 936 * turn off flag to print out virtual geometry (-v), 937 * otherwise use the virtual geometry. 938 */ 939 940 if (errno == ENOTTY) { 941 v_flag = 0; 942 no_virtgeom_ioctl = 1; 943 } else if (errno == EINVAL) { 944 /* 945 * This means that the ioctl exists, but 946 * is invalid for this disk, meaning the 947 * disk doesn't have an HBA geometry 948 * (like, say, it's larger than 8GB). 949 */ 950 v_flag = 0; 951 hba_Numcyl = hba_heads = hba_sectors = 0; 952 } else { 953 (void) fprintf(stderr, 954 "%s: Cannot get virtual disk geometry.\n", 955 argv[optind]); 956 exit(1); 957 } 958 } else { 959 /* save virtual geometry values obtained by ioctl */ 960 hba_Numcyl = disk_geom.dkg_ncyl; 961 hba_heads = disk_geom.dkg_nhead; 962 hba_sectors = disk_geom.dkg_nsect; 963 } 964 965 errno = 0; 966 if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) { 967 if (errno == ENOTTY) { 968 no_physgeom_ioctl = 1; 969 } else { 970 (void) fprintf(stderr, 971 "%s: Cannot get physical disk geometry.\n", 972 argv[optind]); 973 exit(1); 974 } 975 976 } 977 /* 978 * Call DKIOCGGEOM if the ioctls for physical and virtual 979 * geometry fail. Get both from this generic call. 980 */ 981 if (no_virtgeom_ioctl && no_physgeom_ioctl) { 982 errno = 0; 983 if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) { 984 (void) fprintf(stderr, 985 "%s: Cannot get disk label geometry.\n", 986 argv[optind]); 987 exit(1); 988 } 989 } 990 991 Numcyl = disk_geom.dkg_ncyl; 992 heads = disk_geom.dkg_nhead; 993 sectors = disk_geom.dkg_nsect; 994 995 if (minfo.dki_lbsize != 0) 996 sectsiz = minfo.dki_lbsize; 997 else 998 sectsiz = 512; 999 1000 acyl = disk_geom.dkg_acyl; 1001 1002 /* 1003 * if hba geometry was not set by DKIOC_VIRTGEOM 1004 * or we got an invalid hba geometry 1005 * then set hba geometry based on max values 1006 */ 1007 if (no_virtgeom_ioctl || 1008 disk_geom.dkg_ncyl == 0 || 1009 disk_geom.dkg_nhead == 0 || 1010 disk_geom.dkg_nsect == 0 || 1011 disk_geom.dkg_ncyl > MAX_CYL || 1012 disk_geom.dkg_nhead > MAX_HEAD + 1 || 1013 disk_geom.dkg_nsect > MAX_SECT) { 1014 1015 /* 1016 * turn off flag to print out virtual geometry (-v) 1017 */ 1018 v_flag = 0; 1019 hba_sectors = MAX_SECT; 1020 hba_heads = MAX_HEAD + 1; 1021 hba_Numcyl = (Numcyl * heads * sectors) / 1022 (hba_sectors * hba_heads); 1023 } 1024 1025 if (io_debug) { 1026 (void) fprintf(stderr, "Physical Geometry:\n"); 1027 (void) fprintf(stderr, 1028 " cylinders[%d] heads[%d] sectors[%d]\n" 1029 " sector size[%d] blocks[%d] mbytes[%d]\n", 1030 Numcyl, 1031 heads, 1032 sectors, 1033 sectsiz, 1034 Numcyl * heads * sectors, 1035 (Numcyl * heads * sectors * sectsiz) / 1048576); 1036 (void) fprintf(stderr, "Virtual (HBA) Geometry:\n"); 1037 (void) fprintf(stderr, 1038 " cylinders[%d] heads[%d] sectors[%d]\n" 1039 " sector size[%d] blocks[%d] mbytes[%d]\n", 1040 hba_Numcyl, 1041 hba_heads, 1042 hba_sectors, 1043 sectsiz, 1044 hba_Numcyl * hba_heads * hba_sectors, 1045 (hba_Numcyl * hba_heads * hba_sectors * sectsiz) / 1046 1048576); 1047 } 1048 } 1049 1050 /* If user has requested a geometry report just do it and exit */ 1051 if (io_lgeom) { 1052 if (ioctl(Dev, DKIOCGGEOM, &disk_geom)) { 1053 (void) fprintf(stderr, 1054 "%s: Cannot get disk label geometry.\n", 1055 argv[optind]); 1056 exit(1); 1057 } 1058 Numcyl = disk_geom.dkg_ncyl; 1059 heads = disk_geom.dkg_nhead; 1060 sectors = disk_geom.dkg_nsect; 1061 if (minfo.dki_lbsize != 0) 1062 sectsiz = minfo.dki_lbsize; 1063 else 1064 sectsiz = 512; 1065 1066 acyl = disk_geom.dkg_acyl; 1067 (void) printf("* Label geometry for device %s\n", Dfltdev); 1068 (void) printf( 1069 "* PCYL NCYL ACYL BCYL NHEAD NSECT" 1070 " SECSIZ\n"); 1071 (void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n", 1072 Numcyl, 1073 disk_geom.dkg_ncyl, 1074 disk_geom.dkg_acyl, 1075 disk_geom.dkg_bcyl, 1076 heads, 1077 sectors, 1078 sectsiz); 1079 exit(0); 1080 } else if (io_pgeom) { 1081 if (ioctl(Dev, DKIOCG_PHYGEOM, &disk_geom)) { 1082 (void) fprintf(stderr, 1083 "%s: Cannot get physical disk geometry.\n", 1084 argv[optind]); 1085 exit(1); 1086 } 1087 (void) printf("* Physical geometry for device %s\n", Dfltdev); 1088 (void) printf( 1089 "* PCYL NCYL ACYL BCYL NHEAD NSECT" 1090 " SECSIZ\n"); 1091 (void) printf(" %-8d %-8d %-8d %-8d %-5d %-5d %-6d\n", 1092 disk_geom.dkg_pcyl, 1093 disk_geom.dkg_ncyl, 1094 disk_geom.dkg_acyl, 1095 disk_geom.dkg_bcyl, 1096 disk_geom.dkg_nhead, 1097 disk_geom.dkg_nsect, 1098 sectsiz); 1099 exit(0); 1100 } else if (io_sgeom) { 1101 if (read_geom(io_sgeom)) { 1102 exit(1); 1103 } else if (!io_image) { 1104 exit(0); 1105 } 1106 } 1107 1108 /* 1109 * some drivers may not support DKIOCGMEDIAINFO 1110 * in that case use CHS 1111 */ 1112 chs_capacity = (diskaddr_t)Numcyl * heads * sectors; 1113 dev_capacity = chs_capacity; 1114 Numcyl_usable = Numcyl; 1115 1116 if (chs_capacity > DK_MAX_2TB) { 1117 /* limit to 2TB */ 1118 Numcyl_usable = DK_MAX_2TB / (heads * sectors); 1119 chs_capacity = (diskaddr_t)Numcyl_usable * heads * sectors; 1120 } 1121 1122 if (minfo.dki_capacity > 0) 1123 dev_capacity = minfo.dki_capacity; 1124 1125 /* Allocate memory to hold three complete sectors */ 1126 Bootsect = (char *)calloc(3 * sectsiz, 1); 1127 if (Bootsect == NULL) { 1128 (void) fprintf(stderr, 1129 "fdisk: Unable to obtain enough buffer memory" 1130 " (%d bytes).\n", 1131 3 * sectsiz); 1132 exit(1); 1133 } 1134 1135 Nullsect = Bootsect + sectsiz; 1136 /* Zero out the "NULL" sector */ 1137 for (i = 0; i < sectsiz; i++) { 1138 Nullsect[i] = 0; 1139 } 1140 1141 /* Find out what the user wants done */ 1142 if (io_rd) { /* abs disk read */ 1143 abs_read(); /* will not return */ 1144 } else if (io_wrt && !io_readonly) { 1145 abs_write(); /* will not return */ 1146 } else if (io_patt && !io_readonly) { 1147 fill_patt(); /* will not return */ 1148 } 1149 1150 /* This is the fdisk edit, the real reason for the program. */ 1151 1152 sanity_check_provided_device(Dfltdev, Dev); 1153 1154 /* Get the new BOOT program in case we write a new fdisk table */ 1155 mboot_read(); 1156 1157 /* Read from disk master boot */ 1158 dev_mboot_read(); 1159 1160 /* 1161 * Verify and copy the device's fdisk table. This will be used 1162 * as the prototype mboot if the device's mboot looks invalid. 1163 */ 1164 Bootblk = (struct mboot *)Bootsect; 1165 copy_Bootblk_to_Table(); 1166 1167 /* save away a copy of Table in Old_Table for sensing changes */ 1168 copy_Table_to_Old_Table(); 1169 1170 #ifdef i386 1171 /* 1172 * Read extended partition only when the fdisk table is not 1173 * supplied from a file 1174 */ 1175 if (!io_ffdisk) { 1176 lf_op_flag |= FDISK_READ_DISK; 1177 } 1178 if ((rval = libfdisk_init(&epp, Dfltdev, &Table[0], lf_op_flag)) 1179 != FDISK_SUCCESS) { 1180 switch (rval) { 1181 /* 1182 * FDISK_EBADLOGDRIVE, FDISK_ENOLOGDRIVE and 1183 * FDISK_EBADMAGIC can be considered as 1184 * soft errors and hence we do not exit 1185 */ 1186 case FDISK_EBADLOGDRIVE: 1187 break; 1188 case FDISK_ENOLOGDRIVE: 1189 break; 1190 case FDISK_EBADMAGIC: 1191 break; 1192 case FDISK_ENOVGEOM: 1193 (void) fprintf(stderr, "Could not get virtual" 1194 " geometry for this device\n"); 1195 exit(1); 1196 break; 1197 case FDISK_ENOPGEOM: 1198 (void) fprintf(stderr, "Could not get physical" 1199 " geometry for this device\n"); 1200 exit(1); 1201 break; 1202 case FDISK_ENOLGEOM: 1203 (void) fprintf(stderr, "Could not get label" 1204 " geometry for this device\n"); 1205 exit(1); 1206 break; 1207 default: 1208 perror("Failed to initialise libfdisk.\n"); 1209 exit(1); 1210 break; 1211 } 1212 } 1213 #endif 1214 1215 /* Load fdisk table from specified file (-F fdisk_file) */ 1216 if (io_ffdisk) { 1217 /* Load and verify user-specified table parameters */ 1218 load(LOADFILE, io_ffdisk); 1219 } 1220 1221 /* Does user want to delete or add an entry? */ 1222 if (io_Dfdisk) { 1223 load(LOADDEL, io_Dfdisk); 1224 } 1225 if (io_Afdisk) { 1226 load(LOADADD, io_Afdisk); 1227 } 1228 1229 if (!io_ffdisk && !io_Afdisk && !io_Dfdisk) { 1230 /* Check if there is no fdisk table */ 1231 if (nopartdefined() || io_wholedisk || io_EFIdisk) { 1232 if (io_ifdisk && !io_wholedisk && !io_EFIdisk) { 1233 (void) printf( 1234 "No fdisk table exists. The default" 1235 " partition for the disk is:\n\n" 1236 " a 100%% \"SOLARIS System\" " 1237 "partition\n\n" 1238 "Type \"y\" to accept the default " 1239 "partition, otherwise type \"n\" to " 1240 "edit the\n partition table.\n"); 1241 1242 if (Numcyl > Numcyl_usable) 1243 (void) printf("WARNING: Disk is larger" 1244 " than 2TB. Solaris partition will" 1245 " be limited to 2 TB.\n"); 1246 } 1247 1248 /* Edit the partition table as directed */ 1249 if (io_wholedisk ||(io_ifdisk && yesno())) { 1250 1251 /* Default scenario */ 1252 nulltbl(); 1253 /* now set up UNIX System partition */ 1254 Table[0].bootid = ACTIVE; 1255 Table[0].relsect = LE_32(heads * sectors); 1256 1257 Table[0].numsect = 1258 LE_32((ulong_t)((Numcyl_usable - 1) * 1259 heads * sectors)); 1260 1261 Table[0].systid = SUNIXOS2; /* Solaris */ 1262 1263 /* calculate CHS values for table entry 0 */ 1264 Set_Table_CHS_Values(0); 1265 update_disk_and_exit(B_TRUE); 1266 } else if (io_EFIdisk) { 1267 if (efi_create() == 0) { 1268 (void) fprintf(stderr, 1269 "Error creating EFI partition\n"); 1270 exit(1); 1271 } 1272 (void) close(Dev); 1273 exit(0); 1274 /* NOTREACHED */ 1275 } 1276 } 1277 } 1278 1279 /* Display complete fdisk table entries for debugging purposes */ 1280 if (io_debug) { 1281 (void) fprintf(stderr, "Partition Table Entry Values:\n"); 1282 print_Table(); 1283 if (io_ifdisk) { 1284 (void) fprintf(stderr, "\n"); 1285 (void) fprintf(stderr, "Press Enter to continue.\n"); 1286 (void) fgets(s, sizeof (s), stdin); 1287 } 1288 } 1289 1290 /* Interactive fdisk mode */ 1291 if (io_ifdisk) { 1292 (void) printf(CLR_SCR); 1293 disptbl(); 1294 for (;;) { 1295 stage0(); 1296 copy_Bootblk_to_Table(); 1297 disptbl(); 1298 } 1299 } 1300 1301 /* If user wants to write the table to a file, do it */ 1302 if (io_Wfdisk) 1303 ffile_write(io_Wfdisk); 1304 else if (stdo_flag) 1305 ffile_write((char *)stdout); 1306 1307 update_disk_and_exit(TableChanged() == 1); 1308 return (0); 1309 } 1310 1311 /* 1312 * read_geom 1313 * Read geometry from specified file (-S). 1314 */ 1315 1316 static int 1317 read_geom(char *sgeom) 1318 { 1319 char line[256]; 1320 FILE *fp; 1321 1322 /* open the prototype file */ 1323 if ((fp = fopen(sgeom, "r")) == NULL) { 1324 (void) fprintf(stderr, "fdisk: Cannot open file %s.\n", 1325 io_sgeom); 1326 return (1); 1327 } 1328 1329 /* Read a line from the file */ 1330 while (fgets(line, sizeof (line) - 1, fp)) { 1331 if (line[0] == '\0' || line[0] == '\n' || line[0] == '*') { 1332 continue; 1333 } else { 1334 line[strlen(line)] = '\0'; 1335 if (sscanf(line, "%hu %hu %hu %hu %hu %hu %d", 1336 &disk_geom.dkg_pcyl, 1337 &disk_geom.dkg_ncyl, 1338 &disk_geom.dkg_acyl, 1339 &disk_geom.dkg_bcyl, 1340 &disk_geom.dkg_nhead, 1341 &disk_geom.dkg_nsect, 1342 §siz) != 7) { 1343 (void) fprintf(stderr, 1344 "Syntax error:\n \"%s\".\n", 1345 line); 1346 return (1); 1347 } 1348 break; 1349 } /* else */ 1350 } /* while (fgets(line, sizeof (line) - 1, fp)) */ 1351 1352 if (!io_image) { 1353 if (ioctl(Dev, DKIOCSGEOM, &disk_geom)) { 1354 (void) fprintf(stderr, 1355 "fdisk: Cannot set label geometry.\n"); 1356 return (1); 1357 } 1358 } else { 1359 Numcyl = hba_Numcyl = disk_geom.dkg_ncyl; 1360 heads = hba_heads = disk_geom.dkg_nhead; 1361 sectors = hba_sectors = disk_geom.dkg_nsect; 1362 acyl = disk_geom.dkg_acyl; 1363 } 1364 1365 (void) fclose(fp); 1366 return (0); 1367 } 1368 1369 /* 1370 * dev_mboot_read 1371 * Read the master boot sector from the device. 1372 */ 1373 static void 1374 dev_mboot_read(void) 1375 { 1376 if ((ioctl(Dev, DKIOCGMBOOT, Bootsect) < 0) && (errno != ENOTTY)) { 1377 perror("Error in ioctl DKIOCGMBOOT"); 1378 } 1379 if (errno == 0) 1380 return; 1381 if (lseek(Dev, 0, SEEK_SET) == -1) { 1382 (void) fprintf(stderr, 1383 "fdisk: Error seeking to partition table on %s.\n", 1384 Dfltdev); 1385 if (!io_image) 1386 exit(1); 1387 } 1388 if (read(Dev, Bootsect, sectsiz) != sectsiz) { 1389 (void) fprintf(stderr, 1390 "fdisk: Error reading partition table from %s.\n", 1391 Dfltdev); 1392 if (!io_image) 1393 exit(1); 1394 } 1395 } 1396 1397 /* 1398 * dev_mboot_write 1399 * Write the master boot sector to the device. 1400 */ 1401 static void 1402 dev_mboot_write(off_t sect, char *buff, int bootsiz) 1403 { 1404 int new_pt, old_pt, error; 1405 int clr_efi = -1; 1406 1407 if (io_readonly) 1408 return; 1409 1410 if (io_debug) { 1411 (void) fprintf(stderr, "About to write fdisk table:\n"); 1412 print_Table(); 1413 if (io_ifdisk) { 1414 (void) fprintf(stderr, "Press Enter to continue.\n"); 1415 (void) fgets(s, sizeof (s), stdin); 1416 } 1417 } 1418 1419 /* 1420 * If the new table has any Solaris partitions and the old 1421 * table does not have an entry that describes it 1422 * exactly then clear the old vtoc (if any). 1423 */ 1424 for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) { 1425 1426 /* We only care about potential Solaris parts. */ 1427 if (Table[new_pt].systid != SUNIXOS && 1428 Table[new_pt].systid != SUNIXOS2) 1429 continue; 1430 1431 /* Does the old table have an exact entry for the new entry? */ 1432 for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 1433 1434 /* We only care about old Solaris partitions. */ 1435 if ((Old_Table[old_pt].systid == SUNIXOS) || 1436 (Old_Table[old_pt].systid == SUNIXOS2)) { 1437 1438 /* Is this old one the same as a new one? */ 1439 if ((Old_Table[old_pt].relsect == 1440 Table[new_pt].relsect) && 1441 (Old_Table[old_pt].numsect == 1442 Table[new_pt].numsect)) 1443 break; /* Yes */ 1444 } 1445 } 1446 1447 /* Did a solaris partition change location or size? */ 1448 if (old_pt >= FD_NUMPART) { 1449 /* Yes clear old vtoc */ 1450 if (io_debug) { 1451 (void) fprintf(stderr, 1452 "Clearing VTOC labels from NEW" 1453 " table\n"); 1454 } 1455 clear_vtoc(NEW, new_pt); 1456 } 1457 } 1458 1459 /* see if the old table had EFI */ 1460 for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 1461 if (Old_Table[old_pt].systid == EFI_PMBR) { 1462 clr_efi = old_pt; 1463 } 1464 } 1465 1466 /* look to see if a EFI partition changed in relsect/numsect */ 1467 for (new_pt = 0; new_pt < FD_NUMPART; new_pt++) { 1468 if (Table[new_pt].systid != EFI_PMBR) 1469 continue; 1470 for (old_pt = 0; old_pt < FD_NUMPART; old_pt++) { 1471 if ((Old_Table[old_pt].systid == 1472 Table[new_pt].systid) && 1473 (Old_Table[old_pt].relsect == 1474 Table[new_pt].relsect) && 1475 (Old_Table[old_pt].numsect == 1476 Table[new_pt].numsect)) { 1477 /* 1478 * New EFI guard partition matches old. 1479 * Do not clear EFI labels in this case. 1480 */ 1481 clr_efi = -1; 1482 break; 1483 } 1484 } 1485 1486 /* 1487 * if EFI partition changed, set the flag to clear 1488 * the EFI GPT 1489 */ 1490 if (old_pt == FD_NUMPART && Table[new_pt].begcyl != 0) { 1491 clr_efi = 0; 1492 } 1493 break; 1494 } 1495 1496 /* clear labels if necessary */ 1497 if (clr_efi >= 0) { 1498 if (io_debug) { 1499 (void) fprintf(stderr, "Clearing EFI labels\n"); 1500 } 1501 if ((error = clear_efi()) != 0) { 1502 if (io_debug) { 1503 (void) fprintf(stderr, 1504 "\tError %d clearing EFI labels" 1505 " (probably no EFI labels exist)\n", 1506 error); 1507 } 1508 } 1509 } 1510 1511 if ((ioctl(Dev, DKIOCSMBOOT, buff) == -1) && (errno != ENOTTY)) { 1512 (void) fprintf(stderr, 1513 "fdisk: Error in ioctl DKIOCSMBOOT on %s.\n", 1514 Dfltdev); 1515 } 1516 if (errno == 0) 1517 return; 1518 1519 /* write to disk drive */ 1520 if (lseek(Dev, sect, SEEK_SET) == -1) { 1521 (void) fprintf(stderr, 1522 "fdisk: Error seeking to master boot record on %s.\n", 1523 Dfltdev); 1524 exit(1); 1525 } 1526 if (write(Dev, buff, bootsiz) != bootsiz) { 1527 (void) fprintf(stderr, 1528 "fdisk: Error writing master boot record to %s.\n", 1529 Dfltdev); 1530 exit(1); 1531 } 1532 } 1533 1534 /* 1535 * mboot_read 1536 * Read the prototype boot records from the files. 1537 */ 1538 static void 1539 mboot_read(void) 1540 { 1541 int mDev, i; 1542 struct ipart *part; 1543 1544 /* 1545 * If the master boot file hasn't been specified, try to use our 1546 * default. 1547 */ 1548 if (io_mboot == NULL) { 1549 io_mboot = DEFAULT_MASTER_BOOT_FILE; 1550 1551 if ((mDev = open(io_mboot, O_RDONLY, 0666)) == -1) { 1552 /* 1553 * This is not a fault from fdisk's point of view. 1554 * We do not install bootloader with fdisk, 1555 * so just throw away this error and return. 1556 */ 1557 return; 1558 } 1559 } else { 1560 if ((mDev = open(io_mboot, O_RDONLY, 0666)) == -1) { 1561 /* 1562 * The file name was provided by user, provide 1563 * the feedback. 1564 */ 1565 (void) fprintf(stderr, 1566 "fdisk: Cannot open master boot file '%s' : %s\n", 1567 io_mboot, strerror(errno)); 1568 exit(1); 1569 } 1570 } 1571 1572 /* Read the master boot program */ 1573 if (read(mDev, &BootCod, sizeof (struct mboot)) != sizeof 1574 (struct mboot)) { 1575 (void) fprintf(stderr, 1576 "fdisk: Cannot read master boot file %s.\n", 1577 io_mboot); 1578 exit(1); 1579 } 1580 1581 /* Is this really a master boot record? */ 1582 if (LE_16(BootCod.signature) != MBB_MAGIC) { 1583 (void) fprintf(stderr, 1584 "fdisk: Invalid master boot file %s.\n", io_mboot); 1585 (void) fprintf(stderr, 1586 "Bad magic number: is %x, but should be %x.\n", 1587 LE_16(BootCod.signature), MBB_MAGIC); 1588 exit(1); 1589 } 1590 1591 (void) close(mDev); 1592 1593 /* Zero out the partitions part of this record */ 1594 part = (struct ipart *)BootCod.parts; 1595 for (i = 0; i < FD_NUMPART; i++, part++) { 1596 (void) memset(part, 0, sizeof (struct ipart)); 1597 } 1598 1599 } 1600 1601 /* 1602 * fill_patt 1603 * Fill the disk with user/sector number pattern. 1604 */ 1605 static void 1606 fill_patt(void) 1607 { 1608 int *buff_ptr, i; 1609 off_t *off_ptr; 1610 int io_fpatt = 0; 1611 int io_ipatt = 0; 1612 1613 if (strncmp(io_fatt, "#", 1) != 0) { 1614 io_fpatt++; 1615 io_ipatt = strtoul(io_fatt, 0, 0); 1616 buff_ptr = (int *)Bootsect; 1617 for (i = 0; i < sectsiz; i += 4, buff_ptr++) 1618 *buff_ptr = io_ipatt; 1619 } 1620 1621 /* 1622 * Fill disk with pattern based on block number. 1623 * Write to the disk at absolute relative block io_offset 1624 * for io_size blocks. 1625 */ 1626 while (io_size--) { 1627 off_ptr = (off_t *)Bootsect; 1628 if (!io_fpatt) { 1629 for (i = 0; i < sectsiz; 1630 i += sizeof (off_t), off_ptr++) 1631 *off_ptr = io_offset; 1632 } 1633 /* Write the data to disk */ 1634 if (lseek(Dev, (off_t)(sectsiz * io_offset++), 1635 SEEK_SET) == -1) { 1636 (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 1637 Dfltdev); 1638 exit(1); 1639 } 1640 if (write(Dev, Bootsect, sectsiz) != sectsiz) { 1641 (void) fprintf(stderr, "fdisk: Error writing %s.\n", 1642 Dfltdev); 1643 exit(1); 1644 } 1645 } /* while (--io_size); */ 1646 } 1647 1648 /* 1649 * abs_read 1650 * Read from the disk at absolute relative block io_offset for 1651 * io_size blocks. Write the data to standard ouput (-r). 1652 */ 1653 static void 1654 abs_read(void) 1655 { 1656 int c; 1657 1658 while (io_size--) { 1659 if (lseek(Dev, (off_t)(sectsiz * io_offset++), 1660 SEEK_SET) == -1) { 1661 (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 1662 Dfltdev); 1663 exit(1); 1664 } 1665 if (read(Dev, Bootsect, sectsiz) != sectsiz) { 1666 (void) fprintf(stderr, "fdisk: Error reading %s.\n", 1667 Dfltdev); 1668 exit(1); 1669 } 1670 1671 /* Write to standard ouptut */ 1672 if ((c = write(1, Bootsect, (unsigned)sectsiz)) != sectsiz) { 1673 if (c >= 0) { 1674 if (io_debug) 1675 (void) fprintf(stderr, 1676 "fdisk: Output warning: %d of %d" 1677 " characters written.\n", 1678 c, sectsiz); 1679 exit(2); 1680 } else { 1681 perror("write error on output file."); 1682 exit(2); 1683 } 1684 } /* if ((c = write(1, Bootsect, (unsigned)sectsiz)) */ 1685 /* != sectsiz) */ 1686 } /* while (--io_size); */ 1687 exit(0); 1688 } 1689 1690 /* 1691 * abs_write 1692 * Read the data from standard input. Write to the disk at 1693 * absolute relative block io_offset for io_size blocks (-w). 1694 */ 1695 static void 1696 abs_write(void) 1697 { 1698 int c, i; 1699 1700 while (io_size--) { 1701 int part_exit = 0; 1702 /* Read from standard input */ 1703 if ((c = read(0, Bootsect, (unsigned)sectsiz)) != sectsiz) { 1704 if (c >= 0) { 1705 if (io_debug) 1706 (void) fprintf(stderr, 1707 "fdisk: WARNING: Incomplete read (%d of" 1708 " %d characters read) on input file.\n", 1709 c, sectsiz); 1710 /* Fill pattern to mark partial sector in buf */ 1711 for (i = c; i < sectsiz; ) { 1712 Bootsect[i++] = 0x41; 1713 Bootsect[i++] = 0x62; 1714 Bootsect[i++] = 0x65; 1715 Bootsect[i++] = 0; 1716 } 1717 part_exit++; 1718 } else { 1719 perror("read error on input file."); 1720 exit(2); 1721 } 1722 1723 } 1724 /* Write to disk drive */ 1725 if (lseek(Dev, (off_t)(sectsiz * io_offset++), 1726 SEEK_SET) == -1) { 1727 (void) fprintf(stderr, "fdisk: Error seeking on %s.\n", 1728 Dfltdev); 1729 exit(1); 1730 } 1731 if (write(Dev, Bootsect, sectsiz) != sectsiz) { 1732 (void) fprintf(stderr, "fdisk: Error writing %s.\n", 1733 Dfltdev); 1734 exit(1); 1735 } 1736 if (part_exit) 1737 exit(0); 1738 } /* while (--io_size); */ 1739 exit(1); 1740 } 1741 1742 1743 /* 1744 * load 1745 * Load will either read the fdisk table from a file or add or 1746 * delete an entry (-A, -D, -F). 1747 */ 1748 1749 static void 1750 load(int funct, char *file) 1751 { 1752 int id; 1753 int act; 1754 int bhead; 1755 int bsect; 1756 int bcyl; 1757 int ehead; 1758 int esect; 1759 int ecyl; 1760 uint32_t rsect; 1761 uint32_t numsect; 1762 char line[256]; 1763 int i = 0; 1764 FILE *fp; 1765 int startindex = 0; 1766 int tmpindex = 0; 1767 #ifdef i386 1768 int ext_part_present = 0; 1769 uint32_t begsec, endsec, relsect; 1770 logical_drive_t *temp; 1771 int part_count = 0, ldcnt = 0; 1772 uint32_t ext_beg_sec; 1773 uint32_t old_ext_beg_sec = 0, old_ext_num_sec = 0; 1774 uint32_t new_ext_beg_sec = 0, new_ext_num_sec = 0; 1775 int ext_part_inited = 0; 1776 uchar_t systid; 1777 #endif 1778 1779 switch (funct) { 1780 1781 case LOADFILE: 1782 1783 /* 1784 * Zero out the table before loading it, which will 1785 * force it to be updated on disk later (-F 1786 * fdisk_file). 1787 */ 1788 nulltbl(); 1789 1790 /* Open the prototype file */ 1791 if ((fp = fopen(file, "r")) == NULL) { 1792 (void) fprintf(stderr, 1793 "fdisk: Cannot open prototype partition file %s.\n", 1794 file); 1795 exit(1); 1796 } 1797 1798 /* Read a line from the file */ 1799 while (fgets(line, sizeof (line) - 1, fp)) { 1800 if (pars_fdisk(line, &id, &act, &bhead, &bsect, 1801 &bcyl, &ehead, &esect, &ecyl, &rsect, &numsect)) { 1802 continue; 1803 } 1804 #ifdef i386 1805 part_count++; 1806 1807 if (fdisk_is_dos_extended((uchar_t)id)) { 1808 if (ext_part_present) { 1809 (void) fprintf(stderr, 1810 "Extended partition" 1811 " already exists\n"); 1812 (void) fprintf(stderr, "fdisk: Error on" 1813 " entry \"%s\".\n", line); 1814 exit(1); 1815 } 1816 ext_part_present = 1; 1817 /* 1818 * If the existing extended partition's start 1819 * and size matches the new one, do not 1820 * initialize the extended partition EBR 1821 * (Extended Boot Record) because there could 1822 * be existing logical drives. 1823 */ 1824 for (i = 0; i < FD_NUMPART; i++) { 1825 systid = Old_Table[i].systid; 1826 if (fdisk_is_dos_extended(systid)) { 1827 old_ext_beg_sec = 1828 Old_Table[i].relsect; 1829 old_ext_num_sec = 1830 Old_Table[i].numsect; 1831 break; 1832 } 1833 } 1834 new_ext_beg_sec = rsect; 1835 new_ext_num_sec = numsect; 1836 if ((old_ext_beg_sec != new_ext_beg_sec) || 1837 (old_ext_num_sec != new_ext_num_sec)) { 1838 (void) fdisk_init_ext_part(epp, 1839 new_ext_beg_sec, new_ext_num_sec); 1840 ext_part_inited = 1; 1841 } 1842 } 1843 1844 if (part_count > FD_NUMPART) { 1845 /* This line should be logical drive info */ 1846 int offset = MAX_LOGDRIVE_OFFSET; 1847 if (!ext_part_present) { 1848 /* Erroneous input file */ 1849 (void) fprintf(stderr, 1850 "More than 4 primary" 1851 " partitions found in input\n"); 1852 (void) fprintf(stderr, "Exiting...\n"); 1853 exit(1); 1854 } 1855 1856 if (numsect == 0) { 1857 continue; 1858 } 1859 1860 /* 1861 * If the start and size of the existing 1862 * extended partition matches the new one and 1863 * new logical drives are being defined via 1864 * the input file, initialize the EBR. 1865 */ 1866 if (!ext_part_inited) { 1867 (void) fdisk_init_ext_part(epp, 1868 new_ext_beg_sec, new_ext_num_sec); 1869 ext_part_inited = 1; 1870 } 1871 1872 begsec = rsect - offset; 1873 if ((ldcnt = 1874 fdisk_get_logical_drive_count(epp)) == 0) { 1875 /* Adding the first logical drive */ 1876 /* 1877 * Make sure that begsec doesnt wrap 1878 * around. This can happen if rsect is 1879 * less than offset. 1880 */ 1881 if (rsect < offset) { 1882 (void) fprintf(stderr, 1883 "Minimum of " 1884 "63 free sectors required " 1885 "before the beginning of " 1886 "a logical drive."); 1887 exit(1); 1888 } 1889 /* 1890 * Check if the first logical drive 1891 * is out of order. In that case, do 1892 * not subtract MAX_LOGDRIVE_OFFSET 1893 * from the given start of partition. 1894 */ 1895 if (begsec != new_ext_beg_sec) { 1896 begsec = rsect; 1897 offset = 0; 1898 } 1899 } 1900 if (ldcnt >= MAX_EXT_PARTS) { 1901 (void) fprintf(stderr, 1902 "\nError : Number of " 1903 "logical drives exceeds limit of " 1904 "%d.\n", MAX_EXT_PARTS); 1905 exit(1); 1906 } 1907 1908 if (id > FDISK_MAX_VALID_PART_ID) { 1909 (void) fprintf(stderr, 1910 "Invalid partition ID\n"); 1911 (void) fprintf(stderr, "fdisk: Error on" 1912 " entry \"%s\".\n", line); 1913 exit(1); 1914 } 1915 1916 endsec = rsect + numsect - 1; 1917 if (fdisk_validate_logical_drive(epp, 1918 begsec, offset, numsect) == 0) { 1919 if (id == EFI_PMBR) { 1920 (void) fprintf(stderr, "EFI " 1921 "partitions not supported " 1922 "inside extended " 1923 "partition\n"); 1924 exit(1); 1925 } 1926 fdisk_add_logical_drive(epp, begsec, 1927 endsec, id); 1928 continue; 1929 } else { 1930 (void) fprintf(stderr, "fdisk: Error on" 1931 " entry \"%s\".\n", line); 1932 exit(1); 1933 } 1934 } 1935 #endif 1936 1937 /* 1938 * Validate the partition. It cannot start at sector 1939 * 0 unless it is UNUSED or already exists 1940 */ 1941 if (validate_part(id, rsect, numsect) < 0) { 1942 (void) fprintf(stderr, 1943 "fdisk: Error on entry \"%s\".\n", 1944 line); 1945 exit(1); 1946 } 1947 1948 if ((tmpindex = entry_from_old_table(id, act, bhead, 1949 bsect, bcyl, ehead, esect, ecyl, rsect, numsect, 1950 startindex)) != -1) { 1951 /* 1952 * If we got here it means we copied an 1953 * unmodified entry. So there is no need 1954 * to insert it in the table or do any 1955 * checks against disk size. 1956 * 1957 * This is a work around on the following 1958 * situation (for IDE disks, at least): 1959 * Different operation systems calculate 1960 * disk size different ways, of which there 1961 * are two main ways. 1962 * 1963 * The first, rounds the disk size to modulo 1964 * cylinder size (virtual made-up cylinder 1965 * usually based on maximum number of heads 1966 * and sectors in partition table fields). 1967 * Our OS's (for IDE) and most other "Unix" 1968 * type OS's do this. 1969 * 1970 * The second, uses every single block 1971 * on the disk (to maximize available space). 1972 * Since disk manufactures do not know about 1973 * "virtual cylinders", there are some number 1974 * of blocks that make up a partial cylinder 1975 * at the end of the disk. 1976 * 1977 * The difference between these two methods 1978 * is where the problem is. When one 1979 * tries to install Solaris/OpenSolaris on 1980 * a disk that has another OS using that 1981 * "partial cylinder", install fails. It fails 1982 * since fdisk thinks its asked to create a 1983 * partition with the -F option that contains 1984 * a partition that runs off the end of the 1985 * disk. 1986 */ 1987 startindex = tmpindex + 1; 1988 continue; 1989 } 1990 1991 /* 1992 * Find an unused entry to use and put the entry 1993 * in table 1994 */ 1995 if ((startindex = insert_tbl(id, act, bhead, bsect, 1996 bcyl, ehead, esect, ecyl, rsect, numsect, 1997 startindex)) < 0) { 1998 (void) fprintf(stderr, 1999 "fdisk: Error on entry \"%s\".\n", 2000 line); 2001 exit(1); 2002 } 2003 startindex++; 2004 } /* while (fgets(line, sizeof (line) - 1, fp)) */ 2005 2006 if (verify_tbl() < 0) { 2007 (void) fprintf(stderr, 2008 "fdisk: Cannot create partition table\n"); 2009 exit(1); 2010 } 2011 2012 (void) fclose(fp); 2013 return; 2014 2015 case LOADDEL: 2016 2017 /* Parse the user-supplied deletion line (-D) */ 2018 if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl, 2019 &ehead, &esect, &ecyl, &rsect, &numsect)) { 2020 (void) fprintf(stderr, 2021 "fdisk: Syntax error \"%s\"\n", file); 2022 exit(1); 2023 } 2024 2025 /* Find the exact entry in the table */ 2026 for (i = 0; i < FD_NUMPART; i++) { 2027 if (Table[i].systid == id && 2028 Table[i].bootid == act && 2029 Table[i].beghead == bhead && 2030 Table[i].begsect == ((bsect & 0x3f) | 2031 (uchar_t)((bcyl>>2) & 0xc0)) && 2032 Table[i].begcyl == (uchar_t)(bcyl & 0xff) && 2033 Table[i].endhead == ehead && 2034 Table[i].endsect == ((esect & 0x3f) | 2035 (uchar_t)((ecyl>>2) & 0xc0)) && 2036 Table[i].endcyl == (uchar_t)(ecyl & 0xff) && 2037 Table[i].relsect == LE_32(rsect) && 2038 Table[i].numsect == LE_32(numsect)) { 2039 2040 (void) memset(&Table[i], 0, 2041 sizeof (struct ipart)); 2042 #ifdef i386 2043 if (fdisk_is_dos_extended(id)) { 2044 (void) fdisk_delete_ext_part(epp); 2045 } 2046 #endif 2047 return; 2048 } 2049 } 2050 2051 #ifdef i386 2052 ldcnt = FD_NUMPART + 1; 2053 for (temp = fdisk_get_ld_head(epp); temp != NULL; 2054 temp = temp->next) { 2055 relsect = temp->abs_secnum + temp->logdrive_offset; 2056 if (temp->parts[0].systid == id && 2057 temp->parts[0].bootid == act && 2058 temp->parts[0].beghead == bhead && 2059 temp->parts[0].begsect == ((bsect & 0x3f) | 2060 (uchar_t)((bcyl>>2) & 0xc0)) && 2061 temp->parts[0].begcyl == (uchar_t)(bcyl & 0xff) && 2062 temp->parts[0].endhead == ehead && 2063 temp->parts[0].endsect == ((esect & 0x3f) | 2064 (uchar_t)((ecyl>>2) & 0xc0)) && 2065 temp->parts[0].endcyl == (uchar_t)(ecyl & 0xff) && 2066 relsect == LE_32(rsect) && 2067 temp->parts[0].numsect == LE_32(numsect)) { 2068 fdisk_delete_logical_drive(epp, ldcnt); 2069 return; 2070 } 2071 ldcnt++; 2072 } 2073 #endif 2074 2075 (void) fprintf(stderr, 2076 "fdisk: Entry does not match any existing partition:\n" 2077 " \"%s\"\n", 2078 file); 2079 exit(1); 2080 /* FALLTHROUGH */ 2081 2082 case LOADADD: 2083 2084 /* Parse the user-supplied addition line (-A) */ 2085 if (pars_fdisk(file, &id, &act, &bhead, &bsect, &bcyl, &ehead, 2086 &esect, &ecyl, &rsect, &numsect)) { 2087 (void) fprintf(stderr, 2088 "fdisk: Syntax error \"%s\"\n", file); 2089 exit(1); 2090 } 2091 2092 /* Validate the partition. It cannot start at sector 0 */ 2093 if (rsect == 0) { 2094 (void) fprintf(stderr, 2095 "fdisk: New partition cannot start at sector 0:\n" 2096 " \"%s\".\n", 2097 file); 2098 exit(1); 2099 } 2100 2101 /* 2102 * if the user wishes to add an EFI partition, we need 2103 * more extensive validation. rsect should be 1, and 2104 * numsect should equal the entire disk capacity - 1 2105 */ 2106 2107 if (id == EFI_PMBR) { 2108 if (rsect != 1) { 2109 (void) fprintf(stderr, 2110 "fdisk: EFI partitions must start at sector" 2111 " 1 (input rsect = %d)\n", rsect); 2112 exit(1); 2113 } 2114 2115 2116 if (dev_capacity > DK_MAX_2TB) { 2117 if (numsect != DK_MAX_2TB) { 2118 (void) fprintf(stderr, 2119 "fdisk: EFI partitions must " 2120 "encompass the entire maximum 2 TB " 2121 "(input numsect: %u - max: %llu)\n", 2122 numsect, (diskaddr_t)DK_MAX_2TB); 2123 exit(1); 2124 } 2125 } else if (numsect != dev_capacity - 1) { 2126 (void) fprintf(stderr, 2127 "fdisk: EFI partitions must encompass the " 2128 "entire disk\n" 2129 "(input numsect: %u - avail: %llu)\n", 2130 numsect, 2131 dev_capacity - 1); 2132 exit(1); 2133 } 2134 } 2135 2136 #ifdef i386 2137 if (id > FDISK_MAX_VALID_PART_ID) { 2138 (void) printf("Invalid partition ID\n"); 2139 exit(1); 2140 } 2141 2142 if ((fdisk_ext_part_exists(epp)) && 2143 (fdisk_is_dos_extended(id))) { 2144 (void) fprintf(stderr, 2145 "Extended partition already exists.\n"); 2146 (void) fprintf(stderr, 2147 "fdisk: Invalid entry could not be " 2148 "inserted:\n \"%s\"\n", file); 2149 exit(1); 2150 } 2151 2152 if (fdisk_ext_part_exists(epp) && 2153 (rsect >= (ext_beg_sec = fdisk_get_ext_beg_sec(epp))) && 2154 (rsect <= (fdisk_get_ext_end_sec(epp)))) { 2155 int offset = MAX_LOGDRIVE_OFFSET; 2156 2157 /* 2158 * Make sure that begsec doesnt wrap around. 2159 * This can happen if rsect is less than offset 2160 */ 2161 if (rsect < offset) { 2162 return; 2163 } 2164 begsec = rsect - offset; 2165 if ((ldcnt = fdisk_get_logical_drive_count(epp)) == 0) { 2166 /* 2167 * Adding the first logical drive 2168 * Check if the first logical drive 2169 * is out of order. In that case, do 2170 * not subtract MAX_LOGDRIVE_OFFSET 2171 * from the given start of partition. 2172 */ 2173 if (begsec != ext_beg_sec) { 2174 begsec = rsect; 2175 offset = 0; 2176 } 2177 } 2178 2179 if (ldcnt >= MAX_EXT_PARTS) { 2180 (void) printf("\nNumber of logical drives " 2181 "exceeds limit of %d.\n", MAX_EXT_PARTS); 2182 (void) printf("Failing further additions.\n"); 2183 exit(1); 2184 } 2185 2186 if (numsect == 0) { 2187 (void) fprintf(stderr, 2188 "fdisk: Partition size cannot be zero:\n" 2189 " \"%s\".\n", 2190 file); 2191 exit(1); 2192 } 2193 endsec = rsect + numsect - 1; 2194 if (fdisk_validate_logical_drive(epp, begsec, 2195 offset, numsect) == 0) { 2196 /* Valid logical drive */ 2197 fdisk_add_logical_drive(epp, begsec, endsec, 2198 id); 2199 return; 2200 } else { 2201 (void) fprintf(stderr, 2202 "fdisk: Invalid entry could not be " 2203 "inserted:\n \"%s\"\n", file); 2204 exit(1); 2205 } 2206 } 2207 #endif 2208 2209 /* Find unused entry for use and put entry in table */ 2210 if (insert_tbl(id, act, bhead, bsect, bcyl, ehead, esect, 2211 ecyl, rsect, numsect, 0) < 0) { 2212 (void) fprintf(stderr, 2213 "fdisk: Invalid entry could not be inserted:\n" 2214 " \"%s\"\n", 2215 file); 2216 exit(1); 2217 } 2218 2219 /* Make sure new entry does not overlap existing entry */ 2220 if (verify_tbl() < 0) { 2221 (void) fprintf(stderr, 2222 "fdisk: Cannot create partition \"%s\"\n", file); 2223 exit(1); 2224 } 2225 } /* switch funct */ 2226 } 2227 2228 /* 2229 * Set_Table_CHS_Values 2230 * 2231 * This will calculate the CHS values for beginning and ending CHS 2232 * for a single partition table entry (ti) based on the relsect 2233 * and numsect values contained in the partion table entry. 2234 * 2235 * hba_heads and hba_sectors contain the number of heads and sectors. 2236 * 2237 * If the number of cylinders exceeds the MAX_CYL, 2238 * then maximum values will be placed in the corresponding chs entry. 2239 */ 2240 static void 2241 Set_Table_CHS_Values(int ti) 2242 { 2243 uint32_t lba, cy, hd, sc; 2244 2245 lba = (uint32_t)Table[ti].relsect; 2246 if (lba >= hba_heads * hba_sectors * MAX_CYL) { 2247 /* 2248 * the lba address cannot be expressed in CHS value 2249 * so store the maximum CHS field values in the CHS fields. 2250 */ 2251 cy = MAX_CYL + 1; 2252 hd = MAX_HEAD + 1; 2253 sc = MAX_SECT; 2254 } else { 2255 cy = lba / hba_sectors / hba_heads; 2256 hd = lba / hba_sectors % hba_heads; 2257 sc = lba % hba_sectors + 1; 2258 } 2259 Table[ti].begcyl = cy & 0xff; 2260 Table[ti].beghead = (uchar_t)hd; 2261 Table[ti].begsect = (uchar_t)(((cy >> 2) & 0xc0) | sc); 2262 2263 /* 2264 * This code is identical to the code above 2265 * except that it works on ending CHS values 2266 */ 2267 lba = (uint32_t)(Table[ti].relsect + Table[ti].numsect - 1); 2268 if (lba >= hba_heads * hba_sectors * MAX_CYL) { 2269 cy = MAX_CYL + 1; 2270 hd = MAX_HEAD + 1; 2271 sc = MAX_SECT; 2272 } else { 2273 cy = lba / hba_sectors / hba_heads; 2274 hd = lba / hba_sectors % hba_heads; 2275 sc = lba % hba_sectors + 1; 2276 } 2277 Table[ti].endcyl = cy & 0xff; 2278 Table[ti].endhead = (uchar_t)hd; 2279 Table[ti].endsect = (uchar_t)(((cy >> 2) & 0xc0) | sc); 2280 } 2281 2282 /* 2283 * insert_tbl 2284 * Insert entry into fdisk table. Check all user-supplied values 2285 * for the entry, but not the validity relative to other table 2286 * entries! 2287 */ 2288 static int 2289 insert_tbl( 2290 int id, int act, 2291 int bhead, int bsect, int bcyl, 2292 int ehead, int esect, int ecyl, 2293 uint32_t rsect, uint32_t numsect, int startindex) 2294 { 2295 int i; 2296 2297 /* validate partition size */ 2298 if (((diskaddr_t)rsect + numsect) > dev_capacity) { 2299 (void) fprintf(stderr, 2300 "fdisk: Partition table exceeds the size of the disk.\n"); 2301 return (-1); 2302 } 2303 2304 2305 /* find UNUSED partition table entry */ 2306 for (i = startindex; i < FD_NUMPART; i++) { 2307 if (Table[i].systid == UNUSED) { 2308 break; 2309 } 2310 } 2311 if (i >= FD_NUMPART) { 2312 (void) fprintf(stderr, "fdisk: Partition table is full.\n"); 2313 return (-1); 2314 } 2315 2316 Table[i].systid = (uchar_t)id; 2317 Table[i].bootid = (uchar_t)act; 2318 Table[i].numsect = LE_32(numsect); 2319 Table[i].relsect = LE_32(rsect); 2320 2321 if (id == UNUSED) { 2322 (void) memset(&Table[i], 0, sizeof (struct ipart)); 2323 } else if (0 < bsect && bsect <= MAX_SECT && 2324 0 <= bhead && bhead <= MAX_HEAD + 1 && 2325 0 < esect && esect <= MAX_SECT && 2326 0 <= ehead && ehead <= MAX_HEAD + 1) { 2327 2328 /* 2329 * If we have been called with a valid geometry, use it 2330 * valid means non-zero values that fit in the BIOS fields 2331 */ 2332 if (bcyl > MAX_CYL) { 2333 /* 2334 * bcyl is set to the special fence value indicating 2335 * that the geometry is not representable for the 2336 * start LBA. 2337 * Set all fields to the maximum values. 2338 */ 2339 bcyl = MAX_CYL + 1; 2340 bhead = MAX_HEAD + 1; 2341 bsect = MAX_SECT; 2342 } 2343 if (ecyl > MAX_CYL) { 2344 ecyl = MAX_CYL + 1; 2345 ehead = MAX_HEAD + 1; 2346 esect = MAX_SECT; 2347 } 2348 Table[i].begcyl = bcyl & 0xff; 2349 Table[i].endcyl = ecyl & 0xff; 2350 Table[i].beghead = (uchar_t)bhead; 2351 Table[i].endhead = (uchar_t)ehead; 2352 Table[i].begsect = (uchar_t)(((bcyl >> 2) & 0xc0) | bsect); 2353 Table[i].endsect = ((ecyl >> 2) & 0xc0) | esect; 2354 } else { 2355 2356 /* 2357 * The specified values are invalid, 2358 * so calculate the values based on hba_heads, hba_sectors 2359 */ 2360 Set_Table_CHS_Values(i); 2361 } 2362 2363 /* 2364 * return partition index 2365 */ 2366 return (i); 2367 } 2368 2369 /* 2370 * entry_from_old_table 2371 * If the specified entry is in the old table and is not a Solaris entry 2372 * then insert same entry into new fdisk table. If we do this then 2373 * all checks are skipped for that entry! 2374 */ 2375 static int 2376 entry_from_old_table( 2377 int id, int act, 2378 int bhead, int bsect, int bcyl, 2379 int ehead, int esect, int ecyl, 2380 uint32_t rsect, uint32_t numsect, int startindex) 2381 { 2382 uint32_t i, j; 2383 2384 if (id == SUNIXOS || id == SUNIXOS2 || id == UNUSED) 2385 return (-1); 2386 for (i = 0; i < FD_NUMPART; i++) { 2387 if (Old_Table[i].systid == id && 2388 Old_Table[i].bootid == act && 2389 Old_Table[i].beghead == bhead && 2390 Old_Table[i].begsect == ((bsect & 0x3f) | 2391 (uchar_t)((bcyl>>2) & 0xc0)) && 2392 Old_Table[i].begcyl == (uchar_t)(bcyl & 0xff) && 2393 Old_Table[i].endhead == ehead && 2394 Old_Table[i].endsect == ((esect & 0x3f) | 2395 (uchar_t)((ecyl>>2) & 0xc0)) && 2396 Old_Table[i].endcyl == (uchar_t)(ecyl & 0xff) && 2397 Old_Table[i].relsect == lel(rsect) && 2398 Old_Table[i].numsect == lel(numsect)) { 2399 /* find UNUSED partition table entry */ 2400 for (j = startindex; j < FD_NUMPART; j++) { 2401 if (Table[j].systid == UNUSED) { 2402 (void) memcpy(&Table[j], &Old_Table[i], 2403 sizeof (Table[0])); 2404 skip_verify[j] = 1; 2405 return (j); 2406 2407 } 2408 } 2409 return (-1); 2410 } 2411 2412 } 2413 return (-1); 2414 } 2415 2416 /* 2417 * verify_tbl 2418 * Verify that no partition entries overlap or exceed the size of 2419 * the disk. 2420 */ 2421 static int 2422 verify_tbl(void) 2423 { 2424 uint32_t i, j, rsect, numsect; 2425 int noMoreParts = 0; 2426 int numParts = 0; 2427 2428 /* Make sure new entry does not overlap an existing entry */ 2429 for (i = 0; i < FD_NUMPART - 1; i++) { 2430 if (Table[i].systid != UNUSED) { 2431 numParts++; 2432 /* 2433 * No valid partitions allowed after EFI_PMBR part 2434 */ 2435 if (noMoreParts) { 2436 return (-1); 2437 } 2438 2439 if (Table[i].systid == EFI_PMBR) { 2440 /* 2441 * EFI_PMBR partition must be the only 2442 * partition 2443 */ 2444 noMoreParts = 1; 2445 2446 if (Table[i].relsect != 1) { 2447 (void) fprintf(stderr, "ERROR: " 2448 "Invalid starting sector " 2449 "for EFI_PMBR partition:\n" 2450 "relsect %d " 2451 "(should be 1)\n", 2452 Table[i].relsect); 2453 2454 return (-1); 2455 } 2456 2457 if (Table[i].numsect != 2458 ((dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB: 2459 (dev_capacity - 1))) { 2460 2461 (void) fprintf(stderr, "ERROR: " 2462 "EFI_PMBR partition must " 2463 "encompass the entire"); 2464 2465 if (dev_capacity > DK_MAX_2TB) 2466 (void) fprintf(stderr, 2467 "maximum 2 TB.\n " 2468 "numsect %u - " 2469 "actual %llu\n", 2470 Table[i].numsect, 2471 (diskaddr_t)DK_MAX_2TB); 2472 2473 else 2474 (void) fprintf(stderr, 2475 "disk.\n numsect %u - " 2476 "actual %llu\n", 2477 Table[i].numsect, 2478 dev_capacity - 1); 2479 2480 return (-1); 2481 } 2482 } 2483 2484 /* make sure the partition isn't larger than the disk */ 2485 rsect = LE_32(Table[i].relsect); 2486 numsect = LE_32(Table[i].numsect); 2487 2488 if ((((diskaddr_t)rsect + numsect) > dev_capacity) || 2489 (((diskaddr_t)rsect + numsect) > DK_MAX_2TB)) { 2490 if (!skip_verify[i]) 2491 return (-1); 2492 } 2493 2494 for (j = i + 1; j < FD_NUMPART; j++) { 2495 if (Table[j].systid != UNUSED) { 2496 uint32_t t_relsect = 2497 LE_32(Table[j].relsect); 2498 uint32_t t_numsect = 2499 LE_32(Table[j].numsect); 2500 2501 if (noMoreParts) { 2502 (void) fprintf(stderr, 2503 "Cannot add partition to " 2504 "table; no more partitions " 2505 "allowed\n"); 2506 2507 if (io_debug) { 2508 (void) fprintf(stderr, 2509 "DEBUG: Current " 2510 "partition:\t" 2511 "%d:%d:%d:%d:%d:" 2512 "%d:%d:%d:%d:%d\n" 2513 " Next " 2514 "partition:\t\t" 2515 "%d:%d:%d:%d:%d:" 2516 "%d:%d:%d:%d:%d\n", 2517 Table[i].systid, 2518 Table[i].bootid, 2519 Table[i].begcyl, 2520 Table[i].beghead, 2521 Table[i].begsect, 2522 Table[i].endcyl, 2523 Table[i].endhead, 2524 Table[i].endsect, 2525 Table[i].relsect, 2526 Table[i].numsect, 2527 Table[j].systid, 2528 Table[j].bootid, 2529 Table[j].begcyl, 2530 Table[j].beghead, 2531 Table[j].begsect, 2532 Table[j].endcyl, 2533 Table[j].endhead, 2534 Table[j].endsect, 2535 Table[j].relsect, 2536 Table[j].numsect); 2537 } 2538 2539 return (-1); 2540 } 2541 if ((rsect >= 2542 (t_relsect + t_numsect)) || 2543 ((rsect + numsect) <= t_relsect)) { 2544 continue; 2545 } else { 2546 (void) fprintf(stderr, "ERROR: " 2547 "current partition overlaps" 2548 " following partition\n"); 2549 2550 return (-1); 2551 } 2552 } 2553 } 2554 } 2555 } 2556 if (Table[i].systid != UNUSED) { 2557 if (noMoreParts) 2558 return (-1); 2559 if (!skip_verify[i] && 2560 ((((diskaddr_t)lel(Table[i].relsect) + 2561 lel(Table[i].numsect)) > dev_capacity) || 2562 (((diskaddr_t)lel(Table[i].relsect) + 2563 lel(Table[i].numsect)) > DK_MAX_2TB))) { 2564 return (-1); 2565 } 2566 } 2567 2568 return (numParts); 2569 } 2570 2571 /* 2572 * pars_fdisk 2573 * Parse user-supplied data to set up fdisk partitions 2574 * (-A, -D, -F). 2575 */ 2576 static int 2577 pars_fdisk( 2578 char *line, 2579 int *id, int *act, 2580 int *bhead, int *bsect, int *bcyl, 2581 int *ehead, int *esect, int *ecyl, 2582 uint32_t *rsect, uint32_t *numsect) 2583 { 2584 int i; 2585 int64_t test; 2586 char *tok, *p; 2587 char buf[256]; 2588 2589 if (line[0] == '\0' || line[0] == '\n' || line[0] == '*') 2590 return (1); 2591 line[strlen(line)] = '\0'; 2592 for (i = 0; i < strlen(line); i++) { 2593 if (line[i] == '\0') { 2594 break; 2595 } else if (line[i] == ':') { 2596 line[i] = ' '; 2597 } 2598 } 2599 (void) strncpy(buf, line, 256); 2600 errno = 0; 2601 tok = strtok(buf, ": \t\n"); 2602 while (tok != NULL) { 2603 for (p = tok; *p != '\0'; p++) { 2604 if (!isdigit(*p)) { 2605 (void) printf("Invalid input %s in line %s.\n", 2606 tok, line); 2607 exit(1); 2608 } 2609 } 2610 2611 test = strtoll(tok, (char **)NULL, 10); 2612 if ((test < 0) || (test > 0xFFFFFFFF) || (errno != 0)) { 2613 (void) printf("Invalid input %s in line %s.\n", tok, 2614 line); 2615 exit(1); 2616 } 2617 tok = strtok(NULL, ": \t\n"); 2618 } 2619 if (sscanf(line, "%d %d %d %d %d %d %d %d %u %u", 2620 id, act, bhead, bsect, bcyl, ehead, esect, ecyl, 2621 rsect, numsect) != 10) { 2622 (void) fprintf(stderr, "Syntax error:\n \"%s\".\n", line); 2623 exit(1); 2624 } 2625 return (0); 2626 } 2627 2628 /* 2629 * validate_part 2630 * Validate that a new partition does not start at sector 0. Only UNUSED 2631 * partitions and previously existing partitions are allowed to start at 0. 2632 */ 2633 static int 2634 validate_part(int id, uint32_t rsect, uint32_t numsect) 2635 { 2636 int i; 2637 if ((id != UNUSED) && (rsect == 0)) { 2638 for (i = 0; i < FD_NUMPART; i++) { 2639 if ((Old_Table[i].systid == id) && 2640 (Old_Table[i].relsect == LE_32(rsect)) && 2641 (Old_Table[i].numsect == LE_32(numsect))) 2642 return (0); 2643 } 2644 (void) fprintf(stderr, 2645 "New partition cannot start at sector 0\n"); 2646 return (-1); 2647 } 2648 #ifdef i386 2649 if (id > FDISK_MAX_VALID_PART_ID) { 2650 (void) fprintf(stderr, "Invalid partition ID\n"); 2651 return (-1); 2652 } 2653 #endif 2654 return (0); 2655 } 2656 2657 /* 2658 * stage0 2659 * Print out interactive menu and process user input. 2660 */ 2661 static void 2662 stage0(void) 2663 { 2664 #ifdef i386 2665 int rval; 2666 #endif 2667 dispmenu(); 2668 for (;;) { 2669 (void) printf(Q_LINE); 2670 (void) printf("Enter Selection: "); 2671 (void) fgets(s, sizeof (s), stdin); 2672 rm_blanks(s); 2673 #ifdef i386 2674 while (!((s[0] > '0') && (s[0] < '8') && 2675 ((s[1] == '\0') || (s[1] == '\n')))) { 2676 #else 2677 while (!((s[0] > '0') && (s[0] < '7') && 2678 ((s[1] == '\0') || (s[1] == '\n')))) { 2679 #endif 2680 (void) printf(E_LINE); /* Clear any previous error */ 2681 #ifdef i386 2682 (void) printf( 2683 "Enter a one-digit number between 1 and 7."); 2684 #else 2685 (void) printf( 2686 "Enter a one-digit number between 1 and 6."); 2687 #endif 2688 (void) printf(Q_LINE); 2689 (void) printf("Enter Selection: "); 2690 (void) fgets(s, sizeof (s), stdin); 2691 rm_blanks(s); 2692 } 2693 (void) printf(E_LINE); 2694 switch (s[0]) { 2695 case '1': 2696 if (pcreate() == -1) 2697 return; 2698 break; 2699 case '2': 2700 if (pchange() == -1) 2701 return; 2702 break; 2703 case '3': 2704 if (pdelete() == -1) 2705 return; 2706 break; 2707 case '4': 2708 if (ppartid() == -1) 2709 return; 2710 break; 2711 #ifdef i386 2712 case '5': 2713 if (fdisk_ext_part_exists(epp)) { 2714 ext_part_menu(); 2715 } else { 2716 (void) printf(Q_LINE); 2717 (void) printf("\nNo extended partition" 2718 " found\n"); 2719 (void) printf("Press enter to " 2720 "continue\n"); 2721 ext_read_input(s); 2722 } 2723 break; 2724 case '6': 2725 /* update disk partition table, if changed */ 2726 if (TableChanged() == 1) { 2727 copy_Table_to_Bootblk(); 2728 dev_mboot_write(0, Bootsect, sectsiz); 2729 } 2730 2731 /* 2732 * If the VTOC table is wrong fix it 2733 * (truncate only) 2734 */ 2735 if (io_adjt) { 2736 fix_slice(); 2737 } 2738 if (!io_readonly) { 2739 rval = fdisk_commit_ext_part(epp); 2740 switch (rval) { 2741 case FDISK_SUCCESS: 2742 /* Success */ 2743 /* Fallthrough */ 2744 case FDISK_ENOEXTPART: 2745 /* Nothing to do */ 2746 break; 2747 case FDISK_EMOUNTED: 2748 (void) printf(Q_LINE); 2749 preach_and_continue(); 2750 continue; 2751 default: 2752 perror("Commit failed"); 2753 exit(1); 2754 } 2755 libfdisk_fini(&epp); 2756 } 2757 (void) close(Dev); 2758 exit(0); 2759 /* NOTREACHED */ 2760 #else 2761 case '5': 2762 /* update disk partition table, if changed */ 2763 if (TableChanged() == 1) { 2764 copy_Table_to_Bootblk(); 2765 dev_mboot_write(0, Bootsect, sectsiz); 2766 } 2767 /* 2768 * If the VTOC table is wrong fix it 2769 * (truncate only) 2770 */ 2771 if (io_adjt) { 2772 fix_slice(); 2773 } 2774 (void) close(Dev); 2775 exit(0); 2776 /* FALLTHROUGH */ 2777 #endif 2778 #ifdef i386 2779 case '7': 2780 #else 2781 case '6': 2782 #endif 2783 /* 2784 * If the VTOC table is wrong fix it 2785 * (truncate only) 2786 */ 2787 if (io_adjt) { 2788 fix_slice(); 2789 } 2790 (void) close(Dev); 2791 exit(0); 2792 /* FALLTHROUGH */ 2793 default: 2794 break; 2795 } 2796 copy_Table_to_Bootblk(); 2797 disptbl(); 2798 dispmenu(); 2799 } 2800 } 2801 2802 /* 2803 * pcreate 2804 * Create partition entry in the table (interactive mode). 2805 */ 2806 static int 2807 pcreate(void) 2808 { 2809 uchar_t tsystid = 'z'; 2810 int i, j; 2811 uint32_t numsect; 2812 int retCode = 0; 2813 #ifdef i386 2814 int ext_part_present = 0; 2815 #endif 2816 2817 i = 0; 2818 for (;;) { 2819 if (i == FD_NUMPART) { 2820 (void) printf(E_LINE); 2821 (void) printf( 2822 "The partition table is full!\n" 2823 "You must delete a partition before creating" 2824 " a new one.\n"); 2825 return (-1); 2826 } 2827 if (Table[i].systid == UNUSED) { 2828 break; 2829 } 2830 i++; 2831 } 2832 2833 numsect = 0; 2834 for (i = 0; i < FD_NUMPART; i++) { 2835 if (Table[i].systid != UNUSED) { 2836 numsect += LE_32(Table[i].numsect); 2837 } 2838 #ifdef i386 2839 /* Check if an extended partition already exists */ 2840 if (fdisk_is_dos_extended(Table[i].systid)) { 2841 ext_part_present = 1; 2842 } 2843 #endif 2844 if (numsect >= chs_capacity) { 2845 (void) printf(E_LINE); 2846 (void) printf("There is no more room on the disk for" 2847 " another partition.\n"); 2848 (void) printf( 2849 "You must delete a partition before creating" 2850 " a new one.\n"); 2851 return (-1); 2852 } 2853 } 2854 while (tsystid == 'z') { 2855 2856 /* 2857 * The question here is expanding to more than what is 2858 * allocated for question lines (Q_LINE) which garbles 2859 * at least warning line. Clearing warning line as workaround 2860 * for now. 2861 */ 2862 2863 (void) printf(W_LINE); 2864 (void) printf(Q_LINE); 2865 (void) printf( 2866 "Select the partition type to create:\n" 2867 " 1=SOLARIS2 2=UNIX 3=PCIXOS 4=Other\n" 2868 " 5=DOS12 6=DOS16 7=DOSEXT 8=DOSBIG\n" 2869 " 9=DOS16LBA A=x86 Boot B=Diagnostic C=FAT32\n" 2870 " D=FAT32LBA E=DOSEXTLBA F=EFI 0=Exit? "); 2871 (void) fgets(s, sizeof (s), stdin); 2872 rm_blanks(s); 2873 if ((s[1] != '\0') && (s[1] != '\n')) { 2874 (void) printf(E_LINE); 2875 (void) printf("Invalid selection, try again."); 2876 continue; 2877 } 2878 switch (s[0]) { 2879 case '0': /* exit */ 2880 (void) printf(E_LINE); 2881 return (-1); 2882 case '1': /* Solaris partition */ 2883 tsystid = SUNIXOS2; 2884 break; 2885 case '2': /* UNIX partition */ 2886 tsystid = UNIXOS; 2887 break; 2888 case '3': /* PCIXOS partition */ 2889 tsystid = PCIXOS; 2890 break; 2891 case '4': /* OTHEROS System partition */ 2892 tsystid = OTHEROS; 2893 break; 2894 case '5': 2895 tsystid = DOSOS12; /* DOS 12 bit fat */ 2896 break; 2897 case '6': 2898 tsystid = DOSOS16; /* DOS 16 bit fat */ 2899 break; 2900 case '7': 2901 #ifdef i386 2902 if (ext_part_present) { 2903 (void) printf(Q_LINE); 2904 (void) printf(E_LINE); 2905 (void) fprintf(stderr, 2906 "Extended partition already exists\n"); 2907 (void) fprintf(stderr, 2908 "Press enter to continue\n"); 2909 ext_read_input(s); 2910 continue; 2911 } 2912 #endif 2913 tsystid = EXTDOS; 2914 break; 2915 case '8': 2916 tsystid = DOSHUGE; 2917 break; 2918 case '9': 2919 tsystid = FDISK_FAT95; /* FAT16, need extended int13 */ 2920 break; 2921 case 'a': /* x86 Boot partition */ 2922 case 'A': 2923 tsystid = X86BOOT; 2924 break; 2925 case 'b': /* Diagnostic boot partition */ 2926 case 'B': 2927 tsystid = DIAGPART; 2928 break; 2929 case 'c': /* FAT32 */ 2930 case 'C': 2931 tsystid = FDISK_WINDOWS; 2932 break; 2933 case 'd': /* FAT32 and need extended int13 */ 2934 case 'D': 2935 tsystid = FDISK_EXT_WIN; 2936 break; 2937 case 'e': /* Extended partition, need extended int13 */ 2938 case 'E': 2939 #ifdef i386 2940 if (ext_part_present) { 2941 (void) printf(Q_LINE); 2942 (void) printf(E_LINE); 2943 (void) fprintf(stderr, 2944 "Extended partition already exists\n"); 2945 (void) fprintf(stderr, 2946 "Press enter to continue\n"); 2947 ext_read_input(s); 2948 continue; 2949 } 2950 #endif 2951 tsystid = FDISK_EXTLBA; 2952 break; 2953 case 'f': 2954 case 'F': 2955 tsystid = EFI_PMBR; 2956 break; 2957 default: 2958 (void) printf(E_LINE); 2959 (void) printf("Invalid selection, try again."); 2960 continue; 2961 } 2962 } 2963 2964 (void) printf(E_LINE); 2965 2966 if (tsystid != EFI_PMBR) { 2967 (void) printf(W_LINE); 2968 if ((dev_capacity > DK_MAX_2TB)) 2969 (void) printf("WARNING: Disk is larger than 2 TB. " 2970 "Upper limit is 2 TB for non-EFI partition ID\n"); 2971 2972 /* create the new partition */ 2973 i = specify(tsystid); 2974 2975 if (i != -1) { 2976 /* see if it should be the active partition */ 2977 (void) printf(E_LINE); 2978 (void) printf(Q_LINE); 2979 2980 (void) printf( 2981 "Should this become the active partition? If " 2982 "yes, it will be activated\n" 2983 "each time the computer is reset or turned on.\n" 2984 "Please type \"y\" or \"n\". "); 2985 2986 if (yesno()) { 2987 (void) printf(E_LINE); 2988 for (j = 0; j < FD_NUMPART; j++) { 2989 if (j == i) { 2990 Table[j].bootid = ACTIVE; 2991 (void) printf(E_LINE); 2992 (void) printf( 2993 "Partition %d is now " 2994 "the active partition.", 2995 j + 1); 2996 } else { 2997 Table[j].bootid = 0; 2998 } 2999 } 3000 } else { 3001 Table[i].bootid = 0; 3002 } 3003 3004 #ifdef i386 3005 /* 3006 * If partition created is an extended partition, null 3007 * out the first sector of the first cylinder of the 3008 * extended partition 3009 */ 3010 if (fdisk_is_dos_extended(Table[i].systid)) { 3011 (void) fdisk_init_ext_part(epp, 3012 LE_32(Table[i].relsect), 3013 LE_32(Table[i].numsect)); 3014 } 3015 #endif 3016 /* set up the return code */ 3017 i = 1; 3018 } 3019 } else { 3020 /* 3021 * partitions of type EFI_PMBR must be the only partitions in 3022 * the table 3023 * 3024 * First, make sure there were no errors the table is 3025 * empty 3026 */ 3027 retCode = verify_tbl(); 3028 3029 if (retCode < 0) { 3030 (void) fprintf(stderr, 3031 "fdisk: Cannot create EFI partition table; \n" 3032 "current partition table is invalid.\n"); 3033 return (-1); 3034 } else if (retCode > 0) { 3035 (void) printf( 3036 "An EFI partition must be the only partition on " 3037 "disk. You may manually delete existing\n" 3038 "partitions, or fdisk can do it.\n" 3039 "Do you want fdisk to destroy existing " 3040 "partitions?\n" 3041 "Please type \"y\" or \"n\". "); 3042 3043 if (yesno()) { 3044 nulltbl(); 3045 } else { 3046 return (-1); 3047 } 3048 } 3049 3050 /* create the table entry - i should be 0 */ 3051 i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 1, 3052 (dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB: 3053 (dev_capacity - 1), 0); 3054 3055 if (i != 0) { 3056 (void) printf("Error creating EFI partition!!!\n"); 3057 i = -1; 3058 } else { 3059 3060 /* EFI partitions are currently never active */ 3061 Table[i].bootid = 0; 3062 3063 /* set up the return code */ 3064 i = 1; 3065 } 3066 } 3067 3068 return (i); 3069 } 3070 3071 /* 3072 * specify 3073 * Query the user to specify the size of the new partition in 3074 * terms of percentage of the disk or by specifying the starting 3075 * cylinder and length in cylinders. 3076 */ 3077 static int 3078 specify(uchar_t tsystid) 3079 { 3080 int i, j, percent = -1; 3081 int cyl, cylen; 3082 diskaddr_t first_free, size_free; 3083 diskaddr_t max_free; 3084 int cyl_size; 3085 struct ipart *partition[FD_NUMPART]; 3086 struct ipart localpart[FD_NUMPART]; 3087 3088 cyl_size = heads * sectors; 3089 3090 /* 3091 * make a local copy of the partition table 3092 * and sort it into relsect order 3093 */ 3094 3095 3096 for (i = 0, j = 0; i < FD_NUMPART; i++) { 3097 if (Table[i].systid != UNUSED) { 3098 localpart[j] = Table[i]; 3099 j++; 3100 } 3101 } 3102 3103 while (j < FD_NUMPART) { 3104 (void) memset(&localpart[j], 0, sizeof (struct ipart)); 3105 j++; 3106 } 3107 3108 for (i = 0; i < FD_NUMPART; i++) 3109 partition[i] = &localpart[i]; 3110 3111 for (i = 0; i < FD_NUMPART - 1; i++) { 3112 if (partition[i]->systid == UNUSED) 3113 break; 3114 for (j = i + 1; j < FD_NUMPART; j++) { 3115 if (partition[j]->systid == UNUSED) 3116 break; 3117 if (LE_32(partition[j]->relsect) < 3118 LE_32(partition[i]->relsect)) { 3119 struct ipart *temp = partition[i]; 3120 partition[i] = partition[j]; 3121 partition[j] = temp; 3122 } 3123 } 3124 } 3125 3126 3127 (void) printf(Q_LINE); 3128 (void) printf( 3129 "Specify the percentage of disk to use for this partition\n" 3130 "(or type \"c\" to specify the size in cylinders). "); 3131 (void) fgets(s, sizeof (s), stdin); 3132 rm_blanks(s); 3133 if (s[0] != 'c') { /* Specify size in percentage of disk */ 3134 i = 0; 3135 while ((s[i] != '\0') && (s[i] != '\n')) { 3136 if (s[i] < '0' || s[i] > '9') { 3137 (void) printf(E_LINE); 3138 (void) printf("Invalid percentage value " 3139 "specified; retry the operation."); 3140 return (-1); 3141 } 3142 i++; 3143 if (i > 3) { 3144 (void) printf(E_LINE); 3145 (void) printf("Invalid percentage value " 3146 "specified; retry the operation."); 3147 return (-1); 3148 } 3149 } 3150 if ((percent = atoi(s)) > 100) { 3151 (void) printf(E_LINE); 3152 (void) printf( 3153 "Percentage value is too large. The value must be" 3154 " between 1 and 100;\nretry the operation.\n"); 3155 return (-1); 3156 } 3157 if (percent < 1) { 3158 (void) printf(E_LINE); 3159 (void) printf( 3160 "Percentage value is too small. The value must be" 3161 " between 1 and 100;\nretry the operation.\n"); 3162 return (-1); 3163 } 3164 3165 if (percent == 100) 3166 cylen = Numcyl_usable - 1; 3167 else 3168 cylen = (Numcyl_usable * percent) / 100; 3169 3170 /* Verify DOS12 partition doesn't exceed max size of 32MB. */ 3171 if ((tsystid == DOSOS12) && 3172 ((long)((long)cylen * cyl_size) > MAXDOS)) { 3173 int n; 3174 n = MAXDOS * 100 / (int)(cyl_size) / Numcyl_usable; 3175 (void) printf(E_LINE); 3176 (void) printf("Maximum size for a DOS partition " 3177 "is %d%%; retry the operation.", 3178 n <= 100 ? n : 100); 3179 return (-1); 3180 } 3181 3182 3183 max_free = 0; 3184 for (i = 0; i < FD_NUMPART; i++) { 3185 3186 /* 3187 * check for free space before partition i 3188 * where i varies from 0 to 3 3189 * 3190 * freespace after partition 3 is unusable 3191 * because there are no free partitions 3192 * 3193 * freespace begins at the end of previous partition 3194 * or cylinder 1 3195 */ 3196 if (i) { 3197 /* Not an empty table */ 3198 first_free = LE_32(partition[i - 1]->relsect) + 3199 LE_32(partition[i - 1]->numsect); 3200 } else { 3201 first_free = cyl_size; 3202 } 3203 3204 /* 3205 * freespace ends before the current partition 3206 * or the end of the disk (chs end) 3207 */ 3208 if (partition[i]->systid == UNUSED) { 3209 size_free = chs_capacity - first_free; 3210 } else { 3211 /* 3212 * Partition might start before cylinder 1. 3213 * Make sure free space is not negative. 3214 */ 3215 size_free = 3216 (LE_32(partition[i]->relsect > first_free)) 3217 ? (LE_32(partition[i]->relsect) - 3218 first_free) : 0; 3219 } 3220 3221 /* save largest free space */ 3222 if (max_free < size_free) 3223 max_free = size_free; 3224 3225 if (((uint64_t)cylen * cyl_size) <= size_free) { 3226 /* We found a place to use */ 3227 break; 3228 } 3229 if (partition[i]->systid == UNUSED) { 3230 (void) printf(E_LINE); 3231 max_free /= (cyl_size); 3232 (void) fprintf(stderr, "fdisk: " 3233 "Maximum percentage available is %lld\n", 3234 100 * max_free / Numcyl_usable); 3235 return (-1); 3236 } 3237 } 3238 3239 (void) printf(E_LINE); 3240 if (i >= FD_NUMPART) { 3241 (void) fprintf(stderr, 3242 "fdisk: Partition table is full.\n"); 3243 return (-1); 3244 } 3245 3246 if ((i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 3247 first_free, cylen * cyl_size, 0)) >= 0) { 3248 return (i); 3249 } 3250 return (-1); 3251 } else { 3252 3253 /* Specifying size in cylinders */ 3254 (void) printf(E_LINE); 3255 (void) printf(Q_LINE); 3256 (void) printf("Enter starting cylinder number: "); 3257 if ((cyl = getcyl()) == -1) { 3258 (void) printf(E_LINE); 3259 (void) printf("Invalid number; retry the operation."); 3260 return (-1); 3261 } 3262 if (cyl == 0) { 3263 (void) printf(E_LINE); 3264 (void) printf( 3265 "New partition cannot start at cylinder 0.\n"); 3266 return (-1); 3267 } 3268 3269 3270 if (cyl >= Numcyl_usable) { 3271 (void) printf(E_LINE); 3272 (void) printf( 3273 "Cylinder %d is out of bounds, " 3274 "the maximum is %d.\n", 3275 cyl, Numcyl_usable - 1); 3276 return (-1); 3277 } 3278 3279 (void) printf(Q_LINE); 3280 (void) printf("Enter partition size in cylinders: "); 3281 if ((cylen = getcyl()) == -1) { 3282 (void) printf(E_LINE); 3283 (void) printf("Invalid number, retry the operation."); 3284 return (-1); 3285 } 3286 3287 for (i = 0; i < FD_NUMPART; i++) { 3288 uint32_t t_relsect, t_numsect; 3289 3290 if (partition[i]->systid == UNUSED) 3291 break; 3292 t_relsect = LE_32(partition[i]->relsect); 3293 t_numsect = LE_32(partition[i]->numsect); 3294 3295 if (cyl * cyl_size >= t_relsect && 3296 cyl * cyl_size < t_relsect + t_numsect) { 3297 (void) printf(E_LINE); 3298 (void) printf( 3299 "Cylinder %d is already allocated" 3300 "\nretry the operation.", 3301 cyl); 3302 return (-1); 3303 } 3304 3305 if (cyl * cyl_size < t_relsect && 3306 (cyl + cylen - 1) * cyl_size > t_relsect) { 3307 (void) printf(E_LINE); 3308 (void) printf( 3309 "Maximum size for partition is %u cylinders" 3310 "\nretry the operation.", 3311 (t_relsect - cyl * cyl_size) / cyl_size); 3312 return (-1); 3313 } 3314 } 3315 3316 /* Verify partition doesn't exceed disk size or 2 TB */ 3317 if (cyl + cylen > Numcyl_usable) { 3318 (void) printf(E_LINE); 3319 if (Numcyl > Numcyl_usable) { 3320 (void) printf( 3321 "Maximum size for partition is %d " 3322 "cylinders; \nretry the operation.", 3323 Numcyl_usable - cyl); 3324 } else { 3325 (void) printf( 3326 "Maximum size for partition is %d " 3327 "cylinders; \nretry the operation.", 3328 Numcyl_usable - cyl); 3329 } 3330 return (-1); 3331 } 3332 3333 /* Verify DOS12 partition doesn't exceed max size of 32MB. */ 3334 if ((tsystid == DOSOS12) && 3335 ((long)((long)cylen * cyl_size) > MAXDOS)) { 3336 (void) printf(E_LINE); 3337 (void) printf( 3338 "Maximum size for a %s partition is %ld cylinders;" 3339 "\nretry the operation.", 3340 Dstr, MAXDOS / (int)(cyl_size)); 3341 return (-1); 3342 } 3343 3344 (void) printf(E_LINE); 3345 i = insert_tbl(tsystid, 0, 0, 0, 0, 0, 0, 0, 3346 cyl * cyl_size, cylen * cyl_size, 0); 3347 if (i < 0) 3348 return (-1); 3349 3350 if (verify_tbl() < 0) { 3351 (void) printf(E_LINE); 3352 (void) printf("fdisk: Cannot create partition table\n"); 3353 return (-1); 3354 } 3355 3356 return (i); 3357 } 3358 } 3359 3360 /* 3361 * dispmenu 3362 * Display command menu (interactive mode). 3363 */ 3364 static void 3365 dispmenu(void) 3366 { 3367 (void) printf(M_LINE); 3368 #ifdef i386 3369 (void) printf( 3370 "SELECT ONE OF THE FOLLOWING:\n" 3371 " 1. Create a partition\n" 3372 " 2. Specify the active partition\n" 3373 " 3. Delete a partition\n" 3374 " 4. Change between Solaris and Solaris2 Partition IDs\n" 3375 " 5. Edit/View extended partitions\n" 3376 " 6. Exit (update disk configuration and exit)\n" 3377 " 7. Cancel (exit without updating disk configuration)\n"); 3378 #else 3379 (void) printf( 3380 "SELECT ONE OF THE FOLLOWING:\n" 3381 " 1. Create a partition\n" 3382 " 2. Specify the active partition\n" 3383 " 3. Delete a partition\n" 3384 " 4. Change between Solaris and Solaris2 Partition IDs\n" 3385 " 5. Exit (update disk configuration and exit)\n" 3386 " 6. Cancel (exit without updating disk configuration)\n"); 3387 #endif 3388 } 3389 3390 /* 3391 * pchange 3392 * Change the ACTIVE designation of a partition. 3393 */ 3394 static int 3395 pchange(void) 3396 { 3397 char s[80]; 3398 int i, j; 3399 3400 for (;;) { 3401 (void) printf(Q_LINE); 3402 { 3403 (void) printf( 3404 "Specify the partition number to boot from" 3405 " (or specify 0 for none): "); 3406 } 3407 (void) fgets(s, sizeof (s), stdin); 3408 rm_blanks(s); 3409 if (((s[1] != '\0') && (s[1] != '\n')) || 3410 (s[0] < '0') || (s[0] > '4')) { 3411 (void) printf(E_LINE); 3412 (void) printf( 3413 "Invalid response, please specify a number" 3414 " between 0 and 4.\n"); 3415 } else { 3416 break; 3417 } 3418 } 3419 if (s[0] == '0') { /* No active partitions */ 3420 for (i = 0; i < FD_NUMPART; i++) { 3421 if (Table[i].systid != UNUSED && 3422 Table[i].bootid == ACTIVE) 3423 Table[i].bootid = 0; 3424 } 3425 (void) printf(E_LINE); 3426 (void) printf( 3427 "No partition is currently marked as active."); 3428 return (0); 3429 } else { /* User has selected a partition to be active */ 3430 3431 i = s[0] - '1'; 3432 3433 if (Table[i].systid == UNUSED) { 3434 (void) printf(E_LINE); 3435 (void) printf("Partition does not exist."); 3436 return (-1); 3437 } 3438 /* a DOS-DATA or EXT-DOS partition cannot be active */ 3439 else if ((Table[i].systid == DOSDATA) || 3440 (Table[i].systid == EXTDOS) || 3441 (Table[i].systid == FDISK_EXTLBA)) { 3442 (void) printf(E_LINE); 3443 (void) printf( 3444 "DOS-DATA, EXT_DOS and EXT_DOS_LBA partitions " 3445 "cannot be made active.\n"); 3446 (void) printf("Select another partition."); 3447 return (-1); 3448 } 3449 Table[i].bootid = ACTIVE; 3450 for (j = 0; j < FD_NUMPART; j++) { 3451 if (j != i) 3452 Table[j].bootid = 0; 3453 } 3454 } 3455 (void) printf(E_LINE); 3456 { 3457 (void) printf( 3458 "Partition %d is now active. The system will start up" 3459 " from this\n", i + 1); 3460 (void) printf("partition after the next reboot."); 3461 } 3462 return (1); 3463 } 3464 3465 /* 3466 * Change between SOLARIS and SOLARIS2 partition id 3467 */ 3468 static int 3469 ppartid(void) 3470 { 3471 char *p, s[80]; 3472 int i; 3473 3474 for (;;) { 3475 (void) printf(Q_LINE); 3476 (void) printf("Specify the partition number to change" 3477 " (or enter 0 to exit): "); 3478 if (!fgets(s, sizeof (s), stdin)) 3479 return (1); 3480 i = strtol(s, &p, 10); 3481 3482 if (*p != '\n' || i < 0 || i > FD_NUMPART) { 3483 (void) printf(E_LINE); 3484 (void) printf( 3485 "Invalid response, retry the operation.\n"); 3486 continue; 3487 } 3488 3489 if (i == 0) { 3490 /* exit delete command */ 3491 (void) printf(E_LINE); /* clear error message */ 3492 return (1); 3493 } 3494 3495 i -= 1; 3496 3497 if (Table[i].systid == SUNIXOS) { 3498 Table[i].systid = SUNIXOS2; 3499 } else if (Table[i].systid == SUNIXOS2) { 3500 Table[i].systid = SUNIXOS; 3501 } else { 3502 (void) printf(E_LINE); 3503 (void) printf( 3504 "Partition %d is not a Solaris partition.", 3505 i + 1); 3506 continue; 3507 } 3508 3509 (void) printf(E_LINE); 3510 (void) printf("Partition %d has been changed.", i + 1); 3511 return (1); 3512 } 3513 } 3514 3515 /* 3516 * pdelete 3517 * Remove partition entry from the table (interactive mode). 3518 */ 3519 static char 3520 pdelete(void) 3521 { 3522 char s[80]; 3523 int i; 3524 char pactive; 3525 3526 DEL1: (void) printf(Q_LINE); 3527 (void) printf("Specify the partition number to delete" 3528 " (or enter 0 to exit): "); 3529 (void) fgets(s, sizeof (s), stdin); 3530 rm_blanks(s); 3531 if ((s[0] == '0')) { /* exit delete command */ 3532 (void) printf(E_LINE); /* clear error message */ 3533 return (1); 3534 } 3535 /* Accept only a single digit between 1 and 4 */ 3536 if (((s[1] != '\0') && (s[1] != '\n')) || 3537 (i = atoi(s)) < 1 || i > FD_NUMPART) { 3538 (void) printf(E_LINE); 3539 (void) printf("Invalid response, retry the operation.\n"); 3540 goto DEL1; 3541 } else { /* Found a digit between 1 and 4 */ 3542 --i; /* Structure begins with element 0 */ 3543 } 3544 3545 if (Table[i].systid == UNUSED) { 3546 (void) printf(E_LINE); 3547 (void) printf("Partition %d does not exist.", i + 1); 3548 return (-1); 3549 } 3550 3551 #ifdef i386 3552 if (fdisk_is_dos_extended(Table[i].systid) && 3553 (Table[i].relsect == fdisk_get_ext_beg_sec(epp)) && 3554 fdisk_get_logical_drive_count(epp)) { 3555 (void) printf(Q_LINE); 3556 (void) printf("There are logical drives inside the" 3557 " extended partition\n"); 3558 (void) printf("Are you sure of proceeding with deletion ?" 3559 " (type \"y\" or \"n\") "); 3560 3561 (void) printf(E_LINE); 3562 if (! yesno()) { 3563 return (1); 3564 } 3565 if (fdisk_mounted_logical_drives(epp) == FDISK_EMOUNTED) { 3566 (void) printf(Q_LINE); 3567 (void) printf("There are mounted logical drives. " 3568 "Committing changes now can cause data loss or " 3569 "corruption. Unmount all logical drives and then " 3570 "try committing the changes again.\n"); 3571 (void) printf("Press enter to continue.\n"); 3572 ext_read_input(s); 3573 return (1); 3574 } 3575 (void) fdisk_delete_ext_part(epp); 3576 } else { 3577 #endif 3578 (void) printf(Q_LINE); 3579 (void) printf("Are you sure you want to delete partition %d?" 3580 " This will make all files and \n", i + 1); 3581 (void) printf("programs in this partition inaccessible (type" 3582 " \"y\" or \"n\"). "); 3583 3584 (void) printf(E_LINE); 3585 if (! yesno()) { 3586 return (1); 3587 } 3588 #ifdef i386 3589 } 3590 #endif 3591 3592 if (Table[i].bootid == ACTIVE) { 3593 pactive = 1; 3594 } else { 3595 pactive = 0; 3596 } 3597 3598 (void) memset(&Table[i], 0, sizeof (struct ipart)); 3599 3600 (void) printf(E_LINE); 3601 (void) printf("Partition %d has been deleted.", i + 1); 3602 3603 if (pactive) { 3604 (void) printf(" This was the active partition."); 3605 } 3606 3607 return (1); 3608 } 3609 3610 /* 3611 * rm_blanks 3612 * Remove blanks from strings of user responses. 3613 */ 3614 static void 3615 rm_blanks(char *s) 3616 { 3617 register int i, j; 3618 3619 for (i = 0; i < CBUFLEN; i++) { 3620 if ((s[i] == ' ') || (s[i] == '\t')) { 3621 continue; 3622 } else { 3623 /* Found first non-blank character of the string */ 3624 break; 3625 } 3626 } 3627 for (j = 0; i < CBUFLEN; j++, i++) { 3628 if ((s[j] = s[i]) == '\0') { 3629 /* Reached end of string */ 3630 return; 3631 } 3632 } 3633 } 3634 3635 /* 3636 * getcyl 3637 * Take the user-specified cylinder number and convert it from a 3638 * string to a decimal value. 3639 */ 3640 static int 3641 getcyl(void) 3642 { 3643 int slen, i, j; 3644 unsigned int cyl; 3645 (void) fgets(s, sizeof (s), stdin); 3646 rm_blanks(s); 3647 slen = strlen(s); 3648 if (s[slen - 1] == '\n') 3649 slen--; 3650 j = 1; 3651 cyl = 0; 3652 for (i = slen - 1; i >= 0; i--) { 3653 if (s[i] < '0' || s[i] > '9') { 3654 return (-1); 3655 } 3656 cyl += (j * (s[i] - '0')); 3657 j *= 10; 3658 } 3659 return (cyl); 3660 } 3661 3662 /* 3663 * disptbl 3664 * Display the current fdisk table; determine percentage 3665 * of the disk used for each partition. 3666 */ 3667 static void 3668 disptbl(void) 3669 { 3670 int i; 3671 unsigned int startcyl, endcyl, length, percent, remainder; 3672 char *stat, *type; 3673 int is_pmbr = 0; 3674 3675 if ((heads == 0) || (sectors == 0)) { 3676 (void) printf("WARNING: critical disk geometry information" 3677 " missing!\n"); 3678 (void) printf("\theads = %d, sectors = %d\n", heads, sectors); 3679 exit(1); 3680 } 3681 3682 (void) printf(HOME); 3683 (void) printf(T_LINE); 3684 (void) printf(" Total disk size is %d cylinders\n", Numcyl); 3685 (void) printf(" Cylinder size is %d (%d byte) blocks\n\n", 3686 heads * sectors, sectsiz); 3687 (void) printf( 3688 " Cylinders\n"); 3689 (void) printf( 3690 " Partition Status Type Start End Length" 3691 " %%\n"); 3692 (void) printf( 3693 " ========= ====== ============ ===== === ======" 3694 " ==="); 3695 3696 3697 for (i = 0; i < FD_NUMPART; i++) { 3698 3699 if (Table[i].systid == UNUSED) { 3700 continue; 3701 } 3702 3703 if (Table[i].bootid == ACTIVE) 3704 stat = Actvstr; 3705 else 3706 stat = NAstr; 3707 switch (Table[i].systid) { 3708 case UNIXOS: 3709 type = Ustr; 3710 break; 3711 case SUNIXOS: 3712 type = SUstr; 3713 #ifdef i386 3714 if (fdisk_is_linux_swap(epp, Table[i].relsect, 3715 NULL) == 0) 3716 type = LINSWAPstr; 3717 #endif 3718 break; 3719 case SUNIXOS2: 3720 type = SU2str; 3721 break; 3722 case X86BOOT: 3723 type = X86str; 3724 break; 3725 case DOSOS12: 3726 type = Dstr; 3727 break; 3728 case DOSOS16: 3729 type = D16str; 3730 break; 3731 case EXTDOS: 3732 type = EDstr; 3733 break; 3734 case DOSDATA: 3735 type = DDstr; 3736 break; 3737 case DOSHUGE: 3738 type = DBstr; 3739 break; 3740 case PCIXOS: 3741 type = PCstr; 3742 break; 3743 case DIAGPART: 3744 type = DIAGstr; 3745 break; 3746 case FDISK_IFS: 3747 type = IFSstr; 3748 break; 3749 case FDISK_AIXBOOT: 3750 type = AIXstr; 3751 break; 3752 case FDISK_AIXDATA: 3753 type = AIXDstr; 3754 break; 3755 case FDISK_OS2BOOT: 3756 type = OS2str; 3757 break; 3758 case FDISK_WINDOWS: 3759 type = WINstr; 3760 break; 3761 case FDISK_EXT_WIN: 3762 type = EWINstr; 3763 break; 3764 case FDISK_FAT95: 3765 type = FAT95str; 3766 break; 3767 case FDISK_EXTLBA: 3768 type = EXTLstr; 3769 break; 3770 case FDISK_LINUX: 3771 type = LINUXstr; 3772 break; 3773 case FDISK_CPM: 3774 type = CPMstr; 3775 break; 3776 case FDISK_NOVELL2: 3777 type = NOV2str; 3778 break; 3779 case FDISK_NOVELL3: 3780 type = NOVstr; 3781 break; 3782 case FDISK_QNX4: 3783 type = QNXstr; 3784 break; 3785 case FDISK_QNX42: 3786 type = QNX2str; 3787 break; 3788 case FDISK_QNX43: 3789 type = QNX3str; 3790 break; 3791 case FDISK_LINUXNAT: 3792 type = LINNATstr; 3793 break; 3794 case FDISK_NTFSVOL1: 3795 type = NTFSVOL1str; 3796 break; 3797 case FDISK_NTFSVOL2: 3798 type = NTFSVOL2str; 3799 break; 3800 case FDISK_BSD: 3801 type = BSDstr; 3802 break; 3803 case FDISK_NEXTSTEP: 3804 type = NEXTSTEPstr; 3805 break; 3806 case FDISK_BSDIFS: 3807 type = BSDIFSstr; 3808 break; 3809 case FDISK_BSDISWAP: 3810 type = BSDISWAPstr; 3811 break; 3812 case EFI_PMBR: 3813 type = EFIstr; 3814 if (LE_32(Table[i].numsect) == DK_MAX_2TB) 3815 is_pmbr = 1; 3816 3817 break; 3818 default: 3819 type = Ostr; 3820 break; 3821 } 3822 startcyl = LE_32(Table[i].relsect) / 3823 (unsigned long)(heads * sectors); 3824 3825 if (LE_32(Table[i].numsect) == DK_MAX_2TB) { 3826 endcyl = Numcyl - 1; 3827 length = endcyl - startcyl + 1; 3828 } else { 3829 length = LE_32(Table[i].numsect) / 3830 (unsigned long)(heads * sectors); 3831 if (LE_32(Table[i].numsect) % 3832 (unsigned long)(heads * sectors)) 3833 length++; 3834 endcyl = startcyl + length - 1; 3835 } 3836 3837 percent = length * 100 / Numcyl_usable; 3838 if ((remainder = (length * 100 % Numcyl_usable)) != 0) { 3839 if ((remainder * 100 / Numcyl_usable) > 50) { 3840 /* round up */ 3841 percent++; 3842 } 3843 /* Else leave the percent as is since it's already */ 3844 /* rounded down */ 3845 } 3846 if (percent > 100) 3847 percent = 100; 3848 (void) printf( 3849 "\n %d %s %-12.12s %4d %4d %4d" 3850 " %3d", 3851 i + 1, stat, type, startcyl, endcyl, length, percent); 3852 } 3853 3854 /* Print warning message if table is empty */ 3855 if (nopartdefined()) { 3856 (void) printf(W_LINE); 3857 (void) printf("WARNING: no partitions are defined!"); 3858 } else { 3859 /* Clear the warning line */ 3860 (void) printf(W_LINE); 3861 3862 /* Print warning if disk > 2TB and is not EFI PMBR */ 3863 if (!is_pmbr && (dev_capacity > DK_MAX_2TB)) 3864 (void) printf("WARNING: Disk is larger than 2 TB. " 3865 "Upper limit is 2 TB for non-EFI partition ID\n"); 3866 } 3867 } 3868 3869 /* 3870 * print_Table 3871 * Write the detailed fdisk table to standard error for 3872 * the selected disk device. 3873 */ 3874 static void 3875 print_Table(void) 3876 { 3877 int i; 3878 3879 (void) fprintf(stderr, 3880 " SYSID ACT BHEAD BSECT BEGCYL EHEAD ESECT ENDCYL RELSECT" 3881 " NUMSECT\n"); 3882 3883 for (i = 0; i < FD_NUMPART; i++) { 3884 (void) fprintf(stderr, " %-5d ", Table[i].systid); 3885 (void) fprintf(stderr, "%-3d ", Table[i].bootid); 3886 (void) fprintf(stderr, "%-5d ", Table[i].beghead); 3887 (void) fprintf(stderr, "%-5d ", Table[i].begsect & 0x3f); 3888 (void) fprintf(stderr, "%-8d ", 3889 (((uint_t)Table[i].begsect & 0xc0) << 2) + Table[i].begcyl); 3890 3891 (void) fprintf(stderr, "%-5d ", Table[i].endhead); 3892 (void) fprintf(stderr, "%-5d ", Table[i].endsect & 0x3f); 3893 (void) fprintf(stderr, "%-8d ", 3894 (((uint_t)Table[i].endsect & 0xc0) << 2) + Table[i].endcyl); 3895 (void) fprintf(stderr, "%-10u ", LE_32(Table[i].relsect)); 3896 (void) fprintf(stderr, "%-10u\n", LE_32(Table[i].numsect)); 3897 3898 } 3899 } 3900 3901 /* 3902 * copy_Table_to_Old_Table 3903 * Copy Table into Old_Table. The function only copies the systid, 3904 * numsect, relsect, and bootid values because they are the only 3905 * ones compared when determining if Table has changed. 3906 */ 3907 static void 3908 copy_Table_to_Old_Table(void) 3909 { 3910 int i; 3911 for (i = 0; i < FD_NUMPART; i++) { 3912 (void) memcpy(&Old_Table[i], &Table[i], sizeof (Table[0])); 3913 } 3914 } 3915 3916 /* 3917 * nulltbl 3918 * Zero out the systid, numsect, relsect, and bootid values in the 3919 * fdisk table. 3920 */ 3921 static void 3922 nulltbl(void) 3923 { 3924 int i; 3925 3926 for (i = 0; i < FD_NUMPART; i++) { 3927 Table[i].systid = UNUSED; 3928 Table[i].numsect = LE_32(UNUSED); 3929 Table[i].relsect = LE_32(UNUSED); 3930 Table[i].bootid = 0; 3931 skip_verify[i] = 0; 3932 } 3933 } 3934 3935 /* 3936 * copy_Bootblk_to_Table 3937 * Copy the bytes from the boot record to an internal "Table". 3938 * All unused are padded with zeros starting at offset 446. 3939 */ 3940 static void 3941 copy_Bootblk_to_Table(void) 3942 { 3943 int i; 3944 char *bootptr; 3945 struct ipart iparts[FD_NUMPART]; 3946 3947 /* Get an aligned copy of the partition tables */ 3948 (void) memcpy(iparts, Bootblk->parts, sizeof (iparts)); 3949 bootptr = (char *)iparts; /* Points to start of partition table */ 3950 if (LE_16(Bootblk->signature) != MBB_MAGIC) { 3951 /* Signature is missing */ 3952 nulltbl(); 3953 (void) memcpy(Bootblk->bootinst, &BootCod, BOOTSZ); 3954 return; 3955 } 3956 /* 3957 * When the DOS fdisk command deletes a partition, it is not 3958 * recognized by the old algorithm. The algorithm that 3959 * follows looks at each entry in the Bootrec and copies all 3960 * those that are valid. 3961 */ 3962 for (i = 0; i < FD_NUMPART; i++) { 3963 if (iparts[i].systid == 0) { 3964 /* Null entry */ 3965 (void) memset(&Table[i], 0, sizeof (struct ipart)); 3966 } else { 3967 fill_ipart(bootptr, &Table[i]); 3968 } 3969 bootptr += sizeof (struct ipart); 3970 } 3971 3972 /* For now, always replace the bootcode with ours */ 3973 (void) memcpy(Bootblk->bootinst, &BootCod, BOOTSZ); 3974 copy_Table_to_Bootblk(); 3975 } 3976 3977 /* 3978 * fill_ipart 3979 * Initialize ipart structure values. 3980 */ 3981 static void 3982 fill_ipart(char *bootptr, struct ipart *partp) 3983 { 3984 #ifdef sparc 3985 /* Packing struct ipart for Sparc */ 3986 partp->bootid = getbyte(&bootptr); 3987 partp->beghead = getbyte(&bootptr); 3988 partp->begsect = getbyte(&bootptr); 3989 partp->begcyl = getbyte(&bootptr); 3990 partp->systid = getbyte(&bootptr); 3991 partp->endhead = getbyte(&bootptr); 3992 partp->endsect = getbyte(&bootptr); 3993 partp->endcyl = getbyte(&bootptr); 3994 partp->relsect = (int32_t)getlong(&bootptr); 3995 partp->numsect = (int32_t)getlong(&bootptr); 3996 #else 3997 *partp = *(struct ipart *)bootptr; 3998 #endif 3999 } 4000 4001 /* 4002 * getbyte, getlong 4003 * Get a byte, a short, or a long (SPARC only). 4004 */ 4005 #ifdef sparc 4006 uchar_t 4007 getbyte(char **bp) 4008 { 4009 uchar_t b; 4010 4011 b = (uchar_t)**bp; 4012 *bp = *bp + 1; 4013 return (b); 4014 } 4015 4016 uint32_t 4017 getlong(char **bp) 4018 { 4019 int32_t b, bh, bl; 4020 4021 bh = ((**bp) << 8) | *(*bp + 1); 4022 *bp += 2; 4023 bl = ((**bp) << 8) | *(*bp + 1); 4024 *bp += 2; 4025 4026 b = (bh << 16) | bl; 4027 return ((uint32_t)b); 4028 } 4029 #endif 4030 4031 /* 4032 * copy_Table_to_Bootblk 4033 * Copy the table into the boot record. Note that the unused 4034 * entries will always be the last ones in the table and they are 4035 * marked with 100 in sysind. The the unused portion of the table 4036 * is padded with zeros in the bytes after the used entries. 4037 */ 4038 static void 4039 copy_Table_to_Bootblk(void) 4040 { 4041 struct ipart *boot_ptr, *tbl_ptr; 4042 4043 boot_ptr = (struct ipart *)Bootblk->parts; 4044 tbl_ptr = (struct ipart *)&Table[0].bootid; 4045 for (; tbl_ptr < (struct ipart *)&Table[FD_NUMPART].bootid; 4046 tbl_ptr++, boot_ptr++) { 4047 if (tbl_ptr->systid == UNUSED) 4048 (void) memset(boot_ptr, 0, sizeof (struct ipart)); 4049 else 4050 (void) memcpy(boot_ptr, tbl_ptr, sizeof (struct ipart)); 4051 } 4052 Bootblk->signature = LE_16(MBB_MAGIC); 4053 } 4054 4055 /* 4056 * TableChanged 4057 * Check for any changes in the partition table. 4058 */ 4059 static int 4060 TableChanged(void) 4061 { 4062 int i, changed; 4063 4064 changed = 0; 4065 for (i = 0; i < FD_NUMPART; i++) { 4066 if (memcmp(&Old_Table[i], &Table[i], sizeof (Table[0])) != 0) { 4067 /* Partition table changed, write back to disk */ 4068 changed = 1; 4069 } 4070 } 4071 4072 return (changed); 4073 } 4074 4075 /* 4076 * ffile_write 4077 * Display contents of partition table to standard output or 4078 * another file name without writing it to the disk (-W file). 4079 */ 4080 static void 4081 ffile_write(char *file) 4082 { 4083 register int i; 4084 FILE *fp; 4085 4086 /* 4087 * If file isn't standard output, then it's a file name. 4088 * Open file and write it. 4089 */ 4090 if (file != (char *)stdout) { 4091 if ((fp = fopen(file, "w")) == NULL) { 4092 (void) fprintf(stderr, 4093 "fdisk: Cannot open output file %s.\n", 4094 file); 4095 exit(1); 4096 } 4097 } 4098 else 4099 fp = stdout; 4100 4101 /* 4102 * Write the fdisk table information 4103 */ 4104 (void) fprintf(fp, "\n* %s default fdisk table\n", Dfltdev); 4105 (void) fprintf(fp, "* Dimensions:\n"); 4106 (void) fprintf(fp, "* %4d bytes/sector\n", sectsiz); 4107 (void) fprintf(fp, "* %4d sectors/track\n", sectors); 4108 (void) fprintf(fp, "* %4d tracks/cylinder\n", heads); 4109 (void) fprintf(fp, "* %4d cylinders\n", Numcyl); 4110 (void) fprintf(fp, "*\n"); 4111 /* Write virtual (HBA) geometry, if required */ 4112 if (v_flag) { 4113 (void) fprintf(fp, "* HBA Dimensions:\n"); 4114 (void) fprintf(fp, "* %4d bytes/sector\n", sectsiz); 4115 (void) fprintf(fp, "* %4d sectors/track\n", hba_sectors); 4116 (void) fprintf(fp, "* %4d tracks/cylinder\n", hba_heads); 4117 (void) fprintf(fp, "* %4d cylinders\n", hba_Numcyl); 4118 (void) fprintf(fp, "*\n"); 4119 } 4120 (void) fprintf(fp, "* systid:\n"); 4121 (void) fprintf(fp, "* 1: DOSOS12\n"); 4122 (void) fprintf(fp, "* 2: PCIXOS\n"); 4123 (void) fprintf(fp, "* 4: DOSOS16\n"); 4124 (void) fprintf(fp, "* 5: EXTDOS\n"); 4125 (void) fprintf(fp, "* 6: DOSBIG\n"); 4126 (void) fprintf(fp, "* 7: FDISK_IFS\n"); 4127 (void) fprintf(fp, "* 8: FDISK_AIXBOOT\n"); 4128 (void) fprintf(fp, "* 9: FDISK_AIXDATA\n"); 4129 (void) fprintf(fp, "* 10: FDISK_0S2BOOT\n"); 4130 (void) fprintf(fp, "* 11: FDISK_WINDOWS\n"); 4131 (void) fprintf(fp, "* 12: FDISK_EXT_WIN\n"); 4132 (void) fprintf(fp, "* 14: FDISK_FAT95\n"); 4133 (void) fprintf(fp, "* 15: FDISK_EXTLBA\n"); 4134 (void) fprintf(fp, "* 18: DIAGPART\n"); 4135 (void) fprintf(fp, "* 65: FDISK_LINUX\n"); 4136 (void) fprintf(fp, "* 82: FDISK_CPM\n"); 4137 (void) fprintf(fp, "* 86: DOSDATA\n"); 4138 (void) fprintf(fp, "* 98: OTHEROS\n"); 4139 (void) fprintf(fp, "* 99: UNIXOS\n"); 4140 (void) fprintf(fp, "* 100: FDISK_NOVELL2\n"); 4141 (void) fprintf(fp, "* 101: FDISK_NOVELL3\n"); 4142 (void) fprintf(fp, "* 119: FDISK_QNX4\n"); 4143 (void) fprintf(fp, "* 120: FDISK_QNX42\n"); 4144 (void) fprintf(fp, "* 121: FDISK_QNX43\n"); 4145 (void) fprintf(fp, "* 130: SUNIXOS\n"); 4146 (void) fprintf(fp, "* 131: FDISK_LINUXNAT\n"); 4147 (void) fprintf(fp, "* 134: FDISK_NTFSVOL1\n"); 4148 (void) fprintf(fp, "* 135: FDISK_NTFSVOL2\n"); 4149 (void) fprintf(fp, "* 165: FDISK_BSD\n"); 4150 (void) fprintf(fp, "* 167: FDISK_NEXTSTEP\n"); 4151 (void) fprintf(fp, "* 183: FDISK_BSDIFS\n"); 4152 (void) fprintf(fp, "* 184: FDISK_BSDISWAP\n"); 4153 (void) fprintf(fp, "* 190: X86BOOT\n"); 4154 (void) fprintf(fp, "* 191: SUNIXOS2\n"); 4155 (void) fprintf(fp, "* 238: EFI_PMBR\n"); 4156 (void) fprintf(fp, "* 239: EFI_FS\n"); 4157 (void) fprintf(fp, "*\n"); 4158 (void) fprintf(fp, 4159 "\n* Id Act Bhead Bsect Bcyl Ehead Esect Ecyl" 4160 " Rsect Numsect\n"); 4161 4162 for (i = 0; i < FD_NUMPART; i++) { 4163 (void) fprintf(fp, 4164 " %-5d %-4d %-6d %-6d %-7d %-6d %-6d %-7d %-10u" 4165 " %-10u\n", 4166 Table[i].systid, 4167 Table[i].bootid, 4168 Table[i].beghead, 4169 Table[i].begsect & 0x3f, 4170 ((Table[i].begcyl & 0xff) | ((Table[i].begsect & 4171 0xc0) << 2)), 4172 Table[i].endhead, 4173 Table[i].endsect & 0x3f, 4174 ((Table[i].endcyl & 0xff) | ((Table[i].endsect & 4175 0xc0) << 2)), 4176 LE_32(Table[i].relsect), 4177 LE_32(Table[i].numsect)); 4178 } 4179 #ifdef i386 4180 if (fdisk_ext_part_exists(epp)) { 4181 struct ipart ext_tab; 4182 logical_drive_t *temp; 4183 uint32_t rsect, numsect, tempsect = 0; 4184 for (temp = fdisk_get_ld_head(epp); temp != NULL; 4185 temp = temp->next) { 4186 ext_tab = temp->parts[0]; 4187 rsect = tempsect + LE_32(ext_tab.relsect) + 4188 fdisk_get_ext_beg_sec(epp); 4189 numsect = LE_32(ext_tab.numsect); 4190 tempsect = LE_32(temp->parts[1].relsect); 4191 (void) fprintf(fp, 4192 " %-5d %-4d %-6d %-6d %-7d %-6d %-6d " 4193 "%-7d %-8u %-8u\n", 4194 ext_tab.systid, 4195 ext_tab.bootid, 4196 ext_tab.beghead, 4197 ext_tab.begsect & 0x3f, 4198 ((ext_tab.begcyl & 0xff) | 4199 ((ext_tab.begsect & 0xc0) << 2)), 4200 ext_tab.endhead, 4201 ext_tab.endsect & 0x3f, 4202 ((ext_tab.endcyl & 0xff) | 4203 ((ext_tab.endsect & 0xc0) << 2)), 4204 rsect, 4205 numsect); 4206 } 4207 } 4208 #endif 4209 4210 if (fp != stdout) 4211 (void) fclose(fp); 4212 } 4213 4214 /* 4215 * fix_slice 4216 * Read the VTOC table on the Solaris partition and check that no 4217 * slices exist that extend past the end of the Solaris partition. 4218 * If no Solaris partition exists, nothing is done. 4219 */ 4220 static void 4221 fix_slice(void) 4222 { 4223 int i; 4224 uint32_t numsect; 4225 4226 if (io_image) { 4227 return; 4228 } 4229 4230 for (i = 0; i < FD_NUMPART; i++) { 4231 if (Table[i].systid == SUNIXOS || Table[i].systid == SUNIXOS2) { 4232 /* 4233 * Only the size matters (not starting point), since 4234 * VTOC entries are relative to the start of 4235 * the partition. 4236 */ 4237 numsect = LE_32(Table[i].numsect); 4238 break; 4239 } 4240 } 4241 4242 if (i >= FD_NUMPART) { 4243 if (!io_nifdisk) { 4244 (void) fprintf(stderr, 4245 "fdisk: No Solaris partition found - VTOC not" 4246 " checked.\n"); 4247 } 4248 return; 4249 } 4250 4251 if (readvtoc() != VTOC_OK) { 4252 exit(1); /* Failed to read the VTOC */ 4253 } 4254 for (i = 0; i < V_NUMPAR; i++) { 4255 /* Special case for slice two (entire disk) */ 4256 if (i == 2) { 4257 if (disk_vtoc.v_part[i].p_start != 0) { 4258 (void) fprintf(stderr, 4259 "slice %d starts at %llu, is not at" 4260 " start of partition", 4261 i, disk_vtoc.v_part[i].p_start); 4262 if (!io_nifdisk) { 4263 (void) printf(" adjust ?:"); 4264 if (yesno()) 4265 disk_vtoc.v_part[i].p_start = 0; 4266 } else { 4267 disk_vtoc.v_part[i].p_start = 0; 4268 (void) fprintf(stderr, " adjusted!\n"); 4269 } 4270 4271 } 4272 if (disk_vtoc.v_part[i].p_size != numsect) { 4273 (void) fprintf(stderr, 4274 "slice %d size %llu does not cover" 4275 " complete partition", 4276 i, disk_vtoc.v_part[i].p_size); 4277 if (!io_nifdisk) { 4278 (void) printf(" adjust ?:"); 4279 if (yesno()) 4280 disk_vtoc.v_part[i].p_size = 4281 numsect; 4282 } else { 4283 disk_vtoc.v_part[i].p_size = numsect; 4284 (void) fprintf(stderr, " adjusted!\n"); 4285 } 4286 } 4287 if (disk_vtoc.v_part[i].p_tag != V_BACKUP) { 4288 (void) fprintf(stderr, 4289 "slice %d tag was %d should be %d", 4290 i, disk_vtoc.v_part[i].p_tag, 4291 V_BACKUP); 4292 if (!io_nifdisk) { 4293 (void) printf(" fix ?:"); 4294 if (yesno()) 4295 disk_vtoc.v_part[i].p_tag = 4296 V_BACKUP; 4297 } else { 4298 disk_vtoc.v_part[i].p_tag = V_BACKUP; 4299 (void) fprintf(stderr, " fixed!\n"); 4300 } 4301 } 4302 continue; 4303 } 4304 if (io_ADJT) { 4305 if (disk_vtoc.v_part[i].p_start > numsect || 4306 disk_vtoc.v_part[i].p_start + 4307 disk_vtoc.v_part[i].p_size > numsect) { 4308 (void) fprintf(stderr, 4309 "slice %d (start %llu, end %llu)" 4310 " is larger than the partition", 4311 i, disk_vtoc.v_part[i].p_start, 4312 disk_vtoc.v_part[i].p_start + 4313 disk_vtoc.v_part[i].p_size); 4314 if (!io_nifdisk) { 4315 (void) printf(" remove ?:"); 4316 if (yesno()) { 4317 disk_vtoc.v_part[i].p_size = 0; 4318 disk_vtoc.v_part[i].p_start = 0; 4319 disk_vtoc.v_part[i].p_tag = 0; 4320 disk_vtoc.v_part[i].p_flag = 0; 4321 } 4322 } else { 4323 disk_vtoc.v_part[i].p_size = 0; 4324 disk_vtoc.v_part[i].p_start = 0; 4325 disk_vtoc.v_part[i].p_tag = 0; 4326 disk_vtoc.v_part[i].p_flag = 0; 4327 (void) fprintf(stderr, 4328 " removed!\n"); 4329 } 4330 } 4331 continue; 4332 } 4333 if (disk_vtoc.v_part[i].p_start > numsect) { 4334 (void) fprintf(stderr, 4335 "slice %d (start %llu) is larger than the " 4336 "partition", i, disk_vtoc.v_part[i].p_start); 4337 if (!io_nifdisk) { 4338 (void) printf(" remove ?:"); 4339 if (yesno()) { 4340 disk_vtoc.v_part[i].p_size = 0; 4341 disk_vtoc.v_part[i].p_start = 0; 4342 disk_vtoc.v_part[i].p_tag = 0; 4343 disk_vtoc.v_part[i].p_flag = 0; 4344 } 4345 } else { 4346 disk_vtoc.v_part[i].p_size = 0; 4347 disk_vtoc.v_part[i].p_start = 0; 4348 disk_vtoc.v_part[i].p_tag = 0; 4349 disk_vtoc.v_part[i].p_flag = 0; 4350 (void) fprintf(stderr, 4351 " removed!\n"); 4352 } 4353 } else if (disk_vtoc.v_part[i].p_start 4354 + disk_vtoc.v_part[i].p_size > numsect) { 4355 (void) fprintf(stderr, 4356 "slice %d (end %llu) is larger" 4357 " than the partition", 4358 i, 4359 disk_vtoc.v_part[i].p_start + 4360 disk_vtoc.v_part[i].p_size); 4361 if (!io_nifdisk) { 4362 (void) printf(" adjust ?:"); 4363 if (yesno()) { 4364 disk_vtoc.v_part[i].p_size = numsect; 4365 } 4366 } else { 4367 disk_vtoc.v_part[i].p_size = numsect; 4368 (void) fprintf(stderr, " adjusted!\n"); 4369 } 4370 } 4371 } 4372 #if 1 /* bh for now */ 4373 /* Make the VTOC look sane - ha ha */ 4374 disk_vtoc.v_version = V_VERSION; 4375 disk_vtoc.v_sanity = VTOC_SANE; 4376 disk_vtoc.v_nparts = V_NUMPAR; 4377 if (disk_vtoc.v_sectorsz == 0) 4378 disk_vtoc.v_sectorsz = NBPSCTR; 4379 #endif 4380 4381 /* Write the VTOC back to the disk */ 4382 if (!io_readonly) 4383 (void) writevtoc(); 4384 } 4385 4386 /* 4387 * yesno 4388 * Get yes or no answer. Return 1 for yes and 0 for no. 4389 */ 4390 4391 static int 4392 yesno(void) 4393 { 4394 char s[80]; 4395 4396 for (;;) { 4397 (void) fgets(s, sizeof (s), stdin); 4398 rm_blanks(s); 4399 if (((s[1] != '\0') && (s[1] != '\n')) || 4400 ((s[0] != 'y') && (s[0] != 'n'))) { 4401 (void) printf(E_LINE); 4402 (void) printf("Please answer with \"y\" or \"n\": "); 4403 continue; 4404 } 4405 if (s[0] == 'y') 4406 return (1); 4407 else 4408 return (0); 4409 } 4410 } 4411 4412 /* 4413 * readvtoc 4414 * Read the VTOC from the Solaris partition of the device. 4415 */ 4416 static int 4417 readvtoc(void) 4418 { 4419 int i; 4420 int retval = VTOC_OK; 4421 4422 if ((i = read_extvtoc(Dev, &disk_vtoc)) < VTOC_OK) { 4423 if (i == VT_EINVAL) { 4424 (void) fprintf(stderr, "fdisk: Invalid VTOC.\n"); 4425 vt_inval++; 4426 retval = VTOC_INVAL; 4427 } else if (i == VT_ENOTSUP) { 4428 (void) fprintf(stderr, "fdisk: partition may have EFI " 4429 "GPT\n"); 4430 retval = VTOC_NOTSUP; 4431 } else { 4432 (void) fprintf(stderr, "fdisk: Cannot read VTOC.\n"); 4433 retval = VTOC_RWERR; 4434 } 4435 } 4436 return (retval); 4437 } 4438 4439 /* 4440 * writevtoc 4441 * Write the VTOC to the Solaris partition on the device. 4442 */ 4443 static int 4444 writevtoc(void) 4445 { 4446 int i; 4447 int retval = 0; 4448 4449 if ((i = write_extvtoc(Dev, &disk_vtoc)) != 0) { 4450 if (i == VT_EINVAL) { 4451 (void) fprintf(stderr, 4452 "fdisk: Invalid entry exists in VTOC.\n"); 4453 retval = VTOC_INVAL; 4454 } else if (i == VT_ENOTSUP) { 4455 (void) fprintf(stderr, "fdisk: partition may have EFI " 4456 "GPT\n"); 4457 retval = VTOC_NOTSUP; 4458 } else { 4459 (void) fprintf(stderr, "fdisk: Cannot write VTOC.\n"); 4460 retval = VTOC_RWERR; 4461 } 4462 } 4463 return (retval); 4464 } 4465 4466 /* 4467 * efi_ioctl 4468 * issues DKIOCSETEFI IOCTL 4469 * (duplicate of private efi_ioctl() in rdwr_efi.c 4470 */ 4471 static int 4472 efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc) 4473 { 4474 void *data = dk_ioc->dki_data; 4475 int error; 4476 4477 dk_ioc->dki_data_64 = (uintptr_t)data; 4478 error = ioctl(fd, cmd, (void *)dk_ioc); 4479 4480 return (error); 4481 } 4482 4483 /* 4484 * clear_efi 4485 * Clear EFI labels from the EFI_PMBR partition on the device 4486 * This function is modeled on the libefi(3LIB) call efi_write() 4487 */ 4488 static int 4489 clear_efi(void) 4490 { 4491 struct dk_gpt *efi_vtoc; 4492 dk_efi_t dk_ioc; 4493 4494 /* 4495 * see if we can read the EFI label 4496 */ 4497 if (efi_alloc_and_read(Dev, &efi_vtoc) < 0) { 4498 return (VT_ERROR); 4499 } 4500 4501 /* 4502 * set up the dk_ioc structure for writing 4503 */ 4504 dk_ioc.dki_lba = 1; 4505 dk_ioc.dki_length = EFI_MIN_ARRAY_SIZE + efi_vtoc->efi_lbasize; 4506 4507 if ((dk_ioc.dki_data = calloc(dk_ioc.dki_length, 1)) == NULL) { 4508 return (VT_ERROR); 4509 } 4510 4511 /* 4512 * clear the primary label 4513 */ 4514 if (io_debug) { 4515 (void) fprintf(stderr, 4516 "\tClearing primary EFI label at block %lld\n", 4517 dk_ioc.dki_lba); 4518 } 4519 4520 if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 4521 free(dk_ioc.dki_data); 4522 switch (errno) { 4523 case EIO: 4524 return (VT_EIO); 4525 case EINVAL: 4526 return (VT_EINVAL); 4527 default: 4528 return (VT_ERROR); 4529 } 4530 } 4531 4532 /* 4533 * clear the backup partition table 4534 */ 4535 dk_ioc.dki_lba = efi_vtoc->efi_last_u_lba + 1; 4536 dk_ioc.dki_length -= efi_vtoc->efi_lbasize; 4537 dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data + 4538 efi_vtoc->efi_lbasize); 4539 if (io_debug) { 4540 (void) fprintf(stderr, 4541 "\tClearing backup partition table at block %lld\n", 4542 dk_ioc.dki_lba); 4543 } 4544 4545 if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 4546 (void) fprintf(stderr, "\tUnable to clear backup EFI label at " 4547 "block %llu; errno %d\n", efi_vtoc->efi_last_u_lba + 1, 4548 errno); 4549 } 4550 4551 /* 4552 * clear the backup label 4553 */ 4554 dk_ioc.dki_lba = efi_vtoc->efi_last_lba; 4555 dk_ioc.dki_length = efi_vtoc->efi_lbasize; 4556 dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data - 4557 efi_vtoc->efi_lbasize); 4558 if (io_debug) { 4559 (void) fprintf(stderr, "\tClearing backup label at block " 4560 "%lld\n", dk_ioc.dki_lba); 4561 } 4562 4563 if (efi_ioctl(Dev, DKIOCSETEFI, &dk_ioc) == -1) { 4564 (void) fprintf(stderr, 4565 "\tUnable to clear backup EFI label at " 4566 "block %llu; errno %d\n", 4567 efi_vtoc->efi_last_lba, 4568 errno); 4569 } 4570 4571 free(dk_ioc.dki_data); 4572 efi_free(efi_vtoc); 4573 4574 return (0); 4575 } 4576 4577 /* 4578 * clear_vtoc 4579 * Clear the VTOC from the current or previous Solaris partition on the 4580 * device. 4581 */ 4582 static void 4583 clear_vtoc(int table, int part) 4584 { 4585 struct ipart *clr_table; 4586 char *disk_label; 4587 uint32_t pcyl, ncyl, count; 4588 diskaddr_t backup_block, solaris_offset; 4589 ssize_t bytes; 4590 off_t seek_byte; 4591 4592 #ifdef DEBUG 4593 char *read_label; 4594 #endif /* DEBUG */ 4595 4596 if (table == OLD) { 4597 clr_table = &Old_Table[part]; 4598 } else { 4599 clr_table = &Table[part]; 4600 } 4601 4602 disk_label = (char *)calloc(sectsiz, 1); 4603 if (disk_label == NULL) { 4604 return; 4605 } 4606 4607 seek_byte = (off_t)(LE_32(clr_table->relsect) + VTOC_OFFSET) * sectsiz; 4608 4609 if (io_debug) { 4610 (void) fprintf(stderr, 4611 "\tClearing primary VTOC at byte %llu (block %llu)\n", 4612 (uint64_t)seek_byte, 4613 (uint64_t)(LE_32(clr_table->relsect) + VTOC_OFFSET)); 4614 } 4615 4616 if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 4617 (void) fprintf(stderr, 4618 "\tError seeking to primary label at byte %llu\n", 4619 (uint64_t)seek_byte); 4620 free(disk_label); 4621 return; 4622 } 4623 4624 bytes = write(Dev, disk_label, sectsiz); 4625 4626 if (bytes != sectsiz) { 4627 (void) fprintf(stderr, 4628 "\tWarning: only %d bytes written to clear primary" 4629 " VTOC!\n", bytes); 4630 } 4631 4632 #ifdef DEBUG 4633 if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 4634 (void) fprintf(stderr, 4635 "DEBUG: Error seeking to primary label at byte %llu\n", 4636 (uint64_t)seek_byte); 4637 free(disk_label); 4638 return; 4639 } else { 4640 (void) fprintf(stderr, 4641 "DEBUG: Successful lseek() to byte %llu\n", 4642 (uint64_t)seek_byte); 4643 } 4644 4645 read_label = (char *)calloc(sectsiz, 1); 4646 if (read_label == NULL) { 4647 free(disk_label); 4648 return; 4649 } 4650 4651 bytes = read(Dev, read_label, sectsiz); 4652 4653 if (bytes != sectsiz) { 4654 (void) fprintf(stderr, 4655 "DEBUG: Warning: only %d bytes read of label\n", 4656 bytes); 4657 } 4658 4659 if (memcmp(disk_label, read_label, sectsiz) != 0) { 4660 (void) fprintf(stderr, 4661 "DEBUG: Warning: disk_label and read_label differ!!!\n"); 4662 } else { 4663 (void) fprintf(stderr, "DEBUG Good compare of disk_label and " 4664 "read_label\n"); 4665 } 4666 #endif /* DEBUG */ 4667 4668 /* Clear backup label */ 4669 pcyl = LE_32(clr_table->numsect) / (heads * sectors); 4670 solaris_offset = LE_32(clr_table->relsect); 4671 ncyl = pcyl - acyl; 4672 4673 backup_block = ((ncyl + acyl - 1) * 4674 (heads * sectors)) + ((heads - 1) * sectors) + 1; 4675 4676 for (count = 1; count < 6; count++) { 4677 seek_byte = (off_t)(solaris_offset + backup_block) * sectsiz; 4678 4679 if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 4680 (void) fprintf(stderr, 4681 "\tError seeking to backup label at byte %llu on " 4682 "%s.\n", (uint64_t)seek_byte, Dfltdev); 4683 free(disk_label); 4684 #ifdef DEBUG 4685 free(read_label); 4686 #endif /* DEBUG */ 4687 return; 4688 } 4689 4690 if (io_debug) { 4691 (void) fprintf(stderr, "\tClearing backup VTOC at" 4692 " byte %llu (block %llu)\n", 4693 (uint64_t)seek_byte, 4694 (uint64_t)(solaris_offset + backup_block)); 4695 } 4696 4697 bytes = write(Dev, disk_label, sectsiz); 4698 4699 if (bytes != sectsiz) { 4700 (void) fprintf(stderr, 4701 "\t\tWarning: only %d bytes written to " 4702 "clear backup VTOC at block %llu!\n", bytes, 4703 (uint64_t)(solaris_offset + backup_block)); 4704 } 4705 4706 #ifdef DEBUG 4707 if (lseek(Dev, seek_byte, SEEK_SET) == -1) { 4708 (void) fprintf(stderr, 4709 "DEBUG: Error seeking to backup label at byte %llu\n", 4710 (uint64_t)seek_byte); 4711 free(disk_label); 4712 free(read_label); 4713 return; 4714 } else { 4715 (void) fprintf(stderr, 4716 "DEBUG: Successful lseek() to byte %llu\n", 4717 (uint64_t)seek_byte); 4718 } 4719 4720 bytes = read(Dev, read_label, sectsiz); 4721 4722 if (bytes != sectsiz) { 4723 (void) fprintf(stderr, 4724 "DEBUG: Warning: only %d bytes read of backup label\n", 4725 bytes); 4726 } 4727 4728 if (memcmp(disk_label, read_label, sectsiz) != 0) { 4729 (void) fprintf(stderr, 4730 "DEBUG: Warning: disk_label and read_label differ!!!\n"); 4731 } else { 4732 (void) fprintf(stderr, 4733 "DEBUG: Good compare of disk_label and backup " 4734 "read_label\n"); 4735 } 4736 4737 #endif /* DEBUG */ 4738 4739 backup_block += 2; 4740 } 4741 4742 #ifdef DEBUG 4743 free(read_label); 4744 #endif /* DEBUG */ 4745 free(disk_label); 4746 } 4747 4748 #define FDISK_STANDARD_LECTURE \ 4749 "Fdisk is normally used with the device that " \ 4750 "represents the entire fixed disk.\n" \ 4751 "(For example, /dev/rdsk/c0d0p0 on x86 or " \ 4752 "/dev/rdsk/c0t5d0s2 on sparc).\n" 4753 4754 #define FDISK_LECTURE_NOT_SECTOR_ZERO \ 4755 "The device does not appear to include absolute\n" \ 4756 "sector 0 of the PHYSICAL disk " \ 4757 "(the normal location for an fdisk table).\n" 4758 4759 #define FDISK_LECTURE_NOT_FULL \ 4760 "The device does not appear to encompass the entire PHYSICAL disk.\n" 4761 4762 #define FDISK_LECTURE_NO_VTOC \ 4763 "Unable to find a volume table of contents.\n" \ 4764 "Cannot verify the device encompasses the full PHYSICAL disk.\n" 4765 4766 #define FDISK_LECTURE_NO_GEOM \ 4767 "Unable to get geometry from device.\n" \ 4768 "Cannot verify the device encompasses the full PHYSICAL disk.\n" 4769 4770 #define FDISK_SHALL_I_CONTINUE \ 4771 "Are you sure you want to continue? (y/n) " 4772 4773 /* 4774 * lecture_and_query 4775 * Called when a sanity check fails. This routine gives a warning 4776 * specific to the check that fails, followed by a generic lecture 4777 * about the "right" device to supply as input. Then, if appropriate, 4778 * it will prompt the user on whether or not they want to continue. 4779 * Inappropriate times for prompting are when the user has selected 4780 * non-interactive mode or read-only mode. 4781 */ 4782 static int 4783 lecture_and_query(char *warning, char *devname) 4784 { 4785 if (io_nifdisk) 4786 return (0); 4787 4788 (void) fprintf(stderr, "WARNING: Device %s: \n", devname); 4789 (void) fprintf(stderr, "%s", warning); 4790 (void) fprintf(stderr, FDISK_STANDARD_LECTURE); 4791 (void) fprintf(stderr, FDISK_SHALL_I_CONTINUE); 4792 4793 return (yesno()); 4794 } 4795 4796 static void 4797 sanity_check_provided_device(char *devname, int fd) 4798 { 4799 struct extvtoc v; 4800 struct dk_geom d; 4801 struct part_info pi; 4802 struct extpart_info extpi; 4803 diskaddr_t totsize; 4804 int idx = -1; 4805 4806 /* 4807 * First try the PARTINFO ioctl. If it works, we will be able 4808 * to tell if they've specified the full disk partition by checking 4809 * to see if they've specified a partition that starts at sector 0. 4810 */ 4811 if (ioctl(fd, DKIOCEXTPARTINFO, &extpi) != -1) { 4812 if (extpi.p_start != 0) { 4813 if (!lecture_and_query(FDISK_LECTURE_NOT_SECTOR_ZERO, 4814 devname)) { 4815 (void) close(fd); 4816 exit(1); 4817 } 4818 } 4819 } else if (ioctl(fd, DKIOCPARTINFO, &pi) != -1) { 4820 if (pi.p_start != 0) { 4821 if (!lecture_and_query(FDISK_LECTURE_NOT_SECTOR_ZERO, 4822 devname)) { 4823 (void) close(fd); 4824 exit(1); 4825 } 4826 } 4827 } else { 4828 if ((idx = read_extvtoc(fd, &v)) < 0) { 4829 if (!lecture_and_query(FDISK_LECTURE_NO_VTOC, 4830 devname)) { 4831 (void) close(fd); 4832 exit(1); 4833 } 4834 return; 4835 } 4836 if (ioctl(fd, DKIOCGGEOM, &d) == -1) { 4837 perror(devname); 4838 if (!lecture_and_query(FDISK_LECTURE_NO_GEOM, 4839 devname)) { 4840 (void) close(fd); 4841 exit(1); 4842 } 4843 return; 4844 } 4845 totsize = (diskaddr_t)d.dkg_ncyl * d.dkg_nhead * d.dkg_nsect; 4846 if (v.v_part[idx].p_size != totsize) { 4847 if (!lecture_and_query(FDISK_LECTURE_NOT_FULL, 4848 devname)) { 4849 (void) close(fd); 4850 exit(1); 4851 } 4852 } 4853 } 4854 } 4855 4856 4857 /* 4858 * get_node 4859 * Called from main to construct the name of the device node to open. 4860 * Initially tries to stat the node exactly as provided, if that fails 4861 * we prepend the default path (/dev/rdsk/). 4862 */ 4863 static char * 4864 get_node(char *devname) 4865 { 4866 char *node; 4867 struct stat statbuf; 4868 size_t space; 4869 4870 /* Don't do anything if we are skipping device checks */ 4871 if (io_image) 4872 return (devname); 4873 4874 node = devname; 4875 4876 /* Try the node as provided first */ 4877 if (stat(node, (struct stat *)&statbuf) == -1) { 4878 /* 4879 * Copy the passed in string to a new buffer, prepend the 4880 * default path and try again. 4881 */ 4882 space = strlen(DEFAULT_PATH) + strlen(devname) + 1; 4883 4884 if ((node = malloc(space)) == NULL) { 4885 (void) fprintf(stderr, "fdisk: Unable to obtain memory " 4886 "for device node.\n"); 4887 exit(1); 4888 } 4889 4890 /* Copy over the default path and the provided node */ 4891 (void) strncpy(node, DEFAULT_PATH, strlen(DEFAULT_PATH)); 4892 space -= strlen(DEFAULT_PATH); 4893 (void) strlcpy(node + strlen(DEFAULT_PATH), devname, space); 4894 4895 /* Try to stat it again */ 4896 if (stat(node, (struct stat *)&statbuf) == -1) { 4897 /* Failed all options, give up */ 4898 (void) fprintf(stderr, 4899 "fdisk: Cannot stat device %s.\n", 4900 devname); 4901 exit(1); 4902 } 4903 } 4904 4905 /* Make sure the device specified is the raw device */ 4906 if ((statbuf.st_mode & S_IFMT) != S_IFCHR) { 4907 (void) fprintf(stderr, 4908 "fdisk: %s must be a raw device.\n", node); 4909 exit(1); 4910 } 4911 4912 return (node); 4913 } 4914 4915 #ifdef i386 4916 static void 4917 preach_and_continue() 4918 { 4919 (void) fprintf(stderr, "There are mounted logical drives. Committing " 4920 "changes now can lead to inconsistancy in internal system state " 4921 "which can eventually cause data loss or corruption. Unmount all " 4922 "logical drives and try committing the changes again.\n"); 4923 ext_read_input(s); 4924 } 4925 4926 /* 4927 * Convert a given partition ID to an descriptive string. 4928 * Just an index into the partition types table. 4929 */ 4930 void 4931 id_to_name(uchar_t sysid, char *buffer) 4932 { 4933 (void) strcpy(buffer, fdisk_part_types[sysid]); 4934 } 4935 4936 /* 4937 * Procedure to check the validity of the extended partition menu option 4938 * entered by the user 4939 */ 4940 static int 4941 ext_invalid_option(char ch) 4942 { 4943 char *p; 4944 4945 p = strchr(ext_part_menu_opts, tolower(ch)); 4946 4947 if (p == NULL) { 4948 return (1); 4949 } 4950 return (0); 4951 } 4952 4953 /* 4954 * Read 16 bytes of the input (assuming that no valid user input spans more 4955 * than that). Flush the input stream, so that the next read does not reap 4956 * stale data from the previous input that was not processed. 4957 * Note that fgets also reads the trailing '\n' 4958 */ 4959 static void 4960 ext_read_input(char *buf) 4961 { 4962 (void) fgets(buf, 16, stdin); 4963 (void) fflush(stdin); 4964 } 4965 4966 /* 4967 * Procedure to read and validate the user option at the extended partition menu 4968 */ 4969 static int 4970 ext_read_options(char *buf) 4971 { 4972 ext_read_input(buf); 4973 if ((strlen(buf) != 2) || (ext_invalid_option(buf[0]))) { 4974 (void) printf("\nUnknown Command\n"); 4975 return (-1); 4976 } 4977 return (0); 4978 } 4979 4980 /* 4981 * Procedure to print the list of known partition types and their IDs 4982 */ 4983 static void 4984 ext_print_part_types() 4985 { 4986 int i, rowmax, rowcount = 1; 4987 struct winsize ws; 4988 char buf[80]; 4989 4990 /* Get the current window dimensions */ 4991 if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0) { 4992 perror("ioctl"); 4993 rowmax = 20; 4994 } else { 4995 /* 4996 * Accommodate the initial headings by reducing the number of 4997 * partition IDs being printed. 4998 */ 4999 rowmax = ws.ws_row - 5; 5000 } 5001 5002 if (rowmax < 3) { 5003 (void) fprintf(stderr, "Window size too small." 5004 " Try resizing the window\n"); 5005 return; 5006 } 5007 5008 (void) printf("List of known partition types : \n"); 5009 (void) printf("PartID Partition Type\n"); 5010 (void) printf("====== ==============\n"); 5011 for (i = 0; i <= FDISK_MAX_VALID_PART_ID; i++) { 5012 (void) printf("%-3d %s\n", i, fdisk_part_types[i]); 5013 rowcount++; 5014 if (rowcount == rowmax) { 5015 /* 5016 * After the initial screen, use all the rows for 5017 * printing the partition IDs, but one. 5018 */ 5019 rowmax = ws.ws_row - 1; 5020 (void) fprintf(stderr, "\nPress enter to see next " 5021 "page or 'q' to quit : "); 5022 ext_read_input(buf); 5023 if ((strlen(buf) == 2) && (tolower(buf[0]) == 'q')) { 5024 return; 5025 } 5026 rowcount = 1; 5027 } 5028 } 5029 } 5030 5031 static void 5032 ext_read_valid_part_num(int *pno) 5033 { 5034 char buf[80]; 5035 int len, i; 5036 5037 for (;;) { 5038 (void) printf("Enter the partition number : "); 5039 ext_read_input(buf); 5040 5041 len = strlen(buf); 5042 5043 /* Check length of the input */ 5044 if ((len < 2) || (len > (FDISK_MAX_VALID_PART_NUM_DIGITS+1))) { 5045 goto print_error_and_continue; 5046 } 5047 5048 /* Check if there is a non-digit in the input */ 5049 for (i = 0; i < len-1; i++) { 5050 if (!isdigit(buf[i])) { 5051 goto print_error_and_continue; 5052 } 5053 } 5054 5055 *pno = atoi(buf); 5056 5057 if ((*pno <= FD_NUMPART) || 5058 *pno > (fdisk_get_logical_drive_count(epp) + FD_NUMPART)) { 5059 goto print_error_and_continue; 5060 } 5061 5062 break; 5063 print_error_and_continue: 5064 (void) printf("Invalid partition number\n"); 5065 continue; 5066 } 5067 } 5068 5069 static void 5070 ext_read_valid_part_id(uchar_t *partid) 5071 { 5072 char buf[80]; 5073 int len, i, id; 5074 5075 for (;;) { 5076 (void) printf("Enter the ID ( Type I for list of " 5077 "partition IDs ) : "); 5078 ext_read_input(buf); 5079 len = strlen(buf); 5080 5081 if ((len < 2) || (len > (FDISK_MAX_VALID_PART_ID_DIGITS + 1))) { 5082 (void) printf("Invalid partition ID\n"); 5083 continue; 5084 } 5085 5086 if ((len == 2) && (toupper(buf[0]) == 'I')) { 5087 ext_print_part_types(); 5088 continue; 5089 } 5090 5091 /* Check if there is a non-digit in the input */ 5092 for (i = 0; i < len-1; i++) { 5093 if (!isdigit(buf[i])) { 5094 (void) printf("Invalid partition ID\n"); 5095 break; 5096 } 5097 } 5098 5099 if (i < len - 1) { 5100 continue; 5101 } 5102 5103 /* Check if the (now) valid number is greater than the limit */ 5104 if ((id = atoi(buf)) > FDISK_MAX_VALID_PART_ID) { 5105 (void) printf("Invalid partition ID\n"); 5106 continue; 5107 } 5108 5109 *partid = (uchar_t)id; 5110 5111 /* Disallow multiple extended partitions */ 5112 if (fdisk_is_dos_extended(*partid)) { 5113 (void) printf("Multiple extended partitions not " 5114 "allowed\n"); 5115 continue; 5116 } 5117 5118 /* Disallow EFI partitions within extended partition */ 5119 if (*partid == EFI_PMBR) { 5120 (void) printf("EFI partitions within an extended " 5121 "partition is not allowed\n"); 5122 continue; 5123 } 5124 5125 return; /* Valid partition ID is in partid */ 5126 } 5127 } 5128 5129 static void 5130 delete_logical_drive() 5131 { 5132 int pno; 5133 5134 if (!fdisk_get_logical_drive_count(epp)) { 5135 (void) printf("\nNo logical drives defined.\n"); 5136 return; 5137 } 5138 5139 (void) printf("\n"); 5140 ext_read_valid_part_num(&pno); 5141 fdisk_delete_logical_drive(epp, pno); 5142 (void) printf("Partition %d deleted\n", pno); 5143 } 5144 5145 static int 5146 ext_read_valid_partition_start(uint32_t *begsec) 5147 { 5148 char buf[80]; 5149 int ret, len, i; 5150 uint32_t begcyl; 5151 uint32_t first_free_cyl; 5152 uint32_t first_free_sec; 5153 5154 ret = fdisk_ext_find_first_free_sec(epp, &first_free_sec); 5155 if (ret != FDISK_SUCCESS) { 5156 return (ret); 5157 } 5158 5159 first_free_cyl = FDISK_SECT_TO_CYL(epp, first_free_sec); 5160 for (;;) { 5161 (void) printf("Enter the beginning cylinder (Default - %d) : ", 5162 first_free_cyl); 5163 ext_read_input(buf); 5164 len = strlen(buf); 5165 if (len == 1) { /* User accepted the default value */ 5166 *begsec = first_free_sec; 5167 return (FDISK_SUCCESS); 5168 } 5169 5170 if (len > (FDISK_MAX_VALID_CYL_NUM_DIGITS + 1)) { 5171 (void) printf("Input too long\n"); 5172 (void) printf("Invalid beginning cylinder number\n"); 5173 continue; 5174 } 5175 /* Check if there is a non-digit in the input */ 5176 for (i = 0; i < len - 1; i++) { 5177 if (!isdigit(buf[i])) { 5178 (void) printf("Invalid beginning cylinder " 5179 "number\n"); 5180 break; 5181 } 5182 } 5183 if (i < len - 1) { 5184 continue; 5185 } 5186 5187 begcyl = atoi(buf); 5188 ret = fdisk_ext_validate_part_start(epp, begcyl, begsec); 5189 switch (ret) { 5190 case FDISK_SUCCESS: 5191 /* 5192 * Success. 5193 * Valid beginning sector is in begsec 5194 */ 5195 break; 5196 5197 case FDISK_EOVERLAP: 5198 (void) printf("Partition boundary overlaps " 5199 "with "); 5200 (void) printf("existing partitions\n"); 5201 (void) printf("Invalid beginning cylinder " 5202 "number\n"); 5203 continue; 5204 5205 case FDISK_EOOBOUND: 5206 (void) printf("Cylinder boundary beyond the " 5207 "limits\n"); 5208 (void) printf("Invalid beginning cylinder " 5209 "number\n"); 5210 continue; 5211 } 5212 return (FDISK_SUCCESS); 5213 } 5214 } 5215 5216 /* 5217 * Algorithm : 5218 * 1. Check if the first character is a + 5219 * a) If yes, check if the last character is 'k', 'm' or 'g' 5220 * 2. If not, check if there are any non-digits 5221 * 3. Check for the length of the numeral string 5222 * 4. atoi the numeral string 5223 * 5. In case of data entered in KB, MB or GB, convert it to number of cylinders 5224 * a) Adjust size to be cylinder boundary aligned 5225 * 6. If size specifies is zero, flag error 5226 * 7. Check if the size is less than 1 cylinder 5227 * a) If yes, default the size FDISK_MIN_PART_SIZE 5228 * b) If no, Check if the size is within endcyl - begcyl 5229 */ 5230 static void 5231 ext_read_valid_partition_size(uint32_t begsec, uint32_t *endsec) 5232 { 5233 char buf[80]; 5234 uint32_t last_free_sec; 5235 uint32_t last_free_cyl; 5236 int i, len, ch, mbgb = 0, scale = FDISK_SECTS_PER_CYL(epp); 5237 uint64_t size = 0; 5238 int copy_len; 5239 char numbuf[FDISK_MAX_VALID_CYL_NUM_DIGITS + 1]; 5240 int sectsize = fdisk_get_disk_geom(epp, PHYSGEOM, SSIZE); 5241 uint32_t remdr, spc, poss_end; 5242 5243 if (sectsize == EINVAL) { 5244 (void) fprintf(stderr, "Unsupported geometry statistics.\n"); 5245 exit(1); 5246 } 5247 5248 last_free_sec = fdisk_ext_find_last_free_sec(epp, begsec); 5249 last_free_cyl = FDISK_SECT_TO_CYL(epp, last_free_sec); 5250 5251 for (;;) { 5252 (void) printf("Enter the size in cylinders (Default End " 5253 "Cylinder -"); 5254 (void) printf(" %u)\n", last_free_cyl); 5255 (void) printf("Type +<size>K, +<size>M or +<size>G to enter " 5256 "size in"); 5257 (void) printf("KB, MB or GB : "); 5258 ext_read_input(buf); 5259 len = strlen(buf); 5260 mbgb = 0; 5261 scale = FDISK_SECTS_PER_CYL(epp); 5262 5263 if (len == 1) { /* User accepted the default value */ 5264 *endsec = last_free_sec; 5265 return; 5266 } 5267 5268 copy_len = len - 1; 5269 5270 if ((buf[0] == '+') && (isdigit(buf[1]))) { 5271 copy_len--; 5272 if ((ch = toupper(buf[len - 2])) == 'B') { 5273 ch = toupper(buf[len - 3]); 5274 copy_len--; 5275 } 5276 5277 if (!((ch == 'K') || (ch == 'M') || (ch == 'G'))) { 5278 (void) printf("Invalid partition size\n"); 5279 continue; 5280 } 5281 5282 copy_len--; 5283 mbgb = 1; 5284 scale = ((ch == 'K') ? FDISK_KB : 5285 ((ch == 'M') ? FDISK_MB : FDISK_GB)); 5286 } 5287 5288 if (copy_len > FDISK_MAX_VALID_CYL_NUM_DIGITS) { 5289 (void) printf("Input too long\n"); 5290 (void) printf("Invalid partition size\n"); 5291 continue; 5292 } 5293 5294 (void) strncpy(numbuf, &buf[mbgb], copy_len); 5295 numbuf[copy_len] = '\0'; 5296 5297 for (i = mbgb; i < copy_len + mbgb; i++) { 5298 if (!isdigit(buf[i])) { 5299 break; 5300 } 5301 } 5302 5303 if (i < copy_len + mbgb) { 5304 (void) printf("Invalid partition size\n"); 5305 continue; 5306 } 5307 5308 size = (atoll(numbuf) * (scale)); 5309 5310 if (size == 0) { 5311 (void) printf("Zero size is invalid\n"); 5312 (void) printf("Invalid partition size\n"); 5313 continue; 5314 } 5315 5316 if (mbgb) { 5317 size /= sectsize; 5318 } 5319 5320 if (size > (last_free_sec - begsec + 1)) { 5321 (void) printf("Cylinder boundary beyond the limits"); 5322 (void) printf(" or overlaps with existing"); 5323 (void) printf(" partitions\n"); 5324 (void) printf("Invalid partition size\n"); 5325 continue; 5326 } 5327 5328 /* 5329 * Adjust the ending sector such that there are no partial 5330 * cylinders allocated. But at the same time, make sure it 5331 * doesn't over shoot boundaries. 5332 */ 5333 spc = FDISK_SECTS_PER_CYL(epp); 5334 poss_end = begsec + size - 1; 5335 if ((remdr = (poss_end % spc)) != 0) { 5336 poss_end += spc - remdr - 1; 5337 } 5338 *endsec = (poss_end > last_free_sec) ? last_free_sec : 5339 poss_end; 5340 5341 return; 5342 } 5343 } 5344 5345 /* 5346 * ALGORITHM: 5347 * 1. Get the starting and ending sectors/cylinder of the extended partition. 5348 * 2. Keep track of the first free sector/cylinder 5349 * 3. Allow the user to specify the beginning cylinder of the new partition 5350 * 4. Check for the validity of the entered data 5351 * a) If it is non-numeric 5352 * b) If it is beyond the extended partition limits 5353 * c) If it overlaps with the current logical drives 5354 * 5. Allow the user to specify the size in cylinders/ human readable form 5355 * 6. Check for the validity of the entered data 5356 * a) If it is non-numeric 5357 * b) If it is beyond the extended partition limits 5358 * c) If it overlaps with the current logical drives 5359 * d) If it is a number lesser than the starting cylinder 5360 * 7. Request partition ID for the new partition. 5361 * 8. Update the first free cylinder available 5362 * 9. Display Success message 5363 */ 5364 5365 static void 5366 add_logical_drive() 5367 { 5368 uint32_t begsec, endsec; 5369 uchar_t partid; 5370 char buf[80]; 5371 int rval; 5372 5373 if (fdisk_get_logical_drive_count(epp) >= MAX_EXT_PARTS) { 5374 (void) printf("\nNumber of logical drives exceeds limit of " 5375 "%d.\n", MAX_EXT_PARTS); 5376 (void) printf("Command did not succeed. Press enter to " 5377 "continue\n"); 5378 ext_read_input(buf); 5379 return; 5380 } 5381 5382 (void) printf("\n"); 5383 rval = ext_read_valid_partition_start(&begsec); 5384 switch (rval) { 5385 case FDISK_SUCCESS: 5386 break; 5387 5388 case FDISK_EOOBOUND: 5389 (void) printf("\nNo space left in the extended " 5390 "partition\n"); 5391 (void) printf("Press enter to continue\n"); 5392 ext_read_input(buf); 5393 return; 5394 } 5395 5396 ext_read_valid_partition_size(begsec, &endsec); 5397 ext_read_valid_part_id(&partid); 5398 fdisk_add_logical_drive(epp, begsec, endsec, partid); 5399 5400 (void) printf("New partition with ID %d added\n", partid); 5401 } 5402 5403 static void 5404 ext_change_logical_drive_id() 5405 { 5406 int pno; 5407 uchar_t partid; 5408 5409 if (!fdisk_get_logical_drive_count(epp)) { 5410 (void) printf("\nNo logical drives defined.\n"); 5411 return; 5412 } 5413 5414 (void) printf("\n"); 5415 ext_read_valid_part_num(&pno); 5416 ext_read_valid_part_id(&partid); 5417 fdisk_change_logical_drive_id(epp, pno, partid); 5418 5419 (void) printf("Partition ID of partition %d changed to %d\n", pno, 5420 partid); 5421 } 5422 5423 #ifdef DEBUG 5424 static void 5425 ext_print_logdrive_layout_debug() 5426 { 5427 int pno; 5428 char namebuff[255]; 5429 logical_drive_t *head = fdisk_get_ld_head(epp); 5430 logical_drive_t *temp; 5431 5432 if (!fdisk_get_logical_drive_count(epp)) { 5433 (void) printf("\nNo logical drives defined.\n"); 5434 return; 5435 } 5436 5437 (void) printf("\n\n"); 5438 puts("# start block end block abs start abs end OSType"); 5439 for (temp = head, pno = 5; temp != NULL; temp = temp->next, pno++) { 5440 /* Print the logical drive details */ 5441 id_to_name(temp->parts[0].systid, namebuff); 5442 (void) printf("%d: %.10u %.10u %.10u %.10u", 5443 pno, 5444 LE_32(temp->parts[0].relsect), 5445 LE_32(temp->parts[0].numsect), 5446 temp->abs_secnum, 5447 temp->abs_secnum + temp->numsect - 1 + 5448 MAX_LOGDRIVE_OFFSET); 5449 (void) printf(" %s\n", namebuff); 5450 /* 5451 * Print the second entry in the EBR which is information 5452 * about the location and the size of the next extended 5453 * partition. 5454 */ 5455 id_to_name(temp->parts[1].systid, namebuff); 5456 (void) printf("%d: %.10u %.10u %.10s %.10s", 5457 pno, 5458 LE_32(temp->parts[1].relsect), 5459 LE_32(temp->parts[1].numsect), 5460 " ", " "); 5461 (void) printf(" %s\n", namebuff); 5462 } 5463 } 5464 #endif 5465 5466 static void 5467 ext_print_logical_drive_layout() 5468 { 5469 int sysid; 5470 unsigned int startcyl, endcyl, length, percent, remainder; 5471 logical_drive_t *temp; 5472 uint32_t part_start; 5473 struct ipart *fpart; 5474 char namebuff[255]; 5475 int numcyl = fdisk_get_disk_geom(epp, PHYSGEOM, NCYL); 5476 int pno; 5477 5478 if (numcyl == EINVAL) { 5479 (void) fprintf(stderr, "Unsupported geometry statistics.\n"); 5480 exit(1); 5481 } 5482 5483 if (!fdisk_get_logical_drive_count(epp)) { 5484 (void) printf("\nNo logical drives defined.\n"); 5485 return; 5486 } 5487 5488 (void) printf("\n"); 5489 (void) printf("Number of cylinders in disk : %u\n", 5490 numcyl); 5491 (void) printf("Beginning cylinder of extended partition : %u\n", 5492 fdisk_get_ext_beg_cyl(epp)); 5493 (void) printf("Ending cylinder of extended partition : %u\n", 5494 fdisk_get_ext_end_cyl(epp)); 5495 (void) printf("\n"); 5496 (void) printf("Part# StartCyl EndCyl Length %% " 5497 "Part ID (Type)\n"); 5498 (void) printf("===== ======== ======== ======= ===" 5499 " ==============\n"); 5500 for (temp = fdisk_get_ld_head(epp), pno = 5; temp != NULL; 5501 temp = temp->next, pno++) { 5502 /* Print the logical drive details */ 5503 fpart = &temp->parts[0]; 5504 sysid = fpart->systid; 5505 /* 5506 * Check if partition id 0x82 is Solaris 5507 * or a Linux swap. Print the string 5508 * accordingly. 5509 */ 5510 if (sysid == SUNIXOS) { 5511 part_start = temp->abs_secnum + 5512 temp->logdrive_offset; 5513 if (fdisk_is_linux_swap(epp, part_start, 5514 NULL) == 0) 5515 (void) strcpy(namebuff, LINSWAPstr); 5516 else 5517 (void) strcpy(namebuff, SUstr); 5518 } else { 5519 id_to_name(sysid, namebuff); 5520 } 5521 startcyl = temp->begcyl; 5522 endcyl = temp->endcyl; 5523 if (startcyl == endcyl) { 5524 length = 1; 5525 } else { 5526 length = endcyl - startcyl + 1; 5527 } 5528 percent = length * 100 / numcyl; 5529 if ((remainder = (length * 100 % numcyl)) != 0) { 5530 if ((remainder * 100 / numcyl) > 50) { 5531 /* round up */ 5532 percent++; 5533 } 5534 /* Else leave the percent as is since it's already */ 5535 /* rounded down */ 5536 } 5537 if (percent > 100) { 5538 percent = 100; 5539 } 5540 (void) printf("%-5d %-8u %-8u %-7u %-3d " 5541 "%-3d (%-.28s)\n", 5542 pno, startcyl, endcyl, length, percent, sysid, namebuff); 5543 } 5544 #ifdef DEBUG 5545 ext_print_logdrive_layout_debug(); 5546 #endif 5547 (void) printf("\n"); 5548 } 5549 5550 static void 5551 ext_print_help_menu() 5552 { 5553 (void) printf("\n"); 5554 (void) printf("a Add a logical drive\n"); 5555 (void) printf("d Delete a logical drive\n"); 5556 (void) printf("h Print this help menu\n"); 5557 (void) printf("i Change the id of the logical drive\n"); 5558 (void) printf("p Print the logical drive layout\n"); 5559 (void) printf("r Return to the main fdisk menu\n"); 5560 (void) printf(" (To commit or cancel the changes)\n"); 5561 (void) printf("\n"); 5562 } 5563 5564 static void 5565 ext_part_menu() 5566 { 5567 char buf[80]; 5568 uchar_t *bbsigp; 5569 static int bbsig_disp_flag = 1; 5570 5571 int i; 5572 5573 (void) printf(CLR_SCR); 5574 5575 if (fdisk_corrupt_logical_drives(epp)) { 5576 (void) printf("One or more logical drives seem to be " 5577 "corrupt.\n"); 5578 (void) printf("Displaying only sane logical drives.\n"); 5579 } 5580 5581 if (bbsig_disp_flag && fdisk_invalid_bb_sig(epp, &bbsigp)) { 5582 (void) printf("The following logical drives have a wrong " 5583 "boot block signature :\n\n"); 5584 for (i = 0; bbsigp[i]; i++) { 5585 (void) printf("%d ", bbsigp[i]); 5586 } 5587 (void) printf("\n\n"); 5588 (void) printf("They will be corrected when you choose to " 5589 "commit\n"); 5590 bbsig_disp_flag = 0; 5591 } 5592 5593 (void) printf("Extended partition menu\n"); 5594 5595 for (;;) { 5596 (void) printf("\nEnter Command (Type h for help) : "); 5597 if ((ext_read_options(buf)) < 0) { 5598 (void) printf("\nCommand Options : \n"); 5599 ext_print_help_menu(); 5600 continue; 5601 } 5602 switch (buf[0]) { 5603 case 'a': 5604 add_logical_drive(); 5605 break; 5606 case 'd': 5607 delete_logical_drive(); 5608 break; 5609 case 'h': 5610 ext_print_help_menu(); 5611 break; 5612 case 'i': 5613 ext_change_logical_drive_id(); 5614 break; 5615 case 'p': 5616 ext_print_logical_drive_layout(); 5617 break; 5618 case 'r': 5619 (void) printf(CLR_SCR); 5620 return; 5621 default : /* NOTREACHED */ 5622 break; 5623 } 5624 } 5625 } 5626 #endif /* i386 */ 5627 5628 static int 5629 nopartdefined() 5630 { 5631 int i; 5632 5633 for (i = 0; i < FD_NUMPART; i++) 5634 if (Table[i].systid != UNUSED) 5635 return (0); 5636 return (1); 5637 } 5638 5639 /* create an EFI partition for the whole disk */ 5640 static int 5641 efi_create() 5642 { 5643 if (io_EFIslot < 0 || io_EFIslot > 3) { 5644 (void) fprintf(stderr, 5645 "EFI partition slot must be between 0 and 3 inclusive.\n"); 5646 return (0); 5647 } 5648 if (io_EFIactive != 0 && io_EFIactive != 1) { 5649 (void) fprintf(stderr, 5650 "EFI partition active flag must be 0 or 1.\n"); 5651 return (0); 5652 } 5653 5654 nulltbl(); 5655 /* 5656 * In the following call, start and end cylinder values are set to one 5657 * above the maximum number of cylinders. This is a special fence 5658 * value which indicates that the geometry for the corresponding LBA 5659 * is not representable. This results in a protective MBR which 5660 * is the same as that created by libefi. 5661 */ 5662 if (insert_tbl(EFI_PMBR, 5663 io_EFIactive ? ACTIVE : NOTACTIVE, 5664 MAX_HEAD + 1, MAX_SECT, MAX_CYL + 1, 5665 MAX_HEAD + 1, MAX_SECT, MAX_CYL + 1, 5666 1, 5667 (dev_capacity > DK_MAX_2TB) ? DK_MAX_2TB : (dev_capacity - 1), 5668 io_EFIslot) != io_EFIslot) 5669 return (0); 5670 copy_Table_to_Bootblk(); 5671 dev_mboot_write(0, Bootsect, sectsiz); 5672 return (1); 5673 } 5674