码迷，mamicode.com
首页 > 移动开发 > 详细

android 休眠唤醒机制分析(一) — wake_lock

时间：2014-07-16 21:38:22      阅读：323      评论：0      收藏：0      [点我收藏+]

标签：android   des   blog   http   使用   strong   

本文转自：http://blog.csdn.net/g_salamander/article/details/7978772

Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。本文主要分析driver层wake_lock的实现。

一、wake_lock 定义和接口

 

[cpp] view plaincopy
 
  1. enum {  
  2.     WAKE_LOCK_SUSPEND, // 阻止进入深度休眠模式  
  3.     WAKE_LOCK_IDLE,    // 阻止进入空闲模式  
  4.     WAKE_LOCK_TYPE_COUNT  
  5. };  
  6.   
  7. struct wake_lock {  
  8. #ifdef CONFIG_HAS_WAKELOCK  
  9.     struct list_head    link;     // 链表节点  
  10.     int                 flags;    // 标志  
  11.     const char         *name;     // 名称  
  12.     unsigned long       expires;  // 超时时间  
  13. #ifdef CONFIG_WAKELOCK_STAT  
  14.     struct {  
  15.         int             count;         // 使用计数  
  16.         int             expire_count;  // 超时计数  
  17.         int             wakeup_count;  // 唤醒计数  
  18.         ktime_t         total_time;    // 锁使用时间  
  19.         ktime_t         prevent_suspend_time;  // 锁阻止休眠的时间  
  20.         ktime_t         max_time;      // 锁使用时间最长的一次  
  21.         ktime_t         last_time;     // 锁上次操作时间  
  22.     } stat;  
  23. #endif  
  24. #endif  
  25. };  

 

可以看到wake_lock按功能分为休眠锁和空闲锁两种类型，用于阻止系统进入深度休眠模式或者空闲模式。wake_lock的主要部件有锁名称、链表节点、标志位、超时时间，另外还有一个内嵌的结构用于统计锁的使用信息。接下来我们看看wake_lock对外提供的操作接口：

1、内核空间接口

 

[cpp] view plaincopy
 
  1. void wake_lock_init(struct wake_lock *lock, int type, const char *name);  
  2. void wake_lock_destroy(struct wake_lock *lock);  
  3. void wake_lock(struct wake_lock *lock);  
  4. void wake_lock_timeout(struct wake_lock *lock, long timeout);  
  5. void wake_unlock(struct wake_lock *lock);  

其中wake_lock_init()用于初始化一个新锁，type参数指定了锁的类型；wake_lock_destroy()则注销一个锁；wake_lock()和wake_lock_timeout()用于将初始化完成的锁激活，使之成为有效的永久锁或者超时锁；wake_unlock()用于解锁使之成为无效锁。另外还有两个接口：

 

 

[cpp] view plaincopy
 
  1. int wake_lock_active(struct wake_lock *lock);  
  2. long has_wake_lock(int type);  

其中wake_lock_active()用于判断锁当前是否有效，如果有效则返回非0值；has_wake_lock()用于判断系统中是否还存在有效的type型锁，如果存在超时锁则返回最长的一个锁的超时时间，如果存在永久锁则返回-1，如果系统中不存在有效锁则返回0。

2、用户空间接口

wake_lock向用户空间提供了两个文件节点用于申请锁和解锁：

 

 

