Skip to contentSkip to conversation

Suspend block api

RFC PATCH In review Arve Hjønnevåg 5 participants 32 messages Apr 15, 2009 – May 5, 2009

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover Suspend block api

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api from my last patch series, Android PM extensions (version 3). As requested, wake_lock has been renamed to suspend_block(er), and timeout support has been separated into its own patch.

--
Arve Hjønnevåg

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#1 lore raw

PATCH 1/8 PM: Add suspend block api.

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

---
 Documentation/power/suspend-blockers.txt |   76 +++++++++
 include/linux/suspend_block.h            |   61 +++++++
 kernel/power/Kconfig                     |   10 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/main.c                      |   62 +++++++
 kernel/power/power.h                     |    6 +
 kernel/power/suspend_block.c             |  257 ++++++++++++++++++++++++++++++
 7 files changed, 473 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/suspend-blockers.txt
 create mode 100755 include/linux/suspend_block.h
 create mode 100644 kernel/power/suspend_block.c
Documentation/power/suspend-blockers.txt new file +76 -0
new file mode 100644
index 0000000..743b870
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.
+
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend from a sysdev suspend handler you must also return an error from
+that handler to abort suspend.
+
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on. Use set_irq_wake or a platform
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+	struct suspend_blocker suspend_blocker;
+}
+
+init() {
+	suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+
+uninit() {
+	suspend_blocker_destroy(&state->suspend_blocker);
+}
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+	suspend_block(&state->suspend_blocker);
+
+When it no longer needs to run it calls suspend_unblock:
+	suspend_unblock(&state->suspend_blocker);
+
+Calling suspend_block when the suspend blocker is active or suspend_unblock when
+it is not active has no effect. This allows drivers to update their state and
+call suspend suspend_block or suspend_unblock based on the result.
+For instance:
+
+if (list_empty(&state->pending_work))
+	suspend_unblock(&state->suspend_blocker);
+else
+	suspend_block(&state->suspend_blocker);
+
include/linux/suspend_block.h new file +61 -0

61 lines not on this page · raw message

kernel/power/Kconfig +10 -0
index 23bd4da..9d1df13 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
 	  Turning OFF this setting is NOT recommended! If in doubt, say Y.
 
+config SUSPEND_BLOCK
+	bool "Suspend block"
+	depends on PM
+	select RTC_LIB
+	default n
+	---help---
+	  Enable suspend_block. When user space requests a sleep state through
+	  /sys/power/request_state, the requested sleep state will be entered
+	  when no suspend_blockers are active.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 720ea4f..29cdc9e 100644
@@ -6,6 +6,7 @@ endif
 obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
+obj-$(CONFIG_SUSPEND_BLOCK)	+= suspend_block.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/main.c +62 -0

86 lines not on this page · raw message

kernel/power/power.h +6 -0
index 46b5ec7..2414a74 100644
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
 {
 }
 #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif
+
kernel/power/suspend_block.c new file +257 -0

257 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#2 lore raw

PATCH 2/8 PM: suspend_block: Add driver to access suspend blockers from user-space

Adds ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

---
 Documentation/power/suspend-blockers.txt |   17 ++++
 include/linux/suspend_block_dev.h        |   25 ++++++
 kernel/power/Kconfig                     |    9 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/user_suspend_block.c        |  125 ++++++++++++++++++++++++++++++
 5 files changed, 177 insertions(+), 0 deletions(-)
 create mode 100644 include/linux/suspend_block_dev.h
 create mode 100644 kernel/power/user_suspend_block.c
Documentation/power/suspend-blockers.txt +17 -0
index 743b870..35bc713 100644
@@ -74,3 +74,20 @@ if (list_empty(&state->pending_work))
 else
 	suspend_block(&state->suspend_blocker);
 
+User-space API
+==============
+
+To create a suspend_blocker from user-space, open the suspend_blocker device:
+    fd = open("/dev/suspend_blocker", O_RDWR | O_CLOEXEC);
+then call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_INIT(strlen(name)), name);
+
+To activate a suspend_blocker call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK);
+
+To unblock call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK);
+
+To destroy the suspend_blocker, close the device:
+    close(fd);
+
include/linux/suspend_block_dev.h new file +25 -0
new file mode 100644
index 0000000..a7c0bf9
@@ -0,0 +1,25 @@
+/* include/linux/suspend_block_dev.h
+ *
+ * Copyright (C) 2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_DEV_H
+#define _LINUX_SUSPEND_BLOCK_DEV_H
+
+#include <linux/ioctl.h>
+
+#define SUSPEND_BLOCKER_IOCTL_INIT(len)		_IOC(_IOC_WRITE, 's', 0, len)
+#define SUSPEND_BLOCKER_IOCTL_BLOCK		_IO('s', 1)
+#define SUSPEND_BLOCKER_IOCTL_UNBLOCK		_IO('s', 3)
+
+#endif
kernel/power/Kconfig +9 -0
index 9d1df13..2cf4c4d 100644
@@ -126,6 +126,15 @@ config SUSPEND_BLOCK
 	  /sys/power/request_state, the requested sleep state will be entered
 	  when no suspend_blockers are active.
 
+config USER_SUSPEND_BLOCK
+	bool "Userspace suspend blockers"
+	depends on SUSPEND_BLOCK
+	default y
+	---help---
+	  User-space suspend block api. Creates a misc device with ioctls
+	  to create, block and unblock a suspend_blocker. The suspend_blocker
+	  will be deleted when the device is closed.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 29cdc9e..5c524f1 100644
@@ -7,6 +7,7 @@ obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
 obj-$(CONFIG_SUSPEND_BLOCK)	+= suspend_block.o
+obj-$(CONFIG_USER_SUSPEND_BLOCK)	+= user_suspend_block.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/user_suspend_block.c new file +125 -0

125 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#3 lore raw

PATCH 3/8 PM: suspend_block: Abort task freezing if a suspend_blocker is active.

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting as soon as someone blocks suspend (e.g. from an interrupt handler) improves the worst case wakeup latency.

On an older kernel where task freezing could fail for processes attached to a debugger, this fixed a problem where the device sometimes hung for 20 seconds before the screen turned on.

---
 kernel/power/process.c |   23 ++++++++++++++++++-----
 1 files changed, 18 insertions(+), 5 deletions(-)
kernel/power/process.c +18 -5
index ca63401..76d7cdb 100644
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/freezer.h>
+#include <linux/suspend_block.h>
 
 /* 
  * Timeout for stopping processes
@@ -36,6 +37,7 @@ static int try_to_freeze_tasks(bool sig_only)
 	struct timeval start, end;
 	u64 elapsed_csecs64;
 	unsigned int elapsed_csecs;
+	unsigned int wakeup = 0;
 
 	do_gettimeofday(&start);
 
@@ -62,6 +64,10 @@ static int try_to_freeze_tasks(bool sig_only)
 		} while_each_thread(g, p);
 		read_unlock(&tasklist_lock);
 		yield();			/* Yield is okay here */
+		if (todo && suspend_is_blocked()) {
+			wakeup = 1;
+			break;
+		}
 		if (time_after(jiffies, end_time))
 			break;
 	} while (todo);
@@ -77,11 +83,18 @@ static int try_to_freeze_tasks(bool sig_only)
 		 * and caller must call thaw_processes() if something fails),
 		 * but it cleans up leftover PF_FREEZE requests.
 		 */
