Differential D3054 Diff 6864 sys/kern/kern_shutdown.c

Changeset View

Standalone View

sys/kern/kern_shutdown.c

Show All 31 Lines
* SUCH DAMAGE.		* SUCH DAMAGE.
*		*
* @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94		* @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94
*/		*/

#include <sys/cdefs.h>		#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");		__FBSDID("$FreeBSD$");

#include "opt_ddb.h"
#include "opt_kdb.h"		#include "opt_kdb.h"
#include "opt_panic.h"		#include "opt_panic.h"
#include "opt_sched.h"		#include "opt_sched.h"
#include "opt_watchdog.h"		#include "opt_watchdog.h"

#include <sys/param.h>		#include <sys/param.h>
#include <sys/systm.h>		#include <sys/systm.h>
#include <sys/bio.h>		#include <sys/bio.h>
#include <sys/buf.h>		#include <sys/buf.h>
#include <sys/conf.h>		#include <sys/conf.h>
#include <sys/cons.h>		#include <sys/cons.h>
#include <sys/eventhandler.h>		#include <sys/eventhandler.h>
#include <sys/jail.h>
#include <sys/kdb.h>		#include <sys/kdb.h>
#include <sys/kernel.h>		#include <sys/kernel.h>
#include <sys/kerneldump.h>		#include <sys/kerneldump.h>
#include <sys/kthread.h>		#include <sys/kthread.h>
#include <sys/ktr.h>		#include <sys/ktr.h>
#include <sys/malloc.h>		#include <sys/malloc.h>
#include <sys/mount.h>		#include <sys/mount.h>
#include <sys/priv.h>		#include <sys/priv.h>
#include <sys/proc.h>		#include <sys/proc.h>
#include <sys/reboot.h>		#include <sys/reboot.h>
#include <sys/resourcevar.h>		#include <sys/resourcevar.h>
#include <sys/rwlock.h>		#include <sys/rwlock.h>
#include <sys/sched.h>		#include <sys/sched.h>
#include <sys/smp.h>		#include <sys/smp.h>
#include <sys/sysctl.h>		#include <sys/sysctl.h>
#include <sys/sysproto.h>		#include <sys/sysproto.h>
#include <sys/vnode.h>		#include <sys/vnode.h>
#include <sys/watchdog.h>		#include <sys/watchdog.h>

#include <ddb/ddb.h>

#include <machine/cpu.h>		#include <machine/cpu.h>
#include <machine/dump.h>
#include <machine/pcb.h>		#include <machine/pcb.h>
#include <machine/smp.h>		#include <machine/smp.h>

#include <security/mac/mac_framework.h>		#include <security/mac/mac_framework.h>

#include <vm/vm.h>		#include <vm/vm.h>
#include <vm/vm_object.h>		#include <vm/vm_object.h>
#include <vm/vm_page.h>		#include <vm/vm_page.h>
Show All 11 Lines	SYSCTL_INT(_kern, OID_AUTO, panic_reboot_wait_time, CTLFLAG_RWTUN,
"Seconds to wait before rebooting after a panic");		"Seconds to wait before rebooting after a panic");

/*		/*
* Note that stdarg.h and the ANSI style va_start macro is used for both		* Note that stdarg.h and the ANSI style va_start macro is used for both
* ANSI and traditional C compilers.		* ANSI and traditional C compilers.
*/		*/
#include <machine/stdarg.h>		#include <machine/stdarg.h>

		SYSCTL_NODE(_kern, OID_AUTO, shutdown, CTLFLAG_RW, 0,
		"Shutdown environment");

		cemUnsubmitted Not Done Inline Actions Why move this? cem: Why move this?
		markjAuthorUnsubmitted Not Done Inline Actions Oops, I'm not sure. I'll move it back. markj: Oops, I'm not sure. I'll move it back.
