//创建电源锁

[cpp] view plain copy

PowerManagerService.java

mWakeLockSuspendBlocker = createSuspendBlockerLocked("PowerManagerService.WakeLocks");

mDisplaySuspendBlocker = createSuspendBlockerLocked("PowerManagerService.Display");

private SuspendBlocker createSuspendBlockerLocked(String name) {
        SuspendBlocker suspendBlocker = new SuspendBlockerImpl(name);
        mSuspendBlockers.add(suspendBlocker);
        return suspendBlocker;
    }

//电源锁操作类的实现

[cpp] view plain copy

private final class SuspendBlockerImpl implements SuspendBlocker {
        private final String mName;
        private int mReferenceCount;

public SuspendBlockerImpl(String name) {
            mName = name;
        }

@Override
        public void acquire() {
            synchronized (this) {
                mReferenceCount += 1;
                if (mReferenceCount == 1) {
                    if (DEBUG_SPEW) {
                        Slog.d(TAG, "Acquiring suspend blocker \"" + mName + "\".");
                    }
                    nativeAcquireSuspendBlocker(mName);
                }
            }
        }

@Override
        public void release() {
            synchronized (this) {
                mReferenceCount -= 1;
                if (mReferenceCount == 0) {
                    if (DEBUG_SPEW) {
                        Slog.d(TAG, "Releasing suspend blocker \"" + mName + "\".");
                    }
                    nativeReleaseSuspendBlocker(mName);
                } else if (mReferenceCount < 0) {
                    Log.wtf(TAG, "Suspend blocker \"" + mName
                            + "\" was released without being acquired!", new Throwable());
                    mReferenceCount = 0;
                }
            }
        }

}

//JNI层函数实现电源锁的获取

[cpp] view plain copy

com_android_server_power_PowerManagerService.cpp

static void nativeAcquireSuspendBlocker(JNIEnv *env, jclass clazz, jstring nameStr) {
    ScopedUtfChars name(env, nameStr);
    acquire_wake_lock(PARTIAL_WAKE_LOCK, name.c_str());
}

//将电源锁写入到相应的文件中，相当于获得了电源锁

power.c

[cpp] view plain copy

int acquire_wake_lock(int lock, const char* id)
{
    initialize_fds();
    if (g_error) return g_error;

int fd;

if (lock == PARTIAL_WAKE_LOCK) {
        fd = g_fds[ACQUIRE_PARTIAL_WAKE_LOCK];
    }
    else {
        return EINVAL;
    }

return write(fd, id, strlen(id));
}

//打开记录电源锁的文件

[cpp] view plain copy

static inline void
initialize_fds(void)
{
    if (g_initialized == 0) {
        if(open_file_descriptors(NEW_PATHS) < 0)
            open_file_descriptors(OLD_PATHS);
        g_initialized = 1;
    }
}

//记录电源锁的文件路径

[cpp] view plain copy

const char * const OLD_PATHS[] = {
    "/sys/android_power/acquire_partial_wake_lock",
    "/sys/android_power/release_wake_lock",
};

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

到现在为止，我们的代码流程已经走了一大半了，我们一开始介绍的android的上面几层Framework层、JNI层、HAL层都已经介绍了。下面就应该是和kernel层进行交互了。
但是在android/hardware/libhardware_legacy/power/power.c中的acquire_wake_lock()函数似乎没法和kernel层进行通信啊？最后的返回语句return write(fd, id, strlen(id))是一个系统调用，这里就实现了与kernel的交互。
kernel/power/main.c中的power_attr宏很多地方用到：

[cpp] view plain copy
  1. #define power_attr(_name) \
  2. static struct kobj_attribute _name##_attr = {   \
  3. .attr   = {             \
  4. .name = __stringify(_name), \
  5. .mode = 0644,           \
  6. },                  \
  7. .show   = _name##_show,         \
  8. .store  = _name##_store,        \
  9. }
[cpp] view plain copy
  1. #ifdef CONFIG_USER_WAKELOCK
  2. power_attr(wake_lock);
  3. power_attr(wake_unlock);
  4. #endif

