Android睡眠唤醒机制--系统架构

出处:http://blog.csdn.net/myarrow/article/details/8137952

一、简介

     Android在Linux内核原有的睡眠唤醒模块上基础上,主要增加了下面三个机制:

     • Wake Lock 唤醒锁机制;
     • Early Suspend 预挂起机制;
     • Late Resume 迟唤醒机制;

     其基本原理:当启动一个应用程序的时候,它可以申请一个wake_lock唤醒锁,每当申请成功之后都会在内核中注册一下(通知系统内核,现在已经有锁被申请,系统内核的wake_lock_store把它加入红黑树中),当应用程序在某种情况下释放wake_lock的时候,会注销之前所申请的wake_lock。特别要注意的是:只要是系统中有一个wake_lock的时候,系统此时都不能进行睡眠。但此时各个模块可以进行early_suspend。当系统中所有的wake_lock都被释放之后,系统就会进入真正的kernel的睡眠状态。在系统启动的时候会创建一个主唤醒锁main_wake_lock,该锁是内核初始化并持有的一个WAKE_LOCK_SUSPEND属性的非限时唤醒锁。因此,系统正常工作时,将始终因为该锁被内核持有而无法进入睡眠状态。也就是说在不添加新锁的情况下,只需将main_wake_lock 解锁,系统即可进入睡眠状态。

      从Android最上层(Java的应用程序),经过Java、C++和C语言写的Framework层、JNI层、HAL层最后到达android的最底层(Kernel层)。

   

     下图是Android睡眠唤醒模块框架:

 二、相关代码

    • Frameworks

      // 供给上层应用程序调用的接口
      frameworks/base/core/java/android/os/PowerManager.java 

      // 具体实现PowerManager类中的接口
      frameworks/base/services/java/com/android/server/PowerManagerService.java        

      // 被PowerManagerService类调用

      frameworks/base/core/java/android/os/ Power.java

    • JNI

     // 实现Power类中的JNI接口
     frameworks/base/core/jni/android_os_Power.cpp

    • HAL

      // 进行sysfs用户接口的操作
      hardware/libhardware_legacy/power/power.c

    • Kernel

      kernel/kernel/power/main.c 
      kernel/kernel/power/earlysuspend.c
      kernel/kernel/power/suspend.c
      kernel/kernel/power/wakelock.c
      kernel/kernel/power/userwakelock.c

     在应用程序框架层中,PowerManager类是面向上层应用程序的接口类,提供了Wake Lock机制(同时也是睡眠唤醒子系统)的基本接口(唤醒锁的获取和释放)。上层应用程序通过调用这些接口,实现对系统电源状态的监控。

     • PowerManager类通过IBinder这种Android中特有的通信模式,与PowerManagerService 类进行通信。  

     • PowerManagerService 是PowerManager 类中定义的接口的具体实现,并进一步调用Power 类来与下一层进行通信。PowerManagerService 类是WakeLock 机制在应用程序框架层的核心,他们对应用程调用PowerManager类接口时所传递的参数进行初步的分析和对应的设置,并管理一个唤醒锁队列,然后配合其他模块(例如WatchDog、BatteryService、ShutdownThread 等)的状态信息,做出决策,调用Power类的对应接口,最终通过JNI 接口,调用到硬件抽象层中的函数,对sysfs 的用户接口进行操作,从而触发内核态实现的功能。

 三、获得wakelock唤醒锁
      比如在应用程序中,当获得wakelock唤醒锁的时候,它首先调用/android/frameworks/base/core/java/android/os/PowerManager类中的public void acquire()办法,而此方法通过Binder将调用PowerManagerService类中的public void acquireWakeLock。

     在用户态的调用流程如下:

[cpp]  view plain copy
  1. PowerManager.acquire()->  
  2.  PowerManager.acquireLocked()->  
  3.   PowerManagerService.acquireWakeLock(int flags, IBinder lock, String tag, WorkSource ws)->  
  4.    PowerManagerService.acquireWakeLockLocked(int flags, IBinder lock, int uid, int pid,   
  5.                                              String tag, WorkSource ws)->  
  6.     Power.acquireWakeLock(Power.PARTIAL_WAKE_LOCK,PARTIAL_NAME)->  
  7.      android_os_Power.cpp::acquireWakeLock(JNIEnv *env, jobject clazz, jint lock, jstring idObj)->  
  8.       power.c::acquire_wake_lock(int lock, const char* id)->  
  9.        write(fd, id, strlen(id))  