-		printk("\n");
-		printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
-				"(%d tasks refusing to freeze):\n",
-				elapsed_csecs / 100, elapsed_csecs % 100, todo);
-		show_state();
+		if (wakeup) {
+			printk("\n");
+			printk(KERN_ERR "Freezing of %s aborted\n",
+					sig_only ? "user space " : "tasks ");
+		} else {
+			printk("\n");
+			printk(KERN_ERR
+			       "Freezing of tasks failed after %d.%02d seconds "
+			       "(%d tasks refusing to freeze):\n",
+			       elapsed_csecs / 100, elapsed_csecs % 100, todo);
+			show_state();
+		}
 		read_lock(&tasklist_lock);
 		do_each_thread(g, p) {
 			task_lock(p);
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#4 lore raw

PATCH 4/8 Input: Block suspend while event queue is not empty.

Add an ioctl, EVIOCSSUSPENDBLOCK, to enables a suspend_blocker that will block suspend while the event queue is not empty. This allows userspace code to process input events while the device appears to be asleep.

---
 drivers/input/evdev.c |   21 +++++++++++++++++++++
 include/linux/input.h |    3 +++
 2 files changed, 24 insertions(+), 0 deletions(-)
drivers/input/evdev.c +21 -0
index ed8baa0..3a61425 100644
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/major.h>
 #include <linux/device.h>
+#include <linux/suspend_block.h>
 #include "input-compat.h"
 
 struct evdev {
@@ -43,6 +44,8 @@ struct evdev_client {
 	struct fasync_struct *fasync;
 	struct evdev *evdev;
 	struct list_head node;
+	int use_suspend_blocker;
+	struct suspend_blocker suspend_blocker;
 };
 
 static struct evdev *evdev_table[EVDEV_MINORS];
@@ -55,6 +58,8 @@ static void evdev_pass_event(struct evdev_client *client,
 	 * Interrupts are disabled, just acquire the lock
 	 */
 	spin_lock(&client->buffer_lock);
+	if (client->use_suspend_blocker)
+		suspend_block(&client->suspend_blocker);
 	client->buffer[client->head++] = *event;
 	client->head &= EVDEV_BUFFER_SIZE - 1;
 	spin_unlock(&client->buffer_lock);
@@ -236,6 +241,8 @@ static int evdev_release(struct inode *inode, struct file *file)
 	mutex_unlock(&evdev->mutex);
 
 	evdev_detach_client(evdev, client);
+	if (client->use_suspend_blocker)
+		suspend_blocker_destroy(&client->suspend_blocker);
 	kfree(client);
 
 	evdev_close_device(evdev);
@@ -335,6 +342,8 @@ static int evdev_fetch_next_event(struct evdev_client *client,
 	if (have_event) {
 		*event = client->buffer[client->tail++];
 		client->tail &= EVDEV_BUFFER_SIZE - 1;
+		if (client->use_suspend_blocker && client->head == client->tail)
+			suspend_unblock(&client->suspend_blocker);
 	}
 
 	spin_unlock_irq(&client->buffer_lock);
@@ -585,6 +594,18 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 		else
 			return evdev_ungrab(evdev, client);
 
+	case EVIOCGSUSPENDBLOCK:
+		return put_user(EV_VERSION, ip);
+
+	case EVIOCSSUSPENDBLOCK:
+		spin_lock_irq(&client->buffer_lock);
+		if ((client->use_suspend_blocker = !!p))
+			suspend_blocker_init(&client->suspend_blocker, "evdev");
+		else
+			suspend_blocker_destroy(&client->suspend_blocker);
+		spin_unlock_irq(&client->buffer_lock);
+		return 0;
+
 	default:
 
 		if (_IOC_TYPE(cmd) != 'E')
include/linux/input.h +3 -0
index 1249a0c..67e2332 100644
@@ -81,6 +81,9 @@ struct input_absinfo {
 
 #define EVIOCGRAB		_IOW('E', 0x90, int)			/* Grab/Release device */
 
+#define EVIOCGSUSPENDBLOCK	_IOR('E', 0x91, int)			/* get suspend block enable */
+#define EVIOCSSUSPENDBLOCK	_IOW('E', 0x91, int)			/* set suspend block enable */
+
 /*
  * Event types
  */
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#5 lore raw

PATCH 5/8 PM: suspend_block: Switch to list of active and inactive suspend blockers

This allows active suspend blockers to be listed

---
 include/linux/suspend_block.h |    5 ++-
 kernel/power/suspend_block.c  |   77 ++++++++++++++++++++++++++++------------
 2 files changed, 58 insertions(+), 24 deletions(-)
include/linux/suspend_block.h +4 -1
index 7820c60..73ac5f7 100755
@@ -16,12 +16,15 @@
 #ifndef _LINUX_SUSPEND_BLOCK_H
 #define _LINUX_SUSPEND_BLOCK_H
 
+#include <linux/list.h>
+
 /* A suspend_blocker prevents the system from entering suspend when active.
  */
 
 struct suspend_blocker {
 #ifdef CONFIG_SUSPEND_BLOCK
-	atomic_t            flags;
+	struct list_head    link;
+	int                 flags;
 	const char         *name;
 #endif
 };
kernel/power/suspend_block.c +54 -23

150 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#6 lore raw

PATCH 6/8 PM: suspend_block: Add suspend_blocker stats

Report suspend block stats in /proc/suspend_blockers.

---
 include/linux/suspend_block.h |   11 +++
 kernel/power/Kconfig          |    7 ++
 kernel/power/suspend_block.c  |  201 ++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 217 insertions(+), 2 deletions(-)
include/linux/suspend_block.h +11 -0
index 73ac5f7..31225c5 100755
@@ -17,6 +17,7 @@
 #define _LINUX_SUSPEND_BLOCK_H
 
 #include <linux/list.h>
+#include <linux/ktime.h>
 
 /* A suspend_blocker prevents the system from entering suspend when active.
  */
@@ -26,6 +27,16 @@ struct suspend_blocker {
 	struct list_head    link;
 	int                 flags;
 	const char         *name;
+#ifdef CONFIG_SUSPEND_BLOCK_STAT
+	struct {
+		int             count;
+		int             wakeup_count;
+		ktime_t         total_time;
+		ktime_t         prevent_suspend_time;
+		ktime_t         max_time;
+		ktime_t         last_time;
+	} stat;
+#endif
 #endif
 };
 
kernel/power/Kconfig +7 -0
index 2cf4c4d..3de0c5f 100644
@@ -126,6 +126,13 @@ config SUSPEND_BLOCK
 	  /sys/power/request_state, the requested sleep state will be entered
 	  when no suspend_blockers are active.
 
+config SUSPEND_BLOCK_STAT
+	bool "Suspend block stats"
+	depends on SUSPEND_BLOCK
+	default y
+	---help---
+	  Report suspend block stats in /proc/suspend_blockers
+
 config USER_SUSPEND_BLOCK
 	bool "Userspace suspend blockers"
 	depends on SUSPEND_BLOCK
kernel/power/suspend_block.c +199 -2

303 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#7 lore raw

PATCH 7/8 PM: suspend_block: Add timeout support.

Add suspend_block_timeout to block suspend for a limited time.

---
 Documentation/power/suspend-blockers.txt |   10 ++
 include/linux/suspend_block.h            |    7 +
 kernel/power/suspend_block.c             |  232 +++++++++++++++++++++++++-----
 3 files changed, 216 insertions(+), 33 deletions(-)
Documentation/power/suspend-blockers.txt +10 -0
index 35bc713..2781e05 100644
@@ -74,6 +74,16 @@ if (list_empty(&state->pending_work))
 else
 	suspend_block(&state->suspend_blocker);
 
+A driver can also call suspend_block_timeout to release the suspend_blocker
+after a delay:
+	suspend_block_timeout(&state->suspend_blocker, HZ);
+
+This works whether the suspend_blocker is already active or not. It is useful if
+the driver woke up other parts of the system that do not use suspend_blockers
+but still need to run. Avoid this when possible, since it will waste power
+if the timeout is long or may fail to finish needed work if the timeout is
+short. Calling suspend_block or suspend_unblock will cancel the timeout.
+
 User-space API
 ==============
 
include/linux/suspend_block.h +7 -0
index 31225c5..9cea772 100755
@@ -27,9 +27,11 @@ struct suspend_blocker {
 	struct list_head    link;
 	int                 flags;
 	const char         *name;
+	unsigned long       expires;
 #ifdef CONFIG_SUSPEND_BLOCK_STAT
 	struct {
 		int             count;
+		int             expire_count;
 		int             wakeup_count;
 		ktime_t         total_time;
 		ktime_t         prevent_suspend_time;
@@ -45,9 +47,13 @@ struct suspend_blocker {
 void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
 void suspend_blocker_destroy(struct suspend_blocker *blocker);
 void suspend_block(struct suspend_blocker *blocker);
+void suspend_block_timeout(struct suspend_blocker *blocker, long timeout);
 void suspend_unblock(struct suspend_blocker *blocker);
 
 /* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ * If the suspend_blocker has a timeout, it does not check the timeout, but if
+ * the timeout had already expired when it was checked elsewhere this function
+ * will return false.
  */
 bool is_blocking_suspend(struct suspend_blocker *blocker);
 
@@ -65,6 +71,7 @@ static inline void suspend_blocker_init(struct suspend_blocker *blocker,
 					const char *name) {}
 static inline void suspend_blocker_destroy(struct suspend_blocker *blocker) {}
 static inline void suspend_block(struct suspend_blocker *blocker) {}
+static inline void suspend_block_timeout(struct suspend_blocker *bl, long t) {}
 static inline void suspend_unblock(struct suspend_blocker *blocker) {}
 static inline bool is_blocking_suspend(struct suspend_blocker *bl) { return 0; }
 static inline bool suspend_is_blocked(void) { return 0; }
kernel/power/suspend_block.c +199 -33

389 lines not on this page · raw message

Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#8 lore raw

PATCH 8/8 PM: suspend_block: Add timeout support to user-space suspend_blockers

This also allows a grace period to be set where suspend is blocked for a while if a user-space suspend_blocker is destroyed while it was active.

---
 Documentation/power/suspend-blockers.txt |    7 +++++++
 include/linux/suspend_block_dev.h        |    1 +
 kernel/power/user_suspend_block.c        |   22 ++++++++++++++++++++++
 3 files changed, 30 insertions(+), 0 deletions(-)
Documentation/power/suspend-blockers.txt +7 -0
index 2781e05..890f057 100644
@@ -94,6 +94,8 @@ then call:
 
 To activate a suspend_blocker call:
     ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK);
+or
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT, &timespec_timeout);
 
 To unblock call:
     ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK);
@@ -101,3 +103,8 @@ To unblock call:
 To destroy the suspend_blocker, close the device:
     close(fd);
 
+A module parameter, unclean_exit_grace_period, can be set to allow servers
+some time to restart if they crash with an active suspend_blocker. If the
+process dies or the device is closed while the suspend_blocker is active, a
+suspend_blocker will be held for the number of seconds specified.
+
include/linux/suspend_block_dev.h +1 -0
index a7c0bf9..cff4943 100644
@@ -20,6 +20,7 @@
 
 #define SUSPEND_BLOCKER_IOCTL_INIT(len)		_IOC(_IOC_WRITE, 's', 0, len)
 #define SUSPEND_BLOCKER_IOCTL_BLOCK		_IO('s', 1)
+#define SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT	_IOW('s', 2, struct timespec)
 #define SUSPEND_BLOCKER_IOCTL_UNBLOCK		_IO('s', 3)
 
 #endif
kernel/power/user_suspend_block.c +22 -0
index 782407c..1ba07dd 100644
@@ -26,7 +26,12 @@ enum {
 static int debug_mask = DEBUG_FAILURE;
 module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
 
+static int unclean_exit_grace_period;
+module_param_named(unclean_exit_grace_period, unclean_exit_grace_period, int,
+						S_IRUGO | S_IWUSR | S_IWGRP);
+
 static DEFINE_MUTEX(ioctl_lock);
+static struct suspend_blocker unclean_exit_suspend_blocker;
 
 struct user_suspend_blocker {
 	struct suspend_blocker	blocker;
@@ -58,6 +63,8 @@ static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
 {
 	void __user *arg = (void __user *)_arg;
 	struct user_suspend_blocker *bl;
+	struct timespec ts;
+	unsigned long timeout;
 	long ret;
 
 	mutex_lock(&ioctl_lock);
@@ -75,6 +82,15 @@ static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
 		suspend_block(&bl->blocker);
 		ret = 0;
 		break;
+	case SUSPEND_BLOCKER_IOCTL_BLOCK_TIMEOUT:
+		if (copy_from_user(&ts, arg, sizeof(ts))) {
+			ret = -EFAULT;
+			goto done;
+		}
+		timeout  = timespec_to_jiffies(&ts);
+		suspend_block_timeout(&bl->blocker, timeout);
+		ret = 0;
+		break;
 	case SUSPEND_BLOCKER_IOCTL_UNBLOCK:
 		suspend_unblock(&bl->blocker);
 		ret = 0;
@@ -95,6 +111,9 @@ static int user_suspend_blocker_release(struct inode *inode, struct file *file)
 	struct user_suspend_blocker *bl = file->private_data;
 	if (!bl)
 		return 0;
+	if (is_blocking_suspend(&bl->blocker) && unclean_exit_grace_period)
+		suspend_block_timeout(&unclean_exit_suspend_blocker,
+					unclean_exit_grace_period * HZ);
 	suspend_blocker_destroy(&bl->blocker);
 	kfree(bl);
 	return 0;
@@ -113,12 +132,15 @@ struct miscdevice user_suspend_blocker_device = {
 
 static int __init user_suspend_blocker_init(void)
 {
+	suspend_blocker_init(&unclean_exit_suspend_blocker,
+				"user-unclean-exit");
 	return misc_register(&user_suspend_blocker_device);
 }
 
 static void __exit user_suspend_blocker_exit(void)
 {
 	misc_deregister(&user_suspend_blocker_device);
+	suspend_blocker_destroy(&unclean_exit_suspend_blocker);
 }
 
 module_init(user_suspend_blocker_init);
Signature · 6 lines
1.6.1

_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#11 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Arve Hjønnevåg

Review

Quoted 2 lines · On Tue, 14 Apr 2009, [utf-8] Arve HjønnevÃ¥g wrote:
(quoted diff) +2 -0
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on.

This sentence still grates on me. For readers not familiar with the embedded/phone environment, it won't make any sense. Furthermore the rest of the text below doesn't even mention the screen, which will cause readers to wonder why it is mentioned here.

Quoted 15 lines

Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +14 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now

Documentation/power/suspend-blockers.txt line 38

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++

How about replacing that first sentence with something like this:

In cell phones or other embedded systems where powering the screen is a significant drain on the battery, suspend blockers can be used to allow user-space to decide whether a keystroke received while the system is suspended should cause the screen to be turned back on or allow the system to go back into suspend.

Then in the last section, say this:

- The user-space input-event thread returns from read. If it determines that the key should leave the screen off, it calls suspend_unblock on the process_input_events suspend_blocker and then calls select or poll. The system will automatically suspend again, since now no suspend blockers are active.

Alan Stern

#12 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

Quoted 45 lines · Alan Stern

Review

Quoted 2 lines · On Tue, 14 Apr 2009, [utf-8] Arve HjønnevÃ¥g wrote:
(quoted diff) +2 -0
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on.

This sentence still grates on me. For readers not familiar with the embedded/phone environment, it won't make any sense. Furthermore the rest of the text below doesn't even mention the screen, which will cause readers to wonder why it is mentioned here.

Quoted 15 lines

Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +14 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now

Documentation/power/suspend-blockers.txt line 38

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++

How about replacing that first sentence with something like this:

In cell phones or other embedded systems where powering the screen is a significant drain on the battery, suspend blockers can be used to allow user-space to decide whether a keystroke received while the system is suspended should cause the screen to be turned back on or allow the system to go back into suspend.

Quoted 8 lines

Then in the last section, say this:

- The user-space input-event thread returns from read. If it determines that the key should leave the screen off, it calls suspend_unblock on the process_input_events suspend_blocker and then calls select or poll. The system will automatically suspend again, since now no suspend blockers are active.

I'm still re-reviewing the design so I probably should keep my mouth shut, but I only see code for constraining entry into suspend state (S3 if you will) I didn't see code that would get called to block device entry into higher power states just constraints on entire system entry into sleep state. (I apologize if I missed that code and will happily eat my words if needed.)

more comments after I finish looking over the code.

--mgross

#15 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Arve Hjønnevåg

I'm sure you are sick of this question, but couldn't you do this same functionality (constraining entry to Suspend) using existing infrastructure. You are clearly aggregating a block-count and triggering on an zero aggregate value to enter Suspend.

I'm thinking you could do something like CPUIDLE to push the implicit suspend call and use a new pmqos parameter to keep the system alive. We'd have to look at the API to make sure it would work in interrupt mode.

The only thing I got from the earlier threads asking why not PMQOS, was some complaint about the strcmp the constraint aggregation does WRT performance. I don't think it would be too hard to address the perceived performance issue (even if its yet to be proven as an issue anywhere)

FWIW there is some talk of re-factoring some of pmqos to sit on top of a constraint framework (to generalize the code a little and support constraining things that are not really measurable in terms of latencies or throughputs)

anyway a few comments below.

Quoted 25 lines · Arve Hjønnevåg

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

---
 Documentation/power/suspend-blockers.txt |   76 +++++++++
 include/linux/suspend_block.h            |   61 +++++++
 kernel/power/Kconfig                     |   10 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/main.c                      |   62 +++++++
 kernel/power/power.h                     |    6 +
 kernel/power/suspend_block.c             |  257 ++++++++++++++++++++++++++++++
 7 files changed, 473 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/suspend-blockers.txt
 create mode 100755 include/linux/suspend_block.h
 create mode 100644 kernel/power/suspend_block.c
Documentation/power/suspend-blockers.txt new file +0 -0
new file mode 100644
index 0000000..743b870

Documentation/power/suspend-blockers.txt line 4

Quoted 4 lines
Documentation/power/suspend-blockers.txt new file +4 -0
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.

And trigger implicit entry into suspend when last blocker is released.

Documentation/power/suspend-blockers.txt

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend from a sysdev suspend handler you must also return an error from
+that handler to abort suspend.
+
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on. 

Provided the user mode process controlling the screen power is in the calling path of user-space input-event thread.

Basically it should be made clear that this is not a device PM implementation. Its a global system suspend constraint system, where the count of blockers is aggregated in a static variable, suspend_block_count, within suspend_block.c with implicit suspend called when block count gets to zero.

i.e. only useful in platform specific code for platforms that can do ~10ms suspends and resumes.

Documentation/power/suspend-blockers.txt line 18

Quoted 5 lines

Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +4 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.

count = 1

Documentation/power/suspend-blockers.txt line 22

Quoted 4 lines

+- The keypad-scan code detects a key change and reports it to the input-event

Documentation/power/suspend-blockers.txt new file +3 -0
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.

count = 2

Quoted 2 lines
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.

count = 1

Documentation/power/suspend-blockers.txt line 27

Quoted 3 lines

+- The user-space input-event thread returns from select/poll, calls

Documentation/power/suspend-blockers.txt new file +2 -0
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.

count = 2

Quoted 2 lines
+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.

count = 1

Documentation/power/suspend-blockers.txt line 32

Quoted 3 lines

+- The user-space input-event thread returns from read. It determines that the

Documentation/power/suspend-blockers.txt new file +2 -0
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.

count = 0 + race between dropping into Suspend state and the execution of the select or poll. (should probably be ok)

Quoted 285 lines
Documentation/power/suspend-blockers.txt new file +44 -0
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+	struct suspend_blocker suspend_blocker;
+}
+
+init() {
+	suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+
+uninit() {
+	suspend_blocker_destroy(&state->suspend_blocker);
+}
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+	suspend_block(&state->suspend_blocker);
+
+When it no longer needs to run it calls suspend_unblock:
+	suspend_unblock(&state->suspend_blocker);
+
+Calling suspend_block when the suspend blocker is active or suspend_unblock when
+it is not active has no effect. This allows drivers to update their state and
+call suspend suspend_block or suspend_unblock based on the result.
+For instance:
+
+if (list_empty(&state->pending_work))
+	suspend_unblock(&state->suspend_blocker);
+else
+	suspend_block(&state->suspend_blocker);
+
include/linux/suspend_block.h new file +61 -0
new file mode 100755
index 0000000..7820c60
@@ -0,0 +1,61 @@
+/* include/linux/suspend_block.h
+ *
+ * Copyright (C) 2007-2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_H
+#define _LINUX_SUSPEND_BLOCK_H
+
+/* A suspend_blocker prevents the system from entering suspend when active.
+ */
+
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK
+	atomic_t            flags;
+	const char         *name;
+#endif
+};
+
+#ifdef CONFIG_SUSPEND_BLOCK
+
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
+void suspend_blocker_destroy(struct suspend_blocker *blocker);
+void suspend_block(struct suspend_blocker *blocker);
+void suspend_unblock(struct suspend_blocker *blocker);
+
+/* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker);
+
+/* suspend_is_blocked can be used by generic power management code to abort
+ * suspend.
+ *
+ * To preserve backward compatibility suspend_is_blocked returns 0 unless it
+ * is called during suspend initiated from the suspend_block code.
+ */
+bool suspend_is_blocked(void);
+
+#else
+
+static inline void suspend_blocker_init(struct suspend_blocker *blocker,
+					const char *name) {}
+static inline void suspend_blocker_destroy(struct suspend_blocker *blocker) {}
+static inline void suspend_block(struct suspend_blocker *blocker) {}
+static inline void suspend_unblock(struct suspend_blocker *blocker) {}
+static inline bool is_blocking_suspend(struct suspend_blocker *bl) { return 0; }
+static inline bool suspend_is_blocked(void) { return 0; }
+
+#endif
+
+#endif
+
kernel/power/Kconfig +10 -0
index 23bd4da..9d1df13 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
 	  Turning OFF this setting is NOT recommended! If in doubt, say Y.
 
+config SUSPEND_BLOCK
+	bool "Suspend block"
+	depends on PM
+	select RTC_LIB
+	default n
+	---help---
+	  Enable suspend_block. When user space requests a sleep state through
+	  /sys/power/request_state, the requested sleep state will be entered
+	  when no suspend_blockers are active.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 720ea4f..29cdc9e 100644
@@ -6,6 +6,7 @@ endif
 obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
+obj-$(CONFIG_SUSPEND_BLOCK)	+= suspend_block.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/main.c +62 -0
index c9632f8..e4c6b20 100644
@@ -22,6 +22,7 @@
 #include <linux/freezer.h>
 #include <linux/vmstat.h>
 #include <linux/syscalls.h>
+#include <linux/suspend_block.h>
 
 #include "power.h"
 
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
 static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+	[PM_SUSPEND_ON]		= "on",
+#endif
 	[PM_SUSPEND_STANDBY]	= "standby",
 	[PM_SUSPEND_MEM]	= "mem",
 };
@@ -540,6 +544,61 @@ static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 
 power_attr(state);
 
+/**
+ *	request_state - control system power state.
+ *
+ *	This is similar to state, but it does not block until the system
+ *	resumes, and it will try to re-enter the state until another state is
+ *	requested. Suspend blockers are respected and the requested state will
+ *	only be entered when no suspend blockers are active.
+ *	Write "on" to cancel.
+ */
+
+#ifdef CONFIG_SUSPEND_BLOCK
+static ssize_t request_state_show(struct kobject *kobj,
+				  struct kobj_attribute *attr, char *buf)
+{
+	char *s = buf;
+	int i;
+
+	for (i = 0; i < PM_SUSPEND_MAX; i++) {
+		if (pm_states[i] && (i == PM_SUSPEND_ON || valid_state(i)))
+			s += sprintf(s, "%s ", pm_states[i]);
+	}
+	if (s != buf)
+		/* convert the last space to a newline */
+		*(s-1) = '\n';
+	return (s - buf);
+}
+
+static ssize_t request_state_store(struct kobject *kobj,
+				   struct kobj_attribute *attr,
+				   const char *buf, size_t n)
+{
+	suspend_state_t state = PM_SUSPEND_ON;
+	const char * const *s;
+	char *p;
+	int len;
+	int error = -EINVAL;
+
+	p = memchr(buf, '\n', n);
+	len = p ? p - buf : n;
+
+	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
+		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
+			break;
+	}
+	if (state < PM_SUSPEND_MAX && *s)
+		if (state == PM_SUSPEND_ON || valid_state(state)) {
+			error = 0;
+			request_suspend_state(state);
+		}
+	return error ? error : n;
+}
+
+power_attr(request_state);
+#endif /* CONFIG_SUSPEND_BLOCK */
+
 #ifdef CONFIG_PM_TRACE
 int pm_trace_enabled;
 
@@ -567,6 +626,9 @@ power_attr(pm_trace);
 
 static struct attribute * g[] = {
 	&state_attr.attr,
+#ifdef CONFIG_SUSPEND_BLOCK
+	&request_state_attr.attr,
+#endif
 #ifdef CONFIG_PM_TRACE
 	&pm_trace_attr.attr,
 #endif
kernel/power/power.h +6 -0
index 46b5ec7..2414a74 100644
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
 {
 }
 #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif
+
kernel/power/suspend_block.c new file +27 -0
new file mode 100644
index 0000000..b4f2191
@@ -0,0 +1,257 @@
+/* kernel/power/suspend_block.c
+ *
+ * Copyright (C) 2005-2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/suspend.h>
+#include <linux/suspend_block.h>
+#include <linux/sysdev.h>
+#include "power.h"
+
+enum {
+	DEBUG_EXIT_SUSPEND = 1U << 0,
+	DEBUG_WAKEUP = 1U << 1,
+	DEBUG_USER_STATE = 1U << 2,
+	DEBUG_SUSPEND = 1U << 3,

kernel/power/suspend_block.c line 37

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+	DEBUG_SUSPEND_BLOCKER = 1U << 4,
+};
+static int debug_mask = DEBUG_EXIT_SUSPEND | DEBUG_WAKEUP | DEBUG_USER_STATE;
+module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
+
+#define SB_INITIALIZED            (1U << 8)
+#define SB_ACTIVE                 (1U << 9)
+
+static DEFINE_SPINLOCK(state_lock);
+static atomic_t suspend_block_count;

So if suspend_block_count is the lynch pin of the design, why have all the suspend_blocker structs? Why have all the logic around the different suspend blocker instances?

It seems like a lot of extra effort for an atomic "stay awake" counter.

--mgross

Quoted 222 lines
kernel/power/suspend_block.c new file +220 -0
+static atomic_t current_event_num;
+struct workqueue_struct *suspend_work_queue;
+struct suspend_blocker main_suspend_blocker;
+static suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
+static bool enable_suspend_blockers;
+
+bool suspend_is_blocked(void)
+{
+	if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+		return 0;
+	return !!atomic_read(&suspend_block_count);
+}
+
+static void suspend_worker(struct work_struct *work)
+{
+	int ret;
+	int entry_event_num;
+
+	enable_suspend_blockers = 1;
+
+retry:
+	if (suspend_is_blocked()) {
+		if (debug_mask & DEBUG_SUSPEND)
+			pr_info("suspend: abort suspend\n");
+		goto abort;
+	}
+
+	entry_event_num = atomic_read(&current_event_num);
+	if (debug_mask & DEBUG_SUSPEND)
+		pr_info("suspend: enter suspend\n");
+	ret = pm_suspend(requested_suspend_state);
+	if (debug_mask & DEBUG_EXIT_SUSPEND) {
+		struct timespec ts;
+		struct rtc_time tm;
+		getnstimeofday(&ts);
+		rtc_time_to_tm(ts.tv_sec, &tm);
+		pr_info("suspend: exit suspend, ret = %d "
+			"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+	}
+	if (atomic_read(&current_event_num) == entry_event_num) {
+		if (debug_mask & DEBUG_SUSPEND)
+			pr_info("suspend: pm_suspend returned with no event\n");
+		goto retry;
+	}
+abort:
+	enable_suspend_blockers = 0;
+}
+static DECLARE_WORK(suspend_work, suspend_worker);
+
+static int suspend_block_suspend(struct sys_device *dev, pm_message_t state)
+{
+	int ret = suspend_is_blocked() ? -EAGAIN : 0;
+	if (debug_mask & DEBUG_SUSPEND)
+		pr_info("suspend_block_suspend return %d\n", ret);
+	return ret;
+}
+
+static struct sysdev_class suspend_block_sysclass = {
+	.name = "suspend_block",
+	.suspend = suspend_block_suspend,
+};
+static struct sys_device suspend_block_sysdev = {
+	.cls = &suspend_block_sysclass,
+};
+
+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker:	The suspend blocker to initialize.
+ * @name:	The name of the suspend blocker to show in
+ *		/proc/suspend_blockers
+ */
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name)
+{
+	if (name)
+		blocker->name = name;
+	BUG_ON(!blocker->name);
+
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_blocker_init name=%s\n", blocker->name);
+
+	atomic_set(&blocker->flags, SB_INITIALIZED);
+}
+EXPORT_SYMBOL(suspend_blocker_init);
+
+/**
+ * suspend_blocker_destroy() - Destroy a suspend blocker
+ * @blocker:	The suspend blocker to destroy.
+ */
+void suspend_blocker_destroy(struct suspend_blocker *blocker)
+{
+	int flags;
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_blocker_destroy name=%s\n", blocker->name);
+	flags = atomic_xchg(&blocker->flags, 0);
+	WARN(!(flags & SB_INITIALIZED), "suspend_blocker_destroy called on "
+					"uninitialized suspend_blocker\n");
+	if (flags == (SB_INITIALIZED | SB_ACTIVE))
+		if (atomic_dec_and_test(&suspend_block_count))
+			queue_work(suspend_work_queue, &suspend_work);
+}
+EXPORT_SYMBOL(suspend_blocker_destroy);
+
+/**
+ * suspend_block() - Block suspend
+ * @blocker:	The suspend blocker to use
+ */
+void suspend_block(struct suspend_blocker *blocker)
+{
+	BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED));
+
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_block: %s\n", blocker->name);
+	if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED,
+	    SB_INITIALIZED | SB_ACTIVE) == SB_INITIALIZED)
+		atomic_inc(&suspend_block_count);
+
+	atomic_inc(&current_event_num);
+}
+EXPORT_SYMBOL(suspend_block);
+
+/**
+ * suspend_unblock() - Unblock suspend
+ * @blocker:	The suspend blocker to unblock.
+ *
+ * If no other suspend blockers block suspend, the system will suspend.
+ */
+void suspend_unblock(struct suspend_blocker *blocker)
+{
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_unblock: %s\n", blocker->name);
+
+	if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED | SB_ACTIVE,
+	    SB_INITIALIZED) == (SB_INITIALIZED | SB_ACTIVE))
+		if (atomic_dec_and_test(&suspend_block_count))
+			queue_work(suspend_work_queue, &suspend_work);
+}
+EXPORT_SYMBOL(suspend_unblock);
+
+/**
+ * is_blocking_suspend() - Test if a suspend blocker is blocking suspend
+ * @blocker:	The suspend blocker to check.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker)
+{
+	return !!(atomic_read(&blocker->flags) & SB_ACTIVE);
+}
+EXPORT_SYMBOL(is_blocking_suspend);
+
+void request_suspend_state(suspend_state_t state)
+{
+	unsigned long irqflags;
+	spin_lock_irqsave(&state_lock, irqflags);
+	if (debug_mask & DEBUG_USER_STATE) {
+		struct timespec ts;
+		struct rtc_time tm;
+		getnstimeofday(&ts);
+		rtc_time_to_tm(ts.tv_sec, &tm);
+		pr_info("request_suspend_state: %s (%d->%d) at %lld "
+			"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
+			state != PM_SUSPEND_ON ? "sleep" : "wakeup",
+			requested_suspend_state, state,
+			ktime_to_ns(ktime_get()),
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+	}
+	requested_suspend_state = state;
+	if (state == PM_SUSPEND_ON)
+		suspend_block(&main_suspend_blocker);
+	else
+		suspend_unblock(&main_suspend_blocker);
+	spin_unlock_irqrestore(&state_lock, irqflags);
+}
+
+static int __init suspend_block_init(void)
+{
+	int ret;
+
+	suspend_blocker_init(&main_suspend_blocker, "main");
+	suspend_block(&main_suspend_blocker);
+
+	ret = sysdev_class_register(&suspend_block_sysclass);
+	if (ret) {
+		pr_err("suspend_block_init: sysdev_class_register failed\n");
+		goto err_sysdev_class_register;
+	}
+	ret = sysdev_register(&suspend_block_sysdev);
+	if (ret) {
+		pr_err("suspend_block_init: suspend_block_sysdev failed\n");
+		goto err_sysdev_register;
+	}
+
+	suspend_work_queue = create_singlethread_workqueue("suspend");
+	if (suspend_work_queue == NULL) {
+		ret = -ENOMEM;
+		goto err_suspend_work_queue;
+	}
+
+	return 0;
+
+err_suspend_work_queue:
+	sysdev_unregister(&suspend_block_sysdev);
+err_sysdev_register:
+	sysdev_class_unregister(&suspend_block_sysclass);
+err_sysdev_class_register:
+	suspend_blocker_destroy(&main_suspend_blocker);
+	return ret;
+}
+
+static void  __exit suspend_block_exit(void)
+{
+	destroy_workqueue(suspend_work_queue);
+	sysdev_unregister(&suspend_block_sysdev);
+	sysdev_class_unregister(&suspend_block_sysclass);
+	suspend_blocker_destroy(&main_suspend_blocker);
+}
+
+core_initcall(suspend_block_init);
+module_exit(suspend_block_exit);
Signature · 1 line
1.6.1
#31 lore raw
In reply to Arve Hjønnevåg
Quoted 5 lines · Arve Hjønnevåg

This patch series adds a suspend-block api that provides the same functionality as the android wakelock api from my last patch series, Android PM extensions (version 3). As requested, wake_lock has been renamed to suspend_block(er), and timeout support has been separated into its own patch.

Sounds good.

Unfortunately, I don't have the time to review the patches in detail at the moment. Will to that as soon as I can.

Thanks,
Rafael
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#14 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Alan Stern

2009/4/15 Alan Stern <[email protected]>:

Quoted 45 lines · On Tue, 14 Apr 2009, [utf-8] Arve Hjønnevåg wrote:

Review

Quoted 3 lines
(quoted diff) +2 -0
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on.

This sentence still grates on me.  For readers not familiar with the embedded/phone environment, it won't make any sense.  Furthermore the rest of the text below doesn't even mention the screen, which will cause readers to wonder why it is mentioned here.

Quoted 15 lines

 Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +14 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now

Documentation/power/suspend-blockers.txt line 38

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++

How about replacing that first sentence with something like this:

       In cell phones or other embedded systems where powering the screen is a significant drain on the battery, suspend blockers can be used to allow user-space to decide whether a keystroke received while the system is suspended should cause the screen to be turned back on or allow the system to go back into suspend.

Quoted 9 lines

Then in the last section, say this:

     - The user-space input-event thread returns from read. If it determines that the key should leave the screen off, it calls suspend_unblock on the process_input_events suspend_blocker and then calls select or poll.  The system will automatically suspend again, since now no suspend blockers are active.

This sounds reasonable too me.

Signature · 1 line
Arve Hjønnevåg
#13 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to mark gross
Quoted 7 lines · mark gross

I'm still re-reviewing the design so I probably should keep my mouth shut, but I only see code for constraining entry into suspend state (S3 if you will)  I didn't see code that would get called to block device entry into higher power states just constraints on entire system entry into sleep state.  (I apologize if I missed that code and will happily eat my words if needed.)

I removed the idle wake lock type since it had too much overlap with pm_qos. Are there any references to them left in the documentation?

Signature · 1 line
Arve Hjønnevåg
#16 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to mark gross

2009/4/15 mark gross <[email protected]>:

Quoted 4 lines

I'm sure you are sick of this question, but couldn't you do this same functionality (constraining entry to Suspend) using existing infrastructure.  You are clearly aggregating a block-count and triggering on an zero aggregate value to enter Suspend.

The only reason I have a block count, is that the feedback on this list was that it is too expensive to use a spin-lock every time we want to block or unblock suspend. The later patches that enable stats and timeout support uses inactive and active lists instead.

Quoted 10 lines

I'm thinking you could do something like CPUIDLE to push the implicit suspend call and use a new pmqos parameter to keep the system alive. We'd have to look at the API to make sure it would work in interrupt mode.

The only thing I got from the earlier threads asking why not PMQOS, was some complaint about the strcmp the constraint aggregation does WRT performance.  I don't think it would be too hard to address the perceived performance issue (even if its yet to be proven as an issue anywhere)

There was a question about why we did not use pmqos instead othe the idle wake locks. One reason was that we mainly needed to prevent a specific state to not loose interrupts, not because the latency was too high. The other reason was that the pm qos interface uses strings instead of handles. Using strings to search to a list for the item you want to update has an impact on performance that is not hard to measure, but it also require the clients to create unique strings.

Quoted 5 lines

FWIW there is some talk of re-factoring some of pmqos to sit on top of a constraint framework (to generalize the code a little and support constraining things that are not really measurable in terms of latencies or throughputs)

That should help with replacing the idle-wake-locks.

Quoted 35 lines

anyway a few comments below.

Quoted 25 lines · Arve Hjønnevåg

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

---
 Documentation/power/suspend-blockers.txt |   76 +++++++++ include/linux/suspend_block.h            |   61 +++++++ kernel/power/Kconfig                     |   10 ++ kernel/power/Makefile                    |    1 + kernel/power/main.c                      |   62 +++++++ kernel/power/power.h                     |    6 + kernel/power/suspend_block.c             |  257 ++++++++++++++++++++++++++++++

 7 files changed, 473 insertions(+), 0 deletions(-)

 create mode 100644 Documentation/power/suspend-blockers.txt create mode 100755 include/linux/suspend_block.h create mode 100644 kernel/power/suspend_block.c

Documentation/power/suspend-blockers.txt new file +0 -0
new file mode 100644
index 0000000..743b870

Documentation/power/suspend-blockers.txt line 4

Quoted 4 lines
Documentation/power/suspend-blockers.txt new file +4 -0
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.

And trigger implicit entry into suspend when last blocker is released.

Quoted 13 lines

Documentation/power/suspend-blockers.txt

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend from a sysdev suspend handler you must also return an error from
+that handler to abort suspend.
+
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on.

Provided the user mode process controlling the screen power is in the calling path of user-space input-event thread.

What you mean by this? Our user-space input event thread does not turn the screen on, but translates the events and queues the translated event on another queue. As long as all queues are protected by a suspend blocker, there is no requirement about which thread turns the screen on.

Quoted 9 lines

Basically it should be made clear that this is not a device PM implementation.  Its a global system suspend constraint system, where the count of blockers is aggregated in a static variable, suspend_block_count, within suspend_block.c  with implicit suspend called when block count gets to zero.

i.e. only useful in platform specific code for platforms that can do ~10ms suspends and resumes.

I disagree. If I have a desktop system that takes 5 seconds to wake up from sleep, I still want the ability to auto suspend after user inactivity, and to prevent suspend while some tasks are running.

Quoted 19 lines

Documentation/power/suspend-blockers.txt line 18

Quoted 6 lines

Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +4 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.

count = 1

Quoted 4 lines

+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.

count = 2

Quoted 2 lines

+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.

count = 1

Quoted 3 lines

+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.

count = 2

Quoted 8 lines
Quoted 2 lines

+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.

count = 1

Quoted 3 lines

+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.

count = 0 + race between dropping into Suspend state and the execution of the select or poll.  (should probably be ok)

This is not a race condition, select or poll does not affect the suspend blocker in the input driver to it does not matter if the poll is called before or after suspend.

Quoted 17 lines
Quoted 17 lines
Documentation/power/suspend-blockers.txt new file +15 -0
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
 
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK
+     atomic_t            flags;
+     const char         *name;
+#endif
+};
+

...

Quoted 10 lines

Documentation/power/suspend-blockers.txt

Quoted 6 lines
Documentation/power/suspend-blockers.txt new file +6 -0
+
+#define SB_INITIALIZED            (1U << 8)
+#define SB_ACTIVE                 (1U << 9)
+
+static DEFINE_SPINLOCK(state_lock);
+static atomic_t suspend_block_count;

So if suspend_block_count is the lynch pin of the design, why have all the suspend_blocker structs?  Why have all the logic around the different suspend blocker instances?

The suspend block structs need to be part of the api to allow stats and/or debugging. It also ensures that a single suspend_blocker does not change the global count by more than one. Also, suspend_block_count is not part of the design, it is an optimization that becomes useless when you enable stats.

Quoted 3 lines

It seems like a lot of extra effort for an atomic "stay awake" counter.

Signature · 1 line
Arve Hjønnevåg
#17 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

Quoted 22 lines · Arve Hjønnevåg

2009/4/15 mark gross <[email protected]>:

Quoted 4 lines

I'm sure you are sick of this question, but couldn't you do this same functionality (constraining entry to Suspend) using existing infrastructure.  You are clearly aggregating a block-count and triggering on an zero aggregate value to enter Suspend.

The only reason I have a block count, is that the feedback on this list was that it is too expensive to use a spin-lock every time we want to block or unblock suspend. The later patches that enable stats and timeout support uses inactive and active lists instead.

Quoted 10 lines

I'm thinking you could do something like CPUIDLE to push the implicit suspend call and use a new pmqos parameter to keep the system alive. We'd have to look at the API to make sure it would work in interrupt mode.

The only thing I got from the earlier threads asking why not PMQOS, was some complaint about the strcmp the constraint aggregation does WRT performance.  I don't think it would be too hard to address the perceived performance issue (even if its yet to be proven as an issue anywhere)

Quoted 7 lines

There was a question about why we did not use pmqos instead othe the idle wake locks. One reason was that we mainly needed to prevent a specific state to not loose interrupts, not because the latency was too high. The other reason was that the pm qos interface uses strings instead of handles. Using strings to search to a list for the item you want to update has an impact on performance that is not hard to measure, but it also require the clients to create unique strings.

really? How many times / second was your system changing the pmqos parameter? If that turns out to be realistic, non-abusive use of the api then perhaps I need to migrate pmqos to include / use handles.

when pmqos was designed we assumed it wouldn't be hit with high parameter change rates. What could be a realistic upper bound on change rate for the parameters?

Quoted 58 lines
Quoted 6 lines

FWIW there is some talk of re-factoring some of pmqos to sit on top of a constraint framework (to generalize the code a little and support constraining things that are not really measurable in terms of latencies or throughputs)

That should help with replacing the idle-wake-locks.

Quoted 35 lines

anyway a few comments below.

Quoted 25 lines · Arve Hjønnevåg

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

---
 Documentation/power/suspend-blockers.txt |   76 +++++++++ include/linux/suspend_block.h            |   61 +++++++ kernel/power/Kconfig                     |   10 ++ kernel/power/Makefile                    |    1 + kernel/power/main.c                      |   62 +++++++ kernel/power/power.h                     |    6 + kernel/power/suspend_block.c             |  257 ++++++++++++++++++++++++++++++

 7 files changed, 473 insertions(+), 0 deletions(-)

 create mode 100644 Documentation/power/suspend-blockers.txt create mode 100755 include/linux/suspend_block.h create mode 100644 kernel/power/suspend_block.c

Documentation/power/suspend-blockers.txt new file +0 -0
new file mode 100644
index 0000000..743b870

Documentation/power/suspend-blockers.txt line 4

Quoted 4 lines
Documentation/power/suspend-blockers.txt new file +4 -0
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.

And trigger implicit entry into suspend when last blocker is released.

Quoted 13 lines

Documentation/power/suspend-blockers.txt

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend from a sysdev suspend handler you must also return an error from
+that handler to abort suspend.
+
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on.

Provided the user mode process controlling the screen power is in the calling path of user-space input-event thread.

Quoted 5 lines

What you mean by this? Our user-space input event thread does not turn the screen on, but translates the events and queues the translated event on another queue. As long as all queues are protected by a suspend blocker, there is no requirement about which thread turns the screen on.

I mean that to enable the promised partial system wake up ( "Suspend blockers can be used to allow user-space to decide which keys should wake the full system up and turn the screen on.") there is more to the story as this API is about system level pm not device PM needed to keep the screen off while partially waking things up before suspending again.

Perhaps an explanation on how suspend blocker can be used to partially wake up a system without the screen coming on would help me. Right now I'm not seeing how that can be implemented in the context of this patch.

Quoted 7 lines
Quoted 7 lines

Basically it should be made clear that this is not a device PM implementation.  Its a global system suspend constraint system, where the count of blockers is aggregated in a static variable, suspend_block_count, within suspend_block.c  with implicit suspend called when block count gets to zero.

Quoted 6 lines
Quoted 2 lines

i.e. only useful in platform specific code for platforms that can do ~10ms suspends and resumes.

I disagree. If I have a desktop system that takes 5 seconds to wake up from sleep, I still want the ability to auto suspend after user inactivity, and to prevent suspend while some tasks are running.

I guess we have this now, but the user mode implementations don't scale to low latency and frequent suspend applications.

--mgross

Quoted 74 lines
Quoted 19 lines

Documentation/power/suspend-blockers.txt line 18

Quoted 6 lines

Use set_irq_wake or a platform

Documentation/power/suspend-blockers.txt new file +4 -0
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.

count = 1

Quoted 4 lines

+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.

count = 2

Quoted 2 lines

+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.

count = 1

Quoted 3 lines

+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.

count = 2

Quoted 8 lines
Quoted 2 lines

+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.

count = 1

Quoted 3 lines

+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.

count = 0 + race between dropping into Suspend state and the execution of the select or poll.  (should probably be ok)

This is not a race condition, select or poll does not affect the suspend blocker in the input driver to it does not matter if the poll is called before or after suspend.

Quoted 17 lines
Quoted 17 lines
Documentation/power/suspend-blockers.txt new file +15 -0
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
 
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK
+     atomic_t            flags;
+     const char         *name;
+#endif
+};
+

...

Quoted 10 lines

Documentation/power/suspend-blockers.txt

Quoted 6 lines
Documentation/power/suspend-blockers.txt new file +6 -0
+
+#define SB_INITIALIZED            (1U << 8)
+#define SB_ACTIVE                 (1U << 9)
+
+static DEFINE_SPINLOCK(state_lock);
+static atomic_t suspend_block_count;

So if suspend_block_count is the lynch pin of the design, why have all the suspend_blocker structs?  Why have all the logic around the different suspend blocker instances?

The suspend block structs need to be part of the api to allow stats and/or debugging. It also ensures that a single suspend_blocker does not change the global count by more than one. Also, suspend_block_count is not part of the design, it is an optimization that becomes useless when you enable stats.

Quoted 3 lines

It seems like a lot of extra effort for an atomic "stay awake" counter.

Signature · 1 line
Arve Hjønnevåg
#18 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Arve Hjønnevåg

Hi!

Quoted 15 lines
Documentation/power/suspend-blockers.txt new file +15 -0
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+	struct suspend_blocker suspend_blocker;
+}
+
+init() {
+	suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+

Documentation/power/suspend-blockers.txt line 65

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+uninit() {
+	suspend_blocker_destroy(&state->suspend_blocker);
+}
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+	suspend_block(&state->suspend_blocker);
+
+When it no longer needs to run it calls suspend_unblock:
+	suspend_unblock(&state->suspend_blocker);

Sounds reasonably sane. Maybe it should be block_suspend(), because suspend_block() sounds like... something that builds suspend, but I guess it is good enough.

include/linux/suspend_block.h line 21

Quoted 3 lines
include/linux/suspend_block.h new file +3 -0
+/* A suspend_blocker prevents the system from entering suspend when active.
+ */
+

