![Rafael J. Wysocki](/assets/img/avatar_default.png)
One of the arguments during the suspend blockers discussion was that the mainline kernel didn't contain any mechanisms making it possible to avoid races between wakeup and system suspend. Generally, there are two problems in that area. First, if a wakeup event occurs exactly when /sys/power/state is being written to, it may be delivered to user space right before the freezer kicks in, so the user space consumer of the event may not be able to process it before the system is suspended. Second, if a wakeup event occurs after user space has been frozen, it is not generally guaranteed that the ongoing transition of the system into a sleep state will be aborted. To address these issues introduce a new global sysfs attribute, /sys/power/wakeup_count, associated with a running counter of wakeup events and three helper functions, pm_stay_awake(), pm_relax(), and pm_wakeup_event(), that may be used by kernel subsystems to control the behavior of this attribute and to request the PM core to abort system transitions into a sleep state already in progress. The /sys/power/wakeup_count file may be read from or written to by user space. Reads will always succeed (unless interrupted by a signal) and return the current value of the wakeup events counter. Writes, however, will only succeed if the written number is equal to the current value of the wakeup events counter. If a write is successful, it will cause the kernel to save the current value of the wakeup events counter and to abort the subsequent system transition into a sleep state if any wakeup events are reported after the write has returned. [The assumption is that before writing to /sys/power/state user space will first read from /sys/power/wakeup_count. Next, user space consumers of wakeup events will have a chance to acknowledge or veto the upcoming system transition to a sleep state. Finally, if the transition is allowed to proceed, /sys/power/wakeup_count will be written to and if that succeeds, /sys/power/state will be written to as well. Still, if any wakeup events are reported to the PM core by kernel subsystems after that point, the transition will be aborted.] Additionally, put a wakeup events counter into struct dev_pm_info and make these per-device wakeup event counters available via sysfs, so that it's possible to check the activity of various wakeup event sources within the kernel. To illustrate how subsystems can use pm_wakeup_event(), make the low-level PCI runtime PM wakeup-handling code use it. Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> Acked-by: Jesse Barnes <jbarnes@virtuousgeek.org> Acked-by: Greg Kroah-Hartman <gregkh@suse.de> Acked-by: markgross <markgross@thegnar.org> Reviewed-by: Alan Stern <stern@rowland.harvard.edu>
331 lines
7.8 KiB
C
331 lines
7.8 KiB
C
/*
|
|
* kernel/power/main.c - PM subsystem core functionality.
|
|
*
|
|
* Copyright (c) 2003 Patrick Mochel
|
|
* Copyright (c) 2003 Open Source Development Lab
|
|
*
|
|
* This file is released under the GPLv2
|
|
*
|
|
*/
|
|
|
|
#include <linux/kobject.h>
|
|
#include <linux/string.h>
|
|
#include <linux/resume-trace.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
#include "power.h"
|
|
|
|
DEFINE_MUTEX(pm_mutex);
|
|
|
|
unsigned int pm_flags;
|
|
EXPORT_SYMBOL(pm_flags);
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
/* Routines for PM-transition notifications */
|
|
|
|
static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
|
|
|
|
int register_pm_notifier(struct notifier_block *nb)
|
|
{
|
|
return blocking_notifier_chain_register(&pm_chain_head, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(register_pm_notifier);
|
|
|
|
int unregister_pm_notifier(struct notifier_block *nb)
|
|
{
|
|
return blocking_notifier_chain_unregister(&pm_chain_head, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(unregister_pm_notifier);
|
|
|
|
int pm_notifier_call_chain(unsigned long val)
|
|
{
|
|
return (blocking_notifier_call_chain(&pm_chain_head, val, NULL)
|
|
== NOTIFY_BAD) ? -EINVAL : 0;
|
|
}
|
|
|
|
/* If set, devices may be suspended and resumed asynchronously. */
|
|
int pm_async_enabled = 1;
|
|
|
|
static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return sprintf(buf, "%d\n", pm_async_enabled);
|
|
}
|
|
|
|
static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|
const char *buf, size_t n)
|
|
{
|
|
unsigned long val;
|
|
|
|
if (strict_strtoul(buf, 10, &val))
|
|
return -EINVAL;
|
|
|
|
if (val > 1)
|
|
return -EINVAL;
|
|
|
|
pm_async_enabled = val;
|
|
return n;
|
|
}
|
|
|
|
power_attr(pm_async);
|
|
|
|
#ifdef CONFIG_PM_DEBUG
|
|
int pm_test_level = TEST_NONE;
|
|
|
|
static const char * const pm_tests[__TEST_AFTER_LAST] = {
|
|
[TEST_NONE] = "none",
|
|
[TEST_CORE] = "core",
|
|
[TEST_CPUS] = "processors",
|
|
[TEST_PLATFORM] = "platform",
|
|
[TEST_DEVICES] = "devices",
|
|
[TEST_FREEZER] = "freezer",
|
|
};
|
|
|
|
static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|
char *buf)
|
|
{
|
|
char *s = buf;
|
|
int level;
|
|
|
|
for (level = TEST_FIRST; level <= TEST_MAX; level++)
|
|
if (pm_tests[level]) {
|
|
if (level == pm_test_level)
|
|
s += sprintf(s, "[%s] ", pm_tests[level]);
|
|
else
|
|
s += sprintf(s, "%s ", pm_tests[level]);
|
|
}
|
|
|
|
if (s != buf)
|
|
/* convert the last space to a newline */
|
|
*(s-1) = '\n';
|
|
|
|
return (s - buf);
|
|
}
|
|
|
|
static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|
const char *buf, size_t n)
|
|
{
|
|
const char * const *s;
|
|
int level;
|
|
char *p;
|
|
int len;
|
|
int error = -EINVAL;
|
|
|
|
p = memchr(buf, '\n', n);
|
|
len = p ? p - buf : n;
|
|
|
|
mutex_lock(&pm_mutex);
|
|
|
|
level = TEST_FIRST;
|
|
for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
|
|
if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
|
|
pm_test_level = level;
|
|
error = 0;
|
|
break;
|
|
}
|
|
|
|
mutex_unlock(&pm_mutex);
|
|
|
|
return error ? error : n;
|
|
}
|
|
|
|
power_attr(pm_test);
|
|
#endif /* CONFIG_PM_DEBUG */
|
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
struct kobject *power_kobj;
|
|
|
|
/**
|
|
* state - control system power state.
|
|
*
|
|
* show() returns what states are supported, which is hard-coded to
|
|
* 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
|
|
* 'disk' (Suspend-to-Disk).
|
|
*
|
|
* store() accepts one of those strings, translates it into the
|
|
* proper enumerated value, and initiates a suspend transition.
|
|
*/
|
|
static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|
char *buf)
|
|
{
|
|
char *s = buf;
|
|
#ifdef CONFIG_SUSPEND
|
|
int i;
|
|
|
|
for (i = 0; i < PM_SUSPEND_MAX; i++) {
|
|
if (pm_states[i] && valid_state(i))
|
|
s += sprintf(s,"%s ", pm_states[i]);
|
|
}
|
|
#endif
|
|
#ifdef CONFIG_HIBERNATION
|
|
s += sprintf(s, "%s\n", "disk");
|
|
#else
|
|
if (s != buf)
|
|
/* convert the last space to a newline */
|
|
*(s-1) = '\n';
|
|
#endif
|
|
return (s - buf);
|
|
}
|
|
|
|
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|
const char *buf, size_t n)
|
|
{
|
|
#ifdef CONFIG_SUSPEND
|
|
suspend_state_t state = PM_SUSPEND_STANDBY;
|
|
const char * const *s;
|
|
#endif
|
|
char *p;
|
|
int len;
|
|
int error = -EINVAL;
|
|
|
|
p = memchr(buf, '\n', n);
|
|
len = p ? p - buf : n;
|
|
|
|
/* First, check if we are requested to hibernate */
|
|
if (len == 4 && !strncmp(buf, "disk", len)) {
|
|
error = hibernate();
|
|
goto Exit;
|
|
}
|
|
|
|
#ifdef CONFIG_SUSPEND
|
|
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)
|
|
error = enter_state(state);
|
|
#endif
|
|
|
|
Exit:
|
|
return error ? error : n;
|
|
}
|
|
|
|
power_attr(state);
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
/*
|
|
* The 'wakeup_count' attribute, along with the functions defined in
|
|
* drivers/base/power/wakeup.c, provides a means by which wakeup events can be
|
|
* handled in a non-racy way.
|
|
*
|
|
* If a wakeup event occurs when the system is in a sleep state, it simply is
|
|
* woken up. In turn, if an event that would wake the system up from a sleep
|
|
* state occurs when it is undergoing a transition to that sleep state, the
|
|
* transition should be aborted. Moreover, if such an event occurs when the
|
|
* system is in the working state, an attempt to start a transition to the
|
|
* given sleep state should fail during certain period after the detection of
|
|
* the event. Using the 'state' attribute alone is not sufficient to satisfy
|
|
* these requirements, because a wakeup event may occur exactly when 'state'
|
|
* is being written to and may be delivered to user space right before it is
|
|
* frozen, so the event will remain only partially processed until the system is
|
|
* woken up by another event. In particular, it won't cause the transition to
|
|
* a sleep state to be aborted.
|
|
*
|
|
* This difficulty may be overcome if user space uses 'wakeup_count' before
|
|
* writing to 'state'. It first should read from 'wakeup_count' and store
|
|
* the read value. Then, after carrying out its own preparations for the system
|
|
* transition to a sleep state, it should write the stored value to
|
|
* 'wakeup_count'. If that fails, at least one wakeup event has occured since
|
|
* 'wakeup_count' was read and 'state' should not be written to. Otherwise, it
|
|
* is allowed to write to 'state', but the transition will be aborted if there
|
|
* are any wakeup events detected after 'wakeup_count' was written to.
|
|
*/
|
|
|
|
static ssize_t wakeup_count_show(struct kobject *kobj,
|
|
struct kobj_attribute *attr,
|
|
char *buf)
|
|
{
|
|
unsigned long val;
|
|
|
|
return pm_get_wakeup_count(&val) ? sprintf(buf, "%lu\n", val) : -EINTR;
|
|
}
|
|
|
|
static ssize_t wakeup_count_store(struct kobject *kobj,
|
|
struct kobj_attribute *attr,
|
|
const char *buf, size_t n)
|
|
{
|
|
unsigned long val;
|
|
|
|
if (sscanf(buf, "%lu", &val) == 1) {
|
|
if (pm_save_wakeup_count(val))
|
|
return n;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
power_attr(wakeup_count);
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
#ifdef CONFIG_PM_TRACE
|
|
int pm_trace_enabled;
|
|
|
|
static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|
char *buf)
|
|
{
|
|
return sprintf(buf, "%d\n", pm_trace_enabled);
|
|
}
|
|
|
|
static ssize_t
|
|
pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|
const char *buf, size_t n)
|
|
{
|
|
int val;
|
|
|
|
if (sscanf(buf, "%d", &val) == 1) {
|
|
pm_trace_enabled = !!val;
|
|
return n;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
power_attr(pm_trace);
|
|
#endif /* CONFIG_PM_TRACE */
|
|
|
|
static struct attribute * g[] = {
|
|
&state_attr.attr,
|
|
#ifdef CONFIG_PM_TRACE
|
|
&pm_trace_attr.attr,
|
|
#endif
|
|
#ifdef CONFIG_PM_SLEEP
|
|
&pm_async_attr.attr,
|
|
&wakeup_count_attr.attr,
|
|
#ifdef CONFIG_PM_DEBUG
|
|
&pm_test_attr.attr,
|
|
#endif
|
|
#endif
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group attr_group = {
|
|
.attrs = g,
|
|
};
|
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
struct workqueue_struct *pm_wq;
|
|
EXPORT_SYMBOL_GPL(pm_wq);
|
|
|
|
static int __init pm_start_workqueue(void)
|
|
{
|
|
pm_wq = create_freezeable_workqueue("pm");
|
|
|
|
return pm_wq ? 0 : -ENOMEM;
|
|
}
|
|
#else
|
|
static inline int pm_start_workqueue(void) { return 0; }
|
|
#endif
|
|
|
|
static int __init pm_init(void)
|
|
{
|
|
int error = pm_start_workqueue();
|
|
if (error)
|
|
return error;
|
|
power_kobj = kobject_create_and_add("power", NULL);
|
|
if (!power_kobj)
|
|
return -ENOMEM;
|
|
return sysfs_create_group(power_kobj, &attr_group);
|
|
}
|
|
|
|
core_initcall(pm_init);
|