Android kernel wakelock分析

最新推荐文章于 2023-11-09 15:26:03 发布
最新推荐文章于 2023-11-09 15:26:03 发布
阅读量2.2k 收藏
点赞数
分类专栏： Linux kernel

1. Linux kernel wakelock 定义

A wake_lock prevents the system from entering suspend or other low power states when active. If the type is set to WAKE_LOCK_SUSPEND, the wake_lock prevents a full system suspend. If the type is WAKE_LOCK_IDLE, low power

states that cause large interrupt latencies or that disable a set of interrupts will not entered from idle until the wake_locks are released.


当唤醒锁被激活的时候，它能阻止系统进入挂起状态或者其他低功耗模式。

如果锁类型被设置为 WAKE_LOCK_SUSPEND，该锁阻止整个系统进入挂起状态。

如果锁类型被设置为 WAKE_LOCK_IDLE,  除非该锁被释放，产生中断大延迟或者失能中断集的系统低功耗模式将被阻止进入。但是系统可以进入挂起睡眠状态。


2. 编译标志

根据Kconfig 文件， 相关的内核编译标志分别为：

CONFIG_HAS_WAKELOCK    选择是否使能 wakelock模块。

CONFIG_WAKELOCK:   依赖CONFIG_HAS_WAKELOCK。当用户空间请求睡眠状态时，该请求将被延置直到没有唤醒锁为使能状态。

CONFIG_WAKELOCK_STAT:      报告唤醒锁状态并写入到 /proc/wakelocks 文件

CONFIG_USER_WAKELOCK     用户空间唤醒锁。写入"锁名称" 或者“超时锁名称” 到 /sys/power/wake_lock文件来使能唤醒锁 ( 根据需要与否来创建一个唤醒锁）

                                                          写入“锁名称”到 /sys/power/wake_unlock 文件来解锁一个用户空间唤醒锁。

CONFIG_EARLYSUSPEND        当用户空间请求睡眠状态改变时， 调用early suspend handlers

                                                          该标志依赖于 CONFIG_WAKELOCK编译标志。


3. /proc/wakelocks 格式

示例如下

root@android:/ # cat /proc/wakelocks
cat /proc/wakelocks
name    count    expire_count    wake_count      active_since    total_time           sleep_time          max_time          last_change
"em"      4899               0                             0                   0          129695047374    123649908727  2367225591    29445791758668
"alarm_rtc"     2360    474     0       0       1613420206524   1611455462922   1949640000      27899269419825
"bcmpmu_i2c"    244500  0       1876    0       275160569412    268463363255    996054076       29445791728151
"KeyEvents"     11133   0       0       0       1853662043      601848424       231933595       29439508921751


4. 内核锁函数

初始化锁模块

[cpp] view plaincopyprint?

    static int __init wakelocks_init(void) 
    { 
        int ret; 
        int i; 
     
            // 初始化ｓｕｓｐｅｎｄ,　ｉｄｌｅ　两个类型锁的链表 
        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"); 
     
        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; 
        } 
     
        suspend_work_queue = create_singlethread_workqueue("suspend"); 
        if (suspend_work_queue == NULL) { 
            ret = -ENOMEM; 
            goto err_suspend_work_queue; 
        } 
     
    #ifdef CONFIG_WAKELOCK_STAT 
    　　　　　　　//创建　／ｐｒｏｃ／ｗａｋｅｌｏｃｋｓ,　　／ｐｒｏｃ／ａｃｔｉｖｅ_ｗａｋｅｌｏｃｋｓ　节点输出锁状态信息 
        proc_create("wakelocks", S_IRUGO, NULL, &wakelock_stats_fops); 
        proc_create("active_wakelocks", S_IRUGO, NULL, &active_wakelocks_fops); 
    #endif 
     
        return 0; 
     
    err_suspend_work_queue: 
        platform_driver_unregister(&power_driver); 
    err_platform_driver_register: 
        platform_device_unregister(&power_device); 
    err_platform_device_register: 
        wake_lock_destroy(&suspend_backoff_lock); 
        wake_lock_destroy(&unknown_wakeup); 
        wake_lock_destroy(&main_wake_lock); 
    #ifdef CONFIG_WAKELOCK_STAT 
        wake_lock_destroy(&deleted_wake_locks); 
    #endif 
        return ret; 
    } 

初始化锁
[cpp] view plaincopyprint?

    void wake_lock_init(struct wake_lock *lock, int type, const char *name) 

