chk-ch8-part4

Author: wyfcyx

Diff for: .gitignore

@@ -1,3 +1,4 @@
 os/target
 usr/rust/target
+os/src/link_user.S
 Cargo.lock

Diff for: os/Cargo.toml

@@ -10,4 +10,4 @@ edition = "2018"
 riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
 spin = "0.5.2"
 buddy_system_allocator = "0.3"
-
+xmas-elf = "0.6"

Diff for: os/Makefile

@@ -13,6 +13,8 @@ env:
 	rustup component add llvm-tools-preview rustfmt
 	rustup target add $(target)
 
+export USER_IMG = ../usr/rust/target/$(target)/debug/hello_world
+
 kernel:
 	cargo build
 

Diff for: os/build.rs

@@ -0,0 +1,27 @@
+use std::fs::File;
+use std::io::{Result, Write};
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=USER_IMG");
+    if let Ok(user_img) = std::env::var("USER_IMG") {
+        println!("cargo:rerun-if-changed={}", user_img);
+    }
+    gen_link_user_asm().unwrap();
+}
+
+/// Generate assembly file for linking user image
+fn gen_link_user_asm() -> Result<()> {
+    let mut f = File::create("src/link_user.S").unwrap();
+    let user_img = std::env::var("USER_IMG").unwrap();
+
+    writeln!(f, "# generated by build.rs - do not edit")?;
+    writeln!(f, r#"
+    .section .data
+    .global _user_img_start
+    .global _user_img_end
+_user_img_start:
+    .incbin "{}"
+_user_img_end:
+"#, user_img)?;
+    Ok(())
+}

Diff for: os/src/consts.rs

@@ -13,3 +13,6 @@ pub const PHYSICAL_MEMORY_OFFSET: usize = 0xffffffff40000000;
 pub const PAGE_SIZE: usize = 4096;
 
 pub const KERNEL_STACK_SIZE: usize = 0x80000;
+
+pub const USER_STACK_SIZE: usize = 0x80000;
+pub const USER_STACK_OFFSET: usize = 0xffffffff00000000;

Diff for: os/src/context.rs

@@ -46,7 +46,15 @@ impl Context {
         contextContent.tf.x[11] = args[1];
         contextContent.tf.x[12] = args[2];
     }
-
+	
+	pub unsafe fn new_user_thread(
+        entry: usize,
+        ustack_top: usize,
+        kstack_top: usize,
+        satp: usize
+    ) -> Self {
+        ContextContent::new_user_thread(entry, ustack_top, satp).push_at(kstack_top)
+    }
 }
 
 #[repr(C)]
@@ -86,6 +94,28 @@ impl ContextContent {
         content
     }
 
+	fn new_user_thread(
+        entry: usize,
+        ustack_top: usize,
+        satp: usize
+    ) -> Self {
+        ContextContent {
+            ra: __trapret as usize,
+            satp,
+            s: [0; 12],
+            tf: {
+                let mut tf: TrapFrame = unsafe { zeroed() };
+                tf.x[2] = ustack_top;
+                tf.sepc = entry;
+                tf.sstatus = sstatus::read();
+                tf.sstatus.set_spie(true);
+                tf.sstatus.set_sie(false);
+                tf.sstatus.set_spp(sstatus::SPP::User);
+                tf
+            }
+        }
+    }
+
 	unsafe fn push_at(self, stack_top: usize) -> Context {
         let ptr = (stack_top as *mut ContextContent).sub(1);
         *ptr = self;

Diff for: os/src/init.rs

@@ -1,4 +1,5 @@
 global_asm!(include_str!("boot/entry64.asm"));
+global_asm!(include_str!("link_user.S"));
 
 use crate::consts::*;
 use crate::memory::{

Diff for: os/src/interrupt.rs

@@ -40,6 +40,7 @@ pub fn rust_trap(tf: &mut TrapFrame) {
         Trap::Exception(Exception::InstructionPageFault) => page_fault(tf),
         Trap::Exception(Exception::LoadPageFault) => page_fault(tf),
         Trap::Exception(Exception::StorePageFault) => page_fault(tf),
+		Trap::Exception(Exception::UserEnvCall) => syscall(tf),
         _ => panic!("undefined trap!")
     }
 }
@@ -58,6 +59,16 @@ fn page_fault(tf: &mut TrapFrame) {
     panic!("page fault!");
 }
 
+fn syscall(tf: &mut TrapFrame) {
+    tf.sepc += 4;
+    let ret = crate::syscall::syscall(
+        tf.x[17],
+        [tf.x[10], tf.x[11], tf.x[12]],
+        tf
+    );
+    tf.x[10] = ret as usize;
+}
+
 #[inline(always)]
 pub fn disable_and_store() -> usize {
     let sstatus: usize;

Diff for: os/src/lib.rs

@@ -18,3 +18,4 @@ mod timer;
 mod consts;
 mod memory;
 mod process;
+mod syscall;

Diff for: os/src/memory/memory_set/area.rs

@@ -39,4 +39,19 @@ impl MemoryArea {
             attr : attr,
         }
     }
+
+	pub fn page_copy(&self, pt: &mut PageTableImpl, src: usize, length: usize) { 
+        let mut l = length;
+        let mut s = src;
+        for page in PageRange::new(self.start, self.end) {
+            self.handler.page_copy(
+                pt,
+                page,
+                s,
+                if l < PAGE_SIZE { l } else { PAGE_SIZE },
+            );
+            s += PAGE_SIZE;
+            if l >= PAGE_SIZE { l -= PAGE_SIZE; }
+        }
+    }
 }