[cpp] view plaincopy
 
  1. // wack_lock文件的读函数,显示用户空间定义的有效锁  
  2. ssize_t wake_lock_show(  
  3.     struct kobject *kobj, struct kobj_attribute *attr, char *buf)  
  4. {  
  5.     char *s = buf;  
  6.     char *end = buf + PAGE_SIZE;  
  7.     struct rb_node *n;  
  8.     struct user_wake_lock *l;  
  9.   
  10.     mutex_lock(&tree_lock);  
  11.   
  12.     for (n = rb_first(&user_wake_locks); n != NULL; n = rb_next(n)) {  
  13.         l = rb_entry(n, struct user_wake_lock, node);  
  14.         if (wake_lock_active(&l->wake_lock))  
  15.             s += scnprintf(s, end - s, "%s ", l->name);  
  16.     }  
  17.     s += scnprintf(s, end - s, "\n");  
  18.   
  19.     mutex_unlock(&tree_lock);  
  20.     return (s - buf);  
  21. }  
  22.   
  23. // wack_lock文件的写函数,初始化并激活用户空间定义的锁  
  24. ssize_t wake_lock_store(  
  25.     struct kobject *kobj, struct kobj_attribute *attr,  
  26.     const char *buf, size_t n)  
  27. {  
  28.     long timeout;  
  29.     struct user_wake_lock *l;  
  30.   
  31.     mutex_lock(&tree_lock);  
  32.     l = lookup_wake_lock_name(buf, 1, &timeout);  
  33.     if (IS_ERR(l)) {  
  34.         n = PTR_ERR(l);  
  35.         goto bad_name;  
  36.     }  
  37.   
  38.     if (debug_mask & DEBUG_ACCESS)  
  39.         pr_info("wake_lock_store: %s, timeout %ld\n", l->name, timeout);  
  40.   
  41.     if (timeout)  
  42.         wake_lock_timeout(&l->wake_lock, timeout);  
  43.     else  
  44.         wake_lock(&l->wake_lock);  
  45. bad_name:  
  46.     mutex_unlock(&tree_lock);  
  47.     return n;  
  48. }  
  49.   
  50. // wack_unlock文件的读函数,显示用户空间的无效锁  
  51. ssize_t wake_unlock_show(  
  52.     struct kobject *kobj, struct kobj_attribute *attr, char *buf)  
  53. {  
  54.     char *s = buf;  
  55.     char *end = buf + PAGE_SIZE;  
  56.     struct rb_node *n;  
  57.     struct user_wake_lock *l;  
  58.   
  59.     mutex_lock(&tree_lock);  
  60.   
  61.     for (n = rb_first(&user_wake_locks); n != NULL; n = rb_next(n)) {  
  62.         l = rb_entry(n, struct user_wake_lock, node);  
  63.         if (!wake_lock_active(&l->wake_lock))  
  64.             s += scnprintf(s, end - s, "%s ", l->name);  
  65.     }  
  66.     s += scnprintf(s, end - s, "\n");  
  67.   
  68.     mutex_unlock(&tree_lock);  
  69.     return (s - buf);  
  70. }  
  71.   
  72. // wack_unlock文件的写函数,用于用户空间解锁  
  73. ssize_t wake_unlock_store(  
  74.     struct kobject *kobj, struct kobj_attribute *attr,  
  75.     const char *buf, size_t n)  
  76. {  
  77.     struct user_wake_lock *l;  
  78.   
  79.     mutex_lock(&tree_lock);  
  80.     l = lookup_wake_lock_name(buf, 0, NULL);  
  81.     if (IS_ERR(l)) {  
  82.         n = PTR_ERR(l);  
  83.         goto not_found;  
  84.     }  
  85.   
  86.     if (debug_mask & DEBUG_ACCESS)  
  87.         pr_info("wake_unlock_store: %s\n", l->name);  
  88.   
  89.     wake_unlock(&l->wake_lock);  
  90. not_found:  
  91.     mutex_unlock(&tree_lock);  
  92.     return n;  
  93. }  
  94.   
  95. power_attr(wake_lock);  
  96. power_attr(wake_unlock);  

这两个文件节点分别为"/sys/power/wake_lock"和"/sys/power/wake_unlock"，应用程序可以根据HAL层的接口读写这两个节点。
二、wake_lock 实现
在linux/kernel/power/wakelock.c中我们可以看到wake_lock的实现代码，首先看看其定义的一些初始化信息：

 

 

[cpp] view plaincopy
 
  1. #define WAKE_LOCK_TYPE_MASK              (0x0f)     // 锁类型标志掩码  
  2. #define WAKE_LOCK_INITIALIZED            (1U << 8)  // 锁已经初始化标志  
  3. #define WAKE_LOCK_ACTIVE                 (1U << 9)  // 锁有效标志  
  4. #define WAKE_LOCK_AUTO_EXPIRE            (1U << 10) // 超时锁标志  
  5. #define WAKE_LOCK_PREVENTING_SUSPEND     (1U << 11) // 正在阻止休眠标志  
  6.   
  7. static DEFINE_SPINLOCK(list_lock);  // 读写锁链表的自旋锁  
  8. static LIST_HEAD(inactive_locks);   // 内核维护的无效锁链表  
  9. static struct list_head active_wake_locks[WAKE_LOCK_TYPE_COUNT];  // 有效锁链表  
  10. static int current_event_num;       // 休眠锁使用计数器  
  11. struct workqueue_struct *suspend_work_queue;  // 执行系统休眠的工作队列  
  12. struct workqueue_struct *sys_sync_work_queue; // 执行系统同步的工作队列  
  13. struct wake_lock main_wake_lock;              // 内核休眠锁  
  14. struct wake_lock sys_sync_wake_lock;          // 缓存同步锁  
  15. suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;  // 系统休眠状态  
  16. static struct wake_lock unknown_wakeup;       // 未知锁  

在后面的分析中我们会看到这些变量的具体用途。

1、wake_lock系统初始化

 