linuxdoc?

Quoted 7 lines
include/linux/suspend_block.h new file +7 -0
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK
+	atomic_t            flags;
+	const char         *name;
+#endif
+};
+

include/linux/suspend_block.h line 38

Quoted 10 lines
include/linux/suspend_block.h new file +10 -0
+#ifdef CONFIG_SUSPEND_BLOCK
+
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
+void suspend_blocker_destroy(struct suspend_blocker *blocker);
+void suspend_block(struct suspend_blocker *blocker);
+void suspend_unblock(struct suspend_blocker *blocker);
+
+/* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker);

Same here?

kernel/power/Kconfig config SUSPEND_FREEZER · line 122

Quoted 12 lines
kernel/power/Kconfig +4 -0
index 23bd4da..9d1df13 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
 	  Turning OFF this setting is NOT recommended! If in doubt, say Y.
 
+config SUSPEND_BLOCK
+	bool "Suspend block"
+	depends on PM
+	select RTC_LIB

Is RTC_LIB okay to select?

kernel/power/Kconfig static void suspend_finish(void) · line 401

Quoted 10 lines
kernel/power/Kconfig +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
 static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+	[PM_SUSPEND_ON]		= "on",
+#endif
 	[PM_SUSPEND_STANDBY]	= "standby",
 	[PM_SUSPEND_MEM]	= "mem",
 };

This allows you to write "on" to the other interfaces where that makes no sense.... right?

Quoted 1 line

+static bool enable_suspend_blockers;

Uhuh... What is this good for... except debugging?

kernel/power/Kconfig

Quoted 6 lines
kernel/power/Kconfig +6 -0
+bool suspend_is_blocked(void)
+{
+	if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+		return 0;
+	return !!atomic_read(&suspend_block_count);
+}

Yes, if enable_suspend_blockers is one, we are in deep trouble.

Quoted 5 lines

+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name: The name of the suspend blocker to show in
+ * /proc/suspend_blockers

I don't think suspend_blockers should go to /proc. They are not process-related.

kernel/power/Kconfig

Quoted 7 lines
kernel/power/Kconfig +7 -0
+/**
+ * suspend_block() - Block suspend
+ * @blocker:	The suspend blocker to use
+ */
+void suspend_block(struct suspend_blocker *blocker)
+{
+	BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED));

