1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2019 Peter Tribbble. 25 */ 26 27 #include <sys/param.h> 28 #include <sys/fcntl.h> 29 #include <sys/obpdefs.h> 30 #include <sys/reboot.h> 31 #include <sys/promif.h> 32 #include <sys/stat.h> 33 #include <sys/bootvfs.h> 34 #include <sys/platnames.h> 35 #include <sys/salib.h> 36 #include <sys/elf.h> 37 #include <sys/link.h> 38 #include <sys/auxv.h> 39 #include <sys/boot_policy.h> 40 #include <sys/boot_redirect.h> 41 #include <sys/bootconf.h> 42 #include <sys/boot.h> 43 #include "boot_plat.h" 44 45 #define SUCCESS 0 46 #define FAILURE -1 47 48 #define ISSPACE(c) (c == ' ' || c == '\t') 49 #define SKIP_WHITESPC(cp) while (*cp && ISSPACE(*cp)) cp++; 50 51 52 #ifdef DEBUG 53 int debug = 0; 54 #else 55 static const int debug = 0; 56 #endif 57 58 #define dprintf if (debug) printf 59 60 #ifdef DEBUG_LISTS 61 void print_memlist(struct memlist *av); 62 #endif 63 64 extern int (*readfile(int fd, int print))(); 65 extern void kmem_init(void); 66 extern void *kmem_alloc(size_t, int); 67 extern void kmem_free(void *, size_t); 68 extern void get_boot_args(char *buf); 69 extern void setup_bootops(void); 70 extern struct bootops bootops; 71 extern void exitto(int (*entrypoint)()); 72 extern void exitto64(int (*entrypoint)(), void *bootvec); 73 74 int openfile(char *filename); 75 76 char *default_name; 77 char *default_path; 78 79 int vac; /* virtual address cache type (none == 0) */ 80 int is_sun4v; /* sun4u vs. sun4v */ 81 int client_isLP64 = 1; /* SPARC clients are always LP64 */ 82 83 extern bootplat_defaults_t sun4u_plat_defaults; 84 extern bootplat_defaults_t sun4v_plat_defaults; 85 86 /* 87 * filename is the name of the standalone we're going to execute. 88 */ 89 char filename[MAXPATHLEN]; 90 91 char * const defname = "kernel/sparcv9/unix"; 92 93 /* 94 * We enable the cache by default 95 * but boot -n will leave it alone... 96 * that is, we use whatever state the PROM left it in. 97 */ 98 char *mfg_name; 99 int cache_state = 1; 100 char filename2[MAXPATHLEN]; 101 102 int boothowto = 0; 103 int verbosemode = 0; 104 105 106 /* 107 * Copy filename and bargs into v2args_buf, which will be exported as the 108 * boot-args boot property. We should probably warn the user if anything gets 109 * cut off. 110 */ 111 void 112 set_client_bootargs(const char *filename, const char *bargs) 113 { 114 int i = 0; 115 const char *s; 116 117 s = filename; 118 while (*s != '\0' && i < V2ARGS_BUF_SZ - 1) 119 v2args_buf[i++] = *s++; 120 121 if (i >= V2ARGS_BUF_SZ - 2) { 122 /* Not enough room for a space and any of bargs. */ 123 v2args_buf[i] = '\0'; 124 return; 125 } 126 127 v2args_buf[i++] = ' '; 128 129 s = bargs; 130 while (*s != '\0' && i < V2ARGS_BUF_SZ - 1) 131 v2args_buf[i++] = *s++; 132 133 v2args_buf[i] = '\0'; 134 } 135 136 /* 137 * The slice redirection file is used on the install CD 138 */ 139 static int 140 read_redirect(char *redirect) 141 { 142 int fd; 143 char slicec; 144 size_t nread = 0; 145 146 if ((fd = open(BOOT_REDIRECT, O_RDONLY)) != -1) { 147 /* 148 * Read the character out of the file - this is the 149 * slice to use, in base 36. 150 */ 151 nread = read(fd, &slicec, 1); 152 (void) close(fd); 153 if (nread == 1) 154 *redirect++ = slicec; 155 } 156 *redirect = '\0'; 157 158 return (nread == 1); 159 } 160 161 void 162 post_mountroot(char *bootfile, char *redirect) 163 { 164 int (*go2)(); 165 int fd; 166 167 /* Save the bootfile, just in case we need it again */ 168 (void) strcpy(filename2, bootfile); 169 170 for (;;) { 171 if (boothowto & RB_ASKNAME) { 172 char tmpname[MAXPATHLEN]; 173 174 printf("Enter filename [%s]: ", bootfile); 175 (void) cons_gets(tmpname, sizeof (tmpname)); 176 if (tmpname[0] != '\0') 177 (void) strcpy(bootfile, tmpname); 178 } 179 180 if (boothowto & RB_HALT) { 181 printf("Boot halted.\n"); 182 prom_enter_mon(); 183 } 184 185 if ((fd = openfile(bootfile)) == FAILURE) { 186 187 /* 188 * There are many reasons why this might've 189 * happened .. but one of them is that we're 190 * on the installation CD, and we need to 191 * revector ourselves off to a different partition 192 * of the CD. Check for the redirection file. 193 */ 194 if (redirect != NULL && 195 read_redirect(redirect)) { 196 /* restore bootfile */ 197 (void) strcpy(bootfile, filename2); 198 return; 199 /*NOTREACHED*/ 200 } 201 202 printf("%s: cannot open %s\n", my_own_name, bootfile); 203 boothowto |= RB_ASKNAME; 204 205 /* restore bootfile */ 206 (void) strcpy(bootfile, filename2); 207 continue; 208 } 209 210 if ((go2 = readfile(fd, boothowto & RB_VERBOSE)) != 211 (int(*)()) -1) { 212 (void) close(fd); 213 } else { 214 printf("boot failed\n"); 215 boothowto |= RB_ASKNAME; 216 continue; 217 } 218 219 if (boothowto & RB_HALT) { 220 printf("Boot halted before exit to 0x%p.\n", 221 (void *)go2); 222 prom_enter_mon(); 223 } 224 225 my_own_name = bootfile; 226 227 dprintf("Calling exitto64(%p, %p)\n", (void *)go2, 228 (void *)elfbootvecELF64); 229 exitto64(go2, (void *)elfbootvecELF64); 230 } 231 } 232 233 /*ARGSUSED*/ 234 static int 235 boot_open(char *pathname, void *arg) 236 { 237 dprintf("trying '%s'\n", pathname); 238 return (open(pathname, O_RDONLY)); 239 } 240 241 /* 242 * Open the given filename, expanding to it's 243 * platform-dependent location if necessary. 244 * 245 * Boot supports OBP and IEEE1275. 246 * 247 * XXX: Move side effects out of this function! 248 */ 249 int 250 openfile(char *filename) 251 { 252 static char *fullpath; 253 static int once; 254 int fd; 255 256 if (once == 0) { 257 258 ++once; 259 260 /* 261 * Setup exported 'boot' properties: 'mfg-name'. 262 * XXX: This shouldn't be a side effect of openfile(). 263 */ 264 if (mfg_name == NULL) 265 mfg_name = get_mfg_name(); 266 267 fullpath = (char *)kmem_alloc(MAXPATHLEN, 0); 268 } 269 270 if (*filename == '/') { 271 (void) strcpy(fullpath, filename); 272 fd = boot_open(fullpath, NULL); 273 return (fd); 274 } 275 276 fd = open_platform_file(filename, boot_open, NULL, fullpath); 277 if (fd == -1) 278 return (-1); 279 280 /* 281 * Copy back the name we actually found 282 */ 283 (void) strcpy(filename, fullpath); 284 return (fd); 285 } 286 287 /* 288 * Get the boot arguments from the PROM and split it into filename and 289 * options components. 290 * 291 * As per IEEE1275 and boot(1M), the boot arguments will have the syntax 292 * "[filename] [-options]". If filename is specified, it is copied into the 293 * first buffer. (Otherwise, the buffer is left alone.) The rest of the string 294 * is copied into the second buffer. 295 */ 296 static void 297 init_bootargs(char *fname_buf, int fname_buf_sz, char *bargs_buf, 298 int bargs_buf_sz) 299 { 300 const char *tp = prom_bootargs(); 301 302 if (!tp || *tp == '\0') { 303 *bargs_buf = '\0'; 304 return; 305 } 306 307 SKIP_WHITESPC(tp); 308 309 /* 310 * If we don't have an option indicator, then we 311 * already have our filename prepended. 312 */ 313 if (*tp && *tp != '-') { 314 int i; 315 316 /* 317 * Copy the filename into fname_buf. 318 */ 319 for (i = 0; i < fname_buf_sz && *tp && !ISSPACE(*tp); ++i) 320 *fname_buf++ = *tp++; 321 322 if (i >= fname_buf_sz) { 323 printf("boot: boot filename too long!\n"); 324 printf("boot halted.\n"); 325 prom_enter_mon(); 326 /*NOTREACHED*/ 327 } else { 328 *fname_buf = '\0'; 329 } 330 331 SKIP_WHITESPC(tp); 332 } 333 334 /* The rest of the line is the options. */ 335 while (bargs_buf_sz > 1 && *tp) { 336 *bargs_buf++ = *tp++; 337 --bargs_buf_sz; 338 } 339 *bargs_buf = '\0'; 340 341 if (bargs_buf_sz == 1) { 342 printf("boot: boot arguments too long!\n"); 343 printf("boot halted.\n"); 344 prom_enter_mon(); 345 /*NOTREACHED*/ 346 } 347 } 348 349 boolean_t 350 is_netdev(char *devpath) 351 { 352 pnode_t node = prom_finddevice(devpath); 353 char *options; 354 355 if ((node == OBP_NONODE) || (node == OBP_BADNODE)) 356 return (B_FALSE); 357 if (prom_devicetype(node, "network") != 0) 358 return (B_TRUE); 359 360 /* 361 * For Infiniband, network device names will be of the 362 * format XXX/ib@0:port=1,pkey=1234,protocol=ip[,YYY] where 363 * XXX is typically /pci@8,700000/pci@1. The device_type 364 * property will be "ib". 365 */ 366 if (prom_devicetype(node, "ib") != 0) { 367 options = prom_path_options(devpath); 368 if (options != NULL) { 369 370 #define SEARCHSTRING ",protocol=ip" 371 #define SEARCHSTRLEN strlen(SEARCHSTRING) 372 373 if (strstr(options, ",protocol=ip,") != NULL) 374 return (B_TRUE); 375 while ((options = strstr(options, SEARCHSTRING)) != 376 NULL) { 377 char nextc; 378 379 nextc = options[SEARCHSTRLEN]; 380 if ((nextc == ',') || (nextc == 0)) 381 return (B_TRUE); 382 options += SEARCHSTRLEN; 383 } 384 } 385 } 386 return (B_FALSE); 387 } 388 389 /* 390 * Hook for modifying the OS boot path. This hook allows us to handle 391 * device arguments that the OS can't handle. 392 */ 393 void 394 mangle_os_bootpath(char *bpath) 395 { 396 pnode_t node; 397 char *stripped_pathname; 398 399 node = prom_finddevice(bpath); 400 if (prom_devicetype(node, "network") == 0) 401 return; 402 403 /* 404 * The OS can't handle network device arguments 405 * eg: boot net:promiscuous,speed=100,duplex=full 406 * So, we remove any argument strings in the device 407 * pathname we hand off to the OS for network devices. 408 * 409 * Internally, within boot, bpath is used to access 410 * the device, but v2path (as the boot property "boot-path") 411 * is the pathname passed to the OS. 412 */ 413 414 stripped_pathname = kmem_alloc(OBP_MAXPATHLEN, 0); 415 prom_strip_options(bpath, stripped_pathname); 416 v2path = stripped_pathname; 417 } 418 419 /* 420 * Given the boot path in the native firmware format use 421 * the redirection string to mutate the boot path to the new device. 422 * Fix up the 'v2path' so that it matches the new firmware path. 423 */ 424 void 425 redirect_boot_path(char *bpath, char *redirect) 426 { 427 char slicec = *redirect; 428 char *p = bpath + strlen(bpath); 429 430 /* 431 * If the redirection character doesn't fall in this 432 * range, something went horribly wrong. 433 */ 434 if (slicec < '0' || slicec > '7') { 435 printf("boot: bad redirection slice '%c'\n", slicec); 436 return; 437 } 438 439 /* 440 * Handle fully qualified OpenBoot pathname. 441 */ 442 while (--p >= bpath && *p != '@' && *p != '/') 443 if (*p == ':') 444 break; 445 if (*p++ == ':') { 446 /* 447 * Convert slice number to partition 'letter'. 448 */ 449 *p++ = 'a' + slicec - '0'; 450 *p = '\0'; 451 v2path = bpath; 452 return; 453 } 454 prom_panic("redirect_boot_path: mangled boot path!"); 455 } 456 457 void 458 system_check(void) 459 { 460 pnode_t n; 461 char arch[128]; 462 size_t len; 463 bootplat_defaults_t *plat_defaults; 464 465 /* 466 * This is a sun4v machine iff the device_type property 467 * exists on the root node and has the value "sun4v". 468 * Some older sunfire proms do not have such a property. 469 */ 470 is_sun4v = 0; 471 n = prom_rootnode(); 472 len = prom_getproplen(n, "device_type"); 473 if (len > 0 && len < sizeof (arch)) { 474 (void) prom_getprop(n, "device_type", arch); 475 arch[len] = '\0'; 476 dprintf("device_type=%s\n", arch); 477 if (strcmp(arch, "sun4v") == 0) { 478 is_sun4v = 1; 479 } 480 } else { 481 dprintf("device_type: no such property, len=%d\n", (int)len); 482 } 483 484 /* 485 * Set up defaults per platform 486 */ 487 plat_defaults = (is_sun4v) ? 488 &sun4v_plat_defaults : &sun4u_plat_defaults; 489 490 default_name = plat_defaults->plat_defaults_name; 491 default_path = plat_defaults->plat_defaults_path; 492 vac = plat_defaults->plat_defaults_vac; 493 494 dprintf("default_name: %s\n", default_name); 495 dprintf("default_path: %s\n", default_path); 496 dprintf("vac: %d\n", vac); 497 } 498 499 /* 500 * Reads in the standalone (client) program and jumps to it. If this 501 * attempt fails, prints "boot failed" and returns to its caller. 502 * 503 * It will try to determine if it is loading a Unix file by 504 * looking at what should be the magic number. If it makes 505 * sense, it will use it; otherwise it jumps to the first 506 * address of the blocks that it reads in. 507 * 508 * This new boot program will open a file, read the ELF header, 509 * attempt to allocate and map memory at the location at which 510 * the client desires to be linked, and load the program at 511 * that point. It will then jump there. 512 */ 513 /*ARGSUSED*/ 514 int 515 main(void *cookie, char **argv, int argc) 516 { 517 /* 518 * bpath is the boot device path buffer. 519 * bargs is the boot arguments buffer. 520 */ 521 static char bpath[OBP_MAXPATHLEN], bargs[OBP_MAXPATHLEN]; 522 boolean_t user_specified_filename; 523 524 prom_init("boot", cookie); 525 fiximp(); 526 527 system_check(); 528 529 dprintf("\nboot: V%d /boot interface.\n", BO_VERSION); 530 #ifdef HALTBOOT 531 prom_enter_mon(); 532 #endif /* HALTBOOT */ 533 534 init_memlists(); 535 536 #ifdef DEBUG_LISTS 537 dprintf("Physmem avail:\n"); 538 if (debug) print_memlist(pfreelistp); 539 dprintf("Virtmem avail:\n"); 540 if (debug) print_memlist(vfreelistp); 541 dprintf("Phys installed:\n"); 542 if (debug) print_memlist(pinstalledp); 543 prom_enter_mon(); 544 #endif /* DEBUG_LISTS */ 545 546 /* 547 * Initialize the default filename (exported as "default-name" and 548 * used by kadb). 549 */ 550 set_default_filename(defname); 551 552 /* 553 * Parse the arguments ASAP in case there are any flags which may 554 * affect execution. 555 */ 556 557 /* 558 * filename is the path to the standalone. Initialize it to the empty 559 * string so we can tell whether the user specified it in the 560 * arguments. 561 */ 562 filename[0] = '\0'; 563 564 /* 565 * Fetch the boot arguments from the PROM and split the filename off 566 * if it's there. 567 */ 568 init_bootargs(filename, sizeof (filename), bargs, sizeof (bargs)); 569 570 /* 571 * kadb was delivered as a standalone, and as such, people got used to 572 * typing `boot kadb'. kmdb isn't a standalone - it is loaded by krtld 573 * as just another kernel module. For compatibility, though, when we 574 * see an attempt to `boot kadb' or `boot kmdb', we'll transform that 575 * into a `boot -k' (or equivalent). 576 */ 577 if (strcmp(filename, "kmdb") == 0 || strcmp(filename, "kadb") == 0) { 578 boothowto |= RB_KMDB; 579 *filename = '\0'; /* let boot figure out which unix to use */ 580 } 581 582 bootflags(bargs, sizeof (bargs)); 583 584 user_specified_filename = (filename[0] != '\0'); 585 586 /* Fetch the boot path from the PROM. */ 587 (void) strncpy(bpath, prom_bootpath(), sizeof (bpath) - 1); 588 bpath[sizeof (bpath) - 1] = '\0'; 589 590 dprintf("arch: %s\n", is_sun4v ? "sun4v" : "sun4u"); 591 dprintf("bootpath: 0x%p %s\n", (void *)bpath, bpath); 592 dprintf("bootargs: 0x%p %s\n", (void *)bargs, bargs); 593 dprintf("filename: 0x%p %s\n", (void *)filename, filename); 594 dprintf("kernname: 0x%p %s\n", (void *)kernname, kernname); 595 596 /* 597 * *v2path will be exported to the standalone as the boot-path boot 598 * property. 599 */ 600 v2path = bpath; 601 602 /* 603 * Our memory lists should be "up" by this time 604 */ 605 606 setup_bootops(); 607 608 /* 609 * If bpath is a network card, set v2path to a copy of bpath with the 610 * options stripped off. 611 */ 612 mangle_os_bootpath(bpath); 613 614 /* 615 * Not necessary on sun4v as nvram is virtual 616 * and kept by the guest manager on the SP. 617 */ 618 if (!is_sun4v) { 619 retain_nvram_page(); 620 } 621 622 if (bootprog(bpath, bargs, user_specified_filename) == 0) { 623 post_mountroot(filename, NULL); 624 /*NOTREACHED*/ 625 } 626 627 return (0); 628 } 629