lkml.org 
[lkml]   [2007]   [Dec]   [7]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH 3/4 -mm] kexec based hibernation -v7 : kexec hibernate/resume
    From
    Date
    This patch implements kexec based hibernate/resume. This is based on
    the facility provided by kexec_jump. The states save/restore code of
    ordinary kexec_jump is overridden by hibernate/resume specific
    code. The ACPI methods are called at specified environment to conform
    the ACPI specification. A new reboot command is added to go to ACPI S4
    state from user space.

    Signed-off-by: Huang Ying <ying.huang@intel.com>

    ---
    include/linux/kexec.h | 4
    include/linux/reboot.h | 1
    include/linux/suspend.h | 1
    kernel/power/disk.c | 244 +++++++++++++++++++++++++++++++++++++++++++++++-
    kernel/sys.c | 5
    5 files changed, 251 insertions(+), 4 deletions(-)

    --- a/kernel/power/disk.c
    +++ b/kernel/power/disk.c
    @@ -21,6 +21,7 @@
    #include <linux/console.h>
    #include <linux/cpu.h>
    #include <linux/freezer.h>
    +#include <linux/kexec.h>

    #include "power.h"

    @@ -365,13 +366,13 @@ int hibernation_platform_enter(void)
    }

    /**
    - * power_down - Shut the machine down for hibernation.
    + * hibernate_power_down - Shut the machine down for hibernation.
    *
    * Use the platform driver, if configured so; otherwise try
    * to power off or reboot.
    */

    -static void power_down(void)
    +void hibernate_power_down(void)
    {
    switch (hibernation_mode) {
    case HIBERNATION_TEST:
    @@ -461,7 +462,7 @@ int hibernate(void)
    error = swsusp_write(flags);
    swsusp_free();
    if (!error)
    - power_down();
    + hibernate_power_down();
    } else {
    pr_debug("PM: Image restored successfully.\n");
    swsusp_free();
    @@ -478,6 +479,243 @@ int hibernate(void)
    return error;
    }

    +#ifdef CONFIG_KEXEC
    +static int kexec_snapshot(struct notifier_block *nb,
    + unsigned long cmd, void *arg)
    +{
    + int error;
    + int platform_mode = (hibernation_mode == HIBERNATION_PLATFORM);
    +
    + if (cmd != KJUMP_CMD_HIBERNATE_WRITE_IMAGE)
    + return NOTIFY_DONE;
    +
    + pm_prepare_console();
    +
    + error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
    + if (error)
    + goto Exit;
    +
    + error = freeze_processes();
    + if (error) {
    + error = -EBUSY;
    + goto Exit;
    + }
    +
    + if (hibernation_test(TEST_FREEZER) ||
    + hibernation_testmode(HIBERNATION_TESTPROC)) {
    + error = -EAGAIN;
    + goto Resume_process;
    + }
    +
    + error = platform_start(platform_mode);
    + if (error)
    + goto Resume_process;
    +
    + suspend_console();
    + error = device_suspend(PMSG_FREEZE);
    + if (error)
    + goto Resume_console;
    +
    + if (hibernation_test(TEST_DEVICES)) {
    + error = -EAGAIN;
    + goto Resume_devices;
    + }
    +
    + error = platform_pre_snapshot(platform_mode);
    + if (error)
    + goto Resume_devices;
    +
    + if (hibernation_test(TEST_PLATFORM)) {
    + error = -EAGAIN;
    + goto Resume_devices;
    + }
    +
    + error = disable_nonboot_cpus();
    + if (error)
    + goto Resume_devices;
    +
    + if (hibernation_test(TEST_CPUS) ||
    + hibernation_testmode(HIBERNATION_TEST)) {
    + error = -EAGAIN;
    + goto Enable_cpus;
    + }
    +
    + local_irq_disable();
    + /* At this point, device_suspend() has been called, but *not*
    + * device_power_down(). We *must* device_power_down() now.
    + * Otherwise, drivers for some devices (e.g. interrupt
    + * controllers) become desynchronized with the actual state of
    + * the hardware at resume time, and evil weirdness ensues.
    + */
    + error = device_power_down(PMSG_FREEZE);
    + if (error)
    + goto Enable_irqs;
    +
    + if (hibernation_test(TEST_CORE)) {
    + error = -EAGAIN;
    + goto Power_up;
    + }
    +
    + return NOTIFY_STOP;
    +
    + Power_up:
    + device_power_up();
    + Enable_irqs:
    + local_irq_enable();
    + Enable_cpus:
    + enable_nonboot_cpus();
    + Resume_devices:
    + platform_finish(platform_mode);
    + device_resume();
    + Resume_console:
    + resume_console();
    + Resume_process:
    + thaw_processes();
    + Exit:
    + pm_notifier_call_chain(PM_POST_HIBERNATION);
    + pm_restore_console();
    + return notifier_from_errno(error);
    +}
    +
    +static int kexec_prepare_write_image(struct notifier_block *nb,
    + unsigned long cmd, void *arg)
    +{
    + int platform_mode = (hibernation_mode == HIBERNATION_PLATFORM);
    +
    + if (cmd != KJUMP_CMD_HIBERNATE_WRITE_IMAGE)
    + return NOTIFY_DONE;
    +
    + device_power_up();
    + local_irq_enable();
    + enable_nonboot_cpus();
    + platform_finish(platform_mode);
    + device_resume();
    + resume_console();
    + thaw_processes();
    + pm_restore_console();
    + return NOTIFY_STOP;
    +}
    +
    +static int kexec_prepare_resume(struct notifier_block *nb,
    + unsigned long cmd, void *arg)
    +{
    + int error;
    + int platform_mode = (hibernation_mode == HIBERNATION_PLATFORM);
    +
    + if (cmd != KJUMP_CMD_HIBERNATE_RESUME)
    + return NOTIFY_DONE;
    +
    + pm_prepare_console();
    + error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
    + if (error)
    + goto Exit;
    +
    + error = freeze_processes();
    + if (error) {
    + error = -EBUSY;
    + goto Exit;
    + }
    +
    + suspend_console();
    + error = device_suspend(PMSG_PRETHAW);
    + if (error)
    + goto Resume_console;
    +
    + error = platform_pre_restore(platform_mode);
    + if (error)
    + goto Resume_devices;
    +
    + error = disable_nonboot_cpus();
    + if (error)
    + goto Resume_devices;
    + local_irq_disable();
    + /* At this point, device_suspend() has been called, but *not*
    + * device_power_down(). We *must* device_power_down() now.
    + * Otherwise, drivers for some devices (e.g. interrupt controllers)
    + * become desynchronized with the actual state of the hardware
    + * at resume time, and evil weirdness ensues.
    + */
    + error = device_power_down(PMSG_PRETHAW);
    + if (error)
    + goto Enable_irqs;
    +
    + return NOTIFY_STOP;
    +
    + Enable_irqs:
    + local_irq_enable();
    + enable_nonboot_cpus();
    + Resume_devices:
    + platform_restore_cleanup(platform_mode);
    + device_resume();
    + Resume_console:
    + resume_console();
    + thaw_processes();
    + Exit:
    + pm_notifier_call_chain(PM_POST_RESTORE);
    + pm_restore_console();
    + return notifier_from_errno(error);
    +}
    +
    +static int kexec_resume(struct notifier_block *nb,
    + unsigned long cmd, void *arg)
    +{
    + int platform_mode = (hibernation_mode == HIBERNATION_PLATFORM);
    +
    + if (cmd != KJUMP_CMD_HIBERNATE_RESUME)
    + return NOTIFY_DONE;
    +
    + platform_leave(platform_mode);
    + device_power_up();
    + local_irq_enable();
    + enable_nonboot_cpus();
    + platform_finish(platform_mode);
    + device_resume();
    + resume_console();
    + thaw_processes();
    + pm_notifier_call_chain(PM_POST_HIBERNATION);
    + pm_restore_console();
    + return NOTIFY_STOP;
    +}
    +
    +static struct notifier_block nb_kexec_snapshot = {
    + .notifier_call = kexec_snapshot,
    +};
    +
    +static struct notifier_block nb_kexec_prepare_write_image = {
    + .notifier_call = kexec_prepare_write_image,
    +};
    +
    +static struct notifier_block nb_kexec_prepare_resume = {
    + .notifier_call = kexec_prepare_resume,
    +};
    +
    +static struct notifier_block nb_kexec_resume = {
    + .notifier_call = kexec_resume,
    +};
    +
    +static int kexec_hibernation_register(void)
    +{
    + int ret;
    +
    + ret = blocking_notifier_chain_register(&kjump_chain_pre,
    + &nb_kexec_snapshot);
    + if (ret)
    + return ret;
    + ret = blocking_notifier_chain_register(&kjump_chain_post,
    + &nb_kexec_prepare_write_image);
    + if (ret)
    + return ret;
    + ret = blocking_notifier_chain_register(&kjump_chain_pre,
    + &nb_kexec_prepare_resume);
    + if (ret)
    + return ret;
    + ret = blocking_notifier_chain_register(&kjump_chain_post,
    + &nb_kexec_resume);
    + return ret;
    +}
    +
    +late_initcall(kexec_hibernation_register);
    +#endif

    /**
    * software_resume - Resume from a saved image.
    --- a/include/linux/suspend.h
    +++ b/include/linux/suspend.h
    @@ -198,6 +198,7 @@ extern unsigned long get_safe_page(gfp_t

    extern void hibernation_set_ops(struct platform_hibernation_ops *ops);
    extern int hibernate(void);
    +extern void hibernate_power_down(void);
    #else /* CONFIG_HIBERNATION */
    static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
    static inline void swsusp_set_page_free(struct page *p) {}
    --- a/kernel/sys.c
    +++ b/kernel/sys.c
    @@ -442,6 +442,11 @@ asmlinkage long sys_reboot(int magic1, i
    unlock_kernel();
    return ret;
    }
    +
    + case LINUX_REBOOT_CMD_HIBERNATE_POWER_DOWN:
    + hibernate_power_down();
    + unlock_kernel();
    + return -EINVAL;
    #endif

    default:
    --- a/include/linux/reboot.h
    +++ b/include/linux/reboot.h
    @@ -33,6 +33,7 @@
    #define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
    #define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2
    #define LINUX_REBOOT_CMD_KEXEC 0x45584543
    +#define LINUX_REBOOT_CMD_HIBERNATE_POWER_DOWN 0xE4390DF3


    #ifdef __KERNEL__
    --- a/include/linux/kexec.h
    +++ b/include/linux/kexec.h
    @@ -127,7 +127,9 @@ extern int kexec_vcall(struct kimage *im
    unsigned int argc, va_list args);
    extern int kexec_jump(struct kimage *image, unsigned long *cmd_ret,
    unsigned long cmd);
    -#define KJUMP_CMD_NONE 0
    +#define KJUMP_CMD_NONE 0x0
    +#define KJUMP_CMD_HIBERNATE_WRITE_IMAGE 0x6b630001
    +#define KJUMP_CMD_HIBERNATE_RESUME 0x6b630002
    #ifdef CONFIG_COMPAT
    extern asmlinkage long compat_sys_kexec_load(unsigned long entry,
    unsigned long nr_segments,

    \
     
     \ /
      Last update: 2007-12-07 08:59    [W:0.035 / U:14.924 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site