cpuidle子系统之（二）：core层

struct cpuidle_state {

    //name和desc用于保存当前C state的名称的描述

    char name[CPUIDLE_NAME_LEN];

    char desc[CPUIDLE_DESC_LEN];

    //下面exit_latency和target_residency转化为ns，

    //为啥一个结构中要保存两个呢，详见c1d51f684c72b提交

    u64 exit_latency_ns;                    //退出延迟

    u64 target_residency_ns;                //最小滞留时间

    //可选的flags标记如下

    //CPUIDLE_FLAG_TIME_VALID        : 该idle等级下的时间是可测量的

    //CPUIDLE_FLAG_COUPLED        : 该idle等级会同时在多个cpu上起作用，软件需要特殊处理；

    //CPUIDLE_FLAG_POLLING        : 表示不是真正意义上的idle状态，而是处于忙等

    //CPUIDLE_FLAG_TIMER_STOP        : 表面在该C state下，local timer会被关闭

    //CPUIDLE_FLAG_UNUSABLE        : 这个C state不能用，即unavailable

    //CPUIDLE_FLAG_OFF                : 该C state默认是被disable掉的

    //CPUIDLE_FLAG_TLB_FLUSHED    : idle-state flushes TLBs

    //CPUIDLE_FLAG_RCU_IDLE        : idle-state takes care of RCU

    unsigned int flags;

    //cpu从该C state中返回到可运行状态所需的延迟，单位us

    //它决定了cpu在idle状态和run状态之间切换的效率，如果延迟过大，将会影响系统性能

    unsigned int exit_latency; /* in US */

    //cpu在该C state下的功耗，单位mW

    //实际上，cpuidle子系统在挑选C state的过程中并没有使用到该成员，

    //仅在sysfs导出到用户空间的power节点使用，仅起到一个标识的作用

    int power_usage; /* in mW */

    //切换代价，本文称"最小滞留时间"

    //进入和退出idle状态是需要消耗额外的能量的，如果在idle状态停留的时间过短，

    //节省的功耗少于额外的消耗，则得不偿失，该字段用于描述：进入该state至少需

    //要停留多长时间才是值得的，单位us

    //governor根据该字段，结合当前的系统情况，选择合适的C state

    unsigned int target_residency; /* in US */

    //进入该C state的回调函数

    int (*enter) (struct cpuidle_device *dev,

            struct cpuidle_driver *drv,

            int index);

    //cpu长时间不需要工作时（称作offline），可调用该回调函数

    int (*enter_dead) (struct cpuidle_device *dev, int index);

    /*

     * CPUs execute ->enter_s2idle with the local tick or entire timekeeping

     * suspended, so it must not re-enable interrupts at any point (even

     * temporarily) or attempt to change states of clock event devices.

     *

     * This callback may point to the same function as ->enter if all of

     * the above requirements are met by it.

     */

    //在执行enter_s2idle时，本地tick或整个timekeeping系统都会被suspend起来，

    //所以不能在任何点重新使能中断(即使是临时的)或尝试改变时钟事件设备的状态

    int (*enter_s2idle)(struct cpuidle_device *dev,

             struct cpuidle_driver *drv,

             int index);

};

struct cpuidle_state_usage {

    //这个cpu的这个C state是否已经使能，可取值如下，表示被谁禁用了

    //#define CPUIDLE_STATE_DISABLED_BY_USER        BIT(0)

    //#define CPUIDLE_STATE_DISABLED_BY_DRIVER    BIT(1)

    unsigned long long disable;

    //从系统启动到现在，这个cpu进入这个C state的次数

    unsigned long long usage;

    //从系统启动到现在，这个cpu在这个C state下的总耗时，单位ns

    u64 time_ns;

    //注意：下面above和below两个变量都是站在性能的角度考虑问题，忽视功耗

    // 也就是只考虑了"退出延迟"这个因素，没有考虑到"节约功耗"

    // 另外，这两个变量实际只在sysfs中导出节点时使用，内核没有用

    //记录系统从启动到现在，下面情况发生的总次数：

    //当前C state更加符合彼时系统的需求（站在性能的角度），

    //但是实际却偏偏选择了比自己睡眠深的C state

    unsigned long long above; /* Number of times it's been too deep */

    //记录系统从启动到现在，下面情况发生的总次数：

    //当前C state更加符合彼时系统的需求（站在性能的角度），

    //但是实际却偏偏选择了比自己睡眠浅的C state

    unsigned long long below; /* Number of times it's been too shallow */

    //从系统启动到现在，请求进入该C state被拒绝的总次数

    unsigned long long rejected; /* Number of times idle entry was rejected */

#ifdef CONFIG_SUSPEND

    unsigned long long s2idle_usage;

    unsigned long long s2idle_time; /* in US */

#endif

};

struct cpuidle_device {

    //标记这个device是否已经注册进系统

    unsigned int registered:1;

    //标记这个device是否已经使能

    unsigned int enabled:1;

    //标记当前cpu是不是正在执行polling操作

    //注意：为false的时候，表示当前cpu正在执行polling操作，详见poll_idle实现

    unsigned int poll_time_limit:1;

    //该device属于哪个cpu

    unsigned int cpu;

    //cpu进入idle前设置该值，退出idle时清零，详见cpuidle_enter实现

    //该值保存着：cpu睡眠前，距离当前时刻最近那个即将过期的高精度定时器

    ktime_t next_hrtimer;

    //记录该cpu上一次是在哪个C state上睡眠了

    int last_state_idx;

    //记录该cpu上一次在C state上停留的时间

    u64 last_residency_ns;

    //记录这个cpu支持的所有C state中，"最小滞留时间"的最小值

    //因为睡眠越深，"最小滞留时间"就越大，因此，该值一般就是

    //睡眠最浅的那个C state的"最小滞留时间"

    u64 poll_limit_ns;

    u64 forced_idle_latency_limit_ns;

    //记录该cpu在各个C state下的统计信息，最大记录10个状态

    struct cpuidle_state_usage states_usage[CPUIDLE_STATE_MAX];

    //sysfs文件系统相关

    struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];

    struct cpuidle_driver_kobj *kobj_driver;

    struct cpuidle_device_kobj *kobj_dev;

    //系统中的所有cpuidle_device都通过该结构挂在一个全局链表上

    struct list_head device_list;

    //"耦合状态"相关，详见后面分析

#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED

    cpumask_t coupled_cpus;

    struct cpuidle_coupled *coupled;

#endif

};

struct cpuidle_driver {

    //driver名称

    const char *name;

    //driver所属模块

    struct module *owner;

    /* used by the cpuidle framework to setup the broadcast timer */

    //一个标志，用于指示在该driver注册和注销时，是否需要设置一个broadcast timer，

    //有关broadcast timer后面再详细介绍

    unsigned int bctimer:1;

    /* states array must be ordered in decreasing power consumption */

    //该driver支持哪些C state

    //排的越靠前的C state，睡眠越浅，状态切换的代价越小，（即允许呆在该状态的最

    //小时间越短，本文称为"最小滞留时间"），退出时的延迟越短，允许的功耗越高

    struct cpuidle_state states[CPUIDLE_STATE_MAX];

    //该driver支持几个cpuidle等级

    int state_count;

