---
title: "Android在标准linux基础上对休眠唤醒的实现(二)"
author: "mmdev"
date: "2011-12-08T16:39:00Z"
tags: []
slug: "android-linux"
draft: false
lastmod: "2011-12-10T16:03:39Z"
id: 1301201
url: "https://mmdev.iteye.com/blog/1301201"
---

**三、kernel层源码解析- wakelock的重要地位**

wakelock在android的休眠唤醒机制中扮演着及其重要的角色，主要源码位于文件:kernel/kernel/power/wakelock.c，kernel/include/linux/wakelock.h中。

wakelocks\_init()函数所做的工作是整个wakelock可以工作起来的基础，所有这里先说说这个函数。

static int \_\_initwakelocks\_init(void)

{

int ret;

int i;

for (i = 0; i &lt; ARRAY\_SIZE(active\_wake\_locks); i++)

INIT\_LIST\_HEAD(&active\_wake\_locks\[i]);

//初始化active\_wake\_locks数组中的两个类型锁链表: WAKE\_LOCK\_SUSPEND,WAKE\_LOCK\_IDLE

#ifdef CONFIG\_WAKELOCK\_STAT// defined

wake\_lock\_init(&deleted\_wake\_locks, WAKE\_LOCK\_SUSPEND,

"deleted\_wake\_locks");

//初始化wakelock deleted\_wake\_locks，同时将其加入到非活动锁链表中

#endif

wake\_lock\_init(&main\_wake\_lock, WAKE\_LOCK\_SUSPEND, "main");

wake\_lock\_init(&sys\_sync\_wake\_lock, WAKE\_LOCK\_SUSPEND, "sys\_sync");

wake\_lock(&main\_wake\_lock);

wake\_lock\_init(&unknown\_wakeup, WAKE\_LOCK\_SUSPEND, "unknown\_wakeups");

//初始化wakelock: main, sys\_sync, unknown\_wakeups,同时将其加入到非活动锁链表中

//给main\_wake\_lock加锁

ret =platform\_device\_register(&power\_device);

if (ret) {

pr\_err("\[wakelocks\_init]: platform\_device\_register failed/n");

goto err\_platform\_device\_register;

}

ret =platform\_driver\_register(&power\_driver);

if (ret) {

pr\_err("\[wakelocks\_init]: platform\_driver\_register failed/n");

goto err\_platform\_driver\_register;

}

//新建工作队列和工作者内核线程: sys\_sync\_work\_queue, fs\_sync

//suspend\_work\_queue, suspend

sys\_sync\_work\_queue= create\_singlethread\_workqueue("fs\_sync");

if (sys\_sync\_work\_queue == NULL) {

pr\_err("\[wakelocks\_init] fs\_sync workqueue create failed/n");

}

suspend\_work\_queue= create\_singlethread\_workqueue("suspend");

if (suspend\_work\_queue == NULL) {

ret = -ENOMEM;

goto err\_suspend\_work\_queue;

}

#ifdef CONFIG\_WAKELOCK\_STAT

proc\_create("wakelocks", S\_IRUGO, NULL, &wakelock\_stats\_fops);

//创建proc接口

#endif

return 0;

err\_suspend\_work\_queue:

platform\_driver\_unregister(&power\_driver);

err\_platform\_driver\_register:

platform\_device\_unregister(&power\_device);

err\_platform\_device\_register:

wake\_lock\_destroy(&unknown\_wakeup);

wake\_lock\_destroy(&main\_wake\_lock);

#ifdef CONFIG\_WAKELOCK\_STAT

wake\_lock\_destroy(&deleted\_wake\_locks);

#endif

return ret;

}

可以看到该初始化函数中新建了几个wakelock: deleted\_wake\_locks、main\_wake\_lock、sys\_sync\_wake\_lock、unknown\_wakeup，他们全部都是WAKE\_LOCK\_SUSPEND类型的wakelock，说到这里不得不提到wakelock的两种类型了：

1.WAKE\_LOCK\_SUSPEND –这种锁如果被某个task持有，那么系统将无法进入休眠。

2.WAKE\_LOCK\_IDLE –这种锁不会影响到系统进入休眠，但是如果这种锁被持有，那么系统将无法进入idle空闲模式。

