|
|
@@ -0,0 +1,850 @@
|
|
|
+use core::{
|
|
|
+ ffi::c_void,
|
|
|
+ fmt::Debug,
|
|
|
+ sync::atomic::{AtomicBool, Ordering},
|
|
|
+};
|
|
|
+
|
|
|
+use alloc::{boxed::Box, collections::LinkedList, string::String, sync::Arc, vec::Vec};
|
|
|
+use lazy_static::__Deref;
|
|
|
+
|
|
|
+use crate::{
|
|
|
+ include::bindings::bindings::run_watchdog_kthread, kdebug, kinfo, libs::spinlock::SpinLock,
|
|
|
+ syscall::SystemError,
|
|
|
+};
|
|
|
+
|
|
|
+use super::{
|
|
|
+ jiffies::clocksource_default_clock,
|
|
|
+ timer::{clock, Timer, TimerFunction},
|
|
|
+ NSEC_PER_SEC,
|
|
|
+};
|
|
|
+
|
|
|
+lazy_static! {
|
|
|
+ /// linked list with the registered clocksources
|
|
|
+ pub static ref CLOCKSOURCE_LIST: SpinLock<LinkedList<Arc<dyn Clocksource>>> =
|
|
|
+ SpinLock::new(LinkedList::new());
|
|
|
+ /// 被监视中的时钟源
|
|
|
+ pub static ref WATCHDOG_LIST: SpinLock<LinkedList<Arc<dyn Clocksource>>> =
|
|
|
+ SpinLock::new(LinkedList::new());
|
|
|
+
|
|
|
+ pub static ref CLOCKSOUCE_WATCHDOG:SpinLock<ClocksouceWatchdog> = SpinLock::new(ClocksouceWatchdog::new());
|
|
|
+
|
|
|
+ pub static ref OVERRIDE_NAME: SpinLock<String> = SpinLock::new(String::from(""));
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+/// 正在被使用时钟源
|
|
|
+pub static CUR_CLOCKSOURCE: SpinLock<Option<Arc<dyn Clocksource>>> = SpinLock::new(None);
|
|
|
+/// 是否完成加载
|
|
|
+pub static mut FINISHED_BOOTING: AtomicBool = AtomicBool::new(false);
|
|
|
+
|
|
|
+/// Interval: 0.5sec Threshold: 0.0625s
|
|
|
+/// 系统节拍率
|
|
|
+pub const HZ: u64 = 1000;
|
|
|
+/// watchdog检查间隔
|
|
|
+pub const WATCHDOG_INTERVAL: u64 = HZ >> 1;
|
|
|
+/// 最大能接受的误差大小
|
|
|
+pub const WATCHDOG_THRESHOLD: u32 = NSEC_PER_SEC >> 4;
|
|
|
+
|
|
|
+// 时钟周期数
|
|
|
+#[derive(Debug, Clone, Copy)]
|
|
|
+#[repr(transparent)]
|
|
|
+pub struct CycleNum(pub u64);
|
|
|
+
|
|
|
+#[allow(dead_code)]
|
|
|
+impl CycleNum {
|
|
|
+ #[inline(always)]
|
|
|
+ pub fn new(cycle: u64) -> Self {
|
|
|
+ Self(cycle)
|
|
|
+ }
|
|
|
+ #[inline(always)]
|
|
|
+ pub fn data(&self) -> u64 {
|
|
|
+ self.0
|
|
|
+ }
|
|
|
+ #[inline(always)]
|
|
|
+ #[allow(dead_code)]
|
|
|
+ pub fn add(&self, other: CycleNum) -> CycleNum {
|
|
|
+ CycleNum(self.data() + other.data())
|
|
|
+ }
|
|
|
+ #[inline(always)]
|
|
|
+ pub fn div(&self, other: CycleNum) -> CycleNum {
|
|
|
+ CycleNum(self.data() - other.data())
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bitflags! {
|
|
|
+
|
|
|
+ #[derive(Default)]
|
|
|
+ pub struct ClocksourceMask: u64 {
|
|
|
+ }
|
|
|
+ /// 时钟状态标记
|
|
|
+ #[derive(Default)]
|
|
|
+ pub struct ClocksourceFlags: u64 {
|
|
|
+ /// 表示时钟设备是连续的
|
|
|
+ const CLOCK_SOURCE_IS_CONTINUOUS = 0x01;
|
|
|
+ /// 表示该时钟源需要经过watchdog检查
|
|
|
+ const CLOCK_SOURCE_MUST_VERIFY = 0x02;
|
|
|
+ /// 表示该时钟源是watchdog
|
|
|
+ const CLOCK_SOURCE_WATCHDOG = 0x10;
|
|
|
+ /// 表示该时钟源是高分辨率的
|
|
|
+ const CLOCK_SOURCE_VALID_FOR_HRES = 0x20;
|
|
|
+ /// 表示该时钟源误差过大
|
|
|
+ const CLOCK_SOURCE_UNSTABLE = 0x40;
|
|
|
+ }
|
|
|
+}
|
|
|
+impl From<u64> for ClocksourceMask {
|
|
|
+ fn from(value: u64) -> Self {
|
|
|
+ if value < 64 {
|
|
|
+ return Self::from_bits_truncate((1 << value) - 1);
|
|
|
+ }
|
|
|
+ return Self::from_bits_truncate(u64::MAX);
|
|
|
+ }
|
|
|
+}
|
|
|
+impl ClocksourceMask {
|
|
|
+ pub fn new(b: u64) -> Self {
|
|
|
+ Self { bits: b }
|
|
|
+ }
|
|
|
+}
|
|
|
+impl ClocksourceFlags {
|
|
|
+ pub fn new(b: u64) -> Self {
|
|
|
+ Self { bits: b }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[derive(Debug)]
|
|
|
+pub struct ClocksouceWatchdog {
|
|
|
+ /// 监视器
|
|
|
+ watchdog: Option<Arc<dyn Clocksource>>,
|
|
|
+ /// 检查器是否在工作的标志
|
|
|
+ is_running: bool,
|
|
|
+ /// 上一次检查的时刻
|
|
|
+ last_check: CycleNum,
|
|
|
+ /// 定时监视器的过期时间
|
|
|
+ timer_expires: u64,
|
|
|
+}
|
|
|
+impl ClocksouceWatchdog {
|
|
|
+ pub fn new() -> Self {
|
|
|
+ Self {
|
|
|
+ watchdog: None,
|
|
|
+ is_running: false,
|
|
|
+ last_check: CycleNum(0),
|
|
|
+ timer_expires: 0,
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// 获取watchdog
|
|
|
+ fn get_watchdog(&mut self) -> &mut Option<Arc<dyn Clocksource>> {
|
|
|
+ &mut self.watchdog
|
|
|
+ }
|
|
|
+
|
|
|
+ /// 启用检查器
|
|
|
+ pub fn clocksource_start_watchdog(&mut self) {
|
|
|
+ // 如果watchdog未被设置或者已经启用了就退出
|
|
|
+ let watchdog_list = &WATCHDOG_LIST.lock();
|
|
|
+ if self.is_running || self.watchdog.is_none() || watchdog_list.is_empty() {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // 生成一个定时器
|
|
|
+ let wd_timer_func: Box<WatchdogTimerFunc> = Box::new(WatchdogTimerFunc {});
|
|
|
+ self.timer_expires += clock() + WATCHDOG_INTERVAL;
|
|
|
+ self.last_check = self.watchdog.as_ref().unwrap().clone().read();
|
|
|
+ let wd_timer = Timer::new(wd_timer_func, self.timer_expires);
|
|
|
+ wd_timer.activate();
|
|
|
+ self.is_running = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// 停止检查器
|
|
|
+ /// list_len WATCHDOG_LIST长度
|
|
|
+ pub fn clocksource_stop_watchdog(&mut self, list_len: usize) {
|
|
|
+ if !self.is_running || (self.watchdog.is_some() && list_len != 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // TODO 当实现了周期性的定时器后 需要将监视用的定时器删除
|
|
|
+ self.is_running = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// 定时检查器
|
|
|
+#[derive(Debug)]
|
|
|
+pub struct WatchdogTimerFunc;
|
|
|
+impl TimerFunction for WatchdogTimerFunc {
|
|
|
+ fn run(&mut self) -> Result<(), SystemError> {
|
|
|
+ return clocksource_watchdog();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// 时钟源的特性
|
|
|
+pub trait Clocksource: Send + Sync + Debug {
|
|
|
+ // TODO 返回值类型可能需要改变
|
|
|
+ /// returns a cycle value, passes clocksource as argument
|
|
|
+ fn read(&self) -> CycleNum;
|
|
|
+ /// optional function to enable the clocksource
|
|
|
+ fn enable(&self) -> Result<i32, SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ /// optional function to disable the clocksource
|
|
|
+ fn disable(&self) -> Result<(), SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ /// vsyscall based read
|
|
|
+ fn vread(&self) -> Result<CycleNum, SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ /// suspend function for the clocksource, if necessary
|
|
|
+ fn suspend(&self) -> Result<(), SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ /// resume function for the clocksource, if necessary
|
|
|
+ fn resume(&self) -> Result<(), SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ // 获取时钟源数据
|
|
|
+ fn clocksource_data(&self) -> ClocksourceData;
|
|
|
+
|
|
|
+ fn update_clocksource_data(&self, _data: ClocksourceData) -> Result<(), SystemError> {
|
|
|
+ return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
|
|
|
+ }
|
|
|
+ // 获取时钟源
|
|
|
+ fn clocksource(&self) -> Arc<dyn Clocksource>;
|
|
|
+}
|
|
|
+
|
|
|
+/// # 实现整数log2的运算
|
|
|
+///
|
|
|
+/// ## 参数
|
|
|
+///
|
|
|
+/// * `x` - 要计算的数字
|
|
|
+///
|
|
|
+/// ## 返回值
|
|
|
+///
|
|
|
+/// * `u32` - 返回\log_2(x)的值
|
|
|
+fn log2(x: u32) -> u32 {
|
|
|
+ let mut result = 0;
|
|
|
+ let mut x = x;
|
|
|
+
|
|
|
+ if x >= 1 << 16 {
|
|
|
+ x >>= 16;
|
|
|
+ result |= 16;
|
|
|
+ }
|
|
|
+ if x >= 1 << 8 {
|
|
|
+ x >>= 8;
|
|
|
+ result |= 8;
|
|
|
+ }
|
|
|
+ if x >= 1 << 4 {
|
|
|
+ x >>= 4;
|
|
|
+ result |= 4;
|
|
|
+ }
|
|
|
+ if x >= 1 << 2 {
|
|
|
+ x >>= 2;
|
|
|
+ result |= 2;
|
|
|
+ }
|
|
|
+ if x >= 1 << 1 {
|
|
|
+ result |= 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ result
|
|
|
+}
|
|
|
+
|
|
|
+impl dyn Clocksource {
|
|
|
+ /// # 计算时钟源能记录的最大时间跨度
|
|
|
+ pub fn clocksource_max_deferment(&self) -> u64 {
|
|
|
+ let cs_data_guard = self.clocksource_data();
|
|
|
+ let max_nsecs: u64;
|
|
|
+ let mut max_cycles: u64;
|
|
|
+ max_cycles = (1 << (63 - (log2(cs_data_guard.mult) + 1))) as u64;
|
|
|
+ max_cycles = max_cycles.min(cs_data_guard.mask.bits);
|
|
|
+ max_nsecs = clocksource_cyc2ns(
|
|
|
+ CycleNum(max_cycles),
|
|
|
+ cs_data_guard.mult,
|
|
|
+ cs_data_guard.shift,
|
|
|
+ );
|
|
|
+ return max_nsecs - (max_nsecs >> 5);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 注册时钟源
|
|
|
+ ///
|
|
|
+ /// ## 返回值
|
|
|
+ ///
|
|
|
+ /// * `Ok(0)` - 时钟源注册成功。
|
|
|
+ /// * `Err(SystemError)` - 时钟源注册失败。
|
|
|
+ pub fn register(&self) -> Result<i32, SystemError> {
|
|
|
+ let ns = self.clocksource_max_deferment();
|
|
|
+ let mut cs_data = self.clocksource_data();
|
|
|
+ cs_data.max_idle_ns = ns as u32;
|
|
|
+ self.update_clocksource_data(cs_data)?;
|
|
|
+ // 将时钟源加入到时钟源队列中
|
|
|
+ self.clocksource_enqueue();
|
|
|
+ // 将时钟源加入到监视队列中
|
|
|
+ self.clocksource_enqueue_watchdog()
|
|
|
+ .expect("register: failed to enqueue watchdog list");
|
|
|
+ // 选择一个最好的时钟源
|
|
|
+ clocksource_select();
|
|
|
+ kdebug!("clocksource_register successfully");
|
|
|
+ return Ok(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 将时钟源插入时钟源队列
|
|
|
+ pub fn clocksource_enqueue(&self) {
|
|
|
+ // 根据rating由大到小排序
|
|
|
+ let cs_data = self.clocksource_data();
|
|
|
+ let list_guard = &mut CLOCKSOURCE_LIST.lock();
|
|
|
+ let mut spilt_pos: usize = 0;
|
|
|
+ for (pos, ele) in list_guard.iter().enumerate() {
|
|
|
+ if ele.clocksource_data().rating < cs_data.rating {
|
|
|
+ spilt_pos = pos;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let mut temp_list = list_guard.split_off(spilt_pos);
|
|
|
+ let cs = self.clocksource();
|
|
|
+ list_guard.push_back(cs);
|
|
|
+ list_guard.append(&mut temp_list);
|
|
|
+ // kdebug!(
|
|
|
+ // "CLOCKSOURCE_LIST len = {:?},clocksource_enqueue sccessfully",
|
|
|
+ // list_guard.len()
|
|
|
+ // );
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 将时间源插入监控队列
|
|
|
+ ///
|
|
|
+ /// ## 返回值
|
|
|
+ ///
|
|
|
+ /// * `Ok(0)` - 时间源插入监控队列成功
|
|
|
+ /// * `Err(SystemError)` - 时间源插入监控队列失败
|
|
|
+ pub fn clocksource_enqueue_watchdog(&self) -> Result<i32, SystemError> {
|
|
|
+ // BUG 可能需要lock irq
|
|
|
+ let mut cs_data = self.clocksource_data();
|
|
|
+
|
|
|
+ let cs = self.clocksource();
|
|
|
+ if cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_MUST_VERIFY)
|
|
|
+ {
|
|
|
+ let mut list_guard = WATCHDOG_LIST.lock_irqsave();
|
|
|
+ // cs是被监视的
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .remove(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG);
|
|
|
+ cs.update_clocksource_data(cs_data)?;
|
|
|
+ list_guard.push_back(cs);
|
|
|
+ } else {
|
|
|
+ // cs是监视器
|
|
|
+ if cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_IS_CONTINUOUS)
|
|
|
+ {
|
|
|
+ // 如果时钟设备是连续的
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .insert(ClocksourceFlags::CLOCK_SOURCE_VALID_FOR_HRES);
|
|
|
+ cs.update_clocksource_data(cs_data.clone())?;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 将时钟源加入到监控队列中
|
|
|
+ let mut list_guard = WATCHDOG_LIST.lock();
|
|
|
+ list_guard.push_back(cs.clone());
|
|
|
+ drop(list_guard);
|
|
|
+
|
|
|
+ // 对比当前注册的时间源的精度和监视器的精度
|
|
|
+ let cs_watchdog = &mut CLOCKSOUCE_WATCHDOG.lock();
|
|
|
+ if cs_watchdog.watchdog.is_none()
|
|
|
+ || cs_data.rating
|
|
|
+ > cs_watchdog
|
|
|
+ .watchdog
|
|
|
+ .clone()
|
|
|
+ .unwrap()
|
|
|
+ .clocksource_data()
|
|
|
+ .rating
|
|
|
+ {
|
|
|
+ // 当前注册的时间源的精度更高或者没有监视器，替换监视器
|
|
|
+ cs_watchdog.watchdog.replace(cs);
|
|
|
+ clocksource_reset_watchdog();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 启动监视器
|
|
|
+ cs_watchdog.clocksource_start_watchdog();
|
|
|
+ }
|
|
|
+ return Ok(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 将时钟源标记为unstable
|
|
|
+ ///
|
|
|
+ /// ## 参数
|
|
|
+ /// * `delta` - 时钟源误差
|
|
|
+ pub fn set_unstable(&self, delta: i64) -> Result<i32, SystemError> {
|
|
|
+ let mut cs_data = self.clocksource_data();
|
|
|
+ // 打印出unstable的时钟源信息
|
|
|
+ kdebug!(
|
|
|
+ "clocksource :{:?} is unstable, its delta is {:?}",
|
|
|
+ cs_data.name,
|
|
|
+ delta
|
|
|
+ );
|
|
|
+ cs_data.flags.remove(
|
|
|
+ ClocksourceFlags::CLOCK_SOURCE_VALID_FOR_HRES | ClocksourceFlags::CLOCK_SOURCE_WATCHDOG,
|
|
|
+ );
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .insert(ClocksourceFlags::CLOCK_SOURCE_UNSTABLE);
|
|
|
+ self.update_clocksource_data(cs_data)?;
|
|
|
+
|
|
|
+ // 启动watchdog线程 进行后续处理
|
|
|
+ if unsafe { FINISHED_BOOTING.load(Ordering::Relaxed) } {
|
|
|
+ // TODO 在实现了工作队列后，将启动线程换成schedule work
|
|
|
+ unsafe { run_watchdog_kthread() }
|
|
|
+ }
|
|
|
+ return Ok(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 将时间源从监视链表中弹出
|
|
|
+ fn clocksource_dequeue_watchdog(&self) {
|
|
|
+ let data = self.clocksource_data();
|
|
|
+ let mut locked_watchdog = CLOCKSOUCE_WATCHDOG.lock();
|
|
|
+ let watchdog = locked_watchdog
|
|
|
+ .get_watchdog()
|
|
|
+ .clone()
|
|
|
+ .unwrap()
|
|
|
+ .clocksource_data();
|
|
|
+
|
|
|
+ let mut list = WATCHDOG_LIST.lock();
|
|
|
+ let mut size = list.len();
|
|
|
+
|
|
|
+ let mut del_pos: usize = size;
|
|
|
+ for (pos, ele) in list.iter().enumerate() {
|
|
|
+ let ele_data = ele.clocksource_data();
|
|
|
+ if ele_data.name.eq(&data.name) && ele_data.rating.eq(&data.rating) {
|
|
|
+ // 记录要删除的时钟源在监视链表中的下标
|
|
|
+ del_pos = pos;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_MUST_VERIFY)
|
|
|
+ {
|
|
|
+ // 如果时钟源是需要被检查的，直接删除时钟源
|
|
|
+ if del_pos != size {
|
|
|
+ let mut temp_list = list.split_off(del_pos);
|
|
|
+ temp_list.pop_front();
|
|
|
+ list.append(&mut temp_list);
|
|
|
+ }
|
|
|
+ } else if watchdog.name.eq(&data.name) && watchdog.rating.eq(&data.rating) {
|
|
|
+ // 如果要删除的时钟源是监视器，则需要找到一个新的监视器
|
|
|
+ // TODO 重新设置时钟源
|
|
|
+ // 将链表解锁防止reset中双重加锁 并释放保存的旧的watchdog的数据
|
|
|
+
|
|
|
+ // 代替了clocksource_reset_watchdog()的功能，将所有时钟源的watchdog标记清除
|
|
|
+ for ele in list.iter() {
|
|
|
+ ele.clocksource_data()
|
|
|
+ .flags
|
|
|
+ .remove(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 遍历所有时间源，寻找新的监视器
|
|
|
+ let mut clocksource_list = CLOCKSOURCE_LIST.lock();
|
|
|
+ let mut replace_pos: usize = clocksource_list.len();
|
|
|
+ for (pos, ele) in clocksource_list.iter().enumerate() {
|
|
|
+ let ele_data = ele.clocksource_data();
|
|
|
+
|
|
|
+ if ele_data.name.eq(&data.name) && ele_data.rating.eq(&data.rating)
|
|
|
+ || ele_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_MUST_VERIFY)
|
|
|
+ {
|
|
|
+ // 当前时钟源是要被删除的时钟源或没被检查过的时钟源
|
|
|
+ // 不适合成为监视器
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ let watchdog = locked_watchdog.get_watchdog().clone();
|
|
|
+ if watchdog.is_none()
|
|
|
+ || ele_data.rating > watchdog.unwrap().clocksource_data().rating
|
|
|
+ {
|
|
|
+ // 如果watchdog不存在或者当前时钟源的精度高于watchdog的精度，则记录当前时钟源的下标
|
|
|
+ replace_pos = pos;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // 使用刚刚找到的更好的时钟源替换旧的watchdog
|
|
|
+ if replace_pos < clocksource_list.len() {
|
|
|
+ let mut temp_list = clocksource_list.split_off(replace_pos);
|
|
|
+ let new_wd = temp_list.front().unwrap().clone();
|
|
|
+ clocksource_list.append(&mut temp_list);
|
|
|
+ // 替换watchdog
|
|
|
+ locked_watchdog.watchdog.replace(new_wd);
|
|
|
+ // drop(locked_watchdog);
|
|
|
+ }
|
|
|
+ // 删除时钟源
|
|
|
+ if del_pos != size {
|
|
|
+ let mut temp_list = list.split_off(del_pos);
|
|
|
+ temp_list.pop_front();
|
|
|
+ list.append(&mut temp_list);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 清除watchdog标记
|
|
|
+ let mut cs_data = self.clocksource_data();
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .remove(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG);
|
|
|
+ self.update_clocksource_data(cs_data)
|
|
|
+ .expect("clocksource_dequeue_watchdog: failed to update clocksource data");
|
|
|
+ size = list.len();
|
|
|
+ // 停止当前的watchdog
|
|
|
+ locked_watchdog.clocksource_stop_watchdog(size - 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 将时钟源从时钟源链表中弹出
|
|
|
+ fn clocksource_dequeue(&self) {
|
|
|
+ let mut list = CLOCKSOURCE_LIST.lock();
|
|
|
+ let data = self.clocksource_data();
|
|
|
+ let mut del_pos: usize = list.len();
|
|
|
+ for (pos, ele) in list.iter().enumerate() {
|
|
|
+ let ele_data = ele.clocksource_data();
|
|
|
+ if ele_data.name.eq(&data.name) && ele_data.rating.eq(&data.rating) {
|
|
|
+ // 记录时钟源在链表中的下标
|
|
|
+ del_pos = pos;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 删除时钟源
|
|
|
+ if del_pos != list.len() {
|
|
|
+ let mut temp_list = list.split_off(del_pos);
|
|
|
+ temp_list.pop_front();
|
|
|
+ list.append(&mut temp_list);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// # 注销时钟源
|
|
|
+ #[allow(dead_code)]
|
|
|
+ pub fn unregister(&self) {
|
|
|
+ // 将时钟源从监视链表中弹出
|
|
|
+ self.clocksource_dequeue_watchdog();
|
|
|
+ // 将时钟源从时钟源链表中弹出
|
|
|
+ self.clocksource_dequeue();
|
|
|
+ // 检查是否有更好的时钟源
|
|
|
+ clocksource_select();
|
|
|
+ }
|
|
|
+ /// # 修改时钟源的精度
|
|
|
+ ///
|
|
|
+ /// ## 参数
|
|
|
+ ///
|
|
|
+ /// * `rating` - 指定的时钟精度
|
|
|
+ fn clocksource_change_rating(&self, rating: i32) {
|
|
|
+ // 将时钟源从链表中弹出
|
|
|
+ self.clocksource_dequeue();
|
|
|
+ let mut data = self.clocksource_data();
|
|
|
+ // 修改时钟源的精度
|
|
|
+ data.set_rating(rating);
|
|
|
+ self.update_clocksource_data(data)
|
|
|
+ .expect("clocksource_change_rating:updata clocksource failed");
|
|
|
+ // 插入时钟源到时钟源链表中
|
|
|
+ self.clocksource_enqueue();
|
|
|
+ // 检查是否有更好的时钟源
|
|
|
+ clocksource_select();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[derive(Debug, Clone)]
|
|
|
+pub struct ClocksourceData {
|
|
|
+ /// 时钟源名字
|
|
|
+ pub name: String,
|
|
|
+ /// 时钟精度
|
|
|
+ pub rating: i32,
|
|
|
+ pub mask: ClocksourceMask,
|
|
|
+ pub mult: u32,
|
|
|
+ pub shift: u32,
|
|
|
+ pub max_idle_ns: u32,
|
|
|
+ pub flags: ClocksourceFlags,
|
|
|
+ pub watchdog_last: CycleNum,
|
|
|
+}
|
|
|
+
|
|
|
+impl ClocksourceData {
|
|
|
+ #[allow(dead_code)]
|
|
|
+ pub fn new(
|
|
|
+ name: String,
|
|
|
+ rating: i32,
|
|
|
+ mask: ClocksourceMask,
|
|
|
+ mult: u32,
|
|
|
+ shift: u32,
|
|
|
+ max_idle_ns: u32,
|
|
|
+ flags: ClocksourceFlags,
|
|
|
+ ) -> Self {
|
|
|
+ let csd = ClocksourceData {
|
|
|
+ name,
|
|
|
+ rating,
|
|
|
+ mask,
|
|
|
+ mult,
|
|
|
+ shift,
|
|
|
+ max_idle_ns,
|
|
|
+ flags,
|
|
|
+ watchdog_last: CycleNum(0),
|
|
|
+ };
|
|
|
+ return csd;
|
|
|
+ }
|
|
|
+
|
|
|
+ pub fn set_name(&mut self, name: String) {
|
|
|
+ self.name = name;
|
|
|
+ }
|
|
|
+ pub fn set_rating(&mut self, rating: i32) {
|
|
|
+ self.rating = rating;
|
|
|
+ }
|
|
|
+ pub fn set_mask(&mut self, mask: ClocksourceMask) {
|
|
|
+ self.mask = mask;
|
|
|
+ }
|
|
|
+ pub fn set_mult(&mut self, mult: u32) {
|
|
|
+ self.mult = mult;
|
|
|
+ }
|
|
|
+ pub fn set_shift(&mut self, shift: u32) {
|
|
|
+ self.shift = shift;
|
|
|
+ }
|
|
|
+ pub fn set_max_idle_ns(&mut self, max_idle_ns: u32) {
|
|
|
+ self.max_idle_ns = max_idle_ns;
|
|
|
+ }
|
|
|
+ pub fn set_flags(&mut self, flags: ClocksourceFlags) {
|
|
|
+ self.flags = flags;
|
|
|
+ }
|
|
|
+ #[allow(dead_code)]
|
|
|
+ pub fn remove_flags(&mut self, flags: ClocksourceFlags) {
|
|
|
+ self.flags.remove(flags)
|
|
|
+ }
|
|
|
+ #[allow(dead_code)]
|
|
|
+ pub fn insert_flags(&mut self, flags: ClocksourceFlags) {
|
|
|
+ self.flags.insert(flags)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// converts clocksource cycles to nanoseconds
|
|
|
+///
|
|
|
+pub fn clocksource_cyc2ns(cycles: CycleNum, mult: u32, shift: u32) -> u64 {
|
|
|
+ return (cycles.data() * mult as u64) >> shift;
|
|
|
+}
|
|
|
+
|
|
|
+/// # 重启所有的时间源
|
|
|
+#[allow(dead_code)]
|
|
|
+pub fn clocksource_resume() {
|
|
|
+ let list = CLOCKSOURCE_LIST.lock();
|
|
|
+ for ele in list.iter() {
|
|
|
+ let data = ele.clocksource_data();
|
|
|
+ match ele.resume() {
|
|
|
+ Ok(_) => continue,
|
|
|
+ Err(_) => {
|
|
|
+ kdebug!("clocksource {:?} resume failed", data.name)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ clocksource_resume_watchdog();
|
|
|
+}
|
|
|
+
|
|
|
+/// # 暂停所有的时间源
|
|
|
+#[allow(dead_code)]
|
|
|
+pub fn clocksource_suspend() {
|
|
|
+ let list = CLOCKSOURCE_LIST.lock();
|
|
|
+ for ele in list.iter() {
|
|
|
+ let data = ele.clocksource_data();
|
|
|
+ match ele.suspend() {
|
|
|
+ Ok(_) => continue,
|
|
|
+ Err(_) => {
|
|
|
+ kdebug!("clocksource {:?} suspend failed", data.name)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// # 根据watchdog的精度，来检查被监视的时钟源的误差
|
|
|
+///
|
|
|
+/// ## 返回值
|
|
|
+///
|
|
|
+/// * `Ok()` - 检查完成
|
|
|
+/// * `Err(SystemError)` - 错误码
|
|
|
+pub fn clocksource_watchdog() -> Result<(), SystemError> {
|
|
|
+ let mut cs_watchdog = CLOCKSOUCE_WATCHDOG.lock();
|
|
|
+
|
|
|
+ // watchdog没有在运行的话直接退出
|
|
|
+ if !cs_watchdog.is_running || cs_watchdog.watchdog.is_none() {
|
|
|
+ return Ok(());
|
|
|
+ }
|
|
|
+ let cur_watchdog = cs_watchdog.watchdog.as_ref().unwrap().clone();
|
|
|
+ let cur_wd_data = cur_watchdog.as_ref().clocksource_data();
|
|
|
+ let cur_wd_nowclock = cur_watchdog.as_ref().read().data();
|
|
|
+
|
|
|
+ let wd_last = cs_watchdog.last_check.data();
|
|
|
+ let wd_dev_nsec = clocksource_cyc2ns(
|
|
|
+ CycleNum((cur_wd_nowclock - wd_last) & cur_wd_data.mask.bits),
|
|
|
+ cur_wd_data.mult,
|
|
|
+ cur_wd_data.shift,
|
|
|
+ );
|
|
|
+ cs_watchdog.last_check = CycleNum(cur_wd_nowclock);
|
|
|
+ drop(cs_watchdog);
|
|
|
+ let watchdog_list = &mut WATCHDOG_LIST.lock();
|
|
|
+ for cs in watchdog_list.iter() {
|
|
|
+ let mut cs_data = cs.clocksource_data();
|
|
|
+ // 判断时钟源是否已经被标记为不稳定
|
|
|
+ if cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_UNSTABLE)
|
|
|
+ {
|
|
|
+ // 启动watchdog_kthread
|
|
|
+ unsafe { run_watchdog_kthread() };
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // 读取时钟源现在的时间
|
|
|
+ let cs_now_clock = cs.read();
|
|
|
+
|
|
|
+ // 如果时钟源没有被监视，则开始监视他
|
|
|
+ if !cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG)
|
|
|
+ {
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .insert(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG);
|
|
|
+ // 记录此次检查的时刻
|
|
|
+ cs_data.watchdog_last = cs_now_clock;
|
|
|
+ cs.update_clocksource_data(cs_data.clone())?;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 计算时钟源的误差
|
|
|
+ let cs_dev_nsec = clocksource_cyc2ns(
|
|
|
+ CycleNum(cs_now_clock.div(cs_data.watchdog_last).data() & cs_data.mask.bits),
|
|
|
+ cs_data.mult,
|
|
|
+ cs_data.shift,
|
|
|
+ );
|
|
|
+ // 记录此次检查的时刻
|
|
|
+ cs_data.watchdog_last = cs_now_clock;
|
|
|
+ cs.update_clocksource_data(cs_data.clone())?;
|
|
|
+ if cs_dev_nsec.abs_diff(wd_dev_nsec) > WATCHDOG_THRESHOLD.into() {
|
|
|
+ // 误差过大，标记为unstable
|
|
|
+ cs.set_unstable((cs_dev_nsec - wd_dev_nsec).try_into().unwrap())?;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 判断是否要切换为高精度模式
|
|
|
+ if !cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_VALID_FOR_HRES)
|
|
|
+ && cs_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_IS_CONTINUOUS)
|
|
|
+ && cur_wd_data
|
|
|
+ .flags
|
|
|
+ .contains(ClocksourceFlags::CLOCK_SOURCE_IS_CONTINUOUS)
|
|
|
+ {
|
|
|
+ cs_data
|
|
|
+ .flags
|
|
|
+ .insert(ClocksourceFlags::CLOCK_SOURCE_VALID_FOR_HRES);
|
|
|
+ cs.update_clocksource_data(cs_data)?;
|
|
|
+ // TODO 通知tick机制 切换为高精度模式
|
|
|
+ }
|
|
|
+ let mut cs_watchdog = CLOCKSOUCE_WATCHDOG.lock();
|
|
|
+ // FIXME 需要保证所有cpu时间统一
|
|
|
+ cs_watchdog.timer_expires += WATCHDOG_INTERVAL;
|
|
|
+ //创建定时器执行watchdog
|
|
|
+ let watchdog_func = Box::new(WatchdogTimerFunc {});
|
|
|
+ let watchdog_timer = Timer::new(watchdog_func, cs_watchdog.timer_expires);
|
|
|
+ watchdog_timer.activate();
|
|
|
+ }
|
|
|
+ return Ok(());
|
|
|
+}
|
|
|
+
|
|
|
+/// # watchdog线程的逻辑，执行unstable的后续操作
|
|
|
+pub fn clocksource_watchdog_kthread() {
|
|
|
+ let mut del_vec: Vec<usize> = Vec::new();
|
|
|
+ let mut del_clocks: Vec<Arc<dyn Clocksource>> = Vec::new();
|
|
|
+ let wd_list = &mut WATCHDOG_LIST.lock();
|
|
|
+
|
|
|
+ // 将不稳定的时钟源弹出监视链表
|
|
|
+ for (pos, ele) in wd_list.iter().enumerate() {
|
|
|
+ let data = ele.clocksource_data();
|
|
|
+ if data.flags.contains(ClocksourceFlags::CLOCK_SOURCE_UNSTABLE) {
|
|
|
+ del_vec.push(pos);
|
|
|
+ del_clocks.push(ele.clone());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for pos in del_vec {
|
|
|
+ let mut temp_list = wd_list.split_off(pos);
|
|
|
+ temp_list.pop_front();
|
|
|
+ wd_list.append(&mut temp_list);
|
|
|
+ }
|
|
|
+
|
|
|
+ // 检查是否需要停止watchdog
|
|
|
+ CLOCKSOUCE_WATCHDOG
|
|
|
+ .lock()
|
|
|
+ .clocksource_stop_watchdog(wd_list.len());
|
|
|
+ // 将不稳定的时钟源精度都设置为最低
|
|
|
+ for clock in del_clocks.iter() {
|
|
|
+ clock.clocksource_change_rating(0);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// # 清空所有时钟源的watchdog标志位
|
|
|
+pub fn clocksource_reset_watchdog() {
|
|
|
+ let list_guard = WATCHDOG_LIST.lock();
|
|
|
+ for ele in list_guard.iter() {
|
|
|
+ ele.clocksource_data()
|
|
|
+ .flags
|
|
|
+ .remove(ClocksourceFlags::CLOCK_SOURCE_WATCHDOG);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// # 重启检查器
|
|
|
+pub fn clocksource_resume_watchdog() {
|
|
|
+ clocksource_reset_watchdog();
|
|
|
+}
|
|
|
+
|
|
|
+/// # 根据精度选择最优的时钟源，或者接受用户指定的时间源
|
|
|
+pub fn clocksource_select() {
|
|
|
+ let list_guard = CLOCKSOURCE_LIST.lock();
|
|
|
+ if unsafe { FINISHED_BOOTING.load(Ordering::Relaxed) } || list_guard.is_empty() {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ let mut best = list_guard.front().unwrap().clone();
|
|
|
+ let override_name = OVERRIDE_NAME.lock();
|
|
|
+ // 判断是否有用户空间指定的时间源
|
|
|
+ for ele in list_guard.iter() {
|
|
|
+ if ele.clocksource_data().name.eq(override_name.deref()) {
|
|
|
+ // TODO 判断是否是高精度模式
|
|
|
+ // 暂时不支持高精度模式
|
|
|
+ // 如果是高精度模式，但是时钟源不支持高精度模式的话，就要退出循环
|
|
|
+ best = ele.clone();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // 对比当前的时钟源和记录到最好的时钟源的精度
|
|
|
+ if CUR_CLOCKSOURCE.lock().as_ref().is_some() {
|
|
|
+ // 当前时钟源不为空
|
|
|
+ let cur_clocksource = CUR_CLOCKSOURCE.lock().as_ref().unwrap().clone();
|
|
|
+ let best_name = &best.clocksource_data().name;
|
|
|
+ if cur_clocksource.clocksource_data().name.ne(best_name) {
|
|
|
+ kinfo!("Switching to the clocksource {:?}\n", best_name);
|
|
|
+ drop(cur_clocksource);
|
|
|
+ CUR_CLOCKSOURCE.lock().replace(best);
|
|
|
+ // TODO 通知timerkeeping 切换了时间源
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // 当前时钟源为空
|
|
|
+ CUR_CLOCKSOURCE.lock().replace(best);
|
|
|
+ }
|
|
|
+ kdebug!(" clocksource_select finish");
|
|
|
+}
|
|
|
+
|
|
|
+/// # clocksource模块加载完成
|
|
|
+pub fn clocksource_boot_finish() {
|
|
|
+ let mut cur_clocksource = CUR_CLOCKSOURCE.lock();
|
|
|
+ cur_clocksource.replace(clocksource_default_clock());
|
|
|
+ unsafe { FINISHED_BOOTING.store(true, Ordering::Relaxed) };
|
|
|
+ // 清除不稳定的时钟源
|
|
|
+ clocksource_watchdog_kthread();
|
|
|
+ kdebug!("clocksource_boot_finish");
|
|
|
+}
|
|
|
+
|
|
|
+// ======== 以下为对C的接口 ========
|
|
|
+/// # 完成对clocksource模块的加载
|
|
|
+#[no_mangle]
|
|
|
+pub extern "C" fn rs_clocksource_boot_finish() {
|
|
|
+ clocksource_boot_finish();
|
|
|
+}
|
|
|
+
|
|
|
+/// # 启动watchdog线程的辅助函数
|
|
|
+#[no_mangle]
|
|
|
+pub extern "C" fn rs_clocksource_watchdog_kthread(_data: c_void) -> i32 {
|
|
|
+ clocksource_watchdog_kthread();
|
|
|
+ return 0;
|
|
|
+}
|
houmkh