    //和coupled cpu idle有关，后面会单独介绍

    //该driver支持哪些cpu

    int safe_state_index;

    /* the driver handles the cpus in cpumask */

    //这个driver控制着哪些cpu

    struct cpumask *cpumask;

    /* preferred governor to switch at register time */

    //这个driver所使用的governor

    const char *governor;

};

struct cpuidle_governor {

    //governor的名称

    char name[CPUIDLE_NAME_LEN];

    //系统中的所有governor通过该节点链接到全局链表cpuidle_governors中

    struct list_head governor_list;

    //一个数值，标记该governor的级别，数值越大优先级越高

    //Linux默认会选择系统中rating值最大的governor作为当前governor，除非用于主动修改

    unsigned int rating;

    //完成governor使能前准备工作，例如私有数据初始化等

    int (*enable) (struct cpuidle_driver *drv, struct cpuidle_device *dev);

    //完成governor禁用后的销毁工作，例如释放上面enable中申请的空间

    void (*disable) (struct cpuidle_driver *drv, struct cpuidle_device *dev);

    //选择一个C state

    //根据当前系统的运行状况，以及各个C state的特性，选择一个合适的C state

    //其中stop_tick用于返回，调用者根据该标记判断进入该C state前是否需要关闭tick

    int (*select) (struct cpuidle_driver *drv,

                    struct cpuidle_device *dev,

                    bool *stop_tick);

    //每次从C state返回时，kernel会调用governor的reflect接口，以便让governor有机会

    //考虑这一次state切换的结果，并更新一些统计信息，以便在下一次挑选出更加合适的C state

    //对menu而言，它的reflect接口会设置needs_update标志，并在下一次select时，更新状态，

    //为什么不在reflect中直接完成状态更新呢？这是因为reflect是在关中断的上下文，不适宜

    //做太多的工作，需要尽快完成工作并打开中断，处理中断服务程序，具体行为可参考后面的描述；

    void (*reflect) (struct cpuidle_device *dev, int index);

};

LIST_HEAD(cpuidle_detected_devices);

DEFINE_PER_CPU(struct cpuidle_device, cpuidle_dev);

/**

* cpuidle_register_device - registers a CPU's idle PM feature

* @dev: the cpu

*/

int cpuidle_register_device(struct cpuidle_device *dev)

{

    int ret = -EBUSY;

    if (!dev)

        return -EINVAL;

    mutex_lock(&cpuidle_lock);

    //1.如果这个device已经被注册过了，则退出

    if (dev->registered)

        goto out_unlock;

    //2.初始化device中的cpuidle_state_usage成员

    __cpuidle_device_init(dev);

    //3.将cpuidle_device挂入全局链表

    ret = __cpuidle_register_device(dev);

    if (ret)

        goto out_unlock;

    //4.在sysfs文件系统中的节点

    ret = cpuidle_add_sysfs(dev);

    if (ret)

        goto out_unregister;

    //5.使能cpuidle_device

    ret = cpuidle_enable_device(dev);

    if (ret)

        goto out_sysfs;

    //6.所谓的idle handler，其实就是一个内部的全局变量initialized，

    // 后面讲到cpuidle的核心功能时，会再说明

    cpuidle_install_idle_handler();

out_unlock:

    mutex_unlock(&cpuidle_lock);

    return ret;

out_sysfs:

    cpuidle_remove_sysfs(dev);

out_unregister:

    __cpuidle_unregister_device(dev);

    goto out_unlock;

}

static void __cpuidle_device_init(struct cpuidle_device *dev)

{

    memset(dev->states_usage, 0, sizeof(dev->states_usage));

    dev->last_residency_ns = 0;

    dev->next_hrtimer = 0;

}

/**

* __cpuidle_register_device - internal register function called before register

* and enable routines

* @dev: the cpu

*

* cpuidle_lock mutex must be held before this is called

*/

static int __cpuidle_register_device(struct cpuidle_device *dev)

{

    int ret;

    //1.获取device对应的driver，device是每个cpu对应一个

    struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);

    if (!try_module_get(drv->owner))

        return -EINVAL;

    //2.将dev赋值给percpu变量，并将其挂在全局链表上

    per_cpu(cpuidle_devices, dev->cpu) = dev;

    list_add(&dev->device_list, &cpuidle_detected_devices);

    //3.暂时不对coupled进行分析，函数始终返回0，接着设置registered标记

    ret = cpuidle_coupled_register_device(dev);

    if (ret)

        __cpuidle_unregister_device(dev);

    else

        dev->registered = 1;

    return ret;

}

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS

static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);

#else

static struct cpuidle_driver *cpuidle_curr_driver;

#endif

/**

* cpuidle_get_driver - return the driver tied to the current CPU.

*

* Returns a struct cpuidle_driver pointer, or NULL if no driver is registered.

*/

struct cpuidle_driver *cpuidle_get_driver(void)

{

    struct cpuidle_driver *drv;

    int cpu;

    //1.获取当前cpu

    cpu = get_cpu();

    //2.获取指定cpu的driver

    drv = __cpuidle_get_cpu_driver(cpu);

    put_cpu();

    return drv;

}

#define get_cpu()        ({ preempt_disable(); __smp_processor_id(); })

#define put_cpu()        preempt_enable()

/**

* cpuidle_get_cpu_driver - return the driver registered for a CPU.

* @dev: a valid pointer to a struct cpuidle_device

*

* Returns a struct cpuidle_driver pointer, or NULL if no driver is registered

* for the CPU associated with @dev.

*/

struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)

{

    if (!dev)

        return NULL;

    return __cpuidle_get_cpu_driver(dev->cpu);

}

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS

/**

* __cpuidle_get_cpu_driver - return the cpuidle driver tied to a CPU.

* @cpu: the CPU handled by the driver

*

* Returns a pointer to struct cpuidle_driver or NULL if no driver has been

* registered for @cpu.

*/

static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)

{

    return per_cpu(cpuidle_drivers, cpu);

}

#else

/**

* __cpuidle_get_cpu_driver - return the global cpuidle driver pointer.

* @cpu: ignored without the multiple driver support

*

* Return a pointer to a struct cpuidle_driver object or NULL if no driver was

* previously registered.

*/

static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)

{

    return cpuidle_curr_driver;

}

#endif

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS

/**

* __cpuidle_set_driver - set per CPU driver variables for the given driver.

* @drv: a valid pointer to a struct cpuidle_driver

*

* For each CPU in the driver's cpumask, unset the registered driver per CPU

* to @drv.

*

* Returns 0 on success, -EBUSY if the CPUs have driver(s) already.

*/

static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)

{

    int cpu;

    //1.遍历这个driver控制的所有cpu

    for_each_cpu(cpu, drv->cpumask) {

        //2.满足下面条件，表示这个cpu已经有一个可用的driver了，

        // 这时候设置就失败了，只要有一个设置失败了，就会回滚

        if (__cpuidle_get_cpu_driver(cpu)) {

            __cpuidle_unset_driver(drv);

            return -EBUSY;

        }

        //3.设置新的driver

        per_cpu(cpuidle_drivers, cpu) = drv;

    }

    return 0;

}

#else

/**

* __cpuidle_set_driver - assign the global cpuidle driver variable.

* @drv: pointer to a struct cpuidle_driver object

*

* Returns 0 on success, -EBUSY if the driver is already registered.

*/

