Linux与Android休眠唤醒对比（二）

Android  休眠与唤醒 （二）

Android  中定义了几种低功耗状态：earlysuspend ，suspend ，hibernation 。

1 ，earlysuspend 是一种低功耗的状态, 某些设备可以选择进入某种功耗较低的状态, 比如LCD 可以降低亮度或灭掉;

2 ，suspend 是指除电源管理以外的其他外围模块以及cpu 均不工作, 只有内存保持自刷新的状态;

3 ，hibernation 是指所有内存镜像都被写入磁盘中, 然后系统关机, 恢复后系统将能恢复到“关机”之前的状态.

在一个打过android 补丁的内核中, state_store() 首先判断用户写入的是否是“disk” 字符串, 如果是则调用hibernate() 函数命令系统进入hibernation 状态.  如果是其他字符串则调用request_suspend_state() （如果定义CONFIG_EARLYSUSPEND ）或者调用enter_state() （如果未定义CONFIG_EARLYSUSPEND ）.

AndroidSuspend 时, state_store() 函数会进入到request_suspend_state() 中,  这个文件在earlysuspend.c 中, 这些功能都是android 系统加的,  后面会对early suspend 和late resume  进行介绍.

涉及到的文件:

linux_source/kernel/power/main.c 

linux_source/kernel/power/earlysuspend.c

linux_source/kernel/power/wakelock.c

 

特性介绍

Early Suspend

Earlysuspend  是android  引进的一种机制,  这种机制在上游备受争议, 这里不做评论.  这个机制作用在关闭显示的时候.  在这个时候,  一些和显示有关的设备, 比如LCD 背光,  重力感应器,  触摸屏,  这些设备都会关掉,  但是系统可能还是在运行状态( 这时候还有wake lock) 进行任务的处理,  例如在扫描SD 卡上的文件,  后台音乐/FM 播放,  文件传输/ 下载等.  在嵌入式设备中,  背光是一个很大的电源消耗, 所以android 加入这样一种机制.

Late Resume

Late Resume 是和Earlysuspend  配套的一种机制,  是在内核唤醒完毕开始执行的.  主要就是唤醒在Early Suspend 的时候休眠的设备.

Wake Lock

Wake Lock  在Android 的电源管理系统中扮演一个核心的角色. Wake Lock 是一种锁的机制,  只要有人拿着这个锁,  系统就无法进入休眠,  它可以被用户态程序和内核获得.  这个锁可以是有超时的或者是没有超时的,  超时的锁会在时间过去以后自动解锁.  如果没有锁了或者超时了,  内核就会启动休眠的那套机制来进入休眠.

Android Suspend

当用户通过sysfs 写入mem  或者standby 到/sys/power/state 中的时候, state_store() 会被调用,  然后Android 会在这里调用request_suspend_state()  而标准的Linux 会在这里进入enter_state() 这个函数.  如果请求的是休眠,  那么early_suspend 这个workqueue[queue_work()] 就会被调用, 并且进入early_suspend 状态.

voidrequest_suspend_state(suspend_state_t new_state)
{
        unsignedlong irqflags;
        intold_sleep;

        spin_lock_irqsave(&state_lock,irqflags);
        old_sleep= state & SUSPEND_REQUESTED;
        if(debug_mask & DEBUG_USER_STATE) {
                structtimespec ts;
                structrtc_time tm;
                getnstimeofday(&ts);
                rtc_time_to_tm(ts.tv_sec,&tm);
                pr_info("request_suspend_state:%s (%d->%d) at %lld "
                        "(%d-%02d-%02d%02d:%02d:%02d.%09lu UTC)",
                        new_state!= PM_SUSPEND_ON ? "sleep" : "wakeup",
                        requested_suspend_state,new_state,
                        ktime_to_ns(ktime_get()),
                        tm.tm_year+ 1900, tm.tm_mon + 1, tm.tm_mday,
                        tm.tm_hour,tm.tm_min, tm.tm_sec, ts.tv_nsec);
        }
        if(!old_sleep && new_state != PM_SUSPEND_ON) {
                state|= SUSPEND_REQUESTED;
                queue_work(suspend_work_queue,&early_suspend_work);
        }else if (old_sleep && new_state == PM_SUSPEND_ON) {
                state&= ~SUSPEND_REQUESTED;
                wake_lock(&main_wake_lock);
                queue_work(suspend_work_queue,&late_resume_work);
        }

        requested_suspend_state= new_state;
        spin_unlock_irqrestore(&state_lock,irqflags);

}

EarlySuspend

在early_suspend() 函数中,  首先会检查现在请求的状态还是否是suspend,  来防止suspend 的请求会在这个时候取消掉( 因为这个时候用户进程还在运行), 如果需要退出,  就简单的退出了.  如果没有,  这个函数就会把early suspend 中 注册的一系列的回调都调用一次,  然后同步文件系统,  然后放弃掉main_wake_lock,  这个wake lock 是一个没有超时的锁, 如果这个锁不释放,  那么系统就无法进入休眠.