default y
User-space wake lock api. Write "lockname" or "lockname timeout"
to /sys/power/wake_lock lock and if needed create a wake lock.
Write "lockname" to /sys/power/wake_unlock to unlock a user wake
lock.

[cpp] view plain copy
  1. #ifdef CONFIG_PM_WAKELOCKS
  2. power_attr(wake_lock);
  3. power_attr(wake_unlock);
  4. #endif

default n
Allow user space to create, activate and deactivate wakeup source
objects with the help of a sysfs-based interface.
宏展开，等价于：

[cpp] view plain copy
  1. static struct kobj_attribute wake_lock_attr = {
  2. .attr   = {
  3. .name = “wake_lock”,
  4. .mode = 0644,
  5. },
  6. .show   = wake_lock_show,
  7. .store  = wake_lock_store,
  8. }
[cpp] view plain copy
  1. static struct kobj_attribute wake_unlock_attr = {
  2. .attr   = {
  3. .name = “wake_unlock”,
  4. .mode = 0644,
  5. },
  6. .show   = wake_unlock_show,
  7. .store  = wake_unlock_store,
  8. }

show和store函数的源码位于kernel/power/userwakelock.c。

[cpp] view plain copy
  1. static struct attribute * g[] = {
  2. &state_attr.attr,
  3. #ifdef CONFIG_PM_TRACE
  4. &pm_trace_attr.attr,
  5. &pm_trace_dev_match_attr.attr,
  6. #endif
  7. #ifdef CONFIG_PM_SLEEP
  8. &pm_async_attr.attr,
  9. &wakeup_count_attr.attr,
  10. #ifdef CONFIG_USER_WAKELOCK
  11. &wake_lock_attr.attr,
  12. &wake_unlock_attr.attr,
  13. #endif
  14. #ifdef CONFIG_PM_AUTOSLEEP
  15. &autosleep_attr.attr,
  16. #endif
  17. #ifdef CONFIG_PM_WAKELOCKS
  18. &wake_lock_attr.attr,
  19. &wake_unlock_attr.attr,
  20. #endif
  21. #ifdef CONFIG_PM_DEBUG
  22. &pm_test_attr.attr,
  23. #endif
  24. #ifdef CONFIG_PM_SLEEP_DEBUG
  25. &pm_print_times_attr.attr,
  26. #endif
  27. #endif
  28. #ifdef CONFIG_FREEZER
  29. &pm_freeze_timeout_attr.attr,
  30. #endif
  31. NULL,
  32. };
[cpp] view plain copy
  1. static struct attribute_group attr_group = {
  2. .attrs = g,
  3. };

pm_init()->
error = sysfs_create_group(power_kobj, &attr_group);
好了，我们该回到原来我们产生疑问的地方了这时我们还得关注其中的另一个函数acquire_wake_lock()->initialize_fds()。

[cpp] view plain copy
  1. initialize_fds(void)
  2. {
  3. // XXX: should be this:
  4. //pthread_once(&g_initialized, open_file_descriptors);
  5. // XXX: not this:
  6. if (g_initialized == 0) {
  7. if(open_file_descriptors(NEW_PATHS) < 0)
  8. open_file_descriptors(OLD_PATHS);
  9. g_initialized = 1;
  10. }
  11. }

其实这个函数中最核心的步骤就是open_file_descriptors(NEW_PATHS)，顺序打开NEW_PATHS[ ]中的文件：

[cpp] view plain copy
  1. static int
  2. open_file_descriptors(const char * const paths[])
  3. {
  4. int i;
  5. for (i=0; i<OUR_FD_COUNT; i++) {
  6. int fd = open(paths[i], O_RDWR);
  7. if (fd < 0) {
  8. fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]);
  9. g_error = errno;
  10. return -1;
  11. }
  12. g_fds[i] = fd;
  13. }
  14. g_error = 0;
  15. return 0;
  16. }
