Bump Rust version to nightly-2025-02-18(2024 Edition)

wyfcyx · wyfcyx · commit 3817ec5b44d1 · 2025-02-26T22:06:47.000+08:00
diff --git a/.github/workflows/doc-and-test.yml b/.github/workflows/doc-and-test.yml
@@ -4,7 +4,7 @@ on: [push]
 
 env:
   CARGO_TERM_COLOR: always
-  rust_toolchain: nightly-2024-01-18
+  rust_toolchain: nightly-2025-02-18
 
 jobs:
   build-doc:
diff --git a/os/Cargo.toml b/os/Cargo.toml
@@ -2,7 +2,7 @@
 name = "os"
 version = "0.1.0"
 authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/os/build.rs b/os/build.rs
@@ -1,4 +1,4 @@
-use std::fs::{read_dir, File};
+use std::fs::{File, read_dir};
 use std::io::{Result, Write};
 
 fn main() {
diff --git a/os/src/lang_items.rs b/os/src/lang_items.rs
@@ -12,10 +12,10 @@ fn panic(info: &PanicInfo) -> ! {
             "[kernel] Panicked at {}:{} {}",
             location.file(),
             location.line(),
-            info.message().unwrap()
+            info.message()
         );
     } else {
-        error!("[kernel] Panicked: {}", info.message().unwrap());
+        error!("[kernel] Panicked: {}", info.message());
     }
     shutdown(true)
 }
