实现gettimeofday()系统调用和clocksource+timekeeping子模块

kernel/src/Makefile

@@ -17,7 +17,7 @@ export ASFLAGS := --64
 LD_LIST := head.o
 
 
-kernel_subdirs := common driver process debug arch exception mm smp sched syscall ktest libs ipc io
+kernel_subdirs := common driver process debug arch exception mm smp sched syscall ktest libs ipc io time
 
 
 

kernel/src/arch/x86_64/asm/irqflags.rs

@@ -1,18 +1,18 @@
-use core::{arch::asm, ptr::read_volatile};
+use core::arch::asm;
 
 #[inline]
-pub fn local_irq_save(flags: &mut u64) {
+pub fn local_irq_save() -> usize {
+    let x: usize;
     unsafe {
-        asm!("pushfq", "pop rax", "mov rax, {0}", "cli", out(reg)(*flags),);
+        asm!("pushfq ; pop {} ; cli", out(reg) x, options(nostack));
     }
+    x
 }
 
 #[inline]
-pub fn local_irq_restore(flags: &u64) {
-    let x = unsafe { read_volatile(flags) };
-
+// 恢复先前保存的rflags的值x
+pub fn local_irq_restore(x: usize) {
     unsafe {
-        asm!("push r15",
-            "popfq", in("r15")(x));
+        asm!("push {} ; popfq", in(reg) x, options(nostack));
     }
 }

kernel/src/arch/x86_64/fpu.rs

@@ -79,8 +79,7 @@ impl FpState {
 /// @brief 从用户态进入内核时，保存浮点寄存器，并关闭浮点功能
 pub fn fp_state_save(pcb: &mut process_control_block) {
     // 该过程中不允许中断
-    let mut rflags: u64 = 0;
-    local_irq_save(&mut rflags);
+    let rflags = local_irq_save();
 
     let fp: &mut FpState = if pcb.fp_state == null_mut() {
         let f = Box::leak(Box::new(FpState::default()));
@@ -112,14 +111,13 @@ pub fn fp_state_save(pcb: &mut process_control_block) {
                                 "mov cr4, rax" */
         )
     }
-    local_irq_restore(&rflags);
+    local_irq_restore(rflags);
 }
 
 /// @brief 从内核态返回用户态时，恢复浮点寄存器，并开启浮点功能
 pub fn fp_state_restore(pcb: &mut process_control_block) {
     // 该过程中不允许中断
-    let mut rflags: u64 = 0;
-    local_irq_save(&mut rflags);
+    let rflags = local_irq_save();
 
     if pcb.fp_state == null_mut() {
         panic!("fp_state_restore: fp_state is null. pid={}", pcb.pid);
@@ -143,5 +141,5 @@ pub fn fp_state_restore(pcb: &mut process_control_block) {
     fp.restore();
     fp.clear();
 
-    local_irq_restore(&rflags);
+    local_irq_restore(rflags);
 }

kernel/src/arch/x86_64/interrupt/mod.rs

@@ -48,8 +48,7 @@ impl InterruptArch for X86_64InterruptArch {
 
     unsafe fn save_and_disable_irq() -> IrqFlagsGuard {
         compiler_fence(Ordering::SeqCst);
-        let mut rflags: u64 = 0;
-        local_irq_save(&mut rflags);
+        let rflags = local_irq_save() as u64;
         let flags = IrqFlags::new(rflags);
         let guard = IrqFlagsGuard::new(flags);
         compiler_fence(Ordering::SeqCst);
@@ -58,7 +57,7 @@ impl InterruptArch for X86_64InterruptArch {
 
     unsafe fn restore_irq(flags: IrqFlags) {
         compiler_fence(Ordering::SeqCst);
-        local_irq_restore(&flags.flags());
+        local_irq_restore(flags.flags() as usize);
         compiler_fence(Ordering::SeqCst);
     }
 }

kernel/src/common/cpu.h

@@ -66,4 +66,11 @@ extern struct cpu_core_info_t cpu_core_info[MAX_CPU_NUM];
  *
  * @return uint32_t 当前cpu核心晶振频率
  */
-uint32_t cpu_get_core_crysral_freq();
+uint32_t cpu_get_core_crysral_freq();
+
+/**
+ * @brief 获取处理器的tsc频率（单位：hz）
+ *
+ * @return uint64_t
+ */
+uint64_t cpu_get_tsc_freq();

kernel/src/driver/timers/HPET/HPET.c

@@ -207,12 +207,13 @@ void HPET_enable()
     // kdebug("[HPET0] conf register after modify=%#018lx", ((*(uint64_t *)(HPET_REG_BASE + TIM0_CONF))));
     // kdebug("[HPET1] conf register =%#018lx", ((*(uint64_t *)(HPET_REG_BASE + TIM1_CONF))));
 
+    // 注册中断
+    irq_register(34, &entry, &HPET_handler, 0, &HPET_intr_controller, "HPET0");
+    io_mfence();
+    __write8b(HPET_REG_BASE + GEN_CONF, 3); // 置位旧设备中断路由兼容标志位、定时器组使能标志位
     kinfo("HPET0 enabled.");
 
-    __write8b(HPET_REG_BASE + GEN_CONF, 3); // 置位旧设备中断路由兼容标志位、定时器组使能标志位
     io_mfence();
-    // 注册中断
-    irq_register(34, &entry, &HPET_handler, 0, &HPET_intr_controller, "HPET0");
 }
 
 int HPET_init()

kernel/src/driver/timers/rtc/rtc.rs

@@ -1,5 +1,6 @@
 use crate::{
-    arch::interrupt::{cli, sti},
+    arch::CurrentIrqArch,
+    exception::InterruptArch,
     include::bindings::bindings::{io_in8, io_out8},
     syscall::SystemError,
 };
@@ -33,7 +34,7 @@ impl RtcTime {
     ///@return int 成功则为0
     pub fn get(&mut self) -> Result<i32, SystemError> {
         // 为防止中断请求打断该过程，需要先关中断
-        cli();
+        let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
         //0x0B
         let status_register_b: u8 = read_cmos(0x0B); // 读取状态寄存器B
         let is_24h: bool = if (status_register_b & 0x02) != 0 {
@@ -81,7 +82,7 @@ impl RtcTime {
             self.hour = ((self.hour & 0x7f) + 12) % 24;
         } // 将十二小时制转为24小时
 
-        sti();
+        drop(irq_guard);
 
         return Ok(0);
     }

kernel/src/exception/softirq.rs

@@ -225,15 +225,14 @@ impl Softirq {
     }
 
     pub fn raise_softirq(&self, softirq_num: SoftirqNumber) {
-        let mut flags = 0;
-        local_irq_save(&mut flags);
+        let flags = local_irq_save();
         let processor_id = smp_get_processor_id() as usize;
 
         cpu_pending(processor_id).insert(VecStatus::from(softirq_num));
 
         compiler_fence(Ordering::SeqCst);
 
-        local_irq_restore(&flags);
+        local_irq_restore(flags);
         // kdebug!("raise_softirq exited");
     }
     pub unsafe fn clear_softirq_pending(&self, softirq_num: SoftirqNumber) {

kernel/src/include/bindings/wrapper.h

@@ -46,4 +46,5 @@
 #include <process/process.h>
 #include <sched/sched.h>
 #include <smp/smp.h>
+#include <time/clocksource.h>
 #include <time/sleep.h>

kernel/src/libs/cpu.c

@@ -120,3 +120,12 @@ uint32_t cpu_get_core_crysral_freq()
 
     return c;
 }
+/**
+ * @brief 获取处理器的tsc频率（单位：hz）
+ *
+ * @return uint64_t
+ */
+uint64_t cpu_get_tsc_freq()
+{
+    return Cpu_tsc_freq;
+}

kernel/src/libs/spinlock.rs

@@ -14,7 +14,7 @@ use crate::syscall::SystemError;
 /// @brief 保存中断状态到flags中，关闭中断，并对自旋锁加锁
 #[inline]
 pub fn spin_lock_irqsave(lock: *mut spinlock_t, flags: &mut u64) {
-    local_irq_save(flags);
+    *flags = local_irq_save() as u64;
     unsafe {
         spin_lock(lock);
     }
@@ -27,7 +27,7 @@ pub fn spin_unlock_irqrestore(lock: *mut spinlock_t, flags: &u64) {
         spin_unlock(lock);
     }
     // kdebug!("123");
-    local_irq_restore(flags);
+    local_irq_restore(*flags as usize);
 }
 
 /// 判断一个自旋锁是否已经被加锁
@@ -130,26 +130,26 @@ impl RawSpinlock {
 
     /// @brief 保存中断状态到flags中，关闭中断，并对自旋锁加锁
     pub fn lock_irqsave(&self, flags: &mut u64) {
-        local_irq_save(flags);
+        *flags = local_irq_save() as u64;
         self.lock();
     }
 
     /// @brief 恢复rflags以及中断状态并解锁自旋锁
     pub fn unlock_irqrestore(&self, flags: &u64) {
         self.unlock();
-        local_irq_restore(flags);
+        local_irq_restore(*flags as usize);
     }
 
     /// @brief 尝试保存中断状态到flags中，关闭中断，并对自旋锁加锁
     /// @return 加锁成功->true
     ///         加锁失败->false
     #[inline(always)]
     pub fn try_lock_irqsave(&self, flags: &mut u64) -> bool {
-        local_irq_save(flags);
+        *flags = local_irq_save() as u64;
         if self.try_lock() {
             return true;
         }
-        local_irq_restore(flags);
+        local_irq_restore(*flags as usize);
         return false;
     }
 }

kernel/src/main.c

@@ -51,7 +51,8 @@ void reload_gdt()
     gdtp.size = bsp_gdt_size - 1;
     gdtp.gdt_vaddr = (ul)phys_2_virt((ul)&GDT_Table);
 
-    asm volatile("lgdt (%0)   \n\t" ::"r"(&gdtp) : "memory");
+    asm volatile("lgdt (%0)   \n\t" ::"r"(&gdtp)
+                 : "memory");
 }
 
 void reload_idt()
@@ -62,7 +63,8 @@ void reload_idt()
     // kdebug("gdtvaddr=%#018lx", p.gdt_vaddr);
     // kdebug("gdt size=%d", p.size);
 
-    asm volatile("lidt (%0)   \n\t" ::"r"(&idtp) : "memory");
+    asm volatile("lidt (%0)   \n\t" ::"r"(&idtp)
+                 : "memory");
 }
 
 // 初始化系统各模块
@@ -124,23 +126,29 @@ void system_initialize()
 
     current_pcb->cpu_id = 0;
     current_pcb->preempt_count = 0;
-    // 先初始化系统调用模块
+
     syscall_init();
 
     io_mfence();
-    //  再初始化进程模块。顺序不能调转
-    // sched_init();
+
+    rs_timekeeping_init();
     io_mfence();
 
     rs_timer_init();
+    io_mfence();
+
+    rs_jiffies_init();
+    io_mfence();
+
+    rs_clocksource_boot_finish();
     // 这里必须加内存屏障，否则会出错
     io_mfence();
     smp_init();
     io_mfence();
 
     vfs_init();
     rs_tty_init();
-    
+
     cpu_init();
     ps2_keyboard_init();
     // tty_init();
@@ -160,7 +168,7 @@ void system_initialize()
     io_mfence();
     // current_pcb->preempt_count = 0;
     // kdebug("cpu_get_core_crysral_freq()=%ld", cpu_get_core_crysral_freq());
-    
+
     process_init();
     // 启用double buffer
     // scm_enable_double_buffer();  // 因为时序问题, 该函数调用被移到 initial_kernel_thread
@@ -173,7 +181,7 @@ void system_initialize()
 
     apic_timer_init();
     io_mfence();
-   
+
     // 这里不能删除，否则在O1会报错
     // while (1)
     //     pause();

kernel/src/net/net_core.rs

@@ -15,21 +15,24 @@ use super::socket::{SOCKET_SET, SOCKET_WAITQUEUE};
 /// The network poll function, which will be called by timer.
 ///
 /// The main purpose of this function is to poll all network interfaces.
-struct NetWorkPollFunc();
+#[derive(Debug)]
+struct NetWorkPollFunc;
+
 impl TimerFunction for NetWorkPollFunc {
-    fn run(&mut self) {
+    fn run(&mut self) -> Result<(), SystemError> {
         poll_ifaces_try_lock(10).ok();
         let next_time = next_n_ms_timer_jiffies(10);
-        let timer = Timer::new(Box::new(NetWorkPollFunc()), next_time);
+        let timer = Timer::new(Box::new(NetWorkPollFunc), next_time);
         timer.activate();
+        return Ok(());
     }
 }
 
 pub fn net_init() -> Result<(), SystemError> {
     dhcp_query()?;
     // Init poll timer function
     let next_time = next_n_ms_timer_jiffies(5);
-    let timer = Timer::new(Box::new(NetWorkPollFunc()), next_time);
+    let timer = Timer::new(Box::new(NetWorkPollFunc), next_time);
     timer.activate();
     return Ok(());
 }

kernel/src/process/process.c

@@ -859,7 +859,8 @@ void process_exit_thread(struct process_control_block *pcb)
 int process_release_pcb(struct process_control_block *pcb)
 {
     // 释放子进程的页表
-    process_exit_mm(pcb);
+    // BUG 暂时注释process_exit_mm
+    // process_exit_mm(pcb);
     if ((pcb->flags & PF_KTHREAD)) // 释放内核线程的worker private结构体
         free_kthread_struct(pcb);