1 /*- 2 * Copyright (c) 1986, 1988, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include "opt_ddb.h" 41 #include "opt_kdb.h" 42 #include "opt_panic.h" 43 #include "opt_sched.h" 44 #include "opt_watchdog.h" 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/bio.h> 49 #include <sys/buf.h> 50 #include <sys/conf.h> 51 #include <sys/cons.h> 52 #include <sys/eventhandler.h> 53 #include <sys/jail.h> 54 #include <sys/kdb.h> 55 #include <sys/kernel.h> 56 #include <sys/kerneldump.h> 57 #include <sys/kthread.h> 58 #include <sys/ktr.h> 59 #include <sys/malloc.h> 60 #include <sys/mount.h> 61 #include <sys/priv.h> 62 #include <sys/proc.h> 63 #include <sys/reboot.h> 64 #include <sys/resourcevar.h> 65 #include <sys/rwlock.h> 66 #include <sys/sched.h> 67 #include <sys/smp.h> 68 #include <sys/sysctl.h> 69 #include <sys/sysproto.h> 70 #include <sys/vnode.h> 71 #include <sys/watchdog.h> 72 73 #include <ddb/ddb.h> 74 75 #include <machine/cpu.h> 76 #include <machine/dump.h> 77 #include <machine/pcb.h> 78 #include <machine/smp.h> 79 80 #include <security/mac/mac_framework.h> 81 82 #include <vm/vm.h> 83 #include <vm/vm_object.h> 84 #include <vm/vm_page.h> 85 #include <vm/vm_pager.h> 86 #include <vm/swap_pager.h> 87 88 #include <sys/signalvar.h> 89 90 #ifndef PANIC_REBOOT_WAIT_TIME 91 #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */ 92 #endif 93 static int panic_reboot_wait_time = PANIC_REBOOT_WAIT_TIME; 94 SYSCTL_INT(_kern, OID_AUTO, panic_reboot_wait_time, CTLFLAG_RWTUN, 95 &panic_reboot_wait_time, 0, 96 "Seconds to wait before rebooting after a panic"); 97 98 /* 99 * Note that stdarg.h and the ANSI style va_start macro is used for both 100 * ANSI and traditional C compilers. 101 */ 102 #include <machine/stdarg.h> 103 104 #ifdef KDB 105 #ifdef KDB_UNATTENDED 106 int debugger_on_panic = 0; 107 #else 108 int debugger_on_panic = 1; 109 #endif 110 SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic, 111 CTLFLAG_RWTUN | CTLFLAG_SECURE, 112 &debugger_on_panic, 0, "Run debugger on kernel panic"); 113 114 #ifdef KDB_TRACE 115 static int trace_on_panic = 1; 116 #else 117 static int trace_on_panic = 0; 118 #endif 119 SYSCTL_INT(_debug, OID_AUTO, trace_on_panic, 120 CTLFLAG_RWTUN | CTLFLAG_SECURE, 121 &trace_on_panic, 0, "Print stack trace on kernel panic"); 122 #endif /* KDB */ 123 124 static int sync_on_panic = 0; 125 SYSCTL_INT(_kern, OID_AUTO, sync_on_panic, CTLFLAG_RWTUN, 126 &sync_on_panic, 0, "Do a sync before rebooting from a panic"); 127 128 static SYSCTL_NODE(_kern, OID_AUTO, shutdown, CTLFLAG_RW, 0, 129 "Shutdown environment"); 130 131 #ifndef DIAGNOSTIC 132 static int show_busybufs; 133 #else 134 static int show_busybufs = 1; 135 #endif 136 SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW, 137 &show_busybufs, 0, ""); 138 139 /* 140 * Variable panicstr contains argument to first call to panic; used as flag 141 * to indicate that the kernel has already called panic. 142 */ 143 const char *panicstr; 144 145 int dumping; /* system is dumping */ 146 int rebooting; /* system is rebooting */ 147 static struct dumperinfo dumper; /* our selected dumper */ 148 149 /* Context information for dump-debuggers. */ 150 static struct pcb dumppcb; /* Registers. */ 151 lwpid_t dumptid; /* Thread ID. */ 152 153 static void poweroff_wait(void *, int); 154 static void shutdown_halt(void *junk, int howto); 155 static void shutdown_panic(void *junk, int howto); 156 static void shutdown_reset(void *junk, int howto); 157 158 /* register various local shutdown events */ 159 static void 160 shutdown_conf(void *unused) 161 { 162 163 EVENTHANDLER_REGISTER(shutdown_final, poweroff_wait, NULL, 164 SHUTDOWN_PRI_FIRST); 165 EVENTHANDLER_REGISTER(shutdown_final, shutdown_halt, NULL, 166 SHUTDOWN_PRI_LAST + 100); 167 EVENTHANDLER_REGISTER(shutdown_final, shutdown_panic, NULL, 168 SHUTDOWN_PRI_LAST + 100); 169 EVENTHANDLER_REGISTER(shutdown_final, shutdown_reset, NULL, 170 SHUTDOWN_PRI_LAST + 200); 171 } 172 173 SYSINIT(shutdown_conf, SI_SUB_INTRINSIC, SI_ORDER_ANY, shutdown_conf, NULL); 174 175 /* 176 * The system call that results in a reboot. 177 */ 178 /* ARGSUSED */ 179 int 180 sys_reboot(struct thread *td, struct reboot_args *uap) 181 { 182 int error; 183 184 error = 0; 185 #ifdef MAC 186 error = mac_system_check_reboot(td->td_ucred, uap->opt); 187 #endif 188 if (error == 0) 189 error = priv_check(td, PRIV_REBOOT); 190 if (error == 0) { 191 mtx_lock(&Giant); 192 kern_reboot(uap->opt); 193 mtx_unlock(&Giant); 194 } 195 return (error); 196 } 197 198 /* 199 * Called by events that want to shut down.. e.g <CTL><ALT><DEL> on a PC 200 */ 201 void 202 shutdown_nice(int howto) 203 { 204 205 if (initproc != NULL) { 206 /* Send a signal to init(8) and have it shutdown the world. */ 207 PROC_LOCK(initproc); 208 if (howto & RB_POWEROFF) 209 kern_psignal(initproc, SIGUSR2); 210 else if (howto & RB_HALT) 211 kern_psignal(initproc, SIGUSR1); 212 else 213 kern_psignal(initproc, SIGINT); 214 PROC_UNLOCK(initproc); 215 } else { 216 /* No init(8) running, so simply reboot. */ 217 kern_reboot(howto | RB_NOSYNC); 218 } 219 } 220 221 static void 222 print_uptime(void) 223 { 224 int f; 225 struct timespec ts; 226 227 getnanouptime(&ts); 228 printf("Uptime: "); 229 f = 0; 230 if (ts.tv_sec >= 86400) { 231 printf("%ldd", (long)ts.tv_sec / 86400); 232 ts.tv_sec %= 86400; 233 f = 1; 234 } 235 if (f || ts.tv_sec >= 3600) { 236 printf("%ldh", (long)ts.tv_sec / 3600); 237 ts.tv_sec %= 3600; 238 f = 1; 239 } 240 if (f || ts.tv_sec >= 60) { 241 printf("%ldm", (long)ts.tv_sec / 60); 242 ts.tv_sec %= 60; 243 f = 1; 244 } 245 printf("%lds\n", (long)ts.tv_sec); 246 } 247 248 int 249 doadump(boolean_t textdump) 250 { 251 boolean_t coredump; 252 int error; 253 254 error = 0; 255 if (dumping) 256 return (EBUSY); 257 if (dumper.dumper == NULL) 258 return (ENXIO); 259 260 savectx(&dumppcb); 261 dumptid = curthread->td_tid; 262 dumping++; 263 264 coredump = TRUE; 265 #ifdef DDB 266 if (textdump && textdump_pending) { 267 coredump = FALSE; 268 textdump_dumpsys(&dumper); 269 } 270 #endif 271 if (coredump) 272 error = dumpsys(&dumper); 273 274 dumping--; 275 return (error); 276 } 277 278 /* 279 * Shutdown the system cleanly to prepare for reboot, halt, or power off. 280 */ 281 void 282 kern_reboot(int howto) 283 { 284 static int once = 0; 285 286 #if defined(SMP) 287 /* 288 * Bind us to CPU 0 so that all shutdown code runs there. Some 289 * systems don't shutdown properly (i.e., ACPI power off) if we 290 * run on another processor. 291 */ 292 if (!SCHEDULER_STOPPED()) { 293 thread_lock(curthread); 294 sched_bind(curthread, 0); 295 thread_unlock(curthread); 296 KASSERT(PCPU_GET(cpuid) == 0, ("boot: not running on cpu 0")); 297 } 298 #endif 299 /* We're in the process of rebooting. */ 300 rebooting = 1; 301 302 /* We are out of the debugger now. */ 303 kdb_active = 0; 304 305 /* 306 * Do any callouts that should be done BEFORE syncing the filesystems. 307 */ 308 EVENTHANDLER_INVOKE(shutdown_pre_sync, howto); 309 310 /* 311 * Now sync filesystems 312 */ 313 if (!cold && (howto & RB_NOSYNC) == 0 && once == 0) { 314 once = 1; 315 bufshutdown(show_busybufs); 316 } 317 318 print_uptime(); 319 320 cngrab(); 321 322 /* 323 * Ok, now do things that assume all filesystem activity has 324 * been completed. 325 */ 326 EVENTHANDLER_INVOKE(shutdown_post_sync, howto); 327 328 if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold && !dumping) 329 doadump(TRUE); 330 331 /* Now that we're going to really halt the system... */ 332 EVENTHANDLER_INVOKE(shutdown_final, howto); 333 334 for(;;) ; /* safety against shutdown_reset not working */ 335 /* NOTREACHED */ 336 } 337 338 /* 339 * If the shutdown was a clean halt, behave accordingly. 340 */ 341 static void 342 shutdown_halt(void *junk, int howto) 343 { 344 345 if (howto & RB_HALT) { 346 printf("\n"); 347 printf("The operating system has halted.\n"); 348 printf("Please press any key to reboot.\n\n"); 349 switch (cngetc()) { 350 case -1: /* No console, just die */ 351 cpu_halt(); 352 /* NOTREACHED */ 353 default: 354 howto &= ~RB_HALT; 355 break; 356 } 357 } 358 } 359 360 /* 361 * Check to see if the system paniced, pause and then reboot 362 * according to the specified delay. 363 */ 364 static void 365 shutdown_panic(void *junk, int howto) 366 { 367 int loop; 368 369 if (howto & RB_DUMP) { 370 if (panic_reboot_wait_time != 0) { 371 if (panic_reboot_wait_time != -1) { 372 printf("Automatic reboot in %d seconds - " 373 "press a key on the console to abort\n", 374 panic_reboot_wait_time); 375 for (loop = panic_reboot_wait_time * 10; 376 loop > 0; --loop) { 377 DELAY(1000 * 100); /* 1/10th second */ 378 /* Did user type a key? */ 379 if (cncheckc() != -1) 380 break; 381 } 382 if (!loop) 383 return; 384 } 385 } else { /* zero time specified - reboot NOW */ 386 return; 387 } 388 printf("--> Press a key on the console to reboot,\n"); 389 printf("--> or switch off the system now.\n"); 390 cngetc(); 391 } 392 } 393 394 /* 395 * Everything done, now reset 396 */ 397 static void 398 shutdown_reset(void *junk, int howto) 399 { 400 401 printf("Rebooting...\n"); 402 DELAY(1000000); /* wait 1 sec for printf's to complete and be read */ 403 404 /* 405 * Acquiring smp_ipi_mtx here has a double effect: 406 * - it disables interrupts avoiding CPU0 preemption 407 * by fast handlers (thus deadlocking against other CPUs) 408 * - it avoids deadlocks against smp_rendezvous() or, more 409 * generally, threads busy-waiting, with this spinlock held, 410 * and waiting for responses by threads on other CPUs 411 * (ie. smp_tlb_shootdown()). 412 * 413 * For the !SMP case it just needs to handle the former problem. 414 */ 415 #ifdef SMP 416 mtx_lock_spin(&smp_ipi_mtx); 417 #else 418 spinlock_enter(); 419 #endif 420 421 /* cpu_boot(howto); */ /* doesn't do anything at the moment */ 422 cpu_reset(); 423 /* NOTREACHED */ /* assuming reset worked */ 424 } 425 426 #if defined(WITNESS) || defined(INVARIANTS) 427 static int kassert_warn_only = 0; 428 #ifdef KDB 429 static int kassert_do_kdb = 0; 430 #endif 431 #ifdef KTR 432 static int kassert_do_ktr = 0; 433 #endif 434 static int kassert_do_log = 1; 435 static int kassert_log_pps_limit = 4; 436 static int kassert_log_mute_at = 0; 437 static int kassert_log_panic_at = 0; 438 static int kassert_warnings = 0; 439 440 SYSCTL_NODE(_debug, OID_AUTO, kassert, CTLFLAG_RW, NULL, "kassert options"); 441 442 SYSCTL_INT(_debug_kassert, OID_AUTO, warn_only, CTLFLAG_RWTUN, 443 &kassert_warn_only, 0, 444 "KASSERT triggers a panic (1) or just a warning (0)"); 445 446 #ifdef KDB 447 SYSCTL_INT(_debug_kassert, OID_AUTO, do_kdb, CTLFLAG_RWTUN, 448 &kassert_do_kdb, 0, "KASSERT will enter the debugger"); 449 #endif 450 451 #ifdef KTR 452 SYSCTL_UINT(_debug_kassert, OID_AUTO, do_ktr, CTLFLAG_RWTUN, 453 &kassert_do_ktr, 0, 454 "KASSERT does a KTR, set this to the KTRMASK you want"); 455 #endif 456 457 SYSCTL_INT(_debug_kassert, OID_AUTO, do_log, CTLFLAG_RWTUN, 458 &kassert_do_log, 0, "KASSERT triggers a panic (1) or just a warning (0)"); 459 460 SYSCTL_INT(_debug_kassert, OID_AUTO, warnings, CTLFLAG_RWTUN, 461 &kassert_warnings, 0, "number of KASSERTs that have been triggered"); 462 463 SYSCTL_INT(_debug_kassert, OID_AUTO, log_panic_at, CTLFLAG_RWTUN, 464 &kassert_log_panic_at, 0, "max number of KASSERTS before we will panic"); 465 466 SYSCTL_INT(_debug_kassert, OID_AUTO, log_pps_limit, CTLFLAG_RWTUN, 467 &kassert_log_pps_limit, 0, "limit number of log messages per second"); 468 469 SYSCTL_INT(_debug_kassert, OID_AUTO, log_mute_at, CTLFLAG_RWTUN, 470 &kassert_log_mute_at, 0, "max number of KASSERTS to log"); 471 472 static int kassert_sysctl_kassert(SYSCTL_HANDLER_ARGS); 473 474 SYSCTL_PROC(_debug_kassert, OID_AUTO, kassert, 475 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0, 476 kassert_sysctl_kassert, "I", "set to trigger a test kassert"); 477 478 static int 479 kassert_sysctl_kassert(SYSCTL_HANDLER_ARGS) 480 { 481 int error, i; 482 483 error = sysctl_wire_old_buffer(req, sizeof(int)); 484 if (error == 0) { 485 i = 0; 486 error = sysctl_handle_int(oidp, &i, 0, req); 487 } 488 if (error != 0 || req->newptr == NULL) 489 return (error); 490 KASSERT(0, ("kassert_sysctl_kassert triggered kassert %d", i)); 491 return (0); 492 } 493 494 /* 495 * Called by KASSERT, this decides if we will panic 496 * or if we will log via printf and/or ktr. 497 */ 498 void 499 kassert_panic(const char *fmt, ...) 500 { 501 static char buf[256]; 502 va_list ap; 503 504 va_start(ap, fmt); 505 (void)vsnprintf(buf, sizeof(buf), fmt, ap); 506 va_end(ap); 507 508 /* 509 * panic if we're not just warning, or if we've exceeded 510 * kassert_log_panic_at warnings. 511 */ 512 if (!kassert_warn_only || 513 (kassert_log_panic_at > 0 && 514 kassert_warnings >= kassert_log_panic_at)) { 515 va_start(ap, fmt); 516 vpanic(fmt, ap); 517 /* NORETURN */ 518 } 519 #ifdef KTR 520 if (kassert_do_ktr) 521 CTR0(ktr_mask, buf); 522 #endif /* KTR */ 523 /* 524 * log if we've not yet met the mute limit. 525 */ 526 if (kassert_do_log && 527 (kassert_log_mute_at == 0 || 528 kassert_warnings < kassert_log_mute_at)) { 529 static struct timeval lasterr; 530 static int curerr; 531 532 if (ppsratecheck(&lasterr, &curerr, kassert_log_pps_limit)) { 533 printf("KASSERT failed: %s\n", buf); 534 kdb_backtrace(); 535 } 536 } 537 #ifdef KDB 538 if (kassert_do_kdb) { 539 kdb_enter(KDB_WHY_KASSERT, buf); 540 } 541 #endif 542 atomic_add_int(&kassert_warnings, 1); 543 } 544 #endif 545 546 /* 547 * Panic is called on unresolvable fatal errors. It prints "panic: mesg", 548 * and then reboots. If we are called twice, then we avoid trying to sync 549 * the disks as this often leads to recursive panics. 550 */ 551 void 552 panic(const char *fmt, ...) 553 { 554 va_list ap; 555 556 va_start(ap, fmt); 557 vpanic(fmt, ap); 558 } 559 560 void 561 vpanic(const char *fmt, va_list ap) 562 { 563 #ifdef SMP 564 cpuset_t other_cpus; 565 #endif 566 struct thread *td = curthread; 567 int bootopt, newpanic; 568 static char buf[256]; 569 570 spinlock_enter(); 571 572 #ifdef SMP 573 /* 574 * stop_cpus_hard(other_cpus) should prevent multiple CPUs from 575 * concurrently entering panic. Only the winner will proceed 576 * further. 577 */ 578 if (panicstr == NULL && !kdb_active) { 579 other_cpus = all_cpus; 580 CPU_CLR(PCPU_GET(cpuid), &other_cpus); 581 stop_cpus_hard(other_cpus); 582 } 583 584 /* 585 * Ensure that the scheduler is stopped while panicking, even if panic 586 * has been entered from kdb. 587 */ 588 td->td_stopsched = 1; 589 #endif 590 591 bootopt = RB_AUTOBOOT; 592 newpanic = 0; 593 if (panicstr) 594 bootopt |= RB_NOSYNC; 595 else { 596 bootopt |= RB_DUMP; 597 panicstr = fmt; 598 newpanic = 1; 599 } 600 601 if (newpanic) { 602 (void)vsnprintf(buf, sizeof(buf), fmt, ap); 603 panicstr = buf; 604 cngrab(); 605 printf("panic: %s\n", buf); 606 } else { 607 printf("panic: "); 608 vprintf(fmt, ap); 609 printf("\n"); 610 } 611 #ifdef SMP 612 printf("cpuid = %d\n", PCPU_GET(cpuid)); 613 #endif 614 615 #ifdef KDB 616 if (newpanic && trace_on_panic) 617 kdb_backtrace(); 618 if (debugger_on_panic) 619 kdb_enter(KDB_WHY_PANIC, "panic"); 620 #endif 621 /*thread_lock(td); */ 622 td->td_flags |= TDF_INPANIC; 623 /* thread_unlock(td); */ 624 if (!sync_on_panic) 625 bootopt |= RB_NOSYNC; 626 kern_reboot(bootopt); 627 } 628 629 /* 630 * Support for poweroff delay. 631 * 632 * Please note that setting this delay too short might power off your machine 633 * before the write cache on your hard disk has been flushed, leading to 634 * soft-updates inconsistencies. 635 */ 636 #ifndef POWEROFF_DELAY 637 # define POWEROFF_DELAY 5000 638 #endif 639 static int poweroff_delay = POWEROFF_DELAY; 640 641 SYSCTL_INT(_kern_shutdown, OID_AUTO, poweroff_delay, CTLFLAG_RW, 642 &poweroff_delay, 0, "Delay before poweroff to write disk caches (msec)"); 643 644 static void 645 poweroff_wait(void *junk, int howto) 646 { 647 648 if (!(howto & RB_POWEROFF) || poweroff_delay <= 0) 649 return; 650 DELAY(poweroff_delay * 1000); 651 } 652 653 /* 654 * Some system processes (e.g. syncer) need to be stopped at appropriate 655 * points in their main loops prior to a system shutdown, so that they 656 * won't interfere with the shutdown process (e.g. by holding a disk buf 657 * to cause sync to fail). For each of these system processes, register 658 * shutdown_kproc() as a handler for one of shutdown events. 659 */ 660 static int kproc_shutdown_wait = 60; 661 SYSCTL_INT(_kern_shutdown, OID_AUTO, kproc_shutdown_wait, CTLFLAG_RW, 662 &kproc_shutdown_wait, 0, "Max wait time (sec) to stop for each process"); 663 664 void 665 kproc_shutdown(void *arg, int howto) 666 { 667 struct proc *p; 668 int error; 669 670 if (panicstr) 671 return; 672 673 p = (struct proc *)arg; 674 printf("Waiting (max %d seconds) for system process `%s' to stop...", 675 kproc_shutdown_wait, p->p_comm); 676 error = kproc_suspend(p, kproc_shutdown_wait * hz); 677 678 if (error == EWOULDBLOCK) 679 printf("timed out\n"); 680 else 681 printf("done\n"); 682 } 683 684 void 685 kthread_shutdown(void *arg, int howto) 686 { 687 struct thread *td; 688 int error; 689 690 if (panicstr) 691 return; 692 693 td = (struct thread *)arg; 694 printf("Waiting (max %d seconds) for system thread `%s' to stop...", 695 kproc_shutdown_wait, td->td_name); 696 error = kthread_suspend(td, kproc_shutdown_wait * hz); 697 698 if (error == EWOULDBLOCK) 699 printf("timed out\n"); 700 else 701 printf("done\n"); 702 } 703 704 static char dumpdevname[sizeof(((struct cdev*)NULL)->si_name)]; 705 SYSCTL_STRING(_kern_shutdown, OID_AUTO, dumpdevname, CTLFLAG_RD, 706 dumpdevname, 0, "Device for kernel dumps"); 707 708 /* Registration of dumpers */ 709 int 710 set_dumper(struct dumperinfo *di, const char *devname, struct thread *td) 711 { 712 size_t wantcopy; 713 int error; 714 715 error = priv_check(td, PRIV_SETDUMPER); 716 if (error != 0) 717 return (error); 718 719 if (di == NULL) { 720 bzero(&dumper, sizeof dumper); 721 dumpdevname[0] = '\0'; 722 return (0); 723 } 724 if (dumper.dumper != NULL) 725 return (EBUSY); 726 dumper = *di; 727 wantcopy = strlcpy(dumpdevname, devname, sizeof(dumpdevname)); 728 if (wantcopy >= sizeof(dumpdevname)) { 729 printf("set_dumper: device name truncated from '%s' -> '%s'\n", 730 devname, dumpdevname); 731 } 732 return (0); 733 } 734 735 /* Call dumper with bounds checking. */ 736 int 737 dump_write(struct dumperinfo *di, void *virtual, vm_offset_t physical, 738 off_t offset, size_t length) 739 { 740 741 if (length != 0 && (offset < di->mediaoffset || 742 offset - di->mediaoffset + length > di->mediasize)) { 743 printf("Attempt to write outside dump device boundaries.\n" 744 "offset(%jd), mediaoffset(%jd), length(%ju), mediasize(%jd).\n", 745 (intmax_t)offset, (intmax_t)di->mediaoffset, 746 (uintmax_t)length, (intmax_t)di->mediasize); 747 return (ENOSPC); 748 } 749 return (di->dumper(di->priv, virtual, physical, offset, length)); 750 } 751 752 void 753 mkdumpheader(struct kerneldumpheader *kdh, char *magic, uint32_t archver, 754 uint64_t dumplen, uint32_t blksz) 755 { 756 757 bzero(kdh, sizeof(*kdh)); 758 strlcpy(kdh->magic, magic, sizeof(kdh->magic)); 759 strlcpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture)); 760 kdh->version = htod32(KERNELDUMPVERSION); 761 kdh->architectureversion = htod32(archver); 762 kdh->dumplength = htod64(dumplen); 763 kdh->dumptime = htod64(time_second); 764 kdh->blocksize = htod32(blksz); 765 strlcpy(kdh->hostname, prison0.pr_hostname, sizeof(kdh->hostname)); 766 strlcpy(kdh->versionstring, version, sizeof(kdh->versionstring)); 767 if (panicstr != NULL) 768 strlcpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring)); 769 kdh->parity = kerneldump_parity(kdh); 770 } 771