Update image and Rust toolchain

framework/aster-frame/src/arch/x86/console.rs

@@ -55,7 +55,7 @@ pub(crate) fn callback_init() {
         crate::arch::x86::kernel::pic::allocate_irq(4).unwrap()
     } else {
         let irq = IrqLine::alloc().unwrap();
-        let mut io_apic = IO_APIC.get().unwrap().get(0).unwrap().lock();
+        let mut io_apic = IO_APIC.get().unwrap().first().unwrap().lock();
         io_apic.enable(4, irq.clone()).unwrap();
         irq
     };

framework/aster-frame/src/arch/x86/timer/apic.rs

@@ -102,7 +102,7 @@ fn init_periodic_mode() {
     let mut apic_lock = APIC_INSTANCE.get().unwrap().lock();
     let mut irq = IrqLine::alloc_specific(super::TIMER_IRQ_NUM.load(Ordering::Relaxed)).unwrap();
     irq.on_active(init_function);
-    let mut io_apic = IO_APIC.get().unwrap().get(0).unwrap().lock();
+    let mut io_apic = IO_APIC.get().unwrap().first().unwrap().lock();
     debug_assert_eq!(io_apic.interrupt_base(), 0);
     io_apic.enable(2, irq.clone()).unwrap();
     drop(io_apic);
@@ -133,7 +133,7 @@ fn init_periodic_mode() {
                 return;
             }
         }
-        let mut io_apic = IO_APIC.get().unwrap().get(0).unwrap().lock();
+        let mut io_apic = IO_APIC.get().unwrap().first().unwrap().lock();
         io_apic.disable(2).unwrap();
         drop(io_apic);
         // stop APIC Timer, get the number of tick we need

framework/aster-frame/src/bus/mmio/mod.rs