上述write实质上是文件sysfs: /sys/power/wake_lock,当write时,它将调用userwakelock.c::wake_lock_store()函数,其实现如下:
 

[cpp]  view plain copy
  1. ssize_t wake_lock_store(  
  2.     struct kobject *kobj, struct kobj_attribute *attr,  
  3.     const char *buf, size_t n)  
  4. {  
  5.     long timeout;  
  6.     struct user_wake_lock *l;  
  7.   
  8.     mutex_lock(&tree_lock);  
  9.     l = lookup_wake_lock_name(buf, 1, &timeout);  
  10.     if (IS_ERR(l)) {  
  11.         n = PTR_ERR(l);  
  12.         goto bad_name;  
  13.     }  
  14.   
  15.     if (debug_mask & DEBUG_ACCESS)  
  16.         pr_info("wake_lock_store: %s, timeout %ld\n", l->name, timeout);  
  17.   
  18.     if (timeout)  
  19.         wake_lock_timeout(&l->wake_lock, timeout);  
  20.     else  
  21.         wake_lock(&l->wake_lock);  
  22. bad_name:  
  23.     mutex_unlock(&tree_lock);  
  24.     return n;  
  25. }  


   1. 根据name在红黑树中查找user_wake_lock,若找到则直接返回;否则为它分配内存、调用wake_lock_init初始化、然后增加到红黑树中。

   2. 调用wake_lock或wake_lock_timeout,它将调用wake_lock_internal

[cpp]  view plain copy
  1. static void wake_lock_internal(  
  2.     struct wake_lock *lock, long timeout, int has_timeout)  
  3. {  
  4.     int type;  
  5.     unsigned long irqflags;  
  6.     long expire_in;  
  7.   
  8.     spin_lock_irqsave(&list_lock, irqflags);  
  9.     type = lock->flags & WAKE_LOCK_TYPE_MASK;  
  10.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  11.     BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));  
  12. #ifdef CONFIG_WAKELOCK_STAT  
  13.     if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {  
  14.         if (debug_mask & DEBUG_WAKEUP)  
  15.             pr_info("wakeup wake lock: %s\n", lock->name);  
  16.         wait_for_wakeup = 0;  
  17.         lock->stat.wakeup_count++;  
  18.     }  
  19.     if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&  
  20.         (long)(lock->expires - jiffies) <= 0) {  
  21.         wake_unlock_stat_locked(lock, 0);  
  22.         lock->stat.last_time = ktime_get();  
  23.     }  
  24. #endif  
  25.     if (!(lock->flags & WAKE_LOCK_ACTIVE)) {  
  26.         lock->flags |= WAKE_LOCK_ACTIVE;  
  27. #ifdef CONFIG_WAKELOCK_STAT  
  28.         lock->stat.last_time = ktime_get();  
  29. #endif  
  30.     }  
  31.     list_del(&lock->link);  
  32.     if (has_timeout) {  
  33.         if (debug_mask & DEBUG_WAKE_LOCK)  
  34.             pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",  
  35.                 lock->name, type, timeout / HZ,  
  36.                 (timeout % HZ) * MSEC_PER_SEC / HZ);  
  37.         lock->expires = jiffies + timeout;  
  38.         lock->flags |= WAKE_LOCK_AUTO_EXPIRE;  
  39.         list_add_tail(&lock->link, &active_wake_locks[type]);  
  40.     } else {  
  41.         if (debug_mask & DEBUG_WAKE_LOCK)  
  42.             pr_info("wake_lock: %s, type %d\n", lock->name, type);  
  43.         lock->expires = LONG_MAX;  
  44.         lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;  
  45.         list_add(&lock->link, &active_wake_locks[type]);  
  46.     }  
  47.     if (type == WAKE_LOCK_SUSPEND) {  
  48.         current_event_num++;  
  49. #ifdef CONFIG_WAKELOCK_STAT  
  50.         if (lock == &main_wake_lock)  
  51.             update_sleep_wait_stats_locked(1);  
  52.         else if (!wake_lock_active(&main_wake_lock))  
  53.             update_sleep_wait_stats_locked(0);  
  54. #endif  
  55.         if (has_timeout)  
  56.             expire_in = has_wake_lock_locked(type);  
  57.         else  
  58.             expire_in = -1;  
  59.         if (expire_in > 0) {  
  60.             if (debug_mask & DEBUG_EXPIRE)  
  61.                 pr_info("wake_lock: %s, start expire timer, "  
  62.                     "%ld\n", lock->name, expire_in);  
  63.             mod_timer(&expire_timer, jiffies + expire_in);  
  64.         } else {  
  65.             if (del_timer(&expire_timer))  
  66.                 if (debug_mask & DEBUG_EXPIRE)  
  67.                     pr_info("wake_lock: %s, stop expire timer\n",  
  68.                         lock->name);  
  69.             if (expire_in == 0)  
  70.                 queue_work(suspend_work_queue, &suspend_work);  
  71.         }  
  72.     }  
  73.     spin_unlock_irqrestore(&list_lock, irqflags);  
  74. }  

