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 ..

os/src/boards/k210.rs

@@ -20,4 +20,3 @@ pub const MMIO: &[(usize, usize)] = &[
 ];
 
 pub type BlockDeviceImpl = crate::drivers::block::SDCardWrapper;
-

os/src/boards/qemu.rs

@@ -3,4 +3,3 @@ pub const CLOCK_FREQ: usize = 12500000;
 pub const MMIO: &[(usize, usize)] = &[(0x10001000, 0x1000)];
 
 pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;
-

os/src/config.rs

@@ -11,4 +11,3 @@ pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
 pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE;
 
 pub use crate::board::{CLOCK_FREQ, MMIO};
-

os/src/drivers/block/mod.rs

@@ -1,13 +1,13 @@
 mod sdcard;
 mod virtio_blk;
 
-pub use virtio_blk::VirtIOBlock;
 pub use sdcard::SDCardWrapper;
+pub use virtio_blk::VirtIOBlock;
 
+use crate::board::BlockDeviceImpl;
 use alloc::sync::Arc;
 use easy_fs::BlockDevice;
 use lazy_static::*;
-use crate::board::BlockDeviceImpl;
 
 lazy_static! {
     pub static ref BLOCK_DEVICE: Arc<dyn BlockDevice> = Arc::new(BlockDeviceImpl::new());

os/src/fs/stdio.rs

@@ -1,7 +1,7 @@
 use super::File;
 use crate::mm::UserBuffer;
 use crate::sbi::console_getchar;
-use crate::task::{suspend_current_and_run_next,current_add_signal,SignalFlags,};
+use crate::task::{current_add_signal, suspend_current_and_run_next, SignalFlags};
 
 pub struct Stdin;
 

os/src/mm/memory_set.rs

@@ -373,26 +373,20 @@ pub fn remap_test() {
     let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
     let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
     let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_text.floor())
-            .unwrap()
-            .writable(),
-    );
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_rodata.floor())
-            .unwrap()
-            .writable(),
-    );
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_data.floor())
-            .unwrap()
-            .executable(),
-    );
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_text.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_rodata.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_data.floor())
+        .unwrap()
+        .executable(),);
     println!("remap_test passed!");
 }

os/src/syscall/mod.rs

@@ -35,7 +35,11 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
         SYSCALL_EXIT => sys_exit(args[0] as i32),
         SYSCALL_YIELD => sys_yield(),
         SYSCALL_KILL => sys_kill(args[0], args[1] as i32),
-        SYSCALL_SIGACTION => sys_sigaction(args[0] as i32, args[1] as *const SignalAction, args[2] as *mut SignalAction),
+        SYSCALL_SIGACTION => sys_sigaction(
+            args[0] as i32,
+            args[1] as *const SignalAction,
+            args[2] as *mut SignalAction,
+        ),
         SYSCALL_SIGPROCMASK => sys_sigprocmask(args[0] as u32),
         SYSCALL_SIGRETURN => sys_sigretrun(),
         SYSCALL_GET_TIME => sys_get_time(),

os/src/syscall/process.rs

@@ -2,7 +2,7 @@ use crate::fs::{open_file, OpenFlags};
 use crate::mm::{translated_ref, translated_refmut, translated_str};
 use crate::task::{
     add_task, current_task, current_user_token, exit_current_and_run_next, pid2task,
-    suspend_current_and_run_next, SignalFlags, SignalAction, MAX_SIG,
+    suspend_current_and_run_next, SignalAction, SignalFlags, MAX_SIG,
 };
 use crate::timer::get_time_ms;
 use alloc::string::String;