static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)

{

    if (cpuidle_curr_driver)

        return -EBUSY;

    cpuidle_curr_driver = drv;

    return 0;

}

#endif

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS

/**

* __cpuidle_unset_driver - unset per CPU driver variables.

* @drv: a valid pointer to a struct cpuidle_driver

*

* For each CPU in the driver's CPU mask, unset the registered driver per CPU

* variable. If @drv is different from the registered driver, the corresponding

* variable is not cleared.

*/

static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)

{

    int cpu;

    //1.遍历所有的cpu

    for_each_cpu(cpu, drv->cpumask) {

        //2.找到要卸载的driver

        if (drv != __cpuidle_get_cpu_driver(cpu))

            continue;

        //3.设为NULL

        per_cpu(cpuidle_drivers, cpu) = NULL;

    }

}

#else

/**

* __cpuidle_unset_driver - unset the global cpuidle driver variable.

* @drv: a pointer to a struct cpuidle_driver

*

* Reset the global cpuidle variable to NULL. If @drv does not match the

* registered driver, do nothing.

*/

static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)

{

    if (drv == cpuidle_curr_driver)

        cpuidle_curr_driver = NULL;

}

#endif

/**

* __cpuidle_register_driver: register the driver

* @drv: a valid pointer to a struct cpuidle_driver

*

* Do some sanity checks, initialize the driver, assign the driver to the

* global cpuidle driver variable(s) and set up the broadcast timer if the

* cpuidle driver has some states that shut down the local timer.

*

* Returns 0 on success, a negative error code otherwise:

* * -EINVAL if the driver pointer is NULL or no idle states are available

* * -ENODEV if the cpuidle framework is disabled

* * -EBUSY if the driver is already assigned to the global variable(s)

*/

static int __cpuidle_register_driver(struct cpuidle_driver *drv)

{

    int ret;

    //1.要注册的driver里面要有可用的C state

    if (!drv || !drv->state_count)

        return -EINVAL;

    //2.coupled校验driver参数的有效性

    ret = cpuidle_coupled_state_verify(drv);

    if (ret)

        return ret;

    //3.判断cpuidle子系统是否已经被disable掉

    if (cpuidle_disabled())

        return -ENODEV;

    //4.完成数据结构中的一些初始化

    __cpuidle_driver_init(drv);

    //5.启用这个driver，所谓启用，实际就是将这个driver赋值给

    // percpu变量cpuidle_drivers或者全局变量cpuidle_curr_driver

    ret = __cpuidle_set_driver(drv);

    if (ret)

        return ret;

    //6.broadcast_timer相关

    // cpuidle state中flasg被打上CPUIDLE_FLAG_TIMER_STOP标签时，说明对应

    // 的CPU在进入idle state时，会停掉该CPU的local timer，此时kernel的时

    // 间子系统便不能再依赖本CPU的local timer，针对这种情况，设计者会提供一个

    // broadcast timer，该timer独立于所有CPU运行，并可以把tick广播到每个CPU

    // 上，因而不受idle state的影响。因此，如果cpuidle state具有STOP TIMER

    // 的特性的话，需要在driver注册时，提供下面回调函数接口，告知clock events

    // 模块，打开broadcast timer

    // drv->bctimer在__cpuidle_driver_ini中设置

    // 根据drv->bctimer的状态，调用cpuidle_setup_broadcast_timer接口，打开

    // 具体CPU上的broadcat timer

    // 其中on_each_cpu_mask可以在指定的CPU上运行函数

    if (drv->bctimer)

        on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,

                 (void *)1, 1);

    return 0;

}

/**

* __cpuidle_driver_init - initialize the driver's internal data

* @drv: a valid pointer to a struct cpuidle_driver

*/

static void __cpuidle_driver_init(struct cpuidle_driver *drv)

{

    int i;

    /*

     * Use all possible CPUs as the default, because if the kernel boots

     * with some CPUs offline and then we online one of them, the CPU

     * notifier has to know which driver to assign.

     */

    //1.如果这个driver没有指定cpu的话，则默认指定系统中所有可能的cpu

    if (!drv->cpumask)

        drv->cpumask = (struct cpumask *)cpu_possible_mask;

    //2.遍历每一个C state，完成相应的初始化

    for (i = 0; i < drv->state_count; i++) {

        struct cpuidle_state *s = &drv->states[i];

        /*

         * Look for the timer stop flag in the different states and if

         * it is found, indicate that the broadcast timer has to be set

         * up.

         */

        //2.1 如果设置了该标记位，则表示在进入该C state之前，

        // 必须开启broadcast timer，则置位bctimer，后面会用

        // 注意：只要这个driver中有一个state被打上该标记，都会设置bctimer

        if (s->flags & CPUIDLE_FLAG_TIMER_STOP)

            drv->bctimer = 1;

        /*

         * The core will use the target residency and exit latency

         * values in nanoseconds, but allow drivers to provide them in

         * microseconds too.

         */

        //2.2 "最小滞留时间"单位转化成ns

        if (s->target_residency > 0)

            s->target_residency_ns = s->target_residency * NSEC_PER_USEC;

        //2.2 退出延时的单位转化成ns

        if (s->exit_latency > 0)

            s->exit_latency_ns = s->exit_latency * NSEC_PER_USEC;

    }

}

/**

* cpuidle_setup_broadcast_timer - enable/disable the broadcast timer on a cpu

* @arg: a void pointer used to match the SMP cross call API

*

* If @arg is NULL broadcast is disabled otherwise enabled

*

* This function is executed per CPU by an SMP cross call. It's not

* supposed to be called directly.

*/

static void cpuidle_setup_broadcast_timer(void *arg)

{

    if (arg)

        tick_broadcast_enable();

    else

        tick_broadcast_disable();

}

/**

* on_each_cpu_mask(): Run a function on processors specified by

* cpumask, which may include the local processor.

* @mask: The set of cpus to run on (only runs on online subset).

* @func: The function to run. This must be fast and non-blocking.

* @info: An arbitrary pointer to pass to the function.

* @wait: If true, wait (atomically) until function has completed

* on other CPUs.

*

* If @wait is true, then returns once @func has returned.

*

* You must not call this function with disabled interrupts or from a

* hardware interrupt handler or from a bottom half handler. The

* exception is that it may be used during early boot while

* early_boot_irqs_disabled is set.

*/

void on_each_cpu_mask(

            const struct cpumask *mask,        //要在哪些cpu上运行

            smp_call_func_t func,                //要运行的函数

            void *info,                        //上面函数传入的参数

            bool wait)                            //是否需要等待所有cpu执行完毕

{

    int cpu = get_cpu();

    //1.在指定的cpu调用函数

    smp_call_function_many(mask, func, info, wait);

    //2.在local cpu上调用

    if (cpumask_test_cpu(cpu, mask)) {

        unsigned long flags;

        local_irq_save(flags);

        func(info);

        local_irq_restore(flags);

    }

    put_cpu();

}

/*

* Note we still need to test the mask even for UP

* because we actually can get an empty mask from

* code that on SMP might call us without the local

* CPU in the mask.

*/

