#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/vm.h>
#include <sys/proc_internal.h>
#include <sys/user.h>
#include <sys/reboot.h>
#include <sys/conf.h>
#include <sys/vnode_internal.h>
#include <sys/file_internal.h>
#include <sys/mbuf.h>
#include <sys/msgbuf.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/tty.h>
#include <kern/task.h>
#include <sys/quota.h>
#include <vm/vm_kern.h>
#include <mach/vm_param.h>
#include <sys/filedesc.h>
#include <mach/host_priv.h>
#include <mach/host_reboot.h>
#include <security/audit/audit.h>
#include <kern/sched_prim.h>
#include <kern/host.h>
#include <net/if_var.h>
#include <sys/buf_internal.h>
#include <sys/mount_internal.h>
#include <mach/task.h>
#include <sys/sysproto.h>
#include <kern/clock.h>
#include <libkern/OSAtomic.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOMessage.h>
#include <sys/kdebug.h>
uint32_t system_inshutdown = 0;
#if XNU_TARGET_OS_OSX
extern void (*unmountroot_pre_hook)(void);
#endif
unsigned int proc_shutdown_exitcount = 0;
static int sd_openlog(vfs_context_t);
static int sd_closelog(vfs_context_t);
static void sd_log(vfs_context_t, const char *, ...);
static void proc_shutdown(int only_non_dext);
static void zprint_panic_info(void);
extern void halt_log_enter(const char * what, const void * pc, uint64_t time);
#if DEVELOPMENT || DEBUG
extern boolean_t kdp_has_polled_corefile(void);
#endif
struct sd_filterargs {
int delayterm;
int shutdownstate;
int only_non_dext;
};
struct sd_iterargs {
int signo;
int setsdstate;
int countproc;
int activecount;
};
static vnode_t sd_logvp = NULLVP;
static off_t sd_log_offset = 0;
static int sd_filt1(proc_t, void *);
static int sd_filt2(proc_t, void *);
static int sd_callback1(proc_t p, void * arg);
static int sd_callback2(proc_t p, void * arg);
static int sd_callback3(proc_t p, void * arg);
extern bool panic_include_zprint;
extern mach_memory_info_t *panic_kext_memory_info;
extern vm_size_t panic_kext_memory_size;
static void
zprint_panic_info(void)
{
unsigned int num_sites;
kern_return_t kr;
panic_include_zprint = TRUE;
panic_kext_memory_info = NULL;
panic_kext_memory_size = 0;
num_sites = vm_page_diagnose_estimate();
panic_kext_memory_size = num_sites * sizeof(panic_kext_memory_info[0]);
kr = kmem_alloc(kernel_map, (vm_offset_t *)&panic_kext_memory_info, round_page(panic_kext_memory_size), VM_KERN_MEMORY_OSFMK);
if (kr != KERN_SUCCESS) {
panic_kext_memory_info = NULL;
return;
}
vm_page_diagnose(panic_kext_memory_info, num_sites, 0);
}
int
get_system_inshutdown()
{
return system_inshutdown;
}
__abortlike
static void
panic_kernel(int howto, char *message)
{
if ((howto & RB_PANIC_ZPRINT) == RB_PANIC_ZPRINT) {
zprint_panic_info();
}
panic("userspace panic: %s", message);
}
extern boolean_t compressor_store_stop_compaction;
extern lck_mtx_t vm_swap_data_lock;
extern int vm_swapfile_create_thread_running;
extern int vm_swapfile_gc_thread_running;
int
reboot_kernel(int howto, char *message)
{
int hostboot_option = 0;
uint64_t startTime;
if ((howto & (RB_PANIC | RB_QUICK)) == (RB_PANIC | RB_QUICK)) {
panic_kernel(howto, message);
}
if (!OSCompareAndSwap(0, 1, &system_inshutdown)) {
if ((howto & RB_QUICK) == RB_QUICK) {
goto force_reboot;
}
return EBUSY;
}
lck_mtx_lock(&vm_swap_data_lock);
compressor_store_stop_compaction = TRUE;
while (vm_swapfile_create_thread_running || vm_swapfile_gc_thread_running) {
assert_wait((event_t)&compressor_store_stop_compaction, THREAD_UNINT);
lck_mtx_unlock(&vm_swap_data_lock);
thread_block(THREAD_CONTINUE_NULL);
lck_mtx_lock(&vm_swap_data_lock);
}
lck_mtx_unlock(&vm_swap_data_lock);
IOSystemShutdownNotification(kIOSystemShutdownNotificationStageProcessExit);
if ((howto & RB_QUICK) == RB_QUICK) {
printf("Quick reboot...\n");
if ((howto & RB_NOSYNC) == 0) {
sync((proc_t)NULL, (void *)NULL, (int *)NULL);
}
} else if ((howto & RB_NOSYNC) == 0) {
int iter, nbusy;
printf("syncing disks... ");
startTime = mach_absolute_time();
proc_shutdown(TRUE);
halt_log_enter("proc_shutdown", 0, mach_absolute_time() - startTime);
#if CONFIG_AUDIT
startTime = mach_absolute_time();
audit_shutdown();
halt_log_enter("audit_shutdown", 0, mach_absolute_time() - startTime);
#endif
#if XNU_TARGET_OS_OSX
if (unmountroot_pre_hook != NULL) {
unmountroot_pre_hook();
}
#endif
startTime = mach_absolute_time();
sync((proc_t)NULL, (void *)NULL, (int *)NULL);
if (kdebug_enable) {
startTime = mach_absolute_time();
kdbg_dump_trace_to_file("/var/log/shutdown/shutdown.trace");
halt_log_enter("shutdown.trace", 0, mach_absolute_time() - startTime);
}
IOSystemShutdownNotification(kIOSystemShutdownNotificationStageRootUnmount);
#if DEVELOPMENT || DEBUG
if (!(howto & RB_PANIC) || !kdp_has_polled_corefile())
#endif
{
startTime = mach_absolute_time();
vfs_unmountall(TRUE);
halt_log_enter("vfs_unmountall", 0, mach_absolute_time() - startTime);
}
IOSystemShutdownNotification(kIOSystemShutdownNotificationTerminateDEXTs);
startTime = mach_absolute_time();
proc_shutdown(FALSE);
halt_log_enter("proc_shutdown", 0, mach_absolute_time() - startTime);
#if DEVELOPMENT || DEBUG
if (!(howto & RB_PANIC) || !kdp_has_polled_corefile())
#endif
{
startTime = mach_absolute_time();
vfs_unmountall(FALSE);
halt_log_enter("vfs_unmountall", 0, mach_absolute_time() - startTime);
}
startTime = mach_absolute_time();
for (iter = 0; iter < 100; iter++) {
nbusy = count_busy_buffers();
if (nbusy == 0) {
break;
}
printf("%d ", nbusy);
delay_for_interval( 1 * nbusy, 1000 * 1000);
}
if (nbusy) {
printf("giving up\n");
} else {
printf("done\n");
}
halt_log_enter("bufferclean", 0, mach_absolute_time() - startTime);
}
#if NETWORKING
startTime = mach_absolute_time();
if_down_all();
halt_log_enter("if_down_all", 0, mach_absolute_time() - startTime);
#endif
force_reboot:
if (howto & RB_PANIC) {
panic_kernel(howto, message);
}
if (howto & RB_HALT) {
hostboot_option = HOST_REBOOT_HALT;
}
if (howto & RB_UPSDELAY) {
hostboot_option = HOST_REBOOT_UPSDELAY;
}
host_reboot(host_priv_self(), hostboot_option);
return 0;
}
static int
sd_openlog(vfs_context_t ctx)
{
int error = 0;
struct timeval tv;
if ((error = vnode_open(PROC_SHUTDOWN_LOG, (O_CREAT | FWRITE | O_NOFOLLOW), 0644, 0, &sd_logvp, ctx))) {
printf("Failed to open %s: error %d\n", PROC_SHUTDOWN_LOG, error);
sd_logvp = NULLVP;
return error;
}
vnode_setsize(sd_logvp, (off_t)0, 0, ctx);
microtime(&tv);
sd_log(ctx, "Process shutdown log. Current time is %lu (in seconds).\n\n", tv.tv_sec);
return 0;
}
static int
sd_closelog(vfs_context_t ctx)
{
int error = 0;
if (sd_logvp != NULLVP) {
VNOP_FSYNC(sd_logvp, MNT_WAIT, ctx);
error = vnode_close(sd_logvp, FWRITE, ctx);
sd_logvp = NULLVP;
}
return error;
}
static void
sd_log(vfs_context_t ctx, const char *fmt, ...)
{
int resid, log_error, len;
char logbuf[100];
va_list arglist;
if (sd_logvp == NULLVP) {
if (sd_openlog(ctx) != 0) {
return;
}
}
va_start(arglist, fmt);
len = vsnprintf(logbuf, sizeof(logbuf), fmt, arglist);
log_error = vn_rdwr(UIO_WRITE, sd_logvp, (caddr_t)logbuf, len, sd_log_offset,
UIO_SYSSPACE, IO_UNIT | IO_NOAUTH, vfs_context_ucred(ctx), &resid, vfs_context_proc(ctx));
if (log_error == EIO || log_error == 0) {
sd_log_offset += (len - resid);
}
va_end(arglist);
}
#define proc_is_driver(p) (task_is_driver((p)->task))
static int
sd_filt1(proc_t p, void * args)
{
proc_t self = current_proc();
struct sd_filterargs * sf = (struct sd_filterargs *)args;
int delayterm = sf->delayterm;
int shutdownstate = sf->shutdownstate;
if (sf->only_non_dext && proc_is_driver(p)) {
return 0;
}
if (((p->p_flag & P_SYSTEM) != 0) || (p->p_ppid == 0)
|| (p == self) || (p->p_stat == SZOMB)
|| (p->p_shutdownstate != shutdownstate)
|| ((delayterm == 0) && ((p->p_lflag & P_LDELAYTERM) == P_LDELAYTERM))
|| ((p->p_sigcatch & sigmask(SIGTERM)) == 0)) {
return 0;
} else {
return 1;
}
}
static int
sd_callback1(proc_t p, void * args)
{
struct sd_iterargs * sd = (struct sd_iterargs *)args;
int signo = sd->signo;
int setsdstate = sd->setsdstate;
int countproc = sd->countproc;
proc_lock(p);
p->p_shutdownstate = (char)setsdstate;
if (p->p_stat != SZOMB) {
proc_unlock(p);
if (countproc != 0) {
proc_list_lock();
p->p_listflag |= P_LIST_EXITCOUNT;
proc_shutdown_exitcount++;
proc_list_unlock();
}
if (proc_is_driver(p)) {
printf("lingering dext %s signal(%d)\n", p->p_name, signo);
}
psignal(p, signo);
if (countproc != 0) {
sd->activecount++;
}
} else {
proc_unlock(p);
}
return PROC_RETURNED;
}
static int
sd_filt2(proc_t p, void * args)
{
proc_t self = current_proc();
struct sd_filterargs * sf = (struct sd_filterargs *)args;
int delayterm = sf->delayterm;
int shutdownstate = sf->shutdownstate;
if (sf->only_non_dext && proc_is_driver(p)) {
return 0;
}
if (((p->p_flag & P_SYSTEM) != 0) || (p->p_ppid == 0)
|| (p == self) || (p->p_stat == SZOMB)
|| (p->p_shutdownstate == shutdownstate)
|| ((delayterm == 0) && ((p->p_lflag & P_LDELAYTERM) == P_LDELAYTERM))) {
return 0;
} else {
return 1;
}
}
static int
sd_callback2(proc_t p, void * args)
{
struct sd_iterargs * sd = (struct sd_iterargs *)args;
int signo = sd->signo;
int setsdstate = sd->setsdstate;
int countproc = sd->countproc;
proc_lock(p);
p->p_shutdownstate = (char)setsdstate;
if (p->p_stat != SZOMB) {
proc_unlock(p);
if (countproc != 0) {
proc_list_lock();
p->p_listflag |= P_LIST_EXITCOUNT;
proc_shutdown_exitcount++;
proc_list_unlock();
}
if (proc_is_driver(p)) {
printf("lingering dext %s signal(%d)\n", p->p_name, signo);
}
psignal(p, signo);
if (countproc != 0) {
sd->activecount++;
}
} else {
proc_unlock(p);
}
return PROC_RETURNED;
}
static int
sd_callback3(proc_t p, void * args)
{
struct sd_iterargs * sd = (struct sd_iterargs *)args;
vfs_context_t ctx = vfs_context_current();
int setsdstate = sd->setsdstate;
proc_lock(p);
p->p_shutdownstate = (char)setsdstate;
if (p->p_stat != SZOMB) {
if (p->exit_thread) {
proc_unlock(p);
thread_block(THREAD_CONTINUE_NULL);
} else {
p->exit_thread = current_thread();
printf(".");
sd_log(ctx, "%s[%d] had to be forced closed with exit1().\n", p->p_comm, p->p_pid);
proc_unlock(p);
KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_PROC, BSD_PROC_FRCEXIT) | DBG_FUNC_NONE,
p->p_pid, 0, 1, 0, 0);
sd->activecount++;
exit1(p, 1, (int *)NULL);
}
} else {
proc_unlock(p);
}
return PROC_RETURNED;
}
static void
proc_shutdown(int only_non_dext)
{
vfs_context_t ctx = vfs_context_current();
struct proc *p, *self;
int delayterm = 0;
struct sd_filterargs sfargs;
struct sd_iterargs sdargs;
int error = 0;
struct timespec ts;
self = (struct proc *)current_proc();
p = proc_find(1);
if (p && p != self) {
psignal(p, SIGTERM);
}
proc_rele(p);
printf("Killing all processes ");
sigterm_loop:
sfargs.delayterm = delayterm;
sfargs.shutdownstate = 0;
sfargs.only_non_dext = only_non_dext;
sdargs.signo = SIGTERM;
sdargs.setsdstate = 1;
sdargs.countproc = 1;
sdargs.activecount = 0;
error = 0;
proc_rebootscan(sd_callback1, (void *)&sdargs, sd_filt1, (void *)&sfargs);
if (sdargs.activecount != 0 && proc_shutdown_exitcount != 0) {
proc_list_lock();
if (proc_shutdown_exitcount != 0) {
ts.tv_sec = 3;
ts.tv_nsec = 0;
error = msleep(&proc_shutdown_exitcount, &proc_list_mlock, PWAIT, "shutdownwait", &ts);
if (error != 0) {
for (p = allproc.lh_first; p; p = p->p_list.le_next) {
if ((p->p_listflag & P_LIST_EXITCOUNT) == P_LIST_EXITCOUNT) {
p->p_listflag &= ~P_LIST_EXITCOUNT;
}
}
for (p = zombproc.lh_first; p; p = p->p_list.le_next) {
if ((p->p_listflag & P_LIST_EXITCOUNT) == P_LIST_EXITCOUNT) {
p->p_listflag &= ~P_LIST_EXITCOUNT;
}
}
}
}
proc_list_unlock();
}
if (error == ETIMEDOUT) {
proc_list_lock();
for (p = allproc.lh_first; p; p = p->p_list.le_next) {
if (p->p_shutdownstate == 1) {
printf("%s[%d]: didn't act on SIGTERM\n", p->p_comm, p->p_pid);
sd_log(ctx, "%s[%d]: didn't act on SIGTERM\n", p->p_comm, p->p_pid);
}
}
proc_list_unlock();
}
sfargs.delayterm = delayterm;
sfargs.shutdownstate = 2;
sdargs.signo = SIGKILL;
sdargs.setsdstate = 2;
sdargs.countproc = 1;
sdargs.activecount = 0;
proc_rebootscan(sd_callback2, (void *)&sdargs, sd_filt2, (void *)&sfargs);
error = 0;
if (sdargs.activecount != 0 && proc_shutdown_exitcount != 0) {
proc_list_lock();
if (proc_shutdown_exitcount != 0) {
ts.tv_sec = 10;
ts.tv_nsec = 0;
error = msleep(&proc_shutdown_exitcount, &proc_list_mlock, PWAIT, "shutdownwait", &ts);
if (error != 0) {
for (p = allproc.lh_first; p; p = p->p_list.le_next) {
if ((p->p_listflag & P_LIST_EXITCOUNT) == P_LIST_EXITCOUNT) {
p->p_listflag &= ~P_LIST_EXITCOUNT;
}
}
for (p = zombproc.lh_first; p; p = p->p_list.le_next) {
if ((p->p_listflag & P_LIST_EXITCOUNT) == P_LIST_EXITCOUNT) {
p->p_listflag &= ~P_LIST_EXITCOUNT;
}
}
}
}
proc_list_unlock();
}
if (error == ETIMEDOUT) {
proc_list_lock();
for (p = allproc.lh_first; p; p = p->p_list.le_next) {
if (p->p_shutdownstate == 2) {
printf("%s[%d]: didn't act on SIGKILL\n", p->p_comm, p->p_pid);
sd_log(ctx, "%s[%d]: didn't act on SIGKILL\n", p->p_comm, p->p_pid);
}
}
proc_list_unlock();
}
sfargs.delayterm = delayterm;
sfargs.shutdownstate = 3;
sdargs.signo = 0;
sdargs.setsdstate = 3;
sdargs.countproc = 0;
sdargs.activecount = 0;
proc_rebootscan(sd_callback3, (void *)&sdargs, sd_filt2, (void *)&sfargs);
printf("\n");
if (delayterm == 0) {
delayterm = 1;
goto sigterm_loop;
}
sd_closelog(ctx);
if (only_non_dext) {
return;
}
task_suspend_internal(initproc->task);
proc_rele(initproc);
printf("continuing\n");
}