@@ -151,15 +151,22 @@ pub fn sys_sigretrun() -> isize {
 }
 
 fn check_sigaction_error(signal: SignalFlags, action: usize, old_action: usize) -> bool {
-    if action == 0 || old_action == 0 || signal == SignalFlags::SIGKILL ||
-        signal == SignalFlags::SIGSTOP {
+    if action == 0
+        || old_action == 0
+        || signal == SignalFlags::SIGKILL
+        || signal == SignalFlags::SIGSTOP
+    {
         true
     } else {
         false
     }
 }
 
-pub fn sys_sigaction(signum: i32, action: *const SignalAction, old_action: *mut SignalAction) -> isize {
+pub fn sys_sigaction(
+    signum: i32,
+    action: *const SignalAction,
+    old_action: *mut SignalAction,
+) -> isize {
     let token = current_user_token();
     if let Some(task) = current_task() {
         let mut inner = task.inner_exclusive_access();

os/src/task/action.rs

@@ -1,19 +1,18 @@
 use crate::task::{SignalFlags, MAX_SIG};
 
-
 /// Action for a signal
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
 pub struct SignalAction {
-    pub handler: usize, 
-    pub mask: SignalFlags
+    pub handler: usize,
+    pub mask: SignalFlags,
 }
 
 impl Default for SignalAction {
     fn default() -> Self {
         Self {
             handler: 0,
-            mask: SignalFlags::from_bits(40).unwrap()
+            mask: SignalFlags::from_bits(40).unwrap(),
         }
     }
 }

os/src/task/task.rs

@@ -1,5 +1,5 @@
-use super::{TaskContext, SignalActions};
 use super::{pid_alloc, KernelStack, PidHandle, SignalFlags};
+use super::{SignalActions, TaskContext};
 use crate::config::TRAP_CONTEXT;
 use crate::fs::{File, Stdin, Stdout};
 use crate::mm::{translated_refmut, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
@@ -39,7 +39,7 @@ pub struct TaskControlBlockInner {
     pub killed: bool,
     // if the task is frozen by a signal
     pub frozen: bool,
-    pub trap_ctx_backup: Option<TrapContext>
+    pub trap_ctx_backup: Option<TrapContext>,
 }
 
 impl TaskControlBlockInner {
@@ -107,7 +107,7 @@ impl TaskControlBlock {
                     signal_actions: SignalActions::default(),
                     killed: false,
                     frozen: false,
-                    trap_ctx_backup: None
+                    trap_ctx_backup: None,
                 })
             },
         };
@@ -216,7 +216,7 @@ impl TaskControlBlock {
                     signal_actions: parent_inner.signal_actions.clone(),
                     killed: false,
                     frozen: false,
-                    trap_ctx_backup: None
+                    trap_ctx_backup: None,
                 })
             },
         });

os/src/trap/mod.rs

@@ -4,7 +4,7 @@ use crate::config::{TRAMPOLINE, TRAP_CONTEXT};
 use crate::syscall::syscall;
 use crate::task::{
     check_signals_error_of_current, current_add_signal, current_trap_cx, current_user_token,
-    exit_current_and_run_next, suspend_current_and_run_next, SignalFlags, handle_signals,
+    exit_current_and_run_next, handle_signals, suspend_current_and_run_next, SignalFlags,
 };
 use crate::timer::set_next_trigger;
 use core::arch::{asm, global_asm};

user/src/bin/getchar.rs

@@ -18,9 +18,9 @@ pub fn main() -> i32 {
         let c = getchar();
 
         println!("Got Char  {}", c);
-        if c == LF || c==CR  {
+        if c == LF || c == CR {
             println!("exit(0)");
             return 0;
         }
     }
-}
+}

user/src/bin/sig_ctrlc.rs

@@ -5,8 +5,8 @@ extern crate alloc;
 
 #[macro_use]
 extern crate user_lib;
-use user_lib::*;
 use user_lib::console::getchar;
+use user_lib::*;
 
 const LF: u8 = 0x0au8;
 const CR: u8 = 0x0du8;