Diff for: os/src/memory/memory_set/handler.rs

@@ -3,12 +3,14 @@ use super::attr::MemoryAttr;
 use crate::memory::alloc_frame; 
 use core::fmt::Debug;
 use alloc::boxed::Box;
-
+use crate::memory::access_pa_via_va;
+use crate::consts::PAGE_SIZE;
 
 pub trait MemoryHandler: Debug + 'static {
     fn box_clone(&self) -> Box<dyn MemoryHandler>;
     fn map(&self, pt: &mut PageTableImpl, va: usize, attr: &MemoryAttr);
     fn unmap(&self, pt: &mut PageTableImpl, va: usize);
+	fn page_copy(&self, pt: &mut PageTableImpl, va: usize, src: usize, length: usize);
 }
 
 impl Clone for Box<dyn MemoryHandler> {
@@ -32,6 +34,29 @@ impl MemoryHandler for Linear {
     fn unmap(&self, pt: &mut PageTableImpl, va: usize) {
         pt.unmap(va);
     }
+	fn page_copy(&self, pt: &mut PageTableImpl, va: usize, src: usize, length: usize) {
+        let pa = pt.get_entry(va)
+            .expect("get pa error!")
+            .0
+            .addr()
+            .as_usize();
+        assert!(va == access_pa_via_va(pa));
+        assert!(va == pa + self.offset);
+        unsafe {
+            let dst = core::slice::from_raw_parts_mut(
+                va as *mut u8,
+                PAGE_SIZE,
+            );
+            if length > 0 {
+                let src = core::slice::from_raw_parts(
+                    src as *const u8,
+                    PAGE_SIZE,
+                );
+                for i in 0..length { dst[i] = src[i]; }
+            }
+            for i in length..PAGE_SIZE { dst[i] = 0; }
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -55,4 +80,25 @@ impl MemoryHandler for ByFrame {
     fn unmap(&self, pt: &mut PageTableImpl, va: usize) {
         pt.unmap(va);
     }
+	fn page_copy(&self, pt: &mut PageTableImpl, va: usize, src: usize, length: usize) {
+        let pa = pt.get_entry(va)
+            .expect("get pa error!")
+            .0
+            .addr()
+            .as_usize();
+        unsafe {
+            let dst = core::slice::from_raw_parts_mut(
+                access_pa_via_va(pa) as *mut u8,
+                PAGE_SIZE,
+            );
+            if length > 0 {
+                let src = core::slice::from_raw_parts(
+                    src as *const u8,
+                    PAGE_SIZE,
+                );
+                for i in 0..length { dst[i] = src[i]; }
+            }
+            for i in length..PAGE_SIZE { dst[i] = 0; }
+        }
+    }
 }

Diff for: os/src/memory/memory_set/mod.rs

@@ -22,13 +22,17 @@ pub struct MemorySet {
 }
 
 impl MemorySet {
-    pub fn push(&mut self, start: usize, end: usize, attr: MemoryAttr, handler: impl MemoryHandler) {
+    pub fn push(&mut self, start: usize, end: usize, attr: MemoryAttr, handler: impl MemoryHandler, data: Option<(usize, usize)>) {
         assert!(start <= end, "invalid memory area!");
         assert!(self.test_free_area(start, end), "memory area overlap!");
         let area = MemoryArea::new(start, end, Box::new(handler), attr);
         area.map(&mut self.page_table);
+        if let Some((src, length)) = data {
+            area.page_copy(&mut self.page_table, src, length);
+        }
         self.areas.push(area);
-    } 
+
+    }  
     fn test_free_area(&self, start: usize, end: usize) -> bool {
         self.areas
             .iter()
@@ -66,34 +70,42 @@ impl MemorySet {
             etext as usize,
             MemoryAttr::new().set_readonly().set_execute(),
             Linear::new(offset),
+			None,
         );
         // .rodata R
         self.push(
             srodata as usize,
             erodata as usize,
             MemoryAttr::new().set_readonly(),
             Linear::new(offset),
+			None,
         );
         // .data R|W
         self.push(
             sdata as usize,
             edata as usize,
             MemoryAttr::new(),
-            Linear::new(offset)
+            Linear::new(offset),
+			None,
         );
         // .bss R|W
         self.push(
             sbss as usize,
             ebss as usize,
             MemoryAttr::new(),
-            Linear::new(offset)
+            Linear::new(offset),
+			None,
         );
         // 物理内存 R|W
         self.push(
             (end as usize / PAGE_SIZE + 1) * PAGE_SIZE, 
             access_pa_via_va(PHYSICAL_MEMORY_END),
             MemoryAttr::new(),
             Linear::new(offset),
+			None,
         );
     }
+	pub fn token(&self) -> usize {
+		self.page_table.token()
+	}
 }

Diff for: os/src/memory/mod.rs

@@ -57,6 +57,7 @@ pub fn kernel_remap() {
         bootstacktop as usize,
         MemoryAttr::new(),
         Linear::new(PHYSICAL_MEMORY_OFFSET),
+	None,
     );
 
     unsafe {

Diff for: os/src/memory/paging.rs

@@ -21,7 +21,7 @@ use crate::memory::{
     access_pa_via_va
 };
 
-pub struct PageEntry(&'static mut PageTableEntry, Page);
+pub struct PageEntry(pub &'static mut PageTableEntry, Page);
 
 impl PageEntry {
     pub fn update(&mut self) {
@@ -115,7 +115,7 @@ impl PageTableImpl {
         flush.flush();
     }
 
-    fn get_entry(&mut self, va: usize) -> Option<&mut PageEntry> {
+    pub fn get_entry(&mut self, va: usize) -> Option<&mut PageEntry> {
         let page = Page::of_addr(VirtAddr::new(va));
         if let Ok(e) = self.page_table.ref_entry(page.clone()) {
             let e = unsafe { &mut *(e as *mut PageTableEntry) };

Diff for: os/src/process/mod.rs

@@ -9,21 +9,15 @@ use scheduler::RRScheduler;
 use thread_pool::ThreadPool;
 use alloc::boxed::Box;
 
+
 pub type Tid = usize;
 pub type ExitCode = usize;
 
 
 static CPU: Processor = Processor::new();
 
-
-#[no_mangle]
-pub extern "C" fn temp_thread(from_thread: &mut Thread, current_thread: &mut Thread) {
-    println!("I'm leaving soon, but I still want to say: Hello world!");
-    current_thread.switch_to(from_thread);
-}
-
 pub fn init() {
-    let scheduler = RRScheduler::new(1);
+    let scheduler = RRScheduler::new(2);
     let thread_pool = ThreadPool::new(100, Box::new(scheduler));
     let idle = Thread::new_kernel(Processor::idle_main as usize);
     idle.append_initial_arguments([&CPU as *const Processor as usize, 0, 0]);
@@ -36,6 +30,20 @@ pub fn init() {
             thread
         });
     }
+
+	extern "C" {
+        fn _user_img_start();
+        fn _user_img_end();
+    }
+    let data = unsafe {
+        core::slice::from_raw_parts(
+            _user_img_start as *const u8,
+            _user_img_end as usize - _user_img_start as usize,
+        )
+    };
+    let user_thread = unsafe { Thread::new_user(data) };
+    CPU.add_thread(user_thread);
+
     println!("++++ setup process!   ++++");
 }
 
@@ -50,6 +58,7 @@ pub extern "C" fn hello_thread(arg: usize) -> ! {
     loop {}
 }
 
+
 pub fn tick() {
     CPU.tick();
 }