From: Rafael J. Wysocki <rjw@xxxxxxx> Make it possible to register hibernation and suspend notifiers, so that subsystems can perform hibernation-related or suspend-related operations that should not be carried out by device drivers' .suspend() and .resume() routines. Signed-off-by: Rafael J. Wysocki <rjw@xxxxxxx> Documentation/power/notifiers.txt | 76 ++++++++++++++++++++++++++++++++++++++ include/linux/notifier.h | 13 ++++++ include/linux/suspend.h | 25 +++++++++++- kernel/power/Makefile | 2 - kernel/power/disk.c | 31 +++++++++++++-- kernel/power/main.c | 12 ++++++ kernel/power/notifier.c | 51 +++++++++++++++++++++++++ kernel/power/power.h | 4 ++ kernel/power/user.c | 11 ++++- 9 files changed, 214 insertions(+), 11 deletions(-) Index: linux-2.6.22-rc3/kernel/power/notifier.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ linux-2.6.22-rc3/kernel/power/notifier.c 2007-05-27 14:43:14.000000000 +0200 @@ -0,0 +1,51 @@ +/* + * linux/kernel/power/notifier.c + * + * This file contains functions used for registering and calling hibernation and + * suspend (PM) notifiers that can be used by subsystems for carrying out some + * special hibernation-related and/or suspend-related operations. + * + * Copyright (C) 2007 Rafael J. Wysocki <rjw@xxxxxxx> + * + * This file is released under the GPLv2. + * + */ + +#include <linux/smp.h> +#include <linux/notifier.h> +#include <linux/module.h> +#include <linux/suspend.h> + +static DEFINE_MUTEX(pm_notifier_lock); + +static RAW_NOTIFIER_HEAD(pm_chain); + +int register_pm_notifier(struct notifier_block *nb) +{ + int ret; + mutex_lock(&pm_notifier_lock); + ret = raw_notifier_chain_register(&pm_chain, nb); + mutex_unlock(&pm_notifier_lock); + return ret; +} +EXPORT_SYMBOL(register_pm_notifier); + +void unregister_pm_notifier(struct notifier_block *nb) +{ + mutex_lock(&pm_notifier_lock); + raw_notifier_chain_unregister(&pm_chain, nb); + mutex_unlock(&pm_notifier_lock); +} +EXPORT_SYMBOL(unregister_pm_notifier); + +int pm_notifier_call_chain(unsigned long val) +{ + int error = 0; + + mutex_lock(&pm_notifier_lock); + if (raw_notifier_call_chain(&pm_chain, val, NULL) == NOTIFY_BAD) + error = -EINVAL; + + mutex_unlock(&pm_notifier_lock); + return error; +} Index: linux-2.6.22-rc3/kernel/power/Makefile =================================================================== --- linux-2.6.22-rc3.orig/kernel/power/Makefile 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/kernel/power/Makefile 2007-05-27 14:43:14.000000000 +0200 @@ -3,7 +3,7 @@ ifeq ($(CONFIG_PM_DEBUG),y) EXTRA_CFLAGS += -DDEBUG endif -obj-y := main.o process.o console.o +obj-y := main.o process.o console.o notifier.o obj-$(CONFIG_PM_LEGACY) += pm.o obj-$(CONFIG_SOFTWARE_SUSPEND) += swsusp.o disk.o snapshot.o swap.o user.o Index: linux-2.6.22-rc3/include/linux/suspend.h =================================================================== --- linux-2.6.22-rc3.orig/include/linux/suspend.h 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/include/linux/suspend.h 2007-05-27 14:43:14.000000000 +0200 @@ -54,7 +54,8 @@ struct hibernation_ops { void (*restore_cleanup)(void); }; -#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND) +#ifdef CONFIG_PM +#ifdef CONFIG_SOFTWARE_SUSPEND /* kernel/power/snapshot.c */ extern void __register_nosave_region(unsigned long b, unsigned long e, int km); static inline void register_nosave_region(unsigned long b, unsigned long e) @@ -72,7 +73,7 @@ extern unsigned long get_safe_page(gfp_t extern void hibernation_set_ops(struct hibernation_ops *ops); extern int hibernate(void); -#else +#else /* CONFIG_SOFTWARE_SUSPEND */ static inline void register_nosave_region(unsigned long b, unsigned long e) {} static inline void register_nosave_region_late(unsigned long b, unsigned long e) {} static inline int swsusp_page_is_forbidden(struct page *p) { return 0; } @@ -81,7 +82,7 @@ static inline void swsusp_unset_page_fre static inline void hibernation_set_ops(struct hibernation_ops *ops) {} static inline int hibernate(void) { return -ENOSYS; } -#endif /* defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND) */ +#endif /* CONFIG_SOFTWARE_SUSPEND */ void save_processor_state(void); void restore_processor_state(void); @@ -89,4 +90,22 @@ struct saved_context; void __save_processor_state(struct saved_context *ctxt); void __restore_processor_state(struct saved_context *ctxt); +int register_pm_notifier(struct notifier_block *nb); +void unregister_pm_notifier(struct notifier_block *nb); + +#define pm_notifier(fn, pri) { \ + static struct notifier_block fn##_nb = \ + { .notifier_call = fn, .priority = pri }; \ + register_pm_notifier(&fn##_nb); \ +} +#else /* CONFIG_PM */ +static inline int register_pm_notifier(struct notifier_block *nb) { + return 0; +} +static inline void unregister_pm_notifier(struct notifier_block *nb) { +} + +#define pm_notifier(fn, pri) do { (void)(fn); } while (0) +#endif /* CONFIG_PM */ + #endif /* _LINUX_SWSUSP_H */ Index: linux-2.6.22-rc3/kernel/power/power.h =================================================================== --- linux-2.6.22-rc3.orig/kernel/power/power.h 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/kernel/power/power.h 2007-05-27 14:43:14.000000000 +0200 @@ -173,5 +173,9 @@ extern void swsusp_close(void); extern int suspend_enter(suspend_state_t state); struct timeval; +/* kernel/power/swsusp.c */ extern void swsusp_show_speed(struct timeval *, struct timeval *, unsigned int, char *); + +/* kernel/power/notifier.c */ +extern int pm_notifier_call_chain(unsigned long val); Index: linux-2.6.22-rc3/include/linux/notifier.h =================================================================== --- linux-2.6.22-rc3.orig/include/linux/notifier.h 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/include/linux/notifier.h 2007-05-27 14:43:14.000000000 +0200 @@ -209,5 +209,18 @@ extern int __srcu_notifier_call_chain(st #define CPU_DOWN_FAILED_FROZEN (CPU_DOWN_FAILED | CPU_TASKS_FROZEN) #define CPU_DEAD_FROZEN (CPU_DEAD | CPU_TASKS_FROZEN) +/* Hibernation and suspend events */ +#define PM_PRE_FREEZE 0x0001 /* Going to freeze tasks */ +#define PM_POST_THAW 0x0002 /* Tasks have just been thawed */ +#define PM_HIBERNATION_PREPARE 0x0003 /* Tasks frozen, going to hibernate */ +#define PM_SNAPSHOT_FAILED 0x0004 /* Couldn't create hibernation image */ +#define PM_POST_SNAPSHOT 0x0005 /* Image created, going to save it */ +#define PM_RESTORE_PREPARE 0x0006 /* Going to restore snapshotted system */ +#define PM_RESTORE_FAILED 0x0007 /* Couldn't restore snapshotted system */ +#define PM_POST_RESTORE 0x0008 /* Restore complete, thawing tasks */ +#define PM_SUSPEND_PREPARE 0x0009 /* Tasks frozen, going to suspend */ +#define PM_SUSPEND_FAILED 0x000A /* Couldn't suspend */ +#define PM_POST_RESUME 0x000B /* Resume successful, thawing tasks */ + #endif /* __KERNEL__ */ #endif /* _LINUX_NOTIFIER_H */ Index: linux-2.6.22-rc3/kernel/power/disk.c =================================================================== --- linux-2.6.22-rc3.orig/kernel/power/disk.c 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/kernel/power/disk.c 2007-05-27 15:42:54.000000000 +0200 @@ -130,6 +130,10 @@ int hibernation_snapshot(int platform_mo { int error; + error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE); + if (error) + return error; + /* Free memory before shutting down devices. */ error = swsusp_shrink_memory(); if (error) @@ -161,6 +165,12 @@ int hibernation_snapshot(int platform_mo device_resume(); Resume_console: resume_console(); + if (error) + pm_notifier_call_chain(PM_SNAPSHOT_FAILED); + else + pm_notifier_call_chain(in_suspend ? + PM_POST_SNAPSHOT : PM_POST_RESTORE); + return error; } @@ -177,6 +187,10 @@ int hibernation_restore(int platform_mod { int error; + error = pm_notifier_call_chain(PM_RESTORE_PREPARE); + if (error) + return error; + pm_prepare_console(); suspend_console(); error = device_suspend(PMSG_PRETHAW); @@ -195,6 +209,7 @@ int hibernation_restore(int platform_mod Finish: resume_console(); pm_restore_console(); + pm_notifier_call_chain(PM_RESTORE_FAILED); return error; } @@ -259,12 +274,17 @@ static void unprepare_processes(void) { thaw_processes(); pm_restore_console(); + pm_notifier_call_chain(PM_POST_THAW); } static int prepare_processes(void) { int error = 0; + error = pm_notifier_call_chain(PM_PRE_FREEZE); + if (error) + return error; + pm_prepare_console(); if (freeze_processes()) { error = -EBUSY; @@ -281,9 +301,12 @@ int hibernate(void) { int error; + mutex_lock(&pm_mutex); /* The snapshot device should not be opened while we're running */ - if (!atomic_add_unless(&snapshot_device_available, -1, 0)) - return -EBUSY; + if (!atomic_add_unless(&snapshot_device_available, -1, 0)) { + error = -EBUSY; + goto Unlock; + } /* Allocate memory management structures */ error = create_basic_memory_bitmaps(); @@ -294,7 +317,6 @@ int hibernate(void) if (error) goto Finish; - mutex_lock(&pm_mutex); if (hibernation_mode == HIBERNATION_TESTPROC) { printk("swsusp debug: Waiting for 5 seconds.\n"); mdelay(5000); @@ -316,12 +338,13 @@ int hibernate(void) swsusp_free(); } Thaw: - mutex_unlock(&pm_mutex); unprepare_processes(); Finish: free_basic_memory_bitmaps(); Exit: atomic_inc(&snapshot_device_available); + Unlock: + mutex_unlock(&pm_mutex); return error; } Index: linux-2.6.22-rc3/kernel/power/main.c =================================================================== --- linux-2.6.22-rc3.orig/kernel/power/main.c 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/kernel/power/main.c 2007-05-27 15:05:51.000000000 +0200 @@ -82,6 +82,10 @@ static int suspend_prepare(suspend_state if (!pm_ops || !pm_ops->enter) return -EPERM; + error = pm_notifier_call_chain(PM_PRE_FREEZE); + if (error) + return error; + pm_prepare_console(); if (freeze_processes()) { @@ -89,6 +93,10 @@ static int suspend_prepare(suspend_state goto Thaw; } + error = pm_notifier_call_chain(PM_SUSPEND_PREPARE); + if (error) + return error; + if ((free_pages = global_page_state(NR_FREE_PAGES)) < FREE_PAGE_NUMBER) { pr_debug("PM: free some memory\n"); @@ -121,9 +129,11 @@ static int suspend_prepare(suspend_state device_resume(); Resume_console: resume_console(); + pm_notifier_call_chain(PM_SUSPEND_FAILED); Thaw: thaw_processes(); pm_restore_console(); + pm_notifier_call_chain(PM_POST_THAW); return error; } @@ -173,8 +183,10 @@ static void suspend_finish(suspend_state pm_finish(state); device_resume(); resume_console(); + pm_notifier_call_chain(PM_POST_RESUME); thaw_processes(); pm_restore_console(); + pm_notifier_call_chain(PM_POST_THAW); } Index: linux-2.6.22-rc3/kernel/power/user.c =================================================================== --- linux-2.6.22-rc3.orig/kernel/power/user.c 2007-05-27 14:41:59.000000000 +0200 +++ linux-2.6.22-rc3/kernel/power/user.c 2007-05-27 15:53:03.000000000 +0200 @@ -149,9 +149,13 @@ static int snapshot_ioctl(struct inode * if (data->frozen) break; mutex_lock(&pm_mutex); - if (freeze_processes()) { - thaw_processes(); - error = -EBUSY; + error = pm_notifier_call_chain(PM_PRE_FREEZE); + if (!error) { + error = freeze_processes(); + if (error) { + thaw_processes(); + pm_notifier_call_chain(PM_POST_THAW); + } } mutex_unlock(&pm_mutex); if (!error) @@ -163,6 +167,7 @@ static int snapshot_ioctl(struct inode * break; mutex_lock(&pm_mutex); thaw_processes(); + pm_notifier_call_chain(PM_POST_THAW); mutex_unlock(&pm_mutex); data->frozen = 0; break; Index: linux-2.6.22-rc3/Documentation/power/notifiers.txt =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ linux-2.6.22-rc3/Documentation/power/notifiers.txt 2007-05-27 18:20:48.000000000 +0200 @@ -0,0 +1,76 @@ +Suspend notifiers + (C) 2007 Rafael J. Wysocki <rjw@xxxxxxx>, GPL + +There are some operations that device drivers may want to carry out in their +.suspend() routines, but shouldn't, because they can cause the hibernation or +suspend to fail. For example, a driver may want to allocate a substantial amount +of memory (like 50 MB) in .suspend(), but that shouldn't be done after the +swsusp's memory shrinker has run. + +Also, there may be some operations, that subsystems want to carry out before a +hibernation/suspend or after a restore/resume, requiring the system to be fully +functional, so the drivers' .suspend() and .resume() routines are not suitable +for this purpose. For example, device drivers may want to upload firmware to +their devices after a restore from a hibernation image, but they cannot do it by +calling request_firmware() from their .resume() routines (user land processes +are frozen at this point). The solution may be to load the firmware into +memory before processes are frozen and upload it from there in the .resume() +routine. Of course, a hibernation notifier may be used for this purpose. + +The subsystems that have such needs can register suspend notifiers that will be +called upon the following events by the suspend core: + +PM_PRE_FREEZE The system is going to hibernate or suspend, tasks will + be frozen immediately + +PM_POST_THAW Tasks have just been thawed after a resume or restore + from a hibernation image + +PM_HIBERNATION_PREPARE The system is preparing for hibernation. Tasks have + been frozen, memory is going to be freed and devices + are going to be suspended. + +PM_SNAPSHOT_FAILED The creation of hibernation image has failed. Tasks + will be thawed immediately. + +PM_POST_SNAPSHOT Hibernation image has been created and it is going to + be saved immediately. Device drivers' .resume() + callbacks have been executed. + +PM_RESTORE_PREPARE The system is preparing for the restoration from a + hibernation image. Tasks have been frozen, devices + are going to be prepared for the restore. + +PM_RESTORE_FAILED The restore operation has failed. Tasks will be thawed + immediately and the system boot will continue. + +PM_POST_RESTORE The system memory state has been restored from a + hibernation image. Device drivers' .resume() + callbacks have been executed, tasks will be thawed + immediately. + +PM_SUSPEND_PREPARE The system is preparing for a suspend. Tasks have been + frozen, devices are going to be suspended. + +PM_SUSPEND_FAILED The suspend transition failed. Tasks will be thawed + immediately. + +PM_POST_RESUME The system has resumed. Tasks will be thawed + immediately. + +It is generally assumed that whatever the notifiers do for PM_PRE_FREEZE, +should be undone for PM_POST_THAW. Moreover, what is done for +PM_HIBERNATION_PREPARE, should be undone for PM_SNAPSHOT_FAILED, +PM_POST_SNAPSHOT and PM_POST_RESTORE (eg. if memory is allocated for +PM_HIBERNATION_PREPARE, it should be freed for PM_SNAPSHOT_FAILED, +PM_POST_SNAPSHOT and PM_POST_RESTORE). Analogously, operations performed for +PM_RESTORE_PREPARE should be reversed for PM_RESTORE_FAILED and operations +performed for PM_SUSPEND_PREPARE should be reversed for PM_SUSPEND_FAILED and +PM_POST_RESUME. + +The hibernation and suspend notifiers are called with pm_mutex held. They are +defined in the usual way, but their last argument is meaningless (it is always +NULL). To register and/or unregister a suspend notifier use the functions +register_pm_notifier() and unregister_pm_notifier(), respectively, defined in +kernel/power/notifier.c . If you don't need to unregister the notifier, you can +also use the pm_notifier() macro defined in include/linux/suspend.h . _______________________________________________ linux-pm mailing list linux-pm@xxxxxxxxxxxxxxxxxxxxxxxxxx https://lists.linux-foundation.org/mailman/listinfo/linux-pm