android休眠喚醒機制分析

1、Android的休眠喚醒主要基于wake_lock機制，只要系統中存在任一有效的wake_lock，系統就不能進入深度休眠，但可以進行設備的淺度休眠操作。wake_lock一般在關閉lcd、tp但系統仍然需要正常運行的情況下使用，比如聽歌、傳輸很大的文件等。本文主要分析driver層wake_lock的實現。一、wake_lock 定義和接口cpp view plaincopy1. enum   2.     WAKE_LOCK_SUSPEND, / 阻止進入深度休眠模式  

2、3.     WAKE_LOCK_IDLE,    / 阻止進入空閑模式  4.     WAKE_LOCK_TYPE_COUNT  5. ;  6.   7. struct wake_lock   8. #ifdef CONFIG_HAS_WAKELOCK  9.     st

3、ruct list_head    link;     / 鏈表節(jié)點  10.     int                 flags;    / 標志  11.   

4、;  const char         *name;     / 名稱  12.     unsigned long       expires;  / 超時時間  13. #ifdef CONFIG_WAKELOC

5、K_STAT  14.     struct   15.         int             count;         / 使用計數  16.  

6、0;      int             expire_count;  / 超時計數  17.         int             

7、wakeup_count;  / 喚醒計數  18.         ktime_t         total_time;    / 鎖使用時間  19.         ktime_t   

8、60;     prevent_suspend_time;  / 鎖阻止休眠的時間  20.         ktime_t         max_time;      / 鎖使用時間最長的一次  21.   

9、0;     ktime_t         last_time;     / 鎖上次操作時間  22.      stat;  23. #endif  24. #endif  25. ;  可以看到wake_lock按功能分為休眠鎖和空閑鎖兩種類型

