Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754241AbXLGHzc (ORCPT ); Fri, 7 Dec 2007 02:55:32 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1752423AbXLGHyQ (ORCPT ); Fri, 7 Dec 2007 02:54:16 -0500 Received: from mga11.intel.com ([192.55.52.93]:53438 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751549AbXLGHyL (ORCPT ); Fri, 7 Dec 2007 02:54:11 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.23,265,1194249600"; d="scan'208";a="423054679" Subject: [PATCH 3/4 -mm] kexec based hibernation -v7 : kexec hibernate/resume From: "Huang, Ying" To: "Eric W. Biederman" , Pavel Machek , nigel@nigel.suspend2.net, "Rafael J. Wysocki" , Andrew Morton , Jeremy Maitin-Shepard Cc: linux-kernel@vger.kernel.org, linux-pm@lists.linux-foundation.org, Kexec Mailing List Content-Type: text/plain Content-Transfer-Encoding: 7bit Date: Fri, 07 Dec 2007 15:53:40 +0000 Message-Id: <1197042820.24045.63.camel@caritas-dev.intel.com> Mime-Version: 1.0 X-Mailer: Evolution 2.10.3 X-OriginalArrivalTime: 07 Dec 2007 07:54:07.0826 (UTC) FILETIME=[585CC320:01C838A6] Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 9011 Lines: 348 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 --- 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 #include #include +#include #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, -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/