add cargo fmt in Makefile, and exec make fmt

Makefile

@@ -6,3 +6,5 @@ docker:
 
 build_docker: 
 	docker build -t ${DOCKER_NAME} .
+fmt:
+	cd easy-fs; cargo fmt; cd ../easy-fs-fuse cargo fmt; cd ../os ; cargo fmt; cd ../user; cargo fmt; cd ..

README.md

@@ -3,6 +3,8 @@ rCore-Tutorial version 3.5. See the [Documentation in Chinese](https://rcore-os.
 
 rCore-Tutorial API Docs.  See the [API Docs of Ten OSes ](#OS-API-DOCS)
 
+If you don't know  Rust Language and try to learn it, please visit [Rust Learning Resources](https://github.com/rcore-os/rCore/wiki/study-resource-of-system-programming-in-RUST)
+
 Official QQ group number: 735045051
 
 ## news

os/src/boards/qemu.rs

@@ -1,10 +1,10 @@
 pub const CLOCK_FREQ: usize = 12500000;
 
 pub const MMIO: &[(usize, usize)] = &[
-    (0x1000_0000, 0x1000),        // VIRT_UART0 in virt machine
-    (0x1000_1000, 0x1000),        // VIRT_VIRTIO in virt machine 
-    (0x0C00_0000, 0x40_0000),  // VIRT_PLIC in virt machine
-    (0x0010_0000, 0x00_2000),  // VIRT_TEST/RTC  in virt machine
+    (0x1000_0000, 0x1000),    // VIRT_UART0 in virt machine
+    (0x1000_1000, 0x1000),    // VIRT_VIRTIO in virt machine
+    (0x0C00_0000, 0x40_0000), // VIRT_PLIC in virt machine
+    (0x0010_0000, 0x00_2000), // VIRT_TEST/RTC  in virt machine
 ];
 
 pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;
@@ -51,8 +51,8 @@ use core::arch::asm;
 const EXIT_SUCCESS: u32 = 0x5555; // Equals `exit(0)`. qemu successful exit
 
 const EXIT_FAILURE_FLAG: u32 = 0x3333;
-const EXIT_FAILURE: u32 = exit_code_encode(1); // Equals `exit(1)`. qemu failed exit 
-const EXIT_RESET: u32 = 0x7777;       // qemu reset
+const EXIT_FAILURE: u32 = exit_code_encode(1); // Equals `exit(1)`. qemu failed exit
+const EXIT_RESET: u32 = 0x7777; // qemu reset
 
 pub trait QEMUExit {
     /// Exit with specified return code.
@@ -69,7 +69,6 @@ pub trait QEMUExit {
     fn exit_failure(&self) -> !;
 }
 
-
 /// RISCV64 configuration
 pub struct RISCV64 {
     /// Address of the sifive_test mapped device.
@@ -122,6 +121,6 @@ impl QEMUExit for RISCV64 {
     }
 }
 
-const VIRT_TEST: u64 =0x100000;
+const VIRT_TEST: u64 = 0x100000;
 
-pub const QEMU_EXIT_HANDLE: RISCV64 = RISCV64::new(VIRT_TEST); 
+pub const QEMU_EXIT_HANDLE: RISCV64 = RISCV64::new(VIRT_TEST);

user/src/bin/eisenberg.rs

@@ -7,16 +7,18 @@ extern crate user_lib;
 extern crate alloc;
 extern crate core;
 
-use user_lib::{thread_create, waittid, exit, sleep};
 use alloc::vec::Vec;
 use core::sync::atomic::{AtomicUsize, Ordering};
+use user_lib::{exit, sleep, thread_create, waittid};
 
 const N: usize = 2;
 const THREAD_NUM: usize = 10;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum FlagState {
-    Out, Want, In,
+    Out,
+    Want,
+    In,
 }
 
 static mut TURN: usize = 0;
@@ -25,7 +27,7 @@ static mut FLAG: [FlagState; THREAD_NUM] = [FlagState::Out; THREAD_NUM];
 static GUARD: AtomicUsize = AtomicUsize::new(0);
 
 fn critical_test_enter() {
-    assert_eq!(GUARD.fetch_add(1, Ordering::SeqCst), 0); 
+    assert_eq!(GUARD.fetch_add(1, Ordering::SeqCst), 0);
 }
 
 fn critical_test_claim() {
@@ -33,7 +35,7 @@ fn critical_test_claim() {
 }
 
 fn critical_test_exit() {
-    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1); 
+    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1);
 }
 
 fn eisenberg_enter_critical(id: usize) {
@@ -43,7 +45,7 @@ fn eisenberg_enter_critical(id: usize) {
         vstore!(&FLAG[id], FlagState::Want);
         loop {
             /* check if any with higher priority is `Want` or `In` */
-            let mut prior_thread:Option<usize> = None;
+            let mut prior_thread: Option<usize> = None;
             let turn = vload!(&TURN);
             let ring_id = if id < turn { id + THREAD_NUM } else { id };
             // FLAG.iter() may lead to some errors, use for-loop instead
@@ -56,8 +58,11 @@ fn eisenberg_enter_critical(id: usize) {
             if prior_thread.is_none() {
                 break;
             }
-            println!("Thread[{}]: prior thread {} exist, sleep and retry", 
-                      id, prior_thread.unwrap());
+            println!(
+                "Thread[{}]: prior thread {} exist, sleep and retry",
+                id,
+                prior_thread.unwrap()
+            );
             sleep(1);
         }
         /* now tentatively claim the resource */
@@ -86,7 +91,7 @@ fn eisenberg_exit_critical(id: usize) {
     /* find next one who wants to enter and give the turn to it*/
     let mut next = id;
     let ring_id = id + THREAD_NUM;
-    for i in (id+1)..ring_id {
+    for i in (id + 1)..ring_id {
         let idx = i % THREAD_NUM;
         if vload!(&FLAG[idx]) == FlagState::Want {
             next = idx;
@@ -119,7 +124,7 @@ pub fn main() -> i32 {
     let mut v = Vec::new();
     // TODO: really shuffle
     assert_eq!(THREAD_NUM, 10);
-    let shuffle:[usize; 10] = [0, 7, 4, 6, 2, 9, 8, 1, 3, 5];
+    let shuffle: [usize; 10] = [0, 7, 4, 6, 2, 9, 8, 1, 3, 5];
     for i in 0..THREAD_NUM {
         v.push(thread_create(thread_fn as usize, shuffle[i]));
     }
@@ -130,4 +135,4 @@ pub fn main() -> i32 {
     }
     println!("main thread exited.");
     0
-}
+}

user/src/bin/forktree.rs

@@ -4,7 +4,7 @@
 #[macro_use]
 extern crate user_lib;
 
-use user_lib::{exit, fork, getpid, sleep, yield_, wait};
+use user_lib::{exit, fork, getpid, sleep, wait, yield_};
 
 const DEPTH: usize = 4;
 
@@ -28,7 +28,7 @@ fn fork_tree(cur: &str) {
     fork_child(cur, '0');
     fork_child(cur, '1');
     let mut exit_code: i32 = 0;
-    for _ in 0..2{
+    for _ in 0..2 {
         wait(&mut exit_code);
     }
 }
@@ -37,7 +37,7 @@ fn fork_tree(cur: &str) {
 pub fn main() -> i32 {
     fork_tree("");
     let mut exit_code: i32 = 0;
-    for _ in 0..2{
+    for _ in 0..2 {
         wait(&mut exit_code);
     }
     sleep(3000);

user/src/bin/peterson.rs

@@ -8,9 +8,9 @@ extern crate user_lib;
 extern crate alloc;
 extern crate core;
 
-use user_lib::{thread_create, waittid, exit, sleep};
-use core::sync::atomic::{AtomicUsize, Ordering};
 use alloc::vec::Vec;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use user_lib::{exit, sleep, thread_create, waittid};
 const N: usize = 3;
 
 static mut TURN: usize = 0;
@@ -26,7 +26,7 @@ fn critical_test_claim() {
 }
 
 fn critical_test_exit() {
-    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1); 
+    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1);
 }
 
 fn peterson_enter_critical(id: usize, peer_id: usize) {
@@ -75,4 +75,4 @@ pub fn main() -> i32 {
     }
     println!("main thread exited.");
     0
-}
+}

user/src/bin/usertests.rs

@@ -4,7 +4,7 @@
 #[macro_use]
 extern crate user_lib;
 
-// not in SUCC_TESTS & FAIL_TESTS 
+// not in SUCC_TESTS & FAIL_TESTS
 // count_lines, infloop, user_shell, usertests
 
 // item of TESTS : app_name(argv_0), argv_1, argv_2, argv_3, exit_code
@@ -115,7 +115,11 @@ pub fn main() -> i32 {
     let succ_num = run_tests(SUCC_TESTS);
     let err_num = run_tests(FAIL_TESTS);
     if succ_num == SUCC_TESTS.len() as i32 && err_num == FAIL_TESTS.len() as i32 {
-        println!("{} of sueecssed apps, {} of failed apps run correctly. \nUsertests passed!", SUCC_TESTS.len(), FAIL_TESTS.len() );
+        println!(
+            "{} of sueecssed apps, {} of failed apps run correctly. \nUsertests passed!",
+            SUCC_TESTS.len(),
+            FAIL_TESTS.len()
+        );
         return 0;
     }
     if succ_num != SUCC_TESTS.len() as i32 {

user/src/lib.rs

@@ -201,14 +201,14 @@ pub fn condvar_wait(condvar_id: usize, mutex_id: usize) {
 
 #[macro_export]
 macro_rules! vstore {
-    ($var_ref: expr, $value: expr) => { 
+    ($var_ref: expr, $value: expr) => {
         unsafe { core::intrinsics::volatile_store($var_ref as *const _ as _, $value) }
     };
 }
 
 #[macro_export]
 macro_rules! vload {
-    ($var_ref: expr) => { 
+    ($var_ref: expr) => {
         unsafe { core::intrinsics::volatile_load($var_ref as *const _ as _) }
     };
 }
@@ -218,4 +218,4 @@ macro_rules! memory_fence {
     () => {
         core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst)
     };
-}
+}