[cpp] view plaincopy
 
  1. static int __init wakelocks_init(void)  
  2. {  
  3.     int ret;  
  4.     int i;  
  5.     // 初始化有效锁链表,内核维护了2个有效锁链表  
  6.     // WAKE_LOCK_SUSPEND 用于阻止进入深度休眠模式  
  7.     // WAKE_LOCK_IDLE    用于阻止进入空闲模式  
  8.     for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)  
  9.         INIT_LIST_HEAD(&active_wake_locks[i]);  
  10.   
  11. #ifdef CONFIG_WAKELOCK_STAT  
  12.     // 初始化deleted_wake_locks  
  13.     wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,  
  14.             "deleted_wake_locks");  
  15. #endif  
  16.     // 初始化内核休眠锁  
  17.     wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");  
  18.     // 初始化同步锁  
  19.     wake_lock_init(&sys_sync_wake_lock, WAKE_LOCK_SUSPEND, "sys_sync");  
  20.     // 激活内核休眠锁  
  21.     wake_lock(&main_wake_lock);  
  22.     // 初始化未知锁  
  23.     wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");  
  24.   
  25.     // 注册power_device,power_driver  
  26.     ret = platform_device_register(&power_device);  
  27.     if (ret) {  
  28.         pr_err("wakelocks_init: platform_device_register failed\n");  
  29.         goto err_platform_device_register;  
  30.     }  
  31.     ret = platform_driver_register(&power_driver);  
  32.     if (ret) {  
  33.         pr_err("wakelocks_init: platform_driver_register failed\n");  
  34.         goto err_platform_driver_register;  
  35.     }  
  36.     // 创建fs_sync内核进程  
  37.     sys_sync_work_queue = create_singlethread_workqueue("fs_sync");  
  38.     if (sys_sync_work_queue == NULL) {  
  39.         pr_err ("fs_sync workqueue create failed.\n");  
  40.     }  
  41.     // 创建suspend内核进程  
  42.     suspend_work_queue = create_singlethread_workqueue("suspend");  
  43.     if (suspend_work_queue == NULL) {  
  44.         ret = -ENOMEM;  
  45.         goto err_suspend_work_queue;  
  46.     }  
  47.   
  48. #ifdef CONFIG_WAKELOCK_STAT  
  49.     // 在proc下创建wakelocks文件  
  50.     proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);  
  51. #endif  
  52.   
  53.     return 0;  
  54.   
  55. err_suspend_work_queue:  
  56.     platform_driver_unregister(&power_driver);  
  57. err_platform_driver_register:  
  58.     platform_device_unregister(&power_device);  
  59. err_platform_device_register:  
  60.     wake_lock_destroy(&unknown_wakeup);  
  61.     wake_lock_destroy(&main_wake_lock);  
  62. #ifdef CONFIG_WAKELOCK_STAT  
  63.     wake_lock_destroy(&deleted_wake_locks);  
  64. #endif  
  65.     return ret;  
  66. }  
  67. core_initcall(wakelocks_init);  

可以看到内核通过core_initcall调用了wake_lock系统的初始化函数，函数首先初始化了两个有效锁的链表，用于管理系统中的有效锁；接下来初始化了deleted_wake_locks用于处理统计信息，main_wake_lock用于锁定内核（系统启动时会激活这个锁，深度休眠时需要释放这个锁），sys_sync_wake_lock用于浅度休眠阶段同步缓存时阻止内核进入深度休眠，unknown_wakeup用于唤醒时延迟0.5s进入下一次可能的深度休眠；还注册了一个platform_device用于深度休眠阶段检测是否存在有效锁；后面创建了内核进程fs_sync用于浅度休眠阶段同步缓存，内核进程suspend用于进行浅度休眠和深度休眠；还在/proc下面创建了wakelocks节点用于显示wake_lock的统计信息。

2、wake_lock初始化

 

[cpp] view plaincopy
 
  1. void wake_lock_init(struct wake_lock *lock, int type, const char *name)  
  2. {  
  3.     unsigned long irqflags = 0;  
  4.     // 初始化名称  
  5.     if (name)  
  6.         lock->name = name;  
  7.     BUG_ON(!lock->name);  
  8.   
  9.     if (debug_mask & DEBUG_WAKE_LOCK)  
  10.         pr_info("wake_lock_init name=%s\n", lock->name);  
  11. #ifdef CONFIG_WAKELOCK_STAT  
  12.     lock->stat.count = 0;  
  13.     lock->stat.expire_count = 0;  
  14.     lock->stat.wakeup_count = 0;  
  15.     lock->stat.total_time = ktime_set(0, 0);  
  16.     lock->stat.prevent_suspend_time = ktime_set(0, 0);  
  17.     lock->stat.max_time = ktime_set(0, 0);  
  18.     lock->stat.last_time = ktime_set(0, 0);  
  19. #endif  
  20.     // 初始化flag  
  21.     lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;  
  22.     // 初始化链表节点  
  23.     INIT_LIST_HEAD(&lock->link);  
  24.     spin_lock_irqsave(&list_lock, irqflags);  
  25.     // 将锁加入无效锁链表  
  26.     list_add(&lock->link, &inactive_locks);  
  27.     spin_unlock_irqrestore(&list_lock, irqflags);  
  28. }  
  29. EXPORT_SYMBOL(wake_lock_init);  

