現在, 我們可以利用writer 去做事了。 但是,

    let mut writer = Writer {
        column_position: 0,
        color_code: ColorCode::new(Color::Yellow, Color::Black),
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
    };

writer 是個局部物件, 那麼要怎麼可以把它提到static 局域去呢?
在Rust 中, 有一個Crate 叫lazy_static (https://crates.io/crates/lazy_static)

我們看看他能不能把這 writer 變成global

Cargo.toml 加入 :

[dependencies.lazy_static]
version = "1.0"
features = ["spin_no_std"]

然後在vga_buffer.rs 加入

use lazy_static::lazy_static;

lazy_static! {
    pub static ref WRITER: Writer = Writer {
        column_position: 0,
        color_code: ColorCode::new(Color::Yellow, Color::Black),
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
    };
}

在這裡, 我們深入一點看的話, 會有好幾個問題:

  1. 如果 WRITER 是immutable 的話, 要怎麼做write 呢? write 是用到 &mut self
  2. 如果static 是mutable 的話, 這就是一個處處unsafe 的方法了
  3. RefCell 呢? 雖然他是可以不傳mut 而改變內部記憶, 但它不是Sync 的

在Rust 中, 我們有很多的智能指針, Rc, RefCell, Box, RefCellUnsafe...
但萬變不離其宗, 這種體積的非Atomic Object, 一定要用某種方法做出臨界區才可以被多個Thread 讀取的。

說到臨界區, 那麼就回到Mutex, Semaphore 和 Spinlock 了
Rust 中的Mutex 是在std 中的, 那麼我們先用Spinlock 解決這個問題。

Cargo.toml 加入

[dependencies]
spin = "0.5.2"

然後把 WRITER 改成

use spin::Mutex;
//...
    pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
        column_position: 0,
        color_code: ColorCode::new(Color::Yellow, Color::Black),
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
    });

這麼print_something 就可以移除了

在main 中, write! 會同樣發揮效果

#[no_mangle]
pub extern "C" fn _start() -> ! {
    use core::fmt::Write;
    vga_buffer::WRITER.lock().write_str("Hello again").unwrap();
    write!(vga_buffer::WRITER.lock(), ", some numbers: {} {}", 42, 1.337).unwrap();

    loop {}
}

macro

我們有global writer 了, 那麼再進一步把它寫成macro 吧~

我們參考一下Rust 的println! macro 是怎麼寫的: (https://doc.rust-lang.org/nightly/std/macro.println.html)

#[macro_export]
macro_rules! println {
    () => (print!("\n"));
    ($($arg:tt)*) => (print!("{}\n", format_args!($($arg)*)));
}

嗯... 裡面有用到print! (https://doc.rust-lang.org/nightly/std/macro.print.html)

#[macro_export]
macro_rules! print {
    ($($arg:tt)*) => ($crate::io::_print(format_args!($($arg)*)));
}

我們看到一個叫$crate 的變數 (https://doc.rust-lang.org/1.30.0/book/first-edition/macros.html#the-variable-crate)

在Rust 中, 可以利用這個變數去把macro 作跨crate 的重用, 但目前是不保証hygenic 的。

那麼我們依樣畫葫蘆做一個println!print! 吧!

在vga_buffer.rs 加入:

#[macro_export]
macro_rules! print {
    ($($arg:tt)*) => ($crate::vga_buffer::_print(format_args!($($arg)*)));
}

#[macro_export]
macro_rules! println {
    () => ($crate::print!("\n"));
    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
}

#[doc(hidden)]
pub fn _print(args: fmt::Arguments) {
    use core::fmt::Write;
    WRITER.lock().write_fmt(args).unwrap();
}

這樣main 就可以寫成這樣了:

#[no_mangle]
pub extern "C" fn _start() {
    println!("Hello World{}", "!");

    loop {}
}

在main.rs 再加入一個panic handler

#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    println!("{}", info);
    loop {}
}

如果我們在_start() 加入panic!("Some panic message"); 的話, 那麼這句就會被panic 所捕獲然後loop{}
而前後也會出現rust 的罐頭panicinfo.

file