![Rafael J. Wysocki](/assets/img/avatar_default.png)
There is a problem that swap pages allocated before the creation of a hibernation image can be released and used for storing the contents of different memory pages while the image is being saved. Since the kernel stored in the image doesn't know of that, it causes memory corruption to occur after resume from hibernation, especially on systems with relatively small RAM that need to swap often. This issue can be addressed by keeping the GFP_IOFS bits clear in gfp_allowed_mask during the entire hibernation, including the saving of the image, until the system is finally turned off or the hibernation is aborted. Unfortunately, for this purpose it's necessary to rework the way in which the hibernate and suspend code manipulates gfp_allowed_mask. This change is based on an earlier patch from Hugh Dickins. Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> Reported-by: Ondrej Zary <linux@rainbow-software.org> Acked-by: Hugh Dickins <hughd@google.com> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> Cc: stable@kernel.org
311 lines
6.7 KiB
C
311 lines
6.7 KiB
C
/*
|
|
* kernel/power/suspend.c - Suspend to RAM and standby functionality.
|
|
*
|
|
* Copyright (c) 2003 Patrick Mochel
|
|
* Copyright (c) 2003 Open Source Development Lab
|
|
* Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
|
|
*
|
|
* This file is released under the GPLv2.
|
|
*/
|
|
|
|
#include <linux/string.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/console.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/syscalls.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/io.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/list.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/suspend.h>
|
|
|
|
#include "power.h"
|
|
|
|
const char *const pm_states[PM_SUSPEND_MAX] = {
|
|
[PM_SUSPEND_STANDBY] = "standby",
|
|
[PM_SUSPEND_MEM] = "mem",
|
|
};
|
|
|
|
static struct platform_suspend_ops *suspend_ops;
|
|
|
|
/**
|
|
* suspend_set_ops - Set the global suspend method table.
|
|
* @ops: Pointer to ops structure.
|
|
*/
|
|
void suspend_set_ops(struct platform_suspend_ops *ops)
|
|
{
|
|
mutex_lock(&pm_mutex);
|
|
suspend_ops = ops;
|
|
mutex_unlock(&pm_mutex);
|
|
}
|
|
|
|
bool valid_state(suspend_state_t state)
|
|
{
|
|
/*
|
|
* All states need lowlevel support and need to be valid to the lowlevel
|
|
* implementation, no valid callback implies that none are valid.
|
|
*/
|
|
return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
|
|
}
|
|
|
|
/**
|
|
* suspend_valid_only_mem - generic memory-only valid callback
|
|
*
|
|
* Platform drivers that implement mem suspend only and only need
|
|
* to check for that in their .valid callback can use this instead
|
|
* of rolling their own .valid callback.
|
|
*/
|
|
int suspend_valid_only_mem(suspend_state_t state)
|
|
{
|
|
return state == PM_SUSPEND_MEM;
|
|
}
|
|
|
|
static int suspend_test(int level)
|
|
{
|
|
#ifdef CONFIG_PM_DEBUG
|
|
if (pm_test_level == level) {
|
|
printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
|
|
mdelay(5000);
|
|
return 1;
|
|
}
|
|
#endif /* !CONFIG_PM_DEBUG */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* suspend_prepare - Do prep work before entering low-power state.
|
|
*
|
|
* This is common code that is called for each state that we're entering.
|
|
* Run suspend notifiers, allocate a console and stop all processes.
|
|
*/
|
|
static int suspend_prepare(void)
|
|
{
|
|
int error;
|
|
|
|
if (!suspend_ops || !suspend_ops->enter)
|
|
return -EPERM;
|
|
|
|
pm_prepare_console();
|
|
|
|
error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
|
|
if (error)
|
|
goto Finish;
|
|
|
|
error = usermodehelper_disable();
|
|
if (error)
|
|
goto Finish;
|
|
|
|
error = suspend_freeze_processes();
|
|
if (!error)
|
|
return 0;
|
|
|
|
suspend_thaw_processes();
|
|
usermodehelper_enable();
|
|
Finish:
|
|
pm_notifier_call_chain(PM_POST_SUSPEND);
|
|
pm_restore_console();
|
|
return error;
|
|
}
|
|
|
|
/* default implementation */
|
|
void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
|
|
{
|
|
local_irq_disable();
|
|
}
|
|
|
|
/* default implementation */
|
|
void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
|
|
{
|
|
local_irq_enable();
|
|
}
|
|
|
|
/**
|
|
* suspend_enter - enter the desired system sleep state.
|
|
* @state: state to enter
|
|
*
|
|
* This function should be called after devices have been suspended.
|
|
*/
|
|
static int suspend_enter(suspend_state_t state)
|
|
{
|
|
int error;
|
|
|
|
if (suspend_ops->prepare) {
|
|
error = suspend_ops->prepare();
|
|
if (error)
|
|
goto Platform_finish;
|
|
}
|
|
|
|
error = dpm_suspend_noirq(PMSG_SUSPEND);
|
|
if (error) {
|
|
printk(KERN_ERR "PM: Some devices failed to power down\n");
|
|
goto Platform_finish;
|
|
}
|
|
|
|
if (suspend_ops->prepare_late) {
|
|
error = suspend_ops->prepare_late();
|
|
if (error)
|
|
goto Platform_wake;
|
|
}
|
|
|
|
if (suspend_test(TEST_PLATFORM))
|
|
goto Platform_wake;
|
|
|
|
error = disable_nonboot_cpus();
|
|
if (error || suspend_test(TEST_CPUS))
|
|
goto Enable_cpus;
|
|
|
|
arch_suspend_disable_irqs();
|
|
BUG_ON(!irqs_disabled());
|
|
|
|
error = sysdev_suspend(PMSG_SUSPEND);
|
|
if (!error) {
|
|
if (!suspend_test(TEST_CORE) && pm_check_wakeup_events()) {
|
|
error = suspend_ops->enter(state);
|
|
events_check_enabled = false;
|
|
}
|
|
sysdev_resume();
|
|
}
|
|
|
|
arch_suspend_enable_irqs();
|
|
BUG_ON(irqs_disabled());
|
|
|
|
Enable_cpus:
|
|
enable_nonboot_cpus();
|
|
|
|
Platform_wake:
|
|
if (suspend_ops->wake)
|
|
suspend_ops->wake();
|
|
|
|
dpm_resume_noirq(PMSG_RESUME);
|
|
|
|
Platform_finish:
|
|
if (suspend_ops->finish)
|
|
suspend_ops->finish();
|
|
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* suspend_devices_and_enter - suspend devices and enter the desired system
|
|
* sleep state.
|
|
* @state: state to enter
|
|
*/
|
|
int suspend_devices_and_enter(suspend_state_t state)
|
|
{
|
|
int error;
|
|
|
|
if (!suspend_ops)
|
|
return -ENOSYS;
|
|
|
|
if (suspend_ops->begin) {
|
|
error = suspend_ops->begin(state);
|
|
if (error)
|
|
goto Close;
|
|
}
|
|
suspend_console();
|
|
pm_restrict_gfp_mask();
|
|
suspend_test_start();
|
|
error = dpm_suspend_start(PMSG_SUSPEND);
|
|
if (error) {
|
|
printk(KERN_ERR "PM: Some devices failed to suspend\n");
|
|
goto Recover_platform;
|
|
}
|
|
suspend_test_finish("suspend devices");
|
|
if (suspend_test(TEST_DEVICES))
|
|
goto Recover_platform;
|
|
|
|
suspend_enter(state);
|
|
|
|
Resume_devices:
|
|
suspend_test_start();
|
|
dpm_resume_end(PMSG_RESUME);
|
|
suspend_test_finish("resume devices");
|
|
pm_restore_gfp_mask();
|
|
resume_console();
|
|
Close:
|
|
if (suspend_ops->end)
|
|
suspend_ops->end();
|
|
return error;
|
|
|
|
Recover_platform:
|
|
if (suspend_ops->recover)
|
|
suspend_ops->recover();
|
|
goto Resume_devices;
|
|
}
|
|
|
|
/**
|
|
* suspend_finish - Do final work before exiting suspend sequence.
|
|
*
|
|
* Call platform code to clean up, restart processes, and free the
|
|
* console that we've allocated. This is not called for suspend-to-disk.
|
|
*/
|
|
static void suspend_finish(void)
|
|
{
|
|
suspend_thaw_processes();
|
|
usermodehelper_enable();
|
|
pm_notifier_call_chain(PM_POST_SUSPEND);
|
|
pm_restore_console();
|
|
}
|
|
|
|
/**
|
|
* enter_state - Do common work of entering low-power state.
|
|
* @state: pm_state structure for state we're entering.
|
|
*
|
|
* Make sure we're the only ones trying to enter a sleep state. Fail
|
|
* if someone has beat us to it, since we don't want anything weird to
|
|
* happen when we wake up.
|
|
* Then, do the setup for suspend, enter the state, and cleaup (after
|
|
* we've woken up).
|
|
*/
|
|
int enter_state(suspend_state_t state)
|
|
{
|
|
int error;
|
|
|
|
if (!valid_state(state))
|
|
return -ENODEV;
|
|
|
|
if (!mutex_trylock(&pm_mutex))
|
|
return -EBUSY;
|
|
|
|
printk(KERN_INFO "PM: Syncing filesystems ... ");
|
|
sys_sync();
|
|
printk("done.\n");
|
|
|
|
pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
|
|
error = suspend_prepare();
|
|
if (error)
|
|
goto Unlock;
|
|
|
|
if (suspend_test(TEST_FREEZER))
|
|
goto Finish;
|
|
|
|
pr_debug("PM: Entering %s sleep\n", pm_states[state]);
|
|
error = suspend_devices_and_enter(state);
|
|
|
|
Finish:
|
|
pr_debug("PM: Finishing wakeup.\n");
|
|
suspend_finish();
|
|
Unlock:
|
|
mutex_unlock(&pm_mutex);
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* pm_suspend - Externally visible function for suspending system.
|
|
* @state: Enumerated value of state to enter.
|
|
*
|
|
* Determine whether or not value is within range, get state
|
|
* structure, and enter (above).
|
|
*/
|
|
int pm_suspend(suspend_state_t state)
|
|
{
|
|
if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
|
|
return enter_state(state);
|
|
return -EINVAL;
|
|
}
|
|
EXPORT_SYMBOL(pm_suspend);
|