其中参数lock为被初始化对象，type代表锁的类型，name表示锁的名称， 函数主要初始化锁的名称并设置 WAKE_LOCK_INITIALIZED 标志位，并将锁加入无效锁链表inactive_locks，当需要使用锁的时候通过wake_lock()或者wake_lock_timeout()激活该锁：

 

 

[cpp] view plaincopy
 
  1. // 根据参数激活锁  
  2. static void wake_lock_internal(  
  3.     struct wake_lock *lock, long timeout, int has_timeout)  
  4. {  
  5.     int type;  
  6.     unsigned long irqflags;  
  7.     long expire_in;  
  8.   
  9.     spin_lock_irqsave(&list_lock, irqflags);  
  10.     // 获取锁的类型  
  11.     type = lock->flags & WAKE_LOCK_TYPE_MASK;  
  12.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  13.     BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));  
  14. #ifdef CONFIG_WAKELOCK_STAT  
  15.     if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {  
  16.         if (debug_mask & DEBUG_WAKEUP)  
  17.             pr_info("wakeup wake lock: %s\n", lock->name);  
  18.         wait_for_wakeup = 0;  
  19.         lock->stat.wakeup_count++;  
  20.     }  
  21.     if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&  
  22.         (long)(lock->expires - jiffies) <= 0) {  
  23.         wake_unlock_stat_locked(lock, 0);  
  24.         lock->stat.last_time = ktime_get();  
  25.     }  
  26. #endif  
  27.     // 设置锁有效的标志位  
  28.     if (!(lock->flags & WAKE_LOCK_ACTIVE)) {  
  29.         lock->flags |= WAKE_LOCK_ACTIVE;  
  30. #ifdef CONFIG_WAKELOCK_STAT  
  31.         lock->stat.last_time = ktime_get();  
  32. #endif  
  33.     }  
  34.     // 将锁从无效锁链表中删除  
  35.     list_del(&lock->link);  
  36.     // 如果是超时锁  
  37.     if (has_timeout) {  
  38.         if (debug_mask & DEBUG_WAKE_LOCK)  
  39.             pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",  
  40.                 lock->name, type, timeout / HZ,  
  41.                 (timeout % HZ) * MSEC_PER_SEC / HZ);  
  42.         // 设置锁超时时间,以当前jiffies为基准  
  43.         lock->expires = jiffies + timeout;  
  44.         // 设置锁的超时锁标志  
  45.         lock->flags |= WAKE_LOCK_AUTO_EXPIRE;  
  46.         // 将锁加入有效锁链表  
  47.         list_add_tail(&lock->link, &active_wake_locks[type]);  
  48.     } else {  // 如果是永久锁  
  49.         if (debug_mask & DEBUG_WAKE_LOCK)  
  50.             pr_info("wake_lock: %s, type %d\n", lock->name, type);  
  51.         // 设置超时时间为极限  
  52.         lock->expires = LONG_MAX;  
  53.         // 清除超时锁标志  
  54.         lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;  
  55.         // 将锁加入有效锁链表  
  56.         list_add(&lock->link, &active_wake_locks[type]);  
  57.     }  
  58.     // 如果是休眠锁  
  59.     if (type == WAKE_LOCK_SUSPEND) {  
  60.         current_event_num++;  // 休眠锁使用计数器加1  
  61. #ifdef CONFIG_WAKELOCK_STAT  
  62.         // 如果是内核休眠锁  
  63.         if (lock == &main_wake_lock)  
  64.             update_sleep_wait_stats_locked(1);  
  65.         // 如果内核休眠锁无效  
  66.         else if (!wake_lock_active(&main_wake_lock))  
  67.             update_sleep_wait_stats_locked(0);  
  68. #endif  
  69.         // 如果是超时锁  
  70.         if (has_timeout)  
  71.             expire_in = has_wake_lock_locked(type);  
  72.         else  
  73.             expire_in = -1;  
  74.         // 当前存在有效超时锁,并且最长的一个到期时间间隔为expire_in  
  75.         if (expire_in > 0) {  
  76.             if (debug_mask & DEBUG_EXPIRE)  
  77.                 pr_info("wake_lock: %s, start expire timer, "  
  78.                     "%ld\n", lock->name, expire_in);  
  79.             mod_timer(&expire_timer, jiffies + expire_in);  
  80.         } else {  // 如果有永久锁或者无有效锁  
  81.             if (del_timer(&expire_timer))  
  82.                 if (debug_mask & DEBUG_EXPIRE)  
  83.                     pr_info("wake_lock: %s, stop expire timer\n",  
  84.                         lock->name);  
  85.             if (expire_in == 0)  // 无有效锁  
  86.                 queue_work(suspend_work_queue, &suspend_work);  
  87.         }  
  88.     }  
  89.     spin_unlock_irqrestore(&list_lock, irqflags);  
  90. }  
  91.   
  92. // 激活永久锁  
  93. void wake_lock(struct wake_lock *lock)  
  94. {  
  95.     wake_lock_internal(lock, 0, 0);  
  96. }  
  97. EXPORT_SYMBOL(wake_lock);  
  98.   
  99. // 激活超时锁  
  100. void wake_lock_timeout(struct wake_lock *lock, long timeout)  
  101. {  
  102.     wake_lock_internal(lock, timeout, 1);  
  103. }  
  104. EXPORT_SYMBOL(wake_lock_timeout);  

