1 /* $NetBSD: i386.c,v 1.39 2012/04/06 10:10:11 gson Exp $ */ 2 3 /*- 4 * Copyright (c) 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by David Laight. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #if HAVE_NBTOOL_CONFIG_H 33 #include "nbtool_config.h" 34 #endif 35 36 #include <sys/cdefs.h> 37 #if !defined(__lint) 38 __RCSID("$NetBSD: i386.c,v 1.39 2012/04/06 10:10:11 gson Exp $"); 39 #endif /* !__lint */ 40 41 #include <sys/param.h> 42 #ifndef HAVE_NBTOOL_CONFIG_H 43 #include <sys/ioctl.h> 44 #include <sys/dkio.h> 45 #endif 46 47 #include <assert.h> 48 #include <errno.h> 49 #include <err.h> 50 #include <md5.h> 51 #include <stddef.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <unistd.h> 56 57 #include "installboot.h" 58 59 static const struct console_name { 60 const char *name; /* Name of console selection */ 61 const int dev; /* value matching CONSDEV_* from sys/arch/i386/stand/lib/libi386.h */ 62 } consoles[] = { 63 { "pc", 0 /* CONSDEV_PC */ }, 64 { "com0", 1 /* CONSDEV_COM0 */ }, 65 { "com1", 2 /* CONSDEV_COM1 */ }, 66 { "com2", 3 /* CONSDEV_COM2 */ }, 67 { "com3", 4 /* CONSDEV_COM3 */ }, 68 { "com0kbd", 5 /* CONSDEV_COM0KBD */ }, 69 { "com1kbd", 6 /* CONSDEV_COM1KBD */ }, 70 { "com2kbd", 7 /* CONSDEV_COM2KBD */ }, 71 { "com3kbd", 8 /* CONSDEV_COM3KBD */ }, 72 { "auto", -1 /* CONSDEV_AUTO */ }, 73 }; 74 75 static int i386_setboot(ib_params *); 76 static int i386_editboot(ib_params *); 77 78 struct ib_mach ib_mach_i386 = 79 { "i386", i386_setboot, no_clearboot, i386_editboot, 80 IB_RESETVIDEO | IB_CONSOLE | IB_CONSPEED | IB_CONSADDR | 81 IB_KEYMAP | IB_PASSWORD | IB_TIMEOUT | 82 IB_MODULES | IB_BOOTCONF | 83 IB_STAGE1START }; 84 85 struct ib_mach ib_mach_amd64 = 86 { "amd64", i386_setboot, no_clearboot, i386_editboot, 87 IB_RESETVIDEO | IB_CONSOLE | IB_CONSPEED | IB_CONSADDR | 88 IB_KEYMAP | IB_PASSWORD | IB_TIMEOUT | 89 IB_MODULES | IB_BOOTCONF | 90 IB_STAGE1START }; 91 92 /* 93 * Attempting to write the 'labelsector' (or a sector near it - within 8k?) 94 * using the non-raw disk device fails silently. This can be detected (today) 95 * by doing a fsync() and a read back. 96 * This is very likely to affect installboot, indeed the code may need to 97 * be written into the 'labelsector' itself - especially on non-512 byte media. 98 * We do all writes with a read verify. 99 * If EROFS is returned we also try to enable writes to the label sector. 100 * (Maybe these functions should be in the generic part of installboot.) 101 */ 102 static int 103 pwrite_validate(int fd, const void *buf, size_t n_bytes, off_t offset) 104 { 105 void *r_buf; 106 ssize_t rv; 107 108 r_buf = malloc(n_bytes); 109 if (r_buf == NULL) 110 return -1; 111 rv = pwrite(fd, buf, n_bytes, offset); 112 if (rv == -1) { 113 free(r_buf); 114 return -1; 115 } 116 fsync(fd); 117 if (pread(fd, r_buf, rv, offset) == rv && memcmp(r_buf, buf, rv) == 0) { 118 free(r_buf); 119 return rv; 120 } 121 free(r_buf); 122 errno = EROFS; 123 return -1; 124 } 125 126 static int 127 write_boot_area(ib_params *params, uint8_t *buf, size_t len) 128 { 129 int rv, i; 130 131 /* 132 * Writing the 'label' sector (likely to be bytes 512-1023) could 133 * fail, so we try to avoid writing that area. 134 * Unfortunately, if we are accessing the raw disk, and the sector 135 * size is larger than 512 bytes that is also doomed. 136 * See how we get on.... 137 * 138 * NB: Even if the physical sector size is not 512, the space for 139 * the label is 512 bytes from the start of the disk. 140 * So all the '512' constants in these functions are correct. 141 */ 142 143 /* Write out first 512 bytes - the pbr code */ 144 rv = pwrite_validate(params->fsfd, buf, 512, 0); 145 if (rv == 512) { 146 /* That worked, do the rest */ 147 if (len == 512) 148 return 1; 149 len -= 512 * 2; 150 rv = pwrite_validate(params->fsfd, buf + 512 * 2, len, 512 * 2); 151 if (rv != (ssize_t)len) 152 goto bad_write; 153 return 1; 154 } 155 if (rv != -1 || (errno != EINVAL && errno != EROFS)) 156 goto bad_write; 157 158 if (errno == EINVAL) { 159 /* Assume the failure was due to to the sector size > 512 */ 160 rv = pwrite_validate(params->fsfd, buf, len, 0); 161 if (rv == (ssize_t)len) 162 return 1; 163 if (rv != -1 || (errno != EROFS)) 164 goto bad_write; 165 } 166 167 #ifdef DIOCWLABEL 168 /* Pesky label is protected, try to unprotect it */ 169 i = 1; 170 rv = ioctl(params->fsfd, DIOCWLABEL, &i); 171 if (rv != 0) { 172 warn("Cannot enable writes to the label sector"); 173 return 0; 174 } 175 /* Try again with label write-enabled */ 176 rv = pwrite_validate(params->fsfd, buf, len, 0); 177 178 /* Reset write-protext */ 179 i = 0; 180 ioctl(params->fsfd, DIOCWLABEL, &i); 181 if (rv == (ssize_t)len) 182 return 1; 183 #endif 184 185 bad_write: 186 if (rv == -1) 187 warn("Writing `%s'", params->filesystem); 188 else 189 warnx("Writing `%s': short write, %u bytes", 190 params->filesystem, rv); 191 return 0; 192 } 193 194 static void 195 show_i386_boot_params(struct x86_boot_params *bpp) 196 { 197 size_t i; 198 199 printf("Boot options: "); 200 printf("timeout %d, ", le32toh(bpp->bp_timeout)); 201 printf("flags %x, ", le32toh(bpp->bp_flags)); 202 printf("speed %d, ", le32toh(bpp->bp_conspeed)); 203 printf("ioaddr %x, ", le32toh(bpp->bp_consaddr)); 204 for (i = 0; i < __arraycount(consoles); i++) { 205 if (consoles[i].dev == (int)le32toh(bpp->bp_consdev)) 206 break; 207 } 208 if (i == __arraycount(consoles)) 209 printf("console %d\n", le32toh(bpp->bp_consdev)); 210 else 211 printf("console %s\n", consoles[i].name); 212 if (bpp->bp_keymap[0]) 213 printf(" keymap %s\n", bpp->bp_keymap); 214 } 215 216 static int 217 is_zero(const uint8_t *p, unsigned int len) 218 { 219 return len == 0 || (p[0] == 0 && memcmp(p, p + 1, len - 1) == 0); 220 } 221 222 static int 223 update_i386_boot_params(ib_params *params, struct x86_boot_params *bpp) 224 { 225 struct x86_boot_params bp; 226 uint32_t bplen; 227 size_t i; 228 229 bplen = le32toh(bpp->bp_length); 230 if (bplen > sizeof bp) 231 /* Ignore pad space in bootxx */ 232 bplen = sizeof bp; 233 234 /* Take (and update) local copy so we handle size mismatches */ 235 memset(&bp, 0, sizeof bp); 236 memcpy(&bp, bpp, bplen); 237 238 if (params->flags & IB_TIMEOUT) 239 bp.bp_timeout = htole32(params->timeout); 240 if (params->flags & IB_RESETVIDEO) 241 bp.bp_flags ^= htole32(X86_BP_FLAGS_RESET_VIDEO); 242 if (params->flags & IB_CONSPEED) 243 bp.bp_conspeed = htole32(params->conspeed); 244 if (params->flags & IB_CONSADDR) 245 bp.bp_consaddr = htole32(params->consaddr); 246 if (params->flags & IB_CONSOLE) { 247 for (i = 0; i < __arraycount(consoles); i++) 248 if (strcmp(consoles[i].name, params->console) == 0) 249 break; 250 251 if (i == __arraycount(consoles)) { 252 warnx("invalid console name, valid names are:"); 253 (void)fprintf(stderr, "\t%s", consoles[0].name); 254 for (i = 1; i < __arraycount(consoles); i++) 255 (void)fprintf(stderr, ", %s", consoles[i].name); 256 (void)fprintf(stderr, "\n"); 257 return 1; 258 } 259 bp.bp_consdev = htole32(consoles[i].dev); 260 } 261 if (params->flags & IB_PASSWORD) { 262 if (params->password[0]) { 263 MD5_CTX md5ctx; 264 MD5Init(&md5ctx); 265 MD5Update(&md5ctx, params->password, 266 strlen(params->password)); 267 MD5Final(bp.bp_password, &md5ctx); 268 bp.bp_flags |= htole32(X86_BP_FLAGS_PASSWORD); 269 } else { 270 memset(&bp.bp_password, 0, sizeof bp.bp_password); 271 bp.bp_flags &= ~htole32(X86_BP_FLAGS_PASSWORD); 272 } 273 } 274 if (params->flags & IB_KEYMAP) 275 strlcpy(bp.bp_keymap, params->keymap, sizeof bp.bp_keymap); 276 if (params->flags & IB_MODULES) 277 bp.bp_flags ^= htole32(X86_BP_FLAGS_NOMODULES); 278 if (params->flags & IB_BOOTCONF) 279 bp.bp_flags ^= htole32(X86_BP_FLAGS_NOBOOTCONF); 280 281 if (params->flags & (IB_NOWRITE | IB_VERBOSE)) 282 show_i386_boot_params(&bp); 283 284 /* Check we aren't trying to set anything we can't save */ 285 if (!is_zero((char *)&bp + bplen, sizeof bp - bplen)) { 286 warnx("Patch area in stage1 bootstrap is too small"); 287 return 1; 288 } 289 memcpy(bpp, &bp, bplen); 290 return 0; 291 } 292 293 static int 294 i386_setboot(ib_params *params) 295 { 296 unsigned int u; 297 ssize_t rv; 298 uint32_t *magic, expected_magic; 299 union { 300 struct mbr_sector mbr; 301 uint8_t b[8192]; 302 } disk_buf, bootstrap; 303 304 assert(params != NULL); 305 assert(params->fsfd != -1); 306 assert(params->filesystem != NULL); 307 assert(params->s1fd != -1); 308 assert(params->stage1 != NULL); 309 310 /* 311 * There is only 8k of space in a FFSv1 partition (and ustarfs) 312 * so ensure we don't splat over anything important. 313 */ 314 if (params->s1stat.st_size > (off_t)(sizeof bootstrap)) { 315 warnx("stage1 bootstrap `%s' (%u bytes) is larger than 8192 bytes", 316 params->stage1, (unsigned int)params->s1stat.st_size); 317 return 0; 318 } 319 if (params->s1stat.st_size < 3 * 512 && params->s1stat.st_size != 512) { 320 warnx("stage1 bootstrap `%s' (%u bytes) is too small", 321 params->stage1, (unsigned int)params->s1stat.st_size); 322 return 0; 323 } 324 325 /* Read in the existing disk header and boot code */ 326 rv = pread(params->fsfd, &disk_buf, sizeof (disk_buf), 0); 327 if (rv != sizeof(disk_buf)) { 328 if (rv == -1) 329 warn("Reading `%s'", params->filesystem); 330 else 331 warnx("Reading `%s': short read, %ld bytes" 332 " (should be %ld)", params->filesystem, (long)rv, 333 (long)sizeof(disk_buf)); 334 return 0; 335 } 336 337 if (disk_buf.mbr.mbr_magic != le16toh(MBR_MAGIC)) { 338 if (params->flags & IB_VERBOSE) { 339 printf( 340 "Ignoring PBR with invalid magic in sector 0 of `%s'\n", 341 params->filesystem); 342 } 343 memset(&disk_buf, 0, 512); 344 } 345 346 /* Read the new bootstrap code. */ 347 rv = pread(params->s1fd, &bootstrap, params->s1stat.st_size, 0); 348 if (rv != params->s1stat.st_size) { 349 if (rv == -1) 350 warn("Reading `%s'", params->stage1); 351 else 352 warnx("Reading `%s': short read, %ld bytes" 353 " (should be %ld)", params->stage1, (long)rv, 354 (long)params->s1stat.st_size); 355 return 0; 356 } 357 358 /* 359 * The bootstrap code is either 512 bytes for booting FAT16, or best 360 * part of 8k (with bytes 512-1023 all zeros). 361 */ 362 if (params->s1stat.st_size == 512) { 363 /* Magic number is at end of pbr code */ 364 magic = (void *)(bootstrap.b + 512 - 16 + 4); 365 expected_magic = htole32(X86_BOOT_MAGIC_FAT); 366 } else { 367 /* Magic number is at start of sector following label */ 368 magic = (void *)(bootstrap.b + 512 * 2 + 4); 369 expected_magic = htole32(X86_BOOT_MAGIC_1); 370 /* 371 * For a variety of reasons we restrict our 'normal' partition 372 * boot code to a size which enable it to be used as mbr code. 373 * IMHO this is bugus (dsl). 374 */ 375 if (!is_zero(bootstrap.b + 512-2-64, 64)) { 376 warnx("Data in mbr partition table of new bootstrap"); 377 return 0; 378 } 379 if (!is_zero(bootstrap.b + 512, 512)) { 380 warnx("Data in label part of new bootstrap"); 381 return 0; 382 } 383 /* Copy mbr table and label from existing disk buffer */ 384 memcpy(bootstrap.b + 512-2-64, disk_buf.b + 512-2-64, 64); 385 memcpy(bootstrap.b + 512, disk_buf.b + 512, 512); 386 } 387 388 /* Validate the 'magic number' that marks the parameter block */ 389 if (*magic != expected_magic) { 390 warnx("Invalid magic in stage1 bootstrap %x != %x", 391 *magic, expected_magic); 392 return 0; 393 } 394 395 /* 396 * If the partition has a FAT (or NTFS) filesystem, then we must 397 * preserve the BIOS Parameter Block (BPB). 398 * It is also very likely that there isn't 8k of space available 399 * for (say) bootxx_msdos, and that blindly installing it will trash 400 * the FAT filesystem. 401 * To avoid this we check the number of 'reserved' sectors to ensure 402 * there there is enough space. 403 * Unfortunately newfs(8) doesn't (yet) splat the BPB (which is 404 * effectively the FAT superblock) when a filesystem is initailised 405 * so this code tends to complain rather too often, 406 * Specifying 'installboot -f' will delete the old BPB info. 407 */ 408 if (!(params->flags & IB_FORCE)) { 409 #define USE_F ", use -f (may invalidate filesystem)" 410 /* 411 * For FAT compatibility, the pbr code starts 'jmp xx; nop' 412 * followed by the BIOS Parameter Block (BPB). 413 * The 2nd byte (jump offset) is the size of the nop + BPB. 414 */ 415 if (bootstrap.b[0] != 0xeb || bootstrap.b[2] != 0x90) { 416 warnx("No BPB in new bootstrap %02x:%02x:%02x" USE_F, 417 bootstrap.b[0], bootstrap.b[1], bootstrap.b[2]); 418 return 0; 419 } 420 421 /* Find size of old BPB, and copy into new bootcode */ 422 if (!is_zero(disk_buf.b + 3 + 8, disk_buf.b[1] - 1 - 8)) { 423 struct mbr_bpbFAT16 *bpb = (void *)(disk_buf.b + 3 + 8); 424 /* Check enough space before the FAT for the bootcode */ 425 u = le16toh(bpb->bpbBytesPerSec) 426 * le16toh(bpb->bpbResSectors); 427 if (u != 0 && u < params->s1stat.st_size) { 428 warnx("Insufficient reserved space before FAT " 429 "(%u bytes available)" USE_F, u); 430 return 0; 431 } 432 /* Check we have enough space for the old bpb */ 433 if (disk_buf.b[1] > bootstrap.b[1]) { 434 /* old BPB is larger, allow if extra zeros */ 435 if (!is_zero(disk_buf.b + 2 + bootstrap.b[1], 436 disk_buf.b[1] - bootstrap.b[1])) { 437 warnx("Old BPB too big" USE_F); 438 return 0; 439 } 440 u = bootstrap.b[1]; 441 } else { 442 /* Old BPB is shorter, leave zero filled */ 443 u = disk_buf.b[1]; 444 } 445 if (params->s1start != 0) 446 /* Fixup physical offset of filesytem */ 447 bpb->bpbHiddenSecs = htole32(params->s1start); 448 memcpy(bootstrap.b + 2, disk_buf.b + 2, u); 449 } 450 #undef USE_F 451 } 452 453 /* 454 * Fill in any user-specified options into the 455 * struct x86_boot_params 456 * that follows the magic number. 457 * See sys/arch/i386/stand/bootxx/bootxx.S for more information. 458 */ 459 if (update_i386_boot_params(params, (void *)(magic + 1))) 460 return 0; 461 462 if (params->flags & IB_NOWRITE) { 463 return 1; 464 } 465 466 /* Copy new bootstrap data into disk buffer, ignoring label area */ 467 memcpy(&disk_buf, &bootstrap, 512); 468 if (params->s1stat.st_size > 512 * 2) { 469 memcpy(disk_buf.b + 2 * 512, bootstrap.b + 2 * 512, 470 params->s1stat.st_size - 2 * 512); 471 /* Zero pad to 512 byte sector boundary */ 472 memset(disk_buf.b + params->s1stat.st_size, 0, 473 (8192 - params->s1stat.st_size) & 511); 474 } 475 476 return write_boot_area(params, disk_buf.b, sizeof disk_buf.b); 477 } 478 479 static int 480 i386_editboot(ib_params *params) 481 { 482 int retval; 483 uint8_t buf[512]; 484 ssize_t rv; 485 uint32_t magic; 486 uint32_t offset; 487 struct x86_boot_params *bpp; 488 489 assert(params != NULL); 490 assert(params->fsfd != -1); 491 assert(params->filesystem != NULL); 492 493 retval = 0; 494 495 /* 496 * Read in the existing bootstrap. 497 * Look in any of the first 4 sectors. 498 */ 499 500 bpp = NULL; 501 for (offset = 0; offset < 4 * 512; offset += 512) { 502 rv = pread(params->fsfd, &buf, sizeof buf, offset); 503 if (rv == -1) { 504 warn("Reading `%s'", params->filesystem); 505 goto done; 506 } else if (rv != sizeof buf) { 507 warnx("Reading `%s': short read", params->filesystem); 508 goto done; 509 } 510 511 /* Magic number is 4 bytes in (to allow for a jmps) */ 512 /* Also allow any of the magic numbers. */ 513 magic = le32toh(*(uint32_t *)(buf + 4)) | 0xf; 514 if (magic != (X86_BOOT_MAGIC_1 | 0xf)) 515 continue; 516 517 /* The parameters are just after the magic number */ 518 bpp = (void *)(buf + 8); 519 break; 520 } 521 if (bpp == NULL) { 522 warnx("Invalid magic in existing bootstrap"); 523 goto done; 524 } 525 526 /* 527 * Fill in any user-specified options into the 528 * struct x86_boot_params 529 * that's 8 bytes in from the start of the third sector. 530 * See sys/arch/i386/stand/bootxx/bootxx.S for more information. 531 */ 532 if (update_i386_boot_params(params, bpp)) 533 goto done; 534 535 if (params->flags & IB_NOWRITE) { 536 retval = 1; 537 goto done; 538 } 539 540 /* 541 * Write boot code back 542 */ 543 rv = pwrite(params->fsfd, buf, sizeof buf, offset); 544 if (rv == -1) { 545 warn("Writing `%s'", params->filesystem); 546 goto done; 547 } else if (rv != sizeof buf) { 548 warnx("Writing `%s': short write, %zd bytes (should be %zu)", 549 params->filesystem, rv, sizeof(buf)); 550 goto done; 551 } 552 553 retval = 1; 554 555 done: 556 return retval; 557 } 558