#ifdef KDB		#ifdef KDB
#ifdef KDB_UNATTENDED		#ifdef KDB_UNATTENDED
int debugger_on_panic = 0;		int debugger_on_panic = 0;
#else		#else
int debugger_on_panic = 1;		int debugger_on_panic = 1;
#endif		#endif
SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic,		SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic,
CTLFLAG_RWTUN \| CTLFLAG_SECURE,		CTLFLAG_RWTUN \| CTLFLAG_SECURE,
&debugger_on_panic, 0, "Run debugger on kernel panic");		&debugger_on_panic, 0, "Run debugger on kernel panic");

#ifdef KDB_TRACE		#ifdef KDB_TRACE
static int trace_on_panic = 1;		static int trace_on_panic = 1;
#else		#else
static int trace_on_panic = 0;		static int trace_on_panic = 0;
#endif		#endif
SYSCTL_INT(_debug, OID_AUTO, trace_on_panic,		SYSCTL_INT(_debug, OID_AUTO, trace_on_panic,
CTLFLAG_RWTUN \| CTLFLAG_SECURE,		CTLFLAG_RWTUN \| CTLFLAG_SECURE,
&trace_on_panic, 0, "Print stack trace on kernel panic");		&trace_on_panic, 0, "Print stack trace on kernel panic");
#endif /* KDB */		#endif /* KDB */

static int sync_on_panic = 0;		static int sync_on_panic = 0;
SYSCTL_INT(_kern, OID_AUTO, sync_on_panic, CTLFLAG_RWTUN,		SYSCTL_INT(_kern, OID_AUTO, sync_on_panic, CTLFLAG_RWTUN, &sync_on_panic, 0,
&sync_on_panic, 0, "Do a sync before rebooting from a panic");		"Do a sync before rebooting from a panic");

static SYSCTL_NODE(_kern, OID_AUTO, shutdown, CTLFLAG_RW, 0,
"Shutdown environment");

#ifndef DIAGNOSTIC		#ifndef DIAGNOSTIC
static int show_busybufs;		static int show_busybufs;
#else		#else
static int show_busybufs = 1;		static int show_busybufs = 1;
#endif		#endif
SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW,		SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW,
&show_busybufs, 0, "");		&show_busybufs, 0, "");

/*		/*
* Variable panicstr contains argument to first call to panic; used as flag		* Variable panicstr contains argument to first call to panic; used as flag
* to indicate that the kernel has already called panic.		* to indicate that the kernel has already called panic.
*/		*/
const char *panicstr;		const char *panicstr;

int dumping; /* system is dumping */		int dumping; /* system is dumping */
int rebooting; /* system is rebooting */		int rebooting; /* system is rebooting */
static struct dumperinfo dumper; /* our selected dumper */

/* Context information for dump-debuggers. */
static struct pcb dumppcb; /* Registers. */
lwpid_t dumptid; /* Thread ID. */

static void poweroff_wait(void *, int);		static void poweroff_wait(void *, int);
static void shutdown_halt(void *junk, int howto);		static void shutdown_halt(void *junk, int howto);
static void shutdown_panic(void *junk, int howto);		static void shutdown_panic(void *junk, int howto);
static void shutdown_reset(void *junk, int howto);		static void shutdown_reset(void *junk, int howto);

/* register various local shutdown events */		/* register various local shutdown events */
static void		static void
shutdown_conf(void *unused)		shutdown_conf(void *unused)
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines	print_uptime(void)
if (f \|\| ts.tv_sec >= 60) {		if (f \|\| ts.tv_sec >= 60) {
printf("%ldm", (long)ts.tv_sec / 60);		printf("%ldm", (long)ts.tv_sec / 60);
ts.tv_sec %= 60;		ts.tv_sec %= 60;
f = 1;		f = 1;
}		}
printf("%lds\n", (long)ts.tv_sec);		printf("%lds\n", (long)ts.tv_sec);
}		}

int
doadump(boolean_t textdump)
{
boolean_t coredump;
int error;

error = 0;
if (dumping)
return (EBUSY);
if (dumper.dumper == NULL)
return (ENXIO);

savectx(&dumppcb);
dumptid = curthread->td_tid;
dumping++;

coredump = TRUE;
#ifdef DDB
if (textdump && textdump_pending) {
coredump = FALSE;
textdump_dumpsys(&dumper);
}
#endif
if (coredump)
error = dumpsys(&dumper);

dumping--;
return (error);
}

