chk-ch8-part1

Author: wyfcyx

Diff for: .gitignore

@@ -1,2 +1,3 @@
 os/target
+usr/rust/target
 Cargo.lock

Diff for: usr/rust/.cargo/config

@@ -0,0 +1,2 @@
+[build]
+target = "riscv64imac-unknown-none-elf"

Diff for: usr/rust/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "user"
+version = "0.1.0"
+authors = ["wyfcyx <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+buddy_system_allocator = "0.3"

Diff for: usr/rust/src/bin/hello_world.rs

@@ -0,0 +1,15 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+#[macro_use]
+extern crate user;
+
+#[no_mangle]
+pub fn main() -> usize {
+    for _ in 0..10 {
+        println!("Hello world! from user mode program!");
+    }
+    0
+}

Diff for: usr/rust/src/bin/model.rs

@@ -0,0 +1,12 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+#[macro_use]
+extern crate user;
+
+#[no_mangle]
+pub fn main() -> usize {
+    0
+}

Diff for: usr/rust/src/io.rs

@@ -0,0 +1,38 @@
+use crate::syscall::sys_write;
+use core::fmt::{self, Write};
+
+pub fn putchar(ch: char) {
+    sys_write(ch as u8);
+}
+
+pub fn puts(s: &str) {
+    for ch in s.chars() {
+        putchar(ch);
+    }
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ({
+        $crate::io::_print(format_args!($($arg)*));
+    });
+}
+
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
+}
+
+struct Stdout;
+
+impl fmt::Write for Stdout {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        puts(s);
+        Ok(())
+    }
+}
+
+pub fn _print(args: fmt::Arguments) {
+    Stdout.write_fmt(args).unwrap();
+}

Diff for: usr/rust/src/lang_items.rs

@@ -0,0 +1,48 @@
+use core::panic::PanicInfo;
+use crate::syscall::sys_exit;
+use core::alloc::Layout;
+
+#[linkage = "weak"]
+#[no_mangle]
+fn main() -> usize {
+    panic!("No main() linked");
+}
+
+use crate::DYNAMIC_ALLOCATOR;
+
+fn init_heap() {
+    const HEAP_SIZE: usize = 0x1000;
+    static mut HEAP: [u8; HEAP_SIZE] = [0; HEAP_SIZE];
+    unsafe {
+        DYNAMIC_ALLOCATOR.lock().init(HEAP.as_ptr() as usize, HEAP_SIZE);
+    }
+}
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    let location = _info.location().unwrap();
+    let message = _info.message().unwrap();
+    println!(
+        "\nPANIC in {} at line {} \n\t{}",
+        location.file(),
+        location.line(),
+        message
+    );
+    loop {}
+}
+
+#[no_mangle]
+pub extern "C" fn _start(_args: isize, _argv: *const u8) -> ! {
+    init_heap();
+    sys_exit(main())
+}
+
+#[no_mangle]
+pub extern fn abort() {
+    panic!("abort");
+}
+
+#[lang = "oom"]
+fn oom(_: Layout) -> ! {
+    panic!("out of memory!");
+}

Diff for: usr/rust/src/lib.rs

@@ -0,0 +1,18 @@
+#![no_std]
+#![feature(asm)]
+#![feature(lang_items)]
+#![feature(panic_info_message)]
+#![feature(linkage)]
+
+extern crate alloc;
+
+#[macro_use]
+pub mod io;
+
+pub mod syscall;
+pub mod lang_items;
+
+use buddy_system_allocator::LockedHeap;
+
+#[global_allocator]
+static DYNAMIC_ALLOCATOR: LockedHeap = LockedHeap::empty();

Diff for: usr/rust/src/syscall.rs

@@ -0,0 +1,35 @@
+enum SyscallId {
+    Write = 64,
+    Exit = 93,
+}
+
+#[inline(always)]
+fn sys_call(
+    syscall_id: SyscallId,
+    arg0: usize,
+    arg1: usize,
+    arg2: usize,
+    arg3: usize,
+) -> i64 {
+    let id = syscall_id as usize;
+    let mut ret: i64;
+    unsafe {
+        asm!(
+            "ecall"
+            : "={x10}"(ret)
+            : "{x17}"(id), "{x10}"(arg0), "{x11}"(arg1), "{x12}"(arg2), "{x13}"(arg3)
+            : "memory"
+            : "volatile"
+        );
+    }
+    ret
+}
+
+pub fn sys_write(ch: u8) -> i64 {
+    sys_call(SyscallId::Write, ch as usize, 0, 0, 0)
+}
+
+pub fn sys_exit(code: usize) -> ! {
+    sys_call(SyscallId::Exit, code, 0, 0, 0);
+    loop {}
+}