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 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * cprboot - prom client that restores kadb/kernel pages 30 * 31 * simple cprboot overview: 32 * reset boot-file/boot-device to their original values 33 * open cpr statefile, usually "/.CPR" 34 * read in statefile 35 * close statefile 36 * restore kernel pages 37 * jump back into kernel text 38 * 39 * 40 * cprboot supports a restartable statefile for FAA/STARS, 41 * Federal Aviation Administration 42 * Standard Terminal Automation Replacement System 43 */ 44 45 #include <sys/types.h> 46 #include <sys/cpr.h> 47 #include <sys/promimpl.h> 48 #include <sys/ddi.h> 49 #include "cprboot.h" 50 51 52 /* 53 * local defs 54 */ 55 #define CB_MAXPROP 256 56 #define CB_MAXARGS 8 57 58 59 /* 60 * globals 61 */ 62 struct statefile sfile; 63 64 char cpr_statefile[OBP_MAXPATHLEN]; 65 char cpr_filesystem[OBP_MAXPATHLEN]; 66 67 int cpr_debug; /* cpr debug, set with uadmin 3 10x */ 68 uint_t cb_msec; /* cprboot start runtime */ 69 uint_t cb_dents; /* number of dtlb entries */ 70 71 int do_halt = 0; /* halt (enter mon) after load */ 72 int verbose = 0; /* verbose, traces cprboot ops */ 73 74 char rsvp[] = "please reboot"; 75 char prog[] = "cprboot"; 76 char entry[] = "ENTRY"; 77 char ent_fmt[] = "\n%s %s\n"; 78 79 80 /* 81 * file scope 82 */ 83 static char cb_argbuf[CB_MAXPROP]; 84 static char *cb_args[CB_MAXARGS]; 85 86 static int reusable; 87 static char *specialstate; 88 89 90 static int 91 cb_intro(void) 92 { 93 static char cstr[] = "\014" "\033[1P" "\033[18;21H"; 94 95 CB_VENTRY(cb_intro); 96 97 /* 98 * build/debug aid; this condition should not occur 99 */ 100 if ((uintptr_t)_end > CB_SRC_VIRT) { 101 prom_printf("\ndata collision:\n" 102 "(_end=0x%p > CB_LOW_VIRT=0x%x), recompile...\n", 103 _end, CB_SRC_VIRT); 104 return (ERR); 105 } 106 107 /* clear console */ 108 prom_printf(cstr); 109 110 prom_printf("Restoring the System. Please Wait... "); 111 return (0); 112 } 113 114 115 /* 116 * read bootargs and convert to arg vector 117 * 118 * sets globals: 119 * cb_argbuf 120 * cb_args 121 */ 122 static void 123 get_bootargs(void) 124 { 125 char *cp, *tail, *argp, **argv; 126 127 CB_VENTRY(get_bootargs); 128 129 (void) prom_strcpy(cb_argbuf, prom_bootargs()); 130 tail = cb_argbuf + prom_strlen(cb_argbuf); 131 132 /* 133 * scan to the trailing NULL so the last arg 134 * will be found without any special-case code 135 */ 136 argv = cb_args; 137 for (cp = argp = cb_argbuf; cp <= tail; cp++) { 138 if (prom_strchr(" \t\n\r", *cp) == NULL) 139 continue; 140 *cp = '\0'; 141 if (cp - argp) { 142 *argv++ = argp; 143 if ((argv - cb_args) == (CB_MAXARGS - 1)) 144 break; 145 } 146 argp = cp + 1; 147 } 148 *argv = NULLP; 149 150 if (verbose) { 151 for (argv = cb_args; *argv; argv++) { 152 prom_printf(" %ld: \"%s\"\n", 153 (argv - cb_args), *argv); 154 } 155 } 156 } 157 158 159 static void 160 usage(char *expect, char *got) 161 { 162 if (got == NULL) 163 got = "(NULL)"; 164 prom_printf("\nbad OBP boot args: expect %s, got %s\n" 165 "Usage: boot -F %s [-R] [-S <diskpath>]\n%s\n\n", 166 expect, got, prog, rsvp); 167 prom_exit_to_mon(); 168 } 169 170 171 /* 172 * bootargs should start with "-F cprboot" 173 * 174 * may set globals: 175 * specialstate 176 * reusable 177 * do_halt 178 * verbose 179 */ 180 static void 181 check_bootargs(void) 182 { 183 char **argv, *str, *cp; 184 185 argv = cb_args; 186 187 /* expect "-F" */ 188 str = "-F"; 189 if (*argv == NULL || prom_strcmp(*argv, str)) 190 usage(str, *argv); 191 argv++; 192 193 /* expect "cprboot*" */ 194 if (*argv == NULL || prom_strncmp(*argv, prog, sizeof (prog) - 1)) 195 usage(prog, *argv); 196 197 /* 198 * optional args 199 */ 200 str = "-[SR]"; 201 for (argv++; *argv; argv++) { 202 cp = *argv; 203 if (*cp != '-') 204 usage(str, *argv); 205 206 switch (*++cp) { 207 case 'R': 208 case 'r': 209 reusable = 1; 210 break; 211 case 'S': 212 case 's': 213 if (*++argv) 214 specialstate = *argv; 215 else 216 usage("statefile-path", *argv); 217 break; 218 case 'h': 219 do_halt = 1; 220 break; 221 case 'v': 222 verbose = 1; 223 break; 224 default: 225 usage(str, *argv); 226 break; 227 } 228 } 229 } 230 231 232 /* 233 * reset prom props and get statefile info 234 * 235 * sets globals: 236 * cpr_filesystem 237 * cpr_statefile 238 */ 239 static int 240 cb_startup(void) 241 { 242 CB_VENTRY(cb_startup); 243 244 if (!reusable) { 245 /* 246 * Restore the original values of the nvram properties modified 247 * during suspend. Note: if we can't get this info from the 248 * defaults file, the state file may be obsolete or bad, so we 249 * abort. However, failure to restore one or more properties 250 * is NOT fatal (better to continue the resume). 251 */ 252 if (cpr_reset_properties() == -1) { 253 prom_printf("\n%s: cannot read saved " 254 "nvram info, %s\n", prog, rsvp); 255 return (ERR); 256 } 257 } 258 259 /* 260 * simple copy if using specialstate, 261 * otherwise read in fs and statefile from a config file 262 */ 263 if (specialstate) 264 (void) prom_strcpy(cpr_statefile, specialstate); 265 else if (cpr_locate_statefile(cpr_statefile, cpr_filesystem) == -1) { 266 prom_printf("\n%s: cannot find cpr statefile, %s\n", 267 prog, rsvp); 268 return (ERR); 269 } 270 271 return (0); 272 } 273 274 275 static int 276 cb_open_sf(void) 277 { 278 CB_VENTRY(cb_open_sf); 279 280 sfile.fd = cpr_statefile_open(cpr_statefile, cpr_filesystem); 281 if (sfile.fd == -1) { 282 prom_printf("\n%s: can't open %s", prog, cpr_statefile); 283 if (specialstate) 284 prom_printf(" on %s", cpr_filesystem); 285 prom_printf("\n%s\n", rsvp); 286 return (ERR); 287 } 288 289 /* 290 * for block devices, seek past the disk label and bootblock 291 */ 292 if (specialstate) 293 (void) prom_seek(sfile.fd, CPR_SPEC_OFFSET); 294 295 return (0); 296 } 297 298 299 static int 300 cb_close_sf(void) 301 { 302 CB_VENTRY(cb_close_sf); 303 304 /* 305 * close the device so the prom will free up 20+ pages 306 */ 307 (void) cpr_statefile_close(sfile.fd); 308 return (0); 309 } 310 311 312 /* 313 * to restore kernel pages, we have to open a prom device to read-in 314 * the statefile contents; a prom "open" request triggers the driver 315 * and various packages to allocate 20+ pages; unfortunately, some or 316 * all of those pages always clash with kernel pages, and we cant write 317 * to them without corrupting the prom. 318 * 319 * to solve that problem, the only real solution is to close the device 320 * to free up those pages; this means we need to open, read-in the entire 321 * statefile, and close; and to store the statefile, we need to allocate 322 * plenty of space, usually around 2 to 60 MB. 323 * 324 * the simplest alloc means is prom_alloc(), which will "claim" both 325 * virt and phys pages, and creates mappings with a "map" request; 326 * "map" also causes the prom to alloc pages, and again these clash 327 * with kernel pages... 328 * 329 * to solve the "map" problem, we just reserve virt and phys pages and 330 * manage the translations by creating our own tlb entries instead of 331 * relying on the prom. 332 * 333 * sets globals: 334 * cpr_test_mode 335 * sfile.kpages 336 * sfile.size 337 * sfile.buf 338 * sfile.low_ppn 339 * sfile.high_ppn 340 */ 341 static int 342 cb_read_statefile(void) 343 { 344 size_t alsize, len, resid; 345 physaddr_t phys, dst_phys; 346 char *str, *dst_virt; 347 int err, cnt, mmask; 348 uint_t dtlb_index; 349 ssize_t nread; 350 cdd_t cdump; 351 352 str = "cb_read_statefile"; 353 CB_VPRINTF((ent_fmt, str, entry)); 354 355 /* 356 * read-in and check cpr dump header 357 */ 358 if (cpr_read_cdump(sfile.fd, &cdump, CPR_MACHTYPE_4U)) 359 return (ERR); 360 if (cpr_debug) 361 prom_printf("\n"); 362 cb_nbitmaps = cdump.cdd_bitmaprec; 363 cpr_test_mode = cdump.cdd_test_mode; 364 sfile.kpages = cdump.cdd_dumppgsize; 365 CPR_DEBUG(CPR_DEBUG4, "%s: total kpages %d\n", prog, sfile.kpages); 366 367 /* 368 * alloc virt and phys space with 512K alignment; 369 * alloc size should be (n * tte size); 370 */ 371 sfile.size = PAGE_ROUNDUP(cdump.cdd_filesize); 372 alsize = (cdump.cdd_filesize + MMU_PAGEOFFSET512K) & 373 MMU_PAGEMASK512K; 374 phys = 0; 375 err = cb_alloc(alsize, MMU_PAGESIZE512K, &sfile.buf, &phys); 376 CB_VPRINTF(("%s:\n alloc size 0x%lx, buf size 0x%lx\n" 377 " virt 0x%p, phys 0x%llx\n", 378 str, alsize, sfile.size, sfile.buf, phys)); 379 if (err) { 380 prom_printf("%s: cant alloc statefile buf, size 0x%lx\n%s\n", 381 str, sfile.size, rsvp); 382 return (ERR); 383 } 384 385 /* 386 * record low and high phys page numbers for sfile.buf 387 */ 388 sfile.low_ppn = ADDR_TO_PN(phys); 389 sfile.high_ppn = sfile.low_ppn + mmu_btop(sfile.size) - 1; 390 391 /* 392 * setup destination virt and phys addrs for reads; 393 * mapin-mask tells when to create a new tlb entry for the 394 * next set of reads; NB: the read and tlb method needs 395 * ((big-pagesize % read-size) == 0) 396 */ 397 dst_phys = phys; 398 mmask = (MMU_PAGESIZE512K / PROM_MAX_READ) - 1; 399 400 cnt = 0; 401 dtlb_index = cb_dents - 1; 402 (void) prom_seek(sfile.fd, specialstate ? CPR_SPEC_OFFSET : 0); 403 CPR_DEBUG(CPR_DEBUG1, "%s: reading statefile... ", prog); 404 for (resid = cdump.cdd_filesize; resid; resid -= len) { 405 /* 406 * do a full spin (4 spin chars) 407 * for every MB read (8 reads = 256K) 408 */ 409 if ((cnt & 0x7) == 0) 410 cb_spin(); 411 412 /* 413 * map-in statefile buf pages in 512K blocks; 414 * see MMU_PAGESIZE512K above 415 */ 416 if ((cnt & mmask) == 0) { 417 dst_virt = sfile.buf; 418 cb_mapin(dst_virt, ADDR_TO_PN(dst_phys), 419 TTE512K, TTE_HWWR_INT, dtlb_index); 420 } 421 422 cnt++; 423 424 len = min(PROM_MAX_READ, resid); 425 nread = prom_read(sfile.fd, dst_virt, len, 0, 0); 426 if (nread != (ssize_t)len) { 427 prom_printf("\n%s: prom read error, " 428 "expect %ld, got %ld\n", str, len, nread); 429 return (ERR); 430 } 431 dst_virt += len; 432 dst_phys += len; 433 } 434 CPR_DEBUG(CPR_DEBUG1, " \b\n"); 435 436 /* 437 * free up any unused phys pages trailing the statefile buffer; 438 * these pages will later appear on the physavail list 439 */ 440 if (alsize > sfile.size) { 441 len = alsize - sfile.size; 442 prom_free_phys(len, phys + sfile.size); 443 CB_VPRINTF(("%s: freed %ld phys pages (0x%lx - 0x%lx)\n", 444 str, mmu_btop(len), phys + sfile.size, phys + alsize)); 445 } 446 447 /* 448 * start the statefile buffer offset at the base of 449 * the statefile buffer and skip past the dump header 450 */ 451 sfile.buf_offset = 0; 452 SF_ADV(sizeof (cdump)); 453 454 /* 455 * finish with the first block mapped-in to provide easy virt access 456 * to machdep structs and the bitmap; for 2.8, the combined size of 457 * (cdd_t + cmd_t + csu_md_t + prom_words + cbd_t) is about 1K, 458 * leaving room for a bitmap representing nearly 32GB 459 */ 460 cb_mapin(sfile.buf, sfile.low_ppn, 461 TTE512K, TTE_HWWR_INT, dtlb_index); 462 463 return (0); 464 } 465 466 467 /* 468 * cprboot first stage worklist 469 */ 470 static int (*first_worklist[])(void) = { 471 cb_intro, 472 cb_startup, 473 cb_get_props, 474 cb_usb_setup, 475 cb_open_sf, 476 cb_read_statefile, 477 cb_close_sf, 478 cb_check_machdep, 479 cb_interpret, 480 cb_get_physavail, 481 cb_set_bitmap, 482 cb_get_newstack, 483 NULL 484 }; 485 486 /* 487 * cprboot second stage worklist 488 */ 489 static int (*second_worklist[])(void) = { 490 cb_relocate, 491 cb_tracking_setup, 492 cb_restore_kpages, 493 cb_terminator, 494 cb_ksetup, 495 cb_mpsetup, 496 NULL 497 }; 498 499 500 /* 501 * simple loop driving major cprboot operations; 502 * exits to prom if any error is returned 503 */ 504 static void 505 cb_drive(int (**worklist)(void)) 506 { 507 int i; 508 509 for (i = 0; worklist[i] != NULL; i++) { 510 if (worklist[i]()) 511 cb_exit_to_mon(); 512 } 513 } 514 515 516 /* 517 * debugging support: drop to prom if do_halt is set 518 */ 519 static void 520 check_halt(char *str) 521 { 522 if (do_halt) { 523 prom_printf("\n%s halted by -h flag\n==> before %s\n\n", 524 prog, str); 525 cb_enter_mon(); 526 } 527 } 528 529 530 /* 531 * main is called twice from "cb_srt0.s", args are: 532 * cookie ieee1275 cif handle 533 * first (true): first stage, (false): second stage 534 * 535 * first stage summary: 536 * various setup 537 * allocate a big statefile buffer 538 * read in the statefile 539 * setup the bitmap 540 * create a new stack 541 * 542 * return to "cb_srt0.s", switch to new stack 543 * 544 * second stage summary: 545 * relocate cprboot phys pages 546 * setup tracking for statefile buffer pages 547 * restore kernel pages 548 * various cleanup 549 * install tlb entries for the nucleus and cpr module 550 * restore registers and jump into cpr module 551 */ 552 int 553 main(void *cookie, int first) 554 { 555 if (first) { 556 prom_init(prog, cookie); 557 cb_msec = prom_gettime(); 558 get_bootargs(); 559 check_bootargs(); 560 check_halt("first_worklist"); 561 cb_drive(first_worklist); 562 return (0); 563 } else { 564 cb_drive(second_worklist); 565 if (verbose || CPR_DBG(1)) { 566 prom_printf("%s: milliseconds %d\n", 567 prog, prom_gettime() - cb_msec); 568 prom_printf("%s: resume pc 0x%lx\n", 569 prog, mdinfo.func); 570 prom_printf("%s: exit_to_kernel(0x%p, 0x%p)\n\n", 571 prog, cookie, &mdinfo); 572 } 573 check_halt("exit_to_kernel"); 574 exit_to_kernel(cookie, &mdinfo); 575 return (ERR); 576 } 577 } 578