ｗａｋｅ_ｌｏｃｋ_ｉｎｉｔ()　设置锁的名字，类型，最后将新建的锁挂接到一个专门链接这些非锁状态的链表inactive_locks上。


上锁函数

[cpp] view plaincopyprint?

    void wake_lock(struct wake_lock *lock) 
    { 
        wake_lock_internal(lock, 0, 0); 
    } 
    EXPORT_SYMBOL(wake_lock); 
     
    void wake_lock_timeout(struct wake_lock *lock, long timeout) 
    { 
        wake_lock_internal(lock, timeout, 1); 
    } 

ｗａｋｅ_ｌｏｃｋ()和ｗａｋｅ_ｌｏｃｋ_ｔｉｍｅｏｕｔ()　分别对　ｉｎａｃｔｉｖｅ　的锁进行上锁。后者是超时锁。调用同一个内部函数　ｗａｋｅ_ｌｏｃｋ_ｉｎｔｅｒｎａｌ()

[cpp] view plaincopyprint?

    static void wake_lock_internal(struct wake_lock *lock, long timeout, int has_timeout) 
    { 
        spin_lock_irqsave(&list_lock, irqflags); 
        type = lock->flags & WAKE_LOCK_TYPE_MASK; 
     
    　　　　　　　//上锁前，　检查锁类型和有效性 
        BUG_ON(type >= WAKE_LOCK_TYPE_COUNT); 
        BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED)); 
    #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); 
        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); 
    　　　　　　　　　　　　　　　　　　　　　//如果超时锁为０，　且无非超时锁时，　ｅｘｐｉｒｅ_ｉｎ为０,　启动ｓｕｓｐｅｎｄ流程 
                if (expire_in == 0) 
                    queue_work(suspend_work_queue, &suspend_work); 
            } 
        } 
        spin_unlock_irqrestore(&list_lock, irqflags); 
    } 

解锁函数
[cpp] view plaincopyprint?

    void wake_unlock(struct wake_lock *lock) 
    { 
        int type; 
        unsigned long irqflags; 
        spin_lock_irqsave(&list_lock, irqflags); 
        type = lock->flags & WAKE_LOCK_TYPE_MASK; 
    #ifdef CONFIG_WAKELOCK_STAT 
        wake_unlock_stat_locked(lock, 0); 
    #endif 
        if (debug_mask & DEBUG_WAKE_LOCK) 
            pr_info("wake_unlock: %s\n", lock->name); 
    　　　　　　　//去处锁标志 
        lock->flags &= ~(WAKE_LOCK_ACTIVE | WAKE_LOCK_AUTO_EXPIRE); 
    　　　　　　　//该锁从　ａｃｔｉｖｅ列表移除，　加入ｉｎａｃｔｉｖｅ列表 
        list_del(&lock->link); 
        list_add(&lock->link, &inactive_locks); 
        if (type == WAKE_LOCK_SUSPEND) { 
    　　　　　　　　　　　　　　//检查是否需要启动ｓｕｓｐｅｎｄ流程 
            long has_lock = has_wake_lock_locked(type); 
            if (has_lock > 0) { 
                if (debug_mask & DEBUG_EXPIRE) 
                    pr_info("wake_unlock: %s, start expire timer, " 
                        "%ld\n", lock->name, has_lock); 
                mod_timer(&expire_timer, jiffies + has_lock); 
            } else { 
                if (del_timer(&expire_timer)) 
                    if (debug_mask & DEBUG_EXPIRE) 
                        pr_info("wake_unlock: %s, stop expire " 
                            "timer\n", lock->name); 
                if (has_lock == 0) 
                    queue_work(suspend_work_queue, &suspend_work); 
            } 
            if (lock == &main_wake_lock) { 
                if (debug_mask & DEBUG_SUSPEND) 
                    print_active_locks(WAKE_LOCK_SUSPEND); 
    #ifdef CONFIG_WAKELOCK_STAT 
                update_sleep_wait_stats_locked(0); 
    #endif 
            } 
        } 
        spin_unlock_irqrestore(&list_lock, irqflags); 
    } 


ｅｘｐｉｒｅ_ｗａｋｅ_ｌｏｃｋｓ()　检查是否所有锁已经超时。　如果ｈａｓ_ｗａｋｅ_ｌｏｃｋ_ｌｏｃｋｅｄ()　返回０，

针对ｓｕｓｐｅｎｄ锁，必然是超时锁为０且非超时锁为０，　则启动ｓｕｓｐｅｎｄ流程。

ｅｘｐｉｒｅ_ｗａｋｅ_ｌｏｃｋｓ()是　ｅｘｐｉｒｅ_ｔｉｍｅｒ　的超时回调函数。