不过常用的所类型还是WAKE\_LOCK\_SUSPEND，包括userwakelock.c提供给用户空间的新建wakelock的接口，都是建立的第一种锁。另外系统为了分开管理这两种不同类型的锁，建立了两个链表来统一链接不同类型的锁：active\_wake\_locks\[],这个是具有两个链表头的数组，元素0是挂接WAKE\_LOCK\_SUSPEND类型的锁，而元素1就是挂接WAKE\_LOCK\_IDLE类型的wakelock了。

接着上面说，这个初始化函数新建这些锁之后，直接将主锁(main\_wake\_lock)给上锁了,其余都是非锁状态。新建wakelock使用函数wake\_lock\_init()，该函数设置锁的名字，类型，最后将新建的锁挂接到一个专门链接这些非锁状态的链表inactive\_locks上(新建的wakelock初期都是出于非锁状态的，除非显示调用函数wake\_lock来上锁)。接着如果使用函数wake\_lock()来给特定的wakelock上锁的话，会将该锁从链表inactive\_locks上移动到对应类型的专用链表上active\_wake\_locks\[type]上。

wakelock有两种形式的锁：超时锁和非超时锁，这两种形式的锁都是使用函数wake\_lock\_init()来初始化，只是在上锁的时候会有一点点差别，超时锁使用函数wake\_lock\_timeout(),而非超时锁使用函数wake\_lock(),这个两个函数会最终调用到同一个函数wake\_lock\_internal(),该函数依靠传入的不同参数来选择不同的路径来工作。值得注意的是，非超时锁必须手工解锁，否则系统永远不能进入睡眠。下面是wake\_lock\_internal()函数的片段：

if (!(lock-&gt;flags & WAKE\_LOCK\_ACTIVE))

lock-&gt;flags |= WAKE\_LOCK\_ACTIVE;// wakelock状态为inactive，则更改为active

…

if (has\_timeout) {// wake\_lock\_timeout()会传入1

if (wakelock\_debug\_mask & DEBUG\_WAKE\_LOCK)

pr\_info("\[wake\_lock\_internal]: %s, type %d, timeout %ld.%03lu/n",

lock-&gt;name, type, timeout / HZ,

(timeout % HZ) * MSEC\_PER\_SEC / HZ);

lock-&gt;expires = jiffies + timeout;//设置超时时间

lock-&gt;flags |= WAKE\_LOCK\_AUTO\_EXPIRE;//超时锁标志

list\_add\_tail(&lock-&gt;link, &active\_wake\_locks\[type]);

}

// acquire a non-timeout wakelock添加一个非超时锁

else {// wake\_lock ()会传入0

if (wakelock\_debug\_mask & DEBUG\_WAKE\_LOCK)

pr\_info("\[wake\_lock\_internal]: %s, type %d/n", lock-&gt;name, type);

lock-&gt;expires = LONG\_MAX;//设置成超时时间最大值

lock-&gt;flags &= ~WAKE\_LOCK\_AUTO\_EXPIRE;//非超时锁标志

list\_add(&lock-&gt;link, &active\_wake\_locks\[type]);

//将刚刚设置的非超时锁加到对应类型的活动锁链表中

}

解锁的时候，这两种形式的锁所使用函数都是一样了：wake\_unlock()，该函数中会首先作如下操作：

lock-&gt;flags &= ~(WAKE\_LOCK\_ACTIVE | WAKE\_LOCK\_AUTO\_EXPIRE);

//清除锁活动标志和自动超时标志

list\_del(&lock-&gt;link);//从锁对应的活动链表上摘除

list\_add(&lock-&gt;link, &inactive\_locks);

//将unlock的锁挂接到非活动链表inactive\_locks上

前面已经说了只有类型为WAKE\_LOCK\_SUSPEND的wakelock被上锁才会阻止系统进入suspend，那么也就是说只要链表active\_wake\_locks\[WAKE\_LOCK\_SUSPEND]为NULL，那么系统就可以执行suspend的流程了。Android对linux的改造，让其可以在三种情况下进入linux的标准suspend的流程：