wake_lock_internal()函数流程: 
    1)  判断锁的类型是否有效,即是否为WAKE_LOCK_SUSPEND或WAKE_LOCK_IDLE某一种  
    2)  如果定义了CONFIG_WAKELOCK_STAT, 则更新struct wake_lock里面的用于统计锁信息的成员变量  
    3)  将锁从inactive_locks链表上取下,加到active_wake_locks链表上。如果是超期锁则设置锁的flag|=WAKE_LOCK_AUTO_EXPIRE,否则取消WAKE_LOCK_AUTO_EXPIRE标志。如果锁是WAKE_LOCK_SUSPEND型的,则继续下面的步骤。 
    4)  对于WAKE_LOCK_SUSPEND型的锁如果它是超期锁,则调用has_wake_lock_locked函数检查所有处于活动状态的WAKE_LOCK_SUSPEND锁(即在active_wake_locks链表上的WAKE_LOCK_SUSPEND锁,或者说当前被加锁了的WAKE_LOCK_SUSPEND锁),是否有超期锁已经过期,如果有则把过期超期锁从active_wake_locks上删除,挂到inactive_locks上。同时它还检查链表上有没有非超期锁,如果有则直接返回-1,否则它最终返回的是所有超期锁过期时间的最大值  
    5) 如果has_wake_lock_locked函数返回的是-1(表示当前活动锁有非超时锁)或者0(表示所有活动锁都是超时锁,且全已经超时),则删除expire_timer,并排队一个suspend工作到suspend_work_queue工作队列,最终系统会suspend。suspend函数完成suspend系统的任务,它是suspend_work这个工作的处理函数,suspend_workk排队到suspend_work_queue工作队列中,最终系统会处理这个work,调用其handler即suspend函数。该函数首先sync文件系统,然后调用pm_suspend(request_suspend_state),接下来pm_suspend()就会调用 enter_state()来进入 linux的suspend流程。
四、系统进入睡眠(suspend)
       当按了MID上的power键,经过一系统列的事务处理后,它会调用到PowerManager类中的goToSleep。在用户态的调用流程如下所示:
 

[cpp]  view plain copy
  1. PowerManager.goToSleep(long time)->  
  2.  PowerManagerService.goToSleep(long time)->  
  3.   PowerManagerService.goToSleepWithReason(time, WindowManagerPolicy.OFF_BECAUSE_OF_USER)->  
  4.    PowerManagerService.goToSleepLocked(long time, int reason)->  
  5.     PowerManagerService.setPowerState(SCREEN_OFF, false, reason)->  
  6.      PowerManagerService.sendNotificationLocked(false, WindowManagerPolicy.OFF_BECAUSE_OF_USER)  
  7.       PowerManagerService.setScreenStateLocked(true)->  
  8.        Power.setScreenState->  
  9.         android_os_Power.cpp::setScreenState->  
  10.          Power.c::set_screen_state(int on)->  
  11.           write(g_fds[REQUEST_STATE], buf, len)  

      上面的write将把"mem"写入/sys/power/state中。接下来,在kernel态,state_store函数将被调用。

      • Android特有的earlysuspend: request_suspend_state(state)
      • Linux标准的suspend:       enter_state(state)

      在state_store中,若定义了CONFIG_EARLYSUSPEND,则执行request_suspend_state(state)以先进入earlysuspend,然后根据wake_lock的状态决定是否进入suspend;否则直接执行enter_state(state)以进入suspend状态。

 


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值