[cpp] view plain copy
  1. const char * const NEW_PATHS[] = {
  2. "/sys/power/wake_lock",
  3. "/sys/power/wake_unlock",
  4. };

总之经过着一系列的步骤后，最终我们将在 return write(fd, id, strlen(id));时调用android/kernel/kernel/power/userwakelock.c 中的 wake_lock_store()函数。

[cpp] view plain copy
  1. ssize_t wake_lock_store(
  2. struct kobject *kobj, struct kobj_attribute *attr,
  3. const char *buf, size_t n)
  4. {
  5. long timeout;
  6. struct user_wake_lock *l;
  7. mutex_lock(&tree_lock);
  8. l = lookup_wake_lock_name(buf, 1, &timeout);
  9. if (IS_ERR(l)) {
  10. n = PTR_ERR(l);
  11. goto bad_name;
  12. }
  13. if (debug_mask & DEBUG_ACCESS)
  14. pr_info("wake_lock_store: %s, timeout %ld\n", l->name, timeout);
  15. if (timeout)
  16. wake_lock_timeout(&l->wake_lock, timeout);
  17. else
  18. wake_lock(&l->wake_lock);
  19. bad_name:
  20. mutex_unlock(&tree_lock);
  21. return n;
  22. }
[cpp] view plain copy
  1. struct rb_root user_wake_locks;
  2. static struct user_wake_lock *lookup_wake_lock_name(
  3. const char *buf, int allocate, long *timeoutptr)
  4. {
  5. struct rb_node **p = &user_wake_locks.rb_node;
  6. struct rb_node *parent = NULL;
  7. struct user_wake_lock *l;
  8. int diff;
  9. u64 timeout;
  10. int name_len;
  11. const char *arg;
  12. /* Find length of lock name and start of optional timeout string */
  13. arg = buf;
  14. while (*arg && !isspace(*arg))
  15. arg++;
  16. //lock name的长度
  17. name_len = arg - buf;
  18. if (!name_len)
  19. goto bad_arg;
  20. while (isspace(*arg))
  21. arg++;
  22. /* Process timeout string */
  23. if (timeoutptr && *arg) {
  24. //(char **)&arg存储的是解析string的结束字符
  25. timeout = simple_strtoull(arg, (char **)&arg, 0);
  26. while (isspace(*arg))
  27. arg++;
  28. //如果解析string的结束字符不是’\0’
  29. if (*arg)
  30. goto bad_arg;
  31. /* convert timeout from nanoseconds to jiffies > 0 */
  32. timeout += (NSEC_PER_SEC / HZ) - 1;
  33. //do_div(a,b)的返回值是余数，商保存到a中
  34. do_div(timeout, (NSEC_PER_SEC / HZ));
  35. if (timeout <= 0)
  36. timeout = 1;
  37. *timeoutptr = timeout;
  38. } else if (*arg)
  39. //timeoutptr为NULL
  40. goto bad_arg;
  41. else if (timeoutptr)
  42. //*arg为0，没有timeout
  43. *timeoutptr = 0;
  44. /* Lookup wake lock in rbtree */
  45. //对于一颗空的红黑树，略过while。wake lock按照name从小到大的顺序存储到user_wake_locks红黑树中
  46. while (*p) {
  47. parent = *p;
  48. l = rb_entry(parent, struct user_wake_lock, node);
  49. diff = strncmp(buf, l->name, name_len);
  50. //如果buf是l->name的子串，那么l->name[name_len]就不会为0，但是buf[name_len]会为0
  51. if (!diff && l->name[name_len])
  52. diff = -1;
  53. if (debug_mask & DEBUG_ERROR)
  54. pr_info("lookup_wake_lock_name: compare %.*s %s %d\n",
  55. name_len, buf, l->name, diff);
  56. if (diff < 0)
  57. p = &(*p)->rb_left;
  58. else if (diff > 0)
  59. p = &(*p)->rb_right;
  60. else
  61. return l;
  62. }
  63. /* Allocate and add new wakelock to rbtree */
  64. //allocate为0，表示不需要分配新的wakelock，只在rbtree上查找，找不到就出错了
  65. if (!allocate) {
  66. if (debug_mask & DEBUG_ERROR)
  67. pr_info("lookup_wake_lock_name: %.*s not found\n",
  68. name_len, buf);
  69. return ERR_PTR(-EINVAL);
  70. }
  71. l = kzalloc(sizeof(*l) + name_len + 1, GFP_KERNEL);
  72. if (l == NULL) {
  73. if (debug_mask & DEBUG_FAILURE)
  74. pr_err("lookup_wake_lock_name: failed to allocate "
  75. "memory for %.*s\n", name_len, buf);
  76. return ERR_PTR(-ENOMEM);
  77. }
  78. memcpy(l->name, buf, name_len);
  79. if (debug_mask & DEBUG_NEW)
  80. pr_info("lookup_wake_lock_name: new wake lock %s\n", l->name);
  81. wake_lock_init(&l->wake_lock, WAKE_LOCK_SUSPEND, l->name);
  82. //插入结点，并染成红色
  83. rb_link_node(&l->node, parent, p);
  84. rb_insert_color(&l->node, &user_wake_locks);
  85. return l;
  86. bad_arg:
  87. if (debug_mask & DEBUG_ERROR)
  88. pr_info("lookup_wake_lock_name: wake lock, %.*s, bad arg, %s\n",
  89. name_len, buf, arg);
  90. return ERR_PTR(-EINVAL);
  91. }