As blocker->flags seem to be used mostly for debugging; do they have to use "atomic"? Normally, "magic" variable is used, instead. (Single bit is probably not enough to guard against using uninitialized memory.)

kernel/power/Kconfig

Quoted 7 lines

+ * suspend_unblock() - Unblock suspend
+ * @blocker: The suspend blocker to unblock.
+ *
+ * If no other suspend blockers block suspend, the system will suspend.
+ */

kernel/power/Kconfig +2 -0
+void suspend_unblock(struct suspend_blocker *blocker)
+{

...BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED)); ?

kernel/power/Kconfig

Quoted 9 lines
kernel/power/Kconfig +9 -0
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_unblock: %s\n", blocker->name);
+
+	if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED | SB_ACTIVE,
+	    SB_INITIALIZED) == (SB_INITIALIZED | SB_ACTIVE))
+		if (atomic_dec_and_test(&suspend_block_count))
+			queue_work(suspend_work_queue, &suspend_work);
+}
+EXPORT_SYMBOL(suspend_unblock);

Uhuh... can we "loose a oportunity to suspend" here? If someone is just updating the flags...? Is it guaranteed that if two people do suspend_unblock at the same time, one of them will pass?

Quoted 6 lines
kernel/power/Kconfig +6 -0
+void request_suspend_state(suspend_state_t state)
+{
+	unsigned long irqflags;
+	spin_lock_irqsave(&state_lock, irqflags);
+	if (debug_mask & DEBUG_USER_STATE) {
+		struct timespec ts;

kernel/power/Kconfig

Quoted 10 lines
kernel/power/Kconfig +10 -0
+		struct rtc_time tm;
+		getnstimeofday(&ts);
+		rtc_time_to_tm(ts.tv_sec, &tm);
+		pr_info("request_suspend_state: %s (%d->%d) at %lld "
+			"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
+			state != PM_SUSPEND_ON ? "sleep" : "wakeup",
+			requested_suspend_state, state,
+			ktime_to_ns(ktime_get()),
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);

Introduce macro for printing time?

Otherwise, it looks good...
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#19 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

Quoted 11 lines · Pavel Machek

Review

Quoted 6 lines
(quoted diff) +6 -0
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+     suspend_block(&state->suspend_blocker);
+
+When it no longer needs to run it calls suspend_unblock:
+     suspend_unblock(&state->suspend_blocker);

Sounds reasonably sane. Maybe it should be block_suspend(), because suspend_block() sounds like... something that builds suspend, but I guess it is good enough.

I was trying to keep a common prefix.

Quoted 17 lines

Review

Quoted 3 lines
(quoted diff) +3 -0
+/* A suspend_blocker prevents the system from entering suspend when active.
+ */
+

linuxdoc?

Quoted 11 lines
(quoted diff) +11 -0
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK
+     atomic_t            flags;
+     const char         *name;
+#endif
+};
+
+#ifdef CONFIG_SUSPEND_BLOCK
+
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
+void suspend_blocker_destroy(struct suspend_blocker *blocker);
Quoted 8 lines

Review

Quoted 6 lines
(quoted diff) +6 -0
+void suspend_block(struct suspend_blocker *blocker);
+void suspend_unblock(struct suspend_blocker *blocker);
+
+/* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker);

Same here?

I moved this to the c file, see diff below.

Quoted 7 lines
Quoted 7 lines
kernel/power/Kconfig +0 -0
index 23bd4da..9d1df13 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
Quoted 8 lines
Quoted 6 lines

        Turning OFF this setting is NOT recommended! If in doubt, say Y.

+config SUSPEND_BLOCK
+     bool "Suspend block"
+     depends on PM
+     select RTC_LIB

Is RTC_LIB okay to select?

It should be. It cannot be enabled manually.

Quoted 13 lines

kernel/power/Kconfig static void suspend_finish(void) · line 401

Quoted 10 lines
kernel/power/Kconfig +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
  static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+     [PM_SUSPEND_ON]         = "on",
+#endif
       [PM_SUSPEND_STANDBY]    = "standby",
       [PM_SUSPEND_MEM]        = "mem",
  };

This allows you to write "on" to the other interfaces where that makes no sense.... right?

state_store starts iterating at PM_SUSPEND_STANDBY, so don't think so.

Quoted 4 lines
Quoted 2 lines

+static bool enable_suspend_blockers;

Uhuh... What is this good for... except debugging?

It prevents suspend blockers from affecting existing suspend and freezing interfaces (while auto suspend is not active).

Quoted 9 lines

kernel/power/Kconfig

Quoted 7 lines
kernel/power/Kconfig +6 -0
+bool suspend_is_blocked(void)
+{
+     if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+             return 0;
+     return !!atomic_read(&suspend_block_count);
+}

Yes, if enable_suspend_blockers is one, we are in deep trouble.

It just means that you compiled suspend blocker support into the kernel, but used an old interface to enter suspend. It warns if enable_suspend_blockers is 0 not 1.

Quoted 8 lines
Quoted 6 lines

+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name:    The name of the suspend blocker to show in
+ *           /proc/suspend_blockers

I don't think suspend_blockers should go to /proc. They are not process-related.

I moved that comment to the stats patch. It is still in procfs though, as it is most similar to other procfs entries. It is not allowed under the sysfs rules, and we do not want to enable debugfs on a production system since it exposes some unsafe interfaces.

Quoted 12 lines

kernel/power/Kconfig

Quoted 8 lines
kernel/power/Kconfig +7 -0
+/**
+ * suspend_block() - Block suspend
+ * @blocker: The suspend blocker to use
+ */
+void suspend_block(struct suspend_blocker *blocker)
+{
+     BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED));

As blocker->flags seem to be used mostly for debugging; do they have to use "atomic"? Normally, "magic" variable is used, instead. (Single bit is probably not enough to guard against using uninitialized memory.)

It is mostly used to determine if the suspend blocker is already active, so yes it has to be atomic. I could add a magic value, but a single bit is enough to catch uninitialized global and kzalloced members.

Quoted 10 lines

kernel/power/Kconfig

Quoted 8 lines

+ * suspend_unblock() - Unblock suspend
+ * @blocker: The suspend blocker to unblock.
+ *
+ * If no other suspend blockers block suspend, the system will suspend.
+ */

kernel/power/Kconfig +2 -0
+void suspend_unblock(struct suspend_blocker *blocker)
+{

...BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED)); ?

Perhaps. This function does not do anything unless you have already called suspend_block though.

Quoted 14 lines

kernel/power/Kconfig

Quoted 10 lines

+     if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+             pr_info("suspend_unblock: %s\n", blocker->name);

kernel/power/Kconfig +7 -0
+
+     if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED | SB_ACTIVE,
+         SB_INITIALIZED) == (SB_INITIALIZED | SB_ACTIVE))
+             if (atomic_dec_and_test(&suspend_block_count))
+                     queue_work(suspend_work_queue, &suspend_work);
+}
+EXPORT_SYMBOL(suspend_unblock);

Uhuh... can we "loose a oportunity to suspend" here? If someone is just updating the flags...? Is it guaranteed that if two people do suspend_unblock at the same time, one of them will pass?

What do you mean by just updating the flags? SB_ACTIVE was either cleared or not, if it was, then atomic_dec_and_test is called.

Quoted 11 lines
Quoted 11 lines
kernel/power/Kconfig +10 -0
+void request_suspend_state(suspend_state_t state)
+{
+     unsigned long irqflags;
+     spin_lock_irqsave(&state_lock, irqflags);
+     if (debug_mask & DEBUG_USER_STATE) {
+             struct timespec ts;
+             struct rtc_time tm;
+             getnstimeofday(&ts);
+             rtc_time_to_tm(ts.tv_sec, &tm);
+             pr_info("request_suspend_state: %s (%d->%d) at %lld "
Quoted 8 lines
Quoted 6 lines

+                     "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
+                     state != PM_SUSPEND_ON ? "sleep" : "wakeup",
+                     requested_suspend_state, state,
+                     ktime_to_ns(ktime_get()),
+                     tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                     tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);

Introduce macro for printing time?

OK.

Signature · 3 lines
Arve Hjønnevåg

----
(quoted diff) +0 -0

b/Documentation/power/suspend-blockers.txt
index 743b870..e95a507 100644

Documentation/power/suspend-blockers.txt +0 -0
@@ -10,10 +10,14 @@ interrupt handler or a freezeable thread always

works, but if you call
block_suspend from a sysdev suspend handler you must also return an error from that handler to abort suspend.

-Suspend blockers can be used to allow user-space to decide which keys should -wake the full system up and turn the screen on. Use set_irq_wake or a platform -specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
-driver has resumed, the sequence of events can look like this:
+In cell phones or other embedded systems where powering the screen is a +significant drain on the battery, suspend blockers can be used to allow +user-space to decide whether a keystroke received while the system is suspended +should cause the screen to be turned back on or allow the system to go back into
+suspend. Use set_irq_wake or a platform specific api to make sure the keypad +interrupt wakes up the cpu. Once the keypad driver has resumed, the sequence of +events can look like this:
+
- The Keypad driver gets an interrupt. It then calls suspend_block on the keypad-scan suspend_blocker and starts scanning the keypad matrix.
- The keypad-scan code detects a key change and reports it to the input-event
@@ -27,9 +31,11 @@ driver has resumed, the sequence of events can look like this:
on the input-event device.
- The input-event driver dequeues the key-event and, since the queue is now empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
-- The user-space input-event thread returns from read. It determines that the
- key should not wake up the full system, calls suspend_unblock on the
- process-input-events suspend_blocker and calls select or poll.

+- The user-space input-event thread returns from read. If it determines that
+  the key should leave the screen off, it calls suspend_unblock on the
+  process_input_events suspend_blocker and then calls select or poll. The
+  system will automatically suspend again, since now no suspend blockers are
+  active.

Key pressed Key released
| |

include/linux/suspend_block.h +9 -1
index 7820c60..54bf9c4 100755
@@ -16,7 +16,15 @@
 #ifndef _LINUX_SUSPEND_BLOCK_H
 #define _LINUX_SUSPEND_BLOCK_H
 
-/* A suspend_blocker prevents the system from entering suspend when active.
+/**
+ * struct suspend_blocker - the basic suspend_blocker structure
+ * @flags:     Tracks initialized and active state.
+ * @name:      Name used for debugging.
+ *
+ * When a suspend_blocker is active it prevents the system from entering
+ * suspend.
+ *
+ * The suspend_blocker structure must be initialized by suspend_blocker_init()
  */
 
 struct suspend_blocker {
@@ -32,17 +40,7 @@ void suspend_blocker_init(struct suspend_blocker

*blocker, const char *name);
void suspend_blocker_destroy(struct suspend_blocker *blocker); void suspend_block(struct suspend_blocker *blocker);
void suspend_unblock(struct suspend_blocker *blocker);
-
-/* is_blocking_suspend returns true if the suspend_blocker is currently active.
- */
bool is_blocking_suspend(struct suspend_blocker *blocker);
-
-/* suspend_is_blocked can be used by generic power management code to abort
- * suspend.
- *
- * To preserve backward compatibility suspend_is_blocked returns 0 unless it
- * is called during suspend initiated from the suspend_block code.
- */
bool suspend_is_blocked(void);

#else

kernel/power/suspend_block.c +31 -25

86 lines not on this page · raw message

#20 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

Hi!

Quoted 14 lines
Quoted 13 lines

Review static void suspend_finish(void) · line 401

Quoted 10 lines
(quoted diff) +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
  static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+     [PM_SUSPEND_ON]         = "on",
+#endif
       [PM_SUSPEND_STANDBY]    = "standby",
       [PM_SUSPEND_MEM]        = "mem",
  };

This allows you to write "on" to the other interfaces where that makes no sense.... right?

Quoted 1 line

state_store starts iterating at PM_SUSPEND_STANDBY, so don't think so.

Good.

Quoted 9 lines
Quoted 8 lines

Review

Quoted 6 lines
(quoted diff) +6 -0
+bool suspend_is_blocked(void)
+{
+     if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+             return 0;
+     return !!atomic_read(&suspend_block_count);
+}

Yes, if enable_suspend_blockers is one, we are in deep trouble.

Quoted 3 lines

It just means that you compiled suspend blocker support into the kernel, but used an old interface to enter suspend. It warns if enable_suspend_blockers is 0 not 1.

I do not think WARN_ONCE() should be that easy to trigger. WARN is very scary animal; better use normal printk?

Quoted 6 lines
Quoted 6 lines
Quoted 5 lines

+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name:    The name of the suspend blocker to show in
+ *           /proc/suspend_blockers

Quoted 6 lines
Quoted 1 line

I don't think suspend_blockers should go to /proc. They are not process-related.

I moved that comment to the stats patch. It is still in procfs though, as it is most similar to other procfs entries. It is not allowed under the sysfs rules, and we do not want to enable debugfs on a production system since it exposes some unsafe interfaces.

You have to sort this out somehow. It does not belong to /proc.

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#25 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Arve Hjønnevåg

Hi!

Quoted 15 lines
Quoted 5 lines
Quoted 5 lines
kernel/power/power.h +0 -0
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
  {
  }
Quoted 9 lines

kernel/power/power.h static inline void suspend_thaw_processes(void) · line 230

Quoted 6 lines
kernel/power/power.h +5 -0
  #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif

Is the #ifdef really necessary?

Quoted 2 lines

No, but it gives a compile error instead of a link error if you call request_suspend_state when it is not available so it is useful.

I believe #ifdef is too ugly and link error is really good enough.

Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#21 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Pavel Machek
Quoted 30 lines · Pavel Machek

Hi!

Quoted 14 lines
Quoted 13 lines

Review static void suspend_finish(void) · line 401

Quoted 10 lines
(quoted diff) +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
 static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+     [PM_SUSPEND_ON]         = "on",
+#endif
      [PM_SUSPEND_STANDBY]    = "standby",
      [PM_SUSPEND_MEM]        = "mem",
 };

This allows you to write "on" to the other interfaces where that makes no sense.... right?

Quoted 1 line

state_store starts iterating at PM_SUSPEND_STANDBY, so don't think so.

Good.

Quoted 9 lines
Quoted 8 lines

Review

Quoted 6 lines
(quoted diff) +6 -0
+bool suspend_is_blocked(void)
+{
+     if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+             return 0;
+     return !!atomic_read(&suspend_block_count);
+}

Yes, if enable_suspend_blockers is one, we are in deep trouble.

Quoted 6 lines
Quoted 3 lines

It just means that you compiled suspend blocker support into the kernel, but used an old interface to enter suspend. It warns if enable_suspend_blockers is 0 not 1.

I do not think WARN_ONCE() should be that easy to trigger. WARN is very scary animal; better use normal printk?

Yes, printk() please.

Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines

+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name: The name of the suspend blocker to show in
+ * /proc/suspend_blockers

Quoted 8 lines
Quoted 6 lines
Quoted 1 line

I don't think suspend_blockers should go to /proc. They are not process-related.

I moved that comment to the stats patch. It is still in procfs though, as it is most similar to other procfs entries. It is not allowed under the sysfs rules, and we do not want to enable debugfs on a production system since it exposes some unsafe interfaces.

You have to sort this out somehow. It does not belong to /proc.

Agreed.

Thanks,
Rafael

#23 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Arve Hjønnevåg
Quoted 4 lines · Arve Hjønnevåg

Adds /sys/power/request_state, a non-blocking interface that specifies which suspend state to enter when no suspend blockers are active. A special state, "on", stops the process by activating the "main" suspend blocker.

Finally I have some time to look at this more thoroughly, sorry for the long delay.

I'll try not to repeate the others' comments, but I guess that may not be totally avoidable.

Quoted 20 lines
---
 Documentation/power/suspend-blockers.txt |   76 +++++++++
 include/linux/suspend_block.h            |   61 +++++++
 kernel/power/Kconfig                     |   10 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/main.c                      |   62 +++++++
 kernel/power/power.h                     |    6 +
 kernel/power/suspend_block.c             |  257 ++++++++++++++++++++++++++++++
 7 files changed, 473 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/suspend-blockers.txt
 create mode 100755 include/linux/suspend_block.h
 create mode 100644 kernel/power/suspend_block.c
Documentation/power/suspend-blockers.txt new file +0 -0
new file mode 100644
index 0000000..743b870

Documentation/power/suspend-blockers.txt line 4

Quoted 4 lines
Documentation/power/suspend-blockers.txt new file +4 -0
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.

I'd say "suspend blocker", without the underscore.

Also, I'd try to provide a general explanation of how this is supposed to work here, as an introduction. Something like:

"Suspend blockers provide a mechanism allowing device drivers and user space processes to prevent the system from entering a sleep state, such as the ACPI S3 state.

To use a suspend blocker, a device driver needs a struct suspend_blocker object that has to be initialized with the help of suspend_blocker_init(). When no longer needed, the suspend blocker must be garbage collected with the help of suspend_blocker_destroy().

A suspend blocker is activated using suspend_block(), which prevents the system from entering any sleep state until the suspend blocker is deactivated with suspend_unblock(). Many suspend blockers may be used simultaneously and the system is prevented from entering sleep states as long as at least one of them is active."

BTW, I don't really like the names "suspend_block" and "suspend_unblock". See below for possible alternatives.

Documentation/power/suspend-blockers.txt

Quoted 5 lines
Documentation/power/suspend-blockers.txt new file +5 -0
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend

Surely suspend_block() ?

Quoted 2 lines

from a sysdev suspend handler you must also return an error from +that handler to abort suspend.

Well, if a sysdev suspend handler returns an error code, suspend will be aborted anyway, so I'm not sure what the point in using suspend blockers from sysdev suspend handlers really is. Perhaps it's better to say "don't use suspend blockers from withing sysdev suspend handlers"?

Quoted 1 line

+

I'd say "For example" here.

Quoted 40 lines
Documentation/power/suspend-blockers.txt new file +40 -0
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on. Use set_irq_wake or a platform
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+	struct suspend_blocker suspend_blocker;
+}
+
+init() {
+	suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}