可以看到激活过程都是通过调用wake_lock_internal()完成的，该函数首先完成一些统计信息的初始化，设置 WAKE_LOCK_ACTIVE 标志位并将锁从无效锁链表中移除；然后根据是否是超时锁设置 WAKE_LOCK_AUTO_EXPIRE 标志位，并设置超时锁的超时时间，再将锁加入有效锁链表；最后再根据锁的类型判断是否为休眠锁，如果是休眠锁且为超时锁则通过has_wake_lock_locked()获取系统中存在的超时锁中时间最长的到期时间值，并以此值设置expire_timer，has_wake_lock_locked()返回0则表示系统中不存在有效锁则启动suspend进程开始进入深度休眠状态。

 

3、expire_timer

[cpp] view plaincopy
 
  1. static void expire_wake_locks(unsigned long data)  
  2. {  
  3.     long has_lock;  
  4.     unsigned long irqflags;  
  5.     if (debug_mask & DEBUG_EXPIRE)  
  6.         pr_info("expire_wake_locks: start\n");  
  7.     spin_lock_irqsave(&list_lock, irqflags);  
  8.     // 打印当前的有效锁  
  9.     if (debug_mask & DEBUG_SUSPEND)  
  10.         print_active_locks(WAKE_LOCK_SUSPEND);  
  11.     // 检测系统是否持有休眠锁  
  12.     has_lock = has_wake_lock_locked(WAKE_LOCK_SUSPEND);  
  13.     if (debug_mask & DEBUG_EXPIRE)  
  14.         pr_info("expire_wake_locks: done, has_lock %ld\n", has_lock);  
  15.     // 如果系统当前没有持有有效地休眠锁  
  16.     if (has_lock == 0)  
  17.         // 则启动深度休眠工作队列  
  18.         queue_work(suspend_work_queue, &suspend_work);  
  19.     spin_unlock_irqrestore(&list_lock, irqflags);  
  20. }  
  21. // 定义timer,运行函数为expire_wake_locks  
  22. static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);  

该timer会在多个地方用到，在激活锁的函数中注册用于超时锁到期后检测系统的有效锁状态，如果系统不存在有效锁了则启动suspend进程。
4、suspend_work

[cpp] view plaincopy
 
  1. static void suspend(struct work_struct *work)  
  2. {  
  3.     int ret;  
  4.     int entry_event_num;  
  5.   
  6.     // 判断系统是否还持有有效锁,如果有则直接返回  
  7.     if (has_wake_lock(WAKE_LOCK_SUSPEND)) {  
  8.         if (debug_mask & DEBUG_SUSPEND)  
  9.             pr_info("suspend: abort suspend\n");  
  10.         return;  
  11.     }  
  12.   
  13.     // 记录函数进入时休眠锁的使用次数  
  14.     entry_event_num = current_event_num;  
  15.     sys_sync();  // 将缓存中的数据写入磁盘  
  16.     if (debug_mask & DEBUG_SUSPEND)  
  17.         pr_info("suspend: enter suspend\n");  
  18.     // 开始深度休眠  
  19.     ret = pm_suspend(requested_suspend_state);  
  20.     // 退出深度休眠,打印信息  
  21.     if (debug_mask & DEBUG_EXIT_SUSPEND) {  
  22.         struct timespec ts;  
  23.         struct rtc_time tm;  
  24.         getnstimeofday(&ts);  
  25.         rtc_time_to_tm(ts.tv_sec, &tm);  
  26.         pr_info("suspend: exit suspend, ret = %d "  
  27.             "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n", ret,  
  28.             tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,  
  29.             tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);  
  30.     }  
  31.     // 如果深度休眠前和深度休眠后锁的使用次数一致，即唤醒过程中没有激活新的锁  
  32.     if (current_event_num == entry_event_num) {  
  33.         if (debug_mask & DEBUG_SUSPEND)  
  34.             pr_info("suspend: pm_suspend returned with no event\n");  
  35.         // 激活unknown_wakeup,0.5s超时  
  36.         wake_lock_timeout(&unknown_wakeup, HZ / 2);  
  37.     }  
  38. }  
  39. // 声明工作队列,运行函数为suspend  
  40. static DECLARE_WORK(suspend_work, suspend);  

声明工作队列用于内核深度休眠，可以看到一个正常的休眠流程会三次调用sys_sync()用于同步缓存（之前一次在浅度休眠，之后一次在深度休眠），然后调用pm_suspend()开始执行深度休眠流程。
5、has_wake_lock

 

 