static int		static int
isbufbusy(struct buf *bp)		isbufbusy(struct buf *bp)
{		{
if (((bp->b_flags & (B_INVAL \| B_PERSISTENT)) == 0 &&		if (((bp->b_flags & (B_INVAL \| B_PERSISTENT)) == 0 &&
BUF_ISLOCKED(bp)) \|\|		BUF_ISLOCKED(bp)) \|\|
((bp->b_flags & (B_DELWRI \| B_INVAL)) == B_DELWRI))		((bp->b_flags & (B_DELWRI \| B_INVAL)) == B_DELWRI))
return (1);		return (1);
return (0);		return (0);
▲ Show 20 Lines • Show All 526 Lines • ▼ Show 20 Lines	kthread_shutdown(void *arg, int howto)
printf("Waiting (max %d seconds) for system thread `%s' to stop...",		printf("Waiting (max %d seconds) for system thread `%s' to stop...",
kproc_shutdown_wait, td->td_name);		kproc_shutdown_wait, td->td_name);
error = kthread_suspend(td, kproc_shutdown_wait * hz);		error = kthread_suspend(td, kproc_shutdown_wait * hz);

if (error == EWOULDBLOCK)		if (error == EWOULDBLOCK)
printf("timed out\n");		printf("timed out\n");
else		else
printf("done\n");		printf("done\n");
}

static char dumpdevname[sizeof(((struct cdev*)NULL)->si_name)];
SYSCTL_STRING(_kern_shutdown, OID_AUTO, dumpdevname, CTLFLAG_RD,
dumpdevname, 0, "Device for kernel dumps");

/* Registration of dumpers */
int
set_dumper(struct dumperinfo di, const char devname, struct thread *td)
{
size_t wantcopy;
int error;

error = priv_check(td, PRIV_SETDUMPER);
if (error != 0)
return (error);

if (di == NULL) {
bzero(&dumper, sizeof dumper);
dumpdevname[0] = '\0';
return (0);
}
if (dumper.dumper != NULL)
return (EBUSY);
dumper = *di;
wantcopy = strlcpy(dumpdevname, devname, sizeof(dumpdevname));
if (wantcopy >= sizeof(dumpdevname)) {
printf("set_dumper: device name truncated from '%s' -> '%s'\n",
devname, dumpdevname);
}
return (0);
}

/* Call dumper with bounds checking. */
int
dump_write(struct dumperinfo di, void virtual, vm_offset_t physical,
off_t offset, size_t length)
{

if (length != 0 && (offset < di->mediaoffset \|\|
offset - di->mediaoffset + length > di->mediasize)) {
printf("Attempt to write outside dump device boundaries.\n"
"offset(%jd), mediaoffset(%jd), length(%ju), mediasize(%jd).\n",
(intmax_t)offset, (intmax_t)di->mediaoffset,
(uintmax_t)length, (intmax_t)di->mediasize);
return (ENOSPC);
}
return (di->dumper(di->priv, virtual, physical, offset, length));
}

void
mkdumpheader(struct kerneldumpheader kdh, char magic, uint32_t archver,
uint64_t dumplen, uint32_t blksz)
{

bzero(kdh, sizeof(*kdh));
strlcpy(kdh->magic, magic, sizeof(kdh->magic));
strlcpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture));
kdh->version = htod32(KERNELDUMPVERSION);
kdh->architectureversion = htod32(archver);
kdh->dumplength = htod64(dumplen);
kdh->dumptime = htod64(time_second);
kdh->blocksize = htod32(blksz);
strlcpy(kdh->hostname, prison0.pr_hostname, sizeof(kdh->hostname));
strlcpy(kdh->versionstring, version, sizeof(kdh->versionstring));
if (panicstr != NULL)
strlcpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring));
kdh->parity = kerneldump_parity(kdh);
}		}