[PATCH v8 03/27] kernel/reboot: Introduce sys-off handler API

[Dmitry Osipenko <dmitry.osipenko@xxxxxxxxxxxxx>]

In order to support power-off chaining we need to get rid of the global
pm_* variables, replacing them with the new kernel API functions that
support chaining.

Introduce new generic sys-off handler API that brings the following
features:

1. Power-off and restart handlers are registered using same API function
   that supports chaining, hence all power-off and restart modes will
   support chaining using this unified function.

2. Prevents notifier priority collisions by disallowing registration of
   multiple handlers at the non-default priority level.

3. Supports passing opaque user argument to callback, which allows us to
   remove global variables from drivers.

This patch adds support of the following sys-off modes:

- SYS_OFF_MODE_POWER_OFF_PREPARE that replaces global pm_power_off_prepare
  variable and provides chaining support for power-off-prepare handlers.

- SYS_OFF_MODE_POWER_OFF that replaces global pm_power_off variable and
  provides chaining support for power-off handlers.

- SYS_OFF_MODE_RESTART that provides a better restart API, removing a need
  from drivers to have a global scratch variable by utilizing the opaque
  callback argument.

Signed-off-by: Dmitry Osipenko <dmitry.osipenko@xxxxxxxxxxxxx>
---
 include/linux/reboot.h |  77 +++++++++++++++++
 kernel/reboot.c        | 182 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 259 insertions(+)

diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index a2429648d831..05981ef079d8 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -7,6 +7,7 @@
 #include <uapi/linux/reboot.h>
 
 struct device;
+struct sys_off_handler;
 
 #define SYS_DOWN       0x0001  /* Notify of system down */
 #define SYS_RESTART    SYS_DOWN
@@ -62,6 +63,82 @@ extern void machine_shutdown(void);
 struct pt_regs;
 extern void machine_crash_shutdown(struct pt_regs *);
 
+/*
+ * sys-off handler API.
+ */
+
+/*
+ * Standard sys-off priority levels. Users are expected to set priorities
+ * relative to the standard levels.
+ *
+ * SYS_OFF_PRIO_PLATFORM:      Use this for platform-level handlers.
+ *
+ * SYS_OFF_PRIO_LOW:           Use this for handler of last resort.
+ *
+ * SYS_OFF_PRIO_DEFAULT:       Use this for normal handlers.
+ *
+ * SYS_OFF_PRIO_HIGH:          Use this for higher priority handlers.
+ *
+ * SYS_OFF_PRIO_FIRMWARE:      Use this if handler uses firmware call.
+ */
+#define SYS_OFF_PRIO_PLATFORM          -256
+#define SYS_OFF_PRIO_LOW               -128
+#define SYS_OFF_PRIO_DEFAULT           0
+#define SYS_OFF_PRIO_HIGH              192
+#define SYS_OFF_PRIO_FIRMWARE          224
+
+enum sys_off_mode {
+       /**
+        * @SYS_OFF_MODE_POWER_OFF_PREPARE:
+        *
+        * Handlers prepare system to be powered off. Handlers are
+        * allowed to sleep.
+        */
+       SYS_OFF_MODE_POWER_OFF_PREPARE,
+
+       /**
+        * @SYS_OFF_MODE_POWER_OFF:
+        *
+        * Handlers power-off system. Handlers are disallowed to sleep.
+        */
+       SYS_OFF_MODE_POWER_OFF,
+
+       /**
+        * @SYS_OFF_MODE_RESTART:
+        *
+        * Handlers restart system. Handlers are disallowed to sleep.
+        */
+       SYS_OFF_MODE_RESTART,
+};
+
+/**
+ * struct sys_off_data - sys-off callback argument
+ *
+ * @mode: Mode ID. Currently used only by the sys-off restart mode,
+ *        see enum reboot_mode for the available modes.
+ * @cb_data: User's callback data.
+ * @cmd: Command string. Currently used only by the sys-off restart mode,
+ *       NULL otherwise.
+ */
+struct sys_off_data {
+       int mode;
+       void *cb_data;
+       const char *cmd;
+};
+
+struct sys_off_handler *
+register_sys_off_handler(enum sys_off_mode mode,
+                        int priority,
+                        int (*callback)(struct sys_off_data *data),
+                        void *cb_data);
+void unregister_sys_off_handler(struct sys_off_handler *handler);
+
+int devm_register_sys_off_handler(struct device *dev,
+                                 enum sys_off_mode mode,
+                                 int priority,
+                                 int (*callback)(struct sys_off_data *data),
+                                 void *cb_data);
+
 /*
  * Architecture independent implemenations of sys_reboot commands.
  */
diff --git a/kernel/reboot.c b/kernel/reboot.c
index 8ce30fa0a104..672a658f21ee 100644
--- a/kernel/reboot.c
+++ b/kernel/reboot.c
@@ -48,6 +48,15 @@ int reboot_cpu;
 enum reboot_type reboot_type = BOOT_ACPI;
 int reboot_force;
 
+struct sys_off_handler {
+       struct notifier_block nb;
+       int (*sys_off_cb)(struct sys_off_data *data);
+       void *cb_data;
+       enum sys_off_mode mode;
+       bool blocking;
+       void *list;
+};
+
 /*
  * If set, this is used for preparing the system to power off.
  */
@@ -281,6 +290,179 @@ void kernel_halt(void)
 }
 EXPORT_SYMBOL_GPL(kernel_halt);
 
