PM / Core: Introduce struct syscore_ops for core subsystems PM

Some subsystems need to carry out suspend/resume and shutdown
operations with one CPU on-line and interrupts disabled.  The only
way to register such operations is to define a sysdev class and
a sysdev specifically for this purpose which is cumbersome and
inefficient.  Moreover, the arguments taken by sysdev suspend,
resume and shutdown callbacks are practically never necessary.

For this reason, introduce a simpler interface allowing subsystems
to register operations to be executed very late during system suspend
and shutdown and very early during resume in the form of
strcut syscore_ops objects.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 5f51c3b4451e2a3c39fcefbc1c5c0a97e810d78b..4c5701c15f53a1d4ed4c5d55ada286d57d3b85b7 100644 (file)
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -1,6 +1,6 @@
 # Makefile for the Linux device tree
 
-obj-y                  := core.o sys.o bus.o dd.o \
+obj-y                  := core.o sys.o bus.o dd.o syscore.o \
                           driver.o class.o platform.o \
                           cpu.o firmware.o init.o map.o devres.o \
                           attribute_container.o transport_class.o

diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c
new file mode 100644 (file)
index 0000000..90af294
--- /dev/null
+++ b/drivers/base/syscore.c
@@ -0,0 +1,117 @@
+/*
+ *  syscore.c - Execution of system core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ *  This file is released under the GPLv2.
+ */
+
+#include <linux/syscore_ops.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+
+static LIST_HEAD(syscore_ops_list);
+static DEFINE_MUTEX(syscore_ops_lock);
+
+/**
+ * register_syscore_ops - Register a set of system core operations.
+ * @ops: System core operations to register.
+ */
+void register_syscore_ops(struct syscore_ops *ops)
+{
+       mutex_lock(&syscore_ops_lock);
+       list_add_tail(&ops->node, &syscore_ops_list);
+       mutex_unlock(&syscore_ops_lock);
+}
+EXPORT_SYMBOL_GPL(register_syscore_ops);
+
+/**
+ * unregister_syscore_ops - Unregister a set of system core operations.
+ * @ops: System core operations to unregister.
+ */
+void unregister_syscore_ops(struct syscore_ops *ops)
+{
+       mutex_lock(&syscore_ops_lock);
+       list_del(&ops->node);
+       mutex_unlock(&syscore_ops_lock);
+}
+EXPORT_SYMBOL_GPL(unregister_syscore_ops);
+
+#ifdef CONFIG_PM_SLEEP
+/**
+ * syscore_suspend - Execute all the registered system core suspend callbacks.
+ *
+ * This function is executed with one CPU on-line and disabled interrupts.
+ */
+int syscore_suspend(void)
+{
+       struct syscore_ops *ops;
+       int ret = 0;
+
+       WARN_ONCE(!irqs_disabled(),
+               "Interrupts enabled before system core suspend.\n");
+
+       list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+               if (ops->suspend) {
+                       if (initcall_debug)
+                               pr_info("PM: Calling %pF\n", ops->suspend);
+                       ret = ops->suspend();
+                       if (ret)
+                               goto err_out;
+                       WARN_ONCE(!irqs_disabled(),
+                               "Interrupts enabled after %pF\n", ops->suspend);
+               }
+
+       return 0;
+
+ err_out:
+       pr_err("PM: System core suspend callback %pF failed.\n", ops->suspend);
+
+       list_for_each_entry_continue(ops, &syscore_ops_list, node)
+               if (ops->resume)
+                       ops->resume();
+
+       return ret;
+}
+
+/**
+ * syscore_resume - Execute all the registered system core resume callbacks.
+ *
+ * This function is executed with one CPU on-line and disabled interrupts.
+ */
+void syscore_resume(void)
+{
+       struct syscore_ops *ops;
+
+       WARN_ONCE(!irqs_disabled(),
+               "Interrupts enabled before system core resume.\n");
+
+       list_for_each_entry(ops, &syscore_ops_list, node)
+               if (ops->resume) {
+                       if (initcall_debug)
+                               pr_info("PM: Calling %pF\n", ops->resume);
+                       ops->resume();
+                       WARN_ONCE(!irqs_disabled(),
+                               "Interrupts enabled after %pF\n", ops->resume);
+               }
+}
+#endif /* CONFIG_PM_SLEEP */
+
+/**
+ * syscore_shutdown - Execute all the registered system core shutdown callbacks.
+ */
+void syscore_shutdown(void)
+{
+       struct syscore_ops *ops;
+
+       mutex_lock(&syscore_ops_lock);
+
+       list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+               if (ops->shutdown) {
+                       if (initcall_debug)
+                               pr_info("PM: Calling %pF\n", ops->shutdown);
+                       ops->shutdown();
+               }
+
+       mutex_unlock(&syscore_ops_lock);
+}

