Android wakelock 学习总结第三篇

http://slightsnow.blog.chinaunix.net/uid-29269256-id-4093367.html

从这篇开始我就开始对android下的wakelock和suspend是如何结合做些自己的分析，长话短说吧，我们首先看看个函数：

路径如下：

kernel/kernel/power/main.c

这个函数就是Native曾调用的接口程序，比如:state, wakelock , unwakelock，这里都有具体实现，下面我们先分析下wake_lock相关函数，上锁过程:

（注意我只分析store函数 show函数我就不分析了）

456 static ssize_t wake_lock_store(struct kobject *kobj,

457 struct kobj_attribute *attr,

458 const char *buf, size_t n)

459 {

460 int error = pm_wake_lock(buf);

461 return error ? error : n;

462 }

这端函数没有什么可说的，就是直接把上层申请的锁名称传到pm_wake_lock中，比如 mWakeLockSuspendBlocker = createSuspendBlockerLocked("PowerManagerService"); 中的PowerManagerService。我们继续看下pm_wake_lock函数，

183 int pm_wake_lock(const char *buf)

184 {

185 const char *str = buf;

186 struct wakelock *wl;

187 u64 timeout_ns = 0;

188 size_t len;

189 int ret = 0;

190

191 while (*str && !isspace(*str))

192 str++;

193

194 len = str - buf;

195 if (!len)

196 return -EINVAL;

197

198 if (*str && *str != '\n') {

199 /* Find out if there's a valid timeout string appended. */

200 ret = kstrtou64(skip_spaces(str), 10, &timeout_ns);

201 if (ret)

202 return -EINVAL;

203 }

204

205 mutex_lock(&wakelocks_lock);

206

207 wl = wakelock_lookup_add(buf, len, true);

208 if (IS_ERR(wl)) {

209 ret = PTR_ERR(wl);

210 goto out;

211 }

212 if (timeout_ns) {

213 u64 timeout_ms = timeout_ns + NSEC_PER_MSEC - 1;

214

215 do_div(timeout_ms, NSEC_PER_MSEC);

216 __pm_wakeup_event(&wl->ws, timeout_ms);

217 } else {

218 __pm_stay_awake(&wl->ws);

219 }

220

221 wakelocks_lru_most_recent(wl);

222

223 out:

224 mutex_unlock(&wakelocks_lock);

225 return ret;

226 }

这端函数主要功能在于检查这个wakelock是否存在红黑二叉树上，把名字短的放在左叉，名字长的放在右叉，这里是不是跟进程调度的二叉树很像？^_^，然后调用__pm_wakeup_event或者__pm_stay_awake函数，这里的timeout_ms我没有看明白怎么取得的，烦人，以后慢慢看看再。继续跟踪没有timeout_ms的函数吧，另外的函数进入也干了同样的事情，还对timeout进行了一些处理，可能和两种锁有关系哦？一种是带timeout时间的锁，到时会注销，一种是不带时间锁，如果没有显示的unlock就不会放弃锁。

418 void __pm_stay_awake(struct wakeup_source *ws)

419 {

420 unsigned long flags;

421

422 if (!ws)

423 return;

424

425 spin_lock_irqsave(&ws->lock, flags);

426

427 wakeup_source_report_event(ws);

428 del_timer(&ws->timer);

429 ws->timer_expires = 0;

430

431 spin_unlock_irqrestore(&ws->lock, flags);

432 }

这个函数主要干的就是调用wakeup_source_report_evet这个函数

01 static void wakeup_source_report_event(struct wakeup_source *ws)

