[置顶] Android学习之wakelocks

Updated: 2013/03/18， 刚有时间浏览了最新的Android builder submit 2013的相关slides，其中有关于最新的android 对kernel的upstream的状态的总结，大家可以看看
http://events.linuxfoundation.org/images/stories/slides/abs2013_stultz.pdf

Wakelocks已经进入了kernel main stream：）

wakelock是android基于kernel的APM之上,构建的一个新的电源管理层, 使得用户可以通过获得wakelock来使得系统不会进入低功耗状态.

这里我们不讨论android这种实现的优劣, 只关注一下它的实现. 对于它的好坏以及对kernel的电源管理的讨论在最后的相关资料中都有详细的讨论,有兴趣的童鞋可以去参考参考.

首先来看看相关代码的位置

相关代码在内核的/kernel/power/目录下

fbearlysuspend.c

earlysuspend.c

consoleearlysuspend.c

wakelock.c

userwakelock.c

及相应的头文件: include/linux/wakelock.h

接着主要关注wakelock的实现:

1. 主要的数据结构
   wakelock的两种状态, 前者表示还不能suspend,后者表示可以suspe
   

   enum {
       WAKE_LOCK_SUSPEND, /* Prevent suspend */
       WAKE_LOCK_IDLE,    /* Prevent low power idle */
       WAKE_LOCK_TYPE_COUNT
   };

   struct wake_lock, 其中可以看出wakelock是由list管理起来, 并且有相应的过期时间及一些stat信息. 而且会有两个list分别对应上述两种类型的wakelock
   

   struct wake_lock {
   #ifdef CONFIG_HAS_WAKELOCK
       struct list_head    link;
       int                 flags;
       const char         *name;
       unsigned long       expires;
   #ifdef CONFIG_WAKELOCK_STAT
       struct {
           int             count;
           int             expire_count;
           int             wakeup_count;
           ktime_t         total_time;
           ktime_t         prevent_suspend_time;
           ktime_t         max_time;
           ktime_t         last_time;
       } stat;
   #endif
   #endif
   };
   

   static struct list_head active_wake_locks[WAKE_LOCK_TYPE_COUNT];
   static LIST_HEAD(inactive_locks);
   

   
   

   struct workqueue_struct *suspend_work_queue;  //用内核提供的workqueue来缓冲需要suspend的动作
                                                 //这里从后面的初始化可以看出使用的create_singlethread_workqueue接口
                                                 //意味着整个系统只有一个对应的workqueue,而不是per-CPU的多个.嘿嘿,android还没有出现多CPU的情况, 只有多核:)
   
   struct wake_lock main_wake_lock;              // 四个不同用途的wake_lock, 后面会介绍用处
   static struct wake_lock unknown_wakeup;
   static struct wake_lock suspend_backoff_lock;
   static struct wake_lock deleted_wake_locks;
   
   suspend_state_t requested_suspend_state = PM_SUSPEND_MEM    //这里表示wakelock使用的suspend状态是由内核提供的PM_SUSPEND_MEM
   

   这里解释一下内核电源管理中定义的几种PM suspend的状态
   PM_SUSPEND_ON, 通常的运行状态
   PM_SUSPEND_STANDBY, 待机状态, 外围设备不供电,而CPU进入低功耗状态
   PM_SUSPEND_MEM, 与STANDBY类似, 除此之外,CPU也会进入power off状态, 并把CPU的state转存到对应的SDRAM中,以便之后的suspend能够从中恢复CPU及kernel的运行状态
   PM_SUSPEND_MAX, 表示所有设备都不工作了, 并把处于suspend到disk的状态
   这里需要注意的是, 在SoC的环境下, 不同的厂商会有各自实现的PM, 所以有些驱动会需要在这两者之间进行必要的mapping.参见:OMAP3的suspend支持
   
   为了使得user能够通过wakelock提供的接口获取释放wakelock, 就像其它Android新增的内核模块一样, 这个wakelock设备被以platoform device&driver的方式实现.
   

   static struct dev_pm_ops power_driver_pm_ops = {
       .suspend_noirq = power_suspend_late,      //参见devices.txt的解释
   };
   
   static struct platform_driver power_driver = {
       .driver.name = "power",   
       .driver.pm = &power_driver_pm_ops,
   };
   static struct platform_device power_device = {
       .name = "power",          
   };

   
   