[cpp] view plaincopy
 
  1. // 移除过期超时锁  
  2. static void expire_wake_lock(struct wake_lock *lock)  
  3. {  
  4. #ifdef CONFIG_WAKELOCK_STAT  
  5.     wake_unlock_stat_locked(lock, 1);  
  6. #endif  
  7.     // 清除锁有效和超时锁标志  
  8.     lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);  
  9.     // 从当前链表中删除  
  10.     list_del(&lock->link);  
  11.     // 加入无效锁链表  
  12.     list_add(&lock->link, &inactive_locks);  
  13.     if (debug_mask & (DEBUG_WAKE_LOCK | DEBUG_EXPIRE))  
  14.         pr_info("expired wake lock %s\n", lock->name);  
  15. }  
  16.   
  17. // 打印有效锁信息,调用者需持有list_lock  
  18. static void print_active_locks(int type)  
  19. {  
  20.     struct wake_lock *lock;  
  21.     bool print_expired = true;  
  22.   
  23.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  24.     // 遍历有效锁链表  
  25.     list_for_each_entry(lock, &active_wake_locks[type], link) {  
  26.         // 如果是超时锁  
  27.         if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {  
  28.             // 计算超时剩余时间  
  29.             long timeout = lock->expires - jiffies;  
  30.             if (timeout > 0)  
  31.                 pr_info("active wake lock %s, time left %ld\n",  
  32.                     lock->name, timeout);  
  33.             else if (print_expired)  
  34.                 pr_info("wake lock %s, expired\n", lock->name);  
  35.         } else {  // 如果不是超时锁  
  36.             pr_info("active wake lock %s\n", lock->name);  
  37.             if (!debug_mask & DEBUG_EXPIRE)  
  38.                 print_expired = false;  
  39.         }  
  40.     }  
  41. }  
  42.   
  43. static long has_wake_lock_locked(int type)  
  44. {  
  45.     struct wake_lock *lock, *n;  
  46.     long max_timeout = 0;  
  47.   
  48.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);  
  49.     // 遍历有效锁链表  
  50.     list_for_each_entry_safe(lock, n, &active_wake_locks[type], link) {  
  51.         // 如果是超时锁  
  52.         if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {  
  53.             // 计算超时剩余时间  
  54.             long timeout = lock->expires - jiffies;  
  55.             // 如果锁已经过期  
  56.             if (timeout <= 0)  
  57.                 // 移除过期锁  
  58.                 expire_wake_lock(lock);  
  59.             else if (timeout > max_timeout)  // 如果锁没有过期  
  60.                 // 得到最长的一个超时时间  
  61.                 max_timeout = timeout;  
  62.         } else // 如果不是超时锁则返回-1  
  63.             return -1;  
  64.     }  
  65.     return max_timeout;  
  66. }  
  67.   
  68. // 判断系统是否还持有有效锁  
  69. long has_wake_lock(int type)  
  70. {  
  71.     long ret;  
  72.     unsigned long irqflags;  
  73.     spin_lock_irqsave(&list_lock, irqflags);  
  74.     // 开始判断流程  
  75.     ret = has_wake_lock_locked(type);  
  76.     // 如果还有休眠锁有效则打印状态信息  
  77.     if (ret && (debug_mask & DEBUG_SUSPEND) && type == WAKE_LOCK_SUSPEND)  
  78.         print_active_locks(type);  
  79.     spin_unlock_irqrestore(&list_lock, irqflags);  
  80.     return ret;  
  81. }  

has_wake_lock()为系统判断当前是否存在指定类型有效锁的接口，在has_wake_lock_locked()中遍历有效锁链表，返回前面我们已经说明的值；并且打印所有有效锁的状态信息。
6、wake_unlock

 

[cpp] view plaincopy
 
  1. void wake_unlock(struct wake_lock *lock)  
  2. {  
  3.     int type;  
  4.     unsigned long irqflags;  
  5.     spin_lock_irqsave(&list_lock, irqflags);  
  6.     type = lock->flags & WAKE_LOCK_TYPE_MASK;  
  7. #ifdef CONFIG_WAKELOCK_STAT  
  8.     // 更新锁的状态  
  9.     wake_unlock_stat_locked(lock, 0);  
  10. #endif  
  11.     if (debug_mask & DEBUG_WAKE_LOCK)  
  12.         pr_info("wake_unlock: %s\n", lock->name);  
  13.     // 清楚有效锁和超时锁标志  
  14.     lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);  
  15.     // 将锁从有效锁链表中移除加入无效锁链表  
  16.     list_del(&lock->link);  
  17.     list_add(&lock->link, &inactive_locks);  
  18.     // 如果是休眠锁  
  19.     if (type == WAKE_LOCK_SUSPEND) {  
  20.         // 判断系统当前是否还持有锁  
  21.         long has_lock = has_wake_lock_locked(type);  
  22.         // 如果还持有锁,设置timer到超时时间点触发  
  23.         if (has_lock > 0) {  
  24.             if (debug_mask & DEBUG_EXPIRE)  
  25.                 pr_info("wake_unlock: %s, start expire timer, "  
  26.                     "%ld\n", lock->name, has_lock);  
  27.             mod_timer(&expire_timer, jiffies + has_lock);  
  28.         } else {  
  29.             if (del_timer(&expire_timer))  // 删除timer  
  30.                 if (debug_mask & DEBUG_EXPIRE)  
  31.                     pr_info("wake_unlock: %s, stop expire "  
  32.                         "timer\n", lock->name);  
  33.             if (has_lock == 0)  // 启动深度休眠工作队列  
  34.                 queue_work(suspend_work_queue, &suspend_work);  
  35.         }  
  36.         // 如果是内核锁  
  37.         if (lock == &main_wake_lock) {  
  38.             if (debug_mask & DEBUG_SUSPEND)  
  39.                 // 打印当前有效锁信息  
  40.                 print_active_locks(WAKE_LOCK_SUSPEND);  
  41. #ifdef CONFIG_WAKELOCK_STAT  
  42.             update_sleep_wait_stats_locked(0);  
  43. #endif  
  44.         }  
  45.     }  
  46.     spin_unlock_irqrestore(&list_lock, irqflags);  
  47. }  
  48. EXPORT_SYMBOL(wake_unlock);  