402 {

403 ws->event_count++;

404 /* This is racy, but the counter is approximate anyway. */

405 if (events_check_enabled)

406 ws->wakeup_count++;

407

408 if (!ws->active)

409 wakeup_source_activate(ws);

381 static void wakeup_source_activate(struct wakeup_source *ws)

382 {

383 unsigned int cec;

384

385 ws->active = true;

386 ws->active_count++;

387 ws->last_time = ktime_get();

388 if (ws->autosleep_enabled)

389 ws->start_prevent_time = ws->last_time;

390

391 /* Increment the counter of events in progress. */

392 cec = atomic_inc_return(&combined_event_count);

393

394 trace_wakeup_source_activate(ws->name, cec);

395 }

这两段函数连续看，会发现，对与一些count进行的++，设置了下wake_lock中的wake_source的一些变量，主要是 对于combined_event_count这个变量进行的原子操作++，（这个变量暂时理解胃是记录有多少个wakelock吧），然后就完活了啊，这样就对一个wakelock进行。

我们再分析下wake_unlock_store这个函数，

473 static ssize_t wake_unlock_store(struct kobject *kobj,

474 struct kobj_attribute *attr,

475 const char *buf, size_t n)

476 {

477 int error = pm_wake_unlock(buf);

478 return error ? error : n;

479 }

操作一样，把写到节点的字符串传到pm_wake_unlock(buf)函数中

228 int pm_wake_unlock(const char *buf)

229 {

230 struct wakelock *wl;

231 size_t len;

232 int ret = 0;

233

234 len = strlen(buf);

235 if (!len)

236 return -EINVAL;

237

238 if (buf[len-1] == '\n')

239 len--;

240

241 if (!len)

242 return -EINVAL;

243

244 mutex_lock(&wakelocks_lock);

245

246 wl = wakelock_lookup_add(buf, len, false);

247 if (IS_ERR(wl)) {

248 ret = PTR_ERR(wl);

249 goto out;

250 }

251 __pm_relax(&wl->ws);

252

253 wakelocks_lru_most_recent(wl);

254 wakelocks_gc();

255

256 out:

257 mutex_unlock(&wakelocks_lock);

258 return ret;

259 }

这里也是在wake_lock二叉树查找wake_lock，然后调用__pm_relax(&wl->ws);这个函数，精髓都在这里，我们跟踪下去

535 void __pm_relax(struct wakeup_source *ws)

536 {

537 unsigned long flags;

538

539 if (!ws)

540 return;

541

542 spin_lock_irqsave(&ws->lock, flags);

543 if (ws->active)

544 wakeup_source_deactivate(ws);

545 spin_unlock_irqrestore(&ws->lock, flags);

546 }

547 EXPORT_SYMBOL_GPL(__pm_relax);

看到ws->active了吗？这个在之前上锁的时候我们定义过true哦，然后调用wakeup_source_deactivate这个函数，

478 static void wakeup_source_deactivate(struct wakeup_source *ws)

479 {

480 unsigned int cnt, inpr, cec;

481 ktime_t duration;

482 ktime_t now;

483

484 ws->relax_count++;

485 /*

486 * __pm_relax() may be called directly or from a timer function.

487 * If it is called directly right after the timer function has been

488 * started, but before the timer function calls __pm_relax(), it is

489 * possible that __pm_stay_awake() will be called in the meantime and

490 * will set ws->active. Then, ws->active may be cleared immediately

491 * by the __pm_relax() called from the timer function, but in such a

492 * case ws->relax_count will be different from ws->active_count.

493 */

494 if (ws->relax_count != ws->active_count) {

495 ws->relax_count--;

496 return;

497 }

498

499 ws->active = false;

500

501 now = ktime_get();

502 duration = ktime_sub(now, ws->last_time);

503 ws->total_time = ktime_add(ws->total_time, duration);

504 if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))

505 ws->max_time = duration;

506

507 ws->last_time = now;

508 del_timer(&ws->timer);

509 ws->timer_expires = 0;

510

511 if (ws->autosleep_enabled)

512 update_prevent_sleep_time(ws, now);

513

514 /*

515 * Increment the counter of registered wakeup events and decrement the

516 * couter of wakeup events in progress simultaneously.

517 */

518 cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);

519 trace_wakeup_source_deactivate(ws->name, cec);

520

521 split_counters(&cnt, &inpr);

522 if (!inpr && waitqueue_active(&wakeup_count_wait_queue))

523 wake_up(&wakeup_count_wait_queue);

524 }

这个函数前面我们就不看了，主要看下 521行到523行，这里split_counters实现如下

32 static atomic_t combined_event_count = ATOMIC_INIT(0);

33

34 #define IN_PROGRESS_BITS (sizeof(int) * 4)

35 #define MAX_IN_PROGRESS ((1 << IN_PROGRESS_BITS) - 1)

36

37 static void split_counters(unsigned int *cnt, unsigned int *inpr)