@@ -34,7 +34,7 @@ fn iter_range(range: Range<usize>) {
     let mut io_apic = if is_ioapic2 {
         io_apics.get(1).unwrap().lock()
     } else {
-        io_apics.get(0).unwrap().lock()
+        io_apics.first().unwrap().lock()
     };
     let mut device_count = 0;
     while current > range.start {

framework/aster-frame/src/bus/pci/device_info.rs

@@ -68,7 +68,7 @@ impl PciDeviceLocation {
 
     /// Returns an iterator that enumerates all possible PCI device locations.
     pub fn all() -> impl Iterator<Item = PciDeviceLocation> {
-        iter::from_generator(|| {
+        iter::from_coroutine(|| {
             for bus in Self::MIN_BUS..=Self::MAX_BUS {
                 for device in Self::MIN_DEVICE..=Self::MAX_DEVICE {
                     for function in Self::MIN_FUNCTION..=Self::MAX_FUNCTION {

framework/aster-frame/src/lib.rs

@@ -1,13 +1,12 @@
 //! The framework part of Asterinas.
 #![feature(alloc_error_handler)]
-#![feature(const_maybe_uninit_zeroed)]
 #![feature(const_mut_refs)]
 #![feature(const_ptr_sub_ptr)]
 #![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
+#![feature(coroutines)]
 #![feature(fn_traits)]
-#![feature(generators)]
-#![feature(iter_from_generator)]
+#![feature(iter_from_coroutine)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
 #![feature(new_uninit)]

framework/aster-frame/src/sync/wait.rs

@@ -96,7 +96,9 @@ impl WaitQueue {
                 return Some(res);
             };
 
-            if let Some(ref timer_callback) = timer_callback && timer_callback.is_expired() {
+            if let Some(ref timer_callback) = timer_callback
+                && timer_callback.is_expired()
+            {
                 return None;
             }
 

framework/aster-frame/src/util/mod.rs

@@ -1,4 +1 @@
 pub mod recycle_allocator;
-mod type_map;
-
-pub use self::type_map::TypeMap;

framework/aster-frame/src/util/type_map.rs

@@ -1,26 +0,0 @@
-/// A type map is a collection whose keys are types, rather than values.
-pub struct TypeMap {}
-
-pub trait Any: core::any::Any + Send + Sync {}
-
-impl TypeMap {
-    /// Creates an empty typed map.
-    pub fn new() -> Self {
-        todo!()
-    }
-
-    /// Inserts a new item of type `T`.
-    pub fn insert<T: Any>(&mut self, val: T) -> Option<T> {
-        todo!()
-    }
-
-    /// Gets an item of type `T`.
-    pub fn get<T: Any>(&self) -> Option<&T> {
-        todo!()
-    }
-
-    /// Gets an item of type `T`.
-    pub fn remove<T: Any>(&self) -> Option<T> {
-        todo!()
-    }
-}

framework/libs/boot-trojan/builder/Cargo.toml

@@ -12,5 +12,5 @@ serde = { version = "1.0.192", features = ["derive"] }
 xmas-elf = "0.9.1"
 
 [features]
-default = []
+default = ["trojan64"]
 trojan64 = []

framework/libs/boot-trojan/builder/src/lib.rs

@@ -158,7 +158,7 @@ fn build_trojan_with_arch(source_dir: &Path, out_dir: &Path, arch: &TrojanBuildA
     let out_dir = std::fs::canonicalize(out_dir).unwrap();
 
     // Relocations are fewer in release mode. But with release mode it crashes.
-    let profile = "debug";
+    let profile = "release";
 
     let cargo = std::env::var("CARGO").unwrap();
     let mut cmd = std::process::Command::new(cargo);

framework/libs/boot-trojan/trojan/src/x86/amd64_efi/efi.rs

@@ -120,5 +120,12 @@ fn efi_phase_runtime(
         }
     }
 
+    unsafe {
+        use crate::console::{print_hex, print_str};
+        print_str("[EFI stub] Entering Jinux entrypoint at ");
+        print_hex(super::JINUX_ENTRY_POINT as u64);
+        print_str("\n");
+    }
+
     unsafe { super::call_jinux_entrypoint(super::JINUX_ENTRY_POINT, boot_params_ptr as u64) }
 }

framework/libs/boot-trojan/trojan/src/x86/legacy_i386/mod.rs

@@ -8,6 +8,8 @@ global_asm!(include_str!("setup.S"));
 
 use crate::console::{print_hex, print_str};
 
+pub const JINUX_ENTRY_POINT: u32 = 0x8001000;
+
 #[export_name = "_trojan_entry_32"]
 extern "cdecl" fn trojan_entry(boot_params_ptr: u32) -> ! {
     // Safety: this init function is only called once.
@@ -27,12 +29,7 @@ extern "cdecl" fn trojan_entry(boot_params_ptr: u32) -> ! {
     crate::loader::load_elf(payload);
 
     // Safety: the entrypoint and the ptr is valid.
-    unsafe {
-        call_jinux_entrypoint(
-            super::JINUX_ENTRY_POINT,
-            boot_params_ptr.try_into().unwrap(),
-        )
-    };
+    unsafe { call_jinux_entrypoint(JINUX_ENTRY_POINT, boot_params_ptr.try_into().unwrap()) };
 }
 
 pub const ASTER_ENTRY_POINT: u32 = 0x8001000;

framework/libs/boot-trojan/trojan/src/x86/mod.rs

@@ -1,10 +1,8 @@
 cfg_if::cfg_if! {
     if #[cfg(target_arch = "x86_64")] {
         mod amd64_efi;
-        pub use amd64_efi::*;
     } else if #[cfg(target_arch = "x86")] {
         mod legacy_i386;
-        pub use legacy_i386::*;
     } else {
         compile_error!("Unsupported target_arch");
     }

framework/libs/boot-trojan/trojan/src/x86/relocation.rs

@@ -28,10 +28,21 @@ fn get_rela_array() -> &'static [Elf64Rela] {
     let end = __rela_dyn_end as *const Elf64Rela;
     // FIXME: 2023/11/29
     // There should be a Rust compiler bug that makes the calculation of len incorrect.
-    // The current implementation only works in debug mode.
-    // To do it in release mode, a workaround is to use inline asm. But that crashes
-    // in debug mode. QaQ
-    let len = unsafe { end.offset_from(start) } as usize;
+    // The most sound implementation only works in debug mode.
+    // let len = unsafe { end.offset_from(start) } as usize;
+    // The inline asm solution is a workaround.
+    let len = unsafe {
+        let len: usize;
+        core::arch::asm!("
+                mov {len}, {end}
+                sub {len}, {start}
+            ",
+            len = out(reg) len,
+            end = in(reg) end,
+            start = in(reg) start,
+        );
+        len / core::mem::size_of::<Elf64Rela>() as usize
+    };
     #[cfg(feature = "debug_print")]
     unsafe {
         use crate::console::{print_hex, print_str};