Documentation/power/suspend-blockers.txt line 62

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +10 -0
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+
+uninit() {
+	suspend_blocker_destroy(&state->suspend_blocker);
+}
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+	suspend_block(&state->suspend_blocker);

suspend_blocker_activate() ?
suspend_blocker_enable() ?
suspend_blocker_start() ?

Documentation/power/suspend-blockers.txt line 65

Quoted 3 lines
Documentation/power/suspend-blockers.txt new file +3 -0
+
+When it no longer needs to run it calls suspend_unblock:
+	suspend_unblock(&state->suspend_blocker);

suspend_blocker_deactivate() ?
suspend_blocker_disable() ?
suspend_blocker_finish() ?

include/linux/suspend_block.h

Quoted 16 lines
Documentation/power/suspend-blockers.txt new file +11 -0
+
+Calling suspend_block when the suspend blocker is active or suspend_unblock when
+it is not active has no effect. This allows drivers to update their state and
+call suspend suspend_block or suspend_unblock based on the result.
+For instance:
+
+if (list_empty(&state->pending_work))
+	suspend_unblock(&state->suspend_blocker);
+else
+	suspend_block(&state->suspend_blocker);
+
include/linux/suspend_block.h new file +0 -0
new file mode 100755
index 0000000..7820c60

suspend_blockers.h perhaps?

Quoted 8 lines
include/linux/suspend_block.h new file +7 -0
@@ -0,0 +1,61 @@
+/* include/linux/suspend_block.h
+ *
+ * Copyright (C) 2007-2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.

include/linux/suspend_block.h line 17

Quoted 10 lines
include/linux/suspend_block.h new file +10 -0
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_H
+#define _LINUX_SUSPEND_BLOCK_H

SUSPEND_BLOCKERS_H ?

include/linux/suspend_block.h line 23

Quoted 6 lines
include/linux/suspend_block.h new file +6 -0
+
+/* A suspend_blocker prevents the system from entering suspend when active.
+ */
+
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK

CONFIG_SUSPEND_BLOCKERS ?

Quoted 5 lines
include/linux/suspend_block.h new file +5 -0
+	atomic_t            flags;
+	const char         *name;
+#endif
+};
+

include/linux/suspend_block.h line 38

Quoted 10 lines
include/linux/suspend_block.h new file +10 -0
+#ifdef CONFIG_SUSPEND_BLOCK
+
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
+void suspend_blocker_destroy(struct suspend_blocker *blocker);
+void suspend_block(struct suspend_blocker *blocker);
+void suspend_unblock(struct suspend_blocker *blocker);
+
+/* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker);

suspend_blocker_is_active() ?
suspend_blocker_enabled() ?

Quoted 28 lines
include/linux/suspend_block.h new file +23 -0
+
+/* suspend_is_blocked can be used by generic power management code to abort
+ * suspend.
+ *
+ * To preserve backward compatibility suspend_is_blocked returns 0 unless it
+ * is called during suspend initiated from the suspend_block code.
+ */
+bool suspend_is_blocked(void);
+
+#else
+
+static inline void suspend_blocker_init(struct suspend_blocker *blocker,
+					const char *name) {}
+static inline void suspend_blocker_destroy(struct suspend_blocker *blocker) {}
+static inline void suspend_block(struct suspend_blocker *blocker) {}
+static inline void suspend_unblock(struct suspend_blocker *blocker) {}
+static inline bool is_blocking_suspend(struct suspend_blocker *bl) { return 0; }
+static inline bool suspend_is_blocked(void) { return 0; }
+
+#endif
+
+#endif
+
kernel/power/Kconfig +0 -0
index 23bd4da..9d1df13 100644

kernel/power/Kconfig config SUSPEND_FREEZER · line 122

Quoted 7 lines
kernel/power/Kconfig +4 -0
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 
 	  Turning OFF this setting is NOT recommended! If in doubt, say Y.
 
+config SUSPEND_BLOCK
+	bool "Suspend block"
+	depends on PM
+	select RTC_LIB

depends on RTC_LIB

select doesn't really work and I don't think it ever will.

kernel/power/Kconfig config SUSPEND_FREEZER

Quoted 3 lines
kernel/power/Kconfig +3 -0
+	default n
+	---help---
+	  Enable suspend_block.

Enable suspend blockers.

kernel/power/Kconfig config SUSPEND_FREEZER · line 127

Quoted 3 lines

When user space requests a sleep state through

kernel/power/Kconfig +2 -0
+	  /sys/power/request_state, the requested sleep state will be entered
+	  when no suspend_blockers are active.

Well, if you don't want suspend blockers to block suspend started via /sys/power/state, it's worth making it crystal clear in the documentation too.

Quoted 29 lines
kernel/power/Kconfig +1 -0
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 720ea4f..29cdc9e 100644
@@ -6,6 +6,7 @@ endif
 obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
+obj-$(CONFIG_SUSPEND_BLOCK)	+= suspend_block.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/main.c +1 -0
index c9632f8..e4c6b20 100644
@@ -22,6 +22,7 @@
 #include <linux/freezer.h>
 #include <linux/vmstat.h>
 #include <linux/syscalls.h>
+#include <linux/suspend_block.h>
 
 #include "power.h"
 

kernel/power/main.c static void suspend_finish(void) · line 398

Quoted 6 lines
kernel/power/main.c +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
 static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+	[PM_SUSPEND_ON]		= "on",
+#endif

Why #ifdef?

Quoted 80 lines
kernel/power/main.c +58 -0
 	[PM_SUSPEND_STANDBY]	= "standby",
 	[PM_SUSPEND_MEM]	= "mem",
 };
@@ -540,6 +544,61 @@ static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 
 power_attr(state);
 
+/**
+ *	request_state - control system power state.
+ *
+ *	This is similar to state, but it does not block until the system
+ *	resumes, and it will try to re-enter the state until another state is
+ *	requested. Suspend blockers are respected and the requested state will
+ *	only be entered when no suspend blockers are active.
+ *	Write "on" to cancel.
+ */
+
+#ifdef CONFIG_SUSPEND_BLOCK
+static ssize_t request_state_show(struct kobject *kobj,
+				  struct kobj_attribute *attr, char *buf)
+{
+	char *s = buf;
+	int i;
+
+	for (i = 0; i < PM_SUSPEND_MAX; i++) {
+		if (pm_states[i] && (i == PM_SUSPEND_ON || valid_state(i)))
+			s += sprintf(s, "%s ", pm_states[i]);
+	}
+	if (s != buf)
+		/* convert the last space to a newline */
+		*(s-1) = '\n';
+	return (s - buf);
+}
+
+static ssize_t request_state_store(struct kobject *kobj,
+				   struct kobj_attribute *attr,
+				   const char *buf, size_t n)
+{
+	suspend_state_t state = PM_SUSPEND_ON;
+	const char * const *s;
+	char *p;
+	int len;
+	int error = -EINVAL;
+
+	p = memchr(buf, '\n', n);
+	len = p ? p - buf : n;
+
+	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
+		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
+			break;
+	}
+	if (state < PM_SUSPEND_MAX && *s)
+		if (state == PM_SUSPEND_ON || valid_state(state)) {
+			error = 0;
+			request_suspend_state(state);
+		}
+	return error ? error : n;
+}
+
+power_attr(request_state);
+#endif /* CONFIG_SUSPEND_BLOCK */
+
 #ifdef CONFIG_PM_TRACE
 int pm_trace_enabled;
 
@@ -567,6 +626,9 @@ power_attr(pm_trace);
 
 static struct attribute * g[] = {
 	&state_attr.attr,
+#ifdef CONFIG_SUSPEND_BLOCK
+	&request_state_attr.attr,
+#endif
 #ifdef CONFIG_PM_TRACE
 	&pm_trace_attr.attr,
 #endif
kernel/power/power.h +0 -0
index 46b5ec7..2414a74 100644

kernel/power/power.h static inline void suspend_thaw_processes(void) · line 230

Quoted 8 lines
kernel/power/power.h +5 -0
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
 {
 }
 #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif

Is the #ifdef really necessary?

Quoted 53 lines
kernel/power/power.h +1 -0
+
kernel/power/suspend_block.c new file +46 -0
new file mode 100644
index 0000000..b4f2191
@@ -0,0 +1,257 @@
+/* kernel/power/suspend_block.c
+ *
+ * Copyright (C) 2005-2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/suspend.h>
+#include <linux/suspend_block.h>
+#include <linux/sysdev.h>
+#include "power.h"
+
+enum {
+	DEBUG_EXIT_SUSPEND = 1U << 0,
+	DEBUG_WAKEUP = 1U << 1,
+	DEBUG_USER_STATE = 1U << 2,
+	DEBUG_SUSPEND = 1U << 3,
+	DEBUG_SUSPEND_BLOCKER = 1U << 4,
+};
+static int debug_mask = DEBUG_EXIT_SUSPEND | DEBUG_WAKEUP | DEBUG_USER_STATE;
+module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
+
+#define SB_INITIALIZED            (1U << 8)
+#define SB_ACTIVE                 (1U << 9)
+
+static DEFINE_SPINLOCK(state_lock);
+static atomic_t suspend_block_count;
+static atomic_t current_event_num;
+struct workqueue_struct *suspend_work_queue;
+struct suspend_blocker main_suspend_blocker;
+static suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
+static bool enable_suspend_blockers;
+
+bool suspend_is_blocked(void)
+{
+	if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))

kernel/power/suspend_block.c line 56

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+		return 0;
+	return !!atomic_read(&suspend_block_count);
+}
+
+static void suspend_worker(struct work_struct *work)
+{
+	int ret;
+	int entry_event_num;
+
+	enable_suspend_blockers = 1;

'true' instead of '1', please.

kernel/power/suspend_block.c line 62

Quoted 6 lines
kernel/power/suspend_block.c new file +6 -0
+
+retry:
+	if (suspend_is_blocked()) {
+		if (debug_mask & DEBUG_SUSPEND)
+			pr_info("suspend: abort suspend\n");
+		goto abort;

If that were in a loop you could just use 'break' here.

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+	}
+
+	entry_event_num = atomic_read(&current_event_num);
+	if (debug_mask & DEBUG_SUSPEND)
+		pr_info("suspend: enter suspend\n");
+	ret = pm_suspend(requested_suspend_state);
+	if (debug_mask & DEBUG_EXIT_SUSPEND) {
+		struct timespec ts;
+		struct rtc_time tm;
+		getnstimeofday(&ts);

kernel/power/suspend_block.c line 82

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+		rtc_time_to_tm(ts.tv_sec, &tm);
+		pr_info("suspend: exit suspend, ret = %d "
+			"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+	}
+	if (atomic_read(&current_event_num) == entry_event_num) {
+		if (debug_mask & DEBUG_SUSPEND)
+			pr_info("suspend: pm_suspend returned with no event\n");
+		goto retry;

Put that into a loop and use 'continue' here? Or use 'break' to go out of the loop?

kernel/power/suspend_block.c line 85

Quoted 3 lines
kernel/power/suspend_block.c new file +3 -0
+	}
+abort:
+	enable_suspend_blockers = 0;

'false' instead of '0', please.

Quoted 9 lines
kernel/power/suspend_block.c new file +9 -0
+}
+static DECLARE_WORK(suspend_work, suspend_worker);
+
+static int suspend_block_suspend(struct sys_device *dev, pm_message_t state)
+{
+	int ret = suspend_is_blocked() ? -EAGAIN : 0;
+	if (debug_mask & DEBUG_SUSPEND)
+		pr_info("suspend_block_suspend return %d\n", ret);
+	return ret;

kernel/power/suspend_block.c line 104

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+}
+
+static struct sysdev_class suspend_block_sysclass = {
+	.name = "suspend_block",
+	.suspend = suspend_block_suspend,
+};
+static struct sys_device suspend_block_sysdev = {
+	.cls = &suspend_block_sysclass,
+};
+

Hmm. Perhaps add the suspend_is_blocked() check at the beginning of sysdev_suspend() instead of this? Surely you don't want to suspend any sysdevs with any suspend blockers active, right?

kernel/power/suspend_block.c line 115

Quoted 11 lines
kernel/power/suspend_block.c new file +11 -0
+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker:	The suspend blocker to initialize.
+ * @name:	The name of the suspend blocker to show in
+ *		/proc/suspend_blockers
+ */
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name)
+{
+	if (name)
+		blocker->name = name;
+	BUG_ON(!blocker->name);

Do you really want to crash the kernel in this case? WARN_ON() might be better IMO.

Also, this assumes that the caller won't release the memory used to store the 'name' string. it might be a good idea to point that out in the kerneldoc comment.

Quoted 23 lines
kernel/power/suspend_block.c new file +23 -0
+
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_blocker_init name=%s\n", blocker->name);
+
+	atomic_set(&blocker->flags, SB_INITIALIZED);
+}
+EXPORT_SYMBOL(suspend_blocker_init);
+
+/**
+ * suspend_blocker_destroy() - Destroy a suspend blocker
+ * @blocker:	The suspend blocker to destroy.
+ */
+void suspend_blocker_destroy(struct suspend_blocker *blocker)
+{
+	int flags;
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_blocker_destroy name=%s\n", blocker->name);
+	flags = atomic_xchg(&blocker->flags, 0);
+	WARN(!(flags & SB_INITIALIZED), "suspend_blocker_destroy called on "
+					"uninitialized suspend_blocker\n");
+	if (flags == (SB_INITIALIZED | SB_ACTIVE))
+		if (atomic_dec_and_test(&suspend_block_count))
+			queue_work(suspend_work_queue, &suspend_work);

kernel/power/suspend_block.c line 148

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+}
+EXPORT_SYMBOL(suspend_blocker_destroy);
+
+/**
+ * suspend_block() - Block suspend
+ * @blocker:	The suspend blocker to use
+ */
+void suspend_block(struct suspend_blocker *blocker)
+{
+	BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED));

WARN_ON() and exit instead? BUG_ON() is a bit drastic IMHO.

