cpr_main.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This module contains the guts of checkpoint-resume mechanism.
* All code in this module is platform independent.
*/
#include <sys/processor.h>
#include <sys/machsystm.h>
#include <sys/bootconf.h>
extern struct cpr_terminator cpr_term;
extern int cpr_alloc_statefile(int);
extern void cpr_start_kernel_threads(void);
extern void cpr_abbreviate_devpath(char *, char *);
extern void cpr_convert_promtime(cpr_time_t *);
extern void cpr_send_notice(void);
extern void cpr_set_bitmap_size(void);
extern void cpr_stat_init();
extern void cpr_statef_close(void);
extern void flush_windows(void);
extern int pm_powering_down;
static int cpr_suspend(void);
static int cpr_resume(void);
static void cpr_suspend_init(void);
int curthreadremapped;
/*
* save or restore abort_enable; this prevents a drop
* to kadb or prom during cpr_resume_devices() when
* there is no kbd present; see abort_sequence_enter()
*/
static void
{
static int saved_ae = -1;
if (stash) {
abort_enable = 0;
} else if (saved_ae != -1) {
saved_ae = -1;
}
}
/*
* The main switching point for cpr, this routine starts the ckpt
* and state file saving routines; on resume the control is
* returned back to here and it then calls the resume routine.
*/
int
cpr_main(void)
{
int rc;
return (rc);
/*
* Remember where we are for resume
*/
/*
* try to checkpoint the system, if failed return back
* to userland, otherwise power off.
*/
rc = cpr_suspend();
if (rc || cpr_reusable_mode) {
/*
* We don't really want to go down, or
* something went wrong in suspend, do what we can
* to put the system back to an operable state then
* return back to userland.
*/
(void) cpr_resume();
}
} else {
/*
* This is the resumed side of longjmp, restore the previous
* longjmp pointer if there is one so this will be transparent
* to the world.
*/
/*
* resume the system back to the original state
*/
rc = cpr_resume();
}
(void) cpr_default_setup(0);
return (rc);
}
/*
*/
static void
{
str = "cpr_log_status";
/*
* when disabling, first get and save logging status (0 or 1)
*/
if (enable == 0) {
errp("%s: \"%s\", cant get logging status, error %d\n",
return;
}
{
errp("%s: \"%s\", logging status = %d\n",
});
able = "disable";
} else {
able = "enable";
cmd = _FIOLOGENABLE;
}
/*
* disable or re-enable logging when the saved status is 1
*/
if (*svstat == 1) {
if (error) {
errp("%s: \"%s\", cant %s logging, error %d\n",
} else {
{
errp("%s: \"%s\", logging is now %sd\n",
});
}
}
/*
* when enabling logging, reset the saved status
* to unknown for next time
*/
if (enable)
*svstat = -1;
}
/*
* and cpr statefile. since the statefile can be on any fs, that fs
* needs to be handled separately. this routine and cprboot expect that
* CPR_CONFIG and CPR_DEFAULT both reside on the same fs, rootfs. cprboot
* is loaded from the device with rootfs and uses the same device to open
* file outside of rootfs would cause errors during cprboot, plus cpr and
* fsck problems with the new fs if logging were enabled.
*/
static int
cpr_ufs_logging(int enable)
{
char *fname;
int error;
if (cpr_reusable_mode)
return (0);
return (error);
return (ENOENT);
return (error);
}
/*
* check logging status for the statefile if it resides
* on a different fs and the type is a regular file
*/
return (0);
}
/*
* Check if klmmod is loaded and call a lock manager service; if klmmod
* is not loaded, the services aren't needed and a call would trigger a
* modload, which would block since another thread would never run.
*/
static void
cpr_lock_mgr(void (*service)(void))
{
(*service)();
}
/*
* Take the system down to a checkpointable state and write
* the state file, the following are sequentially executed:
*
* - Request all user threads to stop themselves
* - push out and invalidate user pages
* - bring statefile inode incore to prevent a miss later
* - request all daemons to stop
* - check and make sure all threads are stopped
* - sync the file system
* - suspend all devices
* - block intrpts
* - dump system state and memory to state file
*/
static int
cpr_suspend(void)
{
CPR_STAT_EVENT_START("Suspend Total");
if (!cpr_reusable_mode) {
/*
* We need to validate default file before fs functionality
* is disabled.
*/
if (rc = cpr_validate_definfo(0))
return (rc);
}
/* Stop PM scans ASAP */
if (rc = cpr_mp_offline())
return (rc);
/*
* Ask the user threads to stop by themselves, but
* if they don't or can't after 3 retries, we give up on CPR.
* The 3 retry is not a random number because 2 is possible if
* a thread has been forked before the parent thread is stopped.
*/
CPR_STAT_EVENT_START(" stop users");
if (rc = cpr_stop_user_threads())
return (rc);
CPR_STAT_EVENT_END(" stop users");
/*
* User threads are stopped. We will start communicating with the
* user via prom_printf (some debug output may have already happened)
* so let anybody who cares know about this (bug 4096122)
*/
if (cpr_debug)
errp("\n");
/*
* Reattach any drivers which originally exported the
* no-involuntary-power-cycles property. We need to do this before
* stopping kernel threads because modload is implemented using
* a kernel thread.
*/
if (!pm_reattach_noinvol())
return (ENXIO);
/*
* if ufs logging is enabled, we need to disable before
* stopping kernel threads so that ufs delete and roll
* threads can do the work.
*/
if (rc = cpr_ufs_logging(0))
return (rc);
/*
* Use sync_all to swap out all user pages and find out how much
* extra space needed for user pages that don't have back store
* space left.
*/
CPR_STAT_EVENT_START(" swapout upages");
CPR_STAT_EVENT_END(" swapout upages");
/*
* If our last state was C_ST_DUMP_NOSPC, we're trying to realloc
* the statefile, otherwise this is the first attempt.
*/
CPR_STAT_EVENT_START(" alloc statefile");
if (sf_realloc)
errp("realloc failed\n");
return (rc);
}
CPR_STAT_EVENT_END(" alloc statefile");
/*
* Sync the filesystem to preserve its integrity.
*
* This sync is also used to flush out all B_DELWRI buffers (fs cache)
* which are mapped and neither dirty nor referenced before
* cpr_invalidate_pages destroys them. fsflush does similar thing.
*/
sync();
/*
* destroy all clean file mapped kernel pages
*/
CPR_STAT_EVENT_START(" clean pages");
CPR_STAT_EVENT_END(" clean pages");
/*
* Hooks needed by lock manager prior to suspending.
* Refer to code for more comments.
*/
/*
* Now suspend all the devices
*/
CPR_STAT_EVENT_START(" stop drivers");
pm_powering_down = 1;
pm_powering_down = 0;
if (rc)
return (rc);
CPR_STAT_EVENT_END(" stop drivers");
/*
* Stop all daemon activities
*/
if (skt_rc = cpr_stop_kernel_threads())
return (skt_rc);
cpr_sae(1);
/*
* It's safer to do tod_get before we disable all intr.
*/
CPR_STAT_EVENT_START(" write statefile");
/*
* it's time to ignore the outside world, stop the real time
* clock and disable any further intrpt activity.
*/
/*
* Since we will now disable the mechanism that causes prom_printfs
* it must be up now.
*/
ASSERT(pm_cfb_is_up());
/*
* getting ready to write ourself out, flush the register
* windows to make sure that our stack is good when we
* come back on the resume side.
*/
/*
* FATAL: NO MORE MEMORY ALLOCATION ALLOWED AFTER THIS POINT!!!
*
* The system is quiesced at this point, we are ready to either dump
* to the state file for a extended sleep or a simple shutdown for
* systems with non-volatile memory.
*/
/*
* special handling for reusable:
*/
if (cpr_reusable_mode) {
return (nverr);
}
/*
* if any error occured during dump, more
* special handling for reusable:
*/
if (rc && cpr_reusable_mode) {
if (nverr = cpr_set_properties(0))
return (nverr);
}
(void) cpr_resume();
goto alloc_statefile;
} else if (rc == 0) {
if (cpr_reusable_mode) {
} else
}
return (rc);
}
/*
* Bring the system back up from a checkpoint, at this point
* the VM has been minimally restored by boot, the following
* are executed sequentially:
*
* - machdep setup and enable interrupts (mp startup if it's mp)
* - resume all devices
* - restart daemons
* - put all threads back on run queue
*/
static int
cpr_resume(void)
{
char *str;
int rc = 0;
/*
* The following switch is used to resume the system
* that was suspended to a different level.
*/
/*
* Note:
*
* The rollback labels rb_xyz do not represent the cpr resume
* state when event 'xyz' has happened. Instead they represent
* the state during cpr suspend when event 'xyz' was being
* entered (and where cpr suspend failed). The actual call that
* failed may also need to be partially rolled back, since they
* aren't atomic in most cases. In other words, rb_xyz means
* "roll back all cpr suspend events that happened before 'xyz',
* and the one that caused the failure, if necessary."
*/
switch (CPR->c_substate) {
case C_ST_DUMP:
/*
* This is most likely a full-fledged cpr_resume after
* a complete and successful cpr suspend. Just roll back
* everything.
*/
break;
case C_ST_REUSABLE:
case C_ST_DUMP_NOSPC:
case C_ST_SETPROPS_0:
case C_ST_SETPROPS_1:
/*
* C_ST_REUSABLE and C_ST_DUMP_NOSPC are the only two
* special switch cases here. The other two do not have
* any state change during cpr_suspend() that needs to
* be rolled back. But these are exit points from
* cpr_suspend, so theoretically (or in the future), it
* is possible that a need for roll back of a state
* change arises between these exit points.
*/
goto rb_dump;
case C_ST_STOP_KERNEL_THREADS:
goto rb_stop_kernel_threads;
case C_ST_SUSPEND_DEVICES:
goto rb_suspend_devices;
case C_ST_STATEF_ALLOC:
goto rb_statef_alloc;
case C_ST_DISABLE_UFS_LOGGING:
goto rb_disable_ufs_logging;
case C_ST_PM_REATTACH_NOINVOL:
goto rb_pm_reattach_noinvol;
case C_ST_STOP_USER_THREADS:
goto rb_stop_user_threads;
case C_ST_MP_OFFLINE:
goto rb_mp_offline;
default:
goto rb_others;
}
/*
* setup debugger trapping.
*/
/*
* tell prom to monitor keys before the kernel comes alive
*/
/*
* perform platform-dependent initialization
*/
/*
* system did not really go down if we jump here
*/
/*
* IMPORTANT: SENSITIVE RESUME SEQUENCE
*
* DO NOT ADD ANY INITIALIZATION STEP BEFORE THIS POINT!!
*/
/*
* let the tmp callout catch up.
*/
i_cpr_handle_xc(0); /* turn it off to allow xc assertion */
/*
* statistics gathering
*/
if (cpr_suspend_succeeded) {
/*
* Prevent false alarm in tod_validate() due to tod
* value change between suspend and resume
*/
str = " prom time";
str = " read statefile";
}
/*
* Put all threads back to where they belong; get the kernel
* daemons straightened up too. Note that the callback table
* locked during cpr_stop_kernel_threads() is released only
* in cpr_start_kernel_threads(). Ensure modunloading is
* disabled before starting kernel threads, we don't want
* modunload thread to start changing device tree underneath.
*/
CPR_STAT_EVENT_START(" start drivers");
/*
* The policy here is to continue resume everything we can if we did
* not successfully finish suspend; and panic if we are coming back
* from a fully suspended system.
*/
cpr_sae(0);
str = "Failed to resume one or more devices.";
else if (rc)
CPR_STAT_EVENT_END(" start drivers");
/*
* If we had disabled modunloading in this cpr resume cycle (i.e. we
* resumed from a state earlier than C_ST_SUSPEND_DEVICES), re-enable
* modunloading now.
*/
/*
* Hooks needed by lock manager prior to resuming.
* Refer to code for more comments.
*/
/*
* This is a partial (half) resume during cpr suspend, we
* haven't yet given up on the suspend. On return from here,
* cpr_suspend() will try to reallocate and retry the suspend.
*/
return (0);
}
/*
* if ufs logging was disabled, re-enable
*/
(void) cpr_ufs_logging(1);
/*
* When pm_reattach_noinvol() succeeds, modunload_thread will
* remain disabled until after cpr suspend passes the
* C_ST_STOP_KERNEL_THREADS state. If any failure happens before
* cpr suspend reaches this state, we'll need to enable modunload
* thread during rollback.
*/
}
if (cpr_mp_online())
NULL, 0);
/*
* now that all the drivers are going, kernel kbd driver can
* take over, turn off prom monitor clock
*/
if (cpr_suspend_succeeded) {
}
if (!cpr_reusable_mode)
CPR_STAT_EVENT_END("Resume Total");
CPR_STAT_EVENT_END("WHOLE CYCLE");
CPR_STAT_EVENT_START("POST CPR DELAY");
#ifdef CPR_STAT
#endif /* CPR_STAT */
return (rc);
}
static void
cpr_suspend_init(void)
{
/*
* If cpr_suspend() failed before cpr_dump() gets a chance
* to reinitialize the terminator of the statefile,
* the values of the old terminator will still linger around.
* Since the terminator contains information that we need to
* decide whether suspend succeeded or not, we need to
* reinitialize it as early as possible.
*/
cpr_term.real_statef_size = 0;
/*
* Lookup the physical address of our thread structure. This should
* never be invalid and the entire thread structure is expected
* to reside within the same pfn.
*/
}