refactor: replace asm! with llvm_asm! and fix some clippy issue

Author: Rustin170506

Diff for: os/src/context.rs

@@ -20,7 +20,7 @@ impl Context {
     #[naked]
     #[inline(never)]
     pub unsafe extern "C" fn switch(&mut self, target: &mut Context) {
-        asm!(include_str!("process/switch.asm") :::: "volatile");
+        llvm_asm!(include_str!("process/switch.asm") :::: "volatile");
     }
 
     pub fn null() -> Context {
@@ -32,10 +32,10 @@ impl Context {
     }
 
     pub unsafe fn append_initial_arguments(&self, args: [usize; 3]) {
-        let contextContent = &mut *(self.content_addr as *mut ContextContent);
-        contextContent.tf.x[10] = args[0];
-        contextContent.tf.x[11] = args[1];
-        contextContent.tf.x[12] = args[2];
+        let context_content = &mut *(self.content_addr as *mut ContextContent);
+        context_content.tf.x[10] = args[0];
+        context_content.tf.x[11] = args[1];
+        context_content.tf.x[12] = args[2];
     }
 
     pub unsafe fn new_user_thread(
@@ -62,7 +62,7 @@ extern "C" {
 
 impl ContextContent {
     fn new_kernel_thread(entry: usize, kstack_top: usize, satp: usize) -> ContextContent {
-        let mut content = ContextContent {
+        let content = ContextContent {
             ra: __trapret as usize,
             satp,
             s: [0; 12],

Diff for: os/src/fs/file.rs

@@ -1,9 +1,8 @@
+use crate::fs::ROOT_INODE;
 use alloc::sync::Arc;
 use rcore_fs::vfs::INode;
-use rcore_fs_sfs::INodeImpl;
-use crate::fs::ROOT_INODE;
 
-#[derive(Copy,Clone,Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum FileDescriptorType {
     FD_NONE,
     FD_INODE,
@@ -29,14 +28,30 @@ impl File {
             offset: 0,
         }
     }
-    pub fn set_readable(&mut self, v: bool) { self.readable = v; }
-    pub fn set_writable(&mut self, v: bool) { self.writable = v; }
-    pub fn get_readable(&self) -> bool { self.readable }
-    pub fn get_writable(&self) -> bool { self.writable }
-    pub fn set_fdtype(&mut self, t: FileDescriptorType) { self.fdtype = t; }
-    pub fn get_fdtype(&self) -> FileDescriptorType { self.fdtype }
-    pub fn set_offset(&mut self, o: usize) { self.offset = o; }
-    pub fn get_offset(&self) -> usize { self.offset }
+    pub fn set_readable(&mut self, v: bool) {
+        self.readable = v;
+    }
+    pub fn set_writable(&mut self, v: bool) {
+        self.writable = v;
+    }
+    pub fn get_readable(&self) -> bool {
+        self.readable
+    }
+    pub fn get_writable(&self) -> bool {
+        self.writable
+    }
+    pub fn set_fdtype(&mut self, t: FileDescriptorType) {
+        self.fdtype = t;
+    }
+    pub fn get_fdtype(&self) -> FileDescriptorType {
+        self.fdtype
+    }
+    pub fn set_offset(&mut self, o: usize) {
+        self.offset = o;
+    }
+    pub fn get_offset(&self) -> usize {
+        self.offset
+    }
 
     pub fn open_file(&mut self, path: &'static str, flags: i32) {
         self.set_fdtype(FileDescriptorType::FD_INODE);

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

@@ -1,6 +1,6 @@
 mod device;
-pub mod stdio;
 pub mod file;
+pub mod stdio;
 
 use alloc::{sync::Arc, vec::Vec};
 use lazy_static::*;
@@ -42,7 +42,7 @@ impl INodeExt for dyn INode {
 pub fn init() {
     println!("available programs in rust/ are:");
     let mut id = 0;
-    let mut rust_dir = ROOT_INODE.lookup("rust").unwrap();
+    let rust_dir = ROOT_INODE.lookup("rust").unwrap();
     while let Ok(name) = rust_dir.get_entry(id) {
         id += 1;
         println!("  {}", name);

Diff for: os/src/fs/stdio.rs

@@ -1,4 +1,3 @@
-use crate::process;
 use crate::sync::condvar::*;
 use alloc::{collections::VecDeque, sync::Arc};
 use lazy_static::*;

Diff for: os/src/init.rs

@@ -2,7 +2,6 @@ global_asm!(include_str!("boot/entry64.asm"));
 global_asm!(include_str!("link_user.S"));
 
 use crate::consts::*;
-use crate::memory::{alloc_frame, dealloc_frame};
 
 #[no_mangle]
 pub extern "C" fn rust_main() -> ! {

Diff for: os/src/interrupt.rs

@@ -1,11 +1,11 @@
 use crate::context::TrapFrame;
 use crate::memory::access_pa_via_va;
 use crate::process::tick;
-use crate::timer::{clock_set_next_event, TICKS};
+use crate::timer::clock_set_next_event;
 use riscv::register::sie;
 use riscv::register::{
-    scause::{self, Exception, Interrupt, Trap},
-    sepc, sscratch, sstatus, stvec,
+    scause::{Exception, Interrupt, Trap},
+    sscratch, sstatus, stvec,
 };
 
 global_asm!(include_str!("trap/trap.asm"));
@@ -89,7 +89,7 @@ fn external() {
 fn try_serial() -> bool {
     match super::io::getchar_option() {
         Some(ch) => {
-            if (ch == '\r') {
+            if ch == '\r' {
                 crate::fs::stdio::STDIN.push('\n');
             } else {
                 crate::fs::stdio::STDIN.push(ch);
@@ -104,21 +104,21 @@ fn try_serial() -> bool {
 pub fn disable_and_store() -> usize {
     let sstatus: usize;
     unsafe {
-        asm!("csrci sstatus, 1 << 1" : "=r"(sstatus) ::: "volatile");
+        llvm_asm!("csrci sstatus, 1 << 1" : "=r"(sstatus) ::: "volatile");
     }
     sstatus
 }
 
 #[inline(always)]
 pub fn restore(flags: usize) {
     unsafe {
-        asm!("csrs sstatus, $0" :: "r"(flags) :: "volatile");
+        llvm_asm!("csrs sstatus, $0" :: "r"(flags) :: "volatile");
     }
 }
 
 #[inline(always)]
 pub fn enable_and_wfi() {
     unsafe {
-        asm!("csrsi sstatus, 1 << 1; wfi" :::: "volatile");
+        llvm_asm!("csrsi sstatus, 1 << 1; wfi" :::: "volatile");
     }
 }

Diff for: os/src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(asm)]
+#![feature(llvm_asm)]
 #![feature(global_asm)]
 #![feature(alloc_error_handler)]
 #![feature(naked_functions)]

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

@@ -16,10 +16,10 @@ impl SegmentTreeAllocator {
         while self.m < self.n + 2 {
             self.m = self.m << 1;
         }
-        for i in (1..(self.m << 1)) {
+        for i in 1..(self.m << 1) {
             self.a[i] = 1;
         }
-        for i in (1..self.n) {
+        for i in 1..self.n {
             self.a[self.m + i] = 0;
         }
         for i in (1..self.m).rev() {

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

@@ -6,7 +6,7 @@ use crate::consts::*;
 use buddy_system_allocator::LockedHeap;
 use frame_allocator::SEGMENT_TREE_ALLOCATOR as FRAME_ALLOCATOR;
 use memory_set::{attr::MemoryAttr, handler::Linear, MemorySet};
-use riscv::addr::{Frame, Page, PhysAddr, VirtAddr};
+use riscv::addr::Frame;
 use riscv::register::sstatus;
 
 pub fn init(l: usize, r: usize) {

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

@@ -135,7 +135,7 @@ impl PageTableImpl {
     }
 
     unsafe fn set_token(token: usize) {
-        asm!("csrw satp, $0" :: "r"(token) :: "volatile");
+        llvm_asm!("csrw satp, $0" :: "r"(token) :: "volatile");
     }
 
     fn active_token() -> usize {

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

@@ -1,4 +1,3 @@
-use crate::context::ContextContent;
 use crate::interrupt::*;
 use crate::process::structs::*;
 use crate::process::thread_pool::ThreadPool;

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

@@ -2,18 +2,17 @@ use super::{ExitCode, Tid};
 use crate::alloc::alloc::{alloc, dealloc, Layout};
 use crate::consts::*;
 use crate::context::Context;
+use crate::fs::file::File;
 use crate::memory::memory_set::{attr::MemoryAttr, handler::ByFrame, MemorySet};
 use alloc::boxed::Box;
-use core::str;
+use alloc::sync::Arc;
 use riscv::register::satp;
+use spin::Mutex;
 use xmas_elf::{
     header,
     program::{Flags, SegmentData, Type},
     ElfFile,
 };
-use crate::fs::file::File;
-use spin::Mutex;
-use alloc::sync::Arc;
 
 #[derive(Clone)]
 pub enum Status {
@@ -81,7 +80,7 @@ impl Thread {
         let entry_addr = elf.header.pt2.entry_point() as usize;
         let mut vm = elf.make_memory_set();
 
-        let mut ustack_top = {
+        let ustack_top = {
             let (ustack_bottom, ustack_top) =
                 (USER_STACK_OFFSET, USER_STACK_OFFSET + USER_STACK_SIZE);
             vm.push(
@@ -106,7 +105,6 @@ impl Thread {
             thread.ofile[i] = Some(Arc::new(Mutex::new(File::default())));
         }
         Box::new(thread)
-        
     }
 
     // 分配文件描述符

Diff for: os/src/sbi.rs

@@ -4,7 +4,7 @@
 fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
     let ret;
     unsafe {
-        asm!("ecall"
+        llvm_asm!("ecall"
             : "={x10}" (ret)
             : "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
             : "memory"

Diff for: os/src/syscall.rs

@@ -1,6 +1,6 @@
 use crate::context::TrapFrame;
-use crate::process;
 use crate::fs::file::FileDescriptorType;
+use crate::process;
 
 pub const SYS_OPEN: usize = 56;
 pub const SYS_CLOSE: usize = 57;
@@ -56,7 +56,7 @@ unsafe fn sys_read(fd: usize, base: *mut u8, len: usize) -> isize {
         }
         return 1;
     } else {
-        let mut thread = process::current_thread_mut();
+        let thread = process::current_thread_mut();
         assert!(thread.ofile[fd].is_some());
         let mut file = thread.ofile[fd as usize].as_ref().unwrap().lock();
         assert!(file.get_readable());
@@ -83,7 +83,9 @@ unsafe fn sys_read(fd: usize, base: *mut u8, len: usize) -> isize {
 unsafe fn sys_write(fd: usize, base: *const u8, len: usize) -> isize {
     if fd == 1 {
         assert!(len == 1);
-        unsafe { crate::io::putchar(*base as char); }
+        unsafe {
+            crate::io::putchar(*base as char);
+        }
         return 1;
     } else {
         let thread = process::current_thread_mut();

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

@@ -3,7 +3,6 @@
 
 extern crate alloc;
 
-#[macro_use]
 extern crate user;
 
 #[no_mangle]

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

@@ -7,12 +7,7 @@ extern crate alloc;
 extern crate user;
 
 use user::io::*;
-use user::syscall::{
-    sys_open,
-    sys_close,
-    sys_read,
-    sys_write,
-};
+use user::syscall::{sys_close, sys_open, sys_read, sys_write};
 
 const BUFFER_SIZE: usize = 20;
 const FILE: &'static str = "temp\0";
@@ -28,7 +23,7 @@ pub fn main() -> usize {
 
     // 将字符串从文件 temp 读入内存
     let read_fd = sys_open(FILE.as_ptr(), O_RDONLY);
-    let mut read = [0u8; BUFFER_SIZE];
+    let read = [0u8; BUFFER_SIZE];
     sys_read(read_fd as usize, &read[0] as *const u8, BUFFER_SIZE);
     println!("read from file 'temp' successfully...");
 

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

@@ -47,9 +47,8 @@ pub fn getc() -> u8 {
     c
 }
 
-pub const O_RDONLY: i32 = 0;    // 只读
-pub const O_WRONLY: i32 = 1;    // 只写
-pub const O_RDWR: i32 = 2;        // 可读可写
-pub const O_CREAT: i32 = 64;    // 打开文件时若文件不存在，创建它
-pub const O_APPEND: i32 = 1024;    // 从文件结尾开始写入
-
+pub const O_RDONLY: i32 = 0; // 只读
+pub const O_WRONLY: i32 = 1; // 只写
+pub const O_RDWR: i32 = 2; // 可读可写
+pub const O_CREAT: i32 = 64; // 打开文件时若文件不存在，创建它
+pub const O_APPEND: i32 = 1024; // 从文件结尾开始写入

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

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(asm)]
+#![feature(llvm_asm)]
 #![feature(lang_items)]
 #![feature(panic_info_message)]
 #![feature(linkage)]

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

@@ -12,7 +12,7 @@ fn sys_call(syscall_id: SyscallId, arg0: usize, arg1: usize, arg2: usize, arg3:
     let id = syscall_id as usize;
     let mut ret: i64;
     unsafe {
-        asm!(
+        llvm_asm!(
             "ecall"
             : "={x10}"(ret)
             : "{x17}"(id), "{x10}"(arg0), "{x11}"(arg1), "{x12}"(arg2), "{x13}"(arg3)
@@ -23,7 +23,6 @@ fn sys_call(syscall_id: SyscallId, arg0: usize, arg1: usize, arg2: usize, arg3:
     ret
 }
 
-
 pub fn sys_open(path: *const u8, flags: i32) -> i64 {
     sys_call(SyscallId::Open, path as usize, flags as usize, 0, 0)
 }