该函数用于释放一个锁，首先将锁从有效锁链表中移除并加入无效锁链表，并判断系统是否还持有有效锁，如果没有则进入深度休眠流程。

 

7、wake_lock_active

 

[cpp] view plaincopy
 
  1. // 判断锁是否有效  
  2. int wake_lock_active(struct wake_lock *lock)  
  3. {  
  4.     return !!(lock->flags & WAKE_LOCK_ACTIVE);  
  5. }  
  6. EXPORT_SYMBOL(wake_lock_active);  

8、wake_lock_destroy

 

 

[cpp] view plaincopy
 
  1. void wake_lock_destroy(struct wake_lock *lock)  
  2. {  
  3.     unsigned long irqflags;  
  4.     if (debug_mask & DEBUG_WAKE_LOCK)  
  5.         pr_info("wake_lock_destroy name=%s\n", lock->name);  
  6.     spin_lock_irqsave(&list_lock, irqflags);  
  7.     // 清除已经初始化的标志  
  8.     lock->flags &= ~WAKE_LOCK_INITIALIZED;  
  9. #ifdef CONFIG_WAKELOCK_STAT  
  10.     if (lock->stat.count) {  
  11.         deleted_wake_locks.stat.count += lock->stat.count;  
  12.         deleted_wake_locks.stat.expire_count += lock->stat.expire_count;  
  13.         deleted_wake_locks.stat.total_time =  
  14.             ktime_add(deleted_wake_locks.stat.total_time,  
  15.                   lock->stat.total_time);  
  16.         deleted_wake_locks.stat.prevent_suspend_time =  
  17.             ktime_add(deleted_wake_locks.stat.prevent_suspend_time,  
  18.                   lock->stat.prevent_suspend_time);  
  19.         deleted_wake_locks.stat.max_time =  
  20.             ktime_add(deleted_wake_locks.stat.max_time,  
  21.                   lock->stat.max_time);  
  22.     }  
  23. #endif  
  24.     // 从当前链表中删除  
  25.     list_del(&lock->link);  
  26.     spin_unlock_irqrestore(&list_lock, irqflags);  
  27. }  
  28. EXPORT_SYMBOL(wake_lock_destroy);  

该函数用于注销wake_lock，首先清除 WAKE_LOCK_INITIALIZED 标志位，然后更新统计信息，最后将锁从链表中删除。

 

9、proc节点