1.wake\_unlock()，这个应该是最容易想到的，只要系统有对WAKE\_LOCK\_SUSPEND类型的wakelock解锁的动作，都有可能会进入suspend流程开始休眠，为什么是有可能呢？因为可能还有超时锁没有被超时解锁。下面看一下代码片段：

void wake\_unlock(struct wake\_lock \*lock)

{

…

if (type == WAKE\_LOCK\_SUSPEND)//貌似只在处理这个类型的wakelock

{

long has\_lock =has\_wake\_lock\_locked(type);

//这个函数蛮重要，它来检查type类型的链表上是否还有锁被上锁了。

//其返回值如果是0，说明没有该类型的锁被持有了；返回非0表明就是这个类型的活动链表上还存在超时锁但是没有非超时锁了，这个返回值就是当前时间距离最后超时的锁超时时间的jiffies值；如果返回-1，那表明还有该类型的非超时锁被持有。

if (wakelock\_debug\_mask & DEBUG\_WAKE\_LOCK)

pr\_info("\[wake\_unlock]: has\_lock = 0x%x/n" , has\_lock);

if (has\_lock &gt; 0) {

if (wakelock\_debug\_mask & DEBUG\_EXPIRE)

pr\_info("\[wake\_unlock]: %s, start expire timer, "

"%ld/n", lock-&gt;name, has\_lock);

mod\_timer(&expire\_timer, jiffies + has\_lock);

//修改定时器的超时值并add该定时器

}

else//已经没有超时锁了

{

if (del\_timer(&expire\_timer))//删除定时器

if (wakelock\_debug\_mask & DEBUG\_EXPIRE)

pr\_info("\[wake\_unlock]: %s, stop expire "

"timer/n", lock-&gt;name);

if (has\_lock == 0)

// !=0,表明还有该类型的非超时锁被持有，现在还不能进入suspend

{

pr\_info("\[wake\_unlock]: (%s) suspend\_work\_queue suspend\_work/n" , lock-&gt;name);

queue\_work(suspend\_work\_queue, &suspend\_work);

//提交suspend的工作项，开始执行标准linux的suspend流程

}

}

…

}

spin\_unlock\_irqrestore(&list\_lock, irqflags);

}

2.超时锁超时之后，定时器的回调函数会执行会查看是否有其他的wakelock,如果没有,就在这里让系统进入睡眠。

static voidexpire\_wake\_locks(unsigned long data)

{

long has\_lock;

unsigned long irqflags;

if (debug\_mask & DEBUG\_EXPIRE)

pr\_info("expire\_wake\_locks: start/n");

spin\_lock\_irqsave(&list\_lock, irqflags);

if (debug\_mask & DEBUG\_SUSPEND)

print\_active\_locks(WAKE\_LOCK\_SUSPEND);

has\_lock = has\_wake\_lock\_locked(WAKE\_LOCK\_SUSPEND);

if (debug\_mask & DEBUG\_EXPIRE)

pr\_info("expire\_wake\_locks: done, has\_lock %ld/n", has\_lock);

if (has\_lock == 0)

//如果没有SUSPEND类型的wakelock处于active，那么将调用suspend

queue\_work(suspend\_work\_queue, &suspend\_work);

spin\_unlock\_irqrestore(&list\_lock, irqflags);

}

static DEFINE\_TIMER(expire\_timer, expire\_wake\_locks, 0, 0);

列出以下一个重要的函数源码：

static longhas\_wake\_lock\_locked(int type)

{

struct wake\_lock \*lock, \*n;

long max\_timeout = 0;

BUG\_ON(type &gt;= WAKE\_LOCK\_TYPE\_COUNT);

list\_for\_each\_entry\_safe(lock, n, &active\_wake\_locks\[type], link) {

if (lock-&gt;flags & WAKE\_LOCK\_AUTO\_EXPIRE) {

long timeout = lock-&gt;expires - jiffies;

if (timeout &lt;= 0)

expire\_wake\_lock(lock);

else if (timeout &gt; max\_timeout)

max\_timeout = timeout;

} else

return -1;

}

return max\_timeout;

}

3.这个可能有人觉得匪夷所思，就是在wake\_lock{_ \_timeout}()函数中，调用了内部函数wake\_lock\_internal()。这里只有在对超时锁上锁的时候才有可能进入休眠，如果对一个费超时锁上锁的话，那么就没有必要去检查活动链表了。

