1 /* $NetBSD: fdisk.c,v 1.101 2006/06/02 17:40:34 christos Exp $ */ 2 3 /* 4 * Mach Operating System 5 * Copyright (c) 1992 Carnegie Mellon University 6 * All Rights Reserved. 7 * 8 * Permission to use, copy, modify and distribute this software and its 9 * documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation. 13 * 14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR 16 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 17 * 18 * Carnegie Mellon requests users of this software to return to 19 * 20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 21 * School of Computer Science 22 * Carnegie Mellon University 23 * Pittsburgh PA 15213-3890 24 * 25 * any improvements or extensions that they make and grant Carnegie Mellon 26 * the rights to redistribute these changes. 27 */ 28 29 /* 30 * 14-Dec-89 Robert Baron (rvb) at Carnegie-Mellon University 31 * Copyright (c) 1989 Robert. V. Baron 32 * Created. 33 */ 34 35 #if HAVE_NBTOOL_CONFIG_H 36 #include "nbtool_config.h" 37 #endif 38 39 #include <sys/cdefs.h> 40 41 #ifndef lint 42 __RCSID("$NetBSD: fdisk.c,v 1.101 2006/06/02 17:40:34 christos Exp $"); 43 #endif /* not lint */ 44 45 #define MBRPTYPENAMES 46 #include <sys/types.h> 47 #include <sys/param.h> 48 #include <sys/stat.h> 49 50 #if HAVE_NBTOOL_CONFIG_H 51 #include <nbinclude/sys/disklabel.h> 52 #include <nbinclude/sys/bootblock.h> 53 #else 54 #include <sys/disklabel.h> 55 #include <sys/bootblock.h> 56 #include <sys/ioctl.h> 57 #include <sys/sysctl.h> 58 #endif /* HAVE_NBTOOL_CONFIG_H */ 59 60 #include <ctype.h> 61 #include <err.h> 62 #include <errno.h> 63 #include <fcntl.h> 64 #include <paths.h> 65 #include <stdarg.h> 66 #include <stddef.h> 67 #include <stdio.h> 68 #include <stdlib.h> 69 #include <string.h> 70 #include <unistd.h> 71 72 #if HAVE_NBTOOL_CONFIG_H 73 #include "../../include/disktab.h" 74 #else 75 #include <disktab.h> 76 #include <util.h> 77 #endif /* HAVE_NBTOOL_CONFIG_H */ 78 79 #define DEFAULT_BOOTDIR "/usr/mdec" 80 81 #define LE_MBR_MAGIC htole16(MBR_MAGIC) 82 #define LE_MBR_BS_MAGIC htole16(MBR_BS_MAGIC) 83 84 #if defined(__i386__) || defined(__x86_64__) 85 #if !HAVE_NBTOOL_CONFIG_H 86 #include <machine/cpu.h> 87 #endif /* !HAVE_NBTOOL_CONFIG_H */ 88 #define BOOTSEL 89 #endif 90 91 #ifdef BOOTSEL 92 93 #define DEFAULT_BOOTCODE "mbr" 94 #define DEFAULT_BOOTSELCODE "mbr_bootsel" 95 #define DEFAULT_BOOTEXTCODE "mbr_ext" 96 97 /* Scan values for the various keys we use, as returned by the BIOS */ 98 #define SCAN_ENTER 0x1c 99 #define SCAN_F1 0x3b 100 #define SCAN_1 0x2 101 102 #endif 103 104 #define LBUF 100 105 static char lbuf[LBUF]; 106 107 #ifndef PRIdaddr 108 #define PRIdaddr PRId64 109 #endif 110 111 #ifndef PRId64 112 #if HAVE_LONG_LONG 113 #define PRId64 "lld" 114 #endif 115 #endif 116 117 #ifndef _PATH_DEFDISK 118 #define _PATH_DEFDISK "/dev/rwd0d" 119 #endif 120 121 const char *disk = _PATH_DEFDISK; 122 123 struct disklabel disklabel; /* disk parameters */ 124 125 unsigned int cylinders, sectors, heads; 126 daddr_t disksectors; 127 #define cylindersectors (heads * sectors) 128 129 struct mbr_sector mboot; 130 131 132 struct { 133 struct mbr_sector *ptn; /* array of pbrs */ 134 daddr_t base; /* first sector of ext. ptn */ 135 daddr_t limit; /* last sector of ext. ptn */ 136 int num_ptn; /* number of contained partitions */ 137 int ptn_id; /* entry in mbr */ 138 int is_corrupt; /* 1 if extended chain illegal */ 139 } ext; 140 141 const char *boot_dir = DEFAULT_BOOTDIR; 142 char *boot_path = 0; /* name of file we actually opened */ 143 144 #ifdef BOOTSEL 145 146 #define DEFAULT_ACTIVE (~(daddr_t)0) 147 148 #define OPTIONS "0123BFSafiluvs:b:c:E:r:w:t:T:" 149 #else 150 #define change_part(e, p, id, st, sz, bm) change__part(e, p, id, st, sz) 151 #define OPTIONS "0123FSafiluvs:b:c:E:r:w:" 152 #endif 153 154 unsigned int dos_cylinders; 155 unsigned int dos_heads; 156 unsigned int dos_sectors; 157 daddr_t dos_disksectors; 158 #define dos_cylindersectors (dos_heads * dos_sectors) 159 #define dos_totalsectors (dos_heads * dos_sectors * dos_cylinders) 160 161 #define DOSSECT(s,c) (((s) & 0x3f) | (((c) >> 2) & 0xc0)) 162 #define DOSCYL(c) ((c) & 0xff) 163 #define SEC_IN_1M (1024 * 1024 / 512) 164 #define SEC_TO_MB(sec) ((unsigned int)(((sec) + SEC_IN_1M / 2) / SEC_IN_1M)) 165 #define SEC_TO_CYL(sec) (((sec) + dos_cylindersectors/2) / dos_cylindersectors) 166 167 #define MAXCYL 1024 /* Usual limit is 1023 */ 168 #define MAXHEAD 256 /* Usual limit is 255 */ 169 #define MAXSECTOR 63 170 int partition = -1; 171 172 int fd = -1, wfd = -1, *rfd = &fd; 173 char *disk_file = NULL; 174 char *disk_type = NULL; 175 176 int a_flag; /* set active partition */ 177 int i_flag; /* init bootcode */ 178 int u_flag; /* update partition data */ 179 int v_flag; /* more verbose */ 180 int sh_flag; /* Output data as shell defines */ 181 int f_flag; /* force --not interactive */ 182 int s_flag; /* set id,offset,size */ 183 int b_flag; /* Set cyl, heads, secs (as c/h/s) */ 184 int B_flag; /* Edit/install bootselect code */ 185 int E_flag; /* extended partition number */ 186 int b_cyl, b_head, b_sec; /* b_flag values. */ 187 int F_flag = 0; 188 189 struct mbr_sector bootcode[8192 / sizeof (struct mbr_sector)]; 190 int bootsize; /* actual size of bootcode */ 191 int boot_installed; /* 1 if we've copied code into the mbr */ 192 193 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 194 struct disklist *dl; 195 #endif 196 197 198 #define KNOWN_SYSIDS (sizeof(mbr_ptypes)/sizeof(mbr_ptypes[0])) 199 200 void usage(void); 201 void print_s0(int); 202 void print_part(struct mbr_sector *, int, daddr_t); 203 void print_mbr_partition(struct mbr_sector *, int, daddr_t, daddr_t, int); 204 int read_boot(const char *, void *, size_t, int); 205 void init_sector0(int); 206 void intuit_translated_geometry(void); 207 void get_geometry(void); 208 void get_extended_ptn(void); 209 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 210 void get_diskname(const char *, char *, size_t); 211 #endif /* (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H */ 212 int change_part(int, int, int, daddr_t, daddr_t, char *); 213 void print_params(void); 214 void change_active(int); 215 void get_params_to_use(void); 216 void dos(int, unsigned char *, unsigned char *, unsigned char *); 217 int open_disk(int); 218 int read_disk(daddr_t, void *); 219 int write_disk(daddr_t, void *); 220 int get_params(void); 221 int read_s0(daddr_t, struct mbr_sector *); 222 int write_mbr(void); 223 int yesno(const char *, ...); 224 int decimal(const char *, int, int, int, int); 225 #define DEC_SEC 1 /* asking for a sector number */ 226 #define DEC_RND 2 /* round to end of first track */ 227 #define DEC_RND_0 4 /* round 0 to size of a track */ 228 #define DEC_RND_DOWN 8 /* subtract 1 track */ 229 #define DEC_RND_DOWN_2 16 /* subtract 2 tracks */ 230 void string(const char *, int, char *); 231 int ptn_id(const char *, int *); 232 int type_match(const void *, const void *); 233 const char *get_type(int); 234 int get_mapping(int, unsigned int *, unsigned int *, unsigned int *, unsigned long *); 235 #ifdef BOOTSEL 236 daddr_t configure_bootsel(daddr_t); 237 void install_bootsel(int); 238 daddr_t get_default_boot(void); 239 void set_default_boot(daddr_t); 240 #endif 241 242 #if !HAVE_NBTOOL_CONFIG_H 243 static void 244 initvar_disk(const char **diskp) 245 { 246 int mib[2]; 247 size_t len; 248 char *root_device; 249 250 mib[0] = CTL_KERN; 251 mib[1] = KERN_ROOT_DEVICE; 252 if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1 || 253 (root_device = malloc(len)) == NULL || 254 sysctl(mib, 2, root_device, &len, NULL, 0) == -1) 255 return; 256 257 *diskp = root_device; 258 } 259 #endif /* HAVE_NBTOOL_CONFIG_H */ 260 261 int 262 main(int argc, char *argv[]) 263 { 264 struct stat sb; 265 int ch; 266 size_t len; 267 char *cp; 268 int n; 269 #ifdef BOOTSEL 270 daddr_t default_ptn; /* start sector of default ptn */ 271 char *cbootmenu = 0; 272 #endif 273 274 int csysid, cstart, csize; /* For the b_flag. */ 275 276 #if !HAVE_NBTOOL_CONFIG_H 277 initvar_disk(&disk); 278 #endif /* HAVE_NBTOOL_CONFIG_H */ 279 280 a_flag = i_flag = u_flag = sh_flag = f_flag = s_flag = b_flag = 0; 281 v_flag = 0; 282 E_flag = 0; 283 csysid = cstart = csize = 0; 284 while ((ch = getopt(argc, argv, OPTIONS)) != -1) 285 switch (ch) { 286 case '0': 287 partition = 0; 288 break; 289 case '1': 290 partition = 1; 291 break; 292 case '2': 293 partition = 2; 294 break; 295 case '3': 296 partition = 3; 297 break; 298 case 'E': /* Extended partition number */ 299 E_flag = 1; 300 partition = strtoul(optarg, &cp, 0); 301 if (*cp || partition < 0) 302 errx(1, "Bad partition number -E %s.", optarg); 303 break; 304 #ifdef BOOTSEL 305 case 'B': /* Bootselect parameters */ 306 B_flag = 1; 307 break; 308 #endif 309 case 'F': /* device argument is really a file */ 310 F_flag = 1; 311 break; 312 case 'S': /* Output as shell variables */ 313 sh_flag = 1; 314 break; 315 case 'a': /* Set active partition */ 316 a_flag = 1; 317 break; 318 case 'f': /* Non interactive */ 319 f_flag = 1; 320 break; 321 case 'i': /* Always update bootcode */ 322 i_flag = 1; 323 break; 324 case 'l': /* List known partition types */ 325 for (len = 0; len < KNOWN_SYSIDS; len++) 326 printf("%03d %s\n", mbr_ptypes[len].id, 327 mbr_ptypes[len].name); 328 return 0; 329 case 'u': /* Update partition details */ 330 u_flag = 1; 331 break; 332 case 'v': /* Be verbose */ 333 v_flag++; 334 break; 335 case 's': /* Partition details */ 336 s_flag = 1; 337 if (sscanf(optarg, "%d/%d/%d%n", &csysid, &cstart, 338 &csize, &n) == 3) { 339 if (optarg[n] == 0) 340 break; 341 #ifdef BOOTSEL 342 if (optarg[n] == '/') { 343 cbootmenu = optarg + n + 1; 344 break; 345 } 346 #endif 347 } 348 errx(1, "Bad argument to the -s flag."); 349 break; 350 case 'b': /* BIOS geometry */ 351 b_flag = 1; 352 if (sscanf(optarg, "%d/%d/%d%n", &b_cyl, &b_head, 353 &b_sec, &n) != 3 || optarg[n] != 0) 354 errx(1, "Bad argument to the -b flag."); 355 if (b_cyl > MAXCYL) 356 b_cyl = MAXCYL; 357 break; 358 case 'c': /* file/directory containing boot code */ 359 if (strchr(optarg, '/') != NULL && 360 stat(optarg, &sb) == 0 && 361 (sb.st_mode & S_IFMT) == S_IFDIR) { 362 boot_dir = optarg; 363 break; 364 } 365 bootsize = read_boot(optarg, bootcode, 366 sizeof bootcode, 1); 367 i_flag = 1; 368 break; 369 case 'r': /* read data from disk_file (not raw disk) */ 370 rfd = &wfd; 371 /* FALLTHROUGH */ 372 case 'w': /* write data to disk_file */ 373 disk_file = optarg; 374 break; 375 case 't': 376 if (setdisktab(optarg) == -1) 377 errx(EXIT_FAILURE, "bad disktab"); 378 break; 379 case 'T': 380 disk_type = optarg; 381 break; 382 default: 383 usage(); 384 } 385 argc -= optind; 386 argv += optind; 387 388 #if HAVE_NBTOOL_CONFIG_H 389 if (disk_file == NULL && argc > 0) 390 disk_file = argv[0]; 391 else if (disk_file == NULL) 392 usage(); 393 #endif /* HAVE_NBTOOL_CONFIG_H */ 394 395 if (disk_type != NULL && getdiskbyname(disk_type) == NULL) 396 errx(EXIT_FAILURE, "bad disktype"); 397 398 if (sh_flag && (a_flag || i_flag || u_flag || f_flag || s_flag)) 399 usage(); 400 401 if (B_flag && f_flag) { 402 warnx("Bootselector may only be configured interactively"); 403 usage(); 404 } 405 406 if (f_flag && u_flag && !s_flag) { 407 warnx("Partition data not specified"); 408 usage(); 409 } 410 411 if (s_flag && partition == -1) { 412 warnx("-s flag requires a partition selected."); 413 usage(); 414 } 415 416 if (argc > 0) 417 disk = argv[0]; 418 419 if (open_disk(B_flag || a_flag || i_flag || u_flag) < 0) 420 exit(1); 421 422 if (read_s0(0, &mboot)) 423 /* must have been a blank disk */ 424 init_sector0(1); 425 426 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 427 get_geometry(); 428 #else 429 intuit_translated_geometry(); 430 #endif 431 get_extended_ptn(); 432 433 #ifdef BOOTSEL 434 default_ptn = get_default_boot(); 435 #endif 436 437 if (E_flag && !u_flag && partition >= ext.num_ptn) 438 errx(1, "Extended partition %d is not defined.", partition); 439 440 if (u_flag && (!f_flag || b_flag)) 441 get_params_to_use(); 442 443 /* Do the update stuff! */ 444 if (u_flag) { 445 if (s_flag) 446 change_part(E_flag, partition, csysid, cstart, csize, 447 cbootmenu); 448 else { 449 int part = partition, chg_ext = E_flag, prompt = 1; 450 do { 451 if (prompt) { 452 printf("\n"); 453 print_s0(partition); 454 } 455 if (partition == -1) 456 part = ptn_id( 457 "Which partition do you want to change?", 458 &chg_ext); 459 if (part < 0) 460 break; 461 prompt = change_part(chg_ext, part, 0, 0, 0, 0); 462 } while (partition == -1); 463 } 464 } else 465 if (!i_flag && !B_flag) { 466 print_params(); 467 print_s0(partition); 468 } 469 470 if (a_flag && !E_flag) 471 change_active(partition); 472 473 #ifdef BOOTSEL 474 if (B_flag || u_flag || i_flag) 475 /* Ensure the mbr code supports this configuration */ 476 install_bootsel(0); 477 if (B_flag) 478 default_ptn = configure_bootsel(default_ptn); 479 set_default_boot(default_ptn); 480 #else 481 if (i_flag) 482 init_sector0(0); 483 #endif 484 485 if (u_flag || a_flag || i_flag || B_flag) { 486 if (!f_flag) { 487 printf("\nWe haven't written the MBR back to disk " 488 "yet. This is your last chance.\n"); 489 if (u_flag) 490 print_s0(-1); 491 if (yesno("Should we write new partition table?")) 492 write_mbr(); 493 } else 494 write_mbr(); 495 } 496 497 exit(0); 498 } 499 500 void 501 usage(void) 502 { 503 int indent = 7 + (int)strlen(getprogname()) + 1; 504 505 (void)fprintf(stderr, "usage: %s [-afiluvBS] " 506 "[-b cylinders/heads/sectors] \\\n" 507 "%*s[-0123 | -E num " 508 "[-s id/start/size[/bootmenu]]] \\\n" 509 "%*s[-t disktab] [-T disktype] \\\n" 510 "%*s[-c bootcode] " 511 #if !HAVE_NBTOOL_CONFIG_H 512 "[-r|-w file] [device]\n" 513 #else 514 "[-r|-w] file\n" 515 #endif /* HAVE_NBTOOL_CONFIG_H */ 516 "\t-a change active partition\n" 517 "\t-f force - not interactive\n" 518 "\t-i initialise MBR code\n" 519 "\t-l list partition types\n" 520 "\t-u update partition data\n" 521 "\t-v verbose output, -v -v more verbose still\n" 522 "\t-B update bootselect options\n" 523 "\t-F treat device as a regular file\n" 524 "\t-S output as shell defines\n", 525 getprogname(), indent, "", indent, "", indent, ""); 526 exit(1); 527 } 528 529 static daddr_t 530 ext_offset(int part) 531 { 532 daddr_t offset = ext.base; 533 534 if (part != 0) 535 offset += le32toh(ext.ptn[part - 1].mbr_parts[1].mbrp_start); 536 return offset; 537 } 538 539 void 540 print_s0(int which) 541 { 542 int part; 543 544 if (which == -1) { 545 if (!sh_flag) 546 printf("Partition table:\n"); 547 for (part = 0; part < MBR_PART_COUNT; part++) { 548 if (!sh_flag) 549 printf("%d: ", part); 550 print_part(&mboot, part, 0); 551 } 552 if (!sh_flag) { 553 if (ext.is_corrupt) 554 printf("Extended partition table is corrupt\n"); 555 else 556 if (ext.num_ptn != 0) 557 printf("Extended partition table:\n"); 558 } 559 for (part = 0; part < ext.num_ptn; part++) { 560 if (!sh_flag) 561 printf("E%d: ", part); 562 print_part(&ext.ptn[part], 0, ext_offset(part)); 563 if (!sh_flag && v_flag >= 2) { 564 printf("link: "); 565 print_mbr_partition(&ext.ptn[part], 1, 566 ext_offset(part), ext.base, 0); 567 } 568 } 569 #ifdef BOOTSEL 570 if (!sh_flag && mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC) { 571 int tmo; 572 573 printf("Bootselector "); 574 if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_ACTIVE) { 575 printf("enabled"); 576 tmo = le16toh(mboot.mbr_bootsel.mbrbs_timeo); 577 if (tmo == 0xffff) 578 printf(", infinite timeout"); 579 else 580 printf(", timeout %d seconds", 581 (10 * tmo + 9) / 182); 582 } else 583 printf("disabled"); 584 printf(".\n"); 585 } 586 #endif 587 return; 588 } 589 590 if (E_flag) { 591 if (!sh_flag) 592 printf("Extended partition E%d:\n", which); 593 if (which > ext.num_ptn) 594 printf("Undefined\n"); 595 else 596 print_part(&ext.ptn[which], 0, ext_offset(which)); 597 } else { 598 if (!sh_flag) 599 printf("Partition %d:\n", which); 600 print_part(&mboot, which, 0); 601 } 602 } 603 604 void 605 print_part(struct mbr_sector *boot, int part, daddr_t offset) 606 { 607 struct mbr_partition *partp; 608 const char *e; 609 610 if (!sh_flag) { 611 print_mbr_partition(boot, part, offset, 0, 0); 612 return; 613 } 614 615 partp = &boot->mbr_parts[part]; 616 if (boot != &mboot) { 617 part = boot - ext.ptn; 618 e = "E"; 619 } else 620 e = ""; 621 622 if (partp->mbrp_type == 0) { 623 printf("PART%s%dSIZE=0\n", e, part); 624 return; 625 } 626 627 printf("PART%s%dID=%d\n", e, part, partp->mbrp_type); 628 printf("PART%s%dSIZE=%u\n", e, part, le32toh(partp->mbrp_size)); 629 printf("PART%s%dSTART=%"PRIdaddr"\n", e, part, 630 offset + le32toh(partp->mbrp_start)); 631 printf("PART%s%dFLAG=0x%x\n", e, part, partp->mbrp_flag); 632 printf("PART%s%dBCYL=%d\n", e, part, 633 MBR_PCYL(partp->mbrp_scyl, partp->mbrp_ssect)); 634 printf("PART%s%dBHEAD=%d\n", e, part, partp->mbrp_shd); 635 printf("PART%s%dBSEC=%d\n", e, part, MBR_PSECT(partp->mbrp_ssect)); 636 printf("PART%s%dECYL=%d\n", e, part, 637 MBR_PCYL(partp->mbrp_ecyl, partp->mbrp_esect)); 638 printf("PART%s%dEHEAD=%d\n", e, part, partp->mbrp_ehd); 639 printf("PART%s%dESEC=%d\n", e, part, MBR_PSECT(partp->mbrp_esect)); 640 } 641 642 static void 643 pr_cyls(daddr_t sector) 644 { 645 unsigned long cyl, head, sect; 646 cyl = sector / dos_cylindersectors; 647 sect = sector - cyl * dos_cylindersectors; 648 head = sect / dos_sectors; 649 sect -= head * dos_sectors; 650 651 printf("%lu", cyl); 652 if (head == 0 && sect == 0) 653 return; 654 printf("/%lu/%lu", head, sect + 1); 655 } 656 657 void 658 print_mbr_partition(struct mbr_sector *boot, int part, 659 daddr_t offset, daddr_t exoffset, int indent) 660 { 661 daddr_t start; 662 daddr_t size; 663 struct mbr_partition *partp = &boot->mbr_parts[part]; 664 struct mbr_sector eboot; 665 int p; 666 static int dumped = 0; 667 668 if (partp->mbrp_type == 0 && v_flag < 2) { 669 printf("<UNUSED>\n"); 670 return; 671 } 672 673 start = le32toh(partp->mbrp_start); 674 size = le32toh(partp->mbrp_size); 675 if (MBR_IS_EXTENDED(partp->mbrp_type)) 676 start += exoffset; 677 else 678 start += offset; 679 680 printf("%s (sysid %d)\n", get_type(partp->mbrp_type), partp->mbrp_type); 681 #ifdef BOOTSEL 682 if (boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC && 683 boot->mbr_bootsel.mbrbs_nametab[part][0]) 684 printf("%*s bootmenu: %s\n", indent, "", 685 boot->mbr_bootsel.mbrbs_nametab[part]); 686 #endif 687 688 printf("%*s start %"PRIdaddr", size %"PRIdaddr, 689 indent, "", start, size); 690 if (size != 0) { 691 printf(" (%u MB, Cyls ", SEC_TO_MB(size)); 692 if (v_flag == 0 && le32toh(partp->mbrp_start) == dos_sectors) 693 pr_cyls(start - dos_sectors); 694 else 695 pr_cyls(start); 696 printf("-"); 697 pr_cyls(start + size); 698 printf(")"); 699 } 700 701 switch (partp->mbrp_flag) { 702 case 0: 703 break; 704 case MBR_PFLAG_ACTIVE: 705 printf(", Active"); 706 break; 707 default: 708 printf(", flag 0x%x", partp->mbrp_flag); 709 break; 710 } 711 printf("\n"); 712 713 if (v_flag) { 714 printf("%*s beg: cylinder %4d, head %3d, sector %2d\n", 715 indent, "", 716 MBR_PCYL(partp->mbrp_scyl, partp->mbrp_ssect), 717 partp->mbrp_shd, MBR_PSECT(partp->mbrp_ssect)); 718 printf("%*s end: cylinder %4d, head %3d, sector %2d\n", 719 indent, "", 720 MBR_PCYL(partp->mbrp_ecyl, partp->mbrp_esect), 721 partp->mbrp_ehd, MBR_PSECT(partp->mbrp_esect)); 722 } 723 724 if (!MBR_IS_EXTENDED(partp->mbrp_type) || 725 (v_flag <= 2 && !ext.is_corrupt)) 726 return; 727 728 /* 729 * Recursive dump extended table, 730 * This is read from the disk - so is wrong during editing. 731 * Just ensure we only show it once. 732 */ 733 if (dumped) 734 return; 735 736 printf("%*s Extended partition table:\n", indent, ""); 737 indent += 4; 738 if (read_s0(start, &eboot) == -1) 739 return; 740 for (p = 0; p < MBR_PART_COUNT; p++) { 741 printf("%*s%d: ", indent, "", p); 742 print_mbr_partition(&eboot, p, start, 743 exoffset ? exoffset : start, indent); 744 } 745 746 if (exoffset == 0) 747 dumped = 1; 748 } 749 750 int 751 read_boot(const char *name, void *buf, size_t len, int err_exit) 752 { 753 int bfd, ret; 754 struct stat st; 755 756 if (boot_path != NULL) 757 free(boot_path); 758 if (strchr(name, '/') == 0) 759 asprintf(&boot_path, "%s/%s", boot_dir, name); 760 else 761 boot_path = strdup(name); 762 if (boot_path == NULL) 763 err(1, "Malloc failed"); 764 765 if ((bfd = open(boot_path, O_RDONLY)) < 0 || fstat(bfd, &st) == -1) { 766 warn("%s", boot_path); 767 goto fail; 768 } 769 770 if (st.st_size > (off_t)len) { 771 warnx("%s: bootcode too large", boot_path); 772 goto fail; 773 } 774 ret = st.st_size; 775 if (ret < 0x200) { 776 warnx("%s: bootcode too small", boot_path); 777 goto fail; 778 } 779 if (read(bfd, buf, len) != ret) { 780 warn("%s", boot_path); 781 goto fail; 782 } 783 784 /* 785 * Do some sanity checking here 786 */ 787 if (((struct mbr_sector *)buf)->mbr_magic != LE_MBR_MAGIC) { 788 warnx("%s: invalid magic", boot_path); 789 goto fail; 790 } 791 792 close(bfd); 793 ret = (ret + 0x1ff) & ~0x1ff; 794 return ret; 795 796 fail: 797 if (bfd >= 0) 798 close(bfd); 799 if (err_exit) 800 exit(1); 801 return 0; 802 } 803 804 void 805 init_sector0(int zappart) 806 { 807 int i; 808 int copy_size = MBR_PART_OFFSET; 809 810 #ifdef DEFAULT_BOOTCODE 811 if (bootsize == 0) 812 bootsize = read_boot(DEFAULT_BOOTCODE, bootcode, 813 sizeof bootcode, 1); 814 #endif 815 #ifdef BOOTSEL 816 if (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC 817 && bootcode[0].mbr_bootsel_magic == LE_MBR_BS_MAGIC) 818 copy_size = MBR_BS_OFFSET; 819 #endif 820 821 if (bootsize != 0) { 822 boot_installed = 1; 823 memcpy(&mboot, bootcode, copy_size); 824 } 825 mboot.mbr_magic = LE_MBR_MAGIC; 826 827 if (!zappart) 828 return; 829 for (i = 0; i < MBR_PART_COUNT; i++) 830 memset(&mboot.mbr_parts[i], 0, sizeof(mboot.mbr_parts[i])); 831 } 832 833 void 834 get_extended_ptn(void) 835 { 836 struct mbr_partition *mp; 837 struct mbr_sector *boot; 838 daddr_t offset; 839 struct mbr_sector *nptn; 840 841 /* find first (there should only be one) extended partition */ 842 for (mp = mboot.mbr_parts; !MBR_IS_EXTENDED(mp->mbrp_type); mp++) 843 if (mp >= &mboot.mbr_parts[MBR_PART_COUNT]) 844 return; 845 846 /* 847 * The extended partition should be structured as a linked list 848 * (even though it appears, at first glance, to be a tree). 849 */ 850 ext.base = le32toh(mp->mbrp_start); 851 ext.limit = ext.base + le32toh(mp->mbrp_size); 852 ext.ptn_id = mp - mboot.mbr_parts; 853 for (offset = 0;; offset = le32toh(boot->mbr_parts[1].mbrp_start)) { 854 nptn = realloc(ext.ptn, (ext.num_ptn + 1) * sizeof *ext.ptn); 855 if (nptn == NULL) 856 err(1, "Malloc failed"); 857 ext.ptn = nptn; 858 boot = ext.ptn + ext.num_ptn; 859 if (read_s0(offset + ext.base, boot) == -1) 860 break; 861 /* expect p0 to be valid and p1 to be another extended ptn */ 862 if (MBR_IS_EXTENDED(boot->mbr_parts[0].mbrp_type)) 863 break; 864 if (boot->mbr_parts[1].mbrp_type != 0 && 865 !MBR_IS_EXTENDED(boot->mbr_parts[1].mbrp_type)) 866 break; 867 /* p2 and p3 should be unallocated */ 868 if (boot->mbr_parts[2].mbrp_type != 0 || 869 boot->mbr_parts[3].mbrp_type != 0) 870 break; 871 /* data ptn inside extended one */ 872 if (boot->mbr_parts[0].mbrp_type != 0 && 873 offset + le32toh(boot->mbr_parts[0].mbrp_start) 874 + le32toh(boot->mbr_parts[0].mbrp_size) > ext.limit) 875 break; 876 877 ext.num_ptn++; 878 879 if (boot->mbr_parts[1].mbrp_type == 0) 880 /* end of extended partition chain */ 881 return; 882 /* must be in sector order */ 883 if (offset >= le32toh(boot->mbr_parts[1].mbrp_start)) 884 break; 885 } 886 887 warnx("Extended partition table is corrupt\n"); 888 ext.is_corrupt = 1; 889 ext.num_ptn = 0; 890 } 891 892 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 893 void 894 get_diskname(const char *fullname, char *diskname, size_t size) 895 { 896 const char *p, *p2; 897 size_t len; 898 899 p = strrchr(fullname, '/'); 900 if (p == NULL) 901 p = fullname; 902 else 903 p++; 904 905 if (*p == 0) { 906 strlcpy(diskname, fullname, size); 907 return; 908 } 909 910 if (*p == 'r') 911 p++; 912 913 for (p2 = p; *p2 != 0; p2++) 914 if (isdigit((unsigned char)*p2)) 915 break; 916 if (*p2 == 0) { 917 /* XXX invalid diskname? */ 918 strlcpy(diskname, fullname, size); 919 return; 920 } 921 while (isdigit((unsigned char)*p2)) 922 p2++; 923 924 len = p2 - p; 925 if (len > size) { 926 /* XXX */ 927 strlcpy(diskname, fullname, size); 928 return; 929 } 930 931 memcpy(diskname, p, len); 932 diskname[len] = 0; 933 } 934 935 void 936 get_geometry(void) 937 { 938 int mib[2], i; 939 size_t len; 940 struct biosdisk_info *bip; 941 struct nativedisk_info *nip; 942 char diskname[8]; 943 944 mib[0] = CTL_MACHDEP; 945 mib[1] = CPU_DISKINFO; 946 if (sysctl(mib, 2, NULL, &len, NULL, 0) < 0) { 947 goto out; 948 } 949 dl = (struct disklist *) malloc(len); 950 if (dl == NULL) 951 err(1, "Malloc failed"); 952 if (sysctl(mib, 2, dl, &len, NULL, 0) < 0) { 953 free(dl); 954 dl = 0; 955 goto out; 956 } 957 958 get_diskname(disk, diskname, sizeof diskname); 959 960 for (i = 0; i < dl->dl_nnativedisks; i++) { 961 nip = &dl->dl_nativedisks[i]; 962 if (strcmp(diskname, nip->ni_devname)) 963 continue; 964 /* 965 * XXX listing possible matches is better. This is ok for 966 * now because the user has a chance to change it later. 967 * Also, if all the disks have the same parameters then we can 968 * just use them, we don't need to know which disk is which. 969 */ 970 if (nip->ni_nmatches != 0) { 971 bip = &dl->dl_biosdisks[nip->ni_biosmatches[0]]; 972 dos_cylinders = bip->bi_cyl; 973 dos_heads = bip->bi_head; 974 dos_sectors = bip->bi_sec; 975 if (bip->bi_lbasecs) 976 dos_disksectors = bip->bi_lbasecs; 977 return; 978 } 979 } 980 out: 981 /* Allright, allright, make a stupid guess.. */ 982 intuit_translated_geometry(); 983 } 984 #endif /* (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H */ 985 986 #ifdef BOOTSEL 987 daddr_t 988 get_default_boot(void) 989 { 990 unsigned int id; 991 int p; 992 993 if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC) 994 /* default to first active partition */ 995 return DEFAULT_ACTIVE; 996 997 if (mboot.mbr_bootsel.mbrbs_defkey == SCAN_ENTER) 998 return DEFAULT_ACTIVE; 999 1000 id = mboot.mbr_bootsel.mbrbs_defkey; 1001 1002 /* 1+ => allocated partition id, F1+ => disk 0+ */ 1003 if (id >= SCAN_F1) 1004 return id - SCAN_F1; 1005 id -= SCAN_1; 1006 1007 for (p = 0; p < MBR_PART_COUNT; p++) { 1008 if (mboot.mbr_parts[p].mbrp_type == 0) 1009 continue; 1010 if (mboot.mbr_bootsel.mbrbs_nametab[p][0] == 0) 1011 continue; 1012 if (id-- == 0) 1013 return le32toh(mboot.mbr_parts[p].mbrp_start); 1014 } 1015 1016 for (p = 0; p < ext.num_ptn; p++) { 1017 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1018 continue; 1019 if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[0][0] == 0) 1020 continue; 1021 if (id-- == 0) 1022 return ext_offset(p) 1023 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_start); 1024 } 1025 1026 return DEFAULT_ACTIVE; 1027 } 1028 1029 void 1030 set_default_boot(daddr_t default_ptn) 1031 { 1032 int p; 1033 int key = SCAN_1; 1034 1035 if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC) 1036 /* sanity */ 1037 return; 1038 1039 if (default_ptn == DEFAULT_ACTIVE) { 1040 mboot.mbr_bootsel.mbrbs_defkey = SCAN_ENTER; 1041 return; 1042 } 1043 1044 for (p = 0; p < MBR_PART_COUNT; p++) { 1045 if (mboot.mbr_parts[p].mbrp_type == 0) 1046 continue; 1047 if (mboot.mbr_bootsel.mbrbs_nametab[p][0] == 0) 1048 continue; 1049 if (le32toh(mboot.mbr_parts[p].mbrp_start) == default_ptn) { 1050 mboot.mbr_bootsel.mbrbs_defkey = key; 1051 return; 1052 } 1053 key++; 1054 } 1055 1056 if (mboot.mbr_bootsel.mbrbs_flags & MBR_BS_EXTLBA) { 1057 for (p = 0; p < ext.num_ptn; p++) { 1058 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1059 continue; 1060 if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[0][0] == 0) 1061 continue; 1062 if (le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) + 1063 ext_offset(p) == default_ptn) { 1064 mboot.mbr_bootsel.mbrbs_defkey = key; 1065 return; 1066 } 1067 key++; 1068 } 1069 } 1070 1071 if (default_ptn < 8) { 1072 key = SCAN_F1; 1073 mboot.mbr_bootsel.mbrbs_defkey = key + default_ptn; 1074 return; 1075 } 1076 1077 /* Default to first active partition */ 1078 mboot.mbr_bootsel.mbrbs_defkey = SCAN_ENTER; 1079 } 1080 1081 void 1082 install_bootsel(int needed) 1083 { 1084 struct mbr_bootsel *mbs = &mboot.mbr_bootsel; 1085 int p; 1086 int ext13 = 0; 1087 const char *code; 1088 1089 needed |= MBR_BS_NEWMBR; /* need new bootsel code */ 1090 1091 /* Work out which boot code we need for this configuration */ 1092 for (p = 0; p < MBR_PART_COUNT; p++) { 1093 if (mboot.mbr_parts[p].mbrp_type == 0) 1094 continue; 1095 if (mboot.mbr_bootsel_magic != LE_MBR_BS_MAGIC) 1096 break; 1097 if (mbs->mbrbs_nametab[p][0] == 0) 1098 continue; 1099 needed |= MBR_BS_ACTIVE; 1100 if (le32toh(mboot.mbr_parts[p].mbrp_start) >= dos_totalsectors) 1101 ext13 = MBR_BS_EXTINT13; 1102 } 1103 1104 for (p = 0; p < ext.num_ptn; p++) { 1105 if (ext.ptn[p].mbr_bootsel_magic != LE_MBR_BS_MAGIC) 1106 continue; 1107 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1108 continue; 1109 if (ext.ptn[p].mbr_bootsel.mbrbs_nametab[p][0] == 0) 1110 continue; 1111 needed |= MBR_BS_EXTLBA | MBR_BS_ACTIVE; 1112 } 1113 1114 if (B_flag) 1115 needed |= MBR_BS_ACTIVE; 1116 1117 /* Is the installed code good enough ? */ 1118 if (!i_flag && (needed == 0 || 1119 (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC 1120 && (mbs->mbrbs_flags & needed) == needed))) { 1121 /* yes - just set flags */ 1122 mbs->mbrbs_flags |= ext13; 1123 return; 1124 } 1125 1126 /* ok - we need to replace the bootcode */ 1127 1128 if (f_flag && !(i_flag || B_flag)) { 1129 warnx("Installed bootfile doesn't support required options."); 1130 return; 1131 } 1132 1133 if (!f_flag && bootsize == 0 && !i_flag) 1134 /* Output an explanation for the 'update bootcode' prompt. */ 1135 printf("\n%s\n", 1136 "Installed bootfile doesn't support required options."); 1137 1138 /* Were we told a specific file ? (which we have already read) */ 1139 /* If so check that it supports what we need. */ 1140 if (bootsize != 0 && needed != 0 1141 && (bootcode[0].mbr_bootsel_magic != LE_MBR_BS_MAGIC 1142 || ((bootcode[0].mbr_bootsel.mbrbs_flags & needed) != needed))) { 1143 /* No it doesn't... */ 1144 if (f_flag) 1145 warnx("Bootfile %s doesn't support " 1146 "required bootsel options", boot_path ); 1147 /* But install it anyway */ 1148 else 1149 if (yesno("Bootfile %s doesn't support the required " 1150 "options,\ninstall default bootfile instead?", 1151 boot_path)) 1152 bootsize = 0; 1153 } 1154 1155 if (bootsize == 0) { 1156 /* Get name of bootfile that supports the required facilities */ 1157 code = DEFAULT_BOOTCODE; 1158 if (needed & MBR_BS_ACTIVE) 1159 code = DEFAULT_BOOTSELCODE; 1160 #ifdef DEFAULT_BOOTEXTCODE 1161 if (needed & MBR_BS_EXTLBA) 1162 code = DEFAULT_BOOTEXTCODE; 1163 #endif 1164 1165 bootsize = read_boot(code, bootcode, sizeof bootcode, 0); 1166 if (bootsize == 0) 1167 /* The old bootcode is better than no bootcode at all */ 1168 return; 1169 if ((bootcode[0].mbr_bootsel.mbrbs_flags & needed) != needed) 1170 warnx("Default bootfile %s doesn't support required " 1171 "options. Got flags 0x%x, wanted 0x%x\n", 1172 boot_path, bootcode[0].mbr_bootsel.mbrbs_flags, 1173 needed); 1174 } 1175 1176 if (!f_flag && !yesno("Update the bootcode from %s?", boot_path)) 1177 return; 1178 1179 init_sector0(0); 1180 1181 if (mboot.mbr_bootsel_magic == LE_MBR_BS_MAGIC) 1182 mbs->mbrbs_flags = bootcode[0].mbr_bootsel.mbrbs_flags | ext13; 1183 } 1184 1185 daddr_t 1186 configure_bootsel(daddr_t default_ptn) 1187 { 1188 struct mbr_bootsel *mbs = &mboot.mbr_bootsel; 1189 int i, item, opt; 1190 int tmo; 1191 daddr_t *off; 1192 int num_bios_disks; 1193 1194 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 1195 if (dl != NULL) { 1196 num_bios_disks = dl->dl_nbiosdisks; 1197 if (num_bios_disks > 8) 1198 num_bios_disks = 8; 1199 } else 1200 #endif 1201 num_bios_disks = 8; 1202 1203 printf("\nBoot selector configuration:\n"); 1204 1205 /* The timeout value is in ticks, ~18.2 Hz. Avoid using floats. 1206 * Ticks are nearly 64k/3600 - so our long timers are sligtly out! 1207 * Newer bootcode always waits for 1 tick, so treats 0xffff 1208 * as wait forever. 1209 */ 1210 tmo = le16toh(mbs->mbrbs_timeo); 1211 tmo = tmo == 0xffff ? -1 : (10 * tmo + 9) / 182; 1212 tmo = decimal("Timeout value (0 to 3600 seconds, -1 => never)", 1213 tmo, 0, -1, 3600); 1214 mbs->mbrbs_timeo = htole16(tmo == -1 ? 0xffff : (tmo * 182) / 10); 1215 1216 off = calloc(1 + MBR_PART_COUNT + ext.num_ptn + num_bios_disks, sizeof *off); 1217 if (off == NULL) 1218 err(1, "Malloc failed"); 1219 1220 printf("Select the default boot option. Options are:\n\n"); 1221 item = 0; 1222 opt = 0; 1223 off[opt] = DEFAULT_ACTIVE; 1224 printf("%d: The first active partition\n", opt); 1225 for (i = 0; i < MBR_PART_COUNT; i++) { 1226 if (mboot.mbr_parts[i].mbrp_type == 0) 1227 continue; 1228 if (mbs->mbrbs_nametab[i][0] == 0) 1229 continue; 1230 printf("%d: %s\n", ++opt, &mbs->mbrbs_nametab[i][0]); 1231 off[opt] = le32toh(mboot.mbr_parts[i].mbrp_start); 1232 if (off[opt] == default_ptn) 1233 item = opt; 1234 } 1235 if (mbs->mbrbs_flags & MBR_BS_EXTLBA) { 1236 for (i = 0; i < ext.num_ptn; i++) { 1237 if (ext.ptn[i].mbr_parts[0].mbrp_type == 0) 1238 continue; 1239 if (ext.ptn[i].mbr_bootsel.mbrbs_nametab[0][0] == 0) 1240 continue; 1241 printf("%d: %s\n", 1242 ++opt, ext.ptn[i].mbr_bootsel.mbrbs_nametab[0]); 1243 off[opt] = ext_offset(i) + 1244 le32toh(ext.ptn[i].mbr_parts[0].mbrp_start); 1245 if (off[opt] == default_ptn) 1246 item = opt; 1247 } 1248 } 1249 for (i = 0; i < num_bios_disks; i++) { 1250 printf("%d: Harddisk %d\n", ++opt, i); 1251 off[opt] = i; 1252 if (i == default_ptn) 1253 item = opt; 1254 } 1255 1256 item = decimal("Default boot option", item, 0, 0, opt); 1257 1258 default_ptn = off[item]; 1259 free(off); 1260 return default_ptn; 1261 } 1262 #endif /* BOOTSEL */ 1263 1264 1265 /* Prerequisite: the disklabel parameters and master boot record must 1266 * have been read (i.e. dos_* and mboot are meaningful). 1267 * Specification: modifies dos_cylinders, dos_heads, dos_sectors, and 1268 * dos_cylindersectors to be consistent with what the 1269 * partition table is using, if we can find a geometry 1270 * which is consistent with all partition table entries. 1271 * We may get the number of cylinders slightly wrong (in 1272 * the conservative direction). The idea is to be able 1273 * to create a NetBSD partition on a disk we don't know 1274 * the translated geometry of. 1275 * This routine is only used for non-x86 systems or when we fail to 1276 * get the BIOS geometry from the kernel. 1277 */ 1278 void 1279 intuit_translated_geometry(void) 1280 { 1281 int xcylinders = -1, xheads = -1, xsectors = -1, i, j; 1282 unsigned int c1, h1, s1, c2, h2, s2; 1283 unsigned long a1, a2; 1284 uint64_t num, denom; 1285 1286 /* 1287 * The physical parameters may be invalid as bios geometry. 1288 * If we cannot determine the actual bios geometry, we are 1289 * better off picking a likely 'faked' geometry than leaving 1290 * the invalid physical one. 1291 */ 1292 1293 if (dos_cylinders > MAXCYL || dos_heads > MAXHEAD || 1294 dos_sectors > MAXSECTOR) { 1295 h1 = MAXHEAD - 1; 1296 c1 = MAXCYL - 1; 1297 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 1298 if (dl != NULL) { 1299 /* BIOS may use 256 heads or 1024 cylinders */ 1300 for (i = 0; i < dl->dl_nbiosdisks; i++) { 1301 if (h1 < dl->dl_biosdisks[i].bi_head) 1302 h1 = dl->dl_biosdisks[i].bi_head; 1303 if (c1 < dl->dl_biosdisks[i].bi_cyl) 1304 c1 = dl->dl_biosdisks[i].bi_cyl; 1305 } 1306 } 1307 #endif 1308 dos_sectors = MAXSECTOR; 1309 dos_heads = h1; 1310 dos_cylinders = disklabel.d_secperunit / (MAXSECTOR * h1); 1311 if (dos_cylinders > c1) 1312 dos_cylinders = c1; 1313 } 1314 1315 /* Try to deduce the number of heads from two different mappings. */ 1316 for (i = 0; i < MBR_PART_COUNT * 2 - 1; i++) { 1317 if (get_mapping(i, &c1, &h1, &s1, &a1) < 0) 1318 continue; 1319 a1 -= s1; 1320 for (j = i + 1; j < MBR_PART_COUNT * 2; j++) { 1321 if (get_mapping(j, &c2, &h2, &s2, &a2) < 0) 1322 continue; 1323 a2 -= s2; 1324 num = (uint64_t)h1 * a2 - (uint64_t)h2 * a1; 1325 denom = (uint64_t)c2 * a1 - (uint64_t)c1 * a2; 1326 if (denom != 0 && num % denom == 0) { 1327 xheads = num / denom; 1328 xsectors = a1 / (c1 * xheads + h1); 1329 break; 1330 } 1331 } 1332 if (xheads != -1) 1333 break; 1334 } 1335 1336 if (xheads == -1) { 1337 warnx("Cannot determine the number of heads"); 1338 return; 1339 } 1340 1341 /* Estimate the number of cylinders. */ 1342 xcylinders = disklabel.d_secperunit / xheads / xsectors; 1343 if (disklabel.d_secperunit > xcylinders * xheads * xsectors) 1344 xcylinders++; 1345 1346 /* 1347 * Now verify consistency with each of the partition table entries. 1348 * Be willing to shove cylinders up a little bit to make things work, 1349 * but translation mismatches are fatal. 1350 */ 1351 for (i = 0; i < MBR_PART_COUNT * 2; i++) { 1352 if (get_mapping(i, &c1, &h1, &s1, &a1) < 0) 1353 continue; 1354 if (c1 >= MAXCYL - 2) 1355 continue; 1356 if (xsectors * (c1 * xheads + h1) + s1 != a1) 1357 return; 1358 } 1359 1360 1361 /* Everything checks out. 1362 * Reset the geometry to use for further calculations. 1363 * But cylinders cannot be > 1024. 1364 */ 1365 if (xcylinders > MAXCYL) 1366 dos_cylinders = MAXCYL; 1367 else 1368 dos_cylinders = xcylinders; 1369 dos_heads = xheads; 1370 dos_sectors = xsectors; 1371 } 1372 1373 /* 1374 * For the purposes of intuit_translated_geometry(), treat the partition 1375 * table as a list of eight mapping between (cylinder, head, sector) 1376 * triplets and absolute sectors. Get the relevant geometry triplet and 1377 * absolute sectors for a given entry, or return -1 if it isn't present. 1378 * Note: for simplicity, the returned sector is 0-based. 1379 */ 1380 int 1381 get_mapping(int i, unsigned int *cylinder, unsigned int *head, unsigned int *sector, 1382 unsigned long *absolute) 1383 { 1384 struct mbr_partition *part = &mboot.mbr_parts[i / 2]; 1385 1386 if (part->mbrp_type == 0) 1387 return -1; 1388 if (i % 2 == 0) { 1389 *cylinder = MBR_PCYL(part->mbrp_scyl, part->mbrp_ssect); 1390 *head = part->mbrp_shd; 1391 *sector = MBR_PSECT(part->mbrp_ssect) - 1; 1392 *absolute = le32toh(part->mbrp_start); 1393 } else { 1394 *cylinder = MBR_PCYL(part->mbrp_ecyl, part->mbrp_esect); 1395 *head = part->mbrp_ehd; 1396 *sector = MBR_PSECT(part->mbrp_esect) - 1; 1397 *absolute = le32toh(part->mbrp_start) 1398 + le32toh(part->mbrp_size) - 1; 1399 } 1400 /* Sanity check the data against all zeroes */ 1401 if ((*cylinder == 0) && (*sector == 0) && (*head == 0)) 1402 return -1; 1403 /* Sanity check the data against max values */ 1404 if ((((*cylinder * MAXHEAD) + *head) * MAXSECTOR + *sector) < *absolute) 1405 /* cannot be a CHS mapping */ 1406 return -1; 1407 return 0; 1408 } 1409 1410 static void 1411 delete_ptn(int part) 1412 { 1413 if (part == ext.ptn_id) { 1414 /* forget all about the extended partition */ 1415 free(ext.ptn); 1416 memset(&ext, 0, sizeof ext); 1417 } 1418 1419 mboot.mbr_parts[part].mbrp_type = 0; 1420 } 1421 1422 static void 1423 delete_ext_ptn(int part) 1424 { 1425 1426 if (part == 0) { 1427 ext.ptn[0].mbr_parts[0].mbrp_type = 0; 1428 return; 1429 } 1430 ext.ptn[part - 1].mbr_parts[1] = ext.ptn[part].mbr_parts[1]; 1431 memmove(&ext.ptn[part], &ext.ptn[part + 1], 1432 (ext.num_ptn - part - 1) * sizeof ext.ptn[0]); 1433 ext.num_ptn--; 1434 } 1435 1436 static int 1437 add_ext_ptn(daddr_t start, daddr_t size) 1438 { 1439 int part; 1440 struct mbr_partition *partp; 1441 struct mbr_sector *nptn; 1442 1443 nptn = realloc(ext.ptn, (ext.num_ptn + 1) * sizeof *ext.ptn); 1444 if (!nptn) 1445 err(1, "realloc"); 1446 ext.ptn = nptn; 1447 for (part = 0; part < ext.num_ptn; part++) 1448 if (ext_offset(part) > start) 1449 break; 1450 /* insert before 'part' - make space... */ 1451 memmove(&ext.ptn[part + 1], &ext.ptn[part], 1452 (ext.num_ptn - part) * sizeof ext.ptn[0]); 1453 memset(&ext.ptn[part], 0, sizeof ext.ptn[0]); 1454 ext.ptn[part].mbr_magic = LE_MBR_MAGIC; 1455 /* we will be 'part' */ 1456 if (part == 0) { 1457 /* link us to 'next' */ 1458 partp = &ext.ptn[0].mbr_parts[1]; 1459 /* offset will be fixed by caller */ 1460 partp->mbrp_size = htole32( 1461 le32toh(ext.ptn[1].mbr_parts[0].mbrp_start) + 1462 le32toh(ext.ptn[1].mbr_parts[0].mbrp_size)); 1463 } else { 1464 /* link us to prev's next */ 1465 partp = &ext.ptn[part - 1].mbr_parts[1]; 1466 ext.ptn[part].mbr_parts[1] = *partp; 1467 /* and prev onto us */ 1468 partp->mbrp_start = htole32(start - dos_sectors - ext.base); 1469 partp->mbrp_size = htole32(size + dos_sectors); 1470 } 1471 partp->mbrp_type = 5; /* as used by win98 */ 1472 partp->mbrp_flag = 0; 1473 /* wallop in some CHS values - win98 doesn't saturate them */ 1474 dos(le32toh(partp->mbrp_start), 1475 &partp->mbrp_scyl, &partp->mbrp_shd, &partp->mbrp_ssect); 1476 dos(le32toh(partp->mbrp_start) + le32toh(partp->mbrp_size) - 1, 1477 &partp->mbrp_ecyl, &partp->mbrp_ehd, &partp->mbrp_esect); 1478 ext.num_ptn++; 1479 1480 return part; 1481 } 1482 1483 static const char * 1484 check_overlap(int part, int sysid, daddr_t start, daddr_t size, int fix) 1485 { 1486 int p; 1487 unsigned int p_s, p_e; 1488 1489 if (sysid != 0) { 1490 if (start < dos_sectors) 1491 return "Track zero is reserved for the BIOS"; 1492 if (start + size > disksectors) 1493 return "Partition exceeds size of disk"; 1494 for (p = 0; p < MBR_PART_COUNT; p++) { 1495 if (p == part || mboot.mbr_parts[p].mbrp_type == 0) 1496 continue; 1497 p_s = le32toh(mboot.mbr_parts[p].mbrp_start); 1498 p_e = p_s + le32toh(mboot.mbr_parts[p].mbrp_size); 1499 if (start + size <= p_s || start >= p_e) 1500 continue; 1501 if (f_flag) { 1502 if (fix) 1503 delete_ptn(p); 1504 return 0; 1505 } 1506 return "Overlaps another partition"; 1507 } 1508 } 1509 1510 /* Are we trying to create an extended partition */ 1511 if (!MBR_IS_EXTENDED(mboot.mbr_parts[part].mbrp_type)) { 1512 /* this wasn't the extended partition */ 1513 if (!MBR_IS_EXTENDED(sysid)) 1514 return 0; 1515 /* making an extended partition */ 1516 if (ext.base != 0) { 1517 if (!f_flag) 1518 return "There cannot be 2 extended partitions"; 1519 if (fix) 1520 delete_ptn(ext.ptn_id); 1521 } 1522 if (fix) { 1523 /* allocate a new extended partition */ 1524 ext.ptn = calloc(1, sizeof ext.ptn[0]); 1525 if (ext.ptn == NULL) 1526 err(1, "Malloc failed"); 1527 ext.ptn[0].mbr_magic = LE_MBR_MAGIC; 1528 ext.ptn_id = part; 1529 ext.base = start; 1530 ext.limit = start + size; 1531 ext.num_ptn = 1; 1532 } 1533 return 0; 1534 } 1535 1536 /* Check we haven't cut space allocated to an extended ptn */ 1537 1538 if (!MBR_IS_EXTENDED(sysid)) { 1539 /* no longer an extended partition */ 1540 if (fix) { 1541 /* Kill all memory of the extended partitions */ 1542 delete_ptn(part); 1543 return 0; 1544 } 1545 if (ext.num_ptn == 0 || 1546 (ext.num_ptn == 1 && ext.ptn[0].mbr_parts[0].mbrp_type == 0)) 1547 /* nothing in extended partition */ 1548 return 0; 1549 if (f_flag) 1550 return 0; 1551 if (yesno("Do you really want to delete all the extended partitions?")) 1552 return 0; 1553 return "Extended partition busy"; 1554 } 1555 1556 if (le32toh(mboot.mbr_parts[part].mbrp_start) != ext.base) 1557 /* maybe impossible, but an extra sanity check */ 1558 return 0; 1559 1560 for (p = ext.num_ptn; --p >= 0;) { 1561 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1562 continue; 1563 p_s = ext_offset(p); 1564 p_e = p_s + le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) 1565 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_size); 1566 if (p_s >= start && p_e <= start + size) 1567 continue; 1568 if (!f_flag) 1569 return "Extended partition outside main partition"; 1570 if (fix) 1571 delete_ext_ptn(p); 1572 } 1573 1574 if (fix && start != ext.base) { 1575 /* The internal offsets need to be fixed up */ 1576 for (p = 0; p < ext.num_ptn - 1; p++) 1577 ext.ptn[p].mbr_parts[1].mbrp_start = htole32( 1578 le32toh(ext.ptn[p].mbr_parts[1].mbrp_start) 1579 + ext.base - start); 1580 /* and maybe an empty partition at the start */ 1581 if (ext.ptn[0].mbr_parts[0].mbrp_type == 0) { 1582 if (le32toh(ext.ptn[0].mbr_parts[1].mbrp_start) == 0) { 1583 /* don't need the empty slot */ 1584 memmove(&ext.ptn[0], &ext.ptn[1], 1585 (ext.num_ptn - 1) * sizeof ext.ptn[0]); 1586 ext.num_ptn--; 1587 } 1588 } else { 1589 /* must create an empty slot */ 1590 add_ext_ptn(start, dos_sectors); 1591 ext.ptn[0].mbr_parts[1].mbrp_start = htole32(ext.base 1592 - start); 1593 } 1594 } 1595 if (fix) { 1596 ext.base = start; 1597 ext.limit = start + size; 1598 } 1599 return 0; 1600 } 1601 1602 static const char * 1603 check_ext_overlap(int part, int sysid, daddr_t start, daddr_t size, int fix) 1604 { 1605 int p; 1606 unsigned int p_s, p_e; 1607 1608 if (sysid == 0) 1609 return 0; 1610 1611 if (MBR_IS_EXTENDED(sysid)) 1612 return "Nested extended partitions are not allowed"; 1613 1614 /* allow one track at start for extended partition header */ 1615 start -= dos_sectors; 1616 size += dos_sectors; 1617 if (start < ext.base || start + size > ext.limit) 1618 return "Outside bounds of extended partition"; 1619 1620 if (f_flag && !fix) 1621 return 0; 1622 1623 for (p = ext.num_ptn; --p >= 0;) { 1624 if (p == part || ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1625 continue; 1626 p_s = ext_offset(p); 1627 p_e = p_s + le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) 1628 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_size); 1629 if (p == 0) 1630 p_s += le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) 1631 - dos_sectors; 1632 if (start < p_e && start + size > p_s) { 1633 if (!f_flag) 1634 return "Overlaps another extended partition"; 1635 if (fix) { 1636 if (part == -1) 1637 delete_ext_ptn(p); 1638 else 1639 /* must not change numbering yet */ 1640 ext.ptn[p].mbr_parts[0].mbrp_type = 0; 1641 } 1642 } 1643 } 1644 return 0; 1645 } 1646 1647 int 1648 change_part(int extended, int part, int sysid, daddr_t start, daddr_t size, 1649 char *bootmenu) 1650 { 1651 struct mbr_partition *partp; 1652 struct mbr_sector *boot; 1653 daddr_t offset; 1654 const char *e; 1655 int upart = part; 1656 int p; 1657 int fl; 1658 daddr_t n_s, n_e; 1659 const char *errtext; 1660 #ifdef BOOTSEL 1661 char tmp_bootmenu[MBR_PART_COUNT * (MBR_BS_PARTNAMESIZE + 1)]; 1662 int bootmenu_len = (extended ? MBR_PART_COUNT : 1) * (MBR_BS_PARTNAMESIZE + 1); 1663 #endif 1664 1665 if (extended) { 1666 if (part != -1 && part < ext.num_ptn) { 1667 boot = &ext.ptn[part]; 1668 partp = &boot->mbr_parts[0]; 1669 offset = ext_offset(part); 1670 } else { 1671 part = -1; 1672 boot = 0; 1673 partp = 0; 1674 offset = 0; 1675 } 1676 upart = 0; 1677 e = "E"; 1678 } else { 1679 boot = &mboot; 1680 partp = &boot->mbr_parts[part]; 1681 offset = 0; 1682 e = ""; 1683 } 1684 1685 if (!f_flag && part != -1) { 1686 printf("The data for partition %s%d is:\n", e, part); 1687 print_part(boot, upart, offset); 1688 } 1689 1690 #ifdef BOOTSEL 1691 if (bootmenu != NULL) 1692 strlcpy(tmp_bootmenu, bootmenu, bootmenu_len); 1693 else 1694 if (boot != NULL && boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC) 1695 strlcpy(tmp_bootmenu, 1696 boot->mbr_bootsel.mbrbs_nametab[upart], 1697 bootmenu_len); 1698 else 1699 tmp_bootmenu[0] = 0; 1700 #endif 1701 1702 if (!s_flag && partp != NULL) { 1703 /* values not specified, default to current ones */ 1704 sysid = partp->mbrp_type; 1705 start = offset + le32toh(partp->mbrp_start); 1706 size = le32toh(partp->mbrp_size); 1707 } 1708 1709 /* creating a new partition, default to free space */ 1710 if (!s_flag && sysid == 0 && extended) { 1711 /* non-extended partition */ 1712 start = ext.base; 1713 for (p = 0; p < ext.num_ptn; p++) { 1714 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1715 continue; 1716 n_s = ext_offset(p); 1717 if (n_s > start + dos_sectors) 1718 break; 1719 start = ext_offset(p) 1720 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) 1721 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_size); 1722 } 1723 if (ext.limit - start <= dos_sectors) { 1724 printf("No space in extended partition\n"); 1725 return 0; 1726 } 1727 start += dos_sectors; 1728 } 1729 1730 if (!s_flag && sysid == 0 && !extended) { 1731 /* same for non-extended partition */ 1732 /* first see if old start is free */ 1733 if (start < dos_sectors) 1734 start = 0; 1735 for (p = 0; start != 0 && p < MBR_PART_COUNT; p++) { 1736 if (mboot.mbr_parts[p].mbrp_type == 0) 1737 continue; 1738 n_s = le32toh(mboot.mbr_parts[p].mbrp_start); 1739 if (start >= n_s && 1740 start < n_s + le32toh(mboot.mbr_parts[p].mbrp_size)) 1741 start = 0; 1742 } 1743 if (start == 0) { 1744 /* Look for first gap */ 1745 start = dos_sectors; 1746 for (p = 0; p < MBR_PART_COUNT; p++) { 1747 if (mboot.mbr_parts[p].mbrp_type == 0) 1748 continue; 1749 n_s = le32toh(mboot.mbr_parts[p].mbrp_start); 1750 n_e = n_s + le32toh(mboot.mbr_parts[p].mbrp_size); 1751 if (start >= n_s && start < n_e) { 1752 start = n_e; 1753 p = -1; 1754 } 1755 } 1756 if (start >= disksectors) { 1757 printf("No free space\n"); 1758 return 0; 1759 } 1760 } 1761 } 1762 1763 if (!f_flag) { 1764 /* request new values from user */ 1765 if (sysid == 0) 1766 sysid = 169; 1767 sysid = decimal("sysid", sysid, 0, 0, 255); 1768 if (sysid == 0 && !v_flag) { 1769 start = 0; 1770 size = 0; 1771 #ifdef BOOTSEL 1772 tmp_bootmenu[0] = 0; 1773 #endif 1774 } else { 1775 daddr_t old = start; 1776 daddr_t lim = extended ? ext.limit : disksectors; 1777 start = decimal("start", start, 1778 DEC_SEC | DEC_RND_0 | (extended ? DEC_RND : 0), 1779 extended ? ext.base : 0, lim); 1780 /* Adjust 'size' so that end doesn't move when 'start' 1781 * is only changed slightly. 1782 */ 1783 if (size > start - old) 1784 size -= start - old; 1785 else 1786 size = 0; 1787 /* Find end of available space from this start point */ 1788 if (extended) { 1789 for (p = 0; p < ext.num_ptn; p++) { 1790 if (p == part) 1791 continue; 1792 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1793 continue; 1794 n_s = ext_offset(p); 1795 if (n_s > start && n_s < lim) 1796 lim = n_s; 1797 if (start >= n_s && start < n_s 1798 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_start) 1799 + le32toh(ext.ptn[p].mbr_parts[0].mbrp_size)) { 1800 lim = start; 1801 break; 1802 } 1803 } 1804 } else { 1805 for (p = 0; p < MBR_PART_COUNT; p++) { 1806 if (p == part) 1807 continue; 1808 if (mboot.mbr_parts[p].mbrp_type == 0) 1809 continue; 1810 n_s = le32toh(mboot.mbr_parts[p].mbrp_start); 1811 if (n_s > start && n_s < lim) 1812 lim = n_s; 1813 if (start >= n_s && start < n_s 1814 + le32toh(mboot.mbr_parts[p].mbrp_size)) { 1815 lim = start; 1816 break; 1817 } 1818 } 1819 } 1820 lim -= start; 1821 if (lim == 0) { 1822 printf("Start sector already allocated\n"); 1823 return 0; 1824 } 1825 if (size == 0 || size > lim) 1826 size = lim; 1827 fl = DEC_SEC; 1828 if (start % dos_cylindersectors == dos_sectors) 1829 fl |= DEC_RND_DOWN; 1830 if (start == 2 * dos_sectors) 1831 fl |= DEC_RND_DOWN | DEC_RND_DOWN_2; 1832 size = decimal("size", size, fl, 0, lim); 1833 #ifdef BOOTSEL 1834 #ifndef DEFAULT_BOOTEXTCODE 1835 if (!extended) 1836 #endif 1837 string("bootmenu", bootmenu_len, tmp_bootmenu); 1838 #endif 1839 } 1840 } 1841 1842 /* 1843 * Before we write these away, we must verify that nothing 1844 * untoward has been requested. 1845 */ 1846 1847 if (extended) 1848 errtext = check_ext_overlap(part, sysid, start, size, 0); 1849 else 1850 errtext = check_overlap(part, sysid, start, size, 0); 1851 if (errtext != NULL) { 1852 if (f_flag) 1853 errx(2, "%s\n", errtext); 1854 printf("%s\n", errtext); 1855 return 0; 1856 } 1857 1858 /* 1859 * Before proceeding, delete any overlapped partitions. 1860 * This can only happen if '-f' was supplied on the command line. 1861 * Just hope the caller knows what they are doing. 1862 * This also fixes the base of each extended partition if the 1863 * partition itself has moved. 1864 */ 1865 1866 if (extended) 1867 errtext = check_ext_overlap(part, sysid, start, size, 1); 1868 else 1869 errtext = check_overlap(part, sysid, start, size, 1); 1870 1871 if (errtext) 1872 errx(1, "%s\n", errtext); 1873 1874 if (sysid == 0) { 1875 /* delete this partition - save info though */ 1876 if (partp == NULL) 1877 /* must have been trying to create an extended ptn */ 1878 return 0; 1879 if (start == 0 && size == 0) 1880 memset(partp, 0, sizeof *partp); 1881 #ifdef BOOTSEL 1882 if (boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC) 1883 memset(boot->mbr_bootsel.mbrbs_nametab[upart], 0, 1884 sizeof boot->mbr_bootsel.mbrbs_nametab[0]); 1885 #endif 1886 if (extended) 1887 delete_ext_ptn(part); 1888 else 1889 delete_ptn(part); 1890 return 1; 1891 } 1892 1893 1894 if (extended) { 1895 if (part != -1) 1896 delete_ext_ptn(part); 1897 if (start == ext.base + dos_sectors) 1898 /* First one must have been free */ 1899 part = 0; 1900 else 1901 part = add_ext_ptn(start, size); 1902 1903 /* These must be re-calculated because of the realloc */ 1904 boot = &ext.ptn[part]; 1905 partp = &boot->mbr_parts[0]; 1906 offset = ext_offset(part); 1907 } 1908 1909 partp->mbrp_type = sysid; 1910 partp->mbrp_start = htole32( start - offset); 1911 partp->mbrp_size = htole32( size); 1912 dos(start, &partp->mbrp_scyl, &partp->mbrp_shd, &partp->mbrp_ssect); 1913 dos(start + size - 1, 1914 &partp->mbrp_ecyl, &partp->mbrp_ehd, &partp->mbrp_esect); 1915 #ifdef BOOTSEL 1916 if (extended) { 1917 boot->mbr_bootsel_magic = LE_MBR_BS_MAGIC; 1918 strncpy(boot->mbr_bootsel.mbrbs_nametab[upart], tmp_bootmenu, 1919 bootmenu_len); 1920 } else { 1921 /* We need to bootselect code installed in order to have 1922 * somewhere to safely write the menu tag. 1923 */ 1924 if (boot->mbr_bootsel_magic != LE_MBR_BS_MAGIC) { 1925 if (yesno("The bootselect code is not installed, " 1926 "do you want to install it now?")) 1927 install_bootsel(MBR_BS_ACTIVE); 1928 } 1929 if (boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC) { 1930 strncpy(boot->mbr_bootsel.mbrbs_nametab[upart], 1931 tmp_bootmenu, bootmenu_len); 1932 } 1933 } 1934 #endif 1935 1936 if (v_flag && !f_flag && yesno("Explicitly specify beg/end address?")) { 1937 /* this really isn't a good idea.... */ 1938 int tsector, tcylinder, thead; 1939 1940 tcylinder = MBR_PCYL(partp->mbrp_scyl, partp->mbrp_ssect); 1941 thead = partp->mbrp_shd; 1942 tsector = MBR_PSECT(partp->mbrp_ssect); 1943 tcylinder = decimal("beginning cylinder", 1944 tcylinder, 0, 0, dos_cylinders - 1); 1945 thead = decimal("beginning head", 1946 thead, 0, 0, dos_heads - 1); 1947 tsector = decimal("beginning sector", 1948 tsector, 0, 1, dos_sectors); 1949 partp->mbrp_scyl = DOSCYL(tcylinder); 1950 partp->mbrp_shd = thead; 1951 partp->mbrp_ssect = DOSSECT(tsector, tcylinder); 1952 1953 tcylinder = MBR_PCYL(partp->mbrp_ecyl, partp->mbrp_esect); 1954 thead = partp->mbrp_ehd; 1955 tsector = MBR_PSECT(partp->mbrp_esect); 1956 tcylinder = decimal("ending cylinder", 1957 tcylinder, 0, 0, dos_cylinders - 1); 1958 thead = decimal("ending head", 1959 thead, 0, 0, dos_heads - 1); 1960 tsector = decimal("ending sector", 1961 tsector, 0, 1, dos_sectors); 1962 partp->mbrp_ecyl = DOSCYL(tcylinder); 1963 partp->mbrp_ehd = thead; 1964 partp->mbrp_esect = DOSSECT(tsector, tcylinder); 1965 } 1966 1967 /* If we had to mark an extended partition as deleted because 1968 * another request would have overlapped it, now is the time 1969 * to do the actual delete. 1970 */ 1971 if (extended && f_flag) { 1972 for (p = ext.num_ptn; --p >= 0;) 1973 if (ext.ptn[p].mbr_parts[0].mbrp_type == 0) 1974 delete_ext_ptn(p); 1975 } 1976 return 1; 1977 } 1978 1979 void 1980 print_params(void) 1981 { 1982 1983 if (sh_flag) { 1984 printf("DISK=%s\n", disk); 1985 printf("DLCYL=%d\nDLHEAD=%d\nDLSEC=%d\nDLSIZE=%"PRIdaddr"\n", 1986 cylinders, heads, sectors, disksectors); 1987 printf("BCYL=%d\nBHEAD=%d\nBSEC=%d\nBDLSIZE=%"PRIdaddr"\n", 1988 dos_cylinders, dos_heads, dos_sectors, dos_disksectors); 1989 printf("NUMEXTPTN=%d\n", ext.num_ptn); 1990 return; 1991 } 1992 1993 /* Not sh_flag */ 1994 printf("Disk: %s\n", disk); 1995 printf("NetBSD disklabel disk geometry:\n"); 1996 printf("cylinders: %d, heads: %d, sectors/track: %d " 1997 "(%d sectors/cylinder)\ntotal sectors: %"PRIdaddr"\n\n", 1998 cylinders, heads, sectors, cylindersectors, disksectors); 1999 printf("BIOS disk geometry:\n"); 2000 printf("cylinders: %d, heads: %d, sectors/track: %d " 2001 "(%d sectors/cylinder)\ntotal sectors: %"PRIdaddr"\n\n", 2002 dos_cylinders, dos_heads, dos_sectors, dos_cylindersectors, 2003 dos_disksectors); 2004 } 2005 2006 void 2007 change_active(int which) 2008 { 2009 struct mbr_partition *partp; 2010 int part; 2011 int active = MBR_PART_COUNT; 2012 2013 partp = &mboot.mbr_parts[0]; 2014 2015 if (a_flag && which != -1) 2016 active = which; 2017 else { 2018 for (part = 0; part < MBR_PART_COUNT; part++) 2019 if (partp[part].mbrp_flag & MBR_PFLAG_ACTIVE) 2020 active = part; 2021 } 2022 if (!f_flag) { 2023 if (yesno("Do you want to change the active partition?")) { 2024 printf ("Choosing %d will make no partition active.\n", 2025 MBR_PART_COUNT); 2026 do { 2027 active = decimal("active partition", 2028 active, 0, 0, MBR_PART_COUNT); 2029 } while (!yesno("Are you happy with this choice?")); 2030 } else 2031 return; 2032 } else 2033 if (active != MBR_PART_COUNT) 2034 printf ("Making partition %d active.\n", active); 2035 2036 for (part = 0; part < MBR_PART_COUNT; part++) 2037 partp[part].mbrp_flag &= ~MBR_PFLAG_ACTIVE; 2038 if (active < MBR_PART_COUNT) 2039 partp[active].mbrp_flag |= MBR_PFLAG_ACTIVE; 2040 } 2041 2042 void 2043 get_params_to_use(void) 2044 { 2045 #if defined(__i386__) || defined(__x86_64__) 2046 struct biosdisk_info *bip; 2047 int i; 2048 #endif 2049 2050 if (b_flag) { 2051 dos_cylinders = b_cyl; 2052 dos_heads = b_head; 2053 dos_sectors = b_sec; 2054 return; 2055 } 2056 2057 print_params(); 2058 if (!yesno("Do you want to change our idea of what BIOS thinks?")) 2059 return; 2060 2061 #if (defined(__i386__) || defined(__x86_64__)) && !HAVE_NBTOOL_CONFIG_H 2062 if (dl != NULL) { 2063 for (i = 0; i < dl->dl_nbiosdisks; i++) { 2064 if (i == 0) 2065 printf("\nGeometries of known disks:\n"); 2066 bip = &dl->dl_biosdisks[i]; 2067 printf("Disk %d: cylinders %u, heads %u, sectors %u" 2068 " (%"PRIdaddr" sectors, %dMB)\n", 2069 i, bip->bi_cyl, bip->bi_head, bip->bi_sec, 2070 bip->bi_lbasecs, SEC_TO_MB(bip->bi_lbasecs)); 2071 2072 } 2073 printf("\n"); 2074 } 2075 #endif 2076 do { 2077 dos_cylinders = decimal("BIOS's idea of #cylinders", 2078 dos_cylinders, 0, 0, MAXCYL); 2079 dos_heads = decimal("BIOS's idea of #heads", 2080 dos_heads, 0, 0, MAXHEAD); 2081 dos_sectors = decimal("BIOS's idea of #sectors", 2082 dos_sectors, 0, 1, MAXSECTOR); 2083 print_params(); 2084 } while (!yesno("Are you happy with this choice?")); 2085 } 2086 2087 2088 /***********************************************\ 2089 * Change real numbers into strange dos numbers * 2090 \***********************************************/ 2091 void 2092 dos(int sector, unsigned char *cylinderp, unsigned char *headp, 2093 unsigned char *sectorp) 2094 { 2095 int cylinder, head; 2096 2097 cylinder = sector / dos_cylindersectors; 2098 sector -= cylinder * dos_cylindersectors; 2099 2100 head = sector / dos_sectors; 2101 sector -= head * dos_sectors; 2102 if (cylinder > 1023) 2103 cylinder = 1023; 2104 2105 *cylinderp = DOSCYL(cylinder); 2106 *headp = head; 2107 *sectorp = DOSSECT(sector + 1, cylinder); 2108 } 2109 2110 int 2111 open_disk(int update) 2112 { 2113 static char namebuf[MAXPATHLEN + 1]; 2114 2115 #if HAVE_NBTOOL_CONFIG_H 2116 strlcpy(namebuf, disk_file, sizeof(namebuf)); 2117 if ((fd = open(disk_file, update ? O_RDWR : O_RDONLY, 0)) == -1) { 2118 warn("%s", disk_file); 2119 return -1; 2120 } 2121 #else 2122 fd = opendisk(disk, update && disk_file == NULL ? O_RDWR : O_RDONLY, 2123 namebuf, sizeof(namebuf), 0); 2124 if (fd < 0) { 2125 if (errno == ENODEV) 2126 warnx("%s is not a character device", namebuf); 2127 else 2128 warn("%s", namebuf); 2129 return (-1); 2130 } 2131 #endif /* HAVE_NBTOOL_CONFIG_H */ 2132 disk = namebuf; 2133 if (get_params() == -1) { 2134 close(fd); 2135 fd = -1; 2136 return (-1); 2137 } 2138 if (disk_file != NULL) { 2139 /* for testing: read/write data from a disk file */ 2140 wfd = open(disk_file, update ? O_RDWR|O_CREAT : O_RDONLY, 0777); 2141 if (wfd == -1) { 2142 warn("%s", disk_file); 2143 close(fd); 2144 fd = -1; 2145 return -1; 2146 } 2147 } else 2148 wfd = fd; 2149 return (0); 2150 } 2151 2152 int 2153 read_disk(daddr_t sector, void *buf) 2154 { 2155 2156 if (*rfd == -1) 2157 errx(1, "read_disk(); fd == -1"); 2158 if (lseek(*rfd, sector * (off_t)512, 0) == -1) 2159 return (-1); 2160 return (read(*rfd, buf, 512)); 2161 } 2162 2163 int 2164 write_disk(daddr_t sector, void *buf) 2165 { 2166 2167 if (wfd == -1) 2168 errx(1, "write_disk(); wfd == -1"); 2169 if (lseek(wfd, sector * (off_t)512, 0) == -1) 2170 return (-1); 2171 return (write(wfd, buf, 512)); 2172 } 2173 2174 static void 2175 guess_geometry(daddr_t _sectors) 2176 { 2177 dos_sectors = MAXSECTOR; 2178 dos_heads = MAXHEAD - 1; /* some BIOS might use 256 */ 2179 dos_cylinders = _sectors / (MAXSECTOR * (MAXHEAD - 1)); 2180 if (dos_cylinders < 1) 2181 dos_cylinders = 1; 2182 else if (dos_cylinders > MAXCYL - 1) 2183 dos_cylinders = MAXCYL - 1; 2184 } 2185 2186 int 2187 get_params(void) 2188 { 2189 if (disk_type != NULL) { 2190 struct disklabel *tmplabel; 2191 2192 if ((tmplabel = getdiskbyname(disk_type)) == NULL) { 2193 warn("bad disktype"); 2194 return (-1); 2195 } 2196 disklabel = *tmplabel; 2197 } else if (F_flag) { 2198 struct stat st; 2199 if (fstat(fd, &st) == -1) { 2200 warn("fstat"); 2201 return (-1); 2202 } 2203 if (st.st_size % 512 != 0) { 2204 warnx("%s size (%lld) is not divisible " 2205 "by sector size (%d)", disk, (long long)st.st_size, 2206 512); 2207 } 2208 disklabel.d_secperunit = st.st_size / 512; 2209 guess_geometry(disklabel.d_secperunit); 2210 disklabel.d_ncylinders = dos_cylinders; 2211 disklabel.d_ntracks = dos_heads; 2212 disklabel.d_nsectors = dos_sectors; 2213 #if HAVE_NBTOOL_CONFIG_H 2214 } else { 2215 warnx("no disklabel specified"); 2216 return -1; 2217 } 2218 #else 2219 } else if (ioctl(fd, DIOCGDEFLABEL, &disklabel) == -1) { 2220 warn("DIOCGDEFLABEL"); 2221 if (ioctl(fd, DIOCGDINFO, &disklabel) == -1) { 2222 warn("DIOCGDINFO"); 2223 return (-1); 2224 } 2225 } 2226 #endif /* HAVE_NBTOOL_CONFIG_H */ 2227 disksectors = disklabel.d_secperunit; 2228 cylinders = disklabel.d_ncylinders; 2229 heads = disklabel.d_ntracks; 2230 sectors = disklabel.d_nsectors; 2231 2232 /* pick up some defaults for the BIOS sizes */ 2233 if (sectors <= MAXSECTOR) { 2234 dos_cylinders = cylinders; 2235 dos_heads = heads; 2236 dos_sectors = sectors; 2237 } else { 2238 /* guess - has to better than the above */ 2239 guess_geometry(disksectors); 2240 } 2241 dos_disksectors = disksectors; 2242 2243 return (0); 2244 } 2245 2246 #ifdef BOOTSEL 2247 /* 2248 * Rather unfortunately the bootsel 'magic' number is at the end of the 2249 * the structure, and there is no checksum. So when other operating 2250 * systems install mbr code by only writing the length of their code they 2251 * can overwrite part of the structure but keeping the magic number intact. 2252 * This code attempts to empirically detect this problem. 2253 */ 2254 static int 2255 validate_bootsel(struct mbr_bootsel *mbs) 2256 { 2257 unsigned int key = mbs->mbrbs_defkey; 2258 unsigned int tmo; 2259 int i; 2260 2261 if (v_flag) 2262 return 0; 2263 2264 /* 2265 * Check default key is sane 2266 * - this is the most likely field to be stuffed 2267 * 12 disks and 12 bootable partitions seems enough! 2268 * (the keymap decode starts falling apart at that point) 2269 */ 2270 if (key != 0 && !(key == SCAN_ENTER 2271 || (key >= SCAN_1 && key < SCAN_1 + 12) 2272 || (key >= SCAN_F1 && key < SCAN_F1 + 12))) 2273 return 1; 2274 2275 /* Checking the flags will lead to breakage... */ 2276 2277 /* Timeout value is expecyed to be a multiple of a second */ 2278 tmo = htole16(mbs->mbrbs_timeo); 2279 if (tmo != 0 && tmo != 0xffff && tmo != (10 * tmo + 9) / 182 * 182 / 10) 2280 return 2; 2281 2282 /* Check the menu strings are printable */ 2283 /* Unfortunately they aren't zero filled... */ 2284 for (i = 0; i < sizeof(mbs->mbrbs_nametab); i++) { 2285 int c = (uint8_t)mbs->mbrbs_nametab[0][i]; 2286 if (c == 0 || isprint(c)) 2287 continue; 2288 return 3; 2289 } 2290 2291 return 0; 2292 } 2293 #endif 2294 2295 int 2296 read_s0(daddr_t offset, struct mbr_sector *boot) 2297 { 2298 const char *tabletype = offset ? "extended" : "primary"; 2299 #ifdef BOOTSEL 2300 static int reported; 2301 #endif 2302 2303 if (read_disk(offset, boot) == -1) { 2304 warn("Can't read %s partition table", tabletype); 2305 return -1; 2306 } 2307 if (boot->mbr_magic != LE_MBR_MAGIC) { 2308 warnx("%s partition table invalid, " 2309 "no magic in sector %"PRIdaddr, tabletype, offset); 2310 return -1; 2311 2312 } 2313 #ifdef BOOTSEL 2314 if (boot->mbr_bootsel_magic == LE_MBR_BS_MAGIC) { 2315 /* mbr_bootsel in new location */ 2316 if (validate_bootsel(&boot->mbr_bootsel)) { 2317 warnx("removing corrupt bootsel information"); 2318 boot->mbr_bootsel_magic = 0; 2319 } 2320 return 0; 2321 } 2322 if (boot->mbr_bootsel_magic != LE_MBR_MAGIC) 2323 return 0; 2324 2325 /* mbr_bootsel in old location */ 2326 if (!reported) 2327 warnx("%s partition table: using old-style bootsel information", 2328 tabletype); 2329 reported = 1; 2330 if (validate_bootsel((void *)((uint8_t *)boot + MBR_BS_OFFSET + 4))) { 2331 warnx("%s bootsel information corrupt - ignoring", tabletype); 2332 return 0; 2333 } 2334 memmove((uint8_t *)boot + MBR_BS_OFFSET, 2335 (uint8_t *)boot + MBR_BS_OFFSET + 4, 2336 sizeof(struct mbr_bootsel)); 2337 if ( ! (boot->mbr_bootsel.mbrbs_flags & MBR_BS_NEWMBR)) { 2338 /* old style default key */ 2339 int id; 2340 /* F1..F4 => ptn 0..3, F5+ => disk 0+ */ 2341 id = boot->mbr_bootsel.mbrbs_defkey; 2342 id -= SCAN_F1; 2343 if (id >= MBR_PART_COUNT) 2344 id -= MBR_PART_COUNT; /* Use number of disk */ 2345 else if (mboot.mbr_parts[id].mbrp_type != 0) 2346 id = le32toh(boot->mbr_parts[id].mbrp_start); 2347 else 2348 id = DEFAULT_ACTIVE; 2349 boot->mbr_bootsel.mbrbs_defkey = id; 2350 } 2351 boot->mbr_bootsel_magic = LE_MBR_BS_MAGIC; 2352 /* highlight that new bootsel code is necessary */ 2353 boot->mbr_bootsel.mbrbs_flags &= ~MBR_BS_NEWMBR; 2354 #endif /* BOOTSEL */ 2355 return 0; 2356 } 2357 2358 int 2359 write_mbr(void) 2360 { 2361 int flag, i; 2362 daddr_t offset; 2363 int rval = -1; 2364 2365 /* 2366 * write enable label sector before write (if necessary), 2367 * disable after writing. 2368 * needed if the disklabel protected area also protects 2369 * sector 0. (e.g. empty disk) 2370 */ 2371 flag = 1; 2372 #if !HAVE_NBTOOL_CONFIG_H 2373 if (wfd == fd && F_flag == 0 && ioctl(wfd, DIOCWLABEL, &flag) < 0) 2374 warn("DIOCWLABEL"); 2375 #endif /* HAVE_NBTOOL_CONFIG_H */ 2376 if (write_disk(0, &mboot) == -1) { 2377 warn("Can't write fdisk partition table"); 2378 goto protect_label; 2379 } 2380 if (boot_installed) 2381 for (i = bootsize; (i -= 0x200) > 0;) 2382 if (write_disk(i / 0x200, &bootcode[i / 0x200]) == -1) { 2383 warn("Can't write bootcode"); 2384 goto protect_label; 2385 } 2386 for (offset = 0, i = 0; i < ext.num_ptn; i++) { 2387 if (write_disk(ext.base + offset, ext.ptn + i) == -1) { 2388 warn("Can't write %dth extended partition", i); 2389 goto protect_label; 2390 } 2391 offset = le32toh(ext.ptn[i].mbr_parts[1].mbrp_start); 2392 } 2393 rval = 0; 2394 protect_label: 2395 #if !HAVE_NBTOOL_CONFIG_H 2396 flag = 0; 2397 if (wfd == fd && F_flag == 0 && ioctl(wfd, DIOCWLABEL, &flag) < 0) 2398 warn("DIOCWLABEL"); 2399 #endif /* HAVE_NBTOOL_CONFIG_H */ 2400 return rval; 2401 } 2402 2403 int 2404 yesno(const char *str, ...) 2405 { 2406 int ch, first; 2407 va_list ap; 2408 2409 va_start(ap, str); 2410 2411 vprintf(str, ap); 2412 printf(" [n] "); 2413 2414 first = ch = getchar(); 2415 while (ch != '\n' && ch != EOF) 2416 ch = getchar(); 2417 if (ch == EOF) 2418 errx(1, "EOF"); 2419 return (first == 'y' || first == 'Y'); 2420 } 2421 2422 int 2423 decimal(const char *prompt, int dflt, int flags, int minval, int maxval) 2424 { 2425 int acc = 0; 2426 char *cp; 2427 char ch; 2428 2429 for (;;) { 2430 if (flags & DEC_SEC) { 2431 printf("%s: [%d..%dcyl default: %d, %dcyl, %uMB] ", 2432 prompt, SEC_TO_CYL(minval), SEC_TO_CYL(maxval), 2433 dflt, SEC_TO_CYL(dflt), SEC_TO_MB(dflt)); 2434 } else 2435 printf("%s: [%d..%d default: %d] ", 2436 prompt, minval, maxval, dflt); 2437 2438 if (!fgets(lbuf, LBUF, stdin)) 2439 errx(1, "EOF"); 2440 lbuf[strlen(lbuf)-1] = '\0'; 2441 cp = lbuf; 2442 2443 cp += strspn(cp, " \t"); 2444 if (*cp == '\0') 2445 return dflt; 2446 2447 if (cp[0] == '$' && cp[1] == 0) 2448 return maxval; 2449 2450 if (isdigit((unsigned char)*cp) || *cp == '-') { 2451 acc = strtol(lbuf, &cp, 10); 2452 if (flags & DEC_SEC) { 2453 ch = *cp; 2454 if (ch == 'g' || ch == 'G') { 2455 acc *= 1024; 2456 ch = 'm'; 2457 } 2458 if (ch == 'm' || ch == 'M') { 2459 acc *= SEC_IN_1M; 2460 /* round to whole number of cylinders */ 2461 acc += dos_cylindersectors / 2; 2462 acc /= dos_cylindersectors; 2463 ch = 'c'; 2464 } 2465 if (ch == 'c' || ch == 'C') { 2466 cp++; 2467 acc *= dos_cylindersectors; 2468 /* adjustments for cylinder boundary */ 2469 if (acc == 0 && flags & DEC_RND_0) 2470 acc += dos_sectors; 2471 if (flags & DEC_RND) 2472 acc += dos_sectors; 2473 if (flags & DEC_RND_DOWN) 2474 acc -= dos_sectors; 2475 if (flags & DEC_RND_DOWN_2) 2476 acc -= dos_sectors; 2477 } 2478 } 2479 } 2480 2481 cp += strspn(cp, " \t"); 2482 if (*cp != '\0') { 2483 printf("%s is not a valid %s number.\n", lbuf, 2484 flags & DEC_SEC ? "sector" : "decimal"); 2485 continue; 2486 } 2487 2488 if (acc >= minval && acc <= maxval) 2489 return acc; 2490 printf("%d is not between %d and %d.\n", acc, minval, maxval); 2491 } 2492 } 2493 2494 int 2495 ptn_id(const char *prompt, int *extended) 2496 { 2497 unsigned int acc = 0; 2498 char *cp; 2499 2500 for (;; printf("%s is not a valid partition number.\n", lbuf)) { 2501 printf("%s: [none] ", prompt); 2502 2503 if (!fgets(lbuf, LBUF, stdin)) 2504 errx(1, "EOF"); 2505 lbuf[strlen(lbuf)-1] = '\0'; 2506 cp = lbuf; 2507 2508 cp += strspn(cp, " \t"); 2509 *extended = 0; 2510 if (*cp == 0) 2511 return -1; 2512 2513 if (*cp == 'E' || *cp == 'e') { 2514 cp++; 2515 *extended = 1; 2516 } 2517 2518 acc = strtoul(cp, &cp, 10); 2519 2520 cp += strspn(cp, " \t"); 2521 if (*cp != '\0') 2522 continue; 2523 2524 if (*extended || acc < MBR_PART_COUNT) 2525 return acc; 2526 } 2527 } 2528 2529 #ifdef BOOTSEL 2530 void 2531 string(const char *prompt, int length, char *buf) 2532 { 2533 int len; 2534 2535 for (;;) { 2536 printf("%s: [%.*s] ", prompt, length, buf); 2537 2538 if (!fgets(lbuf, LBUF, stdin)) 2539 errx(1, "EOF"); 2540 len = strlen(lbuf); 2541 if (len <= 1) 2542 /* unchanged if just <enter> */ 2543 return; 2544 /* now strip trailing spaces, <space><enter> deletes string */ 2545 do 2546 lbuf[--len] = 0; 2547 while (len != 0 && lbuf[len - 1] == ' '); 2548 if (len < length) 2549 break; 2550 printf("'%s' is longer than %d characters.\n", 2551 lbuf, length - 1); 2552 } 2553 strncpy(buf, lbuf, length); 2554 } 2555 #endif 2556 2557 int 2558 type_match(const void *key, const void *item) 2559 { 2560 const int *idp = key; 2561 const struct mbr_ptype *ptr = item; 2562 2563 if (*idp < ptr->id) 2564 return (-1); 2565 if (*idp > ptr->id) 2566 return (1); 2567 return (0); 2568 } 2569 2570 const char * 2571 get_type(int type) 2572 { 2573 struct mbr_ptype *ptr; 2574 2575 ptr = bsearch(&type, mbr_ptypes, KNOWN_SYSIDS, 2576 sizeof(mbr_ptypes[0]), type_match); 2577 if (ptr == 0) 2578 return ("unknown"); 2579 return (ptr->name); 2580 } 2581