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/malloc.h> 59 #include <sys/mount.h> 60 #include <sys/priv.h> 61 #include <sys/proc.h> 62 #include <sys/reboot.h> 63 #include <sys/resourcevar.h> 64 #include <sys/sched.h> 65 #include <sys/smp.h> 66 #include <sys/sysctl.h> 67 #include <sys/sysproto.h> 68 #include <sys/vnode.h> 69 #ifdef SW_WATCHDOG 70 #include <sys/watchdog.h> 71 #endif 72 73 #include <ddb/ddb.h> 74 75 #include <machine/cpu.h> 76 #include <machine/pcb.h> 77 #include <machine/smp.h> 78 79 #include <security/mac/mac_framework.h> 80 81 #include <vm/vm.h> 82 #include <vm/vm_object.h> 83 #include <vm/vm_page.h> 84 #include <vm/vm_pager.h> 85 #include <vm/swap_pager.h> 86 87 #include <sys/signalvar.h> 88 89 #ifndef PANIC_REBOOT_WAIT_TIME 90 #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */ 91 #endif 92 93 /* 94 * Note that stdarg.h and the ANSI style va_start macro is used for both 95 * ANSI and traditional C compilers. 96 */ 97 #include <machine/stdarg.h> 98 99 #ifdef KDB 100 #ifdef KDB_UNATTENDED 101 int debugger_on_panic = 0; 102 #else 103 int debugger_on_panic = 1; 104 #endif 105 SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic, CTLFLAG_RW | CTLFLAG_TUN, 106 &debugger_on_panic, 0, "Run debugger on kernel panic"); 107 TUNABLE_INT("debug.debugger_on_panic", &debugger_on_panic); 108 109 #ifdef KDB_TRACE 110 static int trace_on_panic = 1; 111 #else 112 static int trace_on_panic = 0; 113 #endif 114 SYSCTL_INT(_debug, OID_AUTO, trace_on_panic, CTLFLAG_RW | CTLFLAG_TUN, 115 &trace_on_panic, 0, "Print stack trace on kernel panic"); 116 TUNABLE_INT("debug.trace_on_panic", &trace_on_panic); 117 #endif /* KDB */ 118 119 static int sync_on_panic = 0; 120 SYSCTL_INT(_kern, OID_AUTO, sync_on_panic, CTLFLAG_RW | CTLFLAG_TUN, 121 &sync_on_panic, 0, "Do a sync before rebooting from a panic"); 122 TUNABLE_INT("kern.sync_on_panic", &sync_on_panic); 123 124 SYSCTL_NODE(_kern, OID_AUTO, shutdown, CTLFLAG_RW, 0, "Shutdown environment"); 125 126 #ifndef DIAGNOSTIC 127 static int show_busybufs; 128 #else 129 static int show_busybufs = 1; 130 #endif 131 SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW, 132 &show_busybufs, 0, ""); 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 int rebooting; /* system is rebooting */ 142 static struct dumperinfo dumper; /* our selected dumper */ 143 144 /* Context information for dump-debuggers. */ 145 static struct pcb dumppcb; /* Registers. */ 146 static lwpid_t dumptid; /* Thread ID. */ 147 148 static void poweroff_wait(void *, int); 149 static void shutdown_halt(void *junk, int howto); 150 static void shutdown_panic(void *junk, int howto); 151 static void shutdown_reset(void *junk, int howto); 152 153 /* register various local shutdown events */ 154 static void 155 shutdown_conf(void *unused) 156 { 157 158 EVENTHANDLER_REGISTER(shutdown_final, poweroff_wait, NULL, 159 SHUTDOWN_PRI_FIRST); 160 EVENTHANDLER_REGISTER(shutdown_final, shutdown_halt, NULL, 161 SHUTDOWN_PRI_LAST + 100); 162 EVENTHANDLER_REGISTER(shutdown_final, shutdown_panic, NULL, 163 SHUTDOWN_PRI_LAST + 100); 164 EVENTHANDLER_REGISTER(shutdown_final, shutdown_reset, NULL, 165 SHUTDOWN_PRI_LAST + 200); 166 } 167 168 SYSINIT(shutdown_conf, SI_SUB_INTRINSIC, SI_ORDER_ANY, shutdown_conf, NULL); 169 170 /* 171 * The system call that results in a reboot. 172 */ 173 /* ARGSUSED */ 174 int 175 sys_reboot(struct thread *td, struct reboot_args *uap) 176 { 177 int error; 178 179 error = 0; 180 #ifdef MAC 181 error = mac_system_check_reboot(td->td_ucred, uap->opt); 182 #endif 183 if (error == 0) 184 error = priv_check(td, PRIV_REBOOT); 185 if (error == 0) { 186 mtx_lock(&Giant); 187 kern_reboot(uap->opt); 188 mtx_unlock(&Giant); 189 } 190 return (error); 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 202 shutdown_howto = howto; 203 204 /* Send a signal to init(8) and have it shutdown the world */ 205 if (initproc != NULL) { 206 PROC_LOCK(initproc); 207 kern_psignal(initproc, SIGINT); 208 PROC_UNLOCK(initproc); 209 } else { 210 /* No init(8) running, so simply reboot */ 211 kern_reboot(RB_NOSYNC); 212 } 213 return; 214 } 215 static int waittime = -1; 216 217 static void 218 print_uptime(void) 219 { 220 int f; 221 struct timespec ts; 222 223 getnanouptime(&ts); 224 printf("Uptime: "); 225 f = 0; 226 if (ts.tv_sec >= 86400) { 227 printf("%ldd", (long)ts.tv_sec / 86400); 228 ts.tv_sec %= 86400; 229 f = 1; 230 } 231 if (f || ts.tv_sec >= 3600) { 232 printf("%ldh", (long)ts.tv_sec / 3600); 233 ts.tv_sec %= 3600; 234 f = 1; 235 } 236 if (f || ts.tv_sec >= 60) { 237 printf("%ldm", (long)ts.tv_sec / 60); 238 ts.tv_sec %= 60; 239 f = 1; 240 } 241 printf("%lds\n", (long)ts.tv_sec); 242 } 243 244 int 245 doadump(boolean_t textdump) 246 { 247 boolean_t coredump; 248 249 if (dumping) 250 return (EBUSY); 251 if (dumper.dumper == NULL) 252 return (ENXIO); 253 254 savectx(&dumppcb); 255 dumptid = curthread->td_tid; 256 dumping++; 257 258 coredump = TRUE; 259 #ifdef DDB 260 if (textdump && textdump_pending) { 261 coredump = FALSE; 262 textdump_dumpsys(&dumper); 263 } 264 #endif 265 if (coredump) 266 dumpsys(&dumper); 267 268 dumping--; 269 return (0); 270 } 271 272 static int 273 isbufbusy(struct buf *bp) 274 { 275 if (((bp->b_flags & (B_INVAL | B_PERSISTENT)) == 0 && 276 BUF_ISLOCKED(bp)) || 277 ((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI)) 278 return (1); 279 return (0); 280 } 281 282 /* 283 * Shutdown the system cleanly to prepare for reboot, halt, or power off. 284 */ 285 void 286 kern_reboot(int howto) 287 { 288 static int first_buf_printf = 1; 289 290 #if defined(SMP) 291 /* 292 * Bind us to CPU 0 so that all shutdown code runs there. Some 293 * systems don't shutdown properly (i.e., ACPI power off) if we 294 * run on another processor. 295 */ 296 thread_lock(curthread); 297 sched_bind(curthread, 0); 298 thread_unlock(curthread); 299 KASSERT(PCPU_GET(cpuid) == 0, ("%s: not running on cpu 0", __func__)); 300 #endif 301 /* We're in the process of rebooting. */ 302 rebooting = 1; 303 304 /* collect extra flags that shutdown_nice might have set */ 305 howto |= shutdown_howto; 306 307 /* We are out of the debugger now. */ 308 kdb_active = 0; 309 310 /* 311 * Do any callouts that should be done BEFORE syncing the filesystems. 312 */ 313 EVENTHANDLER_INVOKE(shutdown_pre_sync, howto); 314 315 /* 316 * Now sync filesystems 317 */ 318 if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) { 319 register struct buf *bp; 320 int iter, nbusy, pbusy; 321 #ifndef PREEMPTION 322 int subiter; 323 #endif 324 325 waittime = 0; 326 327 #ifdef SW_WATCHDOG 328 wdog_kern_pat(WD_LASTVAL); 329 #endif 330 sys_sync(curthread, NULL); 331 332 /* 333 * With soft updates, some buffers that are 334 * written will be remarked as dirty until other 335 * buffers are written. 336 */ 337 for (iter = pbusy = 0; iter < 20; iter++) { 338 nbusy = 0; 339 for (bp = &buf[nbuf]; --bp >= buf; ) 340 if (isbufbusy(bp)) 341 nbusy++; 342 if (nbusy == 0) { 343 if (first_buf_printf) 344 printf("All buffers synced."); 345 break; 346 } 347 if (first_buf_printf) { 348 printf("Syncing disks, buffers remaining... "); 349 first_buf_printf = 0; 350 } 351 printf("%d ", nbusy); 352 if (nbusy < pbusy) 353 iter = 0; 354 pbusy = nbusy; 355 #ifdef SW_WATCHDOG 356 wdog_kern_pat(WD_LASTVAL); 357 #endif 358 sys_sync(curthread, NULL); 359 360 #ifdef PREEMPTION 361 /* 362 * Drop Giant and spin for a while to allow 363 * interrupt threads to run. 364 */ 365 DROP_GIANT(); 366 DELAY(50000 * iter); 367 PICKUP_GIANT(); 368 #else 369 /* 370 * Drop Giant and context switch several times to 371 * allow interrupt threads to run. 372 */ 373 DROP_GIANT(); 374 for (subiter = 0; subiter < 50 * iter; subiter++) { 375 thread_lock(curthread); 376 mi_switch(SW_VOL, NULL); 377 thread_unlock(curthread); 378 DELAY(1000); 379 } 380 PICKUP_GIANT(); 381 #endif 382 } 383 printf("\n"); 384 /* 385 * Count only busy local buffers to prevent forcing 386 * a fsck if we're just a client of a wedged NFS server 387 */ 388 nbusy = 0; 389 for (bp = &buf[nbuf]; --bp >= buf; ) { 390 if (isbufbusy(bp)) { 391 #if 0 392 /* XXX: This is bogus. We should probably have a BO_REMOTE flag instead */ 393 if (bp->b_dev == NULL) { 394 TAILQ_REMOVE(&mountlist, 395 bp->b_vp->v_mount, mnt_list); 396 continue; 397 } 398 #endif 399 nbusy++; 400 if (show_busybufs > 0) { 401 printf( 402 "%d: buf:%p, vnode:%p, flags:%0x, blkno:%jd, lblkno:%jd, buflock:", 403 nbusy, bp, bp->b_vp, bp->b_flags, 404 (intmax_t)bp->b_blkno, 405 (intmax_t)bp->b_lblkno); 406 BUF_LOCKPRINTINFO(bp); 407 if (show_busybufs > 1) 408 vn_printf(bp->b_vp, 409 "vnode content: "); 410 } 411 } 412 } 413 if (nbusy) { 414 /* 415 * Failed to sync all blocks. Indicate this and don't 416 * unmount filesystems (thus forcing an fsck on reboot). 417 */ 418 printf("Giving up on %d buffers\n", nbusy); 419 DELAY(5000000); /* 5 seconds */ 420 } else { 421 if (!first_buf_printf) 422 printf("Final sync complete\n"); 423 /* 424 * Unmount filesystems 425 */ 426 if (panicstr == 0) 427 vfs_unmountall(); 428 } 429 swapoff_all(); 430 DELAY(100000); /* wait for console output to finish */ 431 } 432 433 print_uptime(); 434 435 /* 436 * Ok, now do things that assume all filesystem activity has 437 * been completed. 438 */ 439 EVENTHANDLER_INVOKE(shutdown_post_sync, howto); 440 441 if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold && !dumping) 442 doadump(TRUE); 443 444 /* Now that we're going to really halt the system... */ 445 EVENTHANDLER_INVOKE(shutdown_final, howto); 446 447 for(;;) ; /* safety against shutdown_reset not working */ 448 /* NOTREACHED */ 449 } 450 451 /* 452 * If the shutdown was a clean halt, behave accordingly. 453 */ 454 static void 455 shutdown_halt(void *junk, int howto) 456 { 457 458 if (howto & RB_HALT) { 459 printf("\n"); 460 printf("The operating system has halted.\n"); 461 printf("Please press any key to reboot.\n\n"); 462 switch (cngetc()) { 463 case -1: /* No console, just die */ 464 cpu_halt(); 465 /* NOTREACHED */ 466 default: 467 howto &= ~RB_HALT; 468 break; 469 } 470 } 471 } 472 473 /* 474 * Check to see if the system paniced, pause and then reboot 475 * according to the specified delay. 476 */ 477 static void 478 shutdown_panic(void *junk, int howto) 479 { 480 int loop; 481 482 if (howto & RB_DUMP) { 483 if (PANIC_REBOOT_WAIT_TIME != 0) { 484 if (PANIC_REBOOT_WAIT_TIME != -1) { 485 printf("Automatic reboot in %d seconds - " 486 "press a key on the console to abort\n", 487 PANIC_REBOOT_WAIT_TIME); 488 for (loop = PANIC_REBOOT_WAIT_TIME * 10; 489 loop > 0; --loop) { 490 DELAY(1000 * 100); /* 1/10th second */ 491 /* Did user type a key? */ 492 if (cncheckc() != -1) 493 break; 494 } 495 if (!loop) 496 return; 497 } 498 } else { /* zero time specified - reboot NOW */ 499 return; 500 } 501 printf("--> Press a key on the console to reboot,\n"); 502 printf("--> or switch off the system now.\n"); 503 cngetc(); 504 } 505 } 506 507 /* 508 * Everything done, now reset 509 */ 510 static void 511 shutdown_reset(void *junk, int howto) 512 { 513 514 printf("Rebooting...\n"); 515 DELAY(1000000); /* wait 1 sec for printf's to complete and be read */ 516 517 /* 518 * Acquiring smp_ipi_mtx here has a double effect: 519 * - it disables interrupts avoiding CPU0 preemption 520 * by fast handlers (thus deadlocking against other CPUs) 521 * - it avoids deadlocks against smp_rendezvous() or, more 522 * generally, threads busy-waiting, with this spinlock held, 523 * and waiting for responses by threads on other CPUs 524 * (ie. smp_tlb_shootdown()). 525 * 526 * For the !SMP case it just needs to handle the former problem. 527 */ 528 #ifdef SMP 529 mtx_lock_spin(&smp_ipi_mtx); 530 #else 531 spinlock_enter(); 532 #endif 533 534 /* cpu_boot(howto); */ /* doesn't do anything at the moment */ 535 cpu_reset(); 536 /* NOTREACHED */ /* assuming reset worked */ 537 } 538 539 /* 540 * Panic is called on unresolvable fatal errors. It prints "panic: mesg", 541 * and then reboots. If we are called twice, then we avoid trying to sync 542 * the disks as this often leads to recursive panics. 543 */ 544 void 545 panic(const char *fmt, ...) 546 { 547 #ifdef SMP 548 static volatile u_int panic_cpu = NOCPU; 549 #endif 550 struct thread *td = curthread; 551 int bootopt, newpanic; 552 va_list ap; 553 static char buf[256]; 554 555 critical_enter(); 556 #ifdef SMP 557 /* 558 * We don't want multiple CPU's to panic at the same time, so we 559 * use panic_cpu as a simple spinlock. We have to keep checking 560 * panic_cpu if we are spinning in case the panic on the first 561 * CPU is canceled. 562 */ 563 if (panic_cpu != PCPU_GET(cpuid)) 564 while (atomic_cmpset_int(&panic_cpu, NOCPU, 565 PCPU_GET(cpuid)) == 0) 566 while (panic_cpu != NOCPU) 567 ; /* nothing */ 568 #endif 569 570 bootopt = RB_AUTOBOOT; 571 newpanic = 0; 572 if (panicstr) 573 bootopt |= RB_NOSYNC; 574 else { 575 bootopt |= RB_DUMP; 576 panicstr = fmt; 577 newpanic = 1; 578 } 579 580 va_start(ap, fmt); 581 if (newpanic) { 582 (void)vsnprintf(buf, sizeof(buf), fmt, ap); 583 panicstr = buf; 584 printf("panic: %s\n", buf); 585 } else { 586 printf("panic: "); 587 vprintf(fmt, ap); 588 printf("\n"); 589 } 590 va_end(ap); 591 #ifdef SMP 592 printf("cpuid = %d\n", PCPU_GET(cpuid)); 593 #endif 594 595 #ifdef KDB 596 if (newpanic && trace_on_panic) 597 kdb_backtrace(); 598 if (debugger_on_panic) 599 kdb_enter(KDB_WHY_PANIC, "panic"); 600 #endif 601 /*thread_lock(td); */ 602 td->td_flags |= TDF_INPANIC; 603 /* thread_unlock(td); */ 604 if (!sync_on_panic) 605 bootopt |= RB_NOSYNC; 606 critical_exit(); 607 kern_reboot(bootopt); 608 } 609 610 /* 611 * Support for poweroff delay. 612 * 613 * Please note that setting this delay too short might power off your machine 614 * before the write cache on your hard disk has been flushed, leading to 615 * soft-updates inconsistencies. 616 */ 617 #ifndef POWEROFF_DELAY 618 # define POWEROFF_DELAY 5000 619 #endif 620 static int poweroff_delay = POWEROFF_DELAY; 621 622 SYSCTL_INT(_kern_shutdown, OID_AUTO, poweroff_delay, CTLFLAG_RW, 623 &poweroff_delay, 0, ""); 624 625 static void 626 poweroff_wait(void *junk, int howto) 627 { 628 629 if (!(howto & RB_POWEROFF) || poweroff_delay <= 0) 630 return; 631 DELAY(poweroff_delay * 1000); 632 } 633 634 /* 635 * Some system processes (e.g. syncer) need to be stopped at appropriate 636 * points in their main loops prior to a system shutdown, so that they 637 * won't interfere with the shutdown process (e.g. by holding a disk buf 638 * to cause sync to fail). For each of these system processes, register 639 * shutdown_kproc() as a handler for one of shutdown events. 640 */ 641 static int kproc_shutdown_wait = 60; 642 SYSCTL_INT(_kern_shutdown, OID_AUTO, kproc_shutdown_wait, CTLFLAG_RW, 643 &kproc_shutdown_wait, 0, ""); 644 645 void 646 kproc_shutdown(void *arg, int howto) 647 { 648 struct proc *p; 649 int error; 650 651 if (panicstr) 652 return; 653 654 p = (struct proc *)arg; 655 printf("Waiting (max %d seconds) for system process `%s' to stop...", 656 kproc_shutdown_wait, p->p_comm); 657 error = kproc_suspend(p, kproc_shutdown_wait * hz); 658 659 if (error == EWOULDBLOCK) 660 printf("timed out\n"); 661 else 662 printf("done\n"); 663 } 664 665 void 666 kthread_shutdown(void *arg, int howto) 667 { 668 struct thread *td; 669 int error; 670 671 if (panicstr) 672 return; 673 674 td = (struct thread *)arg; 675 printf("Waiting (max %d seconds) for system thread `%s' to stop...", 676 kproc_shutdown_wait, td->td_name); 677 error = kthread_suspend(td, kproc_shutdown_wait * hz); 678 679 if (error == EWOULDBLOCK) 680 printf("timed out\n"); 681 else 682 printf("done\n"); 683 } 684 685 /* Registration of dumpers */ 686 int 687 set_dumper(struct dumperinfo *di) 688 { 689 690 if (di == NULL) { 691 bzero(&dumper, sizeof dumper); 692 return (0); 693 } 694 if (dumper.dumper != NULL) 695 return (EBUSY); 696 dumper = *di; 697 return (0); 698 } 699 700 /* Call dumper with bounds checking. */ 701 int 702 dump_write(struct dumperinfo *di, void *virtual, vm_offset_t physical, 703 off_t offset, size_t length) 704 { 705 706 if (length != 0 && (offset < di->mediaoffset || 707 offset - di->mediaoffset + length > di->mediasize)) { 708 printf("Attempt to write outside dump device boundaries.\n" 709 "offset(%jd), mediaoffset(%jd), length(%ju), mediasize(%jd).\n", 710 (intmax_t)offset, (intmax_t)di->mediaoffset, 711 (uintmax_t)length, (intmax_t)di->mediasize); 712 return (ENOSPC); 713 } 714 return (di->dumper(di->priv, virtual, physical, offset, length)); 715 } 716 717 void 718 mkdumpheader(struct kerneldumpheader *kdh, char *magic, uint32_t archver, 719 uint64_t dumplen, uint32_t blksz) 720 { 721 722 bzero(kdh, sizeof(*kdh)); 723 strncpy(kdh->magic, magic, sizeof(kdh->magic)); 724 strncpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture)); 725 kdh->version = htod32(KERNELDUMPVERSION); 726 kdh->architectureversion = htod32(archver); 727 kdh->dumplength = htod64(dumplen); 728 kdh->dumptime = htod64(time_second); 729 kdh->blocksize = htod32(blksz); 730 strncpy(kdh->hostname, prison0.pr_hostname, sizeof(kdh->hostname)); 731 strncpy(kdh->versionstring, version, sizeof(kdh->versionstring)); 732 if (panicstr != NULL) 733 strncpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring)); 734 kdh->parity = kerneldump_parity(kdh); 735 } 736