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 */ 25 26 /* 27 * Platform specific implementation code 28 */ 29 30 #define SUNDDI_IMPL 31 32 #include <sys/types.h> 33 #include <sys/promif.h> 34 #include <sys/prom_isa.h> 35 #include <sys/prom_plat.h> 36 #include <sys/mmu.h> 37 #include <vm/hat_sfmmu.h> 38 #include <sys/iommu.h> 39 #include <sys/scb.h> 40 #include <sys/cpuvar.h> 41 #include <sys/intreg.h> 42 #include <sys/pte.h> 43 #include <vm/hat.h> 44 #include <vm/page.h> 45 #include <vm/as.h> 46 #include <sys/cpr.h> 47 #include <sys/kmem.h> 48 #include <sys/clock.h> 49 #include <sys/kmem.h> 50 #include <sys/panic.h> 51 #include <vm/seg_kmem.h> 52 #include <sys/cpu_module.h> 53 #include <sys/callb.h> 54 #include <sys/machsystm.h> 55 #include <sys/vmsystm.h> 56 #include <sys/systm.h> 57 #include <sys/archsystm.h> 58 #include <sys/stack.h> 59 #include <sys/fs/ufs_fs.h> 60 #include <sys/memlist.h> 61 #include <sys/bootconf.h> 62 #include <sys/thread.h> 63 #include <vm/vm_dep.h> 64 65 extern void cpr_clear_bitmaps(void); 66 extern int cpr_setbit(pfn_t ppn, int mapflag); 67 extern int cpr_clrbit(pfn_t ppn, int mapflag); 68 extern pgcnt_t cpr_scan_kvseg(int mapflag, bitfunc_t bitfunc, struct seg *seg); 69 extern pgcnt_t cpr_count_seg_pages(int mapflag, bitfunc_t bitfunc); 70 extern void dtlb_wr_entry(uint_t, tte_t *, uint64_t *); 71 extern void itlb_wr_entry(uint_t, tte_t *, uint64_t *); 72 73 static int i_cpr_storage_desc_alloc(csd_t **, pgcnt_t *, csd_t **, int); 74 static void i_cpr_storage_desc_init(csd_t *, pgcnt_t, csd_t *); 75 static caddr_t i_cpr_storage_data_alloc(pgcnt_t, pgcnt_t *, int); 76 static int cpr_dump_sensitive(vnode_t *, csd_t *); 77 static void i_cpr_clear_entries(uint64_t, uint64_t); 78 static void i_cpr_xcall(xcfunc_t); 79 80 void i_cpr_storage_free(void); 81 82 extern void *i_cpr_data_page; 83 extern int cpr_test_mode; 84 extern int cpr_nbitmaps; 85 extern char cpr_default_path[]; 86 extern caddr_t textva, datava; 87 88 static struct cpr_map_info cpr_prom_retain[CPR_PROM_RETAIN_CNT]; 89 caddr_t cpr_vaddr = NULL; 90 91 static uint_t sensitive_pages_saved; 92 static uint_t sensitive_size_saved; 93 94 caddr_t i_cpr_storage_data_base; 95 caddr_t i_cpr_storage_data_end; 96 csd_t *i_cpr_storage_desc_base; 97 csd_t *i_cpr_storage_desc_end; /* one byte beyond last used descp */ 98 csd_t *i_cpr_storage_desc_last_used; /* last used descriptor */ 99 caddr_t sensitive_write_ptr; /* position for next storage write */ 100 101 size_t i_cpr_sensitive_bytes_dumped; 102 pgcnt_t i_cpr_sensitive_pgs_dumped; 103 pgcnt_t i_cpr_storage_data_sz; /* in pages */ 104 pgcnt_t i_cpr_storage_desc_pgcnt; /* in pages */ 105 106 ushort_t cpr_mach_type = CPR_MACHTYPE_4U; 107 static csu_md_t m_info; 108 109 110 #define MAX_STORAGE_RETRY 3 111 #define MAX_STORAGE_ALLOC_RETRY 3 112 #define INITIAL_ALLOC_PCNT 40 /* starting allocation percentage */ 113 #define INTEGRAL 100 /* to get 1% precision */ 114 115 #define EXTRA_RATE 2 /* add EXTRA_RATE% extra space */ 116 #define EXTRA_DESCS 10 117 118 #define CPR_NO_STORAGE_DESC 1 119 #define CPR_NO_STORAGE_DATA 2 120 121 #define CIF_SPLICE 0 122 #define CIF_UNLINK 1 123 124 125 /* 126 * CPR miscellaneous support routines 127 */ 128 #define cpr_open(path, mode, vpp) (vn_open(path, UIO_SYSSPACE, \ 129 mode, 0600, vpp, CRCREAT, 0)) 130 #define cpr_rdwr(rw, vp, basep, cnt) (vn_rdwr(rw, vp, (caddr_t)(basep), \ 131 cnt, 0LL, UIO_SYSSPACE, 0, (rlim64_t)MAXOFF_T, CRED(), \ 132 (ssize_t *)NULL)) 133 134 /* 135 * definitions for saving/restoring prom pages 136 */ 137 static void *ppage_buf; 138 static pgcnt_t ppage_count; 139 static pfn_t *pphys_list; 140 static size_t pphys_list_size; 141 142 typedef void (*tlb_rw_t)(uint_t, tte_t *, uint64_t *); 143 typedef void (*tlb_filter_t)(int, tte_t *, uint64_t, void *); 144 145 /* 146 * private struct for tlb handling 147 */ 148 struct cpr_trans_info { 149 sutlb_t *dst; 150 sutlb_t *tail; 151 tlb_rw_t reader; 152 tlb_rw_t writer; 153 tlb_filter_t filter; 154 int index; 155 uint64_t skip; /* assumes TLB <= 64 locked entries */ 156 }; 157 typedef struct cpr_trans_info cti_t; 158 159 160 /* 161 * special handling for tlb info 162 */ 163 #define WITHIN_OFW(va) \ 164 (((va) > (uint64_t)OFW_START_ADDR) && ((va) < (uint64_t)OFW_END_ADDR)) 165 166 #define WITHIN_NUCLEUS(va, base) \ 167 (((va) >= (base)) && \ 168 (((va) + MMU_PAGESIZE) <= ((base) + MMU_PAGESIZE4M))) 169 170 #define IS_BIGKTSB(va) \ 171 (enable_bigktsb && \ 172 ((va) >= (uint64_t)ktsb_base) && \ 173 ((va) < (uint64_t)(ktsb_base + ktsb_sz))) 174 175 176 /* 177 * WARNING: 178 * the text from this file is linked to follow cpr_resume_setup.o; 179 * only add text between here and i_cpr_end_jumpback when it needs 180 * to be called during resume before we switch back to the kernel 181 * trap table. all the text in this range must fit within a page. 182 */ 183 184 185 /* 186 * each time a machine is reset, the prom uses an inconsistent set of phys 187 * pages and the cif cookie may differ as well. so prior to restoring the 188 * original prom, we have to use to use the new/tmp prom's translations 189 * when requesting prom services. 190 * 191 * cif_handler starts out as the original prom cookie, and that gets used 192 * by client_handler() to jump into the prom. here we splice-in a wrapper 193 * routine by writing cif_handler; client_handler() will now jump to the 194 * wrapper which switches the %tba to the new/tmp prom's trap table then 195 * jumps to the new cookie. 196 */ 197 void 198 i_cpr_cif_setup(int action) 199 { 200 extern void *i_cpr_orig_cif, *cif_handler; 201 extern int i_cpr_cif_wrapper(void *); 202 203 /* 204 * save the original cookie and change the current cookie to the 205 * wrapper routine. later we just restore the original cookie. 206 */ 207 if (action == CIF_SPLICE) { 208 i_cpr_orig_cif = cif_handler; 209 cif_handler = (void *)i_cpr_cif_wrapper; 210 } else if (action == CIF_UNLINK) 211 cif_handler = i_cpr_orig_cif; 212 } 213 214 215 /* 216 * launch slave cpus into kernel text, pause them, 217 * and restore the original prom pages 218 */ 219 void 220 i_cpr_mp_setup(void) 221 { 222 extern void restart_other_cpu(int); 223 cpu_t *cp; 224 225 uint64_t kctx = kcontextreg; 226 227 /* 228 * Do not allow setting page size codes in MMU primary context 229 * register while using cif wrapper. This is needed to work 230 * around OBP incorrect handling of this MMU register. 231 */ 232 kcontextreg = 0; 233 234 /* 235 * reset cpu_ready_set so x_calls work properly 236 */ 237 CPUSET_ZERO(cpu_ready_set); 238 CPUSET_ADD(cpu_ready_set, getprocessorid()); 239 240 /* 241 * setup cif to use the cookie from the new/tmp prom 242 * and setup tmp handling for calling prom services. 243 */ 244 i_cpr_cif_setup(CIF_SPLICE); 245 246 /* 247 * at this point, only the nucleus and a few cpr pages are 248 * mapped in. once we switch to the kernel trap table, 249 * we can access the rest of kernel space. 250 */ 251 prom_set_traptable(&trap_table); 252 253 if (ncpus > 1) { 254 sfmmu_init_tsbs(); 255 256 mutex_enter(&cpu_lock); 257 /* 258 * All of the slave cpus are not ready at this time, 259 * yet the cpu structures have various cpu_flags set; 260 * clear cpu_flags and mutex_ready. 261 * Since we are coming up from a CPU suspend, the slave cpus 262 * are frozen. 263 */ 264 for (cp = CPU->cpu_next; cp != CPU; cp = cp->cpu_next) { 265 cp->cpu_flags = CPU_FROZEN; 266 cp->cpu_m.mutex_ready = 0; 267 } 268 269 for (cp = CPU->cpu_next; cp != CPU; cp = cp->cpu_next) 270 restart_other_cpu(cp->cpu_id); 271 272 pause_cpus(NULL); 273 mutex_exit(&cpu_lock); 274 275 i_cpr_xcall(i_cpr_clear_entries); 276 } else 277 i_cpr_clear_entries(0, 0); 278 279 /* 280 * now unlink the cif wrapper; WARNING: do not call any 281 * prom_xxx() routines until after prom pages are restored. 282 */ 283 i_cpr_cif_setup(CIF_UNLINK); 284 285 (void) i_cpr_prom_pages(CPR_PROM_RESTORE); 286 287 /* allow setting page size codes in MMU primary context register */ 288 kcontextreg = kctx; 289 } 290 291 292 /* 293 * end marker for jumpback page; 294 * this symbol is used to check the size of i_cpr_resume_setup() 295 * and the above text. For simplicity, the Makefile needs to 296 * link i_cpr_resume_setup.o and cpr_impl.o consecutively. 297 */ 298 void 299 i_cpr_end_jumpback(void) 300 { 301 } 302 303 304 /* 305 * scan tlb entries with reader; when valid entries are found, 306 * the filter routine will selectively save/clear them 307 */ 308 static void 309 i_cpr_scan_tlb(cti_t *ctip) 310 { 311 uint64_t va_tag; 312 int tlb_index; 313 tte_t tte; 314 315 for (tlb_index = ctip->index; tlb_index >= 0; tlb_index--) { 316 (*ctip->reader)((uint_t)tlb_index, &tte, &va_tag); 317 if (va_tag && TTE_IS_VALID(&tte)) 318 (*ctip->filter)(tlb_index, &tte, va_tag, ctip); 319 } 320 } 321 322 323 /* 324 * filter for locked tlb entries that reference the text/data nucleus 325 * and any bigktsb's; these will be reinstalled by cprboot on all cpus 326 */ 327 /* ARGSUSED */ 328 static void 329 i_cpr_lnb(int index, tte_t *ttep, uint64_t va_tag, void *ctrans) 330 { 331 cti_t *ctip; 332 333 /* 334 * record tlb data at ctip->dst; the target tlb index starts 335 * at the highest tlb offset and moves towards 0. the prom 336 * reserves both dtlb and itlb index 0. any selected entry 337 * also gets marked to prevent being flushed during resume 338 */ 339 if (TTE_IS_LOCKED(ttep) && (va_tag == (uint64_t)textva || 340 va_tag == (uint64_t)datava || IS_BIGKTSB(va_tag))) { 341 ctip = ctrans; 342 while ((1 << ctip->index) & ctip->skip) 343 ctip->index--; 344 ASSERT(ctip->index > 0); 345 ASSERT(ctip->dst < ctip->tail); 346 ctip->dst->tte.ll = ttep->ll; 347 ctip->dst->va_tag = va_tag; 348 ctip->dst->index = ctip->index--; 349 ctip->dst->tmp = 0; 350 ctip->dst++; 351 } 352 } 353 354 355 /* 356 * some tlb entries are stale, filter for unlocked entries 357 * within the prom virt range and clear them 358 */ 359 static void 360 i_cpr_ufw(int index, tte_t *ttep, uint64_t va_tag, void *ctrans) 361 { 362 sutlb_t clr; 363 cti_t *ctip; 364 365 if (!TTE_IS_LOCKED(ttep) && WITHIN_OFW(va_tag)) { 366 ctip = ctrans; 367 bzero(&clr, sizeof (clr)); 368 (*ctip->writer)((uint_t)index, &clr.tte, &clr.va_tag); 369 } 370 } 371 372 373 /* 374 * some of the entries installed by cprboot are needed only on a 375 * short-term basis and need to be flushed to avoid clogging the tlbs. 376 * scan the dtte/itte arrays for items marked as temporary and clear 377 * dtlb/itlb entries using wrfunc. 378 */ 379 static void 380 i_cpr_clear_tmp(sutlb_t *listp, int max, tlb_rw_t wrfunc) 381 { 382 sutlb_t clr, *tail; 383 384 bzero(&clr, sizeof (clr)); 385 for (tail = listp + max; listp < tail && listp->va_tag; listp++) { 386 if (listp->tmp) 387 (*wrfunc)((uint_t)listp->index, &clr.tte, &clr.va_tag); 388 } 389 } 390 391 392 /* ARGSUSED */ 393 static void 394 i_cpr_clear_entries(uint64_t arg1, uint64_t arg2) 395 { 396 extern void demap_all(void); 397 cti_t cti; 398 399 i_cpr_clear_tmp(m_info.dtte, CPR_MAX_TLB, dtlb_wr_entry); 400 i_cpr_clear_tmp(m_info.itte, CPR_MAX_TLB, itlb_wr_entry); 401 402 /* 403 * for newer cpus that implement DEMAP_ALL_TYPE, demap_all is 404 * a second label for vtag_flushall. the call is made using 405 * vtag_flushall() instead of demap_all() due to runtime and 406 * krtld results with both older and newer cpu modules. 407 */ 408 if (&demap_all != 0) { 409 vtag_flushall(); 410 return; 411 } 412 413 /* 414 * for older V9 cpus, scan tlbs and clear stale entries 415 */ 416 bzero(&cti, sizeof (cti)); 417 cti.filter = i_cpr_ufw; 418 419 cti.index = cpunodes[CPU->cpu_id].dtlb_size - 1; 420 cti.reader = dtlb_rd_entry; 421 cti.writer = dtlb_wr_entry; 422 i_cpr_scan_tlb(&cti); 423 424 cti.index = cpunodes[CPU->cpu_id].itlb_size - 1; 425 cti.reader = itlb_rd_entry; 426 cti.writer = itlb_wr_entry; 427 i_cpr_scan_tlb(&cti); 428 } 429 430 431 /* 432 * craft tlb info for tmp use during resume; this data gets used by 433 * cprboot to install tlb entries. we also mark each struct as tmp 434 * so those tlb entries will get flushed after switching to the kernel 435 * trap table. no data needs to be recorded for vaddr when it falls 436 * within the nucleus since we've already recorded nucleus ttes and 437 * a 8K tte would conflict with a 4MB tte. eg: the cpr module 438 * text/data may have been loaded into the text/data nucleus. 439 */ 440 static void 441 i_cpr_make_tte(cti_t *ctip, void *vaddr, caddr_t nbase) 442 { 443 pfn_t ppn; 444 uint_t rw; 445 446 if (WITHIN_NUCLEUS((caddr_t)vaddr, nbase)) 447 return; 448 449 while ((1 << ctip->index) & ctip->skip) 450 ctip->index--; 451 ASSERT(ctip->index > 0); 452 ASSERT(ctip->dst < ctip->tail); 453 454 /* 455 * without any global service available to lookup 456 * a tte by vaddr, we craft our own here: 457 */ 458 ppn = va_to_pfn(vaddr); 459 rw = (nbase == datava) ? TTE_HWWR_INT : 0; 460 ctip->dst->tte.tte_inthi = TTE_VALID_INT | TTE_PFN_INTHI(ppn); 461 ctip->dst->tte.tte_intlo = TTE_PFN_INTLO(ppn) | TTE_LCK_INT | 462 TTE_CP_INT | TTE_PRIV_INT | rw; 463 ctip->dst->va_tag = ((uintptr_t)vaddr & MMU_PAGEMASK); 464 ctip->dst->index = ctip->index--; 465 ctip->dst->tmp = 1; 466 ctip->dst++; 467 } 468 469 470 static void 471 i_cpr_xcall(xcfunc_t func) 472 { 473 uint_t pil, reset_pil; 474 475 pil = getpil(); 476 if (pil < XCALL_PIL) 477 reset_pil = 0; 478 else { 479 reset_pil = 1; 480 setpil(XCALL_PIL - 1); 481 } 482 xc_some(cpu_ready_set, func, 0, 0); 483 if (reset_pil) 484 setpil(pil); 485 } 486 487 488 /* 489 * restart paused slave cpus 490 */ 491 void 492 i_cpr_machdep_setup(void) 493 { 494 if (ncpus > 1) { 495 CPR_DEBUG(CPR_DEBUG1, "MP restarted...\n"); 496 mutex_enter(&cpu_lock); 497 start_cpus(); 498 mutex_exit(&cpu_lock); 499 } 500 } 501 502 503 /* 504 * Stop all interrupt activities in the system 505 */ 506 void 507 i_cpr_stop_intr(void) 508 { 509 (void) spl7(); 510 } 511 512 /* 513 * Set machine up to take interrupts 514 */ 515 void 516 i_cpr_enable_intr(void) 517 { 518 (void) spl0(); 519 } 520 521 522 /* 523 * record cpu nodes and ids 524 */ 525 static void 526 i_cpr_save_cpu_info(void) 527 { 528 struct sun4u_cpu_info *scip; 529 cpu_t *cp; 530 531 scip = m_info.sci; 532 cp = CPU; 533 do { 534 ASSERT(scip < &m_info.sci[NCPU]); 535 scip->cpu_id = cp->cpu_id; 536 scip->node = cpunodes[cp->cpu_id].nodeid; 537 scip++; 538 } while ((cp = cp->cpu_next) != CPU); 539 } 540 541 542 /* 543 * Write necessary machine dependent information to cpr state file, 544 * eg. sun4u mmu ctx secondary for the current running process (cpr) ... 545 */ 546 int 547 i_cpr_write_machdep(vnode_t *vp) 548 { 549 extern uint_t getpstate(), getwstate(); 550 extern uint_t i_cpr_tstack_size; 551 const char ustr[] = ": unix-tte 2drop false ;"; 552 uintptr_t tinfo; 553 label_t *ltp; 554 cmd_t cmach; 555 char *fmt; 556 int rc; 557 558 /* 559 * ustr[] is used as temporary forth words during 560 * slave startup sequence, see sfmmu_mp_startup() 561 */ 562 563 cmach.md_magic = (uint_t)CPR_MACHDEP_MAGIC; 564 cmach.md_size = sizeof (m_info) + sizeof (ustr); 565 566 if (rc = cpr_write(vp, (caddr_t)&cmach, sizeof (cmach))) { 567 cpr_err(CE_WARN, "Failed to write descriptor."); 568 return (rc); 569 } 570 571 /* 572 * m_info is now cleared in i_cpr_dump_setup() 573 */ 574 m_info.ksb = (uint32_t)STACK_BIAS; 575 m_info.kpstate = (uint16_t)getpstate(); 576 m_info.kwstate = (uint16_t)getwstate(); 577 CPR_DEBUG(CPR_DEBUG1, "stack bias 0x%x, pstate 0x%x, wstate 0x%x\n", 578 m_info.ksb, m_info.kpstate, m_info.kwstate); 579 580 ltp = &ttolwp(curthread)->lwp_qsav; 581 m_info.qsav_pc = (cpr_ext)ltp->val[0]; 582 m_info.qsav_sp = (cpr_ext)ltp->val[1]; 583 584 /* 585 * Set secondary context to INVALID_CONTEXT to force the HAT 586 * to re-setup the MMU registers and locked TTEs it needs for 587 * TLB miss handling. 588 */ 589 m_info.mmu_ctx_sec = INVALID_CONTEXT; 590 m_info.mmu_ctx_pri = KCONTEXT; 591 592 tinfo = (uintptr_t)curthread; 593 m_info.thrp = (cpr_ptr)tinfo; 594 595 tinfo = (uintptr_t)i_cpr_resume_setup; 596 m_info.func = (cpr_ptr)tinfo; 597 598 /* 599 * i_cpr_data_page is comprised of a 4K stack area and a few 600 * trailing data symbols; the page is shared by the prom and 601 * kernel during resume. the stack size is recorded here 602 * and used by cprboot to set %sp 603 */ 604 tinfo = (uintptr_t)&i_cpr_data_page; 605 m_info.tmp_stack = (cpr_ptr)tinfo; 606 m_info.tmp_stacksize = i_cpr_tstack_size; 607 608 m_info.test_mode = cpr_test_mode; 609 610 i_cpr_save_cpu_info(); 611 612 if (rc = cpr_write(vp, (caddr_t)&m_info, sizeof (m_info))) { 613 cpr_err(CE_WARN, "Failed to write machdep info."); 614 return (rc); 615 } 616 617 fmt = "error writing %s forth info"; 618 if (rc = cpr_write(vp, (caddr_t)ustr, sizeof (ustr))) 619 cpr_err(CE_WARN, fmt, "unix-tte"); 620 621 return (rc); 622 } 623 624 625 /* 626 * Save miscellaneous information which needs to be written to the 627 * state file. This information is required to re-initialize 628 * kernel/prom handshaking. 629 */ 630 void 631 i_cpr_save_machdep_info(void) 632 { 633 CPR_DEBUG(CPR_DEBUG5, "jumpback size = 0x%lx\n", 634 (uintptr_t)&i_cpr_end_jumpback - 635 (uintptr_t)i_cpr_resume_setup); 636 637 /* 638 * Verify the jumpback code all falls in one page. 639 */ 640 if (((uintptr_t)&i_cpr_end_jumpback & MMU_PAGEMASK) != 641 ((uintptr_t)i_cpr_resume_setup & MMU_PAGEMASK)) 642 cpr_err(CE_PANIC, "jumpback code exceeds one page."); 643 } 644 645 646 /* 647 * cpu0 should contain bootcpu info 648 */ 649 cpu_t * 650 i_cpr_bootcpu(void) 651 { 652 return (&cpu0); 653 } 654 655 processorid_t 656 i_cpr_bootcpuid(void) 657 { 658 return (0); 659 } 660 661 /* 662 * Return the virtual address of the mapping area 663 */ 664 caddr_t 665 i_cpr_map_setup(void) 666 { 667 /* 668 * Allocate a virtual memory range spanned by an hmeblk. 669 * This would be 8 hments or 64k bytes. Starting VA 670 * must be 64k (8-page) aligned. 671 */ 672 cpr_vaddr = vmem_xalloc(heap_arena, 673 mmu_ptob(NHMENTS), mmu_ptob(NHMENTS), 674 0, 0, NULL, NULL, VM_NOSLEEP); 675 return (cpr_vaddr); 676 } 677 678 /* 679 * create tmp locked tlb entries for a group of phys pages; 680 * 681 * i_cpr_mapin/i_cpr_mapout should always be called in pairs, 682 * otherwise would fill up a tlb with locked entries 683 */ 684 void 685 i_cpr_mapin(caddr_t vaddr, uint_t pages, pfn_t ppn) 686 { 687 tte_t tte; 688 extern pfn_t curthreadpfn; 689 extern int curthreadremapped; 690 691 curthreadremapped = (ppn <= curthreadpfn && curthreadpfn < ppn + pages); 692 693 for (; pages--; ppn++, vaddr += MMU_PAGESIZE) { 694 tte.tte_inthi = TTE_VALID_INT | TTE_PFN_INTHI(ppn); 695 tte.tte_intlo = TTE_PFN_INTLO(ppn) | TTE_LCK_INT | 696 TTE_CP_INT | TTE_PRIV_INT | TTE_HWWR_INT; 697 sfmmu_dtlb_ld_kva(vaddr, &tte); 698 } 699 } 700 701 void 702 i_cpr_mapout(caddr_t vaddr, uint_t pages) 703 { 704 extern int curthreadremapped; 705 706 if (curthreadremapped && vaddr <= (caddr_t)curthread && 707 (caddr_t)curthread < vaddr + pages * MMU_PAGESIZE) 708 curthreadremapped = 0; 709 710 for (; pages--; vaddr += MMU_PAGESIZE) 711 vtag_flushpage(vaddr, (uint64_t)ksfmmup); 712 } 713 714 /* 715 * We're done using the mapping area; release virtual space 716 */ 717 void 718 i_cpr_map_destroy(void) 719 { 720 vmem_free(heap_arena, cpr_vaddr, mmu_ptob(NHMENTS)); 721 cpr_vaddr = NULL; 722 } 723 724 /* ARGSUSED */ 725 void 726 i_cpr_handle_xc(int flag) 727 { 728 } 729 730 731 /* 732 * This function takes care of pages which are not in kas or need to be 733 * taken care of in a special way. For example, panicbuf pages are not 734 * in kas and their pages are allocated via prom_retain(). 735 */ 736 pgcnt_t 737 i_cpr_count_special_kpages(int mapflag, bitfunc_t bitfunc) 738 { 739 struct cpr_map_info *pri, *tail; 740 pgcnt_t pages, total = 0; 741 pfn_t pfn; 742 743 /* 744 * Save information about prom retained panicbuf pages 745 */ 746 if (bitfunc == cpr_setbit) { 747 pri = &cpr_prom_retain[CPR_PANICBUF]; 748 pri->virt = (cpr_ptr)panicbuf; 749 pri->phys = va_to_pa(panicbuf); 750 pri->size = sizeof (panicbuf); 751 } 752 753 /* 754 * Go through the prom_retain array to tag those pages. 755 */ 756 tail = &cpr_prom_retain[CPR_PROM_RETAIN_CNT]; 757 for (pri = cpr_prom_retain; pri < tail; pri++) { 758 pages = mmu_btopr(pri->size); 759 for (pfn = ADDR_TO_PN(pri->phys); pages--; pfn++) { 760 if (pf_is_memory(pfn)) { 761 if (bitfunc == cpr_setbit) { 762 if ((*bitfunc)(pfn, mapflag) == 0) 763 total++; 764 } else 765 total++; 766 } 767 } 768 } 769 770 return (total); 771 } 772 773 774 /* 775 * Free up memory-related resources here. We start by freeing buffers 776 * allocated during suspend initialization. Also, free up the mapping 777 * resources allocated in cpr_init(). 778 */ 779 void 780 i_cpr_free_memory_resources(void) 781 { 782 (void) i_cpr_prom_pages(CPR_PROM_FREE); 783 i_cpr_map_destroy(); 784 i_cpr_storage_free(); 785 } 786 787 788 /* 789 * Derived from cpr_write_statefile(). 790 * Save the sensitive pages to the storage area and do bookkeeping 791 * using the sensitive descriptors. Each descriptor will contain no more 792 * than CPR_MAXCONTIG amount of contiguous pages to match the max amount 793 * of pages that statefile gets written to disk at each write. 794 * XXX The CPR_MAXCONTIG can be changed to the size of the compression 795 * scratch area. 796 */ 797 static int 798 i_cpr_save_to_storage(void) 799 { 800 sensitive_size_saved = 0; 801 sensitive_pages_saved = 0; 802 sensitive_write_ptr = i_cpr_storage_data_base; 803 return (cpr_contig_pages(NULL, SAVE_TO_STORAGE)); 804 } 805 806 807 /* 808 * This routine allocates space to save the sensitive kernel pages, 809 * i.e. kernel data nucleus, kvalloc and kvseg segments. 810 * It's assumed that those segments are the only areas that can be 811 * contaminated by memory allocations during statefile dumping. 812 * The space allocated here contains: 813 * A list of descriptors describing the saved sensitive pages. 814 * The storage area for saving the compressed sensitive kernel pages. 815 * Since storage pages are allocated from segkmem, they need to be 816 * excluded when saving. 817 */ 818 int 819 i_cpr_save_sensitive_kpages(void) 820 { 821 static const char pages_fmt[] = "\n%s %s allocs\n" 822 " spages %ld, vpages %ld, diff %ld\n"; 823 int retry_cnt; 824 int error = 0; 825 pgcnt_t pages, spages, vpages; 826 caddr_t addr; 827 char *str; 828 829 /* 830 * Tag sensitive kpages. Allocate space for storage descriptors 831 * and storage data area based on the resulting bitmaps. 832 * Note: The storage space will be part of the sensitive 833 * segment, so we need to tag kpages here before the storage 834 * is actually allocated just so their space won't be accounted 835 * for. They will not be part of the statefile although those 836 * pages will be claimed by cprboot. 837 */ 838 cpr_clear_bitmaps(); 839 840 spages = i_cpr_count_sensitive_kpages(REGULAR_BITMAP, cpr_setbit); 841 vpages = cpr_count_volatile_pages(REGULAR_BITMAP, cpr_clrbit); 842 pages = spages - vpages; 843 844 str = "i_cpr_save_sensitive_kpages:"; 845 CPR_DEBUG(CPR_DEBUG7, pages_fmt, "before", str, spages, vpages, pages); 846 847 /* 848 * Allocate space to save the clean sensitive kpages 849 */ 850 for (retry_cnt = 0; retry_cnt < MAX_STORAGE_ALLOC_RETRY; retry_cnt++) { 851 /* 852 * Alloc on first pass or realloc if we are retrying because 853 * of insufficient storage for sensitive pages 854 */ 855 if (retry_cnt == 0 || error == ENOMEM) { 856 if (i_cpr_storage_data_base) { 857 kmem_free(i_cpr_storage_data_base, 858 mmu_ptob(i_cpr_storage_data_sz)); 859 i_cpr_storage_data_base = NULL; 860 i_cpr_storage_data_sz = 0; 861 } 862 addr = i_cpr_storage_data_alloc(pages, 863 &i_cpr_storage_data_sz, retry_cnt); 864 if (addr == NULL) { 865 CPR_DEBUG(CPR_DEBUG7, 866 "\n%s can't allocate data storage space!\n", 867 str); 868 return (ENOMEM); 869 } 870 i_cpr_storage_data_base = addr; 871 i_cpr_storage_data_end = 872 addr + mmu_ptob(i_cpr_storage_data_sz); 873 } 874 875 /* 876 * Allocate on first pass, only realloc if retry is because of 877 * insufficient descriptors, but reset contents on each pass 878 * (desc_alloc resets contents as well) 879 */ 880 if (retry_cnt == 0 || error == -1) { 881 error = i_cpr_storage_desc_alloc( 882 &i_cpr_storage_desc_base, &i_cpr_storage_desc_pgcnt, 883 &i_cpr_storage_desc_end, retry_cnt); 884 if (error != 0) 885 return (error); 886 } else { 887 i_cpr_storage_desc_init(i_cpr_storage_desc_base, 888 i_cpr_storage_desc_pgcnt, i_cpr_storage_desc_end); 889 } 890 891 /* 892 * We are ready to save the sensitive kpages to storage. 893 * We cannot trust what's tagged in the bitmaps anymore 894 * after storage allocations. Clear up the bitmaps and 895 * retag the sensitive kpages again. The storage pages 896 * should be untagged. 897 */ 898 cpr_clear_bitmaps(); 899 900 spages = 901 i_cpr_count_sensitive_kpages(REGULAR_BITMAP, cpr_setbit); 902 vpages = cpr_count_volatile_pages(REGULAR_BITMAP, cpr_clrbit); 903 904 CPR_DEBUG(CPR_DEBUG7, pages_fmt, "after ", str, 905 spages, vpages, spages - vpages); 906 907 /* 908 * Returns 0 on success, -1 if too few descriptors, and 909 * ENOMEM if not enough space to save sensitive pages 910 */ 911 CPR_DEBUG(CPR_DEBUG1, "compressing pages to storage...\n"); 912 error = i_cpr_save_to_storage(); 913 if (error == 0) { 914 /* Saving to storage succeeded */ 915 CPR_DEBUG(CPR_DEBUG1, "compressed %d pages\n", 916 sensitive_pages_saved); 917 break; 918 } else if (error == -1) 919 CPR_DEBUG(CPR_DEBUG1, "%s too few descriptors\n", str); 920 } 921 if (error == -1) 922 error = ENOMEM; 923 return (error); 924 } 925 926 927 /* 928 * Estimate how much memory we will need to save 929 * the sensitive pages with compression. 930 */ 931 static caddr_t 932 i_cpr_storage_data_alloc(pgcnt_t pages, pgcnt_t *alloc_pages, int retry_cnt) 933 { 934 pgcnt_t alloc_pcnt, last_pcnt; 935 caddr_t addr; 936 char *str; 937 938 str = "i_cpr_storage_data_alloc:"; 939 if (retry_cnt == 0) { 940 /* 941 * common compression ratio is about 3:1 942 * initial storage allocation is estimated at 40% 943 * to cover the majority of cases 944 */ 945 alloc_pcnt = INITIAL_ALLOC_PCNT; 946 *alloc_pages = (pages * alloc_pcnt) / INTEGRAL; 947 CPR_DEBUG(CPR_DEBUG7, "%s sensitive pages: %ld\n", str, pages); 948 CPR_DEBUG(CPR_DEBUG7, 949 "%s initial est pages: %ld, alloc %ld%%\n", 950 str, *alloc_pages, alloc_pcnt); 951 } else { 952 /* 953 * calculate the prior compression percentage (x100) 954 * from the last attempt to save sensitive pages 955 */ 956 ASSERT(sensitive_pages_saved != 0); 957 last_pcnt = (mmu_btopr(sensitive_size_saved) * INTEGRAL) / 958 sensitive_pages_saved; 959 CPR_DEBUG(CPR_DEBUG7, "%s last ratio %ld%%\n", str, last_pcnt); 960 961 /* 962 * new estimated storage size is based on 963 * the larger ratio + 5% for each retry: 964 * pages * (last + [5%, 10%]) 965 */ 966 alloc_pcnt = MAX(last_pcnt, INITIAL_ALLOC_PCNT) + 967 (retry_cnt * 5); 968 *alloc_pages = (pages * alloc_pcnt) / INTEGRAL; 969 CPR_DEBUG(CPR_DEBUG7, "%s Retry est pages: %ld, alloc %ld%%\n", 970 str, *alloc_pages, alloc_pcnt); 971 } 972 973 addr = kmem_alloc(mmu_ptob(*alloc_pages), KM_NOSLEEP); 974 CPR_DEBUG(CPR_DEBUG7, "%s alloc %ld pages\n", str, *alloc_pages); 975 return (addr); 976 } 977 978 979 void 980 i_cpr_storage_free(void) 981 { 982 /* Free descriptors */ 983 if (i_cpr_storage_desc_base) { 984 kmem_free(i_cpr_storage_desc_base, 985 mmu_ptob(i_cpr_storage_desc_pgcnt)); 986 i_cpr_storage_desc_base = NULL; 987 i_cpr_storage_desc_pgcnt = 0; 988 } 989 990 991 /* Data storage */ 992 if (i_cpr_storage_data_base) { 993 kmem_free(i_cpr_storage_data_base, 994 mmu_ptob(i_cpr_storage_data_sz)); 995 i_cpr_storage_data_base = NULL; 996 i_cpr_storage_data_sz = 0; 997 } 998 } 999 1000 1001 /* 1002 * This routine is derived from cpr_compress_and_write(). 1003 * 1. Do bookkeeping in the descriptor for the contiguous sensitive chunk. 1004 * 2. Compress and save the clean sensitive pages into the storage area. 1005 */ 1006 int 1007 i_cpr_compress_and_save(int chunks, pfn_t spfn, pgcnt_t pages) 1008 { 1009 extern char *cpr_compress_pages(cpd_t *, pgcnt_t, int); 1010 extern caddr_t i_cpr_storage_data_end; 1011 uint_t remaining, datalen; 1012 uint32_t test_usum; 1013 char *datap; 1014 csd_t *descp; 1015 cpd_t cpd; 1016 int error; 1017 1018 /* 1019 * Fill next empty storage descriptor 1020 */ 1021 descp = i_cpr_storage_desc_base + chunks - 1; 1022 if (descp >= i_cpr_storage_desc_end) { 1023 CPR_DEBUG(CPR_DEBUG1, "ran out of descriptors, base 0x%p, " 1024 "chunks %d, end 0x%p, descp 0x%p\n", 1025 (void *)i_cpr_storage_desc_base, chunks, 1026 (void *)i_cpr_storage_desc_end, (void *)descp); 1027 return (-1); 1028 } 1029 ASSERT(descp->csd_dirty_spfn == (uint_t)-1); 1030 i_cpr_storage_desc_last_used = descp; 1031 1032 descp->csd_dirty_spfn = spfn; 1033 descp->csd_dirty_npages = pages; 1034 1035 i_cpr_mapin(CPR->c_mapping_area, pages, spfn); 1036 1037 /* 1038 * try compressing pages and copy cpd fields 1039 * pfn is copied for debug use 1040 */ 1041 cpd.cpd_pfn = spfn; 1042 datap = cpr_compress_pages(&cpd, pages, C_COMPRESSING); 1043 datalen = cpd.cpd_length; 1044 descp->csd_clean_compressed = (cpd.cpd_flag & CPD_COMPRESS); 1045 #ifdef DEBUG 1046 descp->csd_usum = cpd.cpd_usum; 1047 descp->csd_csum = cpd.cpd_csum; 1048 #endif 1049 1050 error = 0; 1051 1052 /* 1053 * Save the raw or compressed data to the storage area pointed to by 1054 * sensitive_write_ptr. Make sure the storage space is big enough to 1055 * hold the result. Otherwise roll back to increase the storage space. 1056 */ 1057 descp->csd_clean_sva = (cpr_ptr)sensitive_write_ptr; 1058 descp->csd_clean_sz = datalen; 1059 if ((sensitive_write_ptr + datalen) < i_cpr_storage_data_end) { 1060 extern void cprbcopy(void *, void *, size_t); 1061 1062 cprbcopy(datap, sensitive_write_ptr, datalen); 1063 sensitive_size_saved += datalen; 1064 sensitive_pages_saved += descp->csd_dirty_npages; 1065 sensitive_write_ptr += datalen; 1066 } else { 1067 remaining = (i_cpr_storage_data_end - sensitive_write_ptr); 1068 CPR_DEBUG(CPR_DEBUG1, "i_cpr_compress_and_save: The storage " 1069 "space is too small!\ngot %d, want %d\n\n", 1070 remaining, (remaining + datalen)); 1071 #ifdef DEBUG 1072 /* 1073 * Check to see if the content of the sensitive pages that we 1074 * just copied have changed during this small time window. 1075 */ 1076 test_usum = checksum32(CPR->c_mapping_area, mmu_ptob(pages)); 1077 descp->csd_usum = cpd.cpd_usum; 1078 if (test_usum != descp->csd_usum) { 1079 CPR_DEBUG(CPR_DEBUG1, "\nWARNING: " 1080 "i_cpr_compress_and_save: " 1081 "Data in the range of pfn 0x%lx to pfn " 1082 "0x%lx has changed after they are saved " 1083 "into storage.", spfn, (spfn + pages - 1)); 1084 } 1085 #endif 1086 error = ENOMEM; 1087 } 1088 1089 i_cpr_mapout(CPR->c_mapping_area, pages); 1090 return (error); 1091 } 1092 1093 1094 /* 1095 * This routine is derived from cpr_count_kpages(). 1096 * It goes through kernel data nucleus and segkmem segments to select 1097 * pages in use and mark them in the corresponding bitmap. 1098 */ 1099 pgcnt_t 1100 i_cpr_count_sensitive_kpages(int mapflag, bitfunc_t bitfunc) 1101 { 1102 pgcnt_t kdata_cnt = 0, segkmem_cnt = 0; 1103 extern caddr_t e_moddata; 1104 extern struct seg kvalloc; 1105 extern struct seg kmem64; 1106 size_t size; 1107 1108 /* 1109 * Kernel data nucleus pages 1110 */ 1111 size = e_moddata - s_data; 1112 kdata_cnt += cpr_count_pages(s_data, size, 1113 mapflag, bitfunc, DBG_SHOWRANGE); 1114 1115 /* 1116 * kvseg and kvalloc pages 1117 */ 1118 segkmem_cnt += cpr_scan_kvseg(mapflag, bitfunc, &kvseg); 1119 segkmem_cnt += cpr_count_pages(kvalloc.s_base, kvalloc.s_size, 1120 mapflag, bitfunc, DBG_SHOWRANGE); 1121 1122 /* segment to support kernel memory usage above 32-bit space (4GB) */ 1123 if (kmem64.s_base) 1124 segkmem_cnt += cpr_count_pages(kmem64.s_base, kmem64.s_size, 1125 mapflag, bitfunc, DBG_SHOWRANGE); 1126 1127 CPR_DEBUG(CPR_DEBUG7, "\ni_cpr_count_sensitive_kpages:\n" 1128 "\tkdata_cnt %ld + segkmem_cnt %ld = %ld pages\n", 1129 kdata_cnt, segkmem_cnt, kdata_cnt + segkmem_cnt); 1130 1131 return (kdata_cnt + segkmem_cnt); 1132 } 1133 1134 1135 pgcnt_t 1136 i_cpr_count_storage_pages(int mapflag, bitfunc_t bitfunc) 1137 { 1138 pgcnt_t count = 0; 1139 1140 if (i_cpr_storage_desc_base) { 1141 count += cpr_count_pages((caddr_t)i_cpr_storage_desc_base, 1142 (size_t)mmu_ptob(i_cpr_storage_desc_pgcnt), 1143 mapflag, bitfunc, DBG_SHOWRANGE); 1144 } 1145 if (i_cpr_storage_data_base) { 1146 count += cpr_count_pages(i_cpr_storage_data_base, 1147 (size_t)mmu_ptob(i_cpr_storage_data_sz), 1148 mapflag, bitfunc, DBG_SHOWRANGE); 1149 } 1150 return (count); 1151 } 1152 1153 1154 /* 1155 * Derived from cpr_write_statefile(). 1156 * Allocate (or reallocate after exhausting the supply) descriptors for each 1157 * chunk of contiguous sensitive kpages. 1158 */ 1159 static int 1160 i_cpr_storage_desc_alloc(csd_t **basepp, pgcnt_t *pgsp, csd_t **endpp, 1161 int retry) 1162 { 1163 pgcnt_t npages; 1164 int chunks; 1165 csd_t *descp, *end; 1166 size_t len; 1167 char *str = "i_cpr_storage_desc_alloc:"; 1168 1169 /* 1170 * On initial allocation, add some extra to cover overhead caused 1171 * by the allocation for the storage area later. 1172 */ 1173 if (retry == 0) { 1174 chunks = cpr_contig_pages(NULL, STORAGE_DESC_ALLOC) + 1175 EXTRA_DESCS; 1176 npages = mmu_btopr(sizeof (**basepp) * (pgcnt_t)chunks); 1177 CPR_DEBUG(CPR_DEBUG7, "%s chunks %d, ", str, chunks); 1178 } else { 1179 CPR_DEBUG(CPR_DEBUG7, "%s retry %d: ", str, retry); 1180 npages = *pgsp + 1; 1181 } 1182 /* Free old descriptors, if any */ 1183 if (*basepp) 1184 kmem_free((caddr_t)*basepp, mmu_ptob(*pgsp)); 1185 1186 descp = *basepp = kmem_alloc(mmu_ptob(npages), KM_NOSLEEP); 1187 if (descp == NULL) { 1188 CPR_DEBUG(CPR_DEBUG7, "%s no space for descriptors!\n", str); 1189 return (ENOMEM); 1190 } 1191 1192 *pgsp = npages; 1193 len = mmu_ptob(npages); 1194 end = *endpp = descp + (len / (sizeof (**basepp))); 1195 CPR_DEBUG(CPR_DEBUG7, "npages 0x%lx, len 0x%lx, items 0x%lx\n\t*basepp " 1196 "%p, *endpp %p\n", npages, len, (len / (sizeof (**basepp))), 1197 (void *)*basepp, (void *)*endpp); 1198 i_cpr_storage_desc_init(descp, npages, end); 1199 return (0); 1200 } 1201 1202 static void 1203 i_cpr_storage_desc_init(csd_t *descp, pgcnt_t npages, csd_t *end) 1204 { 1205 size_t len = mmu_ptob(npages); 1206 1207 /* Initialize the descriptors to something impossible. */ 1208 bzero(descp, len); 1209 #ifdef DEBUG 1210 /* 1211 * This condition is tested by an ASSERT 1212 */ 1213 for (; descp < end; descp++) 1214 descp->csd_dirty_spfn = (uint_t)-1; 1215 #endif 1216 } 1217 1218 int 1219 i_cpr_dump_sensitive_kpages(vnode_t *vp) 1220 { 1221 int error = 0; 1222 uint_t spin_cnt = 0; 1223 csd_t *descp; 1224 1225 /* 1226 * These following two variables need to be reinitialized 1227 * for each cpr cycle. 1228 */ 1229 i_cpr_sensitive_bytes_dumped = 0; 1230 i_cpr_sensitive_pgs_dumped = 0; 1231 1232 if (i_cpr_storage_desc_base) { 1233 for (descp = i_cpr_storage_desc_base; 1234 descp <= i_cpr_storage_desc_last_used; descp++) { 1235 if (error = cpr_dump_sensitive(vp, descp)) 1236 return (error); 1237 spin_cnt++; 1238 if ((spin_cnt & 0x5F) == 1) 1239 cpr_spinning_bar(); 1240 } 1241 prom_printf(" \b"); 1242 } 1243 1244 CPR_DEBUG(CPR_DEBUG7, "\ni_cpr_dump_sensitive_kpages: dumped %ld\n", 1245 i_cpr_sensitive_pgs_dumped); 1246 return (0); 1247 } 1248 1249 1250 /* 1251 * 1. Fill the cpr page descriptor with the info of the dirty pages 1252 * and 1253 * write the descriptor out. It will be used at resume. 1254 * 2. Write the clean data in stead of the dirty data out. 1255 * Note: to save space, the clean data is already compressed. 1256 */ 1257 static int 1258 cpr_dump_sensitive(vnode_t *vp, csd_t *descp) 1259 { 1260 int error = 0; 1261 caddr_t datap; 1262 cpd_t cpd; /* cpr page descriptor */ 1263 pfn_t dirty_spfn; 1264 pgcnt_t dirty_npages; 1265 size_t clean_sz; 1266 caddr_t clean_sva; 1267 int clean_compressed; 1268 extern uchar_t cpr_pagecopy[]; 1269 1270 dirty_spfn = descp->csd_dirty_spfn; 1271 dirty_npages = descp->csd_dirty_npages; 1272 clean_sva = (caddr_t)descp->csd_clean_sva; 1273 clean_sz = descp->csd_clean_sz; 1274 clean_compressed = descp->csd_clean_compressed; 1275 1276 /* Fill cpr page descriptor. */ 1277 cpd.cpd_magic = (uint_t)CPR_PAGE_MAGIC; 1278 cpd.cpd_pfn = dirty_spfn; 1279 cpd.cpd_flag = 0; /* must init to zero */ 1280 cpd.cpd_pages = dirty_npages; 1281 1282 #ifdef DEBUG 1283 if ((cpd.cpd_usum = descp->csd_usum) != 0) 1284 cpd.cpd_flag |= CPD_USUM; 1285 if ((cpd.cpd_csum = descp->csd_csum) != 0) 1286 cpd.cpd_flag |= CPD_CSUM; 1287 #endif 1288 1289 STAT->cs_dumped_statefsz += mmu_ptob(dirty_npages); 1290 1291 /* 1292 * The sensitive kpages are usually saved with compression 1293 * unless compression could not reduce the size of the data. 1294 * If user choose not to have the statefile compressed, 1295 * we need to decompress the data back before dumping it to disk. 1296 */ 1297 if (CPR->c_flags & C_COMPRESSING) { 1298 cpd.cpd_length = clean_sz; 1299 datap = clean_sva; 1300 if (clean_compressed) 1301 cpd.cpd_flag |= CPD_COMPRESS; 1302 } else { 1303 if (clean_compressed) { 1304 cpd.cpd_length = decompress(clean_sva, cpr_pagecopy, 1305 clean_sz, mmu_ptob(dirty_npages)); 1306 datap = (caddr_t)cpr_pagecopy; 1307 ASSERT(cpd.cpd_length == mmu_ptob(dirty_npages)); 1308 } else { 1309 cpd.cpd_length = clean_sz; 1310 datap = clean_sva; 1311 } 1312 cpd.cpd_csum = 0; 1313 } 1314 1315 /* Write cpr page descriptor */ 1316 error = cpr_write(vp, (caddr_t)&cpd, sizeof (cpd)); 1317 if (error) { 1318 CPR_DEBUG(CPR_DEBUG7, "descp: %p\n", (void *)descp); 1319 #ifdef DEBUG 1320 debug_enter("cpr_dump_sensitive: cpr_write() page " 1321 "descriptor failed!\n"); 1322 #endif 1323 return (error); 1324 } 1325 1326 i_cpr_sensitive_bytes_dumped += sizeof (cpd_t); 1327 1328 /* Write page data */ 1329 error = cpr_write(vp, (caddr_t)datap, cpd.cpd_length); 1330 if (error) { 1331 CPR_DEBUG(CPR_DEBUG7, "error: %x\n", error); 1332 CPR_DEBUG(CPR_DEBUG7, "descp: %p\n", (void *)descp); 1333 CPR_DEBUG(CPR_DEBUG7, "cpr_write(%p, %p , %lx)\n", 1334 (void *)vp, (void *)datap, cpd.cpd_length); 1335 #ifdef DEBUG 1336 debug_enter("cpr_dump_sensitive: cpr_write() data failed!\n"); 1337 #endif 1338 return (error); 1339 } 1340 1341 i_cpr_sensitive_bytes_dumped += cpd.cpd_length; 1342 i_cpr_sensitive_pgs_dumped += dirty_npages; 1343 1344 return (error); 1345 } 1346 1347 1348 /* 1349 * Sanity check to make sure that we have dumped right amount 1350 * of pages from different sources to statefile. 1351 */ 1352 int 1353 i_cpr_check_pgs_dumped(uint_t pgs_expected, uint_t regular_pgs_dumped) 1354 { 1355 uint_t total_pgs_dumped; 1356 1357 total_pgs_dumped = regular_pgs_dumped + i_cpr_sensitive_pgs_dumped; 1358 1359 CPR_DEBUG(CPR_DEBUG7, "\ncheck_pgs: reg %d + sens %ld = %d, " 1360 "expect %d\n\n", regular_pgs_dumped, i_cpr_sensitive_pgs_dumped, 1361 total_pgs_dumped, pgs_expected); 1362 1363 if (pgs_expected == total_pgs_dumped) 1364 return (0); 1365 1366 return (EINVAL); 1367 } 1368 1369 1370 int 1371 i_cpr_reusefini(void) 1372 { 1373 struct vnode *vp; 1374 cdef_t *cdef; 1375 size_t size; 1376 char *bufp; 1377 int rc; 1378 1379 if (cpr_reusable_mode) 1380 cpr_reusable_mode = 0; 1381 1382 if (rc = cpr_open_deffile(FREAD|FWRITE, &vp)) { 1383 if (rc == EROFS) { 1384 cpr_err(CE_CONT, "uadmin A_FREEZE AD_REUSEFINI " 1385 "(uadmin %d %d)\nmust be done with / mounted " 1386 "writeable.\n", A_FREEZE, AD_REUSEFINI); 1387 } 1388 return (rc); 1389 } 1390 1391 cdef = kmem_alloc(sizeof (*cdef), KM_SLEEP); 1392 rc = cpr_rdwr(UIO_READ, vp, cdef, sizeof (*cdef)); 1393 1394 if (rc) { 1395 cpr_err(CE_WARN, "Failed reading %s, errno = %d", 1396 cpr_default_path, rc); 1397 } else if (cdef->mini.magic != CPR_DEFAULT_MAGIC) { 1398 cpr_err(CE_WARN, "bad magic number in %s, cannot restore " 1399 "prom values for %s", cpr_default_path, 1400 cpr_enumerate_promprops(&bufp, &size)); 1401 kmem_free(bufp, size); 1402 rc = EINVAL; 1403 } else { 1404 /* 1405 * clean up prom properties 1406 */ 1407 rc = cpr_update_nvram(cdef->props); 1408 if (rc == 0) { 1409 /* 1410 * invalidate the disk copy and turn off reusable 1411 */ 1412 cdef->mini.magic = 0; 1413 cdef->mini.reusable = 0; 1414 if (rc = cpr_rdwr(UIO_WRITE, vp, 1415 &cdef->mini, sizeof (cdef->mini))) { 1416 cpr_err(CE_WARN, "Failed writing %s, errno %d", 1417 cpr_default_path, rc); 1418 } 1419 } 1420 } 1421 1422 (void) VOP_CLOSE(vp, FREAD|FWRITE, 1, (offset_t)0, CRED(), NULL); 1423 VN_RELE(vp); 1424 kmem_free(cdef, sizeof (*cdef)); 1425 1426 return (rc); 1427 } 1428 1429 1430 int 1431 i_cpr_reuseinit(void) 1432 { 1433 int rc = 0; 1434 1435 if (rc = cpr_default_setup(1)) 1436 return (rc); 1437 1438 /* 1439 * We need to validate default file 1440 */ 1441 rc = cpr_validate_definfo(1); 1442 if (rc == 0) 1443 cpr_reusable_mode = 1; 1444 else if (rc == EROFS) { 1445 cpr_err(CE_NOTE, "reuseinit must be performed " 1446 "while / is mounted writeable"); 1447 } 1448 1449 (void) cpr_default_setup(0); 1450 1451 return (rc); 1452 } 1453 1454 1455 int 1456 i_cpr_check_cprinfo(void) 1457 { 1458 struct vnode *vp; 1459 cmini_t mini; 1460 int rc = 0; 1461 1462 if (rc = cpr_open_deffile(FREAD, &vp)) { 1463 if (rc == ENOENT) 1464 cpr_err(CE_NOTE, "cprinfo file does not " 1465 "exist. You must run 'uadmin %d %d' " 1466 "command while / is mounted writeable,\n" 1467 "then reboot and run 'uadmin %d %d' " 1468 "to create a reusable statefile", 1469 A_FREEZE, AD_REUSEINIT, A_FREEZE, AD_REUSABLE); 1470 return (rc); 1471 } 1472 1473 rc = cpr_rdwr(UIO_READ, vp, &mini, sizeof (mini)); 1474 (void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED(), NULL); 1475 VN_RELE(vp); 1476 1477 if (rc) { 1478 cpr_err(CE_WARN, "Failed reading %s, errno = %d", 1479 cpr_default_path, rc); 1480 } else if (mini.magic != CPR_DEFAULT_MAGIC) { 1481 cpr_err(CE_CONT, "bad magic number in cprinfo file.\n" 1482 "You must run 'uadmin %d %d' while / is mounted " 1483 "writeable, then reboot and run 'uadmin %d %d' " 1484 "to create a reusable statefile\n", 1485 A_FREEZE, AD_REUSEINIT, A_FREEZE, AD_REUSABLE); 1486 rc = EINVAL; 1487 } 1488 1489 return (rc); 1490 } 1491 1492 1493 int 1494 i_cpr_reusable_supported(void) 1495 { 1496 return (1); 1497 } 1498 1499 1500 /* 1501 * find prom phys pages and alloc space for a tmp copy 1502 */ 1503 static int 1504 i_cpr_find_ppages(void) 1505 { 1506 struct page *pp; 1507 struct memlist *pmem; 1508 pgcnt_t npages, pcnt, scnt, vcnt; 1509 pfn_t ppn, plast, *dst; 1510 int mapflag; 1511 1512 cpr_clear_bitmaps(); 1513 mapflag = REGULAR_BITMAP; 1514 1515 /* 1516 * there should be a page_t for each phys page used by the kernel; 1517 * set a bit for each phys page not tracked by a page_t 1518 */ 1519 pcnt = 0; 1520 memlist_read_lock(); 1521 for (pmem = phys_install; pmem; pmem = pmem->ml_next) { 1522 npages = mmu_btop(pmem->ml_size); 1523 ppn = mmu_btop(pmem->ml_address); 1524 for (plast = ppn + npages; ppn < plast; ppn++) { 1525 if (page_numtopp_nolock(ppn)) 1526 continue; 1527 (void) cpr_setbit(ppn, mapflag); 1528 pcnt++; 1529 } 1530 } 1531 memlist_read_unlock(); 1532 1533 /* 1534 * clear bits for phys pages in each segment 1535 */ 1536 scnt = cpr_count_seg_pages(mapflag, cpr_clrbit); 1537 1538 /* 1539 * set bits for phys pages referenced by the promvp vnode; 1540 * these pages are mostly comprised of forthdebug words 1541 */ 1542 vcnt = 0; 1543 for (pp = promvp.v_pages; pp; ) { 1544 if (cpr_setbit(pp->p_offset, mapflag) == 0) 1545 vcnt++; 1546 pp = pp->p_vpnext; 1547 if (pp == promvp.v_pages) 1548 break; 1549 } 1550 1551 /* 1552 * total number of prom pages are: 1553 * (non-page_t pages - seg pages + vnode pages) 1554 */ 1555 ppage_count = pcnt - scnt + vcnt; 1556 CPR_DEBUG(CPR_DEBUG1, 1557 "find_ppages: pcnt %ld - scnt %ld + vcnt %ld = %ld\n", 1558 pcnt, scnt, vcnt, ppage_count); 1559 1560 /* 1561 * alloc array of pfn_t to store phys page list 1562 */ 1563 pphys_list_size = ppage_count * sizeof (pfn_t); 1564 pphys_list = kmem_alloc(pphys_list_size, KM_NOSLEEP); 1565 if (pphys_list == NULL) { 1566 cpr_err(CE_WARN, "cannot alloc pphys_list"); 1567 return (ENOMEM); 1568 } 1569 1570 /* 1571 * phys pages referenced in the bitmap should be 1572 * those used by the prom; scan bitmap and save 1573 * a list of prom phys page numbers 1574 */ 1575 dst = pphys_list; 1576 memlist_read_lock(); 1577 for (pmem = phys_install; pmem; pmem = pmem->ml_next) { 1578 npages = mmu_btop(pmem->ml_size); 1579 ppn = mmu_btop(pmem->ml_address); 1580 for (plast = ppn + npages; ppn < plast; ppn++) { 1581 if (cpr_isset(ppn, mapflag)) { 1582 ASSERT(dst < (pphys_list + ppage_count)); 1583 *dst++ = ppn; 1584 } 1585 } 1586 } 1587 memlist_read_unlock(); 1588 1589 /* 1590 * allocate space to store prom pages 1591 */ 1592 ppage_buf = kmem_alloc(mmu_ptob(ppage_count), KM_NOSLEEP); 1593 if (ppage_buf == NULL) { 1594 kmem_free(pphys_list, pphys_list_size); 1595 pphys_list = NULL; 1596 cpr_err(CE_WARN, "cannot alloc ppage_buf"); 1597 return (ENOMEM); 1598 } 1599 1600 return (0); 1601 } 1602 1603 1604 /* 1605 * save prom pages to kmem pages 1606 */ 1607 static void 1608 i_cpr_save_ppages(void) 1609 { 1610 pfn_t *pphys, *plast; 1611 caddr_t dst; 1612 1613 /* 1614 * map in each prom page and copy to a kmem page 1615 */ 1616 dst = ppage_buf; 1617 plast = pphys_list + ppage_count; 1618 for (pphys = pphys_list; pphys < plast; pphys++) { 1619 i_cpr_mapin(cpr_vaddr, 1, *pphys); 1620 bcopy(cpr_vaddr, dst, MMU_PAGESIZE); 1621 i_cpr_mapout(cpr_vaddr, 1); 1622 dst += MMU_PAGESIZE; 1623 } 1624 1625 CPR_DEBUG(CPR_DEBUG1, "saved %ld prom pages\n", ppage_count); 1626 } 1627 1628 1629 /* 1630 * restore prom pages from kmem pages 1631 */ 1632 static void 1633 i_cpr_restore_ppages(void) 1634 { 1635 pfn_t *pphys, *plast; 1636 caddr_t src; 1637 1638 dcache_flushall(); 1639 1640 /* 1641 * map in each prom page and copy from a kmem page 1642 */ 1643 src = ppage_buf; 1644 plast = pphys_list + ppage_count; 1645 for (pphys = pphys_list; pphys < plast; pphys++) { 1646 i_cpr_mapin(cpr_vaddr, 1, *pphys); 1647 bcopy(src, cpr_vaddr, MMU_PAGESIZE); 1648 i_cpr_mapout(cpr_vaddr, 1); 1649 src += MMU_PAGESIZE; 1650 } 1651 1652 dcache_flushall(); 1653 1654 CPR_DEBUG(CPR_DEBUG1, "restored %ld prom pages\n", ppage_count); 1655 } 1656 1657 1658 /* 1659 * save/restore prom pages or free related allocs 1660 */ 1661 int 1662 i_cpr_prom_pages(int action) 1663 { 1664 int error; 1665 1666 if (action == CPR_PROM_SAVE) { 1667 if (ppage_buf == NULL) { 1668 ASSERT(pphys_list == NULL); 1669 if (error = i_cpr_find_ppages()) 1670 return (error); 1671 i_cpr_save_ppages(); 1672 } 1673 } else if (action == CPR_PROM_RESTORE) { 1674 i_cpr_restore_ppages(); 1675 } else if (action == CPR_PROM_FREE) { 1676 if (pphys_list) { 1677 ASSERT(pphys_list_size); 1678 kmem_free(pphys_list, pphys_list_size); 1679 pphys_list = NULL; 1680 pphys_list_size = 0; 1681 } 1682 if (ppage_buf) { 1683 ASSERT(ppage_count); 1684 kmem_free(ppage_buf, mmu_ptob(ppage_count)); 1685 CPR_DEBUG(CPR_DEBUG1, "freed %ld prom pages\n", 1686 ppage_count); 1687 ppage_buf = NULL; 1688 ppage_count = 0; 1689 } 1690 } 1691 return (0); 1692 } 1693 1694 1695 /* 1696 * record tlb data for the nucleus, bigktsb's, and the cpr module; 1697 * this data is later used by cprboot to install dtlb/itlb entries. 1698 * when we jump into the cpr module during the resume phase, those 1699 * mappings are needed until switching to the kernel trap table. 1700 * to make the dtte/itte info available during resume, we need 1701 * the info recorded prior to saving sensitive pages, otherwise 1702 * all the data would appear as NULLs. 1703 */ 1704 static void 1705 i_cpr_save_tlbinfo(void) 1706 { 1707 cti_t cti = {0}; 1708 1709 /* 1710 * during resume - shortly after jumping into the cpr module, 1711 * sfmmu_load_mmustate() will overwrite any dtlb entry at any 1712 * index used for TSBs; skip is set so that any saved tte will 1713 * target other tlb offsets and prevent being lost during 1714 * resume. now scan the dtlb and save locked entries, 1715 * then add entries for the tmp stack / data page and the 1716 * cpr thread structure. 1717 */ 1718 cti.dst = m_info.dtte; 1719 cti.tail = cti.dst + CPR_MAX_TLB; 1720 cti.reader = dtlb_rd_entry; 1721 cti.writer = NULL; 1722 cti.filter = i_cpr_lnb; 1723 cti.index = cpunodes[CPU->cpu_id].dtlb_size - 1; 1724 1725 if (utsb_dtlb_ttenum != -1) 1726 cti.skip = (1 << utsb_dtlb_ttenum); 1727 1728 if (utsb4m_dtlb_ttenum != -1) 1729 cti.skip |= (1 << utsb4m_dtlb_ttenum); 1730 1731 i_cpr_scan_tlb(&cti); 1732 i_cpr_make_tte(&cti, &i_cpr_data_page, datava); 1733 i_cpr_make_tte(&cti, curthread, datava); 1734 1735 /* 1736 * scan itlb and save locked entries; add an entry for 1737 * the first text page of the cpr module; cprboot will 1738 * jump to that page after restoring kernel pages. 1739 */ 1740 cti.dst = m_info.itte; 1741 cti.tail = cti.dst + CPR_MAX_TLB; 1742 cti.reader = itlb_rd_entry; 1743 cti.index = cpunodes[CPU->cpu_id].itlb_size - 1; 1744 cti.skip = 0; 1745 i_cpr_scan_tlb(&cti); 1746 i_cpr_make_tte(&cti, (void *)i_cpr_resume_setup, textva); 1747 } 1748 1749 1750 /* ARGSUSED */ 1751 int 1752 i_cpr_dump_setup(vnode_t *vp) 1753 { 1754 /* 1755 * zero out m_info and add info to dtte/itte arrays 1756 */ 1757 bzero(&m_info, sizeof (m_info)); 1758 i_cpr_save_tlbinfo(); 1759 return (0); 1760 } 1761 1762 1763 int 1764 i_cpr_is_supported(int sleeptype) 1765 { 1766 char es_prop[] = "energystar-v2"; 1767 pnode_t node; 1768 int last; 1769 extern int cpr_supported_override; 1770 extern int cpr_platform_enable; 1771 1772 if (sleeptype != CPR_TODISK) 1773 return (0); 1774 1775 /* 1776 * The next statement tests if a specific platform has turned off 1777 * cpr support. 1778 */ 1779 if (cpr_supported_override) 1780 return (0); 1781 1782 /* 1783 * Do not inspect energystar-v* property if a platform has 1784 * specifically turned on cpr support 1785 */ 1786 if (cpr_platform_enable) 1787 return (1); 1788 1789 node = prom_rootnode(); 1790 if (prom_getproplen(node, es_prop) != -1) 1791 return (1); 1792 last = strlen(es_prop) - 1; 1793 es_prop[last] = '3'; 1794 return (prom_getproplen(node, es_prop) != -1); 1795 } 1796 1797 1798 /* 1799 * the actual size of the statefile data isn't known until after all the 1800 * compressed pages are written; even the inode size doesn't reflect the 1801 * data size since there are usually many extra fs blocks. for recording 1802 * the actual data size, the first sector of the statefile is copied to 1803 * a tmp buf, and the copy is later updated and flushed to disk. 1804 */ 1805 int 1806 i_cpr_blockzero(char *base, char **bufpp, int *blkno, vnode_t *vp) 1807 { 1808 extern int cpr_flush_write(vnode_t *); 1809 static char cpr_sector[DEV_BSIZE]; 1810 cpr_ext bytes, *dst; 1811 1812 /* 1813 * this routine is called after cdd_t and csu_md_t are copied 1814 * to cpr_buf; mini-hack alert: the save/update method creates 1815 * a dependency on the combined struct size being >= one sector 1816 * or DEV_BSIZE; since introduction in Sol2.7, csu_md_t size is 1817 * over 1K bytes and will probably grow with any changes. 1818 * 1819 * copy when vp is NULL, flush when non-NULL 1820 */ 1821 if (vp == NULL) { 1822 ASSERT((*bufpp - base) >= DEV_BSIZE); 1823 bcopy(base, cpr_sector, sizeof (cpr_sector)); 1824 return (0); 1825 } else { 1826 bytes = dbtob(*blkno); 1827 dst = &((cdd_t *)cpr_sector)->cdd_filesize; 1828 bcopy(&bytes, dst, sizeof (bytes)); 1829 bcopy(cpr_sector, base, sizeof (cpr_sector)); 1830 *bufpp = base + sizeof (cpr_sector); 1831 *blkno = cpr_statefile_offset(); 1832 CPR_DEBUG(CPR_DEBUG1, "statefile data size: %ld\n\n", bytes); 1833 return (cpr_flush_write(vp)); 1834 } 1835 } 1836 1837 1838 /* 1839 * Allocate bitmaps according to the phys_install list. 1840 */ 1841 static int 1842 i_cpr_bitmap_setup(void) 1843 { 1844 struct memlist *pmem; 1845 cbd_t *dp, *tail; 1846 void *space; 1847 size_t size; 1848 1849 /* 1850 * The number of bitmap descriptors will be the count of 1851 * phys_install ranges plus 1 for a trailing NULL struct. 1852 */ 1853 cpr_nbitmaps = 1; 1854 for (pmem = phys_install; pmem; pmem = pmem->ml_next) 1855 cpr_nbitmaps++; 1856 1857 if (cpr_nbitmaps > (CPR_MAX_BMDESC - 1)) { 1858 cpr_err(CE_WARN, "too many physical memory ranges %d, max %d", 1859 cpr_nbitmaps, CPR_MAX_BMDESC - 1); 1860 return (EFBIG); 1861 } 1862 1863 /* Alloc an array of bitmap descriptors. */ 1864 dp = kmem_zalloc(cpr_nbitmaps * sizeof (*dp), KM_NOSLEEP); 1865 if (dp == NULL) { 1866 cpr_nbitmaps = 0; 1867 return (ENOMEM); 1868 } 1869 tail = dp + cpr_nbitmaps; 1870 1871 CPR->c_bmda = dp; 1872 for (pmem = phys_install; pmem; pmem = pmem->ml_next) { 1873 size = BITMAP_BYTES(pmem->ml_size); 1874 space = kmem_zalloc(size * 2, KM_NOSLEEP); 1875 if (space == NULL) 1876 return (ENOMEM); 1877 ASSERT(dp < tail); 1878 dp->cbd_magic = CPR_BITMAP_MAGIC; 1879 dp->cbd_spfn = mmu_btop(pmem->ml_address); 1880 dp->cbd_epfn = mmu_btop(pmem->ml_address + pmem->ml_size) - 1; 1881 dp->cbd_size = size; 1882 dp->cbd_reg_bitmap = (cpr_ptr)space; 1883 dp->cbd_vlt_bitmap = (cpr_ptr)((caddr_t)space + size); 1884 dp++; 1885 } 1886 1887 /* set magic for the last descriptor */ 1888 ASSERT(dp == (tail - 1)); 1889 dp->cbd_magic = CPR_BITMAP_MAGIC; 1890 1891 return (0); 1892 } 1893 1894 1895 void 1896 i_cpr_bitmap_cleanup(void) 1897 { 1898 cbd_t *dp; 1899 1900 if (CPR->c_bmda == NULL) 1901 return; 1902 for (dp = CPR->c_bmda; dp->cbd_size; dp++) 1903 kmem_free((void *)dp->cbd_reg_bitmap, dp->cbd_size * 2); 1904 kmem_free(CPR->c_bmda, cpr_nbitmaps * sizeof (*CPR->c_bmda)); 1905 CPR->c_bmda = NULL; 1906 cpr_nbitmaps = 0; 1907 } 1908 1909 1910 /* 1911 * A "regular" and "volatile" bitmap are created for each range of 1912 * physical memory. The volatile maps are used to count and track pages 1913 * susceptible to heap corruption - caused by drivers that allocate mem 1914 * during VOP_DUMP(); the regular maps are used for all the other non- 1915 * susceptible pages. Before writing the bitmaps to the statefile, 1916 * each bitmap pair gets merged to simplify handling within cprboot. 1917 */ 1918 int 1919 i_cpr_alloc_bitmaps(void) 1920 { 1921 int err; 1922 1923 memlist_read_lock(); 1924 err = i_cpr_bitmap_setup(); 1925 memlist_read_unlock(); 1926 if (err) 1927 i_cpr_bitmap_cleanup(); 1928 return (err); 1929 } 1930 1931 1932 1933 /* 1934 * Power down the system. 1935 */ 1936 int 1937 i_cpr_power_down(int sleeptype) 1938 { 1939 int is_defined = 0; 1940 char *wordexists = "p\" power-off\" find nip swap l! "; 1941 char *req = "power-off"; 1942 1943 ASSERT(sleeptype == CPR_TODISK); 1944 1945 /* 1946 * is_defined has value -1 when defined 1947 */ 1948 prom_interpret(wordexists, (uintptr_t)&is_defined, 0, 0, 0, 0); 1949 if (is_defined) { 1950 CPR_DEBUG(CPR_DEBUG1, "\ncpr: %s...\n", req); 1951 prom_interpret(req, 0, 0, 0, 0, 0); 1952 } 1953 /* 1954 * Only returns if failed 1955 */ 1956 return (EIO); 1957 } 1958 1959 void 1960 i_cpr_stop_other_cpus(void) 1961 { 1962 stop_other_cpus(); 1963 } 1964 1965 /* 1966 * Save context for the specified CPU 1967 */ 1968 /* ARGSUSED */ 1969 void * 1970 i_cpr_save_context(void *arg) 1971 { 1972 /* 1973 * Not yet 1974 */ 1975 ASSERT(0); 1976 return (NULL); 1977 } 1978 1979 void 1980 i_cpr_pre_resume_cpus(void) 1981 { 1982 /* 1983 * Not yet 1984 */ 1985 ASSERT(0); 1986 } 1987 1988 void 1989 i_cpr_post_resume_cpus(void) 1990 { 1991 /* 1992 * Not yet 1993 */ 1994 ASSERT(0); 1995 } 1996 1997 /* 1998 * nothing to do 1999 */ 2000 void 2001 i_cpr_alloc_cpus(void) 2002 { 2003 } 2004 2005 /* 2006 * nothing to do 2007 */ 2008 void 2009 i_cpr_free_cpus(void) 2010 { 2011 } 2012 2013 /* ARGSUSED */ 2014 void 2015 i_cpr_save_configuration(dev_info_t *dip) 2016 { 2017 /* 2018 * this is a no-op on sparc 2019 */ 2020 } 2021 2022 /* ARGSUSED */ 2023 void 2024 i_cpr_restore_configuration(dev_info_t *dip) 2025 { 2026 /* 2027 * this is a no-op on sparc 2028 */ 2029 }