static void wake\_lock\_internal(

struct wake\_lock \*lock, long timeout, int has\_timeout)

{

…

if (type == WAKE\_LOCK\_SUSPEND) {

current\_event\_num++;

#ifdef CONFIG\_WAKELOCK\_STAT

if (lock == &main\_wake\_lock)

update\_sleep\_wait\_stats\_locked(1);

else if (!wake\_lock\_active(&main\_wake\_lock))

update\_sleep\_wait\_stats\_locked(0);

#endif

if (has\_timeout)//超时锁的时候传进来的是1

expire\_in = has\_wake\_lock\_locked(type);

//检查当前锁类型链表上是否还有锁处于active的状态，无返回0

else

expire\_in = -1;

//如果是非超时锁的话，这里直接赋值-1，省去了活动链表检查步骤了

if (expire\_in &gt; 0) {

if (debug\_mask & DEBUG\_EXPIRE)

pr\_info("wake\_lock: %s, start expire timer, "

"%ld/n", lock-&gt;name, expire\_in);

// modify the time wakelock is expired

mod\_timer(&expire\_timer, jiffies + expire\_in);

} else {

if (del\_timer(&expire\_timer))

if (debug\_mask & DEBUG\_EXPIRE)

pr\_info("wake\_lock: %s, stop expire timer/n",

lock-&gt;name);

if (expire\_in == 0)//没有锁处于active状态后，准备调用suspend了

{

pr\_info("\[wake\_lock]: suspend\_work\_queue suspend\_work/n ");

queue\_work(suspend\_work\_queue, &suspend\_work);

}

}

}

spin\_unlock\_irqrestore(&list\_lock, irqflags);

}

下面是suspend的工作项，经过上面三种情况的检查，ok之后将会提交该工作项给工作队列suspend\_work\_queue，如下：

static voidsuspend(struct work\_struct \*work)

{

int ret;

int entry\_event\_num;

// there are still some wakelock

if (has\_wake\_lock(WAKE\_LOCK\_SUSPEND)) {

if (wakelock\_debug\_mask & DEBUG\_SUSPEND)

pr\_info("\[suspend]: abort suspend/n");

return;

}

entry\_event\_num = current\_event\_num;

sys\_sync();

if (debug\_mask & DEBUG\_SUSPEND)

pr\_info("suspend: enter suspend/n");

ret = pm\_suspend(requested\_suspend\_state);

// requested\_suspend\_state这个全局变量在函数request\_suspend\_state()中被设置，也就是执行了eraly suspend或者late resume之后，主要是为suspend保留请求的省电状态。

if (debug\_mask & DEBUG\_EXIT\_SUSPEND) {

struct timespec ts;

struct rtc\_time tm;

getnstimeofday(&ts);

rtc\_time\_to\_tm(ts.tv\_sec, &tm);

pr\_info("suspend: exit suspend, ret = %d "

"(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)/n", ret,

tm.tm\_year + 1900, tm.tm\_mon + 1, tm.tm\_mday,

tm.tm\_hour, tm.tm\_min, tm.tm\_sec, ts.tv\_nsec);

}

if (current\_event\_num == entry\_event\_num) {

if (debug\_mask & DEBUG\_SUSPEND)

pr\_info("suspend: pm\_suspend returned with no event/n");

wake\_lock\_timeout(&unknown\_wakeup, HZ / 2);

}

}

static DECLARE\_WORK(suspend\_work, suspend);

@kernel/kernel/power/suspend.c

intpm\_suspend(suspend\_state\_t state)

{

if (state &gt; PM\_SUSPEND\_ON && state &lt;= PM\_SUSPEND\_MAX)

return enter\_state(state);

//标准linux的suspend流程函数

return -EINVAL;

}

EXPORT\_SYMBOL(pm\_suspend);

Wakelock的机制被文件userwakelock.c中的code封装成了sys的接口sys/power/wake\_lock和sys/power/wake\_unlock文件，那么上层如果需要新建wakelock或者注销wakelock，或者是解锁wakelock，都是操作这两个sys接口文件。