static void early_suspend(struct work_struct *work)
{
        structearly_suspend *pos;
        unsignedlong irqflags;
        intabort = 0

        mutex_lock(&early_suspend_lock);
        spin_lock_irqsave(&state_lock,irqflags);
        if(state == SUSPEND_REQUESTED)
                state|= SUSPENDED;
        else
                abort= 1;
        spin_unlock_irqrestore(&state_lock,irqflags);

        if(abort) {
                if(debug_mask & DEBUG_SUSPEND)
                        pr_info("early_suspend:abort, state %d", state);
                mutex_unlock(&early_suspend_lock);
                gotoabort;
        }

        if(debug_mask & DEBUG_SUSPEND)
                pr_info("early_suspend:call handlers");
        list_for_each_entry(pos,&early_suspend_handlers, link) {
                if(pos->suspend != NULL)
                        pos->suspend(pos);
        }

        mutex_unlock(&early_suspend_lock);

 

        if (debug_mask & DEBUG_SUSPEND)
                pr_info("early_suspend:sync");
        sys_sync();

abort:

        spin_lock_irqsave(&state_lock,irqflags);

 

        if(state == SUSPEND_REQUESTED_AND_SUSPENDED)
                wake_unlock(&main_wake_lock);
        spin_unlock_irqrestore(&state_lock,irqflags);

}

LateResume

当所有的唤醒已经结束以后,  用户进程都已经开始运行了,  唤醒通常会是以下的几种原因:

来电

如果是来电,  那么Modem 会通过发送命令给rild 来让rild 通知WindowManager 有来电响应, 这样就会远程调用PowerManagerService 来写"on"  到/sys/power/state  来执行late resume 的设备,  比如点亮屏幕等.

用户按键

用户按键事件会送到WindowManager  中,WindowManager 会处理这些  按键事件, 按键分为几种情况,  如果案件不是唤醒键( 能够唤醒系统的按键)  那么WindowManager 会主动放弃wakeLock 来使系统进入再次休眠,  如果按键是唤醒键, 那么WindowManger 就会调用PowerManagerService 中的接口来执行Late Resume. Late Resume  会依次唤醒前面调用了Early Suspend 的设备.

static void late_resume(structwork_struct *work)

{

        struct early_suspend *pos;
        unsignedlong irqflags;
        intabort = 0;

        mutex_lock(&early_suspend_lock);
        spin_lock_irqsave(&state_lock,irqflags);
        if(state == SUSPENDED)
                state&= ~SUSPENDED;
        else
                abort= 1;
        spin_unlock_irqrestore(&state_lock,irqflags);
        if(abort) {
                if(debug_mask & DEBUG_SUSPEND)
                        pr_info("late_resume:abort, state %d", state);
                gotoabort;
        }

        if(debug_mask & DEBUG_SUSPEND)
                pr_info("late_resume:call handlers");
        list_for_each_entry_reverse(pos,&early_suspend_handlers, link)
                if(pos->resume != NULL)
                        pos->resume(pos);
        if(debug_mask & DEBUG_SUSPEND)
                pr_info("late_resume:done");

abort:
        mutex_unlock(&early_suspend_lock);

}

Wake Lock

我们接下来看一看wake lock 的机制是怎么运行和起作用的,  主要关注wakelock.c 文件就可以了.

wake lock  有加锁和解锁两种状态,  加锁的方式有两种,  一种是永久的锁住,  这样的锁除非显示的放开,  是不会解锁的,  所以这种锁的使用是非常小心的.  第二种是超时锁,  这种锁会锁定系统唤醒一段时间,  如果这个时间过去了,  这个锁会自动解除.

锁有两种类型:

WAKE_LOCK_SUSPEND  这种锁会防止系统进入睡眠 

WAKE_LOCK_IDLE  这种锁不会影响系统的休眠,  作用我不是很清楚.

在wakelock 中,  会有3 个地方让系统直接开始suspend(),  分别是:

在wake_unlock() 中,  如果发现解锁以后没有任何其他的wake lock 了,  就开始休眠  在定时器都到时间以后,  定时器的回调函数会查看是否有其他的wake lock,  如果没有,  就在这里让系统进入睡眠.  在wake_lock()  中,  对一个wake lock 加锁以后,  会再次检查一下有没有锁,  我想这里的检查是没有必要的,  更好的方法是使加锁的这个操作原子化,  而  不是繁冗的检查.  而且这样的检查也有可能漏掉.

Suspend

当wake_lock 运行suspend() 以后,  在wakelock.c 的suspend() 函数会被调用, 这个函数首先sync 文件系统, 然后调用pm_suspend(request_suspend_state), 接下来pm_suspend() 就会调用enter_state() 来进入Linux 的休眠流程..

static void suspend(structwork_struct *work),
{
        intret;
        intentry_event_num;

        if(has_wake_lock(WAKE_LOCK_SUSPEND)) {
                if(debug_mask & DEBUG_SUSPEND)
                        pr_info("suspend:abort suspend");
                return;
        }

        entry_event_num= current_event_num;
        sys_sync();
        if(debug_mask & DEBUG_SUSPEND)
                pr_info("suspend:enter suspend");

        ret= pm_suspend(requested_suspend_state);

        if (current_event_num == entry_event_num) {

               wake_lock_timeout(&unknown_wakeup,HZ / 2);
        }

}

Android 于标准Linux 休眠的区别

pm_suspend() 虽然会调用enter_state() 来进入标准的Linux 休眠流程, 但是还是有一些区别:

1 ，当进入冻结进程的时候, android 首先会检查有没有wakelock, 如果没有,  才会停止这些进程,  因为在开始suspend 和冻结进程期间有可能有人申请了wake lock, 如果是这样,  冻结进程会被中断. 

2 ，在suspend_late() 中,  会最后检查一次有没有wake lock,  这有可能是某种快速申请wake lock, 并且快速释放这个锁的进程导致的, 如果有这种情况,  这里会返回错误,  整个suspend 就会全部放弃. 如果pm_suspend() 成功了,LOG 的输出可以通过在kernel cmd 里面增加"no_console_suspend"  来看到suspend 和resume 过程中的log 输出.