Android学习之wakelocks

最新推荐文章于 2024-05-01 11:10:29 发布

tron

最新推荐文章于 2024-05-01 11:10:29 发布

阅读量752

点赞数

分类专栏： android power专题文章标签： android timer list struct 数据结构 manager

android power专题专栏收录该内容

18 篇文章 1 订阅

订阅专栏

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

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

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

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

fbearlysuspend.c

earlysuspend.c

consoleearlysuspend.c

wakelock.c

userwakelock.c

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

接着主要关注wakelock的实现:

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

[plain] view plain copy

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

[plain] view plain copy

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
};

[plain] view plain copy

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

[plain] view plain copy

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的方式实现.

[plain] view plain copy

static struct dev_pm_ops power_driver_pm_ops = {
 .suspend_noirq = power_suspend_late, //参见<a href="http://lxr.linux.no/#linux+v3.2.7/Documentation/power/devices.txt#L213">devices.txt</a>的解释
};

static struct platform_driver power_driver = {
 .driver.name = "power",
 .driver.pm = &power_driver_pm_ops,
};
static struct platform_device power_device = {
 .name = "power",
};

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

[plain] view plain copy

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的调用

[plain] view plain copy

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);
}

关键的suspend函数

[plain] view plain copy

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);
 }
}

其余的函数都是一些工具函数,相当简单,这里就偷懒不说了:)

与驱动层的接口
hardware/libhardware_legacy/power/power.c
定义了3种可用的用户接口,与framework提供的功能对应

[plain] view plain copy

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

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

[plain] view plain copy

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

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

[plain] view plain copy

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

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的供电状态.

java层的接口
参见http://developer.android.com/reference/android/os/PowerManager.html, 里面介绍的很清楚了,关于它的使用也有很多教程及建议,我就不在这里敷述了.