static int
settime(struct timeval *tv)
{
struct timeval delta, tv1, tv2;
static struct timeval maxtime, laststep;
struct timespec ts;
int origcpu;
if ((origcpu = mycpu->gd_cpuid) != 0)
lwkt_setcpu_self(globaldata_find(0));
crit_enter();
microtime(&tv1);
delta = *tv;
timevalsub(&delta, &tv1);
/*
* If the system is secure, we do not allow the time to be
* set to a value earlier than 1 second less than the highest
* time we have yet seen. The worst a miscreant can do in
* this circumstance is "freeze" time. He couldn't go
* back to the past.
*
* We similarly do not allow the clock to be stepped more
* than one second, nor more than once per second. This allows
* a miscreant to make the clock march double-time, but no worse.
*/
if (securelevel > 1) {
if (delta.tv_sec < 0 || delta.tv_usec < 0) {
/*
* Update maxtime to latest time we've seen.
*/
if (tv1.tv_sec > maxtime.tv_sec)
maxtime = tv1;
tv2 = *tv;
timevalsub(&tv2, &maxtime);
if (tv2.tv_sec < -1) {
tv->tv_sec = maxtime.tv_sec - 1;
kprintf("Time adjustment clamped to -1 second\n");
}
} else {
if (tv1.tv_sec == laststep.tv_sec) {
crit_exit();
return (EPERM);
}
if (delta.tv_sec > 1) {
tv->tv_sec = tv1.tv_sec + 1;
kprintf("Time adjustment clamped to +1 second\n");
}
laststep = *tv;
}
}
ts.tv_sec = tv->tv_sec;
ts.tv_nsec = tv->tv_usec * 1000;
set_timeofday(&ts);
crit_exit();
if (origcpu != 0)
lwkt_setcpu_self(globaldata_find(origcpu));
resettodr();
return (0);
}
/*
* Go through the rigmarole of shutting down..
* this used to be in machdep.c but I'll be dammned if I could see
* anything machine dependant in it.
*/
static void
boot(int howto)
{
/*
* Get rid of any user scheduler baggage and then give
* us a high priority.
*/
if (curthread->td_release)
curthread->td_release(curthread);
lwkt_setpri_self(TDPRI_MAX);
/* collect extra flags that shutdown_nice might have set */
howto |= shutdown_howto;
#ifdef SMP
/*
* We really want to shutdown on the BSP. Subsystems such as ACPI
* can't power-down the box otherwise.
*/
if (smp_active_mask > 1) {
kprintf("boot() called on cpu#%d\n", mycpu->gd_cpuid);
}
if (panicstr == NULL && mycpu->gd_cpuid != 0) {
kprintf("Switching to cpu #0 for shutdown\n");
lwkt_setcpu_self(globaldata_find(0));
}
#endif
/*
* Do any callouts that should be done BEFORE syncing the filesystems.
*/
EVENTHANDLER_INVOKE(shutdown_pre_sync, howto);
/*
* Try to get rid of any remaining FS references. The calling
* process, proc0, and init may still hold references. The
* VFS cache subsystem may still hold a root reference to root.
*
* XXX this needs work. We really need to SIGSTOP all remaining
* processes in order to avoid blowups due to proc0's filesystem
* references going away. For now just make sure that the init
* process is stopped.
*/
if (panicstr == NULL) {
shutdown_cleanup_proc(curproc);
shutdown_cleanup_proc(&proc0);
if (initproc) {
if (initproc != curproc) {
ksignal(initproc, SIGSTOP);
tsleep(boot, 0, "shutdn", hz / 20);
}
shutdown_cleanup_proc(initproc);
}
vfs_cache_setroot(NULL, NULL);
}
/*
* Now sync filesystems
*/
if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) {
int iter, nbusy, pbusy;
waittime = 0;
kprintf("\nsyncing disks... ");
sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */
/*
* With soft updates, some buffers that are
* written will be remarked as dirty until other
* buffers are written.
*/
for (iter = pbusy = 0; iter < 20; iter++) {
nbusy = scan_all_buffers(shutdown_busycount1, NULL);
if (nbusy == 0)
break;
kprintf("%d ", nbusy);
if (nbusy < pbusy)
iter = 0;
pbusy = nbusy;
/*
* XXX:
* Process soft update work queue if buffers don't sync
* after 6 iterations by permitting the syncer to run.
*/
if (iter > 5)
bio_ops_sync(NULL);
sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */
tsleep(boot, 0, "shutdn", hz * iter / 20 + 1);
}
kprintf("\n");
/*
* Count only busy local buffers to prevent forcing
* a fsck if we're just a client of a wedged NFS server
*/
nbusy = scan_all_buffers(shutdown_busycount2, NULL);
if (nbusy) {
/*
* Failed to sync all blocks. Indicate this and don't
* unmount filesystems (thus forcing an fsck on reboot).
*/
kprintf("giving up on %d buffers\n", nbusy);
#ifdef DDB
if (debugger_on_panic)
Debugger("busy buffer problem");
#endif /* DDB */
tsleep(boot, 0, "shutdn", hz * 5 + 1);
} else {
kprintf("done\n");
/*
* Unmount filesystems
*/
if (panicstr == NULL)
vfs_unmountall();
}
tsleep(boot, 0, "shutdn", hz / 10 + 1);
}
print_uptime();
/*
* Dump before doing post_sync shutdown ops
*/
crit_enter();
if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold) {
dumpsys();
}
/*
* Ok, now do things that assume all filesystem activity has
* been completed. This will also call the device shutdown
* methods.
*/
EVENTHANDLER_INVOKE(shutdown_post_sync, howto);
/* Now that we're going to really halt the system... */
EVENTHANDLER_INVOKE(shutdown_final, howto);
for(;;) ; /* safety against shutdown_reset not working */
/* NOTREACHED */
}
/*
* MPSAFE thread
*/
static void
vm_pagezero(void *arg)
{
vm_page_t m = NULL;
struct lwbuf *lwb = NULL;
struct lwbuf lwb_cache;
enum zeroidle_state state = STATE_IDLE;
char *pg = NULL;
int npages = 0;
int sleep_time;
int i = 0;
int cpu = (int)(intptr_t)arg;
int zero_state = 0;
/*
* Adjust thread parameters before entering our loop. The thread
* is started with the MP lock held and with normal kernel thread
* priority.
*
* Also put us on the last cpu for now.
*
* For now leave the MP lock held, the VM routines cannot be called
* with it released until tokenization is finished.
*/
lwkt_setpri_self(TDPRI_IDLE_WORK);
lwkt_setcpu_self(globaldata_find(cpu));
sleep_time = DEFAULT_SLEEP_TIME;
/*
* Loop forever
*/
for (;;) {
int zero_count;
switch(state) {
case STATE_IDLE:
/*
* Wait for work.
*/
tsleep(&zero_state, 0, "pgzero", sleep_time);
if (vm_page_zero_check(&zero_count, &zero_state))
npages = idlezero_rate / 10;
sleep_time = vm_page_zero_time(zero_count);
if (npages)
state = STATE_GET_PAGE; /* Fallthrough */
break;
case STATE_GET_PAGE:
/*
* Acquire page to zero
*/
if (--npages == 0) {
state = STATE_IDLE;
} else {
m = vm_page_free_fromq_fast();
if (m == NULL) {
state = STATE_IDLE;
} else {
state = STATE_ZERO_PAGE;
lwb = lwbuf_alloc(m, &lwb_cache);
pg = (char *)lwbuf_kva(lwb);
i = 0;
}
}
break;
case STATE_ZERO_PAGE:
/*
* Zero-out the page
*/
while (i < PAGE_SIZE) {
if (idlezero_nocache == 1)
bzeront(&pg[i], IDLEZERO_RUN);
else
bzero(&pg[i], IDLEZERO_RUN);
i += IDLEZERO_RUN;
lwkt_yield();
}
state = STATE_RELEASE_PAGE;
break;
case STATE_RELEASE_PAGE:
lwbuf_free(lwb);
vm_page_flag_set(m, PG_ZERO);
vm_page_free_toq(m);
state = STATE_GET_PAGE;
++idlezero_count; /* non-locked, SMP race ok */
break;
}
lwkt_yield();
}
}
