diff options
author | Arve Hjønnevåg <arve@android.com> | 2010-05-24 20:35:02 +0200 |
---|---|---|
committer | Rafael J. Wysocki <rjw@sisk.pl> | 2010-05-24 20:35:02 +0200 |
commit | 4965b20bd331ac061c466472e923b3fd70452928 (patch) | |
tree | a93aa5c0159afba84ee9b0b52a7fea3e42c9cb9d /kernel | |
parent | e7842b938b29d3476a141f0d555d7d526bcb8fd7 (diff) |
PM: Add driver to access suspend blockers from user space
Add a misc device, "suspend_blocker", that allows user-space processes
to block automatic suspend.
Opening this device creates a suspend blocker that can be used by the
opener to prevent automatic suspend from occurring. There are ioctls
provided for blocking and unblocking suspend and for giving the
suspend blocker a meaningful name. Closing the device special file
causes the suspend blocker to be destroyed.
For example, when select or poll indicates that input event are
available, this interface can be used by user space to block suspend
before it reads those events. This allows the input driver to release
its suspend blocker as soon as the event queue is empty. If user space
could not use a suspend blocker here the input driver would need to
delay the release of its suspend blocker until it knows (or assumes)
that user space has finished processing the events.
By careful use of suspend blockers in drivers and user space system
code, one can arrange for the system to stay awake for extremely short
periods of time in reaction to events, rapidly returning to a fully
suspended state.
Signed-off-by: Arve Hjønnevåg <arve@android.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Diffstat (limited to 'kernel')
-rw-r--r-- | kernel/power/Kconfig | 7 | ||||
-rw-r--r-- | kernel/power/Makefile | 1 | ||||
-rw-r--r-- | kernel/power/user_suspend_blocker.c | 143 |
3 files changed, 151 insertions, 0 deletions
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 6d11a4521d1e..2e665cd93f68 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -146,6 +146,13 @@ config OPPORTUNISTIC_SUSPEND determines the sleep state the system will be put into when there are no active suspend blockers. +config USER_SUSPEND_BLOCKERS + bool "User space suspend blockers" + depends on OPPORTUNISTIC_SUSPEND + ---help--- + User space suspend blockers API. Creates a misc device allowing user + space to create, use and destroy suspend blockers. + config HIBERNATION_NVS bool diff --git a/kernel/power/Makefile b/kernel/power/Makefile index 9b01cb019319..76568fec37be 100644 --- a/kernel/power/Makefile +++ b/kernel/power/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_PM_SLEEP) += console.o obj-$(CONFIG_FREEZER) += process.o obj-$(CONFIG_SUSPEND) += suspend.o obj-$(CONFIG_OPPORTUNISTIC_SUSPEND) += opportunistic_suspend.o +obj-$(CONFIG_USER_SUSPEND_BLOCKERS) += user_suspend_blocker.o obj-$(CONFIG_PM_TEST_SUSPEND) += suspend_test.o obj-$(CONFIG_HIBERNATION) += hibernate.o snapshot.o swap.o user.o \ block_io.o diff --git a/kernel/power/user_suspend_blocker.c b/kernel/power/user_suspend_blocker.c new file mode 100644 index 000000000000..d53f939e6b22 --- /dev/null +++ b/kernel/power/user_suspend_blocker.c @@ -0,0 +1,143 @@ +/* + * kernel/power/user_suspend_blocker.c + * + * Copyright (C) 2009-2010 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/slab.h> +#include <linux/suspend.h> +#include <linux/suspend_ioctls.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); + +#define USER_SUSPEND_BLOCKER_NAME_LEN 31 + +struct user_suspend_blocker { + struct suspend_blocker blocker; + char name[USER_SUSPEND_BLOCKER_NAME_LEN + 1]; + bool registered; +}; + +static int user_suspend_blocker_open(struct inode *inode, struct file *filp) +{ + struct user_suspend_blocker *blocker; + + blocker = kzalloc(sizeof(*blocker), GFP_KERNEL); + if (!blocker) + return -ENOMEM; + + nonseekable_open(inode, filp); + strcpy(blocker->name, "(userspace)"); + blocker->blocker.name = blocker->name; + filp->private_data = blocker; + + return 0; +} + +static int suspend_blocker_set_name(struct user_suspend_blocker *blocker, + void __user *name, size_t name_len) +{ + if (blocker->registered) + return -EBUSY; + + if (name_len > USER_SUSPEND_BLOCKER_NAME_LEN) + name_len = USER_SUSPEND_BLOCKER_NAME_LEN; + + if (copy_from_user(blocker->name, name, name_len)) + return -EFAULT; + blocker->name[name_len] = '\0'; + + return 0; +} + +static long user_suspend_blocker_ioctl(struct file *filp, unsigned int cmd, + unsigned long _arg) +{ + void __user *arg = (void __user *)_arg; + struct user_suspend_blocker *blocker = filp->private_data; + long ret = 0; + + mutex_lock(&ioctl_lock); + if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_SET_NAME(0)) { + ret = suspend_blocker_set_name(blocker, arg, _IOC_SIZE(cmd)); + goto done; + } + if (!blocker->registered) { + suspend_blocker_register(&blocker->blocker); + blocker->registered = true; + } + switch (cmd) { + case SUSPEND_BLOCKER_IOCTL_BLOCK: + suspend_block(&blocker->blocker); + break; + + case SUSPEND_BLOCKER_IOCTL_UNBLOCK: + suspend_unblock(&blocker->blocker); + break; + + default: + ret = -ENOTTY; + } +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 *filp) +{ + struct user_suspend_blocker *blocker = filp->private_data; + + if (blocker->registered) + suspend_blocker_unregister(&blocker->blocker); + kfree(blocker); + + return 0; +} + +const struct file_operations user_suspend_blocker_fops = { + .open = user_suspend_blocker_open, + .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); |