Suspend block api
Subsystems (3)
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
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
@@ -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
@@ -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
@@ -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
@@ -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
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
@@ -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
@@ -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
@@ -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
@@ -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
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
@@ -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
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
@@ -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
@@ -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
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
@@ -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
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
@@ -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
@@ -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
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
@@ -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
@@ -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
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
@@ -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, ×pec_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
@@ -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
@@ -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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Arve HjønnevågReview
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_wakeor a platformDocumentation/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
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_wakeor a platformDocumentation/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 nowDocumentation/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_unblockon theprocess_input_eventssuspend_blockerand 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Arve HjønnevågI'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.Signed-off-by Arve Hjønnevåg <[email protected]>--- 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.cDocumentation/power/suspend-blockers.txt new file +0
-0
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_wakeor a platformDocumentation/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@@ -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@@ -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_POSSIBLEkernel/power/Makefile +1
-0@@ -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.okernel/power/main.c +62
-0@@ -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, #endifkernel/power/power.h +6
-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 +kernel/power/suspend_block.c new file +27
-0@@ -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 (¤t_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 (¤t_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 (¤t_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
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_lockhas been renamed tosuspend_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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Alan Stern2009/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_wakeor a platformDocumentation/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 nowDocumentation/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_unblockon theprocess_input_eventssuspend_blockerand 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to mark grossQuoted 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to mark gross2009/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.Signed-off-by Arve Hjønnevåg <[email protected]>---
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.txtcreate mode 100755include/linux/suspend_block.hcreate mode 100644kernel/power/suspend_block.cDocumentation/power/suspend-blockers.txt new file +0
-0Documentation/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, withinsuspend_block.cwith 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_wakeor a platformDocumentation/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-queuesuspend_blocker.count = 2
Quoted 2 lines
+- The keypad-scan code detects that no keys are held and calls
suspend_unblock
+ on the keypad-scansuspend_blocker.count = 1
Quoted 3 lines
+- The user-space input-event thread returns from select/poll, calls
+ suspend_block on the process-input-eventssuspend_blockerand 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 callssuspend_unblockon the input-event-queuesuspend_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, callssuspend_unblockon the
+ process-input-eventssuspend_blockerand 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_countis the lynch pin of the design, why have all thesuspend_blockerstructs? 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
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.Signed-off-by Arve Hjønnevåg <[email protected]>---
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.txtcreate mode 100755include/linux/suspend_block.hcreate mode 100644kernel/power/suspend_block.cDocumentation/power/suspend-blockers.txt new file +0
-0Documentation/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, withinsuspend_block.cwith 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_wakeor a platformDocumentation/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-queuesuspend_blocker.count = 2
Quoted 2 lines
+- The keypad-scan code detects that no keys are held and calls
suspend_unblock
+ on the keypad-scansuspend_blocker.count = 1
Quoted 3 lines
+- The user-space input-event thread returns from select/poll, calls
+ suspend_block on the process-input-eventssuspend_blockerand 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 callssuspend_unblockon the input-event-queuesuspend_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, callssuspend_unblockon the
+ process-input-eventssuspend_blockerand 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_countis the lynch pin of the design, why have all thesuspend_blockerstructs? 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_blockerdoes not change the global count by more than one. Also,suspend_block_countis 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Arve HjønnevågHi!
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@@ -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
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(), becausesuspend_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@@ -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
+ selectRTC_LIBIs
RTC_LIBokay 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_blockersis 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_blockersI don't think
suspend_blockersshould 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->flagsseem 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_unblockat 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
@@ -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
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_storestarts iterating atPM_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_blockersis 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_blockersis 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_blockersshould 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Arve HjønnevågHi!
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_statewhen 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Pavel MachekQuoted 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_storestarts iterating atPM_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_blockersis 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_blockersis 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_blockersshould 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Arve HjønnevågQuoted 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
Signed-off-by Arve Hjønnevåg <[email protected]>--- 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.cDocumentation/power/suspend-blockers.txt new file +0
-0
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
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
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_POSSIBLEkernel/power/Makefile +1
-0@@ -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.okernel/power/main.c +1
-0@@ -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, #endifkernel/power/power.h +0
-0
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@@ -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 (¤t_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 (¤t_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 (¤t_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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Rafael J. WysockiQuoted 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_storestarts iterating atPM_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_blockersis 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_blockersis 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_blockersI don't think
suspend_blockersshould 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
Re: [PATCH 2/8] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågQuoted 2 lines · Arve Hjønnevåg
Adds ioctls to create a
suspend_blocker, and to block and unblock suspend. To delete thesuspend_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
Signed-off-by Arve Hjønnevåg <[email protected]>--- 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.cDocumentation/power/suspend-blockers.txt +17
-0@@ -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@@ -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@@ -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_POSSIBLEkernel/power/Makefile +1
-0@@ -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.okernel/power/user_suspend_block.c new file +125
-0@@ -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
Re: [PATCH 3/8] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Arve HjønnevågQuoted 27 lines · Arve Hjønnevåg
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan 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.
Signed-off-by Arve Hjønnevåg <[email protected]>--- kernel/power/process.c | 23 ++++++++++++++++++----- 1 files changed, 18 insertions(+), 5 deletions(-)kernel/power/process.c +1
-0@@ -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
-0do_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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Rafael J. Wysocki2009/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@@ -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_blockerobject that has to be initialized with the help ofsuspend_blocker_init(). When no longer needed, the suspend blocker must be garbage collected with the help ofsuspend_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 withsuspend_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_suspendSurely
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);Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Rafael J. Wysocki2009/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
suspend_blockers.hperhaps?
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@@ -116,6 +116,16 @@ config SUSPEND_FREEZERTurning 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
+ selectRTC_LIBdepends on
RTC_LIBselect 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---
+ Enablesuspend_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 nosuspend_blockersare 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_POSSIBLEkernel/power/Makefile +0
-0@@ -6,6 +6,7 @@ endifobj-$(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@@ -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
-0static const char * const pm_states[PM_SUSPEND_MAX] = { +#ifdef CONFIG_SUSPEND_BLOCK + [PM_SUSPEND_ON] = "on", +#endifWhy #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, #endifkernel/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?
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@@ -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(¤t_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(¤t_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 ofsysdev_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(¤t_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_INITIALIZEDtoo, 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
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
suspend_blockers.hperhaps?
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 onPM + selectRTC_LIB depends on
RTC_LIBselect 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 ofsysdev_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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Pavel MachekQuoted 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_statewhen 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Rafael J. WysockiHi!
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_LIBselect 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
Re: [PATCH 1/8] PM: Add suspend block api.
In reply to Rafael J. Wysocki2009/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 ofsysdev_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 callingsuspend_is_blocked()directly fromsysdev_suspend(), right beforecheck_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