diff --git a/include/linux/syscore_ops.h b/include/linux/syscore_ops.h
new file mode 100644 (file)
index 0000000..27b3b0b
--- /dev/null
+++ b/include/linux/syscore_ops.h
@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ *  This file is released under the GPLv2.
+ */
+
+#ifndef _LINUX_SYSCORE_OPS_H
+#define _LINUX_SYSCORE_OPS_H
+
+#include <linux/list.h>
+
+struct syscore_ops {
+       struct list_head node;
+       int (*suspend)(void);
+       void (*resume)(void);
+       void (*shutdown)(void);
+};
+
+extern void register_syscore_ops(struct syscore_ops *ops);
+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif
+extern void syscore_shutdown(void);
+
+#endif

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 1832bd2642192970f2fe9e1b759b737e9519b1cf..aeabd26e3342788e4330cfb4e8e2a5ba40b348d0 100644 (file)
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -23,6 +23,7 @@
 #include <linux/cpu.h>
 #include <linux/freezer.h>
 #include <linux/gfp.h>
+#include <linux/syscore_ops.h>
 #include <scsi/scsi_scan.h>
 #include <asm/suspend.h>
 
@@ -272,6 +273,8 @@ static int create_image(int platform_mode)
        local_irq_disable();
 
        error = sysdev_suspend(PMSG_FREEZE);
+       if (!error)
+               error = syscore_suspend();
        if (error) {
                printk(KERN_ERR "PM: Some system devices failed to power down, "
                        "aborting hibernation\n");
@@ -295,6 +298,7 @@ static int create_image(int platform_mode)
        }
 
  Power_up:
+       syscore_resume();
        sysdev_resume();
        /* NOTE:  dpm_resume_noirq() is just a resume() for devices
         * that suspended with irqs off ... no overall powerup.
@@ -403,6 +407,8 @@ static int resume_target_kernel(bool platform_mode)
        local_irq_disable();
 
        error = sysdev_suspend(PMSG_QUIESCE);
+       if (!error)
+               error = syscore_suspend();
        if (error)
                goto Enable_irqs;
 
@@ -429,6 +435,7 @@ static int resume_target_kernel(bool platform_mode)
        restore_processor_state();
        touch_softlockup_watchdog();
 
+       syscore_resume();
        sysdev_resume();
 
  Enable_irqs:
@@ -516,6 +523,7 @@ int hibernation_platform_enter(void)
 
        local_irq_disable();
        sysdev_suspend(PMSG_HIBERNATE);
+       syscore_suspend();
        if (pm_wakeup_pending()) {
                error = -EAGAIN;
                goto Power_up;
@@ -526,6 +534,7 @@ int hibernation_platform_enter(void)
        while (1);
 
  Power_up:
+       syscore_resume();
        sysdev_resume();
        local_irq_enable();
        enable_nonboot_cpus();

diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index de6f86bfa30389e965f857cdd28b8ff03aeda32e..2814c32aed51c121a7ff9689aa38f6b98d025b15 100644 (file)
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -22,6 +22,7 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/suspend.h>
+#include <linux/syscore_ops.h>
 #include <trace/events/power.h>
 
 #include "power.h"
@@ -163,11 +164,14 @@ static int suspend_enter(suspend_state_t state)
        BUG_ON(!irqs_disabled());
 
        error = sysdev_suspend(PMSG_SUSPEND);
+       if (!error)
+               error = syscore_suspend();
        if (!error) {
                if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) {
                        error = suspend_ops->enter(state);
                        events_check_enabled = false;
                }
+               syscore_resume();
                sysdev_resume();
        }
 

diff --git a/kernel/sys.c b/kernel/sys.c
index 18da702ec813c491c758b6f28e86a31a71ba60b5..1ad48b3b9068ff7454d753c7e36e844ab507afd8 100644 (file)
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -37,6 +37,7 @@
 #include <linux/ptrace.h>
 #include <linux/fs_struct.h>
 #include <linux/gfp.h>
+#include <linux/syscore_ops.h>
 
 #include <linux/compat.h>
 #include <linux/syscalls.h>
@@ -298,6 +299,7 @@ void kernel_restart_prepare(char *cmd)
        system_state = SYSTEM_RESTART;
        device_shutdown();
        sysdev_shutdown();
+       syscore_shutdown();
 }
 
 /**
@@ -336,6 +338,7 @@ void kernel_halt(void)
 {
        kernel_shutdown_prepare(SYSTEM_HALT);
        sysdev_shutdown();
+       syscore_shutdown();
        printk(KERN_EMERG "System halted.\n");
        kmsg_dump(KMSG_DUMP_HALT);
        machine_halt();
@@ -355,6 +358,7 @@ void kernel_power_off(void)
                pm_power_off_prepare();
        disable_nonboot_cpus();
        sysdev_shutdown();
+       syscore_shutdown();
        printk(KERN_EMERG "Power down.\n");
        kmsg_dump(KMSG_DUMP_POWEROFF);
        machine_power_off();