Linux wakelock与autosleep

内核版本：Linux-4.5

. wakelock

Linux kernel在3.4及以后的版本中加入了wakelock机制，作用同之前的Android内核一样：

1. 为应用层提供接口来创建、释放wakelock

2. 在driver中，同样也可以创建、释放wakelock

3. 当所有的wakelock都释放掉之后，系统可以自动进入低功耗状态，由autosleep来实现

从应用层角度来看wakelock并没有什么变化，但是从底层实现角度来看，却并不完全一样。早期Android的内核版本中只是在suspend的流程上加了一把锁，只有当所有的锁释放掉之后，系统才能进入suspend状态，而自3.4之后的Linux内核版本中，是基于wakeup source实现的，创建wakelock本质上是active一个wakeup event，释放wakelock本质上是deactive wakeup event。

来看wake_lock、wake_unlock的sys接口函数：
#ifdef CONFIG_PM_WAKELOCKS
static ssize_t wake_lock_show(struct kobject *kobj,
struct kobj_attribute *attr,
char *buf)
{
return pm_show_wakelocks(buf, true);
}

static ssize_t wake_lock_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t n)
{
int error = pm_wake_lock(buf);
return error ? error : n;
}

power_attr(wake_lock);

static ssize_t wake_unlock_show(struct kobject *kobj,
struct kobj_attribute *attr,
char *buf)
{
return pm_show_wakelocks(buf, false);
}

static ssize_t wake_unlock_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t n)
{
int error = pm_wake_unlock(buf);
return error ? error : n;
}

power_attr(wake_unlock);

#endif /* CONFIG_PM_WAKELOCKS */lock、unlock的show接口直接调用的pm_show_wakelocks，只是参数不一样。

ssize_t pm_show_wakelocks(char *buf, bool show_active)
{
struct rb_node *node;
struct wakelock *wl;
char *str = buf;
char *end = buf + PAGE_SIZE;

mutex_lock(&wakelocks_lock);

for (node = rb_first(&wakelocks_tree); node; node = rb_next(node)) {
wl = rb_entry(node, struct wakelock, node);
if (wl->ws.active == show_active)
str += scnprintf(str, end - str, "%s ", wl->name);
}
if (str > buf)
str--;

str += scnprintf(str, end - str, "\n");

mutex_unlock(&wakelocks_lock);
return (str - buf);
}

查询红黑树，返回处于active、deactive的wakelock。

再来看lock的写接口，直接调用pm_wake_lock()函数。

int pm_wake_lock(const char *buf)
{
const char *str = buf;
struct wakelock *wl;
u64 timeout_ns = 0;
size_t len;
int ret = 0;

if (!capable(CAP_BLOCK_SUSPEND))
return -EPERM;

while (*str && !isspace(*str))
str++;

len = str - buf;
if (!len)
return -EINVAL;

if (*str && *str != '\n') {
/* Find out if there's a valid timeout string appended. */
ret = kstrtou64(skip_spaces(str), 10, &timeout_ns);
if (ret)
return -EINVAL;
}

mutex_lock(&wakelocks_lock);

wl = wakelock_lookup_add(buf, len, true);
if (IS_ERR(wl)) {
ret = PTR_ERR(wl);
goto out;
}
if (timeout_ns) {
u64 timeout_ms = timeout_ns + NSEC_PER_MSEC - 1;

do_div(timeout_ms, NSEC_PER_MSEC);
__pm_wakeup_event(&wl->ws, timeout_ms);
} else {
__pm_stay_awake(&wl->ws);
}

wakelocks_lru_most_recent(wl);

out:
mutex_unlock(&wakelocks_lock);
return ret;
}

例如往/sys/power/wake_lock文件写入wake_lock_test 1000，第一个参数为wakelock name，第二个参数为一个时间值，用空格隔开，单位为ns。

首先来判断进程是否具有阻止系统进入suspend的权限。

然后获取传递进来的时间值，调用wakelock_lookup_add()函数。在wakelock_lookup_add()函数中首先查找是否具有相同name的wakelock，如果找到，则直接返回该wakelock，否则需要重新申请一个wakelock。

如果指定了timerout值，那么调用__pm_wakeup_event()去上报一个有时限的wakeup event，否则调用__pm_stay_awake()上报一个没有时限的wakeup event。

最后来看unlock的写接口。

int pm_wake_unlock(const char *buf)
{
struct wakelock *wl;
size_t len;
int ret = 0;

if (!capable(CAP_BLOCK_SUSPEND))
return -EPERM;

len = strlen(buf);
if (!len)
return -EINVAL;

if (buf[len-1] == '\n')
len--;

if (!len)
return -EINVAL;

mutex_lock(&wakelocks_lock);

wl = wakelock_lookup_add(buf, len, false);
if (IS_ERR(wl)) {
ret = PTR_ERR(wl);
goto out;
}
__pm_relax(&wl->ws);

wakelocks_lru_most_recent(wl);
wakelocks_gc();

out:
mutex_unlock(&wakelocks_lock);
return ret;
}