void on_each_cpu_mask(

            const struct cpumask *mask,            //要在哪些cpu上执行

            smp_call_func_t func,                    //要执行的函数

            void *info,                            //上面函数中传入的参数

            bool wait)                                //是否需要等待上面函数在所有cpu上执行完毕

{

    unsigned long flags;

    if (cpumask_test_cpu(0, mask)) {

        local_irq_save(flags);

        func(info);

        local_irq_restore(flags);

    }

}

/**

* cpuidle_register_driver - registers a driver

* @drv: a pointer to a valid struct cpuidle_driver

*

* Register the driver under a lock to prevent concurrent attempts to

* [un]register the driver from occuring at the same time.

*

* Returns 0 on success, a negative error code (returned by

* __cpuidle_register_driver()) otherwise.

*/

int cpuidle_register_driver(struct cpuidle_driver *drv)

{

    struct cpuidle_governor *gov;

    int ret;

    spin_lock(&cpuidle_driver_lock);

    //1.注册驱动，并启用这个driver

    ret = __cpuidle_register_driver(drv);

    spin_unlock(&cpuidle_driver_lock);

    //2.如果上面在注册这个driver的时候，也成功的启用了这个driver，

    // 则需要将governor也切换到这个driver所使用的governor

    // 目前还没有发现内核中有对param_governor设置的地方，暂且认为他是全空的值

    if (!ret && !strlen(param_governor) && drv->governor &&

     (cpuidle_get_driver() == drv)) {

        mutex_lock(&cpuidle_lock);

        //2.1 根据governor的名称找到对应的governor

        // 并切换到这个新的governoe

        gov = cpuidle_find_governor(drv->governor);

        if (gov) {

            cpuidle_prev_governor = cpuidle_curr_governor;

            if (cpuidle_switch_governor(gov) < 0)

                cpuidle_prev_governor = NULL;

        }

        mutex_unlock(&cpuidle_lock);

    }

    return ret;

}

/**

* cpuidle_register: registers the driver and the cpu devices with the

* coupled_cpus passed as parameter. This function is used for all common

* initialization pattern there are in the arch specific drivers. The

* devices is globally defined in this file.

*

* @drv : a valid pointer to a struct cpuidle_driver

* @coupled_cpus: a cpumask for the coupled states

*

* Returns 0 on success, < 0 otherwise

*/

int cpuidle_register(struct cpuidle_driver *drv,

         const struct cpumask *const coupled_cpus)

{

    int ret, cpu;

    struct cpuidle_device *device;

    //1.注册driver，并启动这个driver和对应的governor

    ret = cpuidle_register_driver(drv);

    if (ret) {

        pr_err("failed to register cpuidle driver\n");

        return ret;

    }

    //2.遍历这个driver管理的cpu，初始他们的cpuidle_device结构

    // 并注册这些device

    for_each_cpu(cpu, drv->cpumask) {

        device = &per_cpu(cpuidle_dev, cpu);

        device->cpu = cpu;

#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED

        /*

         * On multiplatform for ARM, the coupled idle states could be

         * enabled in the kernel even if the cpuidle driver does not

         * use it. Note, coupled_cpus is a struct copy.

         */

        if (coupled_cpus)

            device->coupled_cpus = *coupled_cpus;

#endif

        //2.1 注册device

        ret = cpuidle_register_device(device);

        if (!ret)

            continue;

        pr_err("Failed to register cpuidle device for cpu%d\n", cpu);

        cpuidle_unregister(drv);

        break;

    }

    return ret;

}

LIST_HEAD(cpuidle_governors);

struct cpuidle_governor *cpuidle_curr_governor;

struct cpuidle_governor *cpuidle_prev_governor;

/**

* cpuidle_register_governor - registers a governor

* @gov: the governor

*/

int cpuidle_register_governor(struct cpuidle_governor *gov)

{

    int ret = -EEXIST;

    if (!gov || !gov->select)

        return -EINVAL;

    if (cpuidle_disabled())

        return -ENODEV;

    mutex_lock(&cpuidle_lock);

    //1.如果这个governor确实没有注册，则执行下面的注册动作

    if (cpuidle_find_governor(gov->name) == NULL) {

        ret = 0;

        //2.将这个governor添加进系统的链表中

        list_add_tail(&gov->governor_list, &cpuidle_governors);

        //3.如果系统中当前没有governor可用，或者新注册进来的governor的rating更高

        // 则切换到这个新注册的governor使用，（governor中的rating表示改governor

        // 的级别，内核默认会选择系统中rating值最大的governor作为当前governor）

        // strncasecmp表示不区分大小写比较两个字符串是否相等

        // 目前还没有发现内核中有对param_governor设置的地方，暂且认为他是全空的值

        if (!cpuidle_curr_governor ||

         !strncasecmp(param_governor, gov->name, CPUIDLE_NAME_LEN) ||

         (cpuidle_curr_governor->rating < gov->rating &&

         strncasecmp(param_governor, cpuidle_curr_governor->name, CPUIDLE_NAME_LEN)))

            cpuidle_switch_governor(gov);

    }

    mutex_unlock(&cpuidle_lock);

    return ret;

}

/**

* cpuidle_find_governor - finds a governor of the specified name

* @str: the name

*

* Must be called with cpuidle_lock acquired.

*/

struct cpuidle_governor *cpuidle_find_governor(const char *str)

{

    struct cpuidle_governor *gov;

    //遍历系统中所有governor，找到name一致的governor

    list_for_each_entry(gov, &cpuidle_governors, governor_list)

        if (!strncasecmp(str, gov->name, CPUIDLE_NAME_LEN))

            return gov;

    return NULL;

}

/**

* cpuidle_switch_governor - changes the governor

* @gov: the new target governor

* Must be called with cpuidle_lock acquired.

*/

int cpuidle_switch_governor(struct cpuidle_governor *gov)

{

    struct cpuidle_device *dev;

    if (!gov)

        return -EINVAL;

    //1.如果这个gov就是当前正在使用的governor，则退出

    if (gov == cpuidle_curr_governor)

        return 0;

    //2.在切换governor之前需要唤醒所有已经idle的cpu

    // 为啥捏，因为这些cpu是用old governor的判断标准决定是否需要进入idle，

    // 以及进入哪一个C state的，现在切换到new governor，游戏规则变了，这个

    // cpu是否需要进入idle，以及进入到哪一个C state都不确定，所以先唤醒，后

    // 面cpu根据自己的需要，重新走进入idle的流程

    cpuidle_uninstall_idle_handler();

    if (cpuidle_curr_governor) {

        //3.cpuidle_detected_devices全局链表上挂着系统中所有的device

        // 先将这些device全部disable掉

        list_for_each_entry(dev, &cpuidle_detected_devices, device_list)

            cpuidle_disable_device(dev);

    }

    //4.指定当前正在使用的governor

    cpuidle_curr_governor = gov;

    if (gov) {

        //5.重新使能系统中的所有device

        list_for_each_entry(dev, &cpuidle_detected_devices, device_list)

            cpuidle_enable_device(dev);

        //6.这里实际只是设置全局变量initialized

        // 之后上面已经被唤醒的cpu再根据自己的需要重新判断是否需要进入idle

        cpuidle_install_idle_handler();

        printk(KERN_INFO "cpuidle: using governor %s\n", gov->name);

    }

    return 0;

}