wake_lock_store()执行的基本流程为：首先调用lookup_wake_lock_name()来获得指定的唤醒锁，若延迟参数timeout为零的话，就调用 wake_lock()否则就调用wake_lock_timeout()，但不管调用哪个最后都会调用到android/kernel/kernel/power/wakelock.c中的函数static void wake_lock_internal()。

[cpp] view plain copy
  1. static void wake_lock_internal(
  2. struct wake_lock *lock, long timeout, int has_timeout)
  3. {
  4. int type;
  5. unsigned long irqflags;
  6. long expire_in;
  7. spin_lock_irqsave(&list_lock, irqflags);
  8. type = lock->flags & WAKE_LOCK_TYPE_MASK;
  9. //检查type是否合法
  10. BUG_ON(type >= WAKE_LOCK_TYPE_COUNT);
  11. //检查是否初始化过
  12. BUG_ON(!(lock->flags & WAKE_LOCK_INITIALIZED));
  13. #ifdef CONFIG_WAKELOCK_STAT
  14. if (type == WAKE_LOCK_SUSPEND && wait_for_wakeup) {
  15. if (debug_mask & DEBUG_WAKEUP)
  16. pr_info("wakeup wake lock: %s\n", lock->name);
  17. wait_for_wakeup = 0;
  18. lock->stat.wakeup_count++;
  19. }
  20. if ((lock->flags & WAKE_LOCK_AUTO_EXPIRE) &&
  21. (long)(lock->expires - jiffies) <= 0) {
  22. wake_unlock_stat_locked(lock, 0);
  23. lock->stat.last_time = ktime_get();
  24. }
  25. #endif
  26. if (!(lock->flags & WAKE_LOCK_ACTIVE)) {
  27. lock->flags |= WAKE_LOCK_ACTIVE;
  28. #ifdef CONFIG_WAKELOCK_STAT
  29. lock->stat.last_time = ktime_get();
  30. #endif
  31. }
  32. //从inactive_locks上删除
  33. list_del(&lock->link);
  34. if (has_timeout) {
  35. if (debug_mask & DEBUG_WAKE_LOCK)
  36. pr_info("wake_lock: %s, type %d, timeout %ld.%03lu\n",
  37. lock->name, type, timeout / HZ,
  38. (timeout % HZ) * MSEC_PER_SEC / HZ);
  39. lock->expires = jiffies + timeout;
  40. lock->flags |= WAKE_LOCK_AUTO_EXPIRE;
  41. list_add_tail(&lock->link, &active_wake_locks[type]);
  42. } else {
  43. if (debug_mask & DEBUG_WAKE_LOCK)
  44. pr_info("wake_lock: %s, type %d\n", lock->name, type);
  45. lock->expires = LONG_MAX;
  46. lock->flags &= ~WAKE_LOCK_AUTO_EXPIRE;
  47. list_add(&lock->link, &active_wake_locks[type]);
  48. }
  49. if (type == WAKE_LOCK_SUSPEND) {
  50. current_event_num++;
  51. #ifdef CONFIG_WAKELOCK_STAT
  52. if (lock == &main_wake_lock)
  53. update_sleep_wait_stats_locked(1);
  54. else if (!wake_lock_active(&main_wake_lock))
  55. update_sleep_wait_stats_locked(0);
  56. #endif
  57. if (has_timeout)
  58. expire_in = has_wake_lock_locked(type);
  59. else
  60. expire_in = -1;
  61. if (expire_in > 0) {
  62. if (debug_mask & DEBUG_EXPIRE)
  63. pr_info("wake_lock: %s, start expire timer, "
  64. "%ld\n", lock->name, expire_in);
  65. mod_timer(&expire_timer, jiffies + expire_in);
  66. } else {
  67. if (del_timer(&expire_timer))
  68. if (debug_mask & DEBUG_EXPIRE)
  69. pr_info("wake_lock: %s, stop expire timer\n",
  70. lock->name);
  71. if (expire_in == 0)
  72. queue_work(suspend_work_queue, &suspend_work);
  73. }
  74. }
  75. spin_unlock_irqrestore(&list_lock, irqflags);
  76. }

