全部博文（396）
分类： 嵌入式
2019-07-11 21:33:35
一、前言
和洋葱一样，软件也是有层次的，内核往往需要对形形色色的某类型的驱动进行抽象，屏蔽掉其具体的特质，获取该类驱动共同的逻辑，而又根据这些逻辑撰写该类驱动的抽象层。嵌入式系统总是会提供timer的硬件block，软件需要对timer硬件提供的功能进行抽象：linux kernel将timer类型的硬件抽象成两个组件，一是free running的counter，另外一个是指定的counter值上产生中断的能力。本文主要描述第一个组件，在内核中被称作clock source。
二、什么是clocksource？
1、基础概念
我们先回到一个基础的问题上来：什么是时间？时间其实可以抽象成一条直线，没有起点，也没有终点（所以我们叫它timeline）。我们可以以一定的刻度来划分这条直线，例如以1秒的间隔。这样还不行，还需要一个参考点，例如在耶稣诞辰的时间定位0点。OK，大家终于可以时间的定义上统一了，例如我可以和wowo同学约定在68365287秒的时间一起去吃饭，恩，看起来不是那么方便，还是可以对以秒计算的时间进行grouping，因此有了年、月、日、时、分这些概念。
对于内核，它的timeline是怎样的呢？首先时间不是一条直线，因为硬件的计数不可能是无限制的，我们总是使用有限的bit数目的硬件来计数，因此，对于内核（更准确的说对于计算机系统），其时间更像是一个不断重复的线段，最终也是形成一个没有起点也没有终点的timeline。此外，和人不同的是，机器不喜欢grouping，它们更喜欢用一个绝对的数字来标识当前的时间（当然，机器是为人服务的，最终会在人机界面的部分转换成年、月、日、时、分、秒这样的格式）。
2、内核数据结构
所谓clock source就是用来抽象一个在指定输入频率的clock下工作的一个counter。输入频率可以确定以什么样的精度来划分timeline（假设输入counter的频率是1GHz，那么一个cycle就是1ns，也就是说timeline是用1ns来划分的，最大的精度就是1ns），counter的bit数确定了组成timeline上的“线段”的长度。内核中的struct clocksource 定义如下：
struct clocksource {
cycle_t (*read)(struct clocksource *cs);－－－－－－－－－－－－－－－－－（1）
cycle_t cycle_last;
cycle_t mask;
u32 mult;
u32 shift;
u64 max_idle_ns;
u32 maxadj;const char *name;－－－－－－－－－－－－－－－－－－－－－－－－－－（2）
struct list_head list;
int rating;
int (*enable)(struct clocksource *cs);
void (*disable)(struct clocksource *cs);
unsigned long flags;
void (*suspend)(struct clocksource *cs);
void (*resume)(struct clocksource *cs);#ifdef CONFIG_CLOCKSOURCE_WATCHDOG－－－－－－－－－－－－－－－（3）
struct list_head wd_list;
cycle_t cs_last;
cycle_t wd_last;
#endif
struct module *owner;
} ____cacheline_aligned;
struct clocksource的成员分成3组，我们分别介绍：
（1）这部分的代码是和计时有关的，kernel会频繁的访问这些数据结构，因此最好把它们放到一个cacheline中，struct clocksource这个数据结构有cacheline aligned的属性，任何定义的变量都是对齐到cacheline的，而这些计时相关的成员被放到clocksource数据结构的前面就是为了提高cache hit。一旦访问了read成员，随后的几个成员也就被加载到cacheline中，从而提高的性能。对于clock source抽象的counter而言，其counter value都是针对clock计数的，具体一个clock有多少个纳秒是和输入频率相关的。
通过read获取当前的counter value，这个计数值是基于cycle的。不过，对于用户和其他driver而言，cycle数据是没有意义的，最好统一使用纳秒这样的单位，因此在struct clocksource中就有了mult和shift这两个成员了。我们先看看如何将A个cycles数转换成纳秒，具体公式如下：
转换后的纳秒数目 = (A / F) x NSEC_PER_SEC
这样的转换公式需要除法，绝大部分的CPU都有乘法器，但是有些处理器是不支持除法，当然，对于不支持硬件除法器的CPU上，toolchain中会提供除法的代码库，虽然我们无法将除法操作的代码编译成一条除法的汇编指令，但是也可以用代码库中的其他运算来取代除法。这样做的坏处就是性能会受影响（想到这里的代码会被内核其他模块反复调用，你是不是很心疼那些CPU的MIPS？）。肿么办？要知道，linux kernel的目标是星辰大海，它是打算服务多种CPU体系结构，并且要有优秀性能表现的。把1/F变成浮点数，这样就可以去掉除法了，但是又引入了浮点运算，kernel是不建议使用浮点运算的（为何如此建议，你有考虑过吗？请把答案寄到蜗窝科技大厦，可以赢取内核之旅门票一张，呵呵～～～）。解决方案很简单，使用移位操作，具体可以参考clocksource_cyc2ns的操作：
static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)
{
return ((u64) cycles * mult) >> shift;
}
也就是说，通过clock source的read函数获取了cycle数目，乘以mult这个因子然后右移shift个bit就可以得到纳秒数。这样的操作虽然性能比较好，但是损失了精度，还是那句话，设计是平衡的艺术，看你自己的取舍。 其他的成员我们会在后面的代码分析中给出解释。
（2）这段的代码访问没有那么频繁，主要是和一些系统操作相关。例如list成员。系统将所有已经注册clocksource挂在一个链表中，list就是挂入链表的节点。suspend和resume是和电源管理相关，enable和disable是启停该clock source的callback函数。rating是描述clock source的精度的，毫无疑问，一个输入频率是20MHz的counter精度一定是大于10ms一个cycle的counter。关于rating，内核代码的注释已经足够了，如下：
1-99: Unfit for real use
Only available for bootup and testing purposes.
100-199: Base level usability.
Functional for real use, but not desired.
200-299: Good.
A correct and usable clocksource.
300-399: Desired.
A reasonably fast and accurate clocksource.
400-499: Perfect
The ideal clocksource. A must-use where available.
clock source flag描述一些该clock source的特性，我们会在后面的代码分析中给出更详细的信息。
（3）第三部分的成员和clocksource watch dog相关。大家比较熟悉是系统的watch dog，主要监视系统，如果不及时喂狗，系统就会reset。clocksource watch dog当然是用来监视clock source的运行情况，如果watch dog发现它监视的clocksource的精度有问题，会修改其rating，告知系统。后面我们会有专门一个章节来描述这部分的内容。
三、注册和注销clock source
这个接口主要是提供给底层clock source chip driver使用的，在底层的driver初始化的时候会调用该接口向系统注册clock source。注销clock source是注册的逆过程。
1、注册函数1：调用者已经计算好mult和shift
如果在驱动代码中已经根据输入频率设定好了mult和shift，那么内核的clocksource layer是不需要进行这部分的内容的计算，那么注册clock source就会比较简单，代码如下：
int clocksource_register(struct clocksource *cs)
{
cs->maxadj = clocksource_max_adjustment(cs);－－－－－－－－－－－－－－－（1）cs->max_idle_ns = clocksource_max_deferment(cs); －－－－－－－－－－－－－（2）
mutex_lock(&clocksource_mutex);－－－－－－－－－－－－－－－－－－－－－－（3）
clocksource_enqueue(cs);－－－－－－－－－－－－－－－－－－－－－－－－－－（4）
clocksource_enqueue_watchdog(cs);－－－－－－－－－－－－－－－－－－－－－（5）
clocksource_select();－－－－－－－－－－－－－－－－－－－－－－－－－－－－（6）
mutex_unlock(&clocksource_mutex);
return 0;
}
（1）在给定的mult和shift组合下，计算最大的mult调整值。时间是需要校准的，首先counter的输入频率是有误差的，此外，在计算纳秒的时候mult和shift又引入了误差，这些误差可以通过外部的一些基准值进行校准（例如NTP server）。不过由于在将cycle值转换成纳秒值的过程中（((u64) cycles * mult) >> shift），太大的mult值会导致溢出，因此对multi的修正不应该过大，需要有一个限度，maxadj就是这个限度。clocksource_max_adjustment的代码很简单，就是返回clock source中mult成员11％的值（为何是11％呢？）。
此外，需要注意的是：这里有潜在溢出的风险，用户设定的mult是u32的，有可能已经逼近最大值，mult + maxadj有可能导致32bit的溢出（当然，这是在最大调整值的情况下）。
（2）我们前面已经了解了将counter value（cycle值）转换成ns的公式，这个公式是有限制的，cycle值不能太大，如果太大的话，cycles * mult的结果也会超出64bit从而导致溢出。因此，max_idle_ns 就是说明保证从cycle到ms不产生溢出的那个最大的纳秒数。为何其名字中有个idle呢？这是因为最大的cycle值是出现在idle的时候。我们知道，传统的Unix都是有一个周期性的tick，在嵌入式系统中，我们经常设定为10ms，但是linux kernel也允许你配置成NO_HZ，这时候，系统就不存在那个周期性的tick了，如果系统没有任何的动作是否CPU就一直idle下去了呢？不会的，由于counter value和纳秒的转换限制，这个idle的时间不能超过max_idle_ns。具体的计算很简单，这里不再具体描述。计算max_idle_ns的时候，为了安全还设定了12.5％的margin，之所以选择12.5％，是因为可以通过移位（而不是除法）的操作完成，看，kernel工程师永远都是performance至上的。
（3）通过clocksource_mutex保护对clock sourct list这一全局共享资源的访问。
（4）将该clock source按照rating的顺序插入到全局clock source list中
（5）处理clock source watchdog相关的内容，后面会详细介绍
（6）选择一个合适的clock source。kernel当然是选用一个rating最高的clocksource作为当前的正在使用的那个clock source。当注册一个新的clock source的时候当然要调用clocksource_select，毕竟有可能注册了一个精度更高的clock
source。
2、注册函数2：调用者给出输入clock频率，需要在注册过程中计算mult、shift和max_idle_ns
clock source chip driver可以调用clocksource_register_hz或者clocksource_register_khz这两个接口函数来注册一个clocksource。具体的接口定义如下：
static inline int clocksource_register_hz(struct clocksource *cs, u32 hz)
static inline int clocksource_register_khz(struct clocksource *cs, u32 khz)
hz和khz参数是传递counter的输入频率信息。这两个接口函数实际是调用了__clocksource_register_scale函数进行具体的操作，代码如下：
int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
{
__clocksource_updatefreq_scale(cs, scale, freq);将该clocksource挂入全局链表，代码同上。
return 0;
}
最核心的代码就是__clocksource_updatefreq_scale这个函数，代码如下：
void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
{
u64 sec;
sec = (cs->mask - (cs->mask >> 3));－－－－－－－－－－－－－－－－－－－（1）
do_div(sec, freq);
do_div(sec, scale);
if (!sec)
sec = 1;－－－－－－－－限制最小值
else if (sec > 600 && cs->mask > UINT_MAX)
sec = 600; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－（2）clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,－－－－－－－－－－－－－－（3）
NSEC_PER_SEC / scale, sec * scale);cs->maxadj = clocksource_max_adjustment(cs);－－－－－－－－－－－－－－－（4）
while ((cs->mult + cs->maxadj < cs->mult)
|| (cs->mult - cs->maxadj > cs->mult)) {
cs->mult >>= 1;
cs->shift--;
cs->maxadj = clocksource_max_adjustment(cs);
}cs->max_idle_ns = clocksource_max_deferment(cs);
}
（1）硬件counter本身就是由有限个bit组成，因此它能表示的时间有一个最大的限制，超过之后counter就溢出了。根据counter的bit数目以及输入频率可以计算出该硬件counter能表示的最大的时间长度。cs->mask最是最大的cycle数目，除以频率就是能表示的最大的时间范围（以秒为单位）。因此，代码至此，我们知道，[0, sec秒]就是该counter能表示的以秒计算的时间范围。这里还引入了12.5%的margin，具体原因在上面clocksource_max_deferment函数中已经说明。
（2）在解析这里的代码之前，我们先考虑这样一个问题：如何获取最佳的mult和shift组合？mult这个因子一定是越大越好了，越大精度越高，但是，我们的运算过程都是64 比特的，也就是说，中间的结果（cycle x mult）不能超过64bit。对于32bit的count，这个要求还好，因为cycle就是32bit的，只要mult不超过32bit就OK了（mult本来就是u32的）。因此，对于那些超过32 bit的count，我们就需要注意了，我们要人为的限制最大时间值，也就是说，虽然硬件counter可以表示出更大的时间值，但是通过mult和shift将这个大的cycle值转成ns值的时候，如果cycle太大，势必导致mult要小一些（否则溢出），而mult较小会导致精度不足，而精度不足（这时候如果要保证转换算法正确，mult需要取一个较小的数值，从而降低了精度）导致转换失去意义，因此，这里给出一个600秒的限制，这个限制也是和max idle ns相关的，具体参考上面的描述。
其实这里仍然是一个设计平衡的问题：一方面希望保持精度，因此mult要大，cycle到ns转换的时间范围就会小。另外一方面，cpuidle模块从电源管理的角度看，当然希望其在没有任务的时候，能够idle的时间越长越好，600秒是一个折衷的选择，让双方都基本满意。
（3）进入真正的mult和shift计算时刻了，代码如下：
void clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec)
{
u64 tmp;
u32 sft, sftacc= 32;tmp = ((u64)maxsec * from) >> 32;－－－－－－－－－－－－－－－－－－－（a）
while (tmp) {
tmp >>=1;
sftacc--;－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－（b）
}for (sft = 32; sft > 0; sft--) {－－－－－－－－－－－－－－－－－－－－－－－（c）
tmp = (u64) to << sft;
tmp += from / 2;
do_div(tmp, from);－－－－－－－－－－－－－－－－－－－－－－－－－－（d）
if ((tmp >> sftacc) == 0)
break;
}
*mult = tmp;
*shift = sft;
}
（a）在这个场景中，from是count的输入频率，maxsec是最大的表示的范围。maxsec * from就是将秒数转换成了cycle数目。对于大于32 bit的counter而言，最大的cycle数目有可能需要超过32个bit来表示，因此这里要进行右移32bit的操作。对于32 bit以下的counter，这时候的tmp右移32bit之后一定会等于0，而对于大于32 bit的counter，tmp是一个非0值。
（b）sftacc保存了左移多少位才会造成最大cycle数（对应最大的时间范围值）的溢出，对于32 bit以下的counter，统一设定为32个bit，而对于大于32 bit的counter，sftacc需要根据tmp值（这时候tmp保存了最大cycle数的高32 bit值）进
行计算。
（c）如何获取最佳的mult和shift组合？我们之前已经回答这个问题了，现在进入实现的层面。当一个公式中有两个可变量的时候，最好的办法就是固定其中一个，求出另外一个，然后带入约束条件进行检验。我们首先固定shift这个参数。mult这个因子一定是越大越好，mult越大也就是意味着shift越大。当然shift总有一个起始值，我们设定为32bit，因此sft从32开始搜索，看看是否满足最大时间范围的要求。如果满足，那么就找到最佳的mult和shift组合，否则要sft递减，进行下一轮搜索。
（d）我们先考虑如何计算mult值。根据公式cycles * mult) >> shift可以得到ns数，由此可以得到计算mult值的公式：