/**

* cpuidle_find_deepest_state - Find the deepest available idle state.

* @drv: cpuidle driver for the given CPU.

* @dev: cpuidle device for the given CPU.

* @latency_limit_ns: Idle state exit latency limit

*

* Return: the index of the deepest available idle state.

*/

int cpuidle_find_deepest_state(

            struct cpuidle_driver *drv,

            struct cpuidle_device *dev,

            u64 latency_limit_ns)                    //找出的C state退出延迟不能超过这个值

{

    return find_deepest_state(drv, dev, latency_limit_ns, 0, false);

}

static int find_deepest_state(

            struct cpuidle_driver *drv,

            struct cpuidle_device *dev,

            u64 max_latency_ns,                    //找到的C state，退出延迟最大不能超过该值

            unsigned int forbidden_flags,            //找到的C state，不能带有该标记位

            bool s2idle)                //找到的C state，是否一定要包含enter_s2idle回调函数

{

    u64 latency_req = 0;

    int i, ret = 0;

    //1.遍历drv中所有的C state

    // 注意：

    // a) 从前向后遍历，也就是从睡眠最浅的开始遍历

    // b) 这里是从1开始遍历，因为0是normal state，直接跳过

    for (i = 1; i < drv->state_count; i++) {

        struct cpuidle_state *s = &drv->states[i];

        //2.过滤掉不满足条件的C state

        if (dev->states_usage[i].disable ||

         s->exit_latency_ns <= latency_req ||            //退出延迟越大，睡得越深

         s->exit_latency_ns > max_latency_ns ||        //退出延迟最大不能超过该值

         (s->flags & forbidden_flags) ||                //找到的C state，不能带有该标记位

         (s2idle && !s->enter_s2idle))    //找到的C state，是否一定要包含enter_s2idle回调函数

            continue;

        //3.代码走到这里，表示上面所有的条件都满足了，并且睡眠是最深的

        // 保留满足条件的C state的退出延迟，并记录C state等级

        latency_req = s->exit_latency_ns;

        ret = i;

    }

    //4.返回对应的idle等级的索引

    return ret;

}

/**

* cpuidle_select - ask the cpuidle framework to choose an idle state

*

* @drv: the cpuidle driver

* @dev: the cpuidle device

* @stop_tick: indication on whether or not to stop the tick

*

* Returns the index of the idle state. The return value must not be negative.

*

* The memory location pointed to by @stop_tick is expected to be written the

* 'false' boolean value if the scheduler tick should not be stopped before

* entering the returned state.

*/

int cpuidle_select(

            struct cpuidle_driver *drv,

            struct cpuidle_device *dev,

            bool *stop_tick)                            //是否需要停止tick

{

    //依据什么标准去选择C state，由governor自己决定

    return cpuidle_curr_governor->select(drv, dev, stop_tick);

}

static int call_cpuidle(

            struct cpuidle_driver *drv,

            struct cpuidle_device *dev,

            int next_state)                    //要进入的C state

{

    /*

     * The idle task must be scheduled, it is pointless to go to idle, just

     * update no idle residency and return.

     */

    //1.判断是否有其他线程需要调度

    // 如果系统中还有其他线程等待调度，说明系统现在处于忙状态，不能进入idle

    // 注意：由上一章对idle线程的分析可知，只有在idle中才会调用这个函数的，

    // 所以此时的current是idle线程

    if (current_clr_polling_and_test()) {

        dev->last_residency_ns = 0;

        local_irq_enable();

        return -EBUSY;

    }

    /*

     * Enter the idle state previously returned by the governor decision.

     * This function will block until an interrupt occurs and will take

     * care of re-enabling the local interrupts

     */

    //2.进入指定级别的C state

    return cpuidle_enter(drv, dev, next_state);

}

/**

* cpuidle_enter - enter into the specified idle state

*

* @drv: the cpuidle driver tied with the cpu

* @dev: the cpuidle device

* @index: the index in the idle state table

*

* Returns the index in the idle state, < 0 in case of error.

* The error code depends on the backend driver

*/

int cpuidle_enter(

            struct cpuidle_driver *drv,

            struct cpuidle_device *dev,

            int index)                            //要进入的C state

{

    int ret = 0;

    /*

     * Store the next hrtimer, which becomes either next tick or the next

     * timer event, whatever expires first. Additionally, to make this data

     * useful for consumers outside cpuidle, we rely on that the governor's

     * ->select() callback have decided, whether to stop the tick or not.

     */

    //1.睡眠前，记录下一个即将触发的高精度定时器

    WRITE_ONCE(dev->next_hrtimer, tick_nohz_get_next_hrtimer());

    //2.进入指定级别的idle

    // coupled为"耦合状态"相关，这里我们先不分析，直接进入cpuidle_enter_state

    if (cpuidle_state_is_coupled(drv, index))

        ret = cpuidle_enter_state_coupled(dev, drv, index);

    else

        ret = cpuidle_enter_state(dev, drv, index);

    //3.结束睡眠后，将该值清零

    WRITE_ONCE(dev->next_hrtimer, 0);

    return ret;

}

/**

* cpuidle_enter_state - enter the state and update stats

* @dev: cpuidle device for this cpu

* @drv: cpuidle driver for this cpu

* @index: index into the states table in @drv of the state to enter

*/

int cpuidle_enter_state(

            struct cpuidle_device *dev,

            struct cpuidle_driver *drv,

            int index)                        //要进入的C state