//电源锁的使用

[cpp] view plain copy

/**
     * Updates the suspend blocker that keeps the CPU alive.
     *
     * This function must have no other side-effects.
     */
    private void updateSuspendBlockerLocked() {
        final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);
        final boolean needDisplaySuspendBlocker = needDisplaySuspendBlocker();

// First acquire suspend blockers if needed.
        if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) {
            mWakeLockSuspendBlocker.acquire();
            mHoldingWakeLockSuspendBlocker = true;
        }
        if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) {
            mDisplaySuspendBlocker.acquire();
            mHoldingDisplaySuspendBlocker = true;
        }

// Then release suspend blockers if needed.
        if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) {
            mWakeLockSuspendBlocker.release();
            mHoldingWakeLockSuspendBlocker = false;
        }
        if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) {
            mDisplaySuspendBlocker.release();
            mHoldingDisplaySuspendBlocker = false;
        }
    }

//判断是否处于亮屏或者正在变化阶段

[cpp] view plain copy

private boolean needDisplaySuspendBlocker() {

//正处于变化阶段
        if (!mDisplayReady) {
            return true;
        }
        if (mDisplayPowerRequest.screenState != DisplayPowerRequest.SCREEN_STATE_OFF) {

//有疑问？
            // If we asked for the screen to be on but it is off due to the proximity
            // sensor then we may suspend but only if the configuration allows it.
            // On some hardware it may not be safe to suspend because the proximity
            // sensor may not be correctly configured as a wake-up source.
            if (!mDisplayPowerRequest.useProximitySensor || !mProximityPositive
                    || !mSuspendWhenScreenOffDueToProximityConfig) {
                return true;
            }
        }
        return false;
    }