10、，用于阻止系統進入深度休眠模式或者空閑模式。wake_lock的主要部件有鎖名稱、鏈表節(jié)點、標志位、超時時間，另外還有一個內嵌的結構用于統計鎖的使用信息。接下來我們看看wake_lock對外提供的操作接口：1、內核空間接口cpp view plaincopy1. void wake_lock_init(struct wake_lock *lock, int type, const char *name);  2. void wake_lock_destroy(struct&#

11、160;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()用于初

12、始化一個新鎖，type參數指定了鎖的類型；wake_lock_destroy()則注銷一個鎖；wake_lock()和wake_lock_timeout()用于將初始化完成的鎖激活，使之成為有效的永久鎖或者超時鎖；wake_unlock()用于解鎖使之成為無效鎖。另外還有兩個接口：cpp view plaincopy1. int wake_lock_active(struct wake_lock *lock);  2. long has_wake_lock(int type);  其中wake_

13、lock_active()用于判斷鎖當前是否有效，如果有效則返回非0值；has_wake_lock()用于判斷系統中是否還存在有效的type型鎖，如果存在超時鎖則返回最長的一個鎖的超時時間，如果存在永久鎖則返回-1，如果系統中不存在有效鎖則返回0。2、用戶空間接口wake_lock向用戶空間提供了兩個文件節(jié)點用于申請鎖和解鎖：cpp view plaincopy1. / wack_lock文件的讀函數,顯示用戶空間定義的有效鎖  2. ssize_t wake_lock_show(  3.    

14、; struct kobject *kobj, struct kobj_attribute *attr, char *buf)  4.   5.     char *s = buf;  6.     char *end = buf + PAGE_SIZE;  7.  &

15、#160;  struct rb_node *n;  8.     struct user_wake_lock *l;  9.   10.     mutex_lock(&tree_lock);  11.   12.     for (n = rb_first(&user_

16、wake_locks); n != NULL; n = rb_next(n)   13.         l = rb_entry(n, struct user_wake_lock, node);  14.         if (wake_lock_active(&a

17、mp;l->wake_lock)  15.             s += scnprintf(s, end - s, "%s ", l->name);  16.       17.     s += sc

18、nprintf(s, end - s, "n");  18.   19.     mutex_unlock(&tree_lock);  20.     return (s - buf);  21.   22.   23. / wack_lock文件的寫函數,初始化并激活用戶空間定義的鎖

19、60; 24. ssize_t wake_lock_store(  25.     struct kobject *kobj, struct kobj_attribute *attr,  26.     const char *buf, size_t n)  27.   28.     l

20、ong timeout;  29.     struct user_wake_lock *l;  30.   31.     mutex_lock(&tree_lock);  32.     l = lookup_wake_lock_name(buf, 1, &timeout);  33. &

21、#160;   if (IS_ERR(l)   34.         n = PTR_ERR(l);  35.         goto bad_name;  36.       37.   38.  

22、60;  if (debug_mask & DEBUG_ACCESS)  39.         pr_info("wake_lock_store: %s, timeout %ldn", l->name, timeout);  40.   41.     if (timeou

23、t)  42.         wake_lock_timeout(&l->wake_lock, timeout);  43.     else  44.         wake_lock(&l->wake_lock);  45. bad_name:  46.

24、     mutex_unlock(&tree_lock);  47.     return n;  48.   49.   50. / wack_unlock文件的讀函數,顯示用戶空間的無效鎖  51. ssize_t wake_unlock_show(  52.     struct kobject

25、0;*kobj, struct kobj_attribute *attr, char *buf)  53.   54.     char *s = buf;  55.     char *end = buf + PAGE_SIZE;  56.     struct

26、60;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 

27、;!= NULL; n = rb_next(n)   62.         l = rb_entry(n, struct user_wake_lock, node);  63.         if (!wake_lock_active(&l->wake_lock)

28、0; 64.             s += scnprintf(s, end - s, "%s ", l->name);  65.       66.     s += scnprintf(s, end

29、0;- s, "n");  67.   68.     mutex_unlock(&tree_lock);  69.     return (s - buf);  70.   71.   72. / wack_unlock文件的寫函數,用于用戶空間解鎖  73. ssize_t w

30、ake_unlock_store(  74.     struct kobject *kobj, struct kobj_attribute *attr,  75.     const char *buf, size_t n)  76.   77.     struct user_wake_lock

31、 *l;  78.   79.     mutex_lock(&tree_lock);  80.     l = lookup_wake_lock_name(buf, 0, NULL);  81.     if (IS_ERR(l)   82.     

32、0;   n = PTR_ERR(l);  83.         goto not_found;  84.       85.   86.     if (debug_mask & DEBUG_ACCESS)  87.  

33、0;      pr_info("wake_unlock_store: %sn", l->name);  88.   89.     wake_unlock(&l->wake_lock);  90. not_found:  91.     mutex_unlock(&tree_lock);  

34、;92.     return n;  93.   94.   95. power_attr(wake_lock);  96. power_attr(wake_unlock);  這兩個文件節(jié)點分別為"/sys/power/wake_lock"和"/sys/power/wake_unlock"，應用程序可以根據HAL層的接口讀寫這兩個節(jié)點。二、wake_lock 實現在linux/kernel/power/

35、wakelock.c中我們可以看到wake_lock的實現代碼，首先看看其定義的一些初始化信息：cpp view plaincopy1. #define WAKE_LOCK_TYPE_MASK              (0x0f)     / 鎖類型標志掩碼  2. #define WAKE_LOCK_INITIALIZED  

36、;          (1U << 8)  / 鎖已經初始化標志  3. #define WAKE_LOCK_ACTIVE                 (1U << 9)  /

37、60;鎖有效標志  4. #define WAKE_LOCK_AUTO_EXPIRE            (1U << 10) / 超時鎖標志  5. #define WAKE_LOCK_PREVENTING_SUSPEND     (1U << 11) / 正在

38、阻止休眠標志  6.   7. static DEFINE_SPINLOCK(list_lock);  / 讀寫鎖鏈表的自旋鎖  8. static LIST_HEAD(inactive_locks);   / 內核維護的無效鎖鏈表  9. static struct list_head active_wake_locksWAKE_LOCK_TYPE_COUNT;  /

39、0;有效鎖鏈表  10. static int current_event_num;       / 休眠鎖使用計數器  11. struct workqueue_struct *suspend_work_queue;  / 執(zhí)行系統休眠的工作隊列  12. struct workqueue_struct *sys_sync_work_queue; /

40、60;執(zhí)行系統同步的工作隊列  13. struct wake_lock main_wake_lock;              / 內核休眠鎖  14. struct wake_lock sys_sync_wake_lock;          / 緩存同

41、步鎖  15. suspend_state_t requested_suspend_state = PM_SUSPEND_MEM;  / 系統休眠狀態(tài)  16. static struct wake_lock unknown_wakeup;       / 未知鎖  在后面的分析中我們會看到這些變量的具體用途。1、wake_lock系統初始化cpp view

42、 plaincopy1. static int _init wakelocks_init(void)  2.   3.     int ret;  4.     int i;  5.     / 初始化有效鎖鏈表,內核維護了2個有效鎖鏈表  6.     / WAKE_

43、LOCK_SUSPEND 用于阻止進入深度休眠模式  7.     / WAKE_LOCK_IDLE    用于阻止進入空閑模式  8.     for (i = 0; i < ARRAY_SIZE(active_wake_locks); i+)  9.      

44、0;  INIT_LIST_HEAD(&active_wake_locksi);  10.   11. #ifdef CONFIG_WAKELOCK_STAT  12.     / 初始化deleted_wake_locks  13.     wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,  

45、;14.             "deleted_wake_locks");  15. #endif  16.     / 初始化內核休眠鎖  17.     wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "mai

46、n");  18.     / 初始化同步鎖  19.     wake_lock_init(&sys_sync_wake_lock, WAKE_LOCK_SUSPEND, "sys_sync");  20.     / 激活內核休眠鎖  21.     wake_lock(&am

47、p;main_wake_lock);  22.     / 初始化未知鎖  23.     wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");  24.   25.     / 注冊power_device,power_driver 

48、; 26.     ret = platform_device_register(&power_device);  27.     if (ret)   28.         pr_err("wakelocks_init: platform_device_register failedn");

49、60; 29.         goto err_platform_device_register;  30.       31.     ret = platform_driver_register(&power_driver);  32.     if (ret) &

50、#160; 33.         pr_err("wakelocks_init: platform_driver_register failedn");  34.         goto err_platform_driver_register;  35.       36.

51、     / 創(chuàng)建fs_sync內核進程  37.     sys_sync_work_queue = create_singlethread_workqueue("fs_sync");  38.     if (sys_sync_work_queue = NULL)   39.     

52、    pr_err ("fs_sync workqueue create failed.n");  40.       41.     / 創(chuàng)建suspend內核進程  42.     suspend_work_queue = create_singlethread_workqueue(

53、"suspend");  43.     if (suspend_work_queue = NULL)   44.         ret = -ENOMEM;  45.         goto err_suspend_work_queue;

54、60; 46.       47.   48. #ifdef CONFIG_WAKELOCK_STAT  49.     / 在proc下創(chuàng)建wakelocks文件  50.     proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);&#

55、160; 51. #endif  52.   53.     return 0;  54.   55. err_suspend_work_queue:  56.     platform_driver_unregister(&power_driver);  57. err_platform_driver_register:  58.  &#

56、160;  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_

57、WAKELOCK_STAT  63.     wake_lock_destroy(&deleted_wake_locks);  64. #endif  65.     return ret;  66.   67. core_initcall(wakelocks_init);  可以看到內核通過core_initcall調用了wake_lock系統的初始化函數，函數首先初始化了兩個

58、有效鎖的鏈表，用于管理系統中的有效鎖；接下來初始化了deleted_wake_locks用于處理統計信息，main_wake_lock用于鎖定內核（系統啟動時會激活這個鎖，深度休眠時需要釋放這個鎖），sys_sync_wake_lock用于淺度休眠階段同步緩存時阻止內核進入深度休眠，unknown_wakeup用于喚醒時延遲0.5s進入下一次可能的深度休眠；還注冊了一個platform_device用于深度休眠階段檢測是否存在有效鎖；后面創(chuàng)建了內核進程fs_sync用于淺度休眠階段同步緩存，內核進程suspend用于進行淺度休眠和深度休眠；還在/proc下面創(chuàng)建了wakelocks節(jié)點用于顯示

59、wake_lock的統計信息。2、wake_lock初始化cpp view plaincopy1. void wake_lock_init(struct wake_lock *lock, int type, const char *name)  2.   3.     unsigned long irqflags = 0;  4.    

60、 / 初始化名稱  5.     if (name)  6.         lock->name = name;  7.     BUG_ON(!lock->name);  8.   9.     if (debug_mask

61、 & DEBUG_WAKE_LOCK)  10.         pr_info("wake_lock_init name=%sn", lock->name);  11. #ifdef CONFIG_WAKELOCK_STAT  12.     lock->stat.count = 0;  

62、;13.     lock->stat.expire_count = 0;  14.     lock->stat.wakeup_count = 0;  15.     lock->stat.total_time = ktime_set(0, 0);  16.     lock->st

63、at.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.   

64、  / 初始化flag  21.     lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;  22.     / 初始化鏈表節(jié)點  23.     INIT_LIST_HEAD(&lock->link);&

65、#160; 24.     spin_lock_irqsave(&list_lock, irqflags);  25.     / 將鎖加入無效鎖鏈表  26.     list_add(&lock->link, &inactive_locks);  27.     spin_unlock_irqrestor

66、e(&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 plaincopy1.

67、 / 根據參數激活鎖  2. static void wake_lock_internal(  3.     struct wake_lock *lock, long timeout, int has_timeout)  4.   5.     int type;  6.     

68、;unsigned long irqflags;  7.     long expire_in;  8.   9.     spin_lock_irqsave(&list_lock, irqflags);  10.     / 獲取鎖的類型  11.     type =

69、 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&#

70、160; 15.     if (type = WAKE_LOCK_SUSPEND && wait_for_wakeup)   16.         if (debug_mask & DEBUG_WAKEUP)  17.        

71、0;    pr_info("wakeup wake lock: %sn", lock->name);  18.         wait_for_wakeup = 0;  19.         lock->stat.wakeup_count+; 

72、0;20.       21.     if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&  22.         (long)(lock->expires - jiffies) <= 0)   23.

73、60;       wake_unlock_stat_locked(lock, 0);  24.         lock->stat.last_time = ktime_get();  25.       26. #endif  27.     /&#

74、160;設置鎖有效的標志位  28.     if (!(lock->flags & WAKE_LOCK_ACTIVE)   29.         lock->flags |= WAKE_LOCK_ACTIVE;  30. #ifdef CONFIG_WAKELOCK_STAT  31.  

75、60;      lock->stat.last_time = ktime_get();  32. #endif  33.       34.     / 將鎖從無效鎖鏈表中刪除  35.     list_del(&lock->link);  36.  &#

76、160;  / 如果是超時鎖  37.     if (has_timeout)   38.         if (debug_mask & DEBUG_WAKE_LOCK)  39.             

77、pr_info("wake_lock: %s, type %d, timeout %ld.%03lun",  40.                 lock->name, type, timeout / HZ,  41.      

78、           (timeout % HZ) * MSEC_PER_SEC / HZ);  42.         / 設置鎖超時時間,以當前jiffies為基準  43.         lock->exp

79、ires = jiffies + timeout;  44.         / 設置鎖的超時鎖標志  45.         lock->flags |= WAKE_LOCK_AUTO_EXPIRE;  46.        

80、60;/ 將鎖加入有效鎖鏈表  47.         list_add_tail(&lock->link, &active_wake_lockstype);  48.      else   / 如果是永久鎖  49.         if

81、60;(debug_mask & DEBUG_WAKE_LOCK)  50.             pr_info("wake_lock: %s, type %dn", lock->name, type);  51.         / 設置超

82、時時間為極限  52.         lock->expires = LONG_MAX;  53.         / 清除超時鎖標志  54.         lock->flags &= WAKE_LOCK_AUTO_EXP

83、IRE;  55.         / 將鎖加入有效鎖鏈表  56.         list_add(&lock->link, &active_wake_lockstype);  57.       58.     / 如果是

84、休眠鎖  59.     if (type = WAKE_LOCK_SUSPEND)   60.         current_event_num+;  / 休眠鎖使用計數器加1  61. #ifdef CONFIG_WAKELOCK_STAT  62.      &

85、#160;  / 如果是內核休眠鎖  63.         if (lock = &main_wake_lock)  64.             update_sleep_wait_stats_locked(1);  65.    &#

86、160;    / 如果內核休眠鎖無效  66.         else if (!wake_lock_active(&main_wake_lock)  67.             update_sleep_wait_stats_locked(0);  6

87、8. #endif  69.         / 如果是超時鎖  70.         if (has_timeout)  71.             expire_in = has_wake_lock_locke

88、d(type);  72.         else  73.             expire_in = -1;  74.         / 當前存在有效超時鎖,并且最長的一個到期時間間隔為expire_in &

89、#160;75.         if (expire_in > 0)   76.             if (debug_mask & DEBUG_EXPIRE)  77.         

90、        pr_info("wake_lock: %s, start expire timer, "  78.                     "%ldn", lock->name

91、, expire_in);  79.             mod_timer(&expire_timer, jiffies + expire_in);  80.          else   / 如果有永久鎖或者無有效鎖  81. &#

92、160;           if (del_timer(&expire_timer)  82.                 if (debug_mask & DEBUG_EXPIRE)  83.   

93、0;                 pr_info("wake_lock: %s, stop expire timern",  84.                  

94、0;      lock->name);  85.             if (expire_in = 0)  / 無有效鎖  86.               

95、60; queue_work(suspend_work_queue, &suspend_work);  87.           88.       89.     spin_unlock_irqrestore(&list_lock, irqflags);  90.   91.  

96、 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. / 激活超時鎖  

97、;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_i

98、nternal()完成的，該函數首先完成一些統計信息的初始化，設置 WAKE_LOCK_ACTIVE 標志位并將鎖從無效鎖鏈表中移除；然后根據是否是超時鎖設置 WAKE_LOCK_AUTO_EXPIRE 標志位，并設置超時鎖的超時時間，再將鎖加入有效鎖鏈表；最后再根據鎖的類型判斷是否為休眠鎖，如果是休眠鎖且為超時鎖則通過has_wake_lock_locked()獲取系統中存在的超時鎖中時間最長的到期時間值，并以此值設置expire_timer，has_wake_lock_locked()返回0則表示系統中不存在有效鎖則啟動suspend進程開始進入深度

99、休眠狀態(tài)。3、expire_timercpp view plaincopy1. static void expire_wake_locks(unsigned long data)  2.   3.     long has_lock;  4.     unsigned long irqflags;  5.     if

100、 (debug_mask & DEBUG_EXPIRE)  6.         pr_info("expire_wake_locks: startn");  7.     spin_lock_irqsave(&list_lock, irqflags);  8.     / 打印當前

101、的有效鎖  9.     if (debug_mask & DEBUG_SUSPEND)  10.         print_active_locks(WAKE_LOCK_SUSPEND);  11.     / 檢測系統是否持有休眠鎖  12.     has_loc

102、k = has_wake_lock_locked(WAKE_LOCK_SUSPEND);  13.     if (debug_mask & DEBUG_EXPIRE)  14.         pr_info("expire_wake_locks: done, has_lock %ldn", has_lock);

103、60; 15.     / 如果系統當前沒有持有有效地休眠鎖  16.     if (has_lock = 0)  17.         / 則啟動深度休眠工作隊列  18.         queue_work(suspend_wor

104、k_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); 

105、60;該timer會在多個地方用到，在激活鎖的函數中注冊用于超時鎖到期后檢測系統的有效鎖狀態(tài)，如果系統不存在有效鎖了則啟動suspend進程。4、suspend_workcpp view plaincopy1. static void suspend(struct work_struct *work)  2.   3.     int ret;  4.     int entry_eve

106、nt_num;  5.   6.     / 判斷系統是否還持有有效鎖,如果有則直接返回  7.     if (has_wake_lock(WAKE_LOCK_SUSPEND)   8.         if (debug_mask & DEBUG_SUSPEND)  

107、9.             pr_info("suspend: abort suspendn");  10.         return;  11.       12.   13.     /&#

108、160;記錄函數進入時休眠鎖的使用次數  14.     entry_event_num = current_event_num;  15.     sys_sync();  / 將緩存中的數據寫入磁盤  16.     if (debug_mask & DEBUG_SUSPEND)  17.  &#

109、160;      pr_info("suspend: enter suspendn");  18.     / 開始深度休眠  19.     ret = pm_suspend(requested_suspend_state);  20.     / 退出深度休眠,打印信息&#

110、160; 21.     if (debug_mask & DEBUG_EXIT_SUSPEND)   22.         struct timespec ts;  23.         struct rtc_time tm;  24.

111、         getnstimeofday(&ts);  25.         rtc_time_to_tm(ts.tv_sec, &tm);  26.         pr_info("suspend: exit suspend, ret

112、0;= %d "  27.             "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)n", ret,  28.             tm.tm_year + 1900,

113、 tm.tm_mon + 1, tm.tm_mday,  29.             tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);  30.       31.     / 如果深度休眠前和深度休眠后鎖的使用

114、次數一致，即喚醒過程中沒有激活新的鎖  32.     if (current_event_num = entry_event_num)   33.         if (debug_mask & DEBUG_SUSPEND)  34.         

115、60;   pr_info("suspend: pm_suspend returned with no eventn");  35.         / 激活unknown_wakeup,0.5s超時  36.         wake_lock_timeout(&unknown_

116、wakeup, HZ / 2);  37.       38.   39. / 聲明工作隊列,運行函數為suspend  40. static DECLARE_WORK(suspend_work, suspend);  聲明工作隊列用于內核深度休眠，可以看到一個正常的休眠流程會三次調用sys_sync()用于同步緩存（之前一次在淺度休眠，之后一次在深度休眠），然后調用pm_suspend()開始執(zhí)

117、行深度休眠流程。5、has_wake_lockcpp view plaincopy1. / 移除過期超時鎖  2. static void expire_wake_lock(struct wake_lock *lock)  3.   4. #ifdef CONFIG_WAKELOCK_STAT  5.     wake_unlock_stat_locked(lock, 1);  

118、;6. #endif  7.     / 清除鎖有效和超時鎖標志  8.     lock->flags &= (WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);  9.     / 從當前鏈表中刪除  10.     list_del(&l

119、ock->link);  11.     / 加入無效鎖鏈表  12.     list_add(&lock->link, &inactive_locks);  13.     if (debug_mask & (DEBUG_WAKE_LOCK | DEBUG_EXPIRE)  14.

120、60;       pr_info("expired wake lock %sn", lock->name);  15.   16.   17. / 打印有效鎖信息,調用者需持有l(wèi)ist_lock  18. static void print_active_locks(int type)  19.   

121、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_lockstype, link)   26.         / 如果是超時鎖  27.  &