{

    int entered_state;

    //1.根据索引找到对于的idle state

    struct cpuidle_state *target_state = &drv->states[index];

    //2.在该C state下，local timer会不会被停掉，

    // 如果被停掉的话则需要使能broascast机制

    bool broadcast = !!(target_state->flags & CPUIDLE_FLAG_TIMER_STOP);

    ktime_t time_start, time_end;

    /*

     * Tell the time framework to switch to a broadcast timer because our

     * local timer will be shut down. If a local timer is used from another

     * CPU as a broadcast timer, this call may fail if it is not available.

     */

    //3.考虑到broadcast，重新选择C state

    // 由上面的注释的含义，这里是告诉时间子系统：因为local cpu的timer即将关闭，

    // 下面要进入broadcast模式了，如果这个cpu的定时器需要作为其他cpu的broadcast

    // 的timer时候，下面的调用将会失败

    if (broadcast && tick_broadcast_enter()) {

        //3.1 下面重新找出一个C state，同时满足下面条件、睡眠最深的C state

        // a) 退出延迟小于target_state->exit_latency_ns

        // b) 不能带有CPUIDLE_FLAG_TIMER_STOP标记

        index = find_deepest_state(drv, dev, target_state->exit_latency_ns,

                     CPUIDLE_FLAG_TIMER_STOP, false);

        if (index < 0) {

            //3.2 没有找到合适的C state，调用default_idle_call进入idle

            // arm64实际就是执行wfi指令进入睡眠，trace标记的idx为1

            default_idle_call();

            return -EBUSY;

        }

        target_state = &drv->states[index];

        broadcast = false;

    }

    //4.leave_mm只有在x86的一些平台中使能，表示在进idle之前刷TLB

    if (target_state->flags & CPUIDLE_FLAG_TLB_FLUSHED)

        leave_mm(dev->cpu);

    /* Take note of the planned idle state. */

    //5.在rq结构中记录当前cpu所处的idle_state等级

    sched_idle_set_state(target_state);

    //6.打印trace相关

    trace_cpu_idle(index, dev->cpu);

    //7.记录进入idle的时间戳，用于后面统计在idle中呆了多长时间

    time_start = ns_to_ktime(local_clock());

    //8.通知rcu子系统，后面分析

    stop_critical_timings();

    if (!(target_state->flags & CPUIDLE_FLAG_RCU_IDLE))

        rcu_idle_enter();

    //8.调用下面函数进入idle状态，直到从idle状态中退出时该函数才会返回

    // 返回值表示刚刚是从那个状态中退出的

    entered_state = target_state->enter(dev, drv, index);

    //9.代码走到这里表示已经从idle中退出了

    if (!(target_state->flags & CPUIDLE_FLAG_RCU_IDLE))

        rcu_idle_exit();

    start_critical_timings();

    sched_clock_idle_wakeup_event();

    //10.记录退出idle的时间戳，用于统计在这个C state中呆了多长时间

    time_end = ns_to_ktime(local_clock());

    trace_cpu_idle(PWR_EVENT_EXIT, dev->cpu);

    /* The cpu is no longer idle or about to enter idle. */

    //11.在rq结构中记录当前cpu所处的idle_state等级，NULL表示已经退出idle等级了

    sched_idle_set_state(NULL);

    //12.下面这些广播相关的目前看不懂，以后再分析吧

    if (broadcast) {

        if (WARN_ON_ONCE(!irqs_disabled()))

            local_irq_disable();

        tick_broadcast_exit();

    }

    if (!cpuidle_state_is_coupled(drv, index))

        local_irq_enable();

    //10.上面返回的entered_state表示刚刚是从哪一个C state中退出的，下面需要做一些统计的工作

    if (entered_state >= 0) {

        //10.1 从该状态退出所需的延时

        s64 diff, delay = drv->states[entered_state].exit_latency_ns;

        int i;

        /*

         * Update cpuidle counters

         * This can be moved to within driver enter routine,

         * but that results in multiple copies of same code.

         */

        //10.2 这个时间差表示在这个idle state中一共呆了多长时间

        diff = ktime_sub(time_end, time_start);

        //10.3 统计信息

        dev->last_residency_ns = diff;

        dev->states_usage[entered_state].time_ns += diff;

        dev->states_usage[entered_state].usage++;

        //10.3 target_residency_ns表示该C state的最小滞留时间，而diff表示实际滞留时间

        if (diff < drv->states[entered_state].target_residency_ns) {

            //10.4 满足该条件表示在该C state下的实际滞留时间，小于该C state的最小滞留时间

            // 满足该条件是用于C state挑选不合理造成，也就是选择了深睡眠，但是实际睡眠不够

            // 也就是说：站在"最小滞留时间"的角度，idx比entered_state小的所有C state

            // 都能满足要求，（idx小的还能获取到最佳的性能，因为退出延时短啊，这里忽视和"功

            // 耗"，仅从"性能"角度考虑）

            // 需要注意的是，索引值越小，睡眠越浅，idle等级越高，功耗越低，

            // 相应的唤醒的延迟就越大，也就是说功耗按照降序排列

            for (i = entered_state - 1; i >= 0; i--) {

                if (dev->states_usage[i].disable)

                    continue;

                /* Shallower states are enabled, so update. */

                //10.5 above记录系统从启动到现在，选择"比当前C state睡眠深"的总次数

                dev->states_usage[entered_state].above++;

                break;

            }

        } else if (diff > delay) {

            //10.5 满足该条件表示在该C state下的实际滞留时间diff，大于该C state的退出延迟

            // 满足该条件是正常条件

            for (i = entered_state + 1; i < drv->state_count; i++) {

                if (dev->states_usage[i].disable)

                    continue;

                /*

                 * Update if a deeper state would have been a

                 * better match for the observed idle duration.

                 */

                //10.6 注意，上面在记录diff的时候，是包含在idle中的退出延迟的

                // 两者的差表示在这个C state中"实际睡眠时间"，

                // 如果这个"实际睡眠时间"大于"最小滞留时间"（因为是向上遍历的），

                // 则说明有更深的C state符合当前系统的需求（站在更加节能的角度），

                // 但是却偏偏选择了比自己睡眠浅的C state的次数

                if (diff - delay >= drv->states[i].target_residency_ns)

                    dev->states_usage[entered_state].below++;

                break;

            }

        }

    } else {

        //11.代码走到这里，说明上次在请求进入index这个C state失败了，

        // last_residency_ns表示上一次在睡眠状态睡了多长时间

        // rejected表示：请求进入该idx对应的idle等级被拒绝的次数

        dev->last_residency_ns = 0;

        dev->states_usage[index].rejected++;

    }

    //12.返回进入的idle等级

    return entered_state;

}

/**

* sched_idle_set_state - Record idle state for the current CPU.

* @idle_state: State to record.

*/

void sched_idle_set_state(struct cpuidle_state *idle_state)

{

    idle_set_state(this_rq(), idle_state);

}

static inline void idle_set_state(struct rq *rq,

                 struct cpuidle_state *idle_state)

{

    rq->idle_state = idle_state;

}

/**

* cpuidle_play_dead - cpu off-lining

*

* Returns in case of an error or no driver

*/

int cpuidle_play_dead(void)

{

    struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices);

    struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);

    int i;

    if (!drv)

        return -ENODEV;

    /* Find lowest-power state that supports long-term idle */

    //1.注意：这里是从idle等级最深的哪一级开始向前遍历，

    // 也就是优先选择功耗最小的idle等级

    for (i = drv->state_count - 1; i >= 0; i--)

        if (drv->states[i].enter_dead)

            return drv->states[i].enter_dead(dev, i);

    return -ENODEV;

}

static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);

static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);

static DEVICE_ATTR(current_governor, 0644, show_current_governor, store_current_governor);

static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);

static ssize_t show_available_governors(

            struct device *dev,

            struct device_attribute *attr,

            char *buf)

{

    ssize_t i = 0;

    struct cpuidle_governor *tmp;

    mutex_lock(&cpuidle_lock);

    //1.系统中的所有governor全部挂在这个cpuidle_governors全局链表上

    list_for_each_entry(tmp, &cpuidle_governors, governor_list) {

        //2.这里的i用于控制数据量太大，可以学习一下

        if (i >= (ssize_t) (PAGE_SIZE - (CPUIDLE_NAME_LEN + 2)))

            goto out;

        //3.打印出governor的名称

        i += scnprintf(&buf[i], CPUIDLE_NAME_LEN + 1, "%s ", tmp->name);

    }

out:

    i+= sprintf(&buf[i], "\n");

    mutex_unlock(&cpuidle_lock);

    return i;

}

static ssize_t show_current_driver(

            struct device *dev,

            struct device_attribute *attr,

            char *buf)

{

    ssize_t ret;

    struct cpuidle_driver *drv;

    spin_lock(&cpuidle_driver_lock);

    //1.获取当前cpu正在使用的driver，打印出name

    drv = cpuidle_get_driver();

    if (drv)

        ret = sprintf(buf, "%s\n", drv->name);

    else

        ret = sprintf(buf, "none\n");

    spin_unlock(&cpuidle_driver_lock);

    return ret;

}