@@ -33,7 +33,7 @@ pub fn main() -> i32 {
         let c = getchar();
 
         println!("Got Char  {}", c);
-        if c == LF || c==CR  {
+        if c == LF || c == CR {
             return 0;
         }
     }

user/src/bin/sig_simple2.rs

@@ -4,7 +4,10 @@
 #[macro_use]
 extern crate user_lib;
 
-use user_lib::{sigaction, sigprocmask, SignalAction, SignalFlags, fork, exit, waitpid, kill, getpid, sleep, sigreturn};
+use user_lib::{
+    exit, fork, getpid, kill, sigaction, sigprocmask, sigreturn, sleep, waitpid, SignalAction,
+    SignalFlags,
+};
 
 fn func() {
     println!("user_sig_test succsess");
@@ -14,7 +17,7 @@ fn func() {
 #[no_mangle]
 pub fn main() -> i32 {
     let pid = fork();
-    if pid==0{
+    if pid == 0 {
         let mut new = SignalAction::default();
         let old = SignalAction::default();
         new.handler = func as usize;
@@ -26,10 +29,10 @@ pub fn main() -> i32 {
         sleep(1000);
         println!("signal_simple2: child done");
         exit(0);
-    } else if pid >0 {
+    } else if pid > 0 {
         println!("signal_simple2: parent kill child");
         sleep(500);
-        if kill(pid as usize, 1<<10) < 0 {
+        if kill(pid as usize, 1 << 10) < 0 {
             println!("Kill failed!");
             exit(1);
         }
@@ -39,6 +42,6 @@ pub fn main() -> i32 {
         println!("signal_simple2: parent Done");
         exit(0);
     }
-   
+
     0
 }

user/src/bin/sig_tests.rs

@@ -47,8 +47,8 @@ fn user_sig_test_kill() {
 }
 
 fn user_sig_test_multiprocsignals() {
-    let pid= fork();
-    if pid == 0{
+    let pid = fork();
+    if pid == 0 {
         let mut new = SignalAction::default();
         let old = SignalAction::default();
         new.handler = func as usize;
@@ -87,14 +87,14 @@ fn user_sig_test_restore() {
 
 fn kernel_sig_test_ignore() {
     sigprocmask(SignalFlags::SIGSTOP.bits() as u32);
-    if kill(getpid() as usize, SignalFlags::SIGSTOP.bits()) < 0{
+    if kill(getpid() as usize, SignalFlags::SIGSTOP.bits()) < 0 {
         println!("kill faild\n");
         exit(-1);
     }
 }
 
 fn kernel_sig_test_stop_cont() {
-    let pid= fork();
+    let pid = fork();
     if pid == 0 {
         kill(getpid() as usize, SignalFlags::SIGSTOP.bits());
         sleep(1000);
@@ -134,8 +134,8 @@ fn final_sig_test() {
     let old2 = SignalAction::default();
     new2.handler = func3 as usize;
 
-    let pid= fork();
-    if pid == 0{
+    let pid = fork();
+    if pid == 0 {
         if sigaction(SIGUSR1, &new, &old) < 0 {
             panic!("Sigaction failed!");
         }
@@ -157,7 +157,6 @@ fn final_sig_test() {
     }
 }
 
-
 fn run(f: fn()) -> bool {
     let pid = fork();
     if pid == 0 {
@@ -180,12 +179,18 @@ pub fn main() -> i32 {
     let tests: [(fn(), &str); 8] = [
         (user_sig_test_failsignum, "user_sig_test_failsignum"),
         (user_sig_test_kill, "user_sig_test_kill"),
-        (user_sig_test_multiprocsignals, "user_sig_test_multiprocsignals"),
+        (
+            user_sig_test_multiprocsignals,
+            "user_sig_test_multiprocsignals",
+        ),
         (user_sig_test_restore, "user_sig_test_restore"),
         (kernel_sig_test_ignore, "kernel_sig_test_ignore"),
         (kernel_sig_test_stop_cont, "kernel_sig_test_stop_cont"),
-        (kernel_sig_test_failignorekill, "kernel_sig_test_failignorekill"),
-        (final_sig_test, "final_sig_test")
+        (
+            kernel_sig_test_failignorekill,
+            "kernel_sig_test_failignorekill",
+        ),
+        (final_sig_test, "final_sig_test"),
     ];
     let mut fail_num = 0;
     for test in tests {

user/src/lib.rs

@@ -143,51 +143,51 @@ pub fn sleep(period_ms: usize) {
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
 pub struct SignalAction {
-    pub handler: usize, 
-    pub mask: SignalFlags
+    pub handler: usize,
+    pub mask: SignalFlags,
 }
 
 impl Default for SignalAction {
     fn default() -> Self {
         Self {
             handler: 0,
-            mask: SignalFlags::empty()
+            mask: SignalFlags::empty(),
         }
     }
 }
 
-pub const SIGDEF :i32 = 0; // Default signal handling
-pub const SIGHUP :i32 = 1;
-pub const SIGINT :i32 = 2;
-pub const SIGQUIT :i32 = 3;
-pub const SIGILL :i32 = 4;
-pub const SIGTRAP :i32 = 5;
-pub const SIGABRT :i32 = 6;
-pub const SIGBUS :i32 = 7;
-pub const SIGFPE :i32 = 8;
-pub const SIGKILL :i32 = 9;
-pub const SIGUSR1 :i32 = 10;
-pub const SIGSEGV :i32 = 11;
-pub const SIGUSR2 :i32 = 12;
-pub const SIGPIPE :i32 = 13;
-pub const SIGALRM :i32 = 14;
-pub const SIGTERM :i32 = 15;
-pub const SIGSTKFLT :i32 = 16;
-pub const SIGCHLD :i32 = 17;
-pub const SIGCONT :i32 = 18;
-pub const SIGSTOP :i32 = 19;
-pub const SIGTSTP :i32 = 20;
-pub const SIGTTIN :i32 = 21;
-pub const SIGTTOU :i32 = 22;
-pub const SIGURG :i32 = 23;
-pub const SIGXCPU :i32 = 24;
-pub const SIGXFSZ :i32 = 25;
-pub const SIGVTALRM :i32 = 26;
-pub const SIGPROF :i32 = 27;
-pub const SIGWINCH :i32 = 28;
-pub const SIGIO :i32 = 29;
-pub const SIGPWR :i32 = 30;
-pub const SIGSYS :i32 = 31;
+pub const SIGDEF: i32 = 0; // Default signal handling
+pub const SIGHUP: i32 = 1;
+pub const SIGINT: i32 = 2;
+pub const SIGQUIT: i32 = 3;
+pub const SIGILL: i32 = 4;
+pub const SIGTRAP: i32 = 5;
+pub const SIGABRT: i32 = 6;
+pub const SIGBUS: i32 = 7;
+pub const SIGFPE: i32 = 8;
+pub const SIGKILL: i32 = 9;
+pub const SIGUSR1: i32 = 10;
+pub const SIGSEGV: i32 = 11;
+pub const SIGUSR2: i32 = 12;
+pub const SIGPIPE: i32 = 13;
+pub const SIGALRM: i32 = 14;
+pub const SIGTERM: i32 = 15;
+pub const SIGSTKFLT: i32 = 16;
+pub const SIGCHLD: i32 = 17;
+pub const SIGCONT: i32 = 18;
+pub const SIGSTOP: i32 = 19;
+pub const SIGTSTP: i32 = 20;
+pub const SIGTTIN: i32 = 21;
+pub const SIGTTOU: i32 = 22;
+pub const SIGURG: i32 = 23;
+pub const SIGXCPU: i32 = 24;
+pub const SIGXFSZ: i32 = 25;
+pub const SIGVTALRM: i32 = 26;
+pub const SIGPROF: i32 = 27;
+pub const SIGWINCH: i32 = 28;
+pub const SIGIO: i32 = 29;
+pub const SIGPWR: i32 = 30;
+pub const SIGSYS: i32 = 31;
 
 bitflags! {
     pub struct SignalFlags: i32 {
@@ -230,7 +230,11 @@ pub fn kill(pid: usize, signal: i32) -> isize {
     sys_kill(pid, signal)
 }
 
-pub fn sigaction(signum: i32, action: *const SignalAction, old_action: *const SignalAction) -> isize {
+pub fn sigaction(
+    signum: i32,
+    action: *const SignalAction,
+    old_action: *const SignalAction,
+) -> isize {
     sys_sigaction(signum, action, old_action)
 }
 

user/src/syscall.rs

@@ -97,8 +97,15 @@ pub fn sys_waitpid(pid: isize, exit_code: *mut i32) -> isize {
     syscall(SYSCALL_WAITPID, [pid as usize, exit_code as usize, 0])
 }
 
-pub fn sys_sigaction(signum: i32, action: *const SignalAction, old_action: *const SignalAction) -> isize {
-    syscall(SYSCALL_SIGACTION, [signum as usize , action as usize, old_action as usize])
+pub fn sys_sigaction(
+    signum: i32,
+    action: *const SignalAction,
+    old_action: *const SignalAction,
+) -> isize {
+    syscall(
+        SYSCALL_SIGACTION,
+        [signum as usize, action as usize, old_action as usize],
+    )
 }
 
 pub fn sys_sigprocmask(mask: u32) -> isize {