Allow subsystems to avoid using sysdevs for defining "core" PM callbacks

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.

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

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.

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 11 lines

drivers/base/syscore.c new file +11 -0

+/**
+ * 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;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {

drivers/base/syscore.c line 67

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

drivers/base/syscore.c line 72

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 11 lines

drivers/base/syscore.c new file +11 -0

+/**
+ * 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;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {

drivers/base/syscore.c line 67

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

drivers/base/syscore.c line 72

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

drivers/base/syscore.c

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

drivers/base/syscore.c

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +16 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +16 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

Other than that, this looks great to me, thanks for doing this.

Do you want me to take it through my tree, or yours?

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

Other than that, this looks great to me, thanks for doing this.

Do you want me to take it through my tree, or yours?

Quoted 110 lines · Greg KH

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 8 lines

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

The code using them depends on CONFIG_PM_SLEEP and they are nobody else's business. :-)

I could avoid using the #ifdef here, but I thought I'd make it clear that these things were only available when CONFIG_PM_SLEEP was set.

Quoted 1 line

Other than that, this looks great to me, thanks for doing this.

No problem. :-)

Quoted 1 line

Do you want me to take it through my tree, or yours?

I can handle it if you give me an ack.

Do you think I should push [1/2] alone for 2.6.39 or wait for the patches converting subsystems to use this stuff to be ready? I think it'll take some time to prepare them, especialy for things in the ARM tree that use sysdevs in some interesting ways ...

Quoted 110 lines · Greg KH

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 8 lines

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

The code using them depends on CONFIG_PM_SLEEP and they are nobody else's business. :-)

I could avoid using the #ifdef here, but I thought I'd make it clear that these things were only available when CONFIG_PM_SLEEP was set.

Quoted 1 line

Other than that, this looks great to me, thanks for doing this.

No problem. :-)

Quoted 1 line

Do you want me to take it through my tree, or yours?

I can handle it if you give me an ack.

Do you think I should push [1/2] alone for 2.6.39 or wait for the patches converting subsystems to use this stuff to be ready? I think it'll take some time to prepare them, especialy for things in the ARM tree that use sysdevs in some interesting ways ...

Quoted 120 lines · Rafael J. Wysocki

Quoted 110 lines · Greg KH

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 8 lines

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

Quoted 2 lines

The code using them depends on CONFIG_PM_SLEEP and they are nobody else's business. :-)

Ah, ok.

Quoted 2 lines

I could avoid using the #ifdef here, but I thought I'd make it clear that these things were only available when CONFIG_PM_SLEEP was set.

That's fine.

Quoted 7 lines

Quoted 1 line

Other than that, this looks great to me, thanks for doing this.

No problem. :-)

Quoted 1 line

Do you want me to take it through my tree, or yours?

I can handle it if you give me an ack.

Acked-by Greg Kroah-Hartman <[email protected]>

Quoted 4 lines

Do you think I should push [1/2] alone for 2.6.39 or wait for the patches converting subsystems to use this stuff to be ready? I think it'll take some time to prepare them, especialy for things in the ARM tree that use sysdevs in some interesting ways ...

Send it for .39, and then start converting everyone over to using it. It's easier once the code is in place to handle the different trees, that way you don't have to worry about ordering issues.

Quoted 120 lines · Rafael J. Wysocki

Quoted 110 lines · Greg KH

Quoted 109 lines · Rafael J. Wysocki

Quoted 47 lines · Alan Stern

Quoted 11 lines · Rafael J. Wysocki

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.

...

drivers/base/syscore.c

Quoted 4 lines

Index: linux-2.6/drivers/base/syscore.c
===================================================================

drivers/base/syscore.c new file +0 -0

It's true that the existing sys.c file lies in drivers/base; this is presumably because it handles a bunch of class-related registration stuff. Now you're getting rid of all that, leaving just the power-related operations, so doesn't it make more sense to put this file in drivers/base/power?

Quoted 6 lines

drivers/base/syscore.c new file +6 -0

+/**
+ * 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)

drivers/base/syscore.c line 69

Quoted 10 lines

drivers/base/syscore.c new file +10 -0

+{
+	struct syscore_ops *ops;
+
+	list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+		if (ops->suspend) {
+			int ret = ops->suspend();
+			if (ret) {
+				pr_err("PM: System core suspend callback "
+					"%pF failed.\n", ops->suspend);
+				return ret;

If an error occurs, you need to go back and resume all the things that were suspended. At least, that's what the code in sysdev_suspend does.

Quoted 5 lines

drivers/base/syscore.c line 70

Quoted 5 lines

drivers/base/syscore.c new file +5 -0

+			}
+		}
+
+	return 0;
+}

Below is a new version of the patch. I've taken your comment on the failing suspend into account, fix the list traversal direction in syscore_shutdown() and added some debug statements.

Thanks,
Rafael

---
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.

---
 drivers/base/Makefile       |    2 
 drivers/base/syscore.c      |  107 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/syscore_ops.h |   29 +++++++++++
 kernel/power/hibernate.c    |    9 +++
 kernel/power/suspend.c      |    4 +
 kernel/sys.c                |    4 +
 6 files changed, 154 insertions(+), 1 deletion(-)

Index: linux-2.6/include/linux/syscore_ops.h
===================================================================

include/linux/syscore_ops.h new file +21 -0

@@ -0,0 +1,29 @@
+/*
+ *  syscore_ops.h - System core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, 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);

Quoted 8 lines

include/linux/syscore_ops.h line 26

Quoted 5 lines

include/linux/syscore_ops.h new file +5 -0

+extern void unregister_syscore_ops(struct syscore_ops *ops);
+#ifdef CONFIG_PM_SLEEP
+extern int syscore_suspend(void);
+extern void syscore_resume(void);
+#endif

Minor nit, provide inline functions for these when CONFIG_PM_SLEEP is not defined so the code still builds?

Quoted 2 lines

The code using them depends on CONFIG_PM_SLEEP and they are nobody else's business. :-)

Ah, ok.

Quoted 2 lines

I could avoid using the #ifdef here, but I thought I'd make it clear that these things were only available when CONFIG_PM_SLEEP was set.

That's fine.

Quoted 7 lines

Quoted 1 line

Other than that, this looks great to me, thanks for doing this.

No problem. :-)

Quoted 1 line

Do you want me to take it through my tree, or yours?

I can handle it if you give me an ack.

Acked-by Greg Kroah-Hartman <[email protected]>

Quoted 4 lines

Do you think I should push [1/2] alone for 2.6.39 or wait for the patches converting subsystems to use this stuff to be ready? I think it'll take some time to prepare them, especialy for things in the ARM tree that use sysdevs in some interesting ways ...

Send it for .39, and then start converting everyone over to using it. It's easier once the code is in place to handle the different trees, that way you don't have to worry about ordering issues.

Some subsystems need to carry out suspend/resume and shutdown operations with one CPU on-line and interrupts disabled and they define sysdev classes and sysdevs specifically for this purpose. This leads to unnecessarily complicated code and excessive memory usage, so switch them to using struct syscore_ops objects for this purpose instead.

Some subsystems need to carry out suspend/resume and shutdown operations with one CPU on-line and interrupts disabled and they define sysdev classes and sysdevs specifically for this purpose. This leads to unnecessarily complicated code and excessive memory usage, so switch them to using struct syscore_ops objects for this purpose instead.

Quoted 6 lines · Rafael J. Wysocki

Some subsystems need to carry out suspend/resume and shutdown operations with one CPU on-line and interrupts disabled and they define sysdev classes and sysdevs specifically for this purpose. This leads to unnecessarily complicated code and excessive memory usage, so switch them to using struct syscore_ops objects for this purpose instead.

Heavily-Acked-by Greg Kroah-Hartman <[email protected]>

:)

Do you want to resend this with a signed-off-by and your first one so I can apply it to my tree, or do you want to take it through yours?

thanks again for doing this.

Quoted 6 lines · Rafael J. Wysocki

Some subsystems need to carry out suspend/resume and shutdown operations with one CPU on-line and interrupts disabled and they define sysdev classes and sysdevs specifically for this purpose. This leads to unnecessarily complicated code and excessive memory usage, so switch them to using struct syscore_ops objects for this purpose instead.

Heavily-Acked-by Greg Kroah-Hartman <[email protected]>

:)

Do you want to resend this with a signed-off-by and your first one so I can apply it to my tree, or do you want to take it through yours?

thanks again for doing this.

I thought about two different possible ways forward:

(1) Push [1/2] and the patches converting things that x86 depends on first, followed perhaps by a patch introducing something like CONFIG_ARCH_NO_SYSDEV_OPS that would simply disable sysdev_{suspend|resume|shutdown}() (x86 would set it). The other arches might then be converted over time.

(2) Prepare patches converting everything that can be converted in the tree and push them all in one shot.

The advantage of (1) is that we can start making changes RSN and the advantage of (2) seems to be that we may avoid some potential suspend/resume ordering issues on non-x86 architectures that may arise in principle if some subsystems are converted to using struct syscore_ops while the others are not (syscore_suspend() is executed after sysdev_suspend(), so if we move something from the latter to the former, it may end up being executed after things that it was executed before previously).

Please let me know what your opinion is.

I thought about two different possible ways forward:

(1) Push [1/2] and the patches converting things that x86 depends on first, followed perhaps by a patch introducing something like CONFIG_ARCH_NO_SYSDEV_OPS that would simply disable sysdev_{suspend|resume|shutdown}() (x86 would set it). The other arches might then be converted over time.

(2) Prepare patches converting everything that can be converted in the tree and push them all in one shot.

The advantage of (1) is that we can start making changes RSN and the advantage of (2) seems to be that we may avoid some potential suspend/resume ordering issues on non-x86 architectures that may arise in principle if some subsystems are converted to using struct syscore_ops while the others are not (syscore_suspend() is executed after sysdev_suspend(), so if we move something from the latter to the former, it may end up being executed after things that it was executed before previously).

Please let me know what your opinion is.

Quoted 19 lines · Rafael J. Wysocki

I thought about two different possible ways forward:

(1) Push [1/2] and the patches converting things that x86 depends on first, followed perhaps by a patch introducing something like CONFIG_ARCH_NO_SYSDEV_OPS that would simply disable sysdev_{suspend|resume|shutdown}() (x86 would set it). The other arches might then be converted over time.

(2) Prepare patches converting everything that can be converted in the tree and push them all in one shot.

The advantage of (1) is that we can start making changes RSN and the advantage of (2) seems to be that we may avoid some potential suspend/resume ordering issues on non-x86 architectures that may arise in principle if some subsystems are converted to using struct syscore_ops while the others are not (syscore_suspend() is executed after sysdev_suspend(), so if we move something from the latter to the former, it may end up being executed after things that it was executed before previously).

Quoted 1 line

Please let me know what your opinion is.

Hm, I would prefer (1) as that lets us get this moving sooner, and "flag days" are never good to have. If there are problems that arise because of it, as you have noted, it will be simple just to convert the parts that were using the "old" methods to the new ones to fix the issue, right?

Quoted 19 lines · Rafael J. Wysocki

I thought about two different possible ways forward:

(1) Push [1/2] and the patches converting things that x86 depends on first, followed perhaps by a patch introducing something like CONFIG_ARCH_NO_SYSDEV_OPS that would simply disable sysdev_{suspend|resume|shutdown}() (x86 would set it). The other arches might then be converted over time.

(2) Prepare patches converting everything that can be converted in the tree and push them all in one shot.

The advantage of (1) is that we can start making changes RSN and the advantage of (2) seems to be that we may avoid some potential suspend/resume ordering issues on non-x86 architectures that may arise in principle if some subsystems are converted to using struct syscore_ops while the others are not (syscore_suspend() is executed after sysdev_suspend(), so if we move something from the latter to the former, it may end up being executed after things that it was executed before previously).

Quoted 1 line

Please let me know what your opinion is.

Hm, I would prefer (1) as that lets us get this moving sooner, and "flag days" are never good to have. If there are problems that arise because of it, as you have noted, it will be simple just to convert the parts that were using the "old" methods to the new ones to fix the issue, right?

There are multiple problems with sysdevs, or struct sys_device objects to be precise, that are so annoying that some people have started to think of removind them entirely from the kernel. To me, personally, the most obvious issue is the way sysdevs are used for defining suspend/resume callbacks to be executed with one CPU on-line and interrupts disabled. Greg and Kay may tell you more about the other problems with sysdevs. :-)

Some subsystems need to carry out certain operations during suspend after we've disabled non-boot CPUs and interrupts have been switched off on the only on-line one. Currently, the only way to achieve that is to define sysdev suspend/resume callbacks, but this is cumbersome and inefficient. Namely, to do that, one has to define a sysdev class providing the callbacks and a sysdev actually using them, which is excessively complicated. Moreover, the sysdev suspend/resume callbacks take arguments that are not really used by the majority of subsystems defining sysdev suspend/resume callbacks (or even if they are used, they don't really _need_ to be used, so they are simply unnecessary). Of course, if a sysdev is only defined to provide suspend/resume (and maybe shutdown) callbacks, there's no real reason why it should show up in sysfs.

For this reason, I thought it would be a good idea to provide a simpler interface for subsystems to define "very late" suspend callbacks and "very early" resume callbacks (and "very late" shutdown callbacks as well) without the entire bloat related to sysdevs. The interface is introduced by the first of the following patches, while the second patch converts some sysdev users related to the x86 architecture to using the new interface.

I believe that call sysdev users who need to define suspend/resume/shutdown callbacks may be converted to using the interface provided by the first patch, which in turn should allow us to convert the remaining sysdev functionality into "normal" struct device interfaces. Still, even if that turns out to be too complicated, the bloat reduction resulting from the second patch kind of shows that moving at least some sysdev users to a simpler interface (like in the first patch) is a good idea anyway.

There are multiple problems with sysdevs, or struct sys_device objects to be precise, that are so annoying that some people have started to think of removind them entirely from the kernel. To me, personally, the most obvious issue is the way sysdevs are used for defining suspend/resume callbacks to be executed with one CPU on-line and interrupts disabled. Greg and Kay may tell you more about the other problems with sysdevs. :-)

Some subsystems need to carry out certain operations during suspend after we've disabled non-boot CPUs and interrupts have been switched off on the only on-line one. Currently, the only way to achieve that is to define sysdev suspend/resume callbacks, but this is cumbersome and inefficient. Namely, to do that, one has to define a sysdev class providing the callbacks and a sysdev actually using them, which is excessively complicated. Moreover, the sysdev suspend/resume callbacks take arguments that are not really used by the majority of subsystems defining sysdev suspend/resume callbacks (or even if they are used, they don't really _need_ to be used, so they are simply unnecessary). Of course, if a sysdev is only defined to provide suspend/resume (and maybe shutdown) callbacks, there's no real reason why it should show up in sysfs.

For this reason, I thought it would be a good idea to provide a simpler interface for subsystems to define "very late" suspend callbacks and "very early" resume callbacks (and "very late" shutdown callbacks as well) without the entire bloat related to sysdevs. The interface is introduced by the first of the following patches, while the second patch converts some sysdev users related to the x86 architecture to using the new interface.

I believe that call sysdev users who need to define suspend/resume/shutdown callbacks may be converted to using the interface provided by the first patch, which in turn should allow us to convert the remaining sysdev functionality into "normal" struct device interfaces. Still, even if that turns out to be too complicated, the bloat reduction resulting from the second patch kind of shows that moving at least some sysdev users to a simpler interface (like in the first patch) is a good idea anyway.

Quoted 27 lines · Rafael J. Wysocki

There are multiple problems with sysdevs, or struct sys_device objects to be precise, that are so annoying that some people have started to think of removind them entirely from the kernel. To me, personally, the most obvious issue is the way sysdevs are used for defining suspend/resume callbacks to be executed with one CPU on-line and interrupts disabled. Greg and Kay may tell you more about the other problems with sysdevs. :-)

Some subsystems need to carry out certain operations during suspend after we've disabled non-boot CPUs and interrupts have been switched off on the only on-line one. Currently, the only way to achieve that is to define sysdev suspend/resume callbacks, but this is cumbersome and inefficient. Namely, to do that, one has to define a sysdev class providing the callbacks and a sysdev actually using them, which is excessively complicated. Moreover, the sysdev suspend/resume callbacks take arguments that are not really used by the majority of subsystems defining sysdev suspend/resume callbacks (or even if they are used, they don't really _need_ to be used, so they are simply unnecessary). Of course, if a sysdev is only defined to provide suspend/resume (and maybe shutdown) callbacks, there's no real reason why it should show up in sysfs.

For this reason, I thought it would be a good idea to provide a simpler interface for subsystems to define "very late" suspend callbacks and "very early" resume callbacks (and "very late" shutdown callbacks as well) without the entire bloat related to sysdevs. The interface is introduced by the first of the following patches, while the second patch converts some sysdev users related to the x86 architecture to using the new interface.

Quoted 7 lines

I believe that call sysdev users who need to define suspend/resume/shutdown callbacks may be converted to using the interface provided by the first patch, which in turn should allow us to convert the remaining sysdev functionality into "normal" struct device interfaces. Still, even if that turns out to be too complicated, the bloat reduction resulting from the second patch kind of shows that moving at least some sysdev users to a simpler interface (like in the first patch) is a good idea anyway.

Do I read that right? We get rid of the entire dance of creating sysdevs/sysdev_classes and the pointless and broken stuff in /sys?

We just dynamically maintain a list of devices/operations, which is list-executed when needed?

These new "core" operations are not included in every device but only global per subsystem, just like the sysdev_class did earlier?

Looks all like a nice plan to me.

Quoted 27 lines · Rafael J. Wysocki

There are multiple problems with sysdevs, or struct sys_device objects to be precise, that are so annoying that some people have started to think of removind them entirely from the kernel. To me, personally, the most obvious issue is the way sysdevs are used for defining suspend/resume callbacks to be executed with one CPU on-line and interrupts disabled. Greg and Kay may tell you more about the other problems with sysdevs. :-)

Some subsystems need to carry out certain operations during suspend after we've disabled non-boot CPUs and interrupts have been switched off on the only on-line one. Currently, the only way to achieve that is to define sysdev suspend/resume callbacks, but this is cumbersome and inefficient. Namely, to do that, one has to define a sysdev class providing the callbacks and a sysdev actually using them, which is excessively complicated. Moreover, the sysdev suspend/resume callbacks take arguments that are not really used by the majority of subsystems defining sysdev suspend/resume callbacks (or even if they are used, they don't really _need_ to be used, so they are simply unnecessary). Of course, if a sysdev is only defined to provide suspend/resume (and maybe shutdown) callbacks, there's no real reason why it should show up in sysfs.

For this reason, I thought it would be a good idea to provide a simpler interface for subsystems to define "very late" suspend callbacks and "very early" resume callbacks (and "very late" shutdown callbacks as well) without the entire bloat related to sysdevs. The interface is introduced by the first of the following patches, while the second patch converts some sysdev users related to the x86 architecture to using the new interface.

Quoted 7 lines

I believe that call sysdev users who need to define suspend/resume/shutdown callbacks may be converted to using the interface provided by the first patch, which in turn should allow us to convert the remaining sysdev functionality into "normal" struct device interfaces. Still, even if that turns out to be too complicated, the bloat reduction resulting from the second patch kind of shows that moving at least some sysdev users to a simpler interface (like in the first patch) is a good idea anyway.

Do I read that right? We get rid of the entire dance of creating sysdevs/sysdev_classes and the pointless and broken stuff in /sys?