static ssize_t show_current_governor(struct device *dev,

                 struct device_attribute *attr,

                 char *buf)

{

    ssize_t ret;

    mutex_lock(&cpuidle_lock);

    //1.系统中正在使用的governor，保存在全局变量cpuidle_curr_governor中

    if (cpuidle_curr_governor)

        ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);

    else

        ret = sprintf(buf, "none\n");

    mutex_unlock(&cpuidle_lock);

    return ret;

}

static ssize_t store_current_governor(struct device *dev,

                 struct device_attribute *attr,

                 const char *buf, size_t count)

{

    char gov_name[CPUIDLE_NAME_LEN + 1];

    int ret;

    struct cpuidle_governor *gov;

    ret = sscanf(buf, "%" __stringify(CPUIDLE_NAME_LEN) "s", gov_name);

    if (ret != 1)

        return -EINVAL;

    mutex_lock(&cpuidle_lock);

    ret = -EINVAL;

    //找到用户指定的governor，并切换使能

    list_for_each_entry(gov, &cpuidle_governors, governor_list) {

        if (!strncmp(gov->name, gov_name, CPUIDLE_NAME_LEN)) {

            ret = cpuidle_switch_governor(gov);

            break;

        }

    }

    mutex_unlock(&cpuidle_lock);

    return ret ? ret : count;

}

static ssize_t show_current_governor(struct device *dev,

                 struct device_attribute *attr,

                 char *buf)

{

    ssize_t ret;

    mutex_lock(&cpuidle_lock);

    //正在使用的governor保存在全局变量cpuidle_curr_governor中

    if (cpuidle_curr_governor)

        ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);

    else

        ret = sprintf(buf, "none\n");

    mutex_unlock(&cpuidle_lock);

    return ret;

}

/**

* cpuidle_add_sysfs - creates a sysfs instance for the target device

* @dev: the target device

*/

int cpuidle_add_sysfs(struct cpuidle_device *dev)

{

    struct cpuidle_device_kobj *kdev;

    struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);

    int error;

    /*

     * Return if cpu_device is not setup for this CPU.

     *

     * This could happen if the arch did not set up cpu_device

     * since this CPU is not in cpu_present mask and the

     * driver did not send a correct CPU mask during registration.

     * Without this check we would end up passing bogus

     * value for &cpu_dev->kobj in kobject_init_and_add()

     */

    if (!cpu_dev)

        return -ENODEV;

    kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);

    if (!kdev)

        return -ENOMEM;

    kdev->dev = dev;

    dev->kobj_dev = kdev;

    init_completion(&kdev->kobj_unregister);

    error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,

                 "cpuidle");

    if (error) {

        kobject_put(&kdev->kobj);

        return error;

    }

    kobject_uevent(&kdev->kobj, KOBJ_ADD);

    return 0;

}

/**

* cpuidle_add_device_sysfs - adds device specific sysfs attributes

* @device: the target device

*/

int cpuidle_add_device_sysfs(struct cpuidle_device *device)

{

    int ret;

    //1.创建/sys/devices/system/cpu/cpuN/cpuidle/stateX下的节点

    ret = cpuidle_add_state_sysfs(device);

    if (ret)

        return ret;

    //2.创建/sys/devices/system/cpu/cpuN/cpuidle/driver下的节点

    ret = cpuidle_add_driver_sysfs(device);

    if (ret)

        cpuidle_remove_state_sysfs(device);

    return ret;

}

/**

* cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes

* @device: the target device

*/

static int cpuidle_add_state_sysfs(struct cpuidle_device *device)

{

    int i, ret = -ENOMEM;

    struct cpuidle_state_kobj *kobj;

    struct cpuidle_device_kobj *kdev = device->kobj_dev;

    struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);

    /* state statistics */

    for (i = 0; i < drv->state_count; i++) {

        kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);

        if (!kobj) {

            ret = -ENOMEM;

            goto error_state;

        }

        kobj->state = &drv->states[i];

        kobj->state_usage = &device->states_usage[i];

        kobj->device = device;

        init_completion(&kobj->kobj_unregister);

        //创建stateN路径

        ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,

                     &kdev->kobj, "state%d", i);

        if (ret) {

            kobject_put(&kobj->kobj);

            goto error_state;

        }

        //在路径中创建节点

        cpuidle_add_s2idle_attr_group(kobj);

        kobject_uevent(&kobj->kobj, KOBJ_ADD);

        device->kobjs[i] = kobj;

    }

    return 0;

error_state:

    for (i = i - 1; i >= 0; i--)

        cpuidle_free_state_kobj(device, i);

    return ret;

}

static struct kobj_type ktype_state_cpuidle = {

    .sysfs_ops = &cpuidle_state_sysfs_ops,

    .default_attrs = cpuidle_state_default_attrs,

    .release = cpuidle_state_sysfs_release,

};

define_one_state_ro(name, show_state_name);

define_one_state_ro(desc, show_state_desc);

define_one_state_ro(latency, show_state_exit_latency);

define_one_state_ro(residency, show_state_target_residency);

define_one_state_ro(power, show_state_power_usage);

define_one_state_ro(usage, show_state_usage);

define_one_state_ro(rejected, show_state_rejected);

define_one_state_ro(time, show_state_time);

define_one_state_rw(disable, show_state_disable, store_state_disable);

define_one_state_ro(above, show_state_above);

define_one_state_ro(below, show_state_below);

define_one_state_ro(default_status, show_state_default_status);

static struct attribute *cpuidle_state_default_attrs[] = {

    &attr_name.attr,

    &attr_desc.attr,

    &attr_latency.attr,

    &attr_residency.attr,

    &attr_power.attr,

    &attr_usage.attr,

    &attr_rejected.attr,

    &attr_time.attr,

    &attr_disable.attr,

    &attr_above.attr,

    &attr_below.attr,

    &attr_default_status.attr,

    NULL

};

define_show_state_ull_function(above)

define_one_state_ro(above, show_state_above);

#define define_show_state_ull_function(_name) \

static ssize_t show_state_##_name(struct cpuidle_state *state, \

                 struct cpuidle_state_usage *state_usage, \

                 char *buf)                \

{ \

    return sprintf(buf, "%llu\n", state_usage->_name);\

}

define_one_state_ro(below, show_state_below);

define_show_state_ull_function(below)

define_show_state_str_function(name)

define_one_state_ro(name, show_state_name);

#define define_show_state_str_function(_name) \

static ssize_t show_state_##_name(struct cpuidle_state *state, \

                 struct cpuidle_state_usage *state_usage, \

                 char *buf)                \

{ \

    if (state->_name[0] == '\0')\

        return sprintf(buf, "<null>\n");\

    return sprintf(buf, "%s\n", state->_name);\

}

define_show_state_str_function(desc)

define_one_state_ro(desc, show_state_desc);

define_one_state_rw(disable, show_state_disable, store_state_disable);

static ssize_t show_state_disable(struct cpuidle_state *state,

                 struct cpuidle_state_usage *state_usage,

                 char *buf)

{

    return sprintf(buf, "%llu\n",

         state_usage->disable & CPUIDLE_STATE_DISABLED_BY_USER);

}