38 {

39 unsigned int comb = atomic_read(&combined_event_count);

40

41 *cnt = (comb >> IN_PROGRESS_BITS);

42 *inpr = comb & MAX_IN_PROGRESS;

43 }

这个原子操作不就是得到了刚才我们++combined_event_count记录的wake_lock数量的变量吗？取得32位数上的高16位数啊，这样的话难道每次都是高16位存的都是新值，而后16位都是旧值吗？这个还需要研究研究！然后我们看下后两行

522 if (!inpr && waitqueue_active(&wakeup_count_wait_queue))

523 wake_up(&wakeup_count_wait_queue);

这个就是判断wake_locks数，等待队列是否活动，然后唤醒等待队列，这个等待队列到底在哪里了？我们往后再说，这里先卖个关子 哇哈哈！

好了 现在我们wake_lock和unwake_lock都已经说了，但是他们和suspend有毛关系呢？我们继续分析state这个函数。

如果我们执行echo mem > /sys/power/state 会发生什么？ 没错，手机屏幕会灭，手机会进入了earlysuspend状态，呵呵，这就是我分析第二片文章为什么要特意说下farmework 到 native 怎么把值写到这个节点的必要性了。下面我们看看函数

301 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,

302 const char *buf, size_t n)

303 {

304 suspend_state_t state;

305 int error;

306

307 error = pm_autosleep_lock();

308 if (error)

309 return error;

310

311 if (pm_autosleep_state() > PM_SUSPEND_ON) {

312 error = -EBUSY;

313 goto out;

314 }

315

316 state = decode_state(buf, n);

317 if (state < PM_SUSPEND_MAX) {

318 #ifdef CONFIG_EARLYSUSPEND

319 if (state == PM_SUSPEND_ON || valid_state(state)) {

320 error = 0;

321 request_suspend_state(state);

322 }

323 #else

324 error = pm_suspend(state);

325 #endif

326

327 }

328 else if (state == PM_SUSPEND_MAX)

329 error = hibernate();

330 else

331 error = -EINVAL;

332

333 out:

334 pm_autosleep_unlock();

335 return error ? error : n;

336 }

首先判断系统是不是正在suspend的状态，然后检查写入的值是否有效，如果有效这里分支就是为了支持earlysuspend过能和不带earlysuspend功能，然后调用request_suspend_state(state);这个函数。移动设备默认都带earlysuspend功能

208 void request_suspend_state(suspend_state_t new_state)

209 {

210 unsigned long irqflags;

211 int old_sleep;

212 suspend_state_t prev_state;

213

214 mutex_lock(&suspend_lock);

215 prev_state = suspend_state;

216 spin_lock_irqsave(&state_lock, irqflags);

217 old_sleep = state & SUSPEND_REQUESTED;

218 if (debug_mask & DEBUG_USER_STATE) {

219 struct timespec ts;

220 struct rtc_time tm;

221 getnstimeofday(&ts);

222 rtc_time_to_tm(ts.tv_sec, &tm);

223 pr_info("request_suspend_state: %s (%d->%d) at %lld "

224 "(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",

225 new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",

226 prev_state, new_state,

227 ktime_to_ns(ktime_get()),

228 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,

229 tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);

230 }

231 if (!old_sleep && new_state != PM_SUSPEND_ON) {

232 state |= SUSPEND_REQUESTED;

233 queue_up_early_suspend_work(&early_suspend_work);

234 } else if (old_sleep && new_state == PM_SUSPEND_ON) {

235 state &= ~SUSPEND_REQUESTED;

236 __pm_stay_awake(early_suspend_ws);

237 queue_up_early_suspend_work(&late_resume_work);

238 }

239 suspend_state = new_state;

240 spin_unlock_irqrestore(&state_lock, irqflags);

241 mutex_unlock(&suspend_lock);

242 }

这个函数主要就是区分是要走earlysuspend 还是lateresume，然后调用&early_suspend_work)这个工作队列，其实就是调用early_suspend函数

136 static void early_suspend(struct work_struct *work)

