Suspend block api (version 3)
Subsystems (3)
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Arve HjønnevågHi!
Quoted 2 lines
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan take up to 20 seconds to complete or fail, aborting
Please fix try_to_freeze not to take significant time rather than this...
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 4/9] Input: Block suspend while event queue is not empty.
In reply to Arve HjønnevågQuoted 6 lines
Add an ioctl, EVIOCSSUSPENDBLOCK, to enable a
suspend_blockerthat 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.Signed-off-by Arve Hj??nnev??g <[email protected]>
Looks ok to me, but I guess you should cc input maintainers.
Quoted 6 lines
drivers/input/evdev.c +2
-0@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,else return evdev_ungrab (evdev, client); +case EVIOCGSUSPENDBLOCK : +return put_user (client->use_suspend_blocker, ip);
drivers/input/evdev.c static long evdev_do_ioctl(struct file *file, unsigned int cmd, · line 605
Quoted 10 lines
drivers/input/evdev.c +10
-0+ +case EVIOCSSUSPENDBLOCK : +spin_lock_irq (&client->buffer_lock); +if (!client->use_suspend_blocker && p) +suspend_blocker_init (&client->suspend_blocker,"evdev" ); +else if (client->use_suspend_blocker && !p) +suspend_blocker_destroy (&client->suspend_blocker); + client->use_suspend_blocker = !!p; +spin_unlock_irq (&client->buffer_lock); +return 0 ;
This returns 0 even when you destroy already destroyed blocker (etc). Is that ok?
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågHi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.
Rafael proposed write() interface. I don't think you answered that.
Quoted 4 lines
kernel/power/user_suspend_blocker.c new file +4
-0+static int create_user_suspend_blocker (struct file *file,void __user *name, +size_t name_len) +{ +struct user_suspend_blocker *bl;
kernel/power/user_suspend_blocker.c line 49
Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +10
-0+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 ;
kzalloc on user-supplied argument. Sounds like bad idea.
Aha. And probably integer overflow in the same line. Ouch.
Plus you actually 'trust' the string from userspace. Someone passes "evdev" there and can masquerade as a part of kernel.
kernel/power/user_suspend_blocker.c line 101
Quoted 9 lines
kernel/power/user_suspend_blocker.c new file +9
-0+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 ; +}
What happens if someone does dup() on such file descriptor?
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågQuoted 13 lines · Arve Hj??nnev??g
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.kernel/power/user_suspend_blocker.c new file +7
-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 );
...
kernel/power/user_suspend_blocker.c line 67
Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12
-0+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; + }
Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
cover Suspend block api (version 3)
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in suspend_enter instead. It also has some other code style changes.
---
Arve Hjønnevåg
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
PATCH 1/9 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 | 94 +++++++++++++ include/linux/suspend_blocker.h | 60 +++++++++ kernel/power/Kconfig | 10 ++ kernel/power/Makefile | 1 + kernel/power/main.c | 62 +++++++++- kernel/power/power.h | 4 + kernel/power/suspend_blocker.c | 209 ++++++++++++++++++++++++++++++ 7 files changed, 439 insertions(+), 1 deletions(-) create mode 100644 Documentation/power/suspend-blockers.txt create mode 100755 include/linux/suspend_blocker.h create mode 100644 kernel/power/suspend_blocker.c
Documentation/power/suspend-blockers.txt new file +94 -0
@@ -0,0 +1,94 @@ +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 called suspend_ops->enter. This means that calling suspend_block from an +interrupt handler or a freezeable thread always works, but some or all drivers +may be temporarily suspended. + +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); +
include/linux/suspend_blocker.h new file +60 -0
60 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_BLOCKERS + bool "Suspend blockers" + depends on PM + select RTC_LIB + default n + ---help--- + Enable suspend blockers. 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_BLOCKERS) += suspend_blocker.o obj-$(CONFIG_HIBERNATION) += swsusp.o disk.o snapshot.o swap.o user.o obj-$(CONFIG_MAGIC_SYSRQ) += poweroff.o
kernel/power/main.c +61 -1
92 lines not on this page · raw message
kernel/power/power.h +4 -0
@@ -223,3 +223,7 @@ static inline void suspend_thaw_processes(void) { }#endif + +/* kernel/power/suspend_block.c */ +void request_suspend_state (suspend_state_t state); +
kernel/power/suspend_blocker.c new file +209 -0
209 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/9 PM: suspend_block: Add driver to access suspend blockers from user-space
Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has 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_blocker.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_blocker.c
Documentation/power/suspend-blockers.txt +17 -0
@@ -92,3 +92,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_BLOCKERS through /sys/power/request_state, the requested sleep state will be entered when no suspend blockers are active. +config USER_SUSPEND_BLOCKERS + bool "Userspace suspend blockers" + depends on SUSPEND_BLOCKERS + 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_BLOCKERS) += suspend_blocker.o +obj-$(CONFIG_USER_SUSPEND_BLOCKERS) += user_suspend_blocker.o obj-$(CONFIG_HIBERNATION) += swsusp.o disk.o snapshot.o swap.o user.o obj-$(CONFIG_MAGIC_SYSRQ) += poweroff.o
kernel/power/user_suspend_blocker.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/9 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 | 20 ++++++++++++++++---- 1 files changed, 16 insertions(+), 4 deletions(-)
kernel/power/process.c +16 -4
@@ -13,6 +13,7 @@#include <linux/module.h> #include <linux/syscalls.h> #include <linux/freezer.h> +#include <linux/suspend_blocker.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; +bool wakeup = false;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 = true; +break ; + }if (time_after (jiffies, end_time))break ; }while (todo);
@@ -78,10 +84,16 @@ static int try_to_freeze_tasks(bool sig_only)* 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 (KERN_ERR "Freezing of %s aborted\n" , + sig_only ?"user space " :"tasks " ); + }else { +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/9 Input: Block suspend while event queue is not empty.
Add an ioctl, EVIOCSSUSPENDBLOCK, to enable 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 | 22 ++++++++++++++++++++++ include/linux/input.h | 3 +++ 2 files changed, 25 insertions(+), 0 deletions(-)
drivers/input/evdev.c +22 -0
@@ -19,6 +19,7 @@#include <linux/input.h> #include <linux/major.h> #include <linux/device.h> +#include <linux/suspend_blocker.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; +struct suspend_blocker suspend_blocker; +bool use_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);
@@ -233,6 +238,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);
@@ -332,6 +339,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);
@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,else return evdev_ungrab (evdev, client); +case EVIOCGSUSPENDBLOCK : +return put_user (client->use_suspend_blocker, ip); + +case EVIOCSSUSPENDBLOCK : +spin_lock_irq (&client->buffer_lock); +if (!client->use_suspend_blocker && p) +suspend_blocker_init (&client->suspend_blocker,"evdev" ); +else if (client->use_suspend_blocker && !p) +suspend_blocker_destroy (&client->suspend_blocker); + client->use_suspend_blocker = !!p; +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/9 PM: suspend_block: Switch to list of active and inactive suspend blockers
This allows active suspend blockers to be listed
--- include/linux/suspend_blocker.h | 6 ++- kernel/power/suspend_blocker.c | 85 +++++++++++++++++++++++++++----------- 2 files changed, 65 insertions(+), 26 deletions(-)
include/linux/suspend_blocker.h +5 -1
@@ -16,8 +16,11 @@#ifndef _LINUX_SUSPEND_BLOCKER_H#define _LINUX_SUSPEND_BLOCKER_H +#include <linux/list.h> +/** * struct suspend_blocker - the basic suspend_blocker structure +* @link: List entry for active or inactive list. * @flags: Tracks initialized and active state. * @name: Name used for debugging. *
@@ -29,7 +32,8 @@struct suspend_blocker {#ifdef CONFIG_SUSPEND_BLOCKERS -atomic_t flags; +struct list_head link; +int flags;const char *name;#endif };
kernel/power/suspend_blocker.c +60 -25
162 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/9 PM: suspend_block: Add debugfs file
Report active and inactive suspend blockers in/sys/kernel/debug/suspend_blockers.
--- kernel/power/suspend_blocker.c | 44 ++++++++++++++++++++++++++++++++++++++- 1 files changed, 42 insertions(+), 2 deletions(-)
kernel/power/suspend_blocker.c +42 -2
@@ -17,6 +17,7 @@#include <linux/rtc.h> #include <linux/suspend.h> #include <linux/suspend_blocker.h> +#include <linux/debugfs.h> #include "power.h" enum {
@@ -41,6 +42,7 @@ 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; +static struct dentry *suspend_blocker_stats_dentry; #define pr_info_time(fmt, args...) \ do { \
@@ -54,6 +56,21 @@ static bool enable_suspend_blockers; tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec); \ }while (0 ); +static int suspend_blocker_stats_show (struct seq_file *m,void *unused) +{ +unsigned long irqflags; +struct suspend_blocker *blocker; + +seq_puts (m,"name\tactive\n" ); +spin_lock_irqsave (&list_lock, irqflags); +list_for_each_entry (blocker, &inactive_blockers, link) +seq_printf (m,"\"%s\"\t0\n" , blocker->name); +list_for_each_entry (blocker, &active_blockers, link) +seq_printf (m,"\"%s\"\t1\n" , blocker->name); +spin_unlock_irqrestore (&list_lock, irqflags); +return 0 ; +} +static void print_active_blockers_locked (void ) {struct suspend_blocker *blocker;
@@ -101,8 +118,8 @@ static DECLARE_WORK(suspend_work, suspend_worker);/** * suspend_blocker_init() - Initialize a suspend blocker * @blocker: The suspend blocker to initialize. -* @name: The name of the suspend blocker to show in debug messages. -* +* @name: The name of the suspend blocker to show in debug messages and +* /sys/kernel/debug/suspend_blockers. * The suspend blocker struct and name must not be freed before calling * suspend_blocker_destroy. */
@@ -230,6 +247,19 @@ void request_suspend_state(suspend_state_t state)spin_unlock_irqrestore (&state_lock, irqflags); } +static int suspend_blocker_stats_open (struct inode *inode,struct file *file) +{ +return single_open (file, suspend_blocker_stats_show,NULL ); +} + +static const struct file_operations suspend_blocker_stats_fops = { + .owner =THIS_MODULE , + .open = suspend_blocker_stats_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; +static int __init suspend_block_init (void ) { suspend_work_queue =create_singlethread_workqueue ("suspend" );
@@ -241,4 +271,14 @@ static int __init suspend_block_init(void)return 0 ; } +static int __init suspend_block_postcore_init (void ) +{ +if (!suspend_work_queue) +return 0 ; + suspend_blocker_stats_dentry =debugfs_create_file ("suspend_blockers" , +S_IRUGO ,NULL ,NULL , &suspend_blocker_stats_fops); +return 0 ; +} +core_initcall (suspend_block_init); +postcore_initcall (suspend_block_postcore_init);
Signature · 6 lines
1.6.1 _______________________________________________ linux-pm mailing list [email protected] https://lists.linux-foundation.org/mailman/listinfo/linux-pm
PATCH 7/9 PM: suspend_block: Add suspend_blocker stats
Report suspend block stats in /sys/kernel/debug/suspend_blockers.
--- include/linux/suspend_blocker.h | 21 ++++- kernel/power/Kconfig | 7 ++ kernel/power/main.c | 4 +- kernel/power/power.h | 6 +- kernel/power/suspend_blocker.c | 190 +++++++++++++++++++++++++++++++++++++-- 5 files changed, 218 insertions(+), 10 deletions(-)
include/linux/suspend_blocker.h +20 -1
@@ -17,12 +17,21 @@#define _LINUX_SUSPEND_BLOCKER_H#include <linux/list.h> +#include <linux/ktime.h> /** * struct suspend_blocker - the basic suspend_blocker structure * @link: List entry for active or inactive list. -* @flags: Tracks initialized and active state. +* @flags: Tracks initialized, active and stats state. * @name: Name used for debugging. +* @count: Number of times this blocker has been deacivated +* @wakeup_count: Number of times this blocker was the first to block suspend +* after resume. +* @total_time: Total time this suspend blocker has prevented suspend. +* @prevent_suspend_time: Time this suspend blocker has prevented suspend while +* user-space requested suspend. +* @max_time: Max time this suspend blocker has been continuously active +* @last_time: Monotonic clock when the active state last changed. * * When a suspend_blocker is active it prevents the system from entering * suspend.
@@ -35,6 +44,16 @@ struct suspend_blocker {struct list_head link;int flags;const char *name; +#ifdef CONFIG_SUSPEND_BLOCKER_STATS +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_BLOCKERS through /sys/power/request_state, the requested sleep state will be entered when no suspend blockers are active. +config SUSPEND_BLOCKER_STATS + bool "Suspend block stats" + depends on SUSPEND_BLOCKERS + default y + ---help--- + Report suspend block stats in /sys/kernel/debug/suspend_blockers + config USER_SUSPEND_BLOCKERS bool "Userspace suspend blockers" depends on SUSPEND_BLOCKERS
kernel/power/main.c +3 -1
@@ -322,8 +322,10 @@ static int suspend_enter(suspend_state_t state) error =sysdev_suspend (PMSG_SUSPEND );if (!error) { -if (!suspend_is_blocked () && !suspend_test (TEST_CORE )) +if (!suspend_is_blocked () && !suspend_test (TEST_CORE )) { +about_to_enter_suspend (); error = suspend_ops->enter (state); + }sysdev_resume (); }
kernel/power/power.h +5 -1
@@ -226,4 +226,8 @@ static inline void suspend_thaw_processes(void)/* kernel/power/suspend_block.c */ void request_suspend_state (suspend_state_t state); - +#ifdef CONFIG_SUSPEND_BLOCKER_STATS +void about_to_enter_suspend (void ); +#else +static inline void about_to_enter_suspend (void ) {} +#endif
kernel/power/suspend_blocker.c +183 -7
265 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/9 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_blocker.h | 7 +- kernel/power/suspend_blocker.c | 235 +++++++++++++++++++++++++---- 3 files changed, 218 insertions(+), 34 deletions(-)
Documentation/power/suspend-blockers.txt +10 -0
@@ -92,6 +92,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_blocker.h +6 -1
@@ -22,8 +22,9 @@/** * struct suspend_blocker - the basic suspend_blocker structure * @link: List entry for active or inactive list. -* @flags: Tracks initialized, active and stats state. +* @flags: Tracks initialized, active, stats and autoexpire state. * @name: Name used for debugging. +* @expires: Time, in jiffies, to unblock suspend. * @count: Number of times this blocker has been deacivated * @wakeup_count: Number of times this blocker was the first to block suspend * after resume.
@@ -44,9 +45,11 @@ struct suspend_blocker {struct list_head link;int flags;const char *name; +unsigned long expires; #ifdef CONFIG_SUSPEND_BLOCKER_STATS struct { int count; + int expire_count; int wakeup_count; ktime_t total_time; ktime_t prevent_suspend_time;
@@ -62,6 +65,7 @@ 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);bool suspend_blocker_is_active (struct suspend_blocker *blocker);bool suspend_is_blocked (void );
@@ -72,6 +76,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 suspend_blocker_is_active (struct suspend_blocker *bl) {return 0 ; }
kernel/power/suspend_blocker.c +202 -33
402 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 9/9 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_blocker.c | 23 +++++++++++++++++++++++ 3 files changed, 31 insertions(+), 0 deletions(-)
Documentation/power/suspend-blockers.txt +7 -0
@@ -112,6 +112,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);
@@ -119,3 +121,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_blocker.c +23 -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,10 @@ 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 (suspend_blocker_is_active (&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 +133,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
Quoted 4 lines · Arve Hjønnevåg
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in
suspend_enterinstead. It also has some other code style changes.
Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.
My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?
IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.
The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.
If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.
What am I missing?
Kevin
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Pavel MachekQuoted 15 lines · Pavel Machek
Quoted 13 lines · Arve Hj??nnev??g
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.kernel/power/user_suspend_blocker.c new file +7
-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);...
Quoted 15 lines
kernel/power/user_suspend_blocker.c line 67
Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12
-0+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; + }Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!
This is not uncommon. _IOC encodes the size of the argument, and if this is not a fixed size, then the raw ioctl number change based on the size passed in. Look at input.h is you want other examples of this.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Pavel MachekQuoted 9 lines · Pavel Machek
Hi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.Rafael proposed
write()interface. I don't think you answered that.
I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.
Quoted 18 lines
Quoted 5 lines
kernel/power/user_suspend_blocker.c new file +4
-0+static int create_user_suspend_blocker (struct file *file,void __user *name, + size_t name_len) +{ + struct user_suspend_blocker *bl;kernel/power/user_suspend_blocker.c line 49
Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +10
-0+ 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;kzalloc on user-supplied argument. Sounds like bad idea.
Quoted 2 lines
Aha. And probably integer overflow in the same line. Ouch.
The size is limited to _IOC_SIZEMASK with is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?
Quoted 2 lines
Plus you actually 'trust' the string from userspace. Someone passes "evdev" there and can masquerade as a part of kernel.
Yes. I could add a prefix to userspace names, but it did not seem worth the effort since the name is not used as a key for anything.
Quoted 13 lines
kernel/power/user_suspend_blocker.c line 101
Quoted 10 lines
kernel/power/user_suspend_blocker.c new file +9
-0+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; +}What happens if someone does
dup()on such file descriptor?
Then you have two file descriptors pointing to the same suspend blocker. Release is called when the last reference goes away.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Pavel MachekQuoted 7 lines · Pavel Machek
Hi!
Quoted 2 lines
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan take up to 20 seconds to complete or fail, abortingPlease fix
try_to_freezenot to take significant time rather than this...
I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible sleep in the kernel can delay the task freezing and there is no point in completing this when we know suspend will fail.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 4/9] Input: Block suspend while event queue is not empty.
In reply to Pavel MachekQuoted 8 lines · Pavel Machek
Quoted 6 lines
Add an ioctl, EVIOCSSUSPENDBLOCK, to enable a
suspend_blockerthat 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.Signed-off-by Arve Hj??nnev??g <[email protected]>Looks ok to me, but I guess you should cc input maintainers.
OK.
Quoted 5 lines
Quoted 5 lines
(quoted diff) +0
-0@@ -582,6 +591,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,else
returnevdev_ungrab(evdev, client);
Quoted 15 lines
Quoted 4 lines
+ case EVIOCGSUSPENDBLOCK:
+ returnput_user(client->use_suspend_blocker, ip); +
+ case EVIOCSSUSPENDBLOCK:Quoted 8 lines
+
spin_lock_irq(&client->buffer_lock);
+ if (!client->use_suspend_blocker && p)
+suspend_blocker_init(&client->suspend_blocker, "evdev");
+ else if (client->use_suspend_blocker&& !p)
+suspend_blocker_destroy(&client->suspend_blocker);
+client->use_suspend_blocker= !!p;
+spin_unlock_irq(&client->buffer_lock);
+ return 0;This returns 0 even when you destroy already destroyed blocker (etc). Is that ok?
Yes. If events did not block suspend before the call, they still do not block suspend after the call, so the requested state was reached.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågQuoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek
Hi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.
Quoted 6 lines
Quoted 2 lines
Rafael proposed
write()interface. I don't think you answered that.I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.
Or perhaps just use "userspace/%d" % pid as a name?
1) can't be faked that trivially
2) small / mostly fixed size
3) can use nicer write protocol?
Quoted 7 lines
Quoted 4 lines
kzalloc on user-supplied argument. Sounds like bad idea.
Aha. And probably integer overflow in the same line. Ouch.
The size is limited to
_IOC_SIZEMASKwith is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?
16K of unswappable kernel memory for name is a bit too much, yes.
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 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Arve HjønnevågQuoted 6 lines · Arve Hj?nnev?g
Quoted 5 lines · Pavel Machek
Hi!
Quoted 2 lines
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan take up to 20 seconds to complete or fail, aborting
Quoted 7 lines
Quoted 2 lines
Please fix
try_to_freezenot to take significant time rather than this...I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible
If the code runs for 20 seconds, it is a bug to be fixed.
IOW the patch should not be needed when the bugs are fixed. You should not need it now.
Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.
For now, it just makes stuff harder to review.
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 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågQuoted 32 lines · Arve Hj?nnev?g
Quoted 15 lines · Pavel Machek
Quoted 13 lines · Arve Hj??nnev??g
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.kernel/power/user_suspend_blocker.c new file +7
-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);...
Quoted 15 lines
kernel/power/user_suspend_blocker.c line 67
Quoted 12 lines
kernel/power/user_suspend_blocker.c new file +12
-0+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; + }Wait a moment, wtf is this? Not one ioctl but one ioctl per length of string?!
Quoted 4 lines
This is not uncommon.
_IOCencodes the size of the argument, and if this is not a fixed size, then the raw ioctl number change based on the size passed in. Look atinput.his you want other examples of this.
Ok, I found few examples in code:
pavel@amd:/data/l/linux$ grep -ri IOCSIZE_MASK .
./arch/alpha/include/asm/ioctl.h:#define IOCSIZE_MASK (_IOC_SIZEMASK
<< _IOC_SIZESHIFT)
./arch/mips/include/asm/ioctl.h:#define IOCSIZE_MASK (_IOC_SIZEMASK
<< _IOC_SIZESHIFT)
./arch/sparc/include/asm/ioctl.h:#define IOCSIZE_MASK
(_IOC_XSIZEMASK << _IOC_SIZESHIFT)
./drivers/input/joydev.c: if ((cmd & ~IOCSIZE_MASK) ==
JSIOCGNAME(0)) {
./drivers/message/fusion/mptctl.c: if ((cmd & ~IOCSIZE_MASK) ==
(MPTIOCINFO & ~IOCSIZE_MASK)) {
./drivers/message/fusion/mptctl.c: else if ((cmd & ~IOCSIZE_MASK)
== (HP_GETHOSTINFO & ~IOCSIZE_MASK))
./drivers/mtd/mtdchar.c: size = (cmd & IOCSIZE_MASK) >>
IOCSIZE_SHIFT;
./drivers/pcmcia/pcmcia_ioctl.c: size = (cmd & IOCSIZE_MASK) >>
IOCSIZE_SHIFT;
./include/asm-generic/ioctl.h:#define IOCSIZE_MASK (_IOC_SIZEMASK
<< _IOC_SIZESHIFT)I still do not like introducing 16000 ioctls, and I'm not sure how our ioctl compatibility layer playes with this.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
2009/5/6 Kevin Hilman <[email protected]>:
Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in
suspend_enterinstead. It also has some other code style changes.
Quoted 7 lines
Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.
My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?
We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.
Quoted 4 lines
IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.
suspend blockers have no impact on this.
Quoted 4 lines
The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.
Tools allow you to find apps that waste power, but they do not fix them.
Quoted 5 lines
If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.
What am I missing?
Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Pavel MachekQuoted 10 lines · Pavel Machek
Quoted 9 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek
Hi!
Quoted 2 lines
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan take up to 20 seconds to complete or fail, abortingPlease fix
try_to_freezenot to take significant time rather than this...
Quoted 6 lines
Quoted 4 lines
I though we covered this already. Most of the 20 second delays we saw on earlier kernel version have been fixed, but this code can run for 20 seconds which is an unacceptable wakeup delay. Any uninterruptible
If the code runs for 20 seconds, it is a bug to be fixed.
The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.
Quoted 8 lines
IOW the patch should not be needed when the bugs are fixed. You should not need it now.
Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.
It can take a significant amount of time. It has to wait for every thread it signalled to freeze which seems to be every user-space thread. On my device, with 200 threads, this took less than 10ms half the time, up to 460ms in the worst case.
Quoted 1 line
For now, it just makes stuff harder to review.
I think this patch is needed whether there are bugs or not, to ensure low latency wakeup.
Quoted 5 lines
Pavel --
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Pavel MachekQuoted 7 lines · Pavel Machek
Hi!
Quoted 2 lines
If a
suspend_blockeris active, suspend will fail anyway. Sincetry_to_freeze_taskscan take up to 20 seconds to complete or fail, abortingPlease fix
try_to_freezenot to take significant time rather than this...
FYI, I agree with this patch.
Best,
Rafael
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Pavel MachekQuoted 9 lines · Pavel Machek
Quoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek
Hi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.
Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Rafael proposed
write()interface. I don't think you answered that.I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.
Or perhaps just use "userspace/%d" % pid as a name?
This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.
Quoted 2 lines
1) can't be faked that trivially
I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.
Quoted 5 lines
2) small / mostly fixed size
3) can use nicer write protocol?
I don't think a write protocol is nicer. "ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val = 1; write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".
Quoted 9 lines
Quoted 7 lines
Quoted 4 lines
kzalloc on user-supplied argument. Sounds like bad idea.
Aha. And probably integer overflow in the same line. Ouch.
The size is limited to
_IOC_SIZEMASKwith is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?16K of unswappable kernel memory for name is a bit too much, yes.
What if I just truncate it to NAME_MAX.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Arve HjønnevågHi.
Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek
If the code runs for 20 seconds, it is a bug to be fixed.
The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.
I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).
In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 - when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.
Regards,
Nigel
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
2009/5/7 Nigel Cunningham <[email protected]>:
Quoted 17 lines
Hi.
Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek
If the code runs for 20 seconds, it is a bug to be fixed.
The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.
Quoted 6 lines
I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).
In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -
One second is to long.
Quoted 2 lines
when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.
This patch does nothing with the 20 second timeout.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
Hi.
Quoted 18 lines · Arve Hjønnevåg
2009/5/7 Nigel Cunningham <[email protected]>:
Quoted 17 lines
Hi.
Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek
If the code runs for 20 seconds, it is a bug to be fixed.
The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.
Quoted 8 lines
Quoted 6 lines
I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).
In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -
One second is to long.
I agree. But a one second timeout is still better than a 20s timeout.
Quoted 4 lines
Quoted 2 lines
when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.
This patch does nothing with the 20 second timeout.
I know. Perhaps we should do something with it, though.
Nigel
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Arve HjønnevågQuoted 49 lines · Arve Hjønnevåg
Quoted 9 lines · Pavel Machek
Quoted 8 lines · Arve Hj?nnev?g
Quoted 7 lines · Pavel Machek
Hi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Rafael proposed
write()interface. I don't think you answered that.I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.
Or perhaps just use "userspace/%d" % pid as a name?
This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.
Quoted 2 lines
1) can't be faked that trivially
I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.
Quoted 5 lines
2) small / mostly fixed size
3) can use nicer write protocol?
I don't think a write protocol is nicer. "
ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val= 1;write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".Quoted 5 lines
Quoted 5 lines
Quoted 4 lines
kzalloc on user-supplied argument. Sounds like bad idea.
Aha. And probably integer overflow in the same line. Ouch.
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
The size is limited to
_IOC_SIZEMASKwith is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?16K of unswappable kernel memory for name is a bit too much, yes.
What if I just truncate it to
NAME_MAX.
My main concern with the ioctl() interface is that you're adding a device file just in order to have the ioctl()s available. Usually, however, a device file's purpose is to implement file operations (open, close, read, write), while ioctl()s are used for doing things that the file operations are not suitable for.
So, if your device only implements open(), close() and ioctl(), this is an indication that there's something wrong with the interface, because it doesn't do what one would generally expect it to do (ie. smells like an abuse). That's why I think it would be better to use read() and write() instead of ioctl().
Of course, there also is a problem that people generally don't like adding new ioctl()s without a _really_ good reason.
Thanks,
Rafael
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Nigel CunninghamQuoted 30 lines · Nigel Cunningham
Hi.
Quoted 18 lines · Arve Hjønnevåg
2009/5/7 Nigel Cunningham <[email protected]>:
Quoted 17 lines
Hi.
Quoted 13 lines · Arve Hjønnevåg
Quoted 1 line · Pavel Machek
If the code runs for 20 seconds, it is a bug to be fixed.
The code gives up after 20 seconds, it does not normally run for 20 seconds. It is arguably a bug that it gives up after 20 seconds since the time required to freeze all the threads grows with the number of threads that are running. It could still be making progress after 20 seconds. Since the time required to freeze all tasks is the number of tasks times the time it takes to interrupt each task there is no way to ensure that the time required is insignificant. If we do not abort task freezing when there is a wakeup event, then the worst case wakeup latency is guarantied to be worse than the worst case latency for any other uninterruptible kernel call.
Quoted 8 lines
Quoted 6 lines
I agree with Pavel here. If freezing takes 20 seconds, something is wrong. (Remember that most tasks will not be running, and will therefore respond to the pseudo-signal and freeze immediately).
In fact, I'd go further. In the thousands of times I've run the freezer over the years, it has never taken more than 1 second - let alone 20 -
One second is to long.
Quoted 8 lines
I agree. But a one second timeout is still better than a 20s timeout.
Quoted 4 lines
Quoted 2 lines
when freezing has been successful. A delay of 20 seconds was more relevant when the value included the time for syncing data to disk.
This patch does nothing with the 20 second timeout.
I know. Perhaps we should do something with it, though.
I tried some time ago, but it didn't really work well.
The timeout is actually a workaround for the problem that we don't really know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.
Now, I think the Arve's approach is reasonable. If we know in advace that we're not going to suspend, it's better to stop the freezing as soon as possible.
Thanks,
Rafael
_______________________________________________
linux-pm mailing list
[email protected]
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
Quoted 16 lines · Arve Hjønnevåg
2009/5/6 Kevin Hilman <[email protected]>:
Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in
suspend_enterinstead. It also has some other code style changes.Quoted 7 lines
Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.
My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?
Quoted 7 lines
We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.
Yes CPUIDLE and pmqos are more "cooperative" power management, where suspend is a preemptive form of PM. I get a little itchy when the preemptive PM is made automatic from the kernel level.
BTW Thanks. I feel like I'm understanding your PM design a bit better now.
--mgross
Quoted 33 lines
Quoted 5 lines
IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.
suspend blockers have no impact on this.
Quoted 4 lines
The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.
Tools allow you to find apps that waste power, but they do not fix them.
Quoted 5 lines
If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.
What am I missing?
Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.
Signature · 5 lines
Arve Hjønnevåg _______________________________________________ linux-pm mailing list [email protected] https://lists.linux-foundation.org/mailman/listinfo/linux-pm
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Rafael J. WysockiHi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.
What were the circumstances in which freezing could take 20s?
Quoted 3 lines
Now, I think the Arve's approach is reasonable. If we know in advace that we're not going to suspend, it's better to stop the freezing as soon as possible.
Agreed.
Regards,
Nigel
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
Quoted 11 lines · Nigel Cunningham
Hi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.
Quoted 1 line
What were the circumstances in which freezing could take 20s?
Compiling the kernel with "make -j<big number>" on a dual core system IIRC.
Generally, the situation in which there are many runnable tasks and new tasks come and go etc. I haven't repeated this benchmark recently, though, so it's probably worth doing again.
Which has a little to do with the $subject patch IMO, because I think that it's reasonable to stop freezing tasks as soon as we know that it won't be necessary anyway.
Thanks,
Rafael
Quoted 41 lines · Arve Hjønnevåg
2009/5/6 Kevin Hilman <[email protected]>:
Quoted 7 lines
Quoted 4 lines · Arve Hjønnevåg
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in
suspend_enterinstead. It also has some other code style changes.Quoted 7 lines
Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.
My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?
We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.
Quoted 4 lines
IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.
suspend blockers have no impact on this.
Quoted 4 lines
The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.
Tools allow you to find apps that waste power, but they do not fix them.
Quoted 4 lines
If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.
Quoted 8 lines
Quoted 1 line
What am I missing?
Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.
Arve,
Thanks for the clarifications. Like Mark, I feel like I have a better grip on the motivation behind these changes.
Thanks,
Kevin
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Rafael J. WysockiHi.
Quoted 16 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham
Hi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.Quoted 1 line
What were the circumstances in which freezing could take 20s?
Compiling the kernel with "make -j<big number>" on a dual core system IIRC.
Quoted 7 lines
Generally, the situation in which there are many runnable tasks and new tasks come and go etc. I haven't repeated this benchmark recently, though, so it's probably worth doing again.
Which has a little to do with the $subject patch IMO, because I think that it's reasonable to stop freezing tasks as soon as we know that it won't be necessary anyway.
Yes, but it's still good to know.
Regards,
Nigel
Re: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space
In reply to Rafael J. Wysocki2009/5/8 Rafael J. Wysocki <[email protected]>:
Quoted 55 lines · Arve Hjønnevåg
Quoted 54 lines · Pavel Machek
Quoted 9 lines · Arve Hj?nnev?g
Quoted 8 lines · Pavel Machek
Quoted 7 lines
Hi!
Quoted 4 lines
Add a misc device, "
suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create asuspend_blocker, and to block and unblock suspend. To delete thesuspend_blocker, close the device.Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Rafael proposed
write()interface. I don't think you answered that.I think an ioctl interface makes more sense. With a write interface you either have to do string parsing, or invent some other protocol between the driver and user-space.
Or perhaps just use "userspace/%d" % pid as a name?
This would not be as useful. The point of naming the suspend blockers is to that we can easily identify them in the stats and kernel logs. Using the pid has two problems. First, the pid gives no hint about what it is used for, you have to look up the process somewhere else. Second, we use more than one suspend blocker from the same process.
Quoted 2 lines
1) can't be faked that trivially
I don't think this is a big problem. If you don't trust the apps that you give suspend blocker access to use unique names, we can add a prefix. This can be added in a later patch though.
Quoted 5 lines
2) small / mostly fixed size
3) can use nicer write protocol?
I don't think a write protocol is nicer. "
ioctl(suspend_block_fd, SUSPEND_BLOCKER_IOCTL_BLOCK);" seems less error prone and more readable to me than "write(suspend_block_fd, "1", 1);", "write(suspend_block_fd, "1", 2);" or "suspend_block_val= 1;write(suspend_block_fd, &suspend_block_val, sizeof(suspend_block_val));".Quoted 9 lines
Quoted 7 lines
Quoted 4 lines
kzalloc on user-supplied argument. Sounds like bad idea.
Aha. And probably integer overflow in the same line. Ouch.
The size is limited to
_IOC_SIZEMASKwith is 13 or 14 bits depending on the architecture. Do you want a lower limit on the name length?16K of unswappable kernel memory for name is a bit too much, yes.
Quoted 7 lines
Quoted 1 line
What if I just truncate it to
NAME_MAX.My main concern with the
ioctl()interface is that you're adding a device file just in order to have the ioctl()s available. Usually, however, a device file's purpose is to implement file operations (open, close, read, write), while ioctl()s are used for doing things that the file operations are not suitable for.
In this case, we are adding a device file to get close (release).
Quoted 4 lines
So, if your device only implements
open(),close()andioctl(), this is an indication that there's something wrong with the interface, because it doesn't do what one would generally expect it to do (ie. smells like an abuse). That's why I think it would be better to useread()andwrite()instead ofioctl().
It not not clear to me how putting a control interface on top of read and write is any less abusive.
Quoted 2 lines
Of course, there also is a problem that people generally don't like adding new ioctl()s without a _really_ good reason.
ioctls are better suited for issuing commands than read/write.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Arve HjønnevågHi!
Quoted 8 lines
Quoted 7 lines
IOW the patch should not be needed when the bugs are fixed. You should not need it now.
Can you drop it for now (or keep it in private tree or something). If you have scenario where it takes significant time and that can't be fixed, please present the scenario and we can reconsider it.
Quoted 4 lines
It can take a significant amount of time. It has to wait for every thread it signalled to freeze which seems to be every user-space thread. On my device, with 200 threads, this took less than 10ms half the time, up to 460ms in the worst case.
Ok, 460ms in the worst case is good reason to apply this patch, I agree.
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 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
In reply to Rafael J. WysockiQuoted 12 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham
Hi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.
Quoted 3 lines
Quoted 1 line
What were the circumstances in which freezing could take 20s?
Compiling the kernel with "make -j<big number>" on a dual core system IIRC.
IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".
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 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
Quoted 13 lines · Pavel Machek
Quoted 12 lines · Rafael J. Wysocki
Quoted 11 lines · Nigel Cunningham
Hi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
What were the circumstances in which freezing could take 20s?
Compiling the kernel with "make -j<big number>" on a dual core system IIRC.
IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".
No, it appeared after a number of experiments I carried out a couple of years ago. :-)
Best,
Rafael
Re: [PATCH 3/9] PM: suspend_block: Abort task freezing if a suspend_blocker is active.
Quoted 16 lines · Rafael J. Wysocki
Quoted 15 lines · Pavel Machek
Quoted 14 lines · Rafael J. Wysocki
Quoted 12 lines · Nigel Cunningham
Hi.
Quoted 7 lines · Rafael J. Wysocki
The timeout is actually a workaround for the problem that we don't really
know if tasks are going to react to our freeze requests and how much time it is going to take. The current value of 20 s was chosen after a number of experiments showing that in some cases the freezing _was_ going to take so much time. Of course the question is whether it makes sense to give up earlier even if tasks would eventually freeze, but that's a different issue.What were the circumstances in which freezing could take 20s?
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
Compiling the kernel with "make -j<big number>" on a dual core system IIRC.
IIRC the number happened because I saw up to 5sec under some heavy overload, and added some "safety margin".
No, it appeared after a number of experiments I carried out a couple of years ago. :-)
Ok, that was the "IIRC" part :-).
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 50 lines · Arve Hj?nnev?g
2009/5/6 Kevin Hilman <[email protected]>:
Quoted 7 lines
Quoted 4 lines · Arve Hj?nnev?g
This patch series adds a suspend-block api that provides the same functionality as the android wakelock api. This patch series removes the sysdev that was used to abort suspend and adds a direct check in
suspend_enterinstead. It also has some other code style changes.Quoted 7 lines
Sorry for joining the wakelock/suspend-block discussion a bit late, but I have a very basic, and possibly stupid question on the need for such a feature.
My basic question: is why not use idle (dynamic PM) instead of suspend (static PM) for this?
We use suspend in addition to idle, not instead of. On some systems (msm) we can enter the same power state from idle as from suspend. This reduces the importance of suspend, but entering suspend still has benefits. The monotonic clock stops and all the periodic timers (user-space and kernel) that are based on it stop with it. It also reduces the amount of energy an untrusted application can waste since it will not be allowed to run when the system is suspended.
Quoted 4 lines
IOW, why not use CPUidle + PM QoS to achieve the same goal? It seems to me that you're trying to add some dynamic PM features onto a static PM subsystem. I could see PM QoS possibly needing some extending but the basic abilities to constrain the low-power states are there.
suspend blockers have no impact on this.
Quoted 4 lines
The one reason I can think of is that you can always have broken drivers or apps that prevent you from hitting idle. But with tools like powertop, it's pretty easy to find these problems and fix them.
Tools allow you to find apps that waste power, but they do not fix them.
Quoted 5 lines
If that is the primary concern, it seems to me that we're introducing a new kernel API to work around broken drivers and apps that should be fixed instead.
What am I missing?
Suspend blockers allow you to use suspend. On platforms that cannot enter the same power state from idle this is essential. On platforms can enter the same power state from idle as suspend, suspend reduce the time spent running which in turn reduces the overall power draw. It also offers some protection against bad apps which is important on an open device.
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html