Quoted 26 lines
kernel/power/suspend_block.c new file +26 -0
+
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_block: %s\n", blocker->name);
+	if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED,
+	    SB_INITIALIZED | SB_ACTIVE) == SB_INITIALIZED)
+		atomic_inc(&suspend_block_count);
+
+	atomic_inc(&current_event_num);
+}
+EXPORT_SYMBOL(suspend_block);
+
+/**
+ * suspend_unblock() - Unblock suspend
+ * @blocker:	The suspend blocker to unblock.
+ *
+ * If no other suspend blockers block suspend, the system will suspend.
+ */
+void suspend_unblock(struct suspend_blocker *blocker)
+{
+	if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+		pr_info("suspend_unblock: %s\n", blocker->name);
+
+	if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED | SB_ACTIVE,
+	    SB_INITIALIZED) == (SB_INITIALIZED | SB_ACTIVE))
+		if (atomic_dec_and_test(&suspend_block_count))
+			queue_work(suspend_work_queue, &suspend_work);

kernel/power/suspend_block.c line 184

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+}
+EXPORT_SYMBOL(suspend_unblock);
+
+/**
+ * is_blocking_suspend() - Test if a suspend blocker is blocking suspend
+ * @blocker:	The suspend blocker to check.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker)
+{
+	return !!(atomic_read(&blocker->flags) & SB_ACTIVE);

Check SB_INITIALIZED too, perhaps? WARN_ON(!SB_INITIALIZED)?

Quoted 37 lines
kernel/power/suspend_block.c new file +37 -0
+}
+EXPORT_SYMBOL(is_blocking_suspend);
+
+void request_suspend_state(suspend_state_t state)
+{
+	unsigned long irqflags;
+	spin_lock_irqsave(&state_lock, irqflags);
+	if (debug_mask & DEBUG_USER_STATE) {
+		struct timespec ts;
+		struct rtc_time tm;
+		getnstimeofday(&ts);
+		rtc_time_to_tm(ts.tv_sec, &tm);
+		pr_info("request_suspend_state: %s (%d->%d) at %lld "
+			"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
+			state != PM_SUSPEND_ON ? "sleep" : "wakeup",
+			requested_suspend_state, state,
+			ktime_to_ns(ktime_get()),
+			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+	}
+	requested_suspend_state = state;
+	if (state == PM_SUSPEND_ON)
+		suspend_block(&main_suspend_blocker);
+	else
+		suspend_unblock(&main_suspend_blocker);
+	spin_unlock_irqrestore(&state_lock, irqflags);
+}
+
+static int __init suspend_block_init(void)
+{
+	int ret;
+
+	suspend_blocker_init(&main_suspend_blocker, "main");
+	suspend_block(&main_suspend_blocker);
+
+	ret = sysdev_class_register(&suspend_block_sysclass);
+	if (ret) {

kernel/power/suspend_block.c line 231

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+		pr_err("suspend_block_init: sysdev_class_register failed\n");
+		goto err_sysdev_class_register;
+	}
+	ret = sysdev_register(&suspend_block_sysdev);
+	if (ret) {
+		pr_err("suspend_block_init: suspend_block_sysdev failed\n");
+		goto err_sysdev_register;
+	}
+
+	suspend_work_queue = create_singlethread_workqueue("suspend");

Do we need a separate workqueue for this purpose?

Quoted 16 lines
kernel/power/suspend_block.c new file +16 -0
+	if (suspend_work_queue == NULL) {
+		ret = -ENOMEM;
+		goto err_suspend_work_queue;
+	}
+
+	return 0;
+
+err_suspend_work_queue:
+	sysdev_unregister(&suspend_block_sysdev);
+err_sysdev_register:
+	sysdev_class_unregister(&suspend_block_sysclass);
+err_sysdev_class_register:
+	suspend_blocker_destroy(&main_suspend_blocker);
+	return ret;
+}
+

kernel/power/suspend_block.c line 257

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+static void  __exit suspend_block_exit(void)
+{
+	destroy_workqueue(suspend_work_queue);
+	sysdev_unregister(&suspend_block_sysdev);
+	sysdev_class_unregister(&suspend_block_sysclass);
+	suspend_blocker_destroy(&main_suspend_blocker);
+}
+
+core_initcall(suspend_block_init);
+module_exit(suspend_block_exit);

Thanks,
Rafael
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm

#22 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Rafael J. Wysocki
Quoted 31 lines · Rafael J. Wysocki
Quoted 30 lines · Pavel Machek

Hi!

Quoted 14 lines
Quoted 13 lines

Review static void suspend_finish(void) · line 401

Quoted 10 lines
(quoted diff) +3 -0
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
  static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+     [PM_SUSPEND_ON]         = "on",
+#endif
       [PM_SUSPEND_STANDBY]    = "standby",
       [PM_SUSPEND_MEM]        = "mem",
  };

This allows you to write "on" to the other interfaces where that makes no sense.... right?

Quoted 1 line

state_store starts iterating at PM_SUSPEND_STANDBY, so don't think so.

Good.

Quoted 9 lines
Quoted 8 lines

Review

Quoted 6 lines
(quoted diff) +6 -0
+bool suspend_is_blocked(void)
+{
+     if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+             return 0;
+     return !!atomic_read(&suspend_block_count);
+}

Yes, if enable_suspend_blockers is one, we are in deep trouble.

Quoted 8 lines
Quoted 6 lines
Quoted 3 lines

It just means that you compiled suspend blocker support into the kernel, but used an old interface to enter suspend. It warns if enable_suspend_blockers is 0 not 1.

I do not think WARN_ONCE() should be that easy to trigger. WARN is very scary animal; better use normal printk?

Yes, printk() please.

Using printk instead of WARN_ONCE would be much more verbose, so I removed it instead.

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
Quoted 6 lines

+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name:    The name of the suspend blocker to show in
+ *           /proc/suspend_blockers

I don't think suspend_blockers should go to /proc. They are not process-related.

Quoted 8 lines
Quoted 6 lines
Quoted 4 lines

I moved that comment to the stats patch. It is still in procfs though, as it is most similar to other procfs entries. It is not allowed under the sysfs rules, and we do not want to enable debugfs on a production system since it exposes some unsafe interfaces.

You have to sort this out somehow. It does not belong to /proc.

Agreed.

OK. I moved it to debugfs.

Signature · 1 line
Arve Hjønnevåg
#10 lore raw

Re: [PATCH 2/8] PM: suspend_block: Add driver to access suspend blockers from user-space

In reply to Arve Hjønnevåg
Quoted 2 lines · Arve Hjønnevåg

Adds ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device.

The changelog is minimalistic, so to speak.

Can you please describe the idea in more detail in it?

Also, perhaps you could use write() to initialize the suspend blocker? I don't know really, it's just a thought.

You might not need ioctls() at all if you used write() like write(name) -> initialize
write(1) -> activate
write(0) -> deactivate
write(1) -> activate
write(0) -> deactivate
etc.
read() -> check status (0 -> inactive, 1 -> active) or something like this.

It might be extended for timeouts too. ;-)

Quoted 230 lines
---
 Documentation/power/suspend-blockers.txt |   17 ++++
 include/linux/suspend_block_dev.h        |   25 ++++++
 kernel/power/Kconfig                     |    9 ++
 kernel/power/Makefile                    |    1 +
 kernel/power/user_suspend_block.c        |  125 ++++++++++++++++++++++++++++++
 5 files changed, 177 insertions(+), 0 deletions(-)
 create mode 100644 include/linux/suspend_block_dev.h
 create mode 100644 kernel/power/user_suspend_block.c
Documentation/power/suspend-blockers.txt +17 -0
index 743b870..35bc713 100644
@@ -74,3 +74,20 @@ if (list_empty(&state->pending_work))
 else
 	suspend_block(&state->suspend_blocker);
 
+User-space API
+==============
+
+To create a suspend_blocker from user-space, open the suspend_blocker device:
+    fd = open("/dev/suspend_blocker", O_RDWR | O_CLOEXEC);
+then call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_INIT(strlen(name)), name);
+
+To activate a suspend_blocker call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK);
+
+To unblock call:
+    ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK);
+
+To destroy the suspend_blocker, close the device:
+    close(fd);
+
include/linux/suspend_block_dev.h new file +25 -0
new file mode 100644
index 0000000..a7c0bf9
@@ -0,0 +1,25 @@
+/* include/linux/suspend_block_dev.h
+ *
+ * Copyright (C) 2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_DEV_H
+#define _LINUX_SUSPEND_BLOCK_DEV_H
+
+#include <linux/ioctl.h>
+
+#define SUSPEND_BLOCKER_IOCTL_INIT(len)		_IOC(_IOC_WRITE, 's', 0, len)
+#define SUSPEND_BLOCKER_IOCTL_BLOCK		_IO('s', 1)
+#define SUSPEND_BLOCKER_IOCTL_UNBLOCK		_IO('s', 3)
+
+#endif
kernel/power/Kconfig +9 -0
index 9d1df13..2cf4c4d 100644
@@ -126,6 +126,15 @@ config SUSPEND_BLOCK
 	  /sys/power/request_state, the requested sleep state will be entered
 	  when no suspend_blockers are active.
 
+config USER_SUSPEND_BLOCK
+	bool "Userspace suspend blockers"
+	depends on SUSPEND_BLOCK
+	default y
+	---help---
+	  User-space suspend block api. Creates a misc device with ioctls
+	  to create, block and unblock a suspend_blocker. The suspend_blocker
+	  will be deleted when the device is closed.
+
 config HIBERNATION
 	bool "Hibernation (aka 'suspend to disk')"
 	depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE
kernel/power/Makefile +1 -0
index 29cdc9e..5c524f1 100644
@@ -7,6 +7,7 @@ obj-$(CONFIG_PM)		+= main.o
 obj-$(CONFIG_PM_SLEEP)		+= console.o
 obj-$(CONFIG_FREEZER)		+= process.o
 obj-$(CONFIG_SUSPEND_BLOCK)	+= suspend_block.o
+obj-$(CONFIG_USER_SUSPEND_BLOCK)	+= user_suspend_block.o
 obj-$(CONFIG_HIBERNATION)	+= swsusp.o disk.o snapshot.o swap.o user.o
 
 obj-$(CONFIG_MAGIC_SYSRQ)	+= poweroff.o
kernel/power/user_suspend_block.c new file +125 -0
new file mode 100644
index 0000000..782407c
@@ -0,0 +1,125 @@
+/* kernel/power/user_suspend_block.c
+ *
+ * Copyright (C) 2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/suspend_block.h>
+#include <linux/suspend_block_dev.h>
+
+enum {
+	DEBUG_FAILURE	= BIT(0),
+};
+static int debug_mask = DEBUG_FAILURE;
+module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
+
+static DEFINE_MUTEX(ioctl_lock);
+
+struct user_suspend_blocker {
+	struct suspend_blocker	blocker;
+	char			name[0];
+};
+
+static int create_user_suspend_blocker(struct file *file, void __user *name,
+				 size_t name_len)
+{
+	struct user_suspend_blocker *bl;
+	if (file->private_data)
+		return -EBUSY;
+	bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL);
+	if (!bl)
+		return -ENOMEM;
+	if (copy_from_user(bl->name, name, name_len))
+		goto err_fault;
+	suspend_blocker_init(&bl->blocker, bl->name);
+	file->private_data = bl;
+	return 0;
+
+err_fault:
+	kfree(bl);
+	return -EFAULT;
+}
+
+static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd,
+				unsigned long _arg)
+{
+	void __user *arg = (void __user *)_arg;
+	struct user_suspend_blocker *bl;
+	long ret;
+
+	mutex_lock(&ioctl_lock);
+	if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_INIT(0)) {
+		ret = create_user_suspend_blocker(file, arg, _IOC_SIZE(cmd));
+		goto done;
+	}
+	bl = file->private_data;
+	if (!bl) {
+		ret = -ENOENT;
+		goto done;
+	}
+	switch (cmd) {
+	case SUSPEND_BLOCKER_IOCTL_BLOCK:
+		suspend_block(&bl->blocker);
+		ret = 0;
+		break;
+	case SUSPEND_BLOCKER_IOCTL_UNBLOCK:
+		suspend_unblock(&bl->blocker);
+		ret = 0;
+		break;
+	default:
+		ret = -ENOTSUPP;
+	}
+done:
+	if (ret && debug_mask & DEBUG_FAILURE)
+		pr_err("user_suspend_blocker_ioctl: cmd %x failed, %ld\n",
+			cmd, ret);
+	mutex_unlock(&ioctl_lock);
+	return ret;
+}
+
+static int user_suspend_blocker_release(struct inode *inode, struct file *file)
+{
+	struct user_suspend_blocker *bl = file->private_data;
+	if (!bl)
+		return 0;
+	suspend_blocker_destroy(&bl->blocker);
+	kfree(bl);
+	return 0;
+}
+
+const struct file_operations user_suspend_blocker_fops = {
+	.release = user_suspend_blocker_release,
+	.unlocked_ioctl = user_suspend_blocker_ioctl,
+};
+
+struct miscdevice user_suspend_blocker_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "suspend_blocker",
+	.fops = &user_suspend_blocker_fops,
+};
+
+static int __init user_suspend_blocker_init(void)
+{
+	return misc_register(&user_suspend_blocker_device);
+}
+
+static void __exit user_suspend_blocker_exit(void)
+{
+	misc_deregister(&user_suspend_blocker_device);
+}
+
+module_init(user_suspend_blocker_init);
+module_exit(user_suspend_blocker_exit);
Signature · 7 lines
Everyone knows that debugging is twice as hard as writing a program
in the first place.  So if you're as clever as you can be when you write it,
how will you ever debug it? --- Brian Kernighan
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#9 lore raw

Re: [PATCH 3/8] PM: suspend_block: Abort task freezing if a suspend_blocker is active.

In reply to Arve Hjønnevåg
Quoted 27 lines · Arve Hjønnevåg

If a suspend_blocker is active, suspend will fail anyway. Since try_to_freeze_tasks can take up to 20 seconds to complete or fail, aborting as soon as someone blocks suspend (e.g. from an interrupt handler) improves the worst case wakeup latency.

On an older kernel where task freezing could fail for processes attached to a debugger, this fixed a problem where the device sometimes hung for 20 seconds before the screen turned on.

---
 kernel/power/process.c |   23 ++++++++++++++++++-----
 1 files changed, 18 insertions(+), 5 deletions(-)
kernel/power/process.c +1 -0
index ca63401..76d7cdb 100644
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/freezer.h>
+#include <linux/suspend_block.h>
 
 /* 
  * Timeout for stopping processes

kernel/power/process.c static int try_to_freeze_tasks(bool sig_only) · line 40

Quoted 4 lines
kernel/power/process.c +1 -0
@@ -36,6 +37,7 @@ static int try_to_freeze_tasks(bool sig_only)
 	struct timeval start, end;
 	u64 elapsed_csecs64;
 	unsigned int elapsed_csecs;
+	unsigned int wakeup = 0;

Make it a bool, please.

kernel/power/process.c static int try_to_freeze_tasks(bool sig_only) · line 68

Quoted 8 lines
kernel/power/process.c +2 -0
 	do_gettimeofday(&start);
 
@@ -62,6 +64,10 @@ static int try_to_freeze_tasks(bool sig_only)
 		} while_each_thread(g, p);
 		read_unlock(&tasklist_lock);
 		yield();			/* Yield is okay here */
+		if (todo && suspend_is_blocked()) {
+			wakeup = 1;

'true', please.

Quoted 6 lines
kernel/power/process.c +2 -0
+			break;
+		}
 		if (time_after(jiffies, end_time))
 			break;
 	} while (todo);

kernel/power/process.c static int try_to_freeze_tasks(bool sig_only) · line 87

Quoted 10 lines
kernel/power/process.c +2 -5
@@ -77,11 +83,18 @@ static int try_to_freeze_tasks(bool sig_only)
 		 * and caller must call thaw_processes() if something fails),
 		 * but it cleans up leftover PF_FREEZE requests.
 		 */