2. 主要的函数
   wakelocks_init 主要分为4个部分,如下
   

   static int __init wakelocks_init(void)
   {
       int ret;
       int i;
   
       // 1.初始化上文提到的几个数据结构, 关键是4种wakelock的初始化: 
       // deleted_wake_locks
       // main
       // unknown_wakeups
       // suspend_backoff
   
       for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)
           INIT_LIST_HEAD(&active_wake_locks[i]);
   
   #ifdef CONFIG_WAKELOCK_STAT
       wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,
               "deleted_wake_locks");
   #endif
       wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");
       wake_lock(&main_wake_lock);
       wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");
       wake_lock_init(&suspend_backoff_lock, WAKE_LOCK_SUSPEND,
                  "suspend_backoff");            
   
       // 2. 注册wakelocks的对外接口设备power
       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;
       }
   
       // 3. 创建唯一的workqueue内核线程suspend
       suspend_work_queue = create_singlethread_workqueue("suspend");
       if (suspend_work_queue == NULL) { 
           ret = -ENOMEM;
           goto err_suspend_work_queue;   
       }  
   
       // 4. 在procfs中创建wakelocks数据节点, 即/proc/wakelocks, 所有的wakelocks stat信息都通过它展现出来
   #ifdef CONFIG_WAKELOCK_STAT
       proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);
   #endif
   
       return 0;
   ...
       return ret;
   }
   

   
   void wake_lock_init(struct wake_lock *lock, int type, const char *name)
   初始化各个wakelock,并加入到对应的inactive_locks list
   
   关键的wake_lock_internal函数, 用来响应所有对wake_lock/wake_unlock的调用
   

   static void wake_lock_internal(
       struct wake_lock *lock, long timeout, int has_timeout)
   {
       int type;
       unsigned long irqflags;
       long expire_in;
       
       // 获得每个wakelock的spin lock
       spin_lock_irqsave(&list_lock, irqflags);
       // 获得当前wakelock的类型
       type = lock->flags & WAKE_LOCK_TYPE_MASK;
       BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
       BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));
       // 获取一些当前wakelock的信息
   #ifdef CONFIG_WAKELOCK_STAT
       if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {
           if (debug_mask & DEBUG_WAKEUP)
               pr_info("wakeup wake lock: %s\n", lock->name);
           wait_for_wakeup = 0;
           lock->stat.wakeup_count++;
       }
       if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&
           (long)(lock->expires - jiffies) <= 0) {
           wake_unlock_stat_locked(lock, 0);
           lock->stat.last_time = ktime_get();
       }
   #endif
       if (!(lock->flags & WAKE_LOCK_ACTIVE)) {
           lock->flags |= WAKE_LOCK_ACTIVE;
   #ifdef CONFIG_WAKELOCK_STAT
           lock->stat.last_time = ktime_get();
   #endif
       }
       list_del(&lock->link);
       // 根据是否是需要自动过期的锁来设定相应的过期时间
       // 这里需要注意的是
       // 如果是自动过期锁,则是一个queue类似的操作, 先进先出, 导致过期时先处理自动过期锁,再处理非自动过期锁
       // 如果是非自动过期,则是一个stack类似的操作, 后进先出
       if (has_timeout) {
           if (debug_mask & DEBUG_WAKE_LOCK)
               pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",
                   lock->name, type, timeout / HZ,
                   (timeout % HZ) * MSEC_PER_SEC / HZ);
           lock->expires = jiffies + timeout;
           lock->flags |= WAKE_LOCK_AUTO_EXPIRE;
           list_add_tail(&lock->link, &active_wake_locks[type]);
       } else {
           if (debug_mask & DEBUG_WAKE_LOCK)
               pr_info("wake_lock: %s, type %d\n", lock->name, type);
           lock->expires = LONG_MAX;
           lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;
           list_add(&lock->link, &active_wake_locks[type]);
       }
       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)
               expire_in = has_wake_lock_locked(type);
           else
               expire_in = -1;
           if (expire_in > 0) {
               if (debug_mask & DEBUG_EXPIRE)
                   pr_info("wake_lock: %s, start expire timer, "
                       "%ld\n", lock->name, expire_in);
               // 修改过期时间
               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->name);
               // 如果当前过期了,则调用注册的work_queue函数suspend来进行相应动作
               if (expire_in == 0)
                   queue_work(suspend_work_queue, &suspend_work);
           }
       }
       spin_unlock_irqrestore(&list_lock, irqflags);
   }
   
   