diff --git a/os/src/loader.rs b/os/src/loader.rs
@@ -2,16 +2,16 @@
 
 /// Get the total number of applications.
 pub fn get_num_app() -> usize {
-    extern "C" {
-        fn _num_app();
+    unsafe extern "C" {
+        safe fn _num_app();
     }
     unsafe { (_num_app as usize as *const usize).read_volatile() }
 }
 
 /// get applications data
 pub fn get_app_data(app_id: usize) -> &'static [u8] {
-    extern "C" {
-        fn _num_app();
+    unsafe extern "C" {
+        safe fn _num_app();
     }
     let num_app_ptr = _num_app as usize as *const usize;
     let num_app = get_num_app();
diff --git a/os/src/main.rs b/os/src/main.rs
@@ -19,7 +19,6 @@
 #![deny(warnings)]
 #![no_std]
 #![no_main]
-#![feature(panic_info_message)]
 #![feature(alloc_error_handler)]
 
 extern crate alloc;
@@ -51,18 +50,18 @@ core::arch::global_asm!(include_str!("link_app.S"));
 
 /// clear BSS segment
 fn clear_bss() {
-    extern "C" {
-        fn sbss();
-        fn ebss();
+    unsafe extern "C" {
+        safe fn sbss();
+        safe fn ebss();
     }
     unsafe {
         core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize)
             .fill(0);
     }
 }
 
-#[no_mangle]
 /// the rust entry-point of os
+#[unsafe(no_mangle)]
 pub fn rust_main() -> ! {
     clear_bss();
     logging::init();
diff --git a/os/src/mm/frame_allocator.rs b/os/src/mm/frame_allocator.rs
@@ -94,8 +94,8 @@ lazy_static! {
 
 /// initiate the frame allocator using `ekernel` and `MEMORY_END`
 pub fn init_frame_allocator() {
-    extern "C" {
-        fn ekernel();
+    unsafe extern "C" {
+        safe fn ekernel();
     }
     FRAME_ALLOCATOR.exclusive_access().init(
         PhysAddr::from(ekernel as usize).ceil(),
diff --git a/os/src/mm/heap_allocator.rs b/os/src/mm/heap_allocator.rs
@@ -2,6 +2,7 @@
 
 use crate::config::KERNEL_HEAP_SIZE;
 use buddy_system_allocator::LockedHeap;
+use core::ptr::addr_of_mut;
 
 #[global_allocator]
 /// heap allocator instance
@@ -21,17 +22,17 @@ pub fn init_heap() {
     unsafe {
         HEAP_ALLOCATOR
             .lock()
-            .init(HEAP_SPACE.as_ptr() as usize, KERNEL_HEAP_SIZE);
+            .init(addr_of_mut!(HEAP_SPACE) as usize, KERNEL_HEAP_SIZE);
     }
 }
 
 #[allow(unused)]
 pub fn heap_test() {
     use alloc::boxed::Box;
     use alloc::vec::Vec;
-    extern "C" {
-        fn sbss();
-        fn ebss();
+    unsafe extern "C" {
+        safe fn sbss();
+        safe fn ebss();
     }
     let bss_range = sbss as usize..ebss as usize;
     let a = Box::new(5);
diff --git a/os/src/mm/memory_set.rs b/os/src/mm/memory_set.rs
@@ -1,6 +1,6 @@
 //! Implementation of [`MapArea`] and [`MemorySet`].
 
-use super::{frame_alloc, FrameTracker};
+use super::{FrameTracker, frame_alloc};
 use super::{PTEFlags, PageTable, PageTableEntry};
 use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
 use super::{StepByOne, VPNRange};
@@ -13,17 +13,17 @@ use core::arch::asm;
 use lazy_static::*;
 use riscv::register::satp;
 
-extern "C" {
-    fn stext();
-    fn etext();
-    fn srodata();
-    fn erodata();
-    fn sdata();
-    fn edata();
-    fn sbss_with_stack();
-    fn ebss();
-    fn ekernel();
-    fn strampoline();
+unsafe extern "C" {
+    safe fn stext();
+    safe fn etext();
+    safe fn srodata();
+    safe fn erodata();
+    safe fn sdata();
+    safe fn edata();
+    safe fn sbss_with_stack();
+    safe fn ebss();
+    safe fn ekernel();
+    safe fn strampoline();
 }
 
 lazy_static! {
@@ -386,20 +386,26 @@ 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!");
 }
diff --git a/os/src/mm/mod.rs b/os/src/mm/mod.rs
@@ -14,11 +14,11 @@ mod page_table;
 
 pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
 use address::{StepByOne, VPNRange};
-pub use frame_allocator::{frame_alloc, FrameTracker};
+pub use frame_allocator::{FrameTracker, frame_alloc};
 pub use memory_set::remap_test;
-pub use memory_set::{MapPermission, MemorySet, KERNEL_SPACE};
-pub use page_table::{translated_byte_buffer, PageTableEntry};
+pub use memory_set::{KERNEL_SPACE, MapPermission, MemorySet};
 use page_table::{PTEFlags, PageTable};
+pub use page_table::{PageTableEntry, translated_byte_buffer};
 
 /// initiate heap allocator, frame allocator and kernel space
 pub fn init() {
diff --git a/os/src/mm/page_table.rs b/os/src/mm/page_table.rs
@@ -1,6 +1,6 @@
 //! Implementation of [`PageTableEntry`] and [`PageTable`].
 
-use super::{frame_alloc, FrameTracker, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
+use super::{FrameTracker, PhysPageNum, StepByOne, VirtAddr, VirtPageNum, frame_alloc};
 use alloc::vec;
 use alloc::vec::Vec;
 use bitflags::*;
diff --git a/os/src/sbi.rs b/os/src/sbi.rs
@@ -13,7 +13,7 @@ pub fn set_timer(timer: usize) {
 
 /// use sbi call to shutdown the kernel
 pub fn shutdown(failure: bool) -> ! {
-    use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
+    use sbi_rt::{NoReason, Shutdown, SystemFailure, system_reset};
     if !failure {
         system_reset(Shutdown, NoReason);
     } else {
diff --git a/os/src/task/switch.rs b/os/src/task/switch.rs
@@ -8,8 +8,11 @@
 core::arch::global_asm!(include_str!("switch.S"));
 use super::TaskContext;
 
-extern "C" {
+unsafe extern "C" {
     /// Switch to the context of `next_task_cx_ptr`, saving the current context
     /// in `current_task_cx_ptr`.
-    pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext);
+    pub unsafe fn __switch(
+        current_task_cx_ptr: *mut TaskContext,
+        next_task_cx_ptr: *const TaskContext,
+    );
 }
diff --git a/os/src/task/task.rs b/os/src/task/task.rs
@@ -1,8 +1,8 @@
 //! Types related to task management
 use super::TaskContext;
-use crate::config::{kernel_stack_position, TRAP_CONTEXT};
-use crate::mm::{MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
-use crate::trap::{trap_handler, TrapContext};
+use crate::config::{TRAP_CONTEXT, kernel_stack_position};
+use crate::mm::{KERNEL_SPACE, MapPermission, MemorySet, PhysPageNum, VirtAddr};
+use crate::trap::{TrapContext, trap_handler};
 
 /// task control block structure
 pub struct TaskControlBlock {
diff --git a/os/src/trap/context.rs b/os/src/trap/context.rs
@@ -1,6 +1,6 @@
 //! Implementation of [`TrapContext`]
 
-use riscv::register::sstatus::{self, Sstatus, SPP};
+use riscv::register::sstatus::{self, SPP, Sstatus};
 
 #[repr(C)]
 /// trap context structure containing sstatus, sepc and registers
diff --git a/os/src/trap/mod.rs b/os/src/trap/mod.rs
@@ -52,7 +52,7 @@ pub fn enable_timer_interrupt() {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 /// handle an interrupt, exception, or system call from user space
 pub fn trap_handler() -> ! {
     set_kernel_trap_entry();
@@ -68,7 +68,10 @@ pub fn trap_handler() -> ! {
         | Trap::Exception(Exception::StorePageFault)
         | Trap::Exception(Exception::LoadFault)
         | Trap::Exception(Exception::LoadPageFault) => {
-            println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.", stval, cx.sepc);
+            println!(
+                "[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.",
+                stval, cx.sepc
+            );
             exit_current_and_run_next();
         }
         Trap::Exception(Exception::IllegalInstruction) => {
@@ -90,17 +93,17 @@ pub fn trap_handler() -> ! {
     trap_return();
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 /// set the new addr of __restore asm function in TRAMPOLINE page,
 /// set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table,
 /// finally, jump to new addr of __restore asm function
 pub fn trap_return() -> ! {
     set_user_trap_entry();
     let trap_cx_ptr = TRAP_CONTEXT;
     let user_satp = current_user_token();
-    extern "C" {
-        fn __alltraps();
-        fn __restore();
+    unsafe extern "C" {
+        unsafe fn __alltraps();
+        unsafe fn __restore();
     }
     let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
     unsafe {
@@ -115,7 +118,7 @@ pub fn trap_return() -> ! {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 /// Unimplement: traps/interrupts/exceptions from kernel mode
 /// Todo: Chapter 9: I/O device
 pub fn trap_from_kernel() -> ! {
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 profile = "minimal"
 # use the nightly version of the last stable toolchain, see <https://forge.rust-lang.org/>
-channel = "nightly-2024-05-01"
+channel = "nightly-2025-02-18"
 components = ["rust-src", "llvm-tools", "rustfmt", "clippy"]
 targets = ["riscv64gc-unknown-none-elf"]
diff --git a/user/Cargo.toml b/user/Cargo.toml
@@ -2,7 +2,7 @@
 name = "user_lib"
 version = "0.1.0"
 authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2018"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/user/src/bin/00power_3.rs b/user/src/bin/00power_3.rs
@@ -6,24 +6,23 @@ extern crate user_lib;
 
 const LEN: usize = 100;
 
-static mut S: [u64; LEN] = [0u64; LEN];
-
-#[no_mangle]
-unsafe fn main() -> i32 {
+#[unsafe(no_mangle)]
+fn main() -> i32 {
     let p = 3u64;
     let m = 998244353u64;
     let iter: usize = 300000;
     let mut cur = 0usize;
-    S[cur] = 1;
+    let mut s = [0u64; LEN];
+    s[cur] = 1;
     for i in 1..=iter {
         let next = if cur + 1 == LEN { 0 } else { cur + 1 };
-        S[next] = S[cur] * p % m;
+        s[next] = s[cur] * p % m;
         cur = next;
         if i % 10000 == 0 {
             println!("power_3 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}(MOD {})", p, iter, S[cur], m);
+    println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
     println!("Test power_3 OK!");
     0
 }
diff --git a/user/src/bin/01power_5.rs b/user/src/bin/01power_5.rs
diff --git a/user/src/bin/02power_7.rs b/user/src/bin/02power_7.rs
diff --git a/user/src/bin/03sleep.rs b/user/src/bin/03sleep.rs
diff --git a/user/src/bin/04load_fault.rs b/user/src/bin/04load_fault.rs
diff --git a/user/src/bin/05store_fault.rs b/user/src/bin/05store_fault.rs
diff --git a/user/src/bin/sbrk_test.rs b/user/src/bin/sbrk_test.rs
diff --git a/user/src/lang_items.rs b/user/src/lang_items.rs
diff --git a/user/src/lib.rs b/user/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use std::fs::{read_dir, File};`
	`1`	`+use std::fs::{File, read_dir};`
`2`	`2`	`use std::io::{Result, Write};`
`3`	`3`
`4`	`4`	`fn main() {`
Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,10 @@ fn panic(info: &PanicInfo) -> ! {`
`12`	`12`	`"[kernel] Panicked at {}:{} {}",`
`13`	`13`	`location.file(),`
`14`	`14`	`location.line(),`
`15`		`- info.message().unwrap()`
	`15`	`+ info.message()`
`16`	`16`	`);`
`17`	`17`	`} else {`
`18`		`- error!("[kernel] Panicked: {}", info.message().unwrap());`
	`18`	`+ error!("[kernel] Panicked: {}", info.message());`
`19`	`19`	`}`
`20`	`20`	`shutdown(true)`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,16 +2,16 @@`
`2`	`2`
`3`	`3`	`/// Get the total number of applications.`
`4`	`4`	`pub fn get_num_app() -> usize {`
`5`		`- extern "C" {`
`6`		`- fn _num_app();`
	`5`	`+ unsafe extern "C" {`
	`6`	`+ safe fn _num_app();`
`7`	`7`	`}`
`8`	`8`	`unsafe { (_num_app as usize as *const usize).read_volatile() }`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`/// get applications data`
`12`	`12`	`pub fn get_app_data(app_id: usize) -> &'static [u8] {`
`13`		`- extern "C" {`
`14`		`- fn _num_app();`
	`13`	`+ unsafe extern "C" {`
	`14`	`+ safe fn _num_app();`
`15`	`15`	`}`
`16`	`16`	`let num_app_ptr = _num_app as usize as *const usize;`
`17`	`17`	`let num_app = get_num_app();`