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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94 39 * $FreeBSD: src/sys/kern/kern_shutdown.c,v 1.72.2.12 2002/02/21 19:15:10 dillon Exp $ 40 * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.61 2007/11/06 03:49:58 dillon Exp $ 41 */ 42 43 #include "opt_ddb.h" 44 #include "opt_ddb_trace.h" 45 #include "opt_hw_wdog.h" 46 #include "opt_panic.h" 47 #include "opt_show_busybufs.h" 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/eventhandler.h> 52 #include <sys/buf.h> 53 #include <sys/diskslice.h> 54 #include <sys/reboot.h> 55 #include <sys/proc.h> 56 #include <sys/fcntl.h> /* FREAD */ 57 #include <sys/stat.h> /* S_IFCHR */ 58 #include <sys/vnode.h> 59 #include <sys/kernel.h> 60 #include <sys/kthread.h> 61 #include <sys/malloc.h> 62 #include <sys/mount.h> 63 #include <sys/queue.h> 64 #include <sys/sysctl.h> 65 #include <sys/vkernel.h> 66 #include <sys/conf.h> 67 #include <sys/sysproto.h> 68 #include <sys/device.h> 69 #include <sys/cons.h> 70 #include <sys/shm.h> 71 #include <sys/kern_syscall.h> 72 #include <vm/vm_map.h> 73 #include <vm/pmap.h> 74 75 #include <sys/thread2.h> 76 #include <sys/buf2.h> 77 78 #include <machine/pcb.h> 79 #include <machine/clock.h> 80 #include <machine/md_var.h> 81 #include <machine/smp.h> /* smp_active_mask, cpuid */ 82 #include <machine/vmparam.h> 83 84 #include <sys/signalvar.h> 85 86 #ifndef PANIC_REBOOT_WAIT_TIME 87 #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */ 88 #endif 89 90 /* 91 * Note that stdarg.h and the ANSI style va_start macro is used for both 92 * ANSI and traditional C compilers. We use the machine version to stay 93 * within the confines of the kernel header files. 94 */ 95 #include <machine/stdarg.h> 96 97 #ifdef DDB 98 #ifdef DDB_UNATTENDED 99 int debugger_on_panic = 0; 100 #else 101 int debugger_on_panic = 1; 102 #endif 103 SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic, CTLFLAG_RW, 104 &debugger_on_panic, 0, "Run debugger on kernel panic"); 105 106 extern void db_print_backtrace(void); 107 108 #ifdef DDB_TRACE 109 int trace_on_panic = 1; 110 #else 111 int trace_on_panic = 0; 112 #endif 113 SYSCTL_INT(_debug, OID_AUTO, trace_on_panic, CTLFLAG_RW, 114 &trace_on_panic, 0, "Print stack trace on kernel panic"); 115 #endif 116 117 static int sync_on_panic = 1; 118 SYSCTL_INT(_kern, OID_AUTO, sync_on_panic, CTLFLAG_RW, 119 &sync_on_panic, 0, "Do a sync before rebooting from a panic"); 120 121 SYSCTL_NODE(_kern, OID_AUTO, shutdown, CTLFLAG_RW, 0, "Shutdown environment"); 122 123 #ifdef HW_WDOG 124 /* 125 * If there is a hardware watchdog, point this at the function needed to 126 * hold it off. 127 * It's needed when the kernel needs to do some lengthy operations. 128 * e.g. in wd.c when dumping core.. It's most annoying to have 129 * your precious core-dump only half written because the wdog kicked in. 130 */ 131 watchdog_tickle_fn wdog_tickler = NULL; 132 #endif /* HW_WDOG */ 133 134 /* 135 * Variable panicstr contains argument to first call to panic; used as flag 136 * to indicate that the kernel has already called panic. 137 */ 138 const char *panicstr; 139 140 int dumping; /* system is dumping */ 141 #ifdef SMP 142 u_int panic_cpu_interlock; /* panic interlock */ 143 globaldata_t panic_cpu_gd; /* which cpu took the panic */ 144 #endif 145 146 int bootverbose = 0; /* note: assignment to force non-bss */ 147 int cold = 1; /* note: assignment to force non-bss */ 148 int dumplo; /* OBSOLETE - savecore compat */ 149 u_int64_t dumplo64; 150 151 static void boot (int) __dead2; 152 static void dumpsys (void); 153 static int setdumpdev (cdev_t dev); 154 static void poweroff_wait (void *, int); 155 static void print_uptime (void); 156 static void shutdown_halt (void *junk, int howto); 157 static void shutdown_panic (void *junk, int howto); 158 static void shutdown_reset (void *junk, int howto); 159 static int shutdown_busycount1(struct buf *bp, void *info); 160 static int shutdown_busycount2(struct buf *bp, void *info); 161 static void shutdown_cleanup_proc(struct proc *p); 162 163 /* register various local shutdown events */ 164 static void 165 shutdown_conf(void *unused) 166 { 167 EVENTHANDLER_REGISTER(shutdown_final, poweroff_wait, NULL, SHUTDOWN_PRI_FIRST); 168 EVENTHANDLER_REGISTER(shutdown_final, shutdown_halt, NULL, SHUTDOWN_PRI_LAST + 100); 169 EVENTHANDLER_REGISTER(shutdown_final, shutdown_panic, NULL, SHUTDOWN_PRI_LAST + 100); 170 EVENTHANDLER_REGISTER(shutdown_final, shutdown_reset, NULL, SHUTDOWN_PRI_LAST + 200); 171 } 172 173 SYSINIT(shutdown_conf, SI_BOOT2_MACHDEP, SI_ORDER_ANY, shutdown_conf, NULL) 174 175 /* ARGSUSED */ 176 177 /* 178 * The system call that results in a reboot 179 */ 180 int 181 sys_reboot(struct reboot_args *uap) 182 { 183 struct thread *td = curthread; 184 int error; 185 186 if ((error = suser(td))) 187 return (error); 188 189 boot(uap->opt); 190 return (0); 191 } 192 193 /* 194 * Called by events that want to shut down.. e.g <CTL><ALT><DEL> on a PC 195 */ 196 static int shutdown_howto = 0; 197 198 void 199 shutdown_nice(int howto) 200 { 201 shutdown_howto = howto; 202 203 /* Send a signal to init(8) and have it shutdown the world */ 204 if (initproc != NULL) { 205 ksignal(initproc, SIGINT); 206 } else { 207 /* No init(8) running, so simply reboot */ 208 boot(RB_NOSYNC); 209 } 210 return; 211 } 212 static int waittime = -1; 213 static struct thread *dumpthread; 214 static struct pcb dumppcb; 215 216 static void 217 print_uptime(void) 218 { 219 int f; 220 struct timespec ts; 221 222 getnanouptime(&ts); 223 kprintf("Uptime: "); 224 f = 0; 225 if (ts.tv_sec >= 86400) { 226 kprintf("%ldd", ts.tv_sec / 86400); 227 ts.tv_sec %= 86400; 228 f = 1; 229 } 230 if (f || ts.tv_sec >= 3600) { 231 kprintf("%ldh", ts.tv_sec / 3600); 232 ts.tv_sec %= 3600; 233 f = 1; 234 } 235 if (f || ts.tv_sec >= 60) { 236 kprintf("%ldm", ts.tv_sec / 60); 237 ts.tv_sec %= 60; 238 f = 1; 239 } 240 kprintf("%lds\n", ts.tv_sec); 241 } 242 243 /* 244 * Go through the rigmarole of shutting down.. 245 * this used to be in machdep.c but I'll be dammned if I could see 246 * anything machine dependant in it. 247 */ 248 static void 249 boot(int howto) 250 { 251 /* 252 * Get rid of any user scheduler baggage and then give 253 * us a high priority. 254 */ 255 if (curthread->td_release) 256 curthread->td_release(curthread); 257 lwkt_setpri_self(TDPRI_MAX); 258 259 /* collect extra flags that shutdown_nice might have set */ 260 howto |= shutdown_howto; 261 262 #ifdef SMP 263 /* 264 * We really want to shutdown on the BSP. Subsystems such as ACPI 265 * can't power-down the box otherwise. 266 */ 267 if (smp_active_mask > 1) { 268 kprintf("boot() called on cpu#%d\n", mycpu->gd_cpuid); 269 } 270 if (panicstr == NULL && mycpu->gd_cpuid != 0) { 271 kprintf("Switching to cpu #0 for shutdown\n"); 272 lwkt_setcpu_self(globaldata_find(0)); 273 } 274 #endif 275 /* 276 * Do any callouts that should be done BEFORE syncing the filesystems. 277 */ 278 EVENTHANDLER_INVOKE(shutdown_pre_sync, howto); 279 280 /* 281 * Try to get rid of any remaining FS references. The calling 282 * process, proc0, and init may still hold references. The 283 * VFS cache subsystem may still hold a root reference to root. 284 * 285 * XXX this needs work. We really need to SIGSTOP all remaining 286 * processes in order to avoid blowups due to proc0's filesystem 287 * references going away. For now just make sure that the init 288 * process is stopped. 289 */ 290 if (panicstr == NULL) { 291 shutdown_cleanup_proc(curproc); 292 shutdown_cleanup_proc(&proc0); 293 if (initproc) { 294 if (initproc != curproc) { 295 ksignal(initproc, SIGSTOP); 296 tsleep(boot, 0, "shutdn", hz / 20); 297 } 298 shutdown_cleanup_proc(initproc); 299 } 300 vfs_cache_setroot(NULL, NULL); 301 } 302 303 /* 304 * Now sync filesystems 305 */ 306 if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) { 307 int iter, nbusy, pbusy; 308 309 waittime = 0; 310 kprintf("\nsyncing disks... "); 311 312 sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */ 313 314 /* 315 * With soft updates, some buffers that are 316 * written will be remarked as dirty until other 317 * buffers are written. 318 */ 319 for (iter = pbusy = 0; iter < 20; iter++) { 320 nbusy = scan_all_buffers(shutdown_busycount1, NULL); 321 if (nbusy == 0) 322 break; 323 kprintf("%d ", nbusy); 324 if (nbusy < pbusy) 325 iter = 0; 326 pbusy = nbusy; 327 /* 328 * XXX: 329 * Process soft update work queue if buffers don't sync 330 * after 6 iterations by permitting the syncer to run. 331 */ 332 if (iter > 5) 333 bio_ops_sync(NULL); 334 335 sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */ 336 tsleep(boot, 0, "shutdn", hz * iter / 20 + 1); 337 } 338 kprintf("\n"); 339 /* 340 * Count only busy local buffers to prevent forcing 341 * a fsck if we're just a client of a wedged NFS server 342 */ 343 nbusy = scan_all_buffers(shutdown_busycount2, NULL); 344 if (nbusy) { 345 /* 346 * Failed to sync all blocks. Indicate this and don't 347 * unmount filesystems (thus forcing an fsck on reboot). 348 */ 349 kprintf("giving up on %d buffers\n", nbusy); 350 #ifdef DDB 351 Debugger("busy buffer problem"); 352 #endif /* DDB */ 353 tsleep(boot, 0, "shutdn", hz * 5 + 1); 354 } else { 355 kprintf("done\n"); 356 /* 357 * Unmount filesystems 358 */ 359 if (panicstr == NULL) 360 vfs_unmountall(); 361 } 362 tsleep(boot, 0, "shutdn", hz / 10 + 1); 363 } 364 365 print_uptime(); 366 367 /* 368 * Dump before doing post_sync shutdown ops 369 */ 370 crit_enter(); 371 if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold) 372 dumpsys(); 373 374 /* 375 * Ok, now do things that assume all filesystem activity has 376 * been completed. This will also call the device shutdown 377 * methods. 378 */ 379 EVENTHANDLER_INVOKE(shutdown_post_sync, howto); 380 381 /* Now that we're going to really halt the system... */ 382 EVENTHANDLER_INVOKE(shutdown_final, howto); 383 384 for(;;) ; /* safety against shutdown_reset not working */ 385 /* NOTREACHED */ 386 } 387 388 static int 389 shutdown_busycount1(struct buf *bp, void *info) 390 { 391 if ((bp->b_flags & B_INVAL) == 0 && BUF_REFCNT(bp) > 0) 392 return(1); 393 if ((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) 394 return (1); 395 return (0); 396 } 397 398 static int 399 shutdown_busycount2(struct buf *bp, void *info) 400 { 401 if (((bp->b_flags & B_INVAL) == 0 && BUF_REFCNT(bp)) || 402 ((bp->b_flags & (B_DELWRI|B_INVAL)) == B_DELWRI)) { 403 /* 404 * Only count buffers undergoing write I/O 405 * on the related vnode. 406 */ 407 if (bp->b_vp == NULL || 408 bp->b_vp->v_track_write.bk_active == 0) { 409 return (0); 410 } 411 #if defined(SHOW_BUSYBUFS) || defined(DIAGNOSTIC) 412 kprintf( 413 "%p dev:?, flags:%08x, loffset:%lld, doffset:%lld\n", 414 bp, 415 bp->b_flags, bp->b_loffset, 416 bp->b_bio2.bio_offset); 417 #endif 418 return(1); 419 } 420 return(0); 421 } 422 423 /* 424 * If the shutdown was a clean halt, behave accordingly. 425 */ 426 static void 427 shutdown_halt(void *junk, int howto) 428 { 429 if (howto & RB_HALT) { 430 kprintf("\n"); 431 kprintf("The operating system has halted.\n"); 432 #ifdef _KERNEL_VIRTUAL 433 cpu_halt(); 434 #else 435 kprintf("Please press any key to reboot.\n\n"); 436 switch (cngetc()) { 437 case -1: /* No console, just die */ 438 cpu_halt(); 439 /* NOTREACHED */ 440 default: 441 howto &= ~RB_HALT; 442 break; 443 } 444 #endif 445 } 446 } 447 448 /* 449 * Check to see if the system paniced, pause and then reboot 450 * according to the specified delay. 451 */ 452 static void 453 shutdown_panic(void *junk, int howto) 454 { 455 int loop; 456 457 if (howto & RB_DUMP) { 458 if (PANIC_REBOOT_WAIT_TIME != 0) { 459 if (PANIC_REBOOT_WAIT_TIME != -1) { 460 kprintf("Automatic reboot in %d seconds - " 461 "press a key on the console to abort\n", 462 PANIC_REBOOT_WAIT_TIME); 463 for (loop = PANIC_REBOOT_WAIT_TIME * 10; 464 loop > 0; --loop) { 465 DELAY(1000 * 100); /* 1/10th second */ 466 /* Did user type a key? */ 467 if (cncheckc() != -1) 468 break; 469 } 470 if (!loop) 471 return; 472 } 473 } else { /* zero time specified - reboot NOW */ 474 return; 475 } 476 kprintf("--> Press a key on the console to reboot,\n"); 477 kprintf("--> or switch off the system now.\n"); 478 cngetc(); 479 } 480 } 481 482 /* 483 * Everything done, now reset 484 */ 485 static void 486 shutdown_reset(void *junk, int howto) 487 { 488 kprintf("Rebooting...\n"); 489 DELAY(1000000); /* wait 1 sec for kprintf's to complete and be read */ 490 /* cpu_boot(howto); */ /* doesn't do anything at the moment */ 491 cpu_reset(); 492 /* NOTREACHED */ /* assuming reset worked */ 493 } 494 495 /* 496 * Try to remove FS references in the specified process. This function 497 * is used during shutdown 498 */ 499 static 500 void 501 shutdown_cleanup_proc(struct proc *p) 502 { 503 struct filedesc *fdp; 504 struct vmspace *vm; 505 506 if (p == NULL) 507 return; 508 if ((fdp = p->p_fd) != NULL) { 509 kern_closefrom(0); 510 if (fdp->fd_cdir) { 511 cache_drop(&fdp->fd_ncdir); 512 vrele(fdp->fd_cdir); 513 fdp->fd_cdir = NULL; 514 } 515 if (fdp->fd_rdir) { 516 cache_drop(&fdp->fd_nrdir); 517 vrele(fdp->fd_rdir); 518 fdp->fd_rdir = NULL; 519 } 520 if (fdp->fd_jdir) { 521 cache_drop(&fdp->fd_njdir); 522 vrele(fdp->fd_jdir); 523 fdp->fd_jdir = NULL; 524 } 525 } 526 if (p->p_vkernel) 527 vkernel_exit(p); 528 if (p->p_textvp) { 529 vrele(p->p_textvp); 530 p->p_textvp = NULL; 531 } 532 vm = p->p_vmspace; 533 if (vm != NULL) { 534 pmap_remove_pages(vmspace_pmap(vm), 535 VM_MIN_USER_ADDRESS, 536 VM_MAX_USER_ADDRESS); 537 vm_map_remove(&vm->vm_map, 538 VM_MIN_USER_ADDRESS, 539 VM_MAX_USER_ADDRESS); 540 } 541 } 542 543 /* 544 * Magic number for savecore 545 * 546 * exported (symorder) and used at least by savecore(8) 547 * 548 * Mark it as used so that gcc doesn't optimize it away. 549 */ 550 __attribute__((__used__)) 551 static u_long const dumpmag = 0x8fca0101UL; 552 553 static int dumpsize = 0; /* also for savecore */ 554 555 static int dodump = 1; 556 557 SYSCTL_INT(_machdep, OID_AUTO, do_dump, CTLFLAG_RW, &dodump, 0, 558 "Try to perform coredump on kernel panic"); 559 560 static int 561 setdumpdev(cdev_t dev) 562 { 563 struct partinfo pinfo; 564 u_int64_t newdumplo; 565 int error; 566 int doopen; 567 568 if (dev == NULL) { 569 dumpdev = dev; 570 return (0); 571 } 572 bzero(&pinfo, sizeof(pinfo)); 573 574 /* 575 * We have to open the device before we can perform ioctls on it, 576 * or the slice/label data may not be present. Device opens are 577 * usually tracked by specfs, but the dump device can be set in 578 * early boot and may not be open so this is somewhat of a hack. 579 */ 580 doopen = (dev->si_sysref.refcnt == 1); 581 if (doopen) { 582 error = dev_dopen(dev, FREAD, S_IFCHR, proc0.p_ucred); 583 if (error) 584 return (error); 585 } 586 error = dev_dioctl(dev, DIOCGPART, (void *)&pinfo, 0, proc0.p_ucred); 587 if (doopen) 588 dev_dclose(dev, FREAD, S_IFCHR); 589 if (error || pinfo.media_blocks == 0 || pinfo.media_blksize == 0) 590 return (ENXIO); 591 592 newdumplo = pinfo.media_blocks - 593 ((u_int64_t)Maxmem * PAGE_SIZE / DEV_BSIZE); 594 if ((int64_t)newdumplo < (int64_t)pinfo.reserved_blocks) 595 return (ENOSPC); 596 dumpdev = dev; 597 dumplo64 = newdumplo; 598 return (0); 599 } 600 601 602 /* ARGSUSED */ 603 static void dump_conf (void *dummy); 604 static void 605 dump_conf(void *dummy) 606 { 607 char *path; 608 cdev_t dev; 609 610 path = kmalloc(MNAMELEN, M_TEMP, M_WAITOK); 611 if (TUNABLE_STR_FETCH("dumpdev", path, MNAMELEN) != 0) { 612 dev = kgetdiskbyname(path); 613 if (dev != NULL) 614 dumpdev = dev; 615 } 616 kfree(path, M_TEMP); 617 if (setdumpdev(dumpdev) != 0) 618 dumpdev = NULL; 619 } 620 621 SYSINIT(dump_conf, SI_SUB_DUMP_CONF, SI_ORDER_FIRST, dump_conf, NULL) 622 623 static int 624 sysctl_kern_dumpdev(SYSCTL_HANDLER_ARGS) 625 { 626 int error; 627 udev_t ndumpdev; 628 629 ndumpdev = dev2udev(dumpdev); 630 error = sysctl_handle_opaque(oidp, &ndumpdev, sizeof ndumpdev, req); 631 if (error == 0 && req->newptr != NULL) 632 error = setdumpdev(udev2dev(ndumpdev, 0)); 633 return (error); 634 } 635 636 SYSCTL_PROC(_kern, KERN_DUMPDEV, dumpdev, CTLTYPE_OPAQUE|CTLFLAG_RW, 637 0, sizeof dumpdev, sysctl_kern_dumpdev, "T,udev_t", ""); 638 639 /* 640 * Doadump comes here after turning off memory management and 641 * getting on the dump stack, either when called above, or by 642 * the auto-restart code. 643 */ 644 static void 645 dumpsys(void) 646 { 647 int error; 648 649 savectx(&dumppcb); 650 dumpthread = curthread; 651 if (dumping++) { 652 kprintf("Dump already in progress, bailing...\n"); 653 return; 654 } 655 if (!dodump) 656 return; 657 if (dumpdev == NULL) 658 return; 659 dumpsize = Maxmem; 660 kprintf("\ndumping to dev %s, blockno %lld\n", 661 devtoname(dumpdev), dumplo64); 662 kprintf("dump "); 663 error = dev_ddump(dumpdev); 664 if (error == 0) { 665 kprintf("succeeded\n"); 666 return; 667 } 668 kprintf("failed, reason: "); 669 switch (error) { 670 case ENOSYS: 671 case ENODEV: 672 kprintf("device doesn't support a dump routine\n"); 673 break; 674 675 case ENXIO: 676 kprintf("device bad\n"); 677 break; 678 679 case EFAULT: 680 kprintf("device not ready\n"); 681 break; 682 683 case EINVAL: 684 kprintf("area improper\n"); 685 break; 686 687 case EIO: 688 kprintf("i/o error\n"); 689 break; 690 691 case EINTR: 692 kprintf("aborted from console\n"); 693 break; 694 695 default: 696 kprintf("unknown, error = %d\n", error); 697 break; 698 } 699 } 700 701 int 702 dumpstatus(vm_offset_t addr, off_t count) 703 { 704 int c; 705 706 if (addr % (1024 * 1024) == 0) { 707 #ifdef HW_WDOG 708 if (wdog_tickler) 709 (*wdog_tickler)(); 710 #endif 711 kprintf("%ld ", (long)(count / (1024 * 1024))); 712 } 713 714 if ((c = cncheckc()) == 0x03) 715 return -1; 716 else if (c != -1) 717 kprintf("[CTRL-C to abort] "); 718 719 return 0; 720 } 721 722 /* 723 * Panic is called on unresolvable fatal errors. It prints "panic: mesg", 724 * and then reboots. If we are called twice, then we avoid trying to sync 725 * the disks as this often leads to recursive panics. 726 */ 727 void 728 panic(const char *fmt, ...) 729 { 730 int bootopt, newpanic; 731 __va_list ap; 732 static char buf[256]; 733 734 #ifdef SMP 735 /* 736 * If a panic occurs on multiple cpus before the first is able to 737 * halt the other cpus, only one cpu is allowed to take the panic. 738 * Attempt to be verbose about this situation but if the kprintf() 739 * itself panics don't let us overrun the kernel stack. 740 * 741 * Be very nasty about descheduling our thread at the lowest 742 * level possible in an attempt to freeze the thread without 743 * inducing further panics. 744 * 745 * Bumping gd_trap_nesting_level will also bypass assertions in 746 * lwkt_switch() and allow us to switch away even if we are a 747 * FAST interrupt or IPI. 748 */ 749 if (atomic_poll_acquire_int(&panic_cpu_interlock)) { 750 panic_cpu_gd = mycpu; 751 } else if (panic_cpu_gd != mycpu) { 752 crit_enter(); 753 ++mycpu->gd_trap_nesting_level; 754 if (mycpu->gd_trap_nesting_level < 25) { 755 kprintf("SECONDARY PANIC ON CPU %d THREAD %p\n", 756 mycpu->gd_cpuid, curthread); 757 } 758 curthread->td_release = NULL; /* be a grinch */ 759 for (;;) { 760 lwkt_deschedule_self(curthread); 761 lwkt_switch(); 762 } 763 /* NOT REACHED */ 764 /* --mycpu->gd_trap_nesting_level */ 765 /* crit_exit() */ 766 } 767 #endif 768 bootopt = RB_AUTOBOOT | RB_DUMP; 769 if (sync_on_panic == 0) 770 bootopt |= RB_NOSYNC; 771 newpanic = 0; 772 if (panicstr) 773 bootopt |= RB_NOSYNC; 774 else { 775 panicstr = fmt; 776 newpanic = 1; 777 } 778 779 __va_start(ap, fmt); 780 kvsnprintf(buf, sizeof(buf), fmt, ap); 781 if (panicstr == fmt) 782 panicstr = buf; 783 __va_end(ap); 784 kprintf("panic: %s\n", buf); 785 #ifdef SMP 786 /* two separate prints in case of an unmapped page and trap */ 787 kprintf("mp_lock = %08x; ", mp_lock); 788 kprintf("cpuid = %d\n", mycpu->gd_cpuid); 789 #endif 790 791 #if defined(DDB) 792 if (newpanic && trace_on_panic) 793 db_print_backtrace(); 794 if (debugger_on_panic) 795 Debugger("panic"); 796 #endif 797 boot(bootopt); 798 } 799 800 /* 801 * Support for poweroff delay. 802 */ 803 #ifndef POWEROFF_DELAY 804 # define POWEROFF_DELAY 5000 805 #endif 806 static int poweroff_delay = POWEROFF_DELAY; 807 808 SYSCTL_INT(_kern_shutdown, OID_AUTO, poweroff_delay, CTLFLAG_RW, 809 &poweroff_delay, 0, ""); 810 811 static void 812 poweroff_wait(void *junk, int howto) 813 { 814 if(!(howto & RB_POWEROFF) || poweroff_delay <= 0) 815 return; 816 DELAY(poweroff_delay * 1000); 817 } 818 819 /* 820 * Some system processes (e.g. syncer) need to be stopped at appropriate 821 * points in their main loops prior to a system shutdown, so that they 822 * won't interfere with the shutdown process (e.g. by holding a disk buf 823 * to cause sync to fail). For each of these system processes, register 824 * shutdown_kproc() as a handler for one of shutdown events. 825 */ 826 static int kproc_shutdown_wait = 60; 827 SYSCTL_INT(_kern_shutdown, OID_AUTO, kproc_shutdown_wait, CTLFLAG_RW, 828 &kproc_shutdown_wait, 0, ""); 829 830 void 831 shutdown_kproc(void *arg, int howto) 832 { 833 struct thread *td; 834 struct proc *p; 835 int error; 836 837 if (panicstr) 838 return; 839 840 td = (struct thread *)arg; 841 if ((p = td->td_proc) != NULL) { 842 kprintf("Waiting (max %d seconds) for system process `%s' to stop...", 843 kproc_shutdown_wait, p->p_comm); 844 } else { 845 kprintf("Waiting (max %d seconds) for system thread %s to stop...", 846 kproc_shutdown_wait, td->td_comm); 847 } 848 error = suspend_kproc(td, kproc_shutdown_wait * hz); 849 850 if (error == EWOULDBLOCK) 851 kprintf("timed out\n"); 852 else 853 kprintf("stopped\n"); 854 } 855