-		printk("\n");
-		printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
-				"(%d tasks refusing to freeze):\n",
-				elapsed_csecs / 100, elapsed_csecs % 100, todo);
-		show_state();
+		if (wakeup) {
+			printk("\n");

Why is the separate printk() necessary ?

kernel/power/process.c static int try_to_freeze_tasks(bool sig_only) · line 91

Quoted 4 lines
kernel/power/process.c +4 -0
+			printk(KERN_ERR "Freezing of %s aborted\n",
+					sig_only ? "user space " : "tasks ");
+		} else {
+			printk("\n");

Why is the separate printk() necessary ?

Quoted 9 lines
kernel/power/process.c +6 -0
+			printk(KERN_ERR
+			       "Freezing of tasks failed after %d.%02d seconds "
+			       "(%d tasks refusing to freeze):\n",
+			       elapsed_csecs / 100, elapsed_csecs % 100, todo);
+			show_state();
+		}
 		read_lock(&tasklist_lock);
 		do_each_thread(g, p) {
 			task_lock(p);
Signature · 7 lines
Everyone knows that debugging is twice as hard as writing a program
in the first place.  So if you're as clever as you can be when you write it,
how will you ever debug it? --- Brian Kernighan
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
#30 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Rafael J. Wysocki

2009/4/29 Rafael J. Wysocki <[email protected]>:

Quoted 26 lines · Arve Hjønnevåg

Documentation/power/suspend-blockers.txt line 4

Quoted 10 lines
Documentation/power/suspend-blockers.txt new file +4 -0
new file mode 100644
index 0000000..743b870
@@ -0,0 +1,76 @@
+Suspend blockers
+================
+
+A suspend_blocker prevents the system from entering suspend.

I'd say "suspend blocker", without the underscore.

Also, I'd try to provide a general explanation of how this is supposed to work here, as an introduction.  Something like:

"Suspend blockers provide a mechanism allowing device drivers and user space processes to prevent the system from entering a sleep state, such as the ACPI S3 state.

To use a suspend blocker, a device driver needs a struct suspend_blocker object that has to be initialized with the help of suspend_blocker_init().  When no longer needed, the suspend blocker must be garbage collected with the help of suspend_blocker_destroy().

Quoted 6 lines

A suspend blocker is activated using suspend_block(), which prevents the system from entering any sleep state until the suspend blocker is deactivated with suspend_unblock().  Many suspend blockers may be used simultaneously and the system is prevented from entering sleep states as long as at least one of them is active."

I added most of this, see new text below.

Quoted 10 lines

BTW, I don't really like the names "suspend_block" and "suspend_unblock". See below for possible alternatives.

Documentation/power/suspend-blockers.txt

Quoted 5 lines
Documentation/power/suspend-blockers.txt new file +5 -0
+If the suspend operation has already started when calling suspend_block on a
+suspend_blocker, it will abort the suspend operation as long it has not already
+reached the sysdev suspend stage. This means that calling suspend_block from an
+interrupt handler or a freezeable thread always works, but if you call
+block_suspend

Surely suspend_block() ?

Yes.

Quoted 8 lines
Quoted 3 lines

from a sysdev suspend handler you must also return an error from +that handler to abort suspend.

Well, if a sysdev suspend handler returns an error code, suspend will be aborted anyway, so I'm not sure what the point in using suspend blockers from sysdev suspend handlers really is.  Perhaps it's better to say "don't use suspend blockers from withing sysdev suspend handlers"?

You still need the suspend blocker to prevent the system from trying to enter suspend again. I changed the text to "to abort a suspend sequence that was already started".

Quoted 51 lines
Quoted 2 lines

+

I'd say "For example" here.

Quoted 46 lines
Documentation/power/suspend-blockers.txt new file +46 -0
+Suspend blockers can be used to allow user-space to decide which keys should
+wake the full system up and turn the screen on. Use set_irq_wake or a platform
+specific api to make sure the keypad interrupt wakes up the cpu. Once the keypad
+driver has resumed, the sequence of events can look like this:
+- The Keypad driver gets an interrupt. It then calls suspend_block on the
+  keypad-scan suspend_blocker and starts scanning the keypad matrix.
+- The keypad-scan code detects a key change and reports it to the input-event
+  driver.
+- The input-event driver sees the key change, enqueues an event, and calls
+  suspend_block on the input-event-queue suspend_blocker.
+- The keypad-scan code detects that no keys are held and calls suspend_unblock
+  on the keypad-scan suspend_blocker.
+- The user-space input-event thread returns from select/poll, calls
+  suspend_block on the process-input-events suspend_blocker and then calls read
+  on the input-event device.
+- The input-event driver dequeues the key-event and, since the queue is now
+  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
+- The user-space input-event thread returns from read. It determines that the
+  key should not wake up the full system, calls suspend_unblock on the
+  process-input-events suspend_blocker and calls select or poll.
+
+                 Key pressed   Key released
+                     |             |
+keypad-scan          ++++++++++++++++++
+input-event-queue        +++          +++
+process-input-events       +++          +++
+
+
+Driver API
+==========
+
+A driver can use the suspend block api by adding a suspend_blocker variable to
+its state and calling suspend_blocker_init. For instance:
+struct state {
+     struct suspend_blocker suspend_blocker;
+}
+
+init() {
+     suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
+}
+
+Before freeing the memory, suspend_blocker_destroy must be called:
+
+uninit() {
+     suspend_blocker_destroy(&state->suspend_blocker);
+}
Quoted 9 lines

Documentation/power/suspend-blockers.txt line 62

Quoted 4 lines
Documentation/power/suspend-blockers.txt new file +4 -0
+
+When the driver determines that it needs to run (usually in an interrupt
+handler) it calls suspend_block:
+     suspend_block(&state->suspend_blocker);

suspend_blocker_activate() ?
suspend_blocker_enable() ?
suspend_blocker_start() ?

I don't like any of those better than suspend_block, but if there is some agreement on what it should be changed to, I'll change it.

Quoted 19 lines

Documentation/power/suspend-blockers.txt line 65

Quoted 3 lines
Documentation/power/suspend-blockers.txt new file +3 -0
+
+When it no longer needs to run it calls suspend_unblock:
+     suspend_unblock(&state->suspend_blocker);

suspend_blocker_deactivate() ?
suspend_blocker_disable() ?
suspend_blocker_finish() ?

Quoted 11 lines
Documentation/power/suspend-blockers.txt new file +11 -0
+
+Calling suspend_block when the suspend blocker is active or suspend_unblock when
+it is not active has no effect. This allows drivers to update their state and
+call suspend suspend_block or suspend_unblock based on the result.
+For instance:
+
+if (list_empty(&state->pending_work))
+     suspend_unblock(&state->suspend_blocker);
+else
+     suspend_block(&state->suspend_blocker);
+
Signature · 99 lines
Arve Hjønnevåg


----

Suspend blockers
================

Suspend blockers provide a mechanism for device drivers and user-space processes
to prevent the system from entering suspend. Only suspend states requested
through /sys/power/request_state are prevented. Writing to /sys/power/state
will ignore suspend blockers, and sleep states entered from idle are unaffected.

To use a suspend blocker, a device driver needs a struct suspend_blocker object
that has to be initialized with suspend_blocker_init. When no longer needed,
the suspend blocker must be destroyed with suspend_blocker_destroy.

A suspend blocker is activated using suspend_block, which prevents the system
from entering suspend until the suspend blocker is deactivated with
suspend_unblock. Many suspend blockers may be used simultaneously, and the
system is prevented from entering suspend as long as at least one of them is
active.

If the suspend operation has already started when calling suspend_block on a
suspend_blocker, it will abort the suspend operation as long it has not already
reached the sysdev suspend stage. This means that calling suspend_block from an
interrupt handler or a freezeable thread always works, but if you call
suspend_block from a sysdev suspend handler you must also return an error from
that handler to abort a suspend sequence that was already started.

In cell phones or other embedded systems where powering the screen is a
significant drain on the battery, suspend blockers can be used to allow
user-space to decide whether a keystroke received while the system is suspended
should cause the screen to be turned back on or allow the system to go back into
suspend. Use set_irq_wake or a platform specific api to make sure the keypad
interrupt wakes up the cpu. Once the keypad driver has resumed, the sequence of
events can look like this:

- The Keypad driver gets an interrupt. It then calls suspend_block on the
  keypad-scan suspend_blocker and starts scanning the keypad matrix.
- The keypad-scan code detects a key change and reports it to the input-event
  driver.
- The input-event driver sees the key change, enqueues an event, and calls
  suspend_block on the input-event-queue suspend_blocker.
- The keypad-scan code detects that no keys are held and calls suspend_unblock
  on the keypad-scan suspend_blocker.
- The user-space input-event thread returns from select/poll, calls
  suspend_block on the process-input-events suspend_blocker and then calls read
  on the input-event device.
- The input-event driver dequeues the key-event and, since the queue is now
  empty, it calls suspend_unblock on the input-event-queue suspend_blocker.
- The user-space input-event thread returns from read. If it determines that
  the key should leave the screen off, it calls suspend_unblock on the
  process_input_events suspend_blocker and then calls select or poll. The
  system will automatically suspend again, since now no suspend blockers are
  active.

                 Key pressed   Key released
                     |             |
keypad-scan          ++++++++++++++++++
input-event-queue        +++          +++
process-input-events       +++          +++


Driver API
==========

A driver can use the suspend block api by adding a suspend_blocker variable to
its state and calling suspend_blocker_init. For instance:
struct state {
        struct suspend_blocker suspend_blocker;
}

init() {
        suspend_blocker_init(&state->suspend_blocker, "suspend-blocker-name");
}

Before freeing the memory, suspend_blocker_destroy must be called:

uninit() {
        suspend_blocker_destroy(&state->suspend_blocker);
}

When the driver determines that it needs to run (usually in an interrupt
handler) it calls suspend_block:
        suspend_block(&state->suspend_blocker);

When it no longer needs to run it calls suspend_unblock:
        suspend_unblock(&state->suspend_blocker);

Calling suspend_block when the suspend blocker is active or suspend_unblock when
it is not active has no effect. This allows drivers to update their state and
call suspend suspend_block or suspend_unblock based on the result.
For instance:

if (list_empty(&state->pending_work))
        suspend_unblock(&state->suspend_blocker);
else
        suspend_block(&state->suspend_blocker);
#24 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Rafael J. Wysocki

2009/4/29 Rafael J. Wysocki <[email protected]>:

Quoted 8 lines · Arve Hjønnevåg

include/linux/suspend_block.h

Quoted 5 lines
include/linux/suspend_block.h new file +0 -0
new file mode 100755
index 0000000..7820c60

suspend_blockers.h perhaps?

suspend_blocker.h?

Quoted 22 lines
Quoted 9 lines
include/linux/suspend_block.h new file +7 -0
@@ -0,0 +1,61 @@
+/* include/linux/suspend_block.h
+ *
+ * Copyright (C) 2007-2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.

include/linux/suspend_block.h line 17

Quoted 10 lines
include/linux/suspend_block.h new file +10 -0
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SUSPEND_BLOCK_H
+#define _LINUX_SUSPEND_BLOCK_H

SUSPEND_BLOCKERS_H ?

Quoted 8 lines

include/linux/suspend_block.h line 23

Quoted 6 lines
include/linux/suspend_block.h new file +6 -0
+
+/* A suspend_blocker prevents the system from entering suspend when active.
+ */
+
+struct suspend_blocker {
+#ifdef CONFIG_SUSPEND_BLOCK

CONFIG_SUSPEND_BLOCKERS ?

OK.

Quoted 10 lines
Quoted 10 lines
include/linux/suspend_block.h new file +9 -0
+     atomic_t            flags;
+     const char         *name;
+#endif
+};
+
+#ifdef CONFIG_SUSPEND_BLOCK
+
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name);
+void suspend_blocker_destroy(struct suspend_blocker *blocker);
Quoted 8 lines

include/linux/suspend_block.h line 38

Quoted 6 lines
include/linux/suspend_block.h new file +6 -0
+void suspend_block(struct suspend_blocker *blocker);
+void suspend_unblock(struct suspend_blocker *blocker);
+
+/* is_blocking_suspend returns true if the suspend_blocker is currently active.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker);

suspend_blocker_is_active() ?

OK.

Quoted 33 lines

suspend_blocker_enabled() ?

Quoted 31 lines
include/linux/suspend_block.h new file +23 -0
+
+/* suspend_is_blocked can be used by generic power management code to abort
+ * suspend.
+ *
+ * To preserve backward compatibility suspend_is_blocked returns 0 unless it
+ * is called during suspend initiated from the suspend_block code.
+ */
+bool suspend_is_blocked(void);
+
+#else
+
+static inline void suspend_blocker_init(struct suspend_blocker *blocker,
+                                     const char *name) {}
+static inline void suspend_blocker_destroy(struct suspend_blocker *blocker) {}
+static inline void suspend_block(struct suspend_blocker *blocker) {}
+static inline void suspend_unblock(struct suspend_blocker *blocker) {}
+static inline bool is_blocking_suspend(struct suspend_blocker *bl) { return 0; }
+static inline bool suspend_is_blocked(void) { return 0; }
+
+#endif
+
+#endif
+
kernel/power/Kconfig +0 -0
index 23bd4da..9d1df13 100644
@@ -116,6 +116,16 @@ config SUSPEND_FREEZER
 

        Turning OFF this setting is NOT recommended! If in doubt, say Y.

Quoted 8 lines
Quoted 4 lines

+config SUSPEND_BLOCK
+     bool "Suspend block"
+     depends on PM
+     select RTC_LIB

depends on RTC_LIB

select doesn't really work and I don't think it ever will.

Nothing depends on RTC_LIB, it is only selected.

Quoted 6 lines
Quoted 4 lines

+     default n
+     ---help---
+       Enable suspend_block.

Enable suspend blockers.

OK.

Quoted 7 lines
Quoted 4 lines

When user space requests a sleep state through
+       /sys/power/request_state, the requested sleep state will be entered
+       when no suspend_blockers are active.

Well, if you don't want suspend blockers to block suspend started via /sys/power/state, it's worth making it crystal clear in the documentation too.

I added this to the intro.

Quoted 32 lines
Quoted 32 lines

+
 config HIBERNATION
      bool "Hibernation (aka 'suspend to disk')" depends on PM && SWAP && ARCH_HIBERNATION_POSSIBLE

kernel/power/Makefile +0 -0
index 720ea4f..29cdc9e 100644
@@ -6,6 +6,7 @@ endif

 obj-$(CONFIG_PM)             += main.o obj-$(CONFIG_PM_SLEEP)               += console.o obj-$(CONFIG_FREEZER)                += process.o +obj-$(CONFIG_SUSPEND_BLOCK)  += suspend_block.o obj-$(CONFIG_HIBERNATION)    += swsusp.o disk.o snapshot.o swap.o user.o

 obj-$(CONFIG_MAGIC_SYSRQ)    += poweroff.o

kernel/power/main.c +1 -0
index c9632f8..e4c6b20 100644
@@ -22,6 +22,7 @@
  #include <linux/freezer.h>
  #include <linux/vmstat.h>
  #include <linux/syscalls.h>
+#include <linux/suspend_block.h>
 
  #include "power.h"
 
@@ -392,6 +393,9 @@ static void suspend_finish(void)
 
 
Quoted 6 lines

kernel/power/main.c static void suspend_finish(void) · line 398

Quoted 4 lines
kernel/power/main.c +3 -0
  static const char * const pm_states[PM_SUSPEND_MAX] = {
+#ifdef CONFIG_SUSPEND_BLOCK
+     [PM_SUSPEND_ON]         = "on",
+#endif

Why #ifdef?

Removed.

Quoted 83 lines
Quoted 83 lines
kernel/power/main.c +58 -0
       [PM_SUSPEND_STANDBY]    = "standby",
       [PM_SUSPEND_MEM]        = "mem",
  };
@@ -540,6 +544,61 @@ static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 
  power_attr(state);
 
+/**
+ *   request_state - control system power state.
+ *
+ *   This is similar to state, but it does not block until the system
+ *   resumes, and it will try to re-enter the state until another state is
+ *   requested. Suspend blockers are respected and the requested state will
+ *   only be entered when no suspend blockers are active.
+ *   Write "on" to cancel.
+ */
+
+#ifdef CONFIG_SUSPEND_BLOCK
+static ssize_t request_state_show(struct kobject *kobj,
+                               struct kobj_attribute *attr, char *buf)
+{
+     char *s = buf;
+     int i;
+
+     for (i = 0; i < PM_SUSPEND_MAX; i++) {
+             if (pm_states[i] && (i == PM_SUSPEND_ON || valid_state(i)))
+                     s += sprintf(s, "%s ", pm_states[i]);
+     }
+     if (s != buf)
+             /* convert the last space to a newline */
+             *(s-1) = '\n';
+     return (s - buf);
+}
+
+static ssize_t request_state_store(struct kobject *kobj,
+                                struct kobj_attribute *attr,
+                                const char *buf, size_t n)
+{
+     suspend_state_t state = PM_SUSPEND_ON;
+     const char * const *s;
+     char *p;
+     int len;
+     int error = -EINVAL;
+
+     p = memchr(buf, '\n', n);
+     len = p ? p - buf : n;
+
+     for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
+             if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
+                     break;
+     }
+     if (state < PM_SUSPEND_MAX && *s)
+             if (state == PM_SUSPEND_ON || valid_state(state)) {
+                     error = 0;
+                     request_suspend_state(state);
+             }
+     return error ? error : n;
+}
+
+power_attr(request_state);
+#endif /* CONFIG_SUSPEND_BLOCK */
+
  #ifdef CONFIG_PM_TRACE
  int pm_trace_enabled;
 
