4.2. 时钟中断

本章代码对应 commit ：30d346bfa2638932118b91bf6a5cc4ad10675a2a

概要

目前我们已经实现了简易的中断机制，同时把 main.rs 变得乱七八糟的。本章我们将：

1. 简化 main.rs ，调整代码结构。

2. 实现时钟中断。

3. 在 rust_trap 中区分中断类型，根据中断类型进行不同的处理。

简化 main.rs

前面四章的内容使得我们的 main.rs 变得异常冗长，代码结构也并不清晰。磨刀不误砍柴工，所以在继续编写 os 之前，我们先来对已有文件进行一些整理：

创建 lang_items.rs ：

use core::panic::PanicInfo;

// This function is called on panic.
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    println!("{}", _info);
    loop {}
}

#[no_mangle]
pub extern fn abort() {
    panic!("abort!");
}

创建 init.rs ：

use crate::interrupt::init as interrupt_init;

global_asm!(include_str!("boot/entry.asm"));

#[no_mangle]
pub extern "C" fn rust_main() -> ! {
    interrupt_init();
    println!("Hello World");
    unsafe{
        asm!("ebreak\n"::::);
    }
    panic!("End of rust_main");
}

把中断相关的代码放入 interrupt.rs ：

global_asm!(include_str!("trap/trap.asm"));

创建 lib.rs ，用于声明属性和库文件：

#![feature(lang_items)]
#![feature(asm)]
#![feature(panic_info_message)]
#![feature(global_asm)]
#![no_std]

#[macro_use]
pub mod io;

mod lang_items;
mod context;
mod interrupt;
mod init;

经过以上的精简，我们的 main.rs 变得十分整洁：

#![no_std]
#![no_main]

#[allow(unused_imports)]
use os;

现在，让我们来实现时钟中断吧！

实现时钟中断响应

step1: 初始化时钟

首先，创建 clock.rs ，并在 lib.rs 中加入 mod clock 。

时钟中断，最重要的就是时钟。在 clock.rs 的第一行加入计时器：

pub static mut TICK: usize = 0;

然后对时钟进行初始化：

use riscv::register::sie;
pub fn init() {
    unsafe{
        TICK = 0;
        sie::set_stimer();
    }
    clock_set_next_event();
    println!("++++setup timer !++++");
}

sie::set_stimer 开启了时钟中断。 clock_set_next_event 的作用是设置下一次时钟中断触发的时间，现在我们来实现他：

static timebase: u64 = 100000;
use bbl::sbi::set_timer;

pub fn clock_set_next_event() {
    set_timer(get_cycle() + timebase);
}

timebase 的数值约为 cpu 频率的 1% ，防止时钟中断占用过多的 cpu 资源。get_cycle 可以获取当前时间，当前时间加上 timebase（两次中断的时间差） 为下一次中断产生的时间，通过 set_timer 设置。

cpu 中有一个专门用于储存时间的 64 位寄存器。由于 system call 的返回值存放于 32 位的 x10 通用寄存器，所以需要分别读取时间的前 32 位和后 32 位：

use riscv::register::{ time, timeh};
fn get_cycle() -> u64 {
    loop {
        let hi = timeh::read();
        let lo = time::read();
        let tmp = timeh::read();
        if (hi == tmp) {
            return ((hi as u64) << 32) | (lo as u64);
        }
    }
}

hi 是时间的高 32 位，lo 是时间的低 32 位。注意到这里并没有之间拼接 hi 和 lo 然后将其返回，而是多了一步 if (hi == tmp) 判断。这是由于在执行完 let lo = time::read() 后，当前时间会改变。尽管时间的前 32 位改变的概率很小，但是仍然需要进行一次判断。

step2: 外设中断初始化

前面看到，时钟中断会用到 sie 寄存器。为了能够正确的产生时钟中断，我们需要先对 sie 寄存器进行初始化：

// in interrupt.rs

use riscv::register::{stvec, sstatus};

#[no_mangle]
pub fn init() {
    extern {
        fn __alltraps();
    }
    unsafe {
        sstatus::set_sie();
        stvec::write(__alltraps as usize, stvec::TrapMode::Direct);
    }
}

现在我们有了两个产生中断的方式：

1. 通过内联汇编使用 ebreak 。

2. 时钟中断。

step3: 响应时钟中断

但是我们的 rust_trap 目前除了会打印 trap! 之外什么都不会。让我们来教他怎么区分中断类型吧：

// in interrupt.rs

use riscv::register::scause::Trap;
use riscv::register::scause::Exception;
use riscv::register::scause::Interrupt;
use crate::clock::{ TICK, clock_set_next_event };

#[no_mangle]
pub extern "C" fn rust_trap(tf: &mut TrapFrame) {
    match tf.scause.cause() {
        Trap::Exception(Exception::Breakpoint) => breakpoint(),
        Trap::Interrupt(Interrupt::SupervisorTimer) => super_timer(),
        _ => panic!("unexpected trap"),
    }
}

fn breakpoint() {
    panic!("a breakpoint set by kernel");
}

fn super_timer() {
    // 响应当前时钟中断的同时，手动设置下一个时钟中断。这一函数调用同时清除了 MTIP ，使得 CPU 知道当前这个中断被正确处理。
    clock_set_next_event();
    unsafe{
        TICK = TICK + 1;
        if TICK % 100 == 0 {
            println!("100 ticks!");
        }
    }
}

tf.scause.cause 表示触发中断的中断类型，这里我们只对两种中断类型进行处理，除此之外的中断则调用 panic! 宏。在触发时钟中断时，我们要做的第一件事就是通过 clock_set_next_event 设置下一次中断时间并告知 cpu ，当前时钟中断已经被正确处理。其余的事情十分简单，只需要把从 clock.rs 中引入的 TICK 加一，表示经过了一个时钟周期。每经过 100 个时钟周期，就在屏幕上打印一些字符。

最后，在 rust_main 中使用 use crate::clock::init as clock_init 引入时钟，修改 rust_main 为：

// in init.rs

use crate::clock::init as clock_init;

#[no_mangle]
pub extern "C" fn rust_main() -> ! {
    interrupt_init();
    clock_init();
    loop {}
}

这样，我们就成功的设置好了时钟中断。编译运行：

++++setup interrupt !++++
++++setup timer !++++
100 ticks!
100 ticks!
...

在 loop {} 之前加上： unsafe { asm!("ebreak"::::"volatile"); } ，编译运行：

++++setup interrupt !++++
++++setup timer !++++
panicked at 'a breakpoint set by kernel', src/interrupt.rs:66:5

预告

本章我们实现了时钟中断，并且能够进行一些简单的中断处理。下一章，我们将学习操作系统中最常见的内存管理方式：分页。为此我们会介绍虚拟内存和物理内存的关系，理解页表的功能以及实现方式。