例如往/sys/power/wake_unlock文件写入wake_lock_test，解析该字符串，同样调用wakelock_lookup_add()函数，但是注意第三个参数为false，查找是否有这个name的wakelock，如果找到，则返回这个wakelock，否则的话直接返回。然后调用__pm_relax()函数去deactive一个wakeup source。

从上面代码可以看出wakelock的核心是wakeup source，通过active一个wakeup event来阻止系统进入suspend，通过deactive wakeup event来释放wakelock。

. autosleep

autosleep的sys接口还是在kernel/power/main.c中创建的，读写函数如下：

#ifdef CONFIG_PM_AUTOSLEEP
static ssize_t autosleep_show(struct kobject *kobj,
struct kobj_attribute *attr,
char *buf)
{
suspend_state_t state = pm_autosleep_state();

if (state == PM_SUSPEND_ON)
return sprintf(buf, "off\n");

#ifdef CONFIG_SUSPEND
if (state < PM_SUSPEND_MAX)
return sprintf(buf, "%s\n", pm_states[state] ?
pm_states[state] : "error");
#endif
#ifdef CONFIG_HIBERNATION
return sprintf(buf, "disk\n");
#else
return sprintf(buf, "error");
#endif
}

static ssize_t autosleep_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t n)
{
suspend_state_t state = decode_state(buf, n);
int error;

if (state == PM_SUSPEND_ON
&& strcmp(buf, "off") && strcmp(buf, "off\n"))
return -EINVAL;

error = pm_autosleep_set_state(state);
return error ? error : n;
}

power_attr(autosleep);
#endif /* CONFIG_PM_AUTOSLEEP */

在屏亮情况下，查看/sys/power/autosleep文件的值为off，在屏灭情况下去查看该值通常为mem，当我们按下关机按钮之后会往该属性文件写入mem值来触发suspend流程。

在写函数中，直接调用autosleep.c中的pm_autosleep_set_state()函数。

int pm_autosleep_set_state(suspend_state_t state)
{

#ifndef CONFIG_HIBERNATION
if (state >= PM_SUSPEND_MAX)
return -EINVAL;
#endif

__pm_stay_awake(autosleep_ws);

mutex_lock(&autosleep_lock);

autosleep_state = state;

__pm_relax(autosleep_ws);

if (state > PM_SUSPEND_ON) {
pm_wakep_autosleep_enabled(true);
queue_up_suspend_work();
} else {
pm_wakep_autosleep_enabled(false);
}

mutex_unlock(&autosleep_lock);
return 0;
}

pm_autosleep_set_state()根据名字来看是设置sleep的一个状态，这个状态可以是on、freeze、standby、mem等，mem就是通常所说的suspend to memory，还有一个更为深度的休眠是suspend to disk。

在pm_autosleep_set_state()函数中，首先调用__pm_stay_awake()函数，保证系统不能休眠，保存sleep这个状态，然后根据这个state去做相应处理。

如果是suspend状态，那么首先调用pm_wakep_autosleep_enabled()去使能autosleep，紧接着调用一个workqueue，也就是调用try_to_suspend()函数。

static void try_to_suspend(struct work_struct *work)
{
unsigned int initial_count, final_count;

if (!pm_get_wakeup_count(&initial_count, true))
goto out;

mutex_lock(&autosleep_lock);

if (!pm_save_wakeup_count(initial_count) ||
system_state != SYSTEM_RUNNING) {
mutex_unlock(&autosleep_lock);
goto out;
}

if (autosleep_state == PM_SUSPEND_ON) {
mutex_unlock(&autosleep_lock);
return;
}
if (autosleep_state >= PM_SUSPEND_MAX)
hibernate();
else
pm_suspend(autosleep_state);

mutex_unlock(&autosleep_lock);

if (!pm_get_wakeup_count(&final_count, false))
goto out;

/*
* If the wakeup occured for an unknown reason, wait to prevent the
* system from trying to suspend and waking up in a tight loop.
*/
if (final_count == initial_count)
schedule_timeout_uninterruptible(HZ / 2);

out:
queue_up_suspend_work();
}

在try_to_suspend()函数中，首先调用pm_get_wakeup_count()函数去获取wakeup count，如果有active的wakeup source，这里会block住，直到所有的wakeup soucre变成deactive状态，如果你的系统不能进入suspend，那么多半是这里的问题。

然后调用pm_save_wakeup_count()保存这个wakeup count，调用hibernate()或pm_suspend()让系统进入suspend。

参考：http://www.wowotech.net/pm_subsystem/wakelocks.html
http://www.wowotech.net/pm_subsystem/autosleep.html