chk-ch9-part1

Author: wyfcyx

.gitignore

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

os/Cargo.toml

@@ -11,3 +11,9 @@ riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
 spin = "0.5.2"
 buddy_system_allocator = "0.3"
 xmas-elf = "0.6"
+rcore-fs = { git = "https://github.com/rcore-os/rcore-fs", rev = "d8d61190"  }
+rcore-fs-sfs = { git = "https://github.com/rcore-os/rcore-fs", rev = "d8d61190"  }
+
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]

os/Makefile

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

os/src/fs/device.rs

@@ -0,0 +1,37 @@
+use spin::RwLock;
+use rcore_fs::dev::*;
+
+pub struct MemBuf(RwLock<&'static mut [u8]>);
+
+impl MemBuf {
+    pub unsafe fn new(begin: usize, end: usize) -> Self {
+        use core::slice;
+        MemBuf(
+            RwLock::new(
+                slice::from_raw_parts_mut(
+                    begin as *mut u8,
+                    end - begin
+                )
+            )
+        )
+    }
+}
+
+
+impl Device for MemBuf {
+    fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize> {
+        let slice = self.0.read();
+        let len = buf.len().min(slice.len() - offset);
+        buf[..len].copy_from_slice(&slice[offset..offset + len]);
+        Ok(len)
+    }
+    fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize> {
+        let mut slice = self.0.write();
+        let len = buf.len().min(slice.len() - offset);
+        slice[offset..offset + len].copy_from_slice(&buf[..len]);
+        Ok(len)
+    }
+    fn sync(&self) -> Result<()> {
+        Ok(())
+    }
+}

os/src/fs/mod.rs

@@ -0,0 +1,50 @@
+mod device;
+
+use lazy_static::*;
+use rcore_fs::vfs::*;
+use rcore_fs_sfs::SimpleFileSystem;
+use alloc::{ sync::Arc, vec::Vec };
+
+lazy_static! {
+    pub static ref ROOT_INODE: Arc<dyn INode> = {
+        let device = {
+            extern "C" {
+                fn _user_img_start();
+                fn _user_img_end();
+            };
+            let start = _user_img_start as usize;
+            let end = _user_img_end as usize;
+            Arc::new(unsafe { device::MemBuf::new(start, end) })        
+        };
+        let sfs = SimpleFileSystem::open(device).expect("failed to open SFS");
+        sfs.root_inode()
+        
+    };
+}
+
+pub trait INodeExt {
+    fn read_as_vec(&self) -> Result<Vec<u8>>;
+}
+
+impl INodeExt for dyn INode {
+    fn read_as_vec(&self) -> Result<Vec<u8>> {
+        let size = self.metadata()?.size;
+        let mut buf = Vec::with_capacity(size);
+        unsafe {
+            buf.set_len(size);
+        }
+        self.read_at(0, buf.as_mut_slice())?;
+        Ok(buf)
+    }
+}
+
+pub fn init() {
+    println!("available programs in rust/ are:");
+    let mut id = 0;
+    let mut rust_dir = ROOT_INODE.lookup("rust").unwrap();
+    while let Ok(name) = rust_dir.get_entry(id) {
+        id += 1;
+        println!("  {}", name);
+    }
+    println!("++++ setup fs!        ++++")
+}

os/src/init.rs

@@ -18,6 +18,7 @@ pub extern "C" fn rust_main() -> ! {
         ((end as usize - KERNEL_BEGIN_VADDR + KERNEL_BEGIN_PADDR) >> 12) + 1,
         PHYSICAL_MEMORY_END >> 12
     );
+	crate::fs::init();
     crate::process::init();
     crate::timer::init();
     crate::process::run();

os/src/lib.rs

@@ -19,3 +19,4 @@ mod consts;
 mod memory;
 mod process;
 mod syscall;
+mod fs;

os/src/process/mod.rs

@@ -8,7 +8,10 @@ use processor::Processor;
 use scheduler::RRScheduler;
 use thread_pool::ThreadPool;
 use alloc::boxed::Box;
-
+use crate::fs::{
+    ROOT_INODE,
+    INodeExt
+};
 
 pub type Tid = usize;
 pub type ExitCode = usize;
@@ -17,7 +20,7 @@ pub type ExitCode = usize;
 static CPU: Processor = Processor::new();
 
 pub fn init() {
-    let scheduler = RRScheduler::new(2);
+    let scheduler = RRScheduler::new(1);
     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]);
@@ -31,17 +34,12 @@ pub fn init() {
         });
     }
 
-	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) };
+	let data = ROOT_INODE
+        .lookup("rust/hello_world")
+        .unwrap()
+        .read_as_vec()
+        .unwrap();
+    let user_thread = unsafe { Thread::new_user(data.as_slice()) };
     CPU.add_thread(user_thread);
 
     println!("++++ setup process!   ++++");

usr/Makefile

@@ -0,0 +1,31 @@
+target := riscv64imac-unknown-none-elf
+mode := debug
+rust_src_dir := rust/src/bin
+rust_target_dir := rust/target/$(target)/$(mode)
+rust_srcs := $(wildcard $(rust_src_dir)/*.rs)
+rust_targets := $(patsubst $(rust_src_dir)/%.rs, $(rust_target_dir)/%, $(rust_srcs))
+out_dir := build/riscv64
+sfsimg := build/riscv64.img
+.PHONY: rcore-fs-fuse rust user_img clean
+
+
+rcore-fs-fuse:
+ifeq ($(shell which rcore-fs-fuse),)
+	@echo Installing rcore-fs-fuse
+	@cargo install rcore-fs-fuse --git https://github.com/rcore-os/rcore-fs --rev d8d61190
+endif
+
+rust:
+	@cd rust && cargo build
+	@echo targets includes $(rust_targets)
+	@rm -rf $(out_dir)/rust && mkdir -p $(out_dir)/rust
+	@rm -f $(sfsimg)
+	@cp $(rust_targets) $(out_dir)/rust
+
+$(sfsimg): rcore-fs-fuse rust
+	@rcore-fs-fuse --fs sfs $@ $(out_dir) zip 
+
+user_img: $(sfsimg)
+
+clean:
+	@rm -rf build/