3. 关键的suspend函数
   
   

   static void suspend(struct work_struct *work)
   {
       int ret;
       int entry_event_num;      
       struct timespec ts_entry, ts_exit;
       
       // 简单check, 如果到这里却发现没有处在suspend的wakelock,肯定有问题,直接退出.
       if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
           if (debug_mask & DEBUG_SUSPEND)
               pr_info("suspend: abort suspend\n");
           return;
       }  
   
       entry_event_num = current_event_num;
       // 系统进入suspend之前,需要进行必要的sync,保证一些重要数据不会丢失
       sys_sync();
   
       if (debug_mask & DEBUG_SUSPEND)
           pr_info("suspend: enter suspend\n");
   
       getnstimeofday(&ts_entry);
       // 调用kernel中的标准pm接口,发出suspend请求
       ret = pm_suspend(requested_suspend_state);
       getnstimeofday(&ts_exit); 
   
       if (debug_mask & DEBUG_EXIT_SUSPEND) {
           struct rtc_time tm;   
           rtc_time_to_tm(ts_exit.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_exit.tv_nsec);
       }  
       
       // 因为调用pm_suspend会有延迟,这里做一些微调
       if (ts_exit.tv_sec - ts_entry.tv_sec <= 1) {
           ++suspend_short_count;
   
           if (suspend_short_count == SUSPEND_BACKOFF_THRESHOLD) {
               // 如果这时有多个wake lock suspend时间发生了,则做一定的延后
               suspend_backoff();
               suspend_short_count = 0;       
           }
       } else {
           suspend_short_count = 0;       
       }
       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);
       }
   }
   

   
   其余的函数都是一些工具函数,相当简单,这里就偷懒不说了:)
   
   
4. 与驱动层的接口
   hardware/libhardware_legacy/power/power.c
   定义了3种可用的用户接口,与framework提供的功能对应
   

   enum {
       ACQUIRE_PARTIAL_WAKE_LOCK = 0, 
       RELEASE_WAKE_LOCK,        
       REQUEST_STATE,
       OUR_FD_COUNT              
   };

   定义了3个sysfs的接口,用户通过操作对应的fd,来使用wakelock.
   

   const char * const NEW_PATHS[] = {
       "/sys/power/wake_lock",
       "/sys/power/wake_unlock", 
       "/sys/power/state"
   };

   与之上面对应的几个函数, 都是通过操作对应的sysfs接口,来控制pm的行为. 其中参数id,就是你能够在/proc/wakelocks中看到的那些名字
   

   int acquire_wake_lock(int lock, const char* id)
   int release_wake_lock(const char* id)
   int set_screen_state(int on)
   

   
   
5. framework层的接口
   frameworks/base/core/jni/android_os_Power.cpp
   services/java/com/android/server/PowerManagerService.java
   cmds/svc/src/com/android/commands/svc/PowerCommand.java
   通过这些文件中的接口管理系统的power状态, 调用驱动层的接口, 控制内核适当的改变cpu/screen的供电状态.
   
   
6. java层的接口
   参见http://developer.android.com/reference/android/os/PowerManager.html, 里面介绍的很清楚了,关于它的使用也有很多教程及建议,我就不在这里敷述了.
   

其它,

kernel-pm也提供了一个类似android wakelock的解决方案,值得一看(但是到目前为止,还没有merge到mainstream当中):

http://groups.google.com/group/linux.kernel/browse_frm/thread/b6fed7e38365c259/c92d8b4a41f87902?hl=en&tvc=1&q=linux.kernel+suspend+block+api+(version+6)#

相关资料:

What comes after suspend blockers , 详细介绍了什么是suspend和idle, 内核如何处理它们, 以及android中的wakelock与内核中标准的suspend的区别
标准内核中的suspend/idle实现是基于QOS的反馈来完成的
其中提到了一个suspend block api,可以使得基于标准内核的驱动程序使用它来达到android实现的wakelock逻辑. 不过,不知道有没有人这样用过!!!
pm_qos API用来提供内核所需要的关于power manager相关的QOS信息

The cpuidle subsystem,

http://elinux.org/images/e/e6/Elce11_wysocki.pdf

http://elinux.org/images/0/09/Elce11_pieralisi.pdf--arm电源管理, 尤其针对CPU PW management

http://www.slideshare.net/jserv/power-management-from-linux-kernel-to-android --Power Management from Linux Kernel to Android

http://lwn.net/images/pdf/suspend_blockers.pdf -- 关于android的wakelock的一个详细说明