1 /*- 2 * Copyright (c) 1998 Robert Nordier 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms are freely 6 * permitted provided that the above copyright notice and this 7 * paragraph and the following disclaimer are duplicated in all 8 * such forms. 9 * 10 * This software is provided "AS IS" and without any express or 11 * implied warranties, including, without limitation, the implied 12 * warranties of merchantability and fitness for a particular 13 * purpose. 14 */ 15 16#include <sys/cdefs.h> 17 __FBSDID("$FreeBSD$"); 18 19#include <sys/param.h> 20#include <sys/gpt.h> 21#include <sys/dirent.h> 22#include <sys/reboot.h> 23 24#include <machine/bootinfo.h> 25#include <machine/elf.h> 26#include <machine/pc/bios.h> 27#include <machine/psl.h> 28 29#include <stdarg.h> 30 31#include <a.out.h> 32 33#include <btxv86.h> 34 35#include "stand.h" 36 37#include "bootargs.h" 38#include "lib.h" 39#include "rbx.h" 40#include "drv.h" 41#include "cons.h" 42#include "gpt.h" 43#include "paths.h" 44 45#define ARGS 0x900 46#define NOPT 14 47#define NDEV 3 48#define MEM_BASE 0x12 49#define MEM_EXT 0x15 50 51#define DRV_HARD 0x80 52#define DRV_MASK 0x7f 53 54#define TYPE_AD 0 55#define TYPE_DA 1 56#define TYPE_MAXHARD TYPE_DA 57#define TYPE_FD 2 58 59 extern uint32_t _end; 60 61 static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */ 62 static const unsigned char flags[NOPT] = { 63 RBX_DUAL, 64 RBX_SERIAL, 65 RBX_ASKNAME, 66 RBX_CDROM, 67 RBX_CONFIG, 68 RBX_KDB, 69 RBX_GDB, 70 RBX_MUTE, 71 RBX_NOINTR, 72 RBX_PAUSE, 73 RBX_QUIET, 74 RBX_DFLTROOT, 75 RBX_SINGLE, 76 RBX_VERBOSE 77}; 78 uint32_t opts; 79 80 static const char *const dev_nm[NDEV] = {"ad", "da", "fd"}; 81 static const unsigned char dev_maj[NDEV] = {30, 4, 2}; 82 83 static struct dsk dsk; 84 static char kname[1024]; 85 static int comspeed = SIOSPD; 86 static struct bootinfo bootinfo; 87 88 static vm_offset_t high_heap_base; 89 static uint32_t bios_basemem, bios_extmem, high_heap_size; 90 91 static struct bios_smap smap; 92 93 /* 94 * The minimum amount of memory to reserve in bios_extmem for the heap. 95 */ 96#define HEAP_MIN (3 * 1024 * 1024) 97 98 static char *heap_next; 99 static char *heap_end; 100 101 int main(void); 102 103 static void load(void); 104 static int parse_cmds(char *, int *); 105 106 static uint8_t ls, dsk_meta; 107 static uint32_t fs_off; 108 109#include "cd9660read.c" 110 111 static inline int 112 xfsread(uint64_t inode, void *buf, size_t nbyte) 113{ 114 115 if ((size_t)cd9660_fsread(inode, buf, nbyte) != nbyte) { 116 printf("Invalid %s\n", "format"); 117 return (-1); 118 } 119 return (0); 120} 121 122 static void 123 bios_getmem(void) 124{ 125 uint64_t size; 126 127 /* Parse system memory map */ 128 v86.ebx = 0; 129 do { 130 v86.ctl = V86_FLAGS; 131 v86.addr = MEM_EXT; /* int 0x15 function 0xe820*/ 132 v86.eax = 0xe820; 133 v86.ecx = sizeof(struct bios_smap); 134 v86.edx = SMAP_SIG; 135 v86.es = VTOPSEG(&smap); 136 v86.edi = VTOPOFF(&smap); 137 v86int(); 138 if ((v86.efl & 1) || (v86.eax != SMAP_SIG)) 139 break; 140 /* look for a low-memory segment that's large enough */ 141 if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) && 142 (smap.length >= (512 * 1024))) 143 bios_basemem = smap.length; 144 /* look for the first segment in 'extended' memory */ 145 if ((smap.type == SMAP_TYPE_MEMORY) && 146 (smap.base == 0x100000)) { 147 bios_extmem = smap.length; 148 } 149 150 /* 151 * Look for the largest segment in 'extended' memory beyond 152 * 1MB but below 4GB. 153 */ 154 if ((smap.type == SMAP_TYPE_MEMORY) && 155 (smap.base > 0x100000) && (smap.base < 0x100000000ull)) { 156 size = smap.length; 157 158 /* 159 * If this segment crosses the 4GB boundary, 160 * truncate it. 161 */ 162 if (smap.base + size > 0x100000000ull) 163 size = 0x100000000ull - smap.base; 164 165 if (size > high_heap_size) { 166 high_heap_size = size; 167 high_heap_base = smap.base; 168 } 169 } 170 } while (v86.ebx != 0); 171 172 /* Fall back to the old compatibility function for base memory */ 173 if (bios_basemem == 0) { 174 v86.ctl = 0; 175 v86.addr = 0x12; /* int 0x12 */ 176 v86int(); 177 178 bios_basemem = (v86.eax & 0xffff) * 1024; 179 } 180 181 /* 182 * Fall back through several compatibility functions for extended 183 * memory 184 */ 185 if (bios_extmem == 0) { 186 v86.ctl = V86_FLAGS; 187 v86.addr = 0x15; /* int 0x15 function 0xe801*/ 188 v86.eax = 0xe801; 189 v86int(); 190 if (!(v86.efl & 1)) { 191 bios_extmem = ((v86.ecx & 0xffff) + 192 ((v86.edx & 0xffff) * 64)) * 1024; 193 } 194 } 195 if (bios_extmem == 0) { 196 v86.ctl = 0; 197 v86.addr = 0x15; /* int 0x15 function 0x88*/ 198 v86.eax = 0x8800; 199 v86int(); 200 bios_extmem = (v86.eax & 0xffff) * 1024; 201 } 202 203 /* 204 * If we have extended memory and did not find a suitable heap 205 * region in the SMAP, use the last 3MB of 'extended' memory as a 206 * high heap candidate. 207 */ 208 if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) { 209 high_heap_size = HEAP_MIN; 210 high_heap_base = bios_extmem + 0x100000 - HEAP_MIN; 211 } 212} 213 214 int 215 main(void) 216{ 217 char cmd[512], cmdtmp[512]; 218 ssize_t sz; 219 int autoboot, dskupdated; 220 uint64_t ino; 221 222 bios_getmem(); 223 224 if (high_heap_size > 0) { 225 heap_end = PTOV(high_heap_base + high_heap_size); 226 heap_next = PTOV(high_heap_base); 227 } else { 228 heap_next = (char *) 229 (roundup2(__base + (int32_t)&_end, 0x10000) - __base); 230 heap_end = (char *)PTOV(bios_basemem); 231 } 232 setheap(heap_next, heap_end); 233 234 v86.ctl = V86_FLAGS; 235 v86.efl = PSL_RESERVED_DEFAULT | PSL_I; 236 dsk.drive = *(uint8_t *)PTOV(ARGS); 237 dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; 238 dsk.unit = dsk.drive & DRV_MASK; 239 dsk.part = -1; 240 dsk.start = 0; 241 bootinfo.bi_version = BOOTINFO_VERSION; 242 bootinfo.bi_size = sizeof(bootinfo); 243 bootinfo.bi_basemem = bios_basemem / 1024; 244 bootinfo.bi_extmem = bios_extmem / 1024; 245 bootinfo.bi_memsizes_valid++; 246 bootinfo.bi_bios_dev = dsk.drive; 247 248 autoboot = 1; 249 *cmd = '0円'; 250 251 for (;;) { 252 *kname = '0円'; 253 if ((ino = cd9660_lookup(PATH_CONFIG)) || 254 (ino = cd9660_lookup(PATH_DOTCONFIG))) { 255 sz = cd9660_fsread(ino, cmd, sizeof(cmd) - 1); 256 cmd[(sz < 0) ? 0 : sz] = '0円'; 257 } 258 if (*cmd != '0円') { 259 memcpy(cmdtmp, cmd, sizeof(cmdtmp)); 260 if (parse_cmds(cmdtmp, &dskupdated)) 261 break; 262 if (!OPT_CHECK(RBX_QUIET)) 263 printf("%s: %s", PATH_CONFIG, cmd); 264 *cmd = '0円'; 265 } 266 267 if (autoboot && keyhit(3)) { 268 if (*kname == '0円') 269 memcpy(kname, PATH_LOADER, sizeof(PATH_LOADER)); 270 break; 271 } 272 autoboot = 0; 273 274 /* 275 * Try to exec stage 3 boot loader. If interrupted by a 276 * keypress, or in case of failure, try to load a kernel 277 * directly instead. 278 */ 279 if (*kname != '0円') 280 load(); 281 memcpy(kname, PATH_LOADER, sizeof(PATH_LOADER)); 282 load(); 283 memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL)); 284 load(); 285 dsk_meta = 0; 286 } 287 288 /* Present the user with the boot2 prompt. */ 289 290 for (;;) { 291 if (!OPT_CHECK(RBX_QUIET)) { 292 printf("\nFreeBSD/x86 boot\n" 293 "Default: %u:%s(%up%u)%s\n" 294 "boot: ", 295 dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit, 296 dsk.part, kname); 297 } 298 if (ioctrl & IO_SERIAL) 299 sio_flush(); 300 *cmd = '0円'; 301 if (keyhit(0)) 302 getstr(cmd, sizeof(cmd)); 303 else if (!OPT_CHECK(RBX_QUIET)) 304 putchar('\n'); 305 if (parse_cmds(cmd, &dskupdated)) { 306 putchar('\a'); 307 continue; 308 } 309 load(); 310 } 311 /* NOTREACHED */ 312} 313 314 /* Needed so btxld can link us properly; do not remove. */ 315 void 316 exit(int x) 317{ 318 319 while (1); 320 __unreachable(); 321} 322 323 static void 324 load(void) 325{ 326 union { 327 struct exec ex; 328 Elf32_Ehdr eh; 329 } hdr; 330 static Elf32_Phdr ep[2]; 331 static Elf32_Shdr es[2]; 332 caddr_t p; 333 uint64_t ino; 334 uint32_t addr, x; 335 int fmt, i, j; 336 337 if (!(ino = cd9660_lookup(kname))) { 338 if (!ls) { 339 printf("%s: No %s on %u:%s(%up%u)\n", BOOTPROG, 340 kname, dsk.drive & DRV_MASK, dev_nm[dsk.type], 341 dsk.unit, 342 dsk.part); 343 } 344 return; 345 } 346 if (xfsread(ino, &hdr, sizeof(hdr))) 347 return; 348 if (N_GETMAGIC(hdr.ex) == ZMAGIC) 349 fmt = 0; 350 else if (IS_ELF(hdr.eh)) 351 fmt = 1; 352 else { 353 printf("Invalid %s\n", "format"); 354 return; 355 } 356 if (fmt == 0) { 357 addr = hdr.ex.a_entry & 0xffffff; 358 p = PTOV(addr); 359 fs_off = PAGE_SIZE; 360 if (xfsread(ino, p, hdr.ex.a_text)) 361 return; 362 p += roundup2(hdr.ex.a_text, PAGE_SIZE); 363 if (xfsread(ino, p, hdr.ex.a_data)) 364 return; 365 p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE); 366 bootinfo.bi_symtab = VTOP(p); 367 memcpy(p, &hdr.ex.a_syms, sizeof(hdr.ex.a_syms)); 368 p += sizeof(hdr.ex.a_syms); 369 if (hdr.ex.a_syms) { 370 if (xfsread(ino, p, hdr.ex.a_syms)) 371 return; 372 p += hdr.ex.a_syms; 373 if (xfsread(ino, p, sizeof(int))) 374 return; 375 x = *(uint32_t *)p; 376 p += sizeof(int); 377 x -= sizeof(int); 378 if (xfsread(ino, p, x)) 379 return; 380 p += x; 381 } 382 } else { 383 fs_off = hdr.eh.e_phoff; 384 for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) { 385 if (xfsread(ino, ep + j, sizeof(ep[0]))) 386 return; 387 if (ep[j].p_type == PT_LOAD) 388 j++; 389 } 390 for (i = 0; i < 2; i++) { 391 p = PTOV(ep[i].p_paddr & 0xffffff); 392 fs_off = ep[i].p_offset; 393 if (xfsread(ino, p, ep[i].p_filesz)) 394 return; 395 } 396 p += roundup2(ep[1].p_memsz, PAGE_SIZE); 397 bootinfo.bi_symtab = VTOP(p); 398 if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) { 399 fs_off = hdr.eh.e_shoff + sizeof(es[0]) * 400 (hdr.eh.e_shstrndx + 1); 401 if (xfsread(ino, &es, sizeof(es))) 402 return; 403 for (i = 0; i < 2; i++) { 404 memcpy(p, &es[i].sh_size, 405 sizeof(es[i].sh_size)); 406 p += sizeof(es[i].sh_size); 407 fs_off = es[i].sh_offset; 408 if (xfsread(ino, p, es[i].sh_size)) 409 return; 410 p += es[i].sh_size; 411 } 412 } 413 addr = hdr.eh.e_entry & 0xffffff; 414 } 415 bootinfo.bi_esymtab = VTOP(p); 416 bootinfo.bi_kernelname = VTOP(kname); 417 bootinfo.bi_bios_dev = dsk.drive; 418 __exec((caddr_t)addr, RB_BOOTINFO | (opts & RBX_MASK), 419 MAKEBOOTDEV(dev_maj[dsk.type], 0, dsk.unit, 0), 420 0, 0, 0, VTOP(&bootinfo)); 421} 422 423 static int 424 parse_cmds(char *cmdstr, int *dskupdated) 425{ 426 char *arg; 427 char *ep, *p, *q; 428 const char *cp; 429 unsigned int drv; 430 int c, i, j; 431 432 arg = cmdstr; 433 *dskupdated = 0; 434 while ((c = *arg++)) { 435 if (c == ' ' || c == '\t' || c == '\n') 436 continue; 437 for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++); 438 ep = p; 439 if (*p) 440 *p++ = 0; 441 if (c == '-') { 442 while ((c = *arg++)) { 443 if (c == 'P') { 444 if (*(uint8_t *)PTOV(0x496) & 0x10) { 445 cp = "yes"; 446 } else { 447 opts |= OPT_SET(RBX_DUAL) | 448 OPT_SET(RBX_SERIAL); 449 cp = "no"; 450 } 451 printf("Keyboard: %s\n", cp); 452 continue; 453 } else if (c == 'S') { 454 j = 0; 455 while ((unsigned int)(i = *arg++ - '0') 456 <= 9) 457 j = j * 10 + i; 458 if (j > 0 && i == -'0') { 459 comspeed = j; 460 break; 461 } 462 /* 463 * Fall through to error below 464 * ('S' not in optstr[]). 465 */ 466 } 467 for (i = 0; c != optstr[i]; i++) 468 if (i == NOPT - 1) 469 return (-1); 470 opts ^= OPT_SET(flags[i]); 471 } 472 ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) : 473 OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD; 474 if (ioctrl & IO_SERIAL) { 475 if (sio_init(115200 / comspeed) != 0) 476 ioctrl &= ~IO_SERIAL; 477 } 478 } else { 479 for (q = arg--; *q && *q != '('; q++); 480 if (*q) { 481 drv = -1; 482 if (arg[1] == ':') { 483 drv = *arg - '0'; 484 if (drv > 9) 485 return (-1); 486 arg += 2; 487 } 488 if (q - arg != 2) 489 return (-1); 490 for (i = 0; arg[0] != dev_nm[i][0] || 491 arg[1] != dev_nm[i][1]; i++) 492 if (i == NDEV - 1) 493 return (-1); 494 dsk.type = i; 495 arg += 3; 496 dsk.unit = *arg - '0'; 497 if (arg[1] != 'p' || dsk.unit > 9) 498 return (-1); 499 arg += 2; 500 dsk.part = *arg - '0'; 501 if (dsk.part < 1 || dsk.part > 9) 502 return (-1); 503 arg++; 504 if (arg[0] != ')') 505 return (-1); 506 arg++; 507 if (drv == -1) 508 drv = dsk.unit; 509 dsk.drive = (dsk.type <= TYPE_MAXHARD 510 ? DRV_HARD : 0) + drv; 511 *dskupdated = 1; 512 } 513 if ((i = ep - arg)) { 514 if ((size_t)i >= sizeof(kname)) 515 return (-1); 516 memcpy(kname, arg, i + 1); 517 } 518 } 519 arg = p; 520 } 521 return (0); 522} 523