電子發燒友App
上一篇文章，我介紹了傳統的低分辨率定時器的實現原理。而隨著內核的不斷演進，大牛們已經對這種低分辨率定時器的精度不再滿足，而且，硬件也在不斷地發展，系統中的定時器硬件的精度也越來越高，這也給高分辨率定時器的出現創造了條件。內核從2.6.16開始加入了高精度定時器架構。在實現方式上，內核的高分辨率定時器的實現代碼幾乎沒有借用低分辨率定時器的數據結構和代碼，內核文檔給出的解釋主要有以下幾點：
低分辨率定時器的代碼和jiffies的關系太過緊密，并且默認按32位進行設計，并且它的代碼已經經過長時間的優化，目前的使用也是沒有任何錯誤，如果硬要基于它來實現高分辨率定時器，勢必會打破原有的時間輪概念，并且會引入一大堆#if--#else判斷；
雖然大部分時間里，時間輪可以實現O(1)時間復雜度，但是當有進位發生時，不可預測的O(N)定時器級聯遷移時間，這對于低分辨率定時器來說問題不大，可是它大大地影響了定時器的精度；
低分辨率定時器幾乎是為“超時”而設計的，并為此對它進行了大量的優化，對于這些以“超時”未目的而使用定時器，它們大多數期望在超時到來之前獲得正確的結果，然后刪除定時器，精確時間并不是它們主要的目的，例如網絡通信、設備IO等等。
為此，內核為高精度定時器重新設計了一套軟件架構，它可以為我們提供納秒級的定時精度，以滿足對精確時間有迫切需求的應用程序或內核驅動，例如多媒體應用，音頻設備的驅動程序等等。以下的討論用hrtimer(high resolution timer)表示高精度定時器。
?
1. ?如何組織hrtimer？
我們知道，低分辨率定時器使用5個鏈表數組來組織timer_list結構，形成了著名的時間輪概念，對于高分辨率定時器，我們期望組織它們的數據結構至少具備以下條件：
穩定而且快速的查找能力；
快速地插入和刪除定時器的能力；
排序功能；
內核的開發者考察了多種數據結構，例如基數樹、哈希表等等，最終他們選擇了紅黑樹（rbtree）來組織hrtimer，紅黑樹已經以庫的形式存在于內核中，并被成功地使用在內存管理子系統和文件系統中，隨著系統的運行，hrtimer不停地被創建和銷毀，新的hrtimer按順序被插入到紅黑樹中，樹的最左邊的節點就是最快到期的定時器，內核用一個hrtimer結構來表示一個高精度定時器：
[cpp]?view plain?copy
struct?hrtimer?{??
struct?timerqueue_node??????node;??
ktime_t?????????????_softexpires;??
enum?hrtimer_restart????????(*function)(struct?hrtimer?*);??
struct?hrtimer_clock_base???*base;??
unsigned?long???????????state;??
......??
};??
定時器的到期時間用ktime_t來表示，_softexpires字段記錄了時間，定時器一旦到期，function字段指定的回調函數會被調用，該函數的返回值為一個枚舉值，它決定了該hrtimer是否需要被重新激活：
[cpp]?view plain?copy
enum?hrtimer_restart?{??
HRTIMER_NORESTART,??/*?Timer?is?not?restarted?*/??
HRTIMER_RESTART,????/*?Timer?must?be?restarted?*/??
};??
state字段用于表示hrtimer當前的狀態，有幾下幾種位組合：
[cpp]?view plain?copy
#define?HRTIMER_STATE_INACTIVE??0x00??//?定時器未激活??
#define?HRTIMER_STATE_ENQUEUED??0x01??//?定時器已經被排入紅黑樹中??
#define?HRTIMER_STATE_CALLBACK??0x02??//?定時器的回調函數正在被調用??
#define?HRTIMER_STATE_MIGRATE???0x04??//?定時器正在CPU之間做遷移??
hrtimer的到期時間可以基于以下幾種時間基準系統：
[cpp]?view plain?copy
enum??hrtimer_base_type?{??
HRTIMER_BASE_MONOTONIC,??//?單調遞增的monotonic時間，不包含休眠時間??
HRTIMER_BASE_REALTIME,???//?平常使用的墻上真實時間??
HRTIMER_BASE_BOOTTIME,???//?單調遞增的boottime，包含休眠時間??
HRTIMER_MAX_CLOCK_BASES,?//?用于后續數組的定義??
};??
和低分辨率定時器一樣，處于效率和上鎖的考慮，每個cpu單獨管理屬于自己的hrtimer，為此，專門定義了一個結構hrtimer_cpu_base：
[cpp]?view plain?copy
struct?hrtimer_cpu_base?{??
......??
struct?hrtimer_clock_base???clock_base[HRTIMER_MAX_CLOCK_BASES];??
};??
其中，clock_base數組為每種時間基準系統都定義了一個hrtimer_clock_base結構，它的定義如下：
[cpp]?view plain?copy
struct?hrtimer_clock_base?{??
struct?hrtimer_cpu_base?*cpu_base;??//?指向所屬cpu的hrtimer_cpu_base結構??
......??
struct?timerqueue_head??active;?????//?紅黑樹，包含了所有使用該時間基準系統的hrtimer??
ktime_t?????????resolution;?//?時間基準系統的分辨率??
ktime_t?????????(*get_time)(void);?//?獲取該基準系統的時間函數??
ktime_t?????????softirq_time;//?當用jiffies??
ktime_t?????????offset;??????//???
};??
active字段是一個timerqueue_head結構，它實際上是對rbtree的進一步封裝：
[cpp]?view plain?copy
struct?timerqueue_node?{??
struct?rb_node?node;??//?紅黑樹的節點??
ktime_t?expires;??????//?該節點代表隊hrtimer的到期時間，與hrtimer結構中的_softexpires稍有不同??
};??
struct?timerqueue_head?{??
struct?rb_root?head;??????????//?紅黑樹的根節點??
struct?timerqueue_node?*next;?//?該紅黑樹中最早到期的節點，也就是最左下的節點??
};??
timerqueue_head結構在紅黑樹的基礎上，增加了一個next字段，用于保存樹中最先到期的定時器節點，實際上就是樹的最左下方的節點，有了next字段，當到期事件到來時，系統不必遍歷整個紅黑樹，只要取出next字段對應的節點進行處理即可。timerqueue_node用于表示一個hrtimer節點，它在標準紅黑樹節點rb_node的基礎上增加了expires字段，該字段和hrtimer中的_softexpires字段一起，設定了hrtimer的到期時間的一個范圍，hrtimer可以在hrtimer._softexpires至timerqueue_node.expires之間的任何時刻到期，我們也稱timerqueue_node.expires為硬過期時間(hard)，意思很明顯：到了此時刻，定時器一定會到期，有了這個范圍可以選擇，定時器系統可以讓范圍接近的多個定時器在同一時刻同時到期，這種設計可以降低進程頻繁地被hrtimer進行喚醒。經過以上的討論，我們可以得出以下的圖示，它表明了每個cpu上的hrtimer是如何被組織在一起的：
圖 1.1 ?每個cpu的hrtimer組織結構
總結一下：
每個cpu有一個hrtimer_cpu_base結構；
hrtimer_cpu_base結構管理著3種不同的時間基準系統的hrtimer，分別是：實時時間，啟動時間和單調時間；
每種時間基準系統通過它的active字段（timerqueue_head結構指針），指向它們各自的紅黑樹；
紅黑樹上，按到期時間進行排序，最先到期的hrtimer位于最左下的節點，并被記錄在active.next字段中；
3中時間基準的最先到期時間可能不同，所以，它們之中最先到期的時間被記錄在hrtimer_cpu_base的expires_next字段中。
2. ?hrtimer如何運轉
hrtimer的實現需要一定的硬件基礎，它的實現依賴于我們前幾章介紹的timekeeper和clock_event_device，如果你對timekeeper和clock_event_device不了解請參考以下文章：Linux時間子系統之三：時間的維護者：timekeeper，Linux時間子系統之四：定時器的引擎：clock_event_device。hrtimer系統需要通過timekeeper獲取當前的時間，計算與到期時間的差值，并根據該差值，設定該cpu的tick_device（clock_event_device）的下一次的到期時間，時間一到，在clock_event_device的事件回調函數中處理到期的hrtimer。現在你或許有疑問：前面在介紹clock_event_device時，我們知道，每個cpu有自己的tick_device，通常用于周期性地產生進程調度和時間統計的tick事件，這里又說要用tick_device調度hrtimer系統，通常cpu只有一個tick_device，那他們如何協調工作？這個問題也一度困擾著我，如果再加上NO_HZ配置帶來tickless特性，你可能會更暈。這里我們先把這個疑問放下，我將在后面的章節中來討論這個問題，現在我們只要先知道，一旦開啟了hrtimer，tick_device所關聯的clock_event_device的事件回調函數會被修改為：hrtimer_interrupt，并且會被設置成工作于CLOCK_EVT_MODE_ONESHOT單觸發模式。
2.1 ?添加一個hrtimer
要添加一個hrtimer，系統提供了一些api供我們使用，首先我們需要定義一個hrtimer結構的實例，然后用hrtimer_init函數對它進行初始化，它的原型如下：
[cpp]?view plain?copy
void?hrtimer_init(struct?hrtimer?*timer,?clockid_t?which_clock,??
enum?hrtimer_mode?mode);??
which_clock可以是CLOCK_REALTIME、CLOCK_MONOTONIC、CLOCK_BOOTTIME中的一種，mode則可以是相對時間HRTIMER_MODE_REL，也可以是絕對時間HRTIMER_MODE_ABS。設定回調函數：
[cpp]?view plain?copy
timer.function?=?hr_callback;??
如果定時器無需指定一個到期范圍，可以在設定回調函數后直接使用hrtimer_start激活該定時器：
[cpp]?view plain?copy
int?hrtimer_start(struct?hrtimer?*timer,?ktime_t?tim,??
const?enum?hrtimer_mode?mode);??
如果需要指定到期范圍，則可以使用hrtimer_start_range_ns激活定時器：
[cpp]?view plain?copy
hrtimer_start_range_ns(struct?hrtimer?*timer,?ktime_t?tim,??
unsigned?long?range_ns,?const?enum?hrtimer_mode?mode);??
要取消一個hrtimer，使用hrtimer_cancel：
[cpp]?view plain?copy
int?hrtimer_cancel(struct?hrtimer?*timer);??
以下兩個函數用于推后定時器的到期時間：
[cpp]?view plain?copy
extern?u64??
hrtimer_forward(struct?hrtimer?*timer,?ktime_t?now,?ktime_t?interval);??
/*?Forward?a?hrtimer?so?it?expires?after?the?hrtimer's?current?now?*/??
static?inline?u64?hrtimer_forward_now(struct?hrtimer?*timer,??
ktime_t?interval)??
{??
return?hrtimer_forward(timer,?timer->base->get_time(),?interval);??
}??
以下幾個函數用于獲取定時器的當前狀態：
[cpp]?view plain?copy
static?inline?int?hrtimer_active(const?struct?hrtimer?*timer)??
{??
return?timer->state?!=?HRTIMER_STATE_INACTIVE;??
}??
static?inline?int?hrtimer_is_queued(struct?hrtimer?*timer)??
{??
return?timer->state?&?HRTIMER_STATE_ENQUEUED;??
}??
static?inline?int?hrtimer_callback_running(struct?hrtimer?*timer)??
{??
return?timer->state?&?HRTIMER_STATE_CALLBACK;??
}??
hrtimer_init最終會進入__hrtimer_init函數，該函數的主要目的是初始化hrtimer的base字段，同時初始化作為紅黑樹的節點的node字段：
[cpp]?view plain?copy
static?void?__hrtimer_init(struct?hrtimer?*timer,?clockid_t?clock_id,??
enum?hrtimer_mode?mode)??
{??
struct?hrtimer_cpu_base?*cpu_base;??
int?base;??
memset(timer,?0,?sizeof(struct?hrtimer));??
cpu_base?=?&__raw_get_cpu_var(hrtimer_bases);??
if?(clock_id?==?CLOCK_REALTIME?&&?mode?!=?HRTIMER_MODE_ABS)??
clock_id?=?CLOCK_MONOTONIC;??
base?=?hrtimer_clockid_to_base(clock_id);??
timer->base?=?&cpu_base->clock_base[base];??
timerqueue_init(&timer->node);??
......??
}??
hrtimer_start和hrtimer_start_range_ns最終會把實際的工作交由__hrtimer_start_range_ns來完成：
[cpp]?view plain?copy
int?__hrtimer_start_range_ns(struct?hrtimer?*timer,?ktime_t?tim,??
unsigned?long?delta_ns,?const?enum?hrtimer_mode?mode,??
int?wakeup)??
{??
......??????????
/*?取得hrtimer_clock_base指針?*/??
base?=?lock_hrtimer_base(timer,?&flags);???
/*?如果已經在紅黑樹中，先移除它:?*/??
ret?=?remove_hrtimer(timer,?base);?......??
/*?如果是相對時間，則需要加上當前時間，因為內部是使用絕對時間?*/??
if?(mode?&?HRTIMER_MODE_REL)?{??
tim?=?ktime_add_safe(tim,?new_base->get_time());??
......??
}???
/*?設置到期的時間范圍?*/??
hrtimer_set_expires_range_ns(timer,?tim,?delta_ns);??
......???
/*?把hrtime按到期時間排序，加入到對應時間基準系統的紅黑樹中?*/??
/*?如果該定時器的是最早到期的，將會返回true?*/??
leftmost?=?enqueue_hrtimer(timer,?new_base);??
/*??
*?Only?allow?reprogramming?if?the?new?base?is?on?this?CPU.??
*?(it?might?still?be?on?another?CPU?if?the?timer?was?pending)??
*??
*?XXX?send_remote_softirq()???
*?定時器比之前的到期時間要早，所以需要重新對tick_device進行編程，重新設定的的到期時間?
*/??
if?(leftmost?&&?new_base->cpu_base?==?&__get_cpu_var(hrtimer_bases))??
hrtimer_enqueue_reprogram(timer,?new_base,?wakeup);??
unlock_hrtimer_base(timer,?&flags);??
return?ret;??
}??
2.2 ?hrtimer的到期處理
高精度定時器系統有3個入口可以對到期定時器進行處理，它們分別是：
沒有切換到高精度模式時，在每個jiffie的tick事件中斷中進行查詢和處理；
在HRTIMER_SOFTIRQ軟中斷中進行查詢和處理；
切換到高精度模式后，在每個clock_event_device的到期事件中斷中進行查詢和處理；
低精度模式??因為系統并不是一開始就會支持高精度模式，而是在系統啟動后的某個階段，等待所有的條件都滿足后，才會切換到高精度模式，當系統還沒有切換到高精度模式時，所有的高精度定時器運行在低精度模式下，在每個jiffie的tick事件中斷中進行到期定時器的查詢和處理，顯然這時候的精度和低分辨率定時器是一樣的（HZ級別）。低精度模式下，每個tick事件中斷中，hrtimer_run_queues函數會被調用，由它完成定時器的到期處理。hrtimer_run_queues首先判斷目前高精度模式是否已經啟用，如果已經切換到了高精度模式，什么也不做，直接返回：
[cpp]?view plain?copy
void?hrtimer_run_queues(void)??
{??
if?(hrtimer_hres_active())??
return;??
如果hrtimer_hres_active返回false，說明目前處于低精度模式下，則繼續處理，它用一個for循環遍歷各個時間基準系統，查詢每個hrtimer_clock_base對應紅黑樹的左下節點，判斷它的時間是否到期，如果到期，通過__run_hrtimer函數，對到期定時器進行處理，包括：調用定時器的回調函數、從紅黑樹中移除該定時器、根據回調函數的返回值決定是否重新啟動該定時器等等：
[cpp]?view plain?copy
for?(index?=?0;?index?
base?=?&cpu_base->clock_base[index];??
if?(!timerqueue_getnext(&base->active))??
continue;??
if?(gettime)?{??
hrtimer_get_softirq_time(cpu_base);??
gettime?=?0;??
}??
raw_spin_lock(&cpu_base->lock);??
while?((node?=?timerqueue_getnext(&base->active)))?{??
struct?hrtimer?*timer;??
timer?=?container_of(node,?struct?hrtimer,?node);??
if?(base->softirq_time.tv64?<=??
hrtimer_get_expires_tv64(timer))??
break;??
__run_hrtimer(timer,?&base->softirq_time);??
}??
raw_spin_unlock(&cpu_base->lock);??
}??
上面的timerqueue_getnext函數返回紅黑樹中的左下節點，之所以可以在while循環中使用該函數，是因為__run_hrtimer會在移除舊的左下節點時，新的左下節點會被更新到base->active->next字段中，使得循環可以繼續執行，直到沒有新的到期定時器為止。
高精度模式? 切換到高精度模式后，原來給cpu提供tick事件的tick_device（clock_event_device）會被高精度定時器系統接管，它的中斷事件回調函數被設置為hrtimer_interrupt，紅黑樹中最左下的節點的定時器的到期時間被編程到該clock_event_device中，這樣每次clock_event_device的中斷意味著至少有一個高精度定時器到期。另外，當timekeeper系統中的時間需要修正，或者clock_event_device的到期事件時間被重新編程時，系統會發出HRTIMER_SOFTIRQ軟中斷，軟中斷的處理函數run_hrtimer_softirq最終也會調用hrtimer_interrupt函數對到期定時器進行處理，所以在這里我們只要討論hrtimer_interrupt函數的實現即可。
hrtimer_interrupt函數的前半部分和低精度模式下的hrtimer_run_queues函數完成相同的事情：它用一個for循環遍歷各個時間基準系統，查詢每個hrtimer_clock_base對應紅黑樹的左下節點，判斷它的時間是否到期，如果到期，通過__run_hrtimer函數，對到期定時器進行處理，所以我們只討論后半部分，在處理完所有到期定時器后，下一個到期定時器的到期時間保存在變量expires_next中，接下來的工作就是把這個到期時間編程到tick_device中：
[cpp]?view plain?copy
void?hrtimer_interrupt(struct?clock_event_device?*dev)??
{??
......??
for?(i?=?0;?i?
......??
while?((node?=?timerqueue_getnext(&base->active)))?{??
......??
if?(basenow.tv64?
ktime_t?expires;??
expires?=?ktime_sub(hrtimer_get_expires(timer),??
base->offset);??
if?(expires.tv64?
expires_next?=?expires;??
break;??
}??
__run_hrtimer(timer,?&basenow);??
}??
}??
/*?
*?Store?the?new?expiry?value?so?the?migration?code?can?verify?
*?against?it.?
*/??
cpu_base->expires_next?=?expires_next;??
raw_spin_unlock(&cpu_base->lock);??
/*?Reprogramming?necessary???*/??
if?(expires_next.tv64?==?KTIME_MAX?||??
!tick_program_event(expires_next,?0))?{??
cpu_base->hang_detected?=?0;??
return;??
}??
如果這時的tick_program_event返回了非0值，表示過期時間已經在當前時間的前面，這通常由以下原因造成：
系統正在被調試跟蹤，導致時間在走，程序不走；
定時器的回調函數花了太長的時間；
系統運行在虛擬機中，而虛擬機被調度導致停止運行；
為了避免這些情況的發生，接下來系統提供3次機會，重新執行前面的循環，處理到期的定時器：
[cpp]?view plain?copy
raw_spin_lock(&cpu_base->lock);??
now?=?hrtimer_update_base(cpu_base);??
cpu_base->nr_retries++;??
if?(++retries?
goto?retry;??
如果3次循環后還無法完成到期處理，系統不再循環，轉為計算本次總循環的時間，然后把tick_device的到期時間強制設置為當前時間加上本次的總循環時間，不過推后的時間被限制在100ms以內：
[cpp]?view plain?copy
delta?=?ktime_sub(now,?entry_time);??
if?(delta.tv64?>?cpu_base->max_hang_time.tv64)??
cpu_base->max_hang_time?=?delta;??
/*?
*?Limit?it?to?a?sensible?value?as?we?enforce?a?longer?
*?delay.?Give?the?CPU?at?least?100ms?to?catch?up.?
*/??
if?(delta.tv64?>?100?*?NSEC_PER_MSEC)??
expires_next?=?ktime_add_ns(now,?100?*?NSEC_PER_MSEC);??
else??
expires_next?=?ktime_add(now,?delta);??
tick_program_event(expires_next,?1);??
printk_once(KERN_WARNING?"hrtimer:?interrupt?took?%llu?ns ",??
ktime_to_ns(delta));??
}??
3. ?切換到高精度模式
上面提到，盡管內核配置成支持高精度定時器，但并不是一開始就工作于高精度模式，系統在啟動的開始階段，還是按照傳統的模式在運行：tick_device按HZ頻率定期地產生tick事件，這時的hrtimer工作在低分辨率模式，到期事件在每個tick事件中斷中由hrtimer_run_queues函數處理，同時，在低分辨率定時器（時間輪）的軟件中斷TIMER_SOFTIRQ中，hrtimer_run_pending會被調用，系統在這個函數中判斷系統的條件是否滿足切換到高精度模式，如果條件滿足，則會切換至高分辨率模式，另外提一下，NO_HZ模式也是在該函數中判斷并切換。
[cpp]?view plain?copy
void?hrtimer_run_pending(void)??
{??
if?(hrtimer_hres_active())??
return;??
......??
if?(tick_check_oneshot_change(!hrtimer_is_hres_enabled()))??
hrtimer_switch_to_hres();??
}??
因為不管系統是否工作于高精度模式，每個TIMER_SOFTIRQ期間，該函數都會被調用，所以函數一開始先用hrtimer_hres_active判斷目前高精度模式是否已經激活，如果已經激活，則說明之前的調用中已經切換了工作模式，不必再次切換，直接返回。hrtimer_hres_active很簡單：
[cpp]?view plain?copy
DEFINE_PER_CPU(struct?hrtimer_cpu_base,?hrtimer_bases)?=?{??
......??
}??
static?inline?int?hrtimer_hres_active(void)??
{??
return?__this_cpu_read(hrtimer_bases.hres_active);??
}??
hrtimer_run_pending函數接著通過tick_check_oneshot_change判斷系統是否可以切換到高精度模式，
[cpp]?view plain?copy
int?tick_check_oneshot_change(int?allow_nohz)??
{??
struct?tick_sched?*ts?=?&__get_cpu_var(tick_cpu_sched);??
if?(!test_and_clear_bit(0,?&ts->check_clocks))??
return?0;??
if?(ts->nohz_mode?!=?NOHZ_MODE_INACTIVE)??
return?0;??
if?(!timekeeping_valid_for_hres()?||?!tick_is_oneshot_available())??
return?0;??
if?(!allow_nohz)??
return?1;??
tick_nohz_switch_to_nohz();??
return?0;??
}??
函數的一開始先判斷check_clock標志的第0位是否被置位，如果沒有置位，說明系統中沒有注冊符合要求的時鐘事件設備，函數直接返回，check_clock標志由clocksource和clock_event_device系統的notify系統置位，當系統中有更高精度的clocksource被注冊和選擇后，或者有更精確的支持CLOCK_EVT_MODE_ONESHOT模式的clock_event_device被注冊時，通過它們的notify函數，check_clock標志的第0為會置位。
如果tick_sched結構中的nohz_mode字段不是NOHZ_MODE_INACTIVE，表明系統已經切換到其它模式，直接返回。nohz_mode的取值有3種：
NOHZ_MODE_INACTIVE ? ?// 未啟用NO_HZ模式
NOHZ_MODE_LOWRES ? ?//?啟用NO_HZ模式，hrtimer工作于低精度模式下
NOHZ_MODE_HIGHRES ? // 啟用NO_HZ模式，hrtimer工作于高精度模式下
接下來的timerkeeping_valid_for_hres判斷timekeeper系統是否支持高精度模式，tick_is_oneshot_available判斷tick_device是否支持CLOCK_EVT_MODE_ONESHOT模式。如果都滿足要求，則繼續往下判斷。allow_nohz是函數的參數，為true表明可以切換到NOHZ_MODE_LOWRES 模式，函數將進入tick_nohz_switch_to_nohz，切換至NOHZ_MODE_LOWRES 模式，這里我們傳入的allow_nohz是表達式：
(!hrtimer_is_hres_enabled())
所以當系統不允許高精度模式時，將會在tick_check_oneshot_change函數內，通過tick_nohz_switch_to_nohz切換至NOHZ_MODE_LOWRES 模式，如果系統允許高精度模式，傳入的allow_nohz參數為false，tick_check_oneshot_change函數返回1，回到上面的hrtimer_run_pending函數，hrtimer_switch_to_hres函數將會被調用，已完成切換到NOHZ_MODE_HIGHRES高精度模式。好啦，真正的切換函數找到了，我們看一看它如何切換：
首先，它通過hrtimer_cpu_base中的hres_active字段判斷該cpu是否已經切換至高精度模式，如果是則直接返回：
[cpp]?view plain?copy
static?int?hrtimer_switch_to_hres(void)??
{??
int?i,?cpu?=?smp_processor_id();??
struct?hrtimer_cpu_base?*base?=?&per_cpu(hrtimer_bases,?cpu);??
unsigned?long?flags;??
if?(base->hres_active)??
return?1;??
接著，通過tick_init_highres函數接管tick_device關聯的clock_event_device：
[cpp]?view plain?copy
local_irq_save(flags);??
if?(tick_init_highres())?{??
local_irq_restore(flags);??
printk(KERN_WARNING?"Could?not?switch?to?high?resolution?"??
"mode?on?CPU?%d ",?cpu);??
return?0;??
}??
tick_init_highres函數把tick_device切換到CLOCK_EVT_FEAT_ONESHOT模式，同時把clock_event_device的回調handler設置為hrtimer_interrupt，這樣設置以后，tick_device的中斷回調將由hrtimer_interrupt接管，hrtimer_interrupt在上面已經討論過，它將完成高精度定時器的調度和到期處理。
接著，設置hres_active標志，以表明高精度模式已經切換，然后把3個時間基準系統的resolution字段設為KTIME_HIGH_RES：
[cpp]?view plain?copy
base->hres_active?=?1;??
for?(i?=?0;?i?
base->clock_base[i].resolution?=?KTIME_HIGH_RES;??
最后，因為tick_device被高精度定時器接管，它將不會再提供原有的tick事件機制，所以需要由高精度定時器系統模擬一個tick事件設備，繼續為系統提供tick事件能力，這個工作由tick_setup_sched_timer函數完成。因為剛剛完成切換，tick_device的到期時間并沒有被正確地設置為下一個到期定時器的時間，這里使用retrigger_next_event函數，傳入參數NULL，使得tick_device立刻產生到期中斷，hrtimer_interrupt被調用一次，然后下一個到期的定時器的時間會編程到tick_device中，從而完成了到高精度模式的切換：
[cpp]?view plain?copy
tick_setup_sched_timer();??
/*?"Retrigger"?the?interrupt?to?get?things?going?*/??
retrigger_next_event(NULL);??
local_irq_restore(flags);??
return?1;??
整個切換過程可以用下圖表示：
圖3.1 ?低精度模式切換至高精度模式
4. ?模擬tick事件
根據上一節的討論，當系統切換到高精度模式后，tick_device被高精度定時器系統接管，不再定期地產生tick事件，我們知道，到目前的版本為止（V3.4），內核還沒有徹底廢除jiffies機制，系統還是依賴定期到來的tick事件，供進程調度系統和時間更新等操作，大量存在的低精度定時器也仍然依賴于jiffies的計數，所以，盡管tick_device被接管，高精度定時器系統還是要想辦法繼續提供定期的tick事件。為了達到這一目的，內核使用了一個取巧的辦法：既然高精度模式已經啟用，可以定義一個hrtimer，把它的到期時間設定為一個jiffy的時間，當這個hrtimer到期時，在這個hrtimer的到期回調函數中，進行和原來的tick_device同樣的操作，然后把該hrtimer的到期時間順延一個jiffy周期，如此反復循環，完美地模擬了原有tick_device的功能。下面我們看看具體點代碼是如何實現的。
在kernel/time/tick-sched.c中，內核定義了一個per_cpu全局變量：tick_cpu_sched，從而為每個cpu提供了一個tick_sched結構，?該結構主要用于管理NO_HZ配置下的tickless處理，因為模擬tick事件與tickless有很強的相關性，所以高精度定時器系統也利用了該結構的以下字段，用于完成模擬tick事件的操作：
[cpp]?view plain?copy
struct?tick_sched?{??
struct?hrtimer??????????sched_timer;??
unsigned?long???????????check_clocks;??
enum?tick_nohz_mode?????nohz_mode;??
......??
};??
sched_timer就是要用于模擬tick事件的hrtimer，check_clock上面幾節已經討論過，用于notify系統通知hrtimer系統需要檢查是否切換到高精度模式，nohz_mode則用于表示當前的工作模式。
?
上一節提到，用于切換至高精度模式的函數是hrtimer_switch_to_hres，在它的最后，調用了函數tick_setup_sched_timer，該函數的作用就是設置一個用于模擬tick事件的hrtimer：
[cpp]?view plain?copy
void?tick_setup_sched_timer(void)??
{??
struct?tick_sched?*ts?=?&__get_cpu_var(tick_cpu_sched);??
ktime_t?now?=?ktime_get();??
/*?
*?Emulate?tick?processing?via?per-CPU?hrtimers:?
*/??
hrtimer_init(&ts->sched_timer,?CLOCK_MONOTONIC,?HRTIMER_MODE_ABS);??
ts->sched_timer.function?=?tick_sched_timer;??
/*?Get?the?next?period?(per?cpu)?*/??
hrtimer_set_expires(&ts->sched_timer,?tick_init_jiffy_update());??
for?(;;)?{??
hrtimer_forward(&ts->sched_timer,?now,?tick_period);??
hrtimer_start_expires(&ts->sched_timer,??
HRTIMER_MODE_ABS_PINNED);??
/*?Check,?if?the?timer?was?already?in?the?past?*/??
if?(hrtimer_active(&ts->sched_timer))??
break;??
now?=?ktime_get();??
}??
#ifdef?CONFIG_NO_HZ??
if?(tick_nohz_enabled)??
ts->nohz_mode?=?NOHZ_MODE_HIGHRES;??
#endif??
}??
該函數首先初始化該cpu所屬的tick_sched結構中sched_timer字段，把該hrtimer的回調函數設置為tick_sched_timer，然后把它的到期時間設定為下一個jiffy時刻，返回前把工作模式設置為NOHZ_MODE_HIGHRES，表明是利用高精度模式實現NO_HZ。
接著我們關注一下hrtimer的回調函數tick_sched_timer，我們知道，系統中的jiffies計數，時間更新等是全局操作，在smp系統中，只有一個cpu負責該工作，所以在tick_sched_timer的一開始，先判斷當前cpu是否負責更新jiffies和時間，如果是，則執行更新操作：
[cpp]?view plain?copy
static?enum?hrtimer_restart?tick_sched_timer(struct?hrtimer?*timer)??
{??
......??
#ifdef?CONFIG_NO_HZ??
if?(unlikely(tick_do_timer_cpu?==?TICK_DO_TIMER_NONE))??
tick_do_timer_cpu?=?cpu;??
#endif??
/*?Check,?if?the?jiffies?need?an?update?*/??
if?(tick_do_timer_cpu?==?cpu)??
tick_do_update_jiffies64(now);??
然后，利用regs指針確保當前是在中斷上下文中，然后調用update_process_timer：
[cpp]?view plain?copy
if?(regs)?{??
......??
update_process_times(user_mode(regs));??
......??
}??
最后，把hrtimer的到期時間推進一個tick周期，返回HRTIMER_RESTART表明該hrtimer需要再次啟動，以便產生下一個tick事件。
[cpp]?view plain?copy
hrtimer_forward(timer,?now,?tick_period);??
return?HRTIMER_RESTART;??
}??
關于update_process_times，如果你你感興趣，回看一下本系列關于clock_event_device的那一章：Linux時間子系統之四：定時器的引擎：clock_event_device中的第5小節，對比一下模擬tick事件的hrtimer的回調函數tick_sched_timer和切換前tick_device的回調函數tick_handle_periodic，它們是如此地相像，實際上，它們幾乎完成了一樣的工作。
?
工商網監
評論