137 {

138 struct early_suspend *pos;

139 unsigned long irqflags;

140 int abort = 0;

141

142 mutex_lock(&early_suspend_lock);

143 spin_lock_irqsave(&state_lock, irqflags);

144 if (state == SUSPEND_REQUESTED)

145 state |= SUSPENDED;

146 else

147 abort = 1;

148 spin_unlock_irqrestore(&state_lock, irqflags);

149

150 if (abort) {

151 if (debug_mask & DEBUG_SUSPEND)

152 pr_info("early_suspend: abort, state %d\n", state);

153 mutex_unlock(&early_suspend_lock);

154 goto abort;

155 }

156

157 if (debug_mask & DEBUG_SUSPEND)

158 pr_info("early_suspend: call handlers\n");

159 list_for_each_entry(pos, &early_suspend_handlers, link) {

160 if (pos->suspend != NULL)

161 pos->suspend(pos);

162 }

163 mutex_unlock(&early_suspend_lock);

164

165 if (debug_mask & DEBUG_SUSPEND)

166 pr_info("early_suspend: after call handlers\n");

167 /* just wake up flusher to start write back and don't wait it finished*/

168 wakeup_flusher_threads(0, WB_REASON_SYNC);

169 abort:

170 spin_lock_irqsave(&state_lock, irqflags);

171 if (state == SUSPEND_REQUESTED_AND_SUSPENDED)

172 __pm_relax(early_suspend_ws);

173 spin_unlock_irqrestore(&state_lock, irqflags);

174 mod_timer(&monitor_timer, jiffies + monitor_period*HZ);

175 queue_work(suspend_wq, &suspend_work);

176 }

这里就是逐个调用平台注册过得earlysuspend函数，按照leave来调用哦，注册时候会定义，然后系统会调用 queue_work(suspend_wq, &suspend_work);这个工作队列，这个其实就是try_to_suspend，

68 static void try_to_suspend(struct work_struct *work)

69 {

70 unsigned int initial_count, final_count;

71

72 if (!pm_get_wakeup_count(&initial_count, true) ||

73 !alarm_pm_wake_check())

74 goto queue_again;

75

76 mutex_lock(&suspend_lock);

77

78 if (!pm_save_wakeup_count(initial_count)) {

79 mutex_unlock(&suspend_lock);

80 goto queue_again;

81 }

82 del_timer_sync(&monitor_timer);

83

84 if (suspend_state == PM_SUSPEND_ON) {

85 mutex_unlock(&suspend_lock);

86 return;

87 }

88

89 if (suspend_state >= PM_SUSPEND_MAX)

90 hibernate();

91 else

92 pm_suspend(suspend_state);

93

94 mutex_unlock(&suspend_lock);

95

96 if (!pm_get_wakeup_count(&final_count, false))

97 goto queue_again;

98

99 /*

100 * If the wakeup occured for an unknown reason, wait to prevent the

101 * system from trying to suspend and waking up in a tight loop.

102 */

103 if (final_count == initial_count)

104 schedule_timeout_uninterruptible(HZ / 2);

105

106 queue_again:

107 queue_work(suspend_wq, &suspend_work);

108 }

函数嘴开始就执行了 pm_get_wakeup_count（）这个函数，这个函数：

722 bool pm_get_wakeup_count(unsigned int *count, bool block)

723 {

724 unsigned int cnt, inpr;

725

726 if (block) {

727 DEFINE_WAIT(wait);

728

729 for (;;) {

730 prepare_to_wait(&wakeup_count_wait_queue, &wait,

731 TASK_INTERRUPTIBLE);

732 split_counters(&cnt, &inpr);

733 if (inpr == 0 || signal_pending(current))

734 break;

735

736 schedule();

737 }

738 finish_wait(&wakeup_count_wait_queue, &wait);

739 }

740

741 split_counters(&cnt, &inpr);

742 *count = cnt;

743 return !inpr;

744 }

看到了刚才我们介绍unwake_lock函数的时候碰见的wakeup_count_wait_queue等待队列了吧，没错，这里就循环等待是不是有应用或者driver拿着锁，如果拿着就调度出去做别的事情，等待unwake_lock的显示唤醒队列，然后再去检查split_counters(&cnt, &inpr);锁数量，如果没有锁了，OK，我们跳出循环，准备进入下面的suspend流程，到这里是不是就算解释清楚，wakelock和suspend的关系了呢？上层
中层 底层调用基本上已经联系一起了，我会在下篇文章继续分析suspend的流程！

还是一样，本人小菜鸟一名，如果不对，请指出，谢谢！