+/*
+ *     Notifier list for kernel code which wants to be called
+ *     to prepare system for power off.
+ */
+static BLOCKING_NOTIFIER_HEAD(power_off_prep_handler_list);
+
+/*
+ *     Notifier list for kernel code which wants to be called
+ *     to power off system.
+ */
+static ATOMIC_NOTIFIER_HEAD(power_off_handler_list);
+
+static int sys_off_notify(struct notifier_block *nb,
+                         unsigned long mode, void *cmd)
+{
+       struct sys_off_handler *handler;
+       struct sys_off_data data = {};
+
+       handler = container_of(nb, struct sys_off_handler, nb);
+       data.cb_data = handler->cb_data;
+       data.mode = mode;
+       data.cmd = cmd;
+
+       return handler->sys_off_cb(&data);
+}
+
+/**
+ *     register_sys_off_handler - Register sys-off handler
+ *     @mode: Sys-off mode
+ *     @priority: Handler priority
+ *     @callback: Callback function
+ *     @cb_data: Callback argument
+ *
+ *     Registers system power-off or restart handler that will be invoked
+ *     at the step corresponding to the given sys-off mode. Handler's callback
+ *     should return NOTIFY_DONE to permit execution of the next handler in
+ *     the call chain or NOTIFY_STOP to break the chain (in error case for
+ *     example).
+ *
+ *     Multiple handlers can be registered at the default priority level.
+ *
+ *     Only one handler can be registered at the non-default priority level,
+ *     otherwise ERR_PTR(-EBUSY) is returned.
+ *
+ *     Returns a new instance of struct sys_off_handler on success, or
+ *     an ERR_PTR()-encoded error code otherwise.
+ */
+struct sys_off_handler *
+register_sys_off_handler(enum sys_off_mode mode,
+                        int priority,
+                        int (*callback)(struct sys_off_data *data),
+                        void *cb_data)
+{
+       struct sys_off_handler *handler;
+       int err;
+
+       handler = kzalloc(sizeof(*handler), GFP_KERNEL);
+       if (!handler)
+               return ERR_PTR(-ENOMEM);
+
+       switch (mode) {
+       case SYS_OFF_MODE_POWER_OFF_PREPARE:
+               handler->list = &power_off_prep_handler_list;
+               handler->blocking = true;
+               break;
+
+       case SYS_OFF_MODE_POWER_OFF:
+               handler->list = &power_off_handler_list;
+               break;
+
+       case SYS_OFF_MODE_RESTART:
+               handler->list = &restart_handler_list;
+               break;
+
+       default:
+               kfree(handler);
+               return ERR_PTR(-EINVAL);
+       }
+
+       handler->nb.notifier_call = sys_off_notify;
+       handler->nb.priority = priority;
+       handler->sys_off_cb = callback;
+       handler->cb_data = cb_data;
+       handler->mode = mode;
+
+       if (handler->blocking) {
+               if (priority == SYS_OFF_PRIO_DEFAULT)
+                       err = blocking_notifier_chain_register(handler->list,
+                                                              &handler->nb);
+               else
+                       err = 
blocking_notifier_chain_register_unique_prio(handler->list,
+                                                                          
&handler->nb);
+       } else {
+               if (priority == SYS_OFF_PRIO_DEFAULT)
+                       err = atomic_notifier_chain_register(handler->list,
+                                                            &handler->nb);
+               else
+                       err = 
atomic_notifier_chain_register_unique_prio(handler->list,
+                                                                        
&handler->nb);
+       }
+
+       if (err) {
+               kfree(handler);
+               return ERR_PTR(err);
+       }
+
+       return handler;
+}
+EXPORT_SYMBOL_GPL(register_sys_off_handler);
+
+/**
+ *     unregister_sys_off_handler - Unregister sys-off handler
+ *     @handler: Sys-off handler
+ *
+ *     Unregisters given sys-off handler.
+ */
+void unregister_sys_off_handler(struct sys_off_handler *handler)
+{
+       int err;
+
+       if (!handler)
+               return;
+
+       if (handler->blocking)
+               err = blocking_notifier_chain_unregister(handler->list,
+                                                        &handler->nb);
+       else
+               err = atomic_notifier_chain_unregister(handler->list,
+                                                      &handler->nb);
+
+       /* sanity check, shall never happen */
+       WARN_ON(err);
+
+       kfree(handler);
+}
+EXPORT_SYMBOL_GPL(unregister_sys_off_handler);
+
+static void devm_unregister_sys_off_handler(void *data)
+{
+       struct sys_off_handler *handler = data;
+
+       unregister_sys_off_handler(handler);
+}
+
+/**
+ *     devm_register_sys_off_handler - Register sys-off handler
+ *     @dev: Device that registers handler
+ *     @mode: Sys-off mode
+ *     @priority: Handler priority
+ *     @callback: Callback function
+ *     @cb_data: Callback argument
+ *
+ *     Registers resource-managed sys-off handler.
+ *
+ *     Returns zero on success, or error code on failure.
+ */
+int devm_register_sys_off_handler(struct device *dev,
+                                 enum sys_off_mode mode,
+                                 int priority,
+                                 int (*callback)(struct sys_off_data *data),
+                                 void *cb_data)
+{
+       struct sys_off_handler *handler;
+
+       handler = register_sys_off_handler(mode, priority, callback, cb_data);
+       if (IS_ERR(handler))
+               return PTR_ERR(handler);
+
+       return devm_add_action_or_reset(dev, devm_unregister_sys_off_handler,
+                                       handler);
+}
+EXPORT_SYMBOL_GPL(devm_register_sys_off_handler);
+
 /**
  *     kernel_power_off - power_off the system
  *
-- 
2.35.1