[cpp] view plaincopyprint?

    static DEFINE_TIMER(expire_timer, expire_wake_locks, 0, 0); 


5. suspend函数

[cpp] view plaincopyprint?

    static void suspend(struct work_struct *work) 
    { 
        int ret; 
        int entry_event_num; 
        struct timespec ts_entry, ts_exit; 
     
            //如果还有ｓｕｓｐｅｎｄ锁，直接ａｂｏｒｔ 
        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; 
    　　　　　　　//内存同步 
        sys_sync(); 
        if (debug_mask & DEBUG_SUSPEND) 
            pr_info("suspend: enter suspend\n"); 
        getnstimeofday(&ts_entry); 
    　　　　　　　//系统ｓｕｓｐｅｎｄ 
    　　　　　　 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); 
        } 
     
        if (ts_exit.tv_sec - ts_entry.tv_sec <= 1) { 
            ++suspend_short_count; 
     
            if (suspend_short_count == SUSPEND_BACKOFF_THRESHOLD) { 
                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); 
        } 
    } 
    static DECLARE_WORK(suspend_work, suspend); 

Tommy_wxie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android 的相关原生分析
01-08
android 的相关原生分析
Linux Kernel and Android 休眠与唤醒
08-27
Linux Kernel and Android 休眠与唤醒 Linux Kernel and Android 休眠与唤醒
Linux电源管理_wakelocks－－（四）
子夜的专栏
05-26 8031
1. 前言 wakelocks是一个有故事的功能。 wakelocks最初出现在Android为linux kernel打的一个补丁集上，该补丁集实现了一个名称为“wakelocks”的系统调用，该系统调用允许调用者阻止系统进入低功耗模式（如idle、suspend等）。同时，该补丁集更改了Linux kernel原生的电源管理执行过程（kernel/power/main.c中的state_s
Linux休眠与唤醒---wakelock唤醒锁与autosleep功能使用
lihuan680680的博客
09-11 6066
一、Linux系统休眠 在嵌入式设备中由于省电功耗等原因我们需要让系统在不忙的时候进入休眠模式，Linux pm core提供给我们wakelock及autoslepp内核休眠机制。 autosleep 和 wakelock是并行存在，只有 wakelock 唤醒锁全部释放且 autosleep 为 enable 时候系统才能进入休眠； 二、autosleep功能 节点路径为/sys/power/autosleep，该值为mem表示打开autoslepp功能，如果值为off表示关闭。 如果没有此节点路径，我
android power-wakelock kernel
laughing_zou的专栏
10-30 950
前面讲到HAL层通过acquire_wake_lock和release_wake_lock往"/sys/power/wake_lock"与"/sys/power/wake_unlock"写入wakelock名称来acquire或者release wakelock。 写入这个文件节点时会调用到kernel里面"/sys/power/wake_lock"与"/sys/power/wake_unloc
Linux休眠唤醒之wakelock机制
qq_39575672的博客
03-22 2008
仅用于学习记录
Linux Kernel 5.4 正式版发布：原生支持 exFAT，引入内核锁定功能，AMD 或成最大赢家！...
easylife206的专栏
11-30 1581
大神 Linus Torvalds 于近日宣布了 Linux Kernel 5.4 正式版。作为一个重要版本更新，不仅更新了驱动程序以提供更好的硬件支持、增强了安全性，还引入了很多新的功...
Android4.4 XML解析死循环异常导致的开机无法正常启动
麦麦麦先森的小世界
10-22 2015
此文参考:https://blog.csdn.net/luzhenrong45/article/details/97393639 问题说明 HJE项目在开机过程中出现无法正常启动，系统一直循环打印 D/dalvikvm( 358): GC_CONCURRENT freed 386K, 35% free 943K/1448K, paused 2ms+2ms, total 8ms 日志分析： --...
Android在标准linux基础上对休眠唤醒的实现
tigerly的专栏
12-25 3999
Android在标准linux基础上对休眠唤醒的实现(一) 看到了一些好文章，作者写得非常好，放进来自己仔细研究下。 转自：http://blog.csdn.net/lizhiguo0532/article/details/6453581 说明： 1. Based on linux 2.6.32 and android 2.2，only support SD
内核wake_lock小析
Android开发
05-23 2238
kernel/power/base/power/wakeup.c/** * struct wakeup_source - Representation of wakeup sources * * @total_time: Total time this wakeup source has been active. * @max_time: Maximum time this wakeup ...
Android Wakelock管理【app至kernel】
最新发布
专注于系统快稳省领域
11-09 1570
wakelock流程 [图片]
Linux wakelock与autosleep
Tracy Mcgrady的专栏
06-21 3509
内核版本：Linux-4.5 . wakelock Linux kernel在3.4及以后的版本中加入了wakelock机制，作用同之前的Android内核一样： 1. 为应用层提供接口来创建、释放wakelock 2. 在driver中，同样也可以创建、释放wakelock 3. 当所有的wakelock都释放掉之后，系统可以自动进入低功耗状态，由autosleep来实现
Android睡眠唤醒机制--Kernel态
热门推荐
MyArrow的专栏
11-01 3万+
一、简介       Android系统中定义了几种低功耗状态：earlysuspend、suspend、hibernation.       1) earlysuspend: 是一种低功耗的状态,某些设备可以选择进入某种功耗较低的状态,比如 LCD可以降低亮度或灭掉;        2) suspend: 是指除电源管理以外的其他外围模块以及cpu均不工作,只有内存保持自刷新的状态;
从Android应用层及Framework层的角度分析WakeLock锁机制
IT先森
11-20 2725
    从Android实战角度来分析分析WakeLock锁机制 前言   好久没有写点实战类型的博客了，最近一直都在捣鼓源码分析和项目相关事情，是时候来点实战类型的博客了。捯饬点啥实战的呢，正好前两天有一个同事询问我关于Android的WakeLock锁相关的问题，这里我们就从实战的角度出发来对Android的WakeLock锁机制分析一番。 注意：本篇的介绍是基于Android 7.xx平台为基础的，其中涉及的代码路径如下： frameworks/base/core/java/android/os/P
Linux电源管理-wakelock
半月旋空
11-03 7041
前言 之前说过Google为了在user space阻止系统suspend，为Android设计出一套新的电源管理: wakelocks,  early_suspend等。此机制修改了Linux原生的susupend流程，定义子自己的休眠接口。起初Android为了合入此patch和Linux内核开发者有一段时间的讨论。比如此地址：http://lwn.net/Articles/318611/
安卓禁止系统进入深度休眠，需求：插入充电器时候不进入深度休眠。linux wake_lock wake_unlock，cat /sys/kernel/debug/wakeup_sources查看
海月汐辰
05-31 2003
一、看kernel log，目前插着充电器灭屏幕之后会进入休眠。 二、 目前有个需求：因为进入深度休眠后会把一些电给关了，现在需要插入充电器的情况下不进入深度休眠。 三、linux wake_lock 已经/sys/power 下面提供相关接口 四、驱动文件在 kernel\kernel\power\main.c 、kernel\kernel\power\wakelock.c 五、Android 上层调用这些接口的地方在system\hardware\interfaces\.....
android 用户管理 lock,Android 电源管理 -- wakelock机制
weixin_29098367的博客
05-26 188
PowerManager.WakeLock有加锁和解锁两种状态，加锁的方式有两种：第一种是永久的锁住，这样的锁除非显式的放开，否则是不会解锁的，所以这种锁用起来要非常的小心。第二种锁是超时锁，这种锁会在锁住后一段时间解锁。在创建了PowerManager.WakeLock后，有两种机制，第一种是不计数锁机制，另一种是计数锁机制。可以通过setReferenceCounted(booleanvalu...
ANDROID Porting系列十一Power Management
lqf785435771的专栏
12-11 552
ANDROID Porting系列十一、Power Management 分类： 2.----ANDROID 2010-07-16 20:36 2782人阅读 评论(1) 收藏 举报 http://source.android.com/porting/power_management.html 介绍   wake_locks Wake Locks类型 探索Wa
Android 电源管理 -- wakelock机制
12-12 710
Wake Lock是一种锁的机制, 只要有人拿着这个锁,系统就无法进入休眠, 可以被用户态程序和内核获得. 这个锁可以是有超时的 或者 是没有超时的, 超时的锁会在时间过去以后自动解锁。如果没有锁了或者超时了, 内核就会启动休眠的那套机制来进入休眠. PowerManager.WakeL...
Android 休眠机制->wake_lock机制浅析
u011938662的博客
10-18 870
Android的休眠唤醒主要基于wake_lock机制，只要系统中存在任一有效的wake_lock，系统就不能进入深度休眠，但可以进行设备的浅度休眠操作。wake_lock一般在关闭lcd、tp,但系统仍然需要正常运行的情况下使用，比如听歌、传输很大的文件等。 --------------------------------------------------------------------
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值