wake lock机制

2280阅读　0评论2014-05-30　wangbaolin719
分类：LINUX


  1. //based on linux v3.14 source code
  2. 一、概述
  3. Wake Lock是一种锁的机制, 只要有人拿着这个锁,系统就无法进入休眠，可以被用户态程序和内核获得. 这个锁可以是有超时的或者是没有超时的,超时的锁会在时间过去以后自动解锁. 如果没有锁了或者超时了, 内核就会启动休眠的那套机制来进入休眠.

  5. 二、相关结构体
  6. struct wake_lock {
  7. #ifdef CONFIG_HAS_WAKELOCK
  8.     struct list_head link;    //链入锁链表节点
  9.     int flags; //锁标志
  10.     const char *name;    //锁名字
  11.     unsigned long expires;    //超时时间
  12. #ifdef CONFIG_WAKELOCK_STAT
  13.     struct {
  14.         int count;
  15.         int expire_count;
  16.         int wakeup_count;
  17.         ktime_t total_time;
  18.         ktime_t prevent_suspend_time;
  19.         ktime_t max_time;
  20.         ktime_t last_time;
  21.     } stat;    //记录锁信息
  22. #endif
  23. #endif
  24. };

  26. 三、wakelocks初始化
  27. 1. 内核维护了两个活动锁链表，active_wake_locks[WAKE_LOCK_TYPE_COUNT]。
  28. 1.1 active_wake_locks[0]维护的是suspend lock.WAKE_LOCK_SUSPEND这种锁如果被某个task持有，那么系统将无法进入休眠。
  29. 1.2 active_wake_locks[1]维护的是idle lock.WAKE_LOCK_IDLE这种锁不会影响到系统进入休眠，但是如果这种锁被持有，那么系统将无法进入idle空闲模式。
  30. 2. 内核维护了还一个非活动锁链表inactive_locks，用来记录所有处于inactive状态的锁.

  32. static int __init wakelocks_init(void)
  33. {
  34.     int ret;
  35.     int i;
  36.     
  37.     //初始化active_wake_locks数组中的两个类型锁链表: WAKE_LOCK_SUSPEND,WAKE_LOCK_IDLE
  38.     for (i = 0; i < ARRAY_SIZE(active_wake_locks); i++)
  39.         INIT_LIST_HEAD(&active_wake_locks[i]);

  41.     //初始化wakelock deleted_wake_locks，同时将其加入到非活动锁链表中
  42. #ifdef CONFIG_WAKELOCK_STAT
  43.     wake_lock_init(&deleted_wake_locks, WAKE_LOCK_SUSPEND,"deleted_wake_locks");
  44. #endif
  45.     
  46.     // 初始化wakelock: main, sys_sync, unknown_wakeups, 同时将其加入到非活动锁链表中
  47.     //给main_wake_lock 加锁
  48.     wake_lock_init(&main_wake_lock, WAKE_LOCK_SUSPEND, "main");
  49.     wake_lock(&main_wake_lock);
  50.     wake_lock_init(&unknown_wakeup, WAKE_LOCK_SUSPEND, "unknown_wakeups");
  51.     wake_lock_init(&suspend_backoff_lock, WAKE_LOCK_SUSPEND,"suspend_backoff");

  53.     //platform device 和 driver注册
  54.     ret = platform_device_register(&power_device);
  55.     if (ret) {
  56.         pr_err("wakelocks_init: platform_device_register failed\n");
  57.         goto err_platform_device_register;
  58.     }
  59.     ret = platform_driver_register(&power_driver);
  60.     if (ret) {
  61.         pr_err("wakelocks_init: platform_driver_register failed\n");
  62.         goto err_platform_driver_register;
  63.     }

  65.     //新建工作队列和工作者内核线程
  66.     INIT_COMPLETION(suspend_sys_sync_comp);
  67.     suspend_sys_sync_work_queue = create_singlethread_workqueue("suspend_sys_sync");
  68.     if (suspend_sys_sync_work_queue == NULL) {
  69.         ret = -ENOMEM;
  70.         goto err_suspend_sys_sync_work_queue;
  71.     }

  73.     suspend_work_queue = create_singlethread_workqueue("suspend");
  74.     if (suspend_work_queue == NULL) {
  75.         ret = -ENOMEM;
  76.         goto err_suspend_work_queue;
  77.     }

  79.     //创建proc接口
  80. #ifdef CONFIG_WAKELOCK_STAT
  81.     proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops);
  82. #endif

  84.     return 0;

  86. err_suspend_sys_sync_work_queue:
  87. err_suspend_work_queue:
  88.     platform_driver_unregister(&power_driver);
  89. err_platform_driver_register:
  90.     platform_device_unregister(&power_device);
  91. err_platform_device_register:
  92.     wake_lock_destroy(&suspend_backoff_lock);
  93.     wake_lock_destroy(&unknown_wakeup);
  94.     wake_lock_destroy(&main_wake_lock);
  95. #ifdef CONFIG_WAKELOCK_STAT
  96.     wake_lock_destroy(&deleted_wake_locks);
  97. #endif
  98.     return ret;
  99. }

  101. 四、wake lock使用
  102. 1. 初始化一个wake lock锁
  103. //该函数设置锁的名字，类型，最后将新建的锁挂接到一个专门链接这些非锁状态的链表inactive_locks上(新建的wakelock初期都是处于非锁状态的，除非显示调用函数wake_lock来上锁)。
  104. void wake_lock_init(struct wake_lock *lock, int type, const char *name)
  105. {
  106.     unsigned long irqflags = 0;

  108.     if (name)
  109.         lock->name = name;
  110.     BUG_ON(!lock->name);

  112.     if (debug_mask & DEBUG_WAKE_LOCK)
  113.         pr_info("wake_lock_init name=%s\n", lock->name);
  114. #ifdef CONFIG_WAKELOCK_STAT
  115.     lock->stat.count = 0;
  116.     lock->stat.expire_count = 0;
  117.     lock->stat.wakeup_count = 0;
  118.     lock->stat.total_time = ktime_set(0, 0);
  119.     lock->stat.prevent_suspend_time = ktime_set(0, 0);
  120.     lock->stat.max_time = ktime_set(0, 0);
  121.     lock->stat.last_time = ktime_set(0, 0);
  122. #endif
  123.     lock->flags = (type & WAKE_LOCK_TYPE_MASK) | WAKE_LOCK_INITIALIZED;

  125.     INIT_LIST_HEAD(&lock->link);
  126.     spin_lock_irqsave(&list_lock, irqflags);
  127.     //将锁挂到非锁状态的链表inactive_locks上
  128.     list_add(&lock->link, &inactive_locks);
  129.     spin_unlock_irqrestore(&list_lock, irqflags);
  130. }

  132. 2. 上锁
  133. wakelock有两种形式的锁：超时锁和非超时锁，这两种形式的锁都是使用函数wake_lock_init()来初始化，只是在上锁的时候会有一点点差别，超时锁使用函数wake_lock_timeout(),而非超时锁使用函数wake_lock(), 这个两个函数会最终调用到同一个函数wake_lock_internal(),该函数依靠传入的不同参数来选择不同的路径来工作。值得注意的是，非超时锁必须手工解锁，否则系统永远不能进入睡眠。
  134. static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0);
  135. void wake_lock(struct wake_lock *lock)
  136. {
  137.     wake_lock_internal(lock, 0, 0);
  138. }

  140. void wake_lock_timeout(struct wake_lock *lock, long timeout)
  141. {
  142.     wake_lock_internal(lock, timeout, 1);
  143. }

  145. static void wake_lock_internal(struct wake_lock *lock, long timeout, int has_timeout)
  146. {
  147.     int type;
  148.     unsigned long irqflags;
  149.     long expire_in;

  151.     spin_lock_irqsave(&list_lock, irqflags);
  152.     //上锁前，检查锁类型和有效性，是否为WAKE_LOCK_SUSPEND或WAKE_LOCK_IDLE某一种
  153.     type = lock->flags & WAKE_LOCK_TYPE_MASK;
  154.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
  155.     BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));
  156. #ifdef CONFIG_WAKELOCK_STAT
  157.     //检查wait_for_wakeup标志
  158.     if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {
  159.         if (debug_mask & DEBUG_WAKEUP)
  160.             pr_info("wakeup wake lock: %s\n", lock->name);
  161.         wait_for_wakeup = 0;
  162.         lock->stat.wakeup_count++;
  163.     }
  164.     //检查超时锁
  165.     if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&
  166.      (long)(lock->expires - jiffies) <= 0) {
  167.         wake_unlock_stat_locked(lock, 0);//若超时，则解锁
  168.         lock->stat.last_time = ktime_get();
  169.     }
  170. #endif
  171.     //上锁，设置WAKE_LOCK_ACTIVE标志
  172.     if (!(lock->flags & WAKE_LOCK_ACTIVE)) {
  173.         lock->flags |= WAKE_LOCK_ACTIVE;
  174. #ifdef CONFIG_WAKELOCK_STAT
  175.         lock->stat.last_time = ktime_get();
  176. #endif
  177.     }
  178.     //lock从非锁状态的链表inactive_locks上删除
  179.     list_del(&lock->link);

  181.     //has_timeout=1，表示是超时锁
  182.     if (has_timeout) {
  183.         if (debug_mask & DEBUG_WAKE_LOCK)
  184.             pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",
  185.                 lock->name, type, timeout / HZ,
  186.                 (timeout % HZ) * MSEC_PER_SEC / HZ);
  187.         //设置超时时间
  188.         lock->expires = jiffies + timeout;
  189.         lock->flags |= WAKE_LOCK_AUTO_EXPIRE;//超时锁标志
  190.         //超时锁重新挂入链表尾
  191.         list_add_tail(&lock->link, &active_wake_locks[type]);
  192.     } else {
  193.         //非超时锁
  194.         if (debug_mask & DEBUG_WAKE_LOCK)
  195.             pr_info("wake_lock: %s, type %d\n", lock->name, type);
  196.         lock->expires = LONG_MAX;
  197.         lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;//非超时锁标志
  198.         //非超时锁直接挂入链表
  199.         list_add(&lock->link, &active_wake_locks[type]);
  200.     }

  202.     //对于WAKE_LOCK_SUSPEND型的锁
  203.     if (type == WAKE_LOCK_SUSPEND) {
  204.         current_event_num++;
  205. #ifdef CONFIG_WAKELOCK_STAT
  206.         if (lock == &main_wake_lock)
  207.             update_sleep_wait_stats_locked(1);
  208.         else if (!wake_lock_active(&main_wake_lock))
  209.             update_sleep_wait_stats_locked(0);
  210. #endif
  211.         if (has_timeout)
  212.             //检查所有处于活动状态的 WAKE_LOCK_SUSPEND 锁(即在 active_wake_locks 链表上的WAKE_LOCK_SUSPEND 锁,或者说当前被加锁了的 WAKE_LOCK_SUSPEND 锁),是否有超期锁已经过期,如果有则把过期超期锁从 active_wake_locks 上删除,挂到 inactive_locks 上。同时它还检查链表上有没有非超期锁,如果有则直接返回-1,否则它最终返回的是所有超期锁过期时间的最大值
  213.             expire_in = has_wake_lock_locked(type);
  214.         else
  215.             expire_in = -1;

  217.         //如果 has_wake_lock_locked 函数返回的是-1(表示当前活动锁有非超时锁)或者 0(表示所有活动锁都是超时锁,且全已经超时),则删除 expire_timer,并排队一个 suspend 工作到 suspend_work_queue 工作队列,最终系统会suspend
  218.         if (expire_in > 0) {
  219.             //有超时锁，设置超时定时器，超时调用expire_wake_locks函数
  220.             if (debug_mask & DEBUG_EXPIRE)
  221.                 pr_info("wake_lock: %s, start expire timer, ""%ld\n", lock->name, expire_in);
  222.             mod_timer(&expire_timer, jiffies + expire_in);
  223.         } else {
  224.             //无超时锁，删除超时定时器
  225.             if (del_timer(&expire_timer))
  226.                 if (debug_mask & DEBUG_EXPIRE)
  227.                     pr_info("wake_lock: %s, stop expire timer\n",lock->name);
  228.             //如果超时锁为０,且无非超时锁时,expire_in为０,启动suspend_work_queue工作队列进行suspend
  229.             //也就是说链表active_wake_locks[WAKE_LOCK_SUSPEND]为NULL，就没有锁阻止系统进入suspend了，那么系统就可以执行suspend的流程了。
  230.             if (expire_in == 0)
  231.                 queue_work(suspend_work_queue, &suspend_work);
  232.         }
  233.     }
  234.     spin_unlock_irqrestore(&list_lock, irqflags);
  235. }

  237. 3. 解锁
  238. void wake_unlock(struct wake_lock *lock)
  239. {
  240.     int type;
  241.     unsigned long irqflags;
  242.     spin_lock_irqsave(&list_lock, irqflags);
  243.     type = lock->flags & WAKE_LOCK_TYPE_MASK;
  244. #ifdef CONFIG_WAKELOCK_STAT
  245.     wake_unlock_stat_locked(lock, 0);
  246. #endif
  247.     if (debug_mask & DEBUG_WAKE_LOCK)
  248.         pr_info("wake_unlock: %s\n", lock->name);
  249.     //去锁标志
  250.     lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE);
  251.     //该锁从active_wake_locks[type]链表移除，加入inactive_locks链表
  252.     list_del(&lock->link);
  253.     list_add(&lock->link, &inactive_locks);

  255.     //前面已经说了只有类型为WAKE_LOCK_SUSPEND的wakelock被上锁才会阻止系统进入suspend，那么也就是说只要链表active_wake_locks[WAKE_LOCK_SUSPEND]为NULL，就没有锁阻止系统进入suspend了，那么系统就可以执行suspend的流程了。
  256.     if (type == WAKE_LOCK_SUSPEND) {
  257.         //检查所有处于活动状态的 WAKE_LOCK_SUSPEND 锁
  258.         long has_lock = has_wake_lock_locked(type);
  259.         //has_lock>0表示有超时锁，has_lock为最大超时时间，设置定时器，超时调用expire_wake_locks函数
  260.         if (has_lock > 0) {
  261.             if (debug_mask & DEBUG_EXPIRE)
  262.                 pr_info("wake_unlock: %s, start expire timer, ""%ld\n", lock->name, has_lock);
  263.             mod_timer(&expire_timer, jiffies + has_lock);
  264.         } else {
  265.             //has_lock=-1，表示有非超时锁。
  266.             if (del_timer(&expire_timer))
  267.                 if (debug_mask & DEBUG_EXPIRE)
  268.                     pr_info("wake_unlock: %s, stop expire ""timer\n", lock->name);
  269.             //如果has_lock=0，表示超时锁已超时时间为0,且无非超时锁时,启动suspend流程
  270.             if (has_lock == 0)
  271.                 queue_work(suspend_work_queue, &suspend_work);
  272.         }
  273.         if (lock == &main_wake_lock) {
  274.             if (debug_mask & DEBUG_SUSPEND)
  275.                 print_active_locks(WAKE_LOCK_SUSPEND);
  276. #ifdef CONFIG_WAKELOCK_STAT
  277.             update_sleep_wait_stats_locked(0);
  278. #endif
  279.         }
  280.     }
  281.     spin_unlock_irqrestore(&list_lock, irqflags);
  282. }

  284. 4. 设置超时锁时，设置超时定时器，超时时会回调定时器函数
  285. static void expire_wake_locks(unsigned long data)
  286. {
  287.     long has_lock;
  288.     unsigned long irqflags;
  289.     if (debug_mask & DEBUG_EXPIRE)
  290.         pr_info("expire_wake_locks: start\n");
  291.     spin_lock_irqsave(&list_lock, irqflags);
  292.     if (debug_mask & DEBUG_SUSPEND)
  293.         print_active_locks(WAKE_LOCK_SUSPEND);

  295.     //检查所有处于活动状态的 WAKE_LOCK_SUSPEND 锁
  296.     has_lock = has_wake_lock_locked(WAKE_LOCK_SUSPEND);
  297.     if (debug_mask & DEBUG_EXPIRE)
  298.         pr_info("expire_wake_locks: done, has_lock %ld\n", has_lock);

  300.     //如果没有SUSPEND类型的wakelock处于active，那么将调用suspend
  301.     if (has_lock == 0)
  302.         queue_work(suspend_work_queue, &suspend_work);
  303.     spin_unlock_irqrestore(&list_lock, irqflags);
  304. }

  306. static long has_wake_lock_locked(int type)
  307. {
  308.     struct wake_lock *lock, *n;
  309.     long max_timeout = 0;

  311.     BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
  312.     //遍历链表中的所有锁
  313.     list_for_each_entry_safe(lock, n, &active_wake_locks[type], link) {
  314.         //若设置了超时锁标志
  315.         if (lock->flags & WAKE_LOCK_AUTO_EXPIRE) {
  316.             //计算还剩余的时间
  317.    
上一篇：Linux内核模块导出后无法调用问题解决
下一篇：wait queue机制