[cpp] view plaincopy
 
  1. // 获取锁的剩余超时时间,通过*expire_time传递  
  2. int get_expired_time(struct wake_lock *lock, ktime_t *expire_time)  
  3. {  
  4.     struct timespec ts;  
  5.     struct timespec kt;  
  6.     struct timespec tomono;  
  7.     struct timespec delta;  
  8.     unsigned long seq;  
  9.     long timeout;  
  10.   
  11.     // 如果不是超时锁则直接返回  
  12.     if (!(lock->flags & WAKE_LOCK_AUTO_EXPIRE))  
  13.         return 0;  
  14.   
  15.     do {  
  16.         seq = read_seqbegin(&xtime_lock);  
  17.         // 计算超时时间点与当前时间的差值  
  18.         timeout = lock->expires - jiffies;  
  19.         // 如果时间没有到期,返回0  
  20.         if (timeout > 0)  
  21.             return 0;  
  22.         // 获取当前时间  
  23.         kt = current_kernel_time();  
  24.         tomono = wall_to_monotonic;  
  25.     } while (read_seqretry(&xtime_lock, seq));  
  26.     // 时间格式转换  
  27.     jiffies_to_timespec(-timeout, &delta);  
  28.     // 设置timespec的成员  
  29.     set_normalized_timespec(&ts, kt.tv_sec + tomono.tv_sec - delta.tv_sec,  
  30.                 kt.tv_nsec + tomono.tv_nsec - delta.tv_nsec);  
  31.     // 返回ts值  
  32.     *expire_time = timespec_to_ktime(ts);  
  33.     return 1;  
  34. }  
  35.   
  36. // 打印出锁的状态信息  
  37. static int print_lock_stat(struct seq_file *m, struct wake_lock *lock)  
  38. {  
  39.     int lock_count = lock->stat.count;  
  40.     int expire_count = lock->stat.expire_count;  
  41.     ktime_t active_time = ktime_set(0, 0);  
  42.     ktime_t total_time = lock->stat.total_time;  
  43.     ktime_t max_time = lock->stat.max_time;  
  44.   
  45.     ktime_t prevent_suspend_time = lock->stat.prevent_suspend_time;  
  46.     // 如果锁有效  
  47.     if (lock->flags & WAKE_LOCK_ACTIVE) {  
  48.         ktime_t now, add_time;  
  49.         // 获取超时剩余时间  
  50.         int expired = get_expired_time(lock, &now);  
  51.         if (!expired)  
  52.             now = ktime_get();  
  53.         // 计算当前时间和上次操作时间的差值  
  54.         add_time = ktime_sub(now, lock->stat.last_time);  
  55.         lock_count++;  // 使用计数加1  
  56.         if (!expired)  // 如果没有到期  
  57.             active_time = add_time;  
  58.         else  // 锁已经到期  
  59.             expire_count++;  // 超时计数加1  
  60.         total_time = ktime_add(total_time, add_time);  // 锁使用时间增加  
  61.         if (lock->flags & WAKE_LOCK_PREVENTING_SUSPEND)  
  62.             prevent_suspend_time = ktime_add(prevent_suspend_time,  
  63.                     ktime_sub(now, last_sleep_time_update));  
  64.         if (add_time.tv64 > max_time.tv64)  
  65.             max_time = add_time;  
  66.     }  
  67.   
  68.     return seq_printf(m,  
  69.              "\"%s\"\t%d\t%d\t%d\t%lld\t%lld\t%lld\t%lld\t%lld\n",  
  70.              lock->name, lock_count, expire_count,  
  71.              lock->stat.wakeup_count, ktime_to_ns(active_time),  
  72.              ktime_to_ns(total_time),  
  73.              ktime_to_ns(prevent_suspend_time), ktime_to_ns(max_time),  
  74.              ktime_to_ns(lock->stat.last_time));  
  75. }  
  76.   
  77. // 打印锁状态  
  78. static int wakelock_stats_show(struct seq_file *m, void *unused)  
  79. {  
  80.     unsigned long irqflags;  
  81.     struct wake_lock *lock;  
  82.     int ret;  
  83.     int type;  
  84.   
  85.     spin_lock_irqsave(&list_lock, irqflags);  
  86.     // 输出菜单  
  87.     ret = seq_puts(m, "name\tcount\texpire_count\twake_count\tactive_since"  
  88.             "\ttotal_time\tsleep_time\tmax_time\tlast_change\n");  
  89.     // 遍历无效锁链表并打印锁的状态信息  
  90.     list_for_each_entry(lock, &inactive_locks, link)  
  91.         ret = print_lock_stat(m, lock);  
  92.     // 遍历有效锁链表并打印锁的状态信息  
  93.     for (type = 0; type < WAKE_LOCK_TYPE_COUNT; type++) {  
  94.         list_for_each_entry(lock, &active_wake_locks[type], link)  
  95.             ret = print_lock_stat(m, lock);  
  96.     }  
  97.     spin_unlock_irqrestore(&list_lock, irqflags);  
  98.     return 0;  
  99. }  
  100.   
  101. // proc文件打开函数,调用show函数显示当前所有的锁信息  
  102. static int wakelock_stats_open(struct inode *inode, struct file *file)  
  103. {  
  104.     return single_open(file, wakelock_stats_show, NULL);  
  105. }  
  106.   
  107. // proc文件系统操作函数  
  108. static const struct file_operations wakelock_stats_fops = {  
  109.     .owner = THIS_MODULE,  
  110.     .open = wakelock_stats_open,  
  111.     .read = seq_read,  
  112.     .llseek = seq_lseek,  
  113.     .release = single_release,  
  114. };  

以上是proc节点的操作接口，在wakelocks_init中注册。

 

总结：通过以上分析我们可以看到启动深度休眠流程有四个可能的地方，分别为expire_timer、wake_lock、wake_lock_timeout、wake_unlock，其中expire_timer和wake_unlock最常见。

android 休眠唤醒机制分析(一) — wake_lock,布布扣,bubuko.com

android 休眠唤醒机制分析(一) — wake_lock

标签：android   des   blog   http   使用   strong   

原文地址：http://www.cnblogs.com/rzq232/p/3835892.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！