static ssize_t store_state_disable(struct cpuidle_state *state,

                 struct cpuidle_state_usage *state_usage,

                 const char *buf, size_t size)

{

    unsigned int value;

    int err;

    //权限校验

    if (!capable(CAP_SYS_ADMIN))

        return -EPERM;

    err = kstrtouint(buf, 0, &value);

    if (err)

        return err;

    //标记被用户空间禁用了

    if (value)

        state_usage->disable |= CPUIDLE_STATE_DISABLED_BY_USER;

    else

        state_usage->disable &= ~CPUIDLE_STATE_DISABLED_BY_USER;

    return size;

}

define_show_state_time_function(exit_latency)

define_one_state_ro(latency, show_state_exit_latency);

#define define_show_state_time_function(_name) \

static ssize_t show_state_##_name(struct cpuidle_state *state, \

                 struct cpuidle_state_usage *state_usage, \

                 char *buf) \

{ \

    return sprintf(buf, "%llu\n", ktime_to_us(state->_name##_ns)); \

}

define_show_state_time_function(target_residency)

define_one_state_ro(residency, show_state_target_residency);

define_one_state_ro(power, show_state_power_usage);

define_show_state_function(power_usage)

#define define_show_state_function(_name) \

static ssize_t show_state_##_name(struct cpuidle_state *state, \

             struct cpuidle_state_usage *state_usage, char *buf) \

{ \

    return sprintf(buf, "%u\n", state->_name);\

}

define_one_state_ro(time, show_state_time);

static ssize_t show_state_time(struct cpuidle_state *state,

             struct cpuidle_state_usage *state_usage,

             char *buf)

{

    return sprintf(buf, "%llu\n", ktime_to_us(state_usage->time_ns));

}

define_one_state_ro(usage, show_state_usage);

define_show_state_ull_function(usage)

/**

* cpuidle_add_driver_sysfs - adds the driver name sysfs attribute

* @dev: the target device

*/

static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)

{

    struct cpuidle_driver_kobj *kdrv;

    struct cpuidle_device_kobj *kdev = dev->kobj_dev;

    struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);

    int ret;

    kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);

    if (!kdrv)

        return -ENOMEM;

    kdrv->drv = drv;

    init_completion(&kdrv->kobj_unregister);

    //创建driver目录

    ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,

                 &kdev->kobj, "driver");

    if (ret) {

        kobject_put(&kdrv->kobj);

        return ret;

    }

    kobject_uevent(&kdrv->kobj, KOBJ_ADD);

    dev->kobj_driver = kdrv;

    return ret;

}

static struct kobj_type ktype_driver_cpuidle = {

    .sysfs_ops = &cpuidle_driver_sysfs_ops,

    .default_attrs = cpuidle_driver_default_attrs,

    .release = cpuidle_driver_sysfs_release,

};

static struct attribute *cpuidle_driver_default_attrs[] = {

    &attr_driver_name.attr,

    NULL

};

define_one_driver_ro(name, show_driver_name);

static ssize_t show_driver_name(struct cpuidle_driver *drv, char *buf)

{

    ssize_t ret;

    spin_lock(&cpuidle_driver_lock);

    ret = sprintf(buf, "%s\n", drv ? drv->name : "none");

    spin_unlock(&cpuidle_driver_lock);

    return ret;

}

/**

* cpuidle_enable_device - enables idle PM for a CPU

* @dev: the CPU

*

* This function must be called between cpuidle_pause_and_lock and

* cpuidle_resume_and_unlock when used externally.

*/

int cpuidle_enable_device(struct cpuidle_device *dev)

{

    int ret;

    struct cpuidle_driver *drv;

    if (!dev)

        return -EINVAL;

    //1.已经使能则退出

    if (dev->enabled)

        return 0;

    //2.未指定governor则退出

    if (!cpuidle_curr_governor)

        return -EIO;

    //3.获取device对应的driver

    drv = cpuidle_get_cpu_driver(dev);

    if (!drv)

        return -EIO;

    if (!dev->registered)

        return -EINVAL;

    //4.在sysfs文件系统中创建节点

    // 创建/sys/devices/system/cpu/cpuN/cpuidle/stateX下的节点

    ret = cpuidle_add_device_sysfs(dev);

    if (ret)

        return ret;

    //5.调用governor的enable回调函数，一般完成私有数据的初始化

    if (cpuidle_curr_governor->enable) {

        ret = cpuidle_curr_governor->enable(drv, dev);

        if (ret)

            goto fail_sysfs;

    }

    smp_wmb();

    dev->enabled = 1;

    //6.全局变量，记录系统中共有多少个cpu受cpuidle子系统管控

    enabled_devices++;

    return 0;

fail_sysfs:

    cpuidle_remove_device_sysfs(dev);

    return ret;

}

/**

* cpuidle_disable_device - disables idle PM for a CPU

* @dev: the CPU

*

* This function must be called between cpuidle_pause_and_lock and

* cpuidle_resume_and_unlock when used externally.

*/

void cpuidle_disable_device(struct cpuidle_device *dev)

{

    struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);

    //1.已经被disable，则退出

    if (!dev || !dev->enabled)

        return;

    if (!drv || !cpuidle_curr_governor)

        return;

    dev->enabled = 0;

    //2.完成gonvernor私有数据的销毁工作，例如申请的内存的是释放等

    if (cpuidle_curr_governor->disable)

        cpuidle_curr_governor->disable(drv, dev);

    //3.移除sysfs中的节点信息

    // 移除/sys/devices/system/cpu/cpuN/cpuidle/stateX下的节点

    cpuidle_remove_device_sysfs(dev);

    //4.全局变量，记录系统中共有多少个cpu受cpuidle子系统管控

    enabled_devices--;

}

/* Currently used in suspend/resume path to suspend cpuidle */

void cpuidle_pause(void)

{

    mutex_lock(&cpuidle_lock);

    cpuidle_uninstall_idle_handler();

    mutex_unlock(&cpuidle_lock);

}

/**

* cpuidle_uninstall_idle_handler - uninstalls the cpuidle idle loop handler

*/

void cpuidle_uninstall_idle_handler(void)

{

    //如果enabled_devices不为0，则说明cpuidle子系统此时正控制着某些cpu，

    //当然也可能存在一些cpu已经被cpuidle子系统搞睡眠了，因为cpuidle子系

    //统马上就要狗带了，在狗带之前就需要唤醒所有已经idle的cpu

    if (enabled_devices) {

        initialized = 0;

        wake_up_all_idle_cpus();

    }

    /*

     * Make sure external observers (such as the scheduler)

     * are done looking at pointed idle states.

     */

    synchronize_rcu();

}

/**

* wake_up_all_idle_cpus - break all cpus out of idle

* wake_up_all_idle_cpus try to break all cpus which is in idle state even

* including idle polling cpus, for non-idle cpus, we will do nothing

* for them.

*/

void wake_up_all_idle_cpus(void)

{

    int cpu;

    preempt_disable();

    //1.遍历所有online的cpu

    for_each_online_cpu(cpu) {

        //2.当前cpu肯定不是idle的，跳过

        if (cpu == smp_processor_id())

            continue;

        //3.执行唤醒动作

        wake_up_if_idle(cpu);

    }

    preempt_enable();

}