@@ -567,6 +626,9 @@ power_attr(pm_trace);
 
  static struct attribute * g[] = {
       &state_attr.attr,
+#ifdef CONFIG_SUSPEND_BLOCK
+     &request_state_attr.attr,
+#endif
  #ifdef CONFIG_PM_TRACE
       &pm_trace_attr.attr,
  #endif
kernel/power/power.h +0 -0
index 46b5ec7..2414a74 100644
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
  {
  }
Quoted 9 lines

kernel/power/power.h static inline void suspend_thaw_processes(void) · line 230

Quoted 6 lines
kernel/power/power.h +5 -0
  #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif

Is the #ifdef really necessary?

No, but it gives a compile error instead of a link error if you call request_suspend_state when it is not available so it is useful.

Quoted 57 lines
Quoted 57 lines
kernel/power/power.h +1 -0
+
kernel/power/suspend_block.c new file +50 -0
new file mode 100644
index 0000000..b4f2191
@@ -0,0 +1,257 @@
+/* kernel/power/suspend_block.c
+ *
+ * Copyright (C) 2005-2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/suspend.h>
+#include <linux/suspend_block.h>
+#include <linux/sysdev.h>
+#include "power.h"
+
+enum {
+     DEBUG_EXIT_SUSPEND = 1U << 0,
+     DEBUG_WAKEUP = 1U << 1,
+     DEBUG_USER_STATE = 1U << 2,
+     DEBUG_SUSPEND = 1U << 3,
+     DEBUG_SUSPEND_BLOCKER = 1U << 4,
+};
+static int debug_mask = DEBUG_EXIT_SUSPEND | DEBUG_WAKEUP | DEBUG_USER_STATE;
+module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
+
+#define SB_INITIALIZED            (1U << 8)
+#define SB_ACTIVE                 (1U << 9)
+
+static DEFINE_SPINLOCK(state_lock);
+static atomic_t suspend_block_count;
+static atomic_t current_event_num;
+struct workqueue_struct *suspend_work_queue;
+struct suspend_blocker main_suspend_blocker;
+static suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;
+static bool enable_suspend_blockers;
+
+bool suspend_is_blocked(void)
+{
+     if (WARN_ONCE(!enable_suspend_blockers, "ignoring suspend blockers\n"))
+             return 0;
+     return !!atomic_read(&suspend_block_count);
+}
+
Quoted 8 lines

kernel/power/suspend_block.c line 56

Quoted 6 lines
kernel/power/suspend_block.c new file +6 -0
+static void suspend_worker(struct work_struct *work)
+{
+     int ret;
+     int entry_event_num;
+
+     enable_suspend_blockers = 1;

'true' instead of '1', please.

OK.

Quoted 9 lines

kernel/power/suspend_block.c line 62

Quoted 7 lines
kernel/power/suspend_block.c new file +6 -0
+
+retry:
+     if (suspend_is_blocked()) {
+             if (debug_mask & DEBUG_SUSPEND)
+                     pr_info("suspend: abort suspend\n");
+             goto abort;

If that were in a loop you could just use 'break' here.

do you think this is better:

while(1) {
        if (exception1) {
                ...
                break;
        }
        ...
        if (exception2) {
                ...
                continue;
        }
        break;
}
Quoted 22 lines
Quoted 11 lines
kernel/power/suspend_block.c new file +10 -0
+     }
+
+     entry_event_num = atomic_read(&current_event_num);
+     if (debug_mask & DEBUG_SUSPEND)
+             pr_info("suspend: enter suspend\n");
+     ret = pm_suspend(requested_suspend_state);
+     if (debug_mask & DEBUG_EXIT_SUSPEND) {
+             struct timespec ts;
+             struct rtc_time tm;
+             getnstimeofday(&ts);

kernel/power/suspend_block.c line 82

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+             rtc_time_to_tm(ts.tv_sec, &tm);
+             pr_info("suspend: exit suspend, ret = %d "
+                     "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,
+                     tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                     tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+     }
+     if (atomic_read(&current_event_num) == entry_event_num) {
+             if (debug_mask & DEBUG_SUSPEND)
+                     pr_info("suspend: pm_suspend returned with no event\n");
+             goto retry;
Quoted 2 lines

Put that into a loop and use 'continue' here?  Or use 'break' to go out of the loop?

The retry is a workaround for the lack of suspend_block_timeout.

Quoted 6 lines

kernel/power/suspend_block.c line 85

Quoted 4 lines
kernel/power/suspend_block.c new file +3 -0
+     }
+abort:
+     enable_suspend_blockers = 0;

'false' instead of '0', please.

OK.

Quoted 16 lines
Quoted 16 lines
kernel/power/suspend_block.c new file +15 -0
+}
+static DECLARE_WORK(suspend_work, suspend_worker);
+
+static int suspend_block_suspend(struct sys_device *dev, pm_message_t state)
+{
+     int ret = suspend_is_blocked() ? -EAGAIN : 0;
+     if (debug_mask & DEBUG_SUSPEND)
+             pr_info("suspend_block_suspend return %d\n", ret);
+     return ret;
+}
+
+static struct sysdev_class suspend_block_sysclass = {
+     .name = "suspend_block",
+     .suspend = suspend_block_suspend,
+};
Quoted 8 lines

kernel/power/suspend_block.c line 104

Quoted 4 lines
kernel/power/suspend_block.c new file +4 -0
+static struct sys_device suspend_block_sysdev = {
+     .cls = &suspend_block_sysclass,
+};
+

Hmm.  Perhaps add the suspend_is_blocked() check at the beginning of sysdev_suspend() instead of this?  Surely you don't want to suspend any sysdevs with any suspend blockers active, right?

You could make the same argument for any device. Using a sysdev makes the patch easier to apply.

Quoted 14 lines

kernel/power/suspend_block.c line 115

Quoted 12 lines
kernel/power/suspend_block.c new file +11 -0
+/**
+ * suspend_blocker_init() - Initialize a suspend blocker
+ * @blocker: The suspend blocker to initialize.
+ * @name:    The name of the suspend blocker to show in
+ *           /proc/suspend_blockers
+ */
+void suspend_blocker_init(struct suspend_blocker *blocker, const char *name)
+{
+     if (name)
+             blocker->name = name;
+     BUG_ON(!blocker->name);

Do you really want to crash the kernel in this case?  WARN_ON() might be better IMO.

OK.

Quoted 71 lines

Also, this assumes that the caller won't release the memory used to store the 'name' string.  it might be a good idea to point that out in the kerneldoc comment.

Quoted 23 lines
kernel/power/suspend_block.c new file +23 -0
+
+     if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+             pr_info("suspend_blocker_init name=%s\n", blocker->name);
+
+     atomic_set(&blocker->flags, SB_INITIALIZED);
+}
+EXPORT_SYMBOL(suspend_blocker_init);
+
+/**
+ * suspend_blocker_destroy() - Destroy a suspend blocker
+ * @blocker: The suspend blocker to destroy.
+ */
+void suspend_blocker_destroy(struct suspend_blocker *blocker)
+{
+     int flags;
+     if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+             pr_info("suspend_blocker_destroy name=%s\n", blocker->name);
+     flags = atomic_xchg(&blocker->flags, 0);
+     WARN(!(flags & SB_INITIALIZED), "suspend_blocker_destroy called on "
+                                     "uninitialized suspend_blocker\n");
+     if (flags == (SB_INITIALIZED | SB_ACTIVE))
+             if (atomic_dec_and_test(&suspend_block_count))
+                     queue_work(suspend_work_queue, &suspend_work);

kernel/power/suspend_block.c line 148

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+}
+EXPORT_SYMBOL(suspend_blocker_destroy);
+
+/**
+ * suspend_block() - Block suspend
+ * @blocker: The suspend blocker to use
+ */
+void suspend_block(struct suspend_blocker *blocker)
+{
+     BUG_ON(!(atomic_read(&blocker->flags) & SB_INITIALIZED));

WARN_ON() and exit instead?  BUG_ON() is a bit drastic IMHO.

Quoted 30 lines
kernel/power/suspend_block.c new file +30 -0
+
+     if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+             pr_info("suspend_block: %s\n", blocker->name);
+     if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED,
+         SB_INITIALIZED | SB_ACTIVE) == SB_INITIALIZED)
+             atomic_inc(&suspend_block_count);
+
+     atomic_inc(&current_event_num);
+}
+EXPORT_SYMBOL(suspend_block);
+
+/**
+ * suspend_unblock() - Unblock suspend
+ * @blocker: The suspend blocker to unblock.
+ *
+ * If no other suspend blockers block suspend, the system will suspend.
+ */
+void suspend_unblock(struct suspend_blocker *blocker)
+{
+     if (debug_mask & DEBUG_SUSPEND_BLOCKER)
+             pr_info("suspend_unblock: %s\n", blocker->name);
+
+     if (atomic_cmpxchg(&blocker->flags, SB_INITIALIZED | SB_ACTIVE,
+         SB_INITIALIZED) == (SB_INITIALIZED | SB_ACTIVE))
+             if (atomic_dec_and_test(&suspend_block_count))
+                     queue_work(suspend_work_queue, &suspend_work);
+}
+EXPORT_SYMBOL(suspend_unblock);
+
+/**
Quoted 8 lines

kernel/power/suspend_block.c line 184

Quoted 6 lines
kernel/power/suspend_block.c new file +6 -0
+ * is_blocking_suspend() - Test if a suspend blocker is blocking suspend
+ * @blocker: The suspend blocker to check.
+ */
+bool is_blocking_suspend(struct suspend_blocker *blocker)
+{
+     return !!(atomic_read(&blocker->flags) & SB_ACTIVE);

Check SB_INITIALIZED too, perhaps?  WARN_ON(!SB_INITIALIZED)?

Added WARN_ON.

Quoted 42 lines
Quoted 42 lines
kernel/power/suspend_block.c new file +41 -0
+}
+EXPORT_SYMBOL(is_blocking_suspend);
+
+void request_suspend_state(suspend_state_t state)
+{
+     unsigned long irqflags;
+     spin_lock_irqsave(&state_lock, irqflags);
+     if (debug_mask & DEBUG_USER_STATE) {
+             struct timespec ts;
+             struct rtc_time tm;
+             getnstimeofday(&ts);
+             rtc_time_to_tm(ts.tv_sec, &tm);
+             pr_info("request_suspend_state: %s (%d->%d) at %lld "
+                     "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
+                     state != PM_SUSPEND_ON ? "sleep" : "wakeup",
+                     requested_suspend_state, state,
+                     ktime_to_ns(ktime_get()),
+                     tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                     tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+     }
+     requested_suspend_state = state;
+     if (state == PM_SUSPEND_ON)
+             suspend_block(&main_suspend_blocker);
+     else
+             suspend_unblock(&main_suspend_blocker);
+     spin_unlock_irqrestore(&state_lock, irqflags);
+}
+
+static int __init suspend_block_init(void)
+{
+     int ret;
+
+     suspend_blocker_init(&main_suspend_blocker, "main");
+     suspend_block(&main_suspend_blocker);
+
+     ret = sysdev_class_register(&suspend_block_sysclass);
+     if (ret) {
+             pr_err("suspend_block_init: sysdev_class_register failed\n");
+             goto err_sysdev_class_register;
+     }
+     ret = sysdev_register(&suspend_block_sysdev);
Quoted 9 lines

kernel/power/suspend_block.c line 231

Quoted 6 lines
kernel/power/suspend_block.c new file +6 -0
+     if (ret) {
+             pr_err("suspend_block_init: suspend_block_sysdev failed\n");
+             goto err_sysdev_register;
+     }
+
+     suspend_work_queue = create_singlethread_workqueue("suspend");

Do we need a separate workqueue for this purpose?

Yes. Some drivers wait on work that runs on the main workqueue in their suspend handler.

Quoted 30 lines
Quoted 16 lines
kernel/power/suspend_block.c new file +16 -0
+     if (suspend_work_queue == NULL) {
+             ret = -ENOMEM;
+             goto err_suspend_work_queue;
+     }
+
+     return 0;
+
+err_suspend_work_queue:
+     sysdev_unregister(&suspend_block_sysdev);
+err_sysdev_register:
+     sysdev_class_unregister(&suspend_block_sysclass);
+err_sysdev_class_register:
+     suspend_blocker_destroy(&main_suspend_blocker);
+     return ret;
+}
+

kernel/power/suspend_block.c line 257

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+static void  __exit suspend_block_exit(void)
+{
+     destroy_workqueue(suspend_work_queue);
+     sysdev_unregister(&suspend_block_sysdev);
+     sysdev_class_unregister(&suspend_block_sysclass);
+     suspend_blocker_destroy(&main_suspend_blocker);
+}
+
+core_initcall(suspend_block_init);
+module_exit(suspend_block_exit);

Thanks,
Rafael

Signature · 1 line
Arve Hjønnevåg
#27 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

Quoted 11 lines · Arve Hjønnevåg

2009/4/29 Rafael J. Wysocki <[email protected]>:

Quoted 8 lines · Arve Hjønnevåg

include/linux/suspend_block.h

Quoted 5 lines
include/linux/suspend_block.h new file +0 -0
new file mode 100755
index 0000000..7820c60

suspend_blockers.h perhaps?

suspend_blocker.h?

Fine by me.

[--snip--]

Quoted 10 lines
Quoted 8 lines

include/linux/suspend_block.h

Quoted 4 lines
include/linux/suspend_block.h new file +4 -0
+config SUSPEND_BLOCK
+     bool "Suspend block"
+     depends on PM
+     select RTC_LIB

depends on RTC_LIB

select doesn't really work and I don't think it ever will.

Nothing depends on RTC_LIB, it is only selected.

If nothing in your code needs anything depending on RTC_LIB, why select it?

[--snip--]

Quoted 11 lines
Quoted 9 lines

include/linux/suspend_block.h

Quoted 7 lines
include/linux/suspend_block.h new file +6 -0
+
+retry:
+     if (suspend_is_blocked()) {
+             if (debug_mask & DEBUG_SUSPEND)
+                     pr_info("suspend: abort suspend\n");
+             goto abort;

If that were in a loop you could just use 'break' here.

do you think this is better:

Quoted 12 lines
while(1) {
        if (exception1) {
                ...
                break;
        }
        ...
        if (exception2) {
                ...
                continue;
        }
        break;
}

I rather thought of

for (;;) {
         if (exception1) {
                 ...
                 break;
         }
         ...
         if (!exception2)
                 break;
         ...
}

[--snip--]

Quoted 21 lines
Quoted 12 lines
Quoted 12 lines
include/linux/suspend_block.h new file +12 -0
+static int suspend_block_suspend(struct sys_device *dev, pm_message_t state)
+{
+     int ret = suspend_is_blocked() ? -EAGAIN : 0;
+     if (debug_mask & DEBUG_SUSPEND)
+             pr_info("suspend_block_suspend return %d\n", ret);
+     return ret;
+}
+
+static struct sysdev_class suspend_block_sysclass = {
+     .name = "suspend_block",
+     .suspend = suspend_block_suspend,
+};
Quoted 8 lines

include/linux/suspend_block.h

Quoted 4 lines
include/linux/suspend_block.h new file +4 -0
+static struct sys_device suspend_block_sysdev = {
+     .cls = &suspend_block_sysclass,
+};
+

Hmm. Perhaps add the suspend_is_blocked() check at the beginning of sysdev_suspend() instead of this? Surely you don't want to suspend any sysdevs with any suspend blockers active, right?

Quoted 2 lines

You could make the same argument for any device. Using a sysdev makes the patch easier to apply.

You've lost me here. :-)

AFAICT, the only purpose of the sysdev class above is to abort suspend if suspend_is_blocked() returns 'true'. If that is correct, then IMO you could achieve the same goal by calling suspend_is_blocked() directly from sysdev_suspend(), right before check_wakeup_irqs(). Or am I missing anything?

Thanks,
Rafael

#26 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Pavel Machek
Quoted 17 lines · Pavel Machek

Hi!

Quoted 15 lines
Quoted 14 lines

kernel/power/power.h static inline void suspend_thaw_processes(void) · line 230

Quoted 11 lines
kernel/power/power.h +5 -0
@@ -223,3 +223,9 @@ static inline void suspend_thaw_processes(void)
 {
 }
 #endif
+
+#ifdef CONFIG_SUSPEND_BLOCK
+/* kernel/power/suspend_block.c */
+void request_suspend_state(suspend_state_t state);
+#endif

Is the #ifdef really necessary?

Quoted 4 lines
Quoted 2 lines

No, but it gives a compile error instead of a link error if you call request_suspend_state when it is not available so it is useful.

I believe #ifdef is too ugly and link error is really good enough.

Well, I agree with this FWIW.

We don't ususally use #ifdefs around function headers, unless they are defined conditionally.

Thanks,
Rafael

#28 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Rafael J. Wysocki

Hi!

Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines
kernel/power/Kconfig +4 -0
+config SUSPEND_BLOCK
+     bool "Suspend block"
+     depends on PM
+     select RTC_LIB
Quoted 7 lines
Quoted 5 lines
Quoted 3 lines

depends on RTC_LIB

select doesn't really work and I don't think it ever will.

Nothing depends on RTC_LIB, it is only selected.

If nothing in your code needs anything depending on RTC_LIB, why select it?

He wants to say nothing in _kernel proper_ depends on RTC_LIB:

pavel@amd:/data/l/linux-good$ grep 'select RTC_LIB' `find . -name
"Kconfig"`
./arch/arm/Kconfig:	select RTC_LIB
./arch/mips/Kconfig:	select RTC_LIB
./drivers/rtc/Kconfig:	select RTC_LIB
pavel@amd:/data/l/linux-good$ grep 'depends.*RTC_LIB' `find . -name
"Kconfig"`
pavel@amd:/data/l/linux-good$ 

RTC_LIB seems to be designed for select.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#29 lore raw

Re: [PATCH 1/8] PM: Add suspend block api.

In reply to Rafael J. Wysocki

2009/5/2 Rafael J. Wysocki <[email protected]>:

Quoted 27 lines

[--snip--]

Quoted 10 lines
Quoted 9 lines

kernel/power/suspend_block.c line 62

Quoted 7 lines
kernel/power/suspend_block.c new file +6 -0
+
+retry:
+     if (suspend_is_blocked()) {
+             if (debug_mask & DEBUG_SUSPEND)
+                     pr_info("suspend: abort suspend\n");
+             goto abort;

If that were in a loop you could just use 'break' here.

Quoted 13 lines

do you think this is better:
while(1) {
        if (exception1) {
                ...
                break;
        }
        ...
        if (exception2) {
                ...
                continue;
        }
        break;
}

I rather thought of

Quoted 10 lines

for (;;) {
        if (exception1) {
                ...
                break;
        }
        ...
        if (!exception2)
                break;
        ...
}

I don't think that is much better, but I changed the first patch to use a loop anyway. The loop is then removed (as before) in the patch that adds the stats.

Quoted 23 lines

[--snip--]

Quoted 21 lines
Quoted 20 lines
Quoted 6 lines
kernel/power/suspend_block.c new file +6 -0
+static int suspend_block_suspend(struct sys_device *dev, pm_message_t state)
+{
+     int ret = suspend_is_blocked() ? -EAGAIN : 0;
+     if (debug_mask & DEBUG_SUSPEND)
+             pr_info("suspend_block_suspend return %d\n", ret);
+     return ret;

kernel/power/suspend_block.c line 104

Quoted 10 lines
kernel/power/suspend_block.c new file +10 -0
+}
+
+static struct sysdev_class suspend_block_sysclass = {
+     .name = "suspend_block",
+     .suspend = suspend_block_suspend,
+};
+static struct sys_device suspend_block_sysdev = {
+     .cls = &suspend_block_sysclass,
+};
+

Hmm.  Perhaps add the suspend_is_blocked() check at the beginning of sysdev_suspend() instead of this?  Surely you don't want to suspend any sysdevs with any suspend blockers active, right?

Quoted 4 lines
Quoted 2 lines

You could make the same argument for any device. Using a sysdev makes the patch easier to apply.

You've lost me here. :-)

You have been making other changes to those files which made it a moving target.

Quoted 4 lines

AFAICT, the only purpose of the sysdev class above is to abort suspend if suspend_is_blocked() returns 'true'.  If that is correct, then IMO you could achieve the same goal by calling suspend_is_blocked() directly from sysdev_suspend(), right before check_wakeup_irqs().  Or am I missing anything?

The stats patch also used it to track wakeup events, but I have added another call for this to get rid of the sysdev.

Signature · 1 line
Arve Hjønnevåg