Android4.4电源管理——电源锁相关推荐

  1. iTOP-4418开发板支持动态调频,AXP228电源管理,预留锂电池接口，内置充放电电路及电量计...

    iTOP-4418开发板 支持动态调频,AXP228电源管理,预留锂电池接口,内置充放电电路及电量计 核心板320PIN全引出,16G存储高配版本,核心板4418/6818全兼容,并跨行业大量应用 系 ...

  2. Android电源管理介绍

    一.电源管理基础知识 1.1电源管理的几种状态 Android kernel源码中,定义了三种电源状态,在kernel/power/suspend.c中: 对应的宏定义/include/linux/s ...

  3. linux pcie热插拔驱动_Linux安装TLP-高级电源管理工具

    唉,最近有了一个新问题.系统版本Ubuntu 18.04,笔记本,一旦断开电源,电脑就会卡住.试过的方法: 更新了固件 sudo apt update sudo apt upgrade -y 管了几天 ...

  4. 时钟,复位和电源管理

    文章目录 一.电源管理和复位 二.时钟 1.时钟的分类和特性 2.时钟图 杨桃32学习笔记,本文图片文字皆为转述 一.电源管理和复位 (1)8MHZ的振荡器给arm内核提供,40khz给RTC使用也就 ...

  5. 关闭linux服务器电源,linux关闭ACPI电源管理模块

    一.运行环境 # cat /etc/redhat-release CentOS release 6.2 (Final) # uname -a Linux web-server- 2.6.-.el6.x ...

  6. Freescale 基于IMX536处理器的Dialog DA9053电源管理参考设计

    Freescale 基于IMX536处理器的Dialog DA9053电源管理参考设计 ----------墨翟科技(上海)有限公司编撰 在2012年飞思卡尔技术论坛中国站的展示区,Dialog公司推 ...

  7. android电源驱动程序,[转]Android虚拟电源管理驱动

    Android系统如果没有电源管理相关的驱动程序,在启动时将会提示如下错误: I/SystemServer(   50): Starting Battery Service. E/BatterySer ...

  8. IC基础知识（4）电源管理简介：稳压器IC

    文章目录 写在前面 正文 线性与开关 线性稳压器 开关稳压器 其他类型的功率IC 结论 写在前面 原文链接:Introduction to Power Management: Voltage Regu ...

  9. FPGA内部电源管理详解

    做了这么长时间的FPGA的设计,也看了很多这方面的书籍资料,不管是编程还是调试,一直都只在关心有没有实现功能,没有去深入理解FFPGA的内部结构,接下来这几篇文章将着重分析FPGA设计的各个部分细节. ...

最新文章

  1. 计算机领域收费sci期刊,计算机领域收费sci期刊 - 百度学术
  2. python中any的妙用
  3. Leetcode python《热题 HOT 100》1. 两数之和
  4. c语言黄建灯第七章答案,c语言实训大纲.doc
  5. NSArray 数组
  6. 关于Redis在windows上运行及fork函数问题
  7. Mbps和MB/s之间的换算
  8. 携程旅行网的盈利模式
  9. 运用设计模式实现Sql语句动态转换
  10. android平台获取手机IMSI，IMEI ,序列号，和 手机号的方法
  11. oracle 18c 转 11g,安装Oracle：Oracle 18c、Oracle 11g
  12. COM笔记-Widows 注册表
  13. 事业单位采购计算机的申请报告,事业单位采购申请报告
  14. 一款简单的本地音乐播放器，界面美观、包括主题切换、歌单管理等等
  15. 超声波测距仪编程_Arduino轻松学Mixly编程第9课 超声波测距仪
  16. 排名：百度小程序 微信 + 支付宝 + 百度 + 头条 商城源码-拓客营销
  17. 全球投资移民青睐低气候风险地，最具气候韧性国家排名前五都在北半球 | 美通社头条...
  18. 服务器显示屏出现白屏,前端性能优化之白屏时间
  19. 列出美国每个州及一个邮编
  20. Ubuntu16.04+GTX1060mq（驱动版本430.64）安装CUDA10.0

热门文章

  1. linux安装多系统之后启动等待90秒的解决办法
  2. 【暑假禁止摆烂】可以看看Java55个项目去练手
  3. Kubernetes 是下一代操作系统 | 面向 Kubernetes 编程
  4. 终于收到OCP证书了
  5. 王杰 吉他谱，呵呵蛮简单的哦
  6. 2021年软件测试工具大全（自动化、接口、性能、安全、测试管理）
  7. 美创科技与浪潮云海Insight HD软件完成产品兼容互认证
  8. 声网赵斌：RTE 体验提升，新一代 Killer App 将成为现实丨RTE 2022
  9. IDA7.2破解版本
  10. 培养意志力的11条建议