Merge branch 'main' into main

Author: volcaxiao

.github/workflows/build.yml

@@ -64,3 +64,20 @@ jobs:
 
     - name: Run AML test suite
       run: cargo run --bin aml_tester -- -p tests --reset
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: 'recursive'
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        default: true
+        profile: minimal
+        components: clippy
+
+    - name: Run clippy
+      run: cargo clippy -p acpi

acpi-dumper/src/main.rs

@@ -98,5 +98,5 @@ fn main() {
 
 #[cfg(not(target_os = "linux"))]
 fn main() {
-    std::compilation_error!("acpi-dumper currently only supports linux");
+    std::compile_error!("acpi-dumper currently only supports linux");
 }

acpi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "acpi"
-version = "5.0.0"
+version = "5.1.0"
 authors = ["Isaac Woods"]
 repository = "https://github.com/rust-osdev/acpi"
 description = "A pure-Rust library for parsing ACPI tables"

acpi/src/handler.rs

@@ -1,4 +1,8 @@
-use core::{fmt, ops::Deref, ptr::NonNull};
+use core::{
+    fmt,
+    ops::{Deref, DerefMut},
+    ptr::NonNull,
+};
 
 /// Describes a physical mapping created by `AcpiHandler::map_physical_region` and unmapped by
 /// `AcpiHandler::unmap_physical_region`. The region mapped must be at least `size_of::<T>()`
@@ -47,6 +51,10 @@ where
     ///   than `region_length`, due to requirements of the paging system or other reasoning.
     /// - `handler` should be the same `AcpiHandler` that created the mapping. When the `PhysicalMapping` is
     ///   dropped, it will be used to unmap the structure.
+    ///
+    /// ### Safety
+    ///
+    /// The caller must ensure that the physical memory can be safely mapped.
     pub unsafe fn new(
         physical_start: usize,
         virtual_start: NonNull<T>,
@@ -105,6 +113,15 @@ where
     }
 }
 
+impl<H, T> DerefMut for PhysicalMapping<H, T>
+where
+    H: AcpiHandler,
+{
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { self.virtual_start.as_mut() }
+    }
+}
+
 impl<H, T> Drop for PhysicalMapping<H, T>
 where
     H: AcpiHandler,

acpi/src/lib.rs

@@ -20,30 +20,27 @@
 //!      default configuration of the crate.
 //!
 //! ### Usage
-//! To use the library, you will need to provide an implementation of the `AcpiHandler` trait, which allows the
+//! To use the library, you will need to provide an implementation of the [`AcpiHandler`] trait, which allows the
 //! library to make requests such as mapping a particular region of physical memory into the virtual address space.
 //!
-//! You then need to construct an instance of `AcpiTables`, which can be done in a few ways depending on how much
+//! You then need to construct an instance of [`AcpiTables`], which can be done in a few ways depending on how much
 //! information you have:
-//! * Use `AcpiTables::from_rsdp` if you have the physical address of the RSDP
-//! * Use `AcpiTables::from_rsdt` if you have the physical address of the RSDT/XSDT
-//! * Use `AcpiTables::search_for_rsdp_bios` if you don't have the address of either, but **you know you are
-//! running on BIOS, not UEFI**
-//! * Use `AcpiTables::from_tables_direct` if you are using the library in an unusual setting, such as in usermode,
-//!   and have a custom method to enumerate and access the tables.
+//! * Use [`AcpiTables::from_rsdp`] if you have the physical address of the RSDP
+//! * Use [`AcpiTables::from_rsdt`] if you have the physical address of the RSDT/XSDT
+//! * Use [`AcpiTables::search_for_rsdp_bios`] if you don't have the address of either, but **you know you are
+//!   running on BIOS, not UEFI**
 //!
 //! `AcpiTables` stores the addresses of all of the tables detected on a platform. The SDTs are parsed by this
 //! library, or can be accessed directly with `from_sdt`, while the `DSDT` and any `SSDTs` should be parsed with
 //! `aml`.
 //!
 //! To gather information out of the static tables, a few of the types you should take a look at are:
-//!    - [`PlatformInfo`](crate::platform::PlatformInfo) parses the FADT and MADT to create a nice view of the
-//!      processor topology and interrupt controllers on `x86_64`, and the interrupt controllers on other platforms.
-//!      `AcpiTables::platform_info` is a convenience method for constructing a `PlatformInfo`.
-//!    - [`HpetInfo`](crate::hpet::HpetInfo) parses the HPET table and tells you how to configure the High
-//!      Precision Event Timer.
-//!    - [`PciConfigRegions`](crate::mcfg::PciConfigRegions) parses the MCFG and tells you how PCIe configuration
-//!      space is mapped into physical memory.
+//!    - [`PlatformInfo`] parses the FADT and MADT to create a nice view of the processor topology and interrupt
+//!      controllers on `x86_64`, and the interrupt controllers on other platforms.
+//!      [`AcpiTables::platform_info`] is a convenience method for constructing a `PlatformInfo`.
+//!    - [`HpetInfo`] parses the HPET table and tells you how to configure the High Precision Event Timer.
+//!    - [`PciConfigRegions`] parses the MCFG and tells you how PCIe configuration space is mapped into physical
+//!      memory.
 
 /*
  * Contributing notes (you may find these useful if you're new to contributing to the library):
@@ -206,7 +203,9 @@ where
 {
     /// Create an `AcpiTables` if you have the physical address of the RSDP.
     ///
-    /// ### Safety: Caller must ensure the provided address is valid to read as an RSDP.
+    /// ### Safety
+    ///
+    /// Caller must ensure the provided address is valid to read as an RSDP.
     pub unsafe fn from_rsdp(handler: H, address: usize) -> AcpiResult<Self> {
         let rsdp_mapping = unsafe { handler.map_physical_region::<Rsdp>(address, mem::size_of::<Rsdp>()) };
         rsdp_mapping.validate()?;
@@ -216,8 +215,12 @@ where
     }
 
     /// Search for the RSDP on a BIOS platform. This accesses BIOS-specific memory locations and will probably not
-    /// work on UEFI platforms. See [Rsdp::search_for_rsdp_bios](rsdp_search::Rsdp::search_for_rsdp_bios) for
+    /// work on UEFI platforms. See [`Rsdp::search_for_on_bios`] for details.
     /// details.
+    ///
+    /// ### Safety
+    ///
+    /// The caller must ensure that this function is called on BIOS platforms.
     pub unsafe fn search_for_rsdp_bios(handler: H) -> AcpiResult<Self> {
         let rsdp_mapping = unsafe { Rsdp::search_for_on_bios(handler.clone())? };
         // Safety: RSDP has been validated from `Rsdp::search_for_on_bios`
@@ -234,7 +237,9 @@ where
     /// from `from_rsdp` after validation, but can also be used if you've searched for the RSDP manually on a BIOS
     /// system.
     ///
-    /// ### Safety: Caller must ensure that the provided mapping is a fully validated RSDP.
+    /// ### Safety
+    ///
+    /// Caller must ensure that the provided mapping is a fully validated RSDP.
     pub unsafe fn from_validated_rsdp(handler: H, rsdp_mapping: PhysicalMapping<H, Rsdp>) -> AcpiResult<Self> {
         let revision = rsdp_mapping.revision();
         let root_table_mapping = if revision == 0 {
@@ -259,7 +264,9 @@ where
 
     /// Create an `AcpiTables` if you have the physical address of the RSDT/XSDT.
     ///
-    /// ### Safety: Caller must ensure the provided address is valid RSDT/XSDT address.
+    /// ### Safety
+    ///
+    /// Caller must ensure the provided address is valid RSDT/XSDT address.
     pub unsafe fn from_rsdt(handler: H, revision: u8, address: usize) -> AcpiResult<Self> {
         let root_table_mapping = if revision == 0 {
             /*
@@ -404,19 +411,17 @@ where
         Ok(())
     }
 
-    /// Convenience method for contructing a [`PlatformInfo`](crate::platform::PlatformInfo). This is one of the
-    /// first things you should usually do with an `AcpiTables`, and allows to collect helpful information about
-    /// the platform from the ACPI tables.
+    /// Convenience method for contructing a [`PlatformInfo`]. This is one of the first things you should usually do
+    /// with an `AcpiTables`, and allows to collect helpful information about the platform from the ACPI tables.
     ///
-    /// Like `platform_info_in`, but uses the global allocator.
+    /// Like [`platform_info_in`](Self::platform_info_in), but uses the global allocator.
     #[cfg(feature = "alloc")]
     pub fn platform_info(&self) -> AcpiResult<PlatformInfo<alloc::alloc::Global>> {
         PlatformInfo::new(self)
     }
 
-    /// Convenience method for contructing a [`PlatformInfo`](crate::platform::PlatformInfo). This is one of the
-    /// first things you should usually do with an `AcpiTables`, and allows to collect helpful information about
-    /// the platform from the ACPI tables.
+    /// Convenience method for contructing a [`PlatformInfo`]. This is one of the first things you should usually do
+    /// with an `AcpiTables`, and allows to collect helpful information about the platform from the ACPI tables.
     #[cfg(feature = "allocator_api")]
     pub fn platform_info_in<A>(&self, allocator: A) -> AcpiResult<PlatformInfo<A>>
     where
@@ -457,7 +462,9 @@ impl AmlTable {
     }
 }
 
-/// ### Safety: Caller must ensure the provided address is valid for being read as an `SdtHeader`.
+/// ### Safety
+///
+/// Caller must ensure the provided address is valid for being read as an `SdtHeader`.
 unsafe fn read_table<H: AcpiHandler, T: AcpiTable>(
     handler: H,
     address: usize,
@@ -480,7 +487,7 @@ where
     handler: H,
 }
 
-impl<'t, H> Iterator for SsdtIterator<'t, H>
+impl<H> Iterator for SsdtIterator<'_, H>
 where
     H: AcpiHandler,
 {
@@ -528,7 +535,7 @@ where
     handler: H,
 }
 
-impl<'t, H> Iterator for SdtHeaderIterator<'t, H>
+impl<H> Iterator for SdtHeaderIterator<'_, H>
 where
     H: AcpiHandler,
 {

acpi/src/madt.rs

@@ -1,5 +1,6 @@
 use crate::{
     sdt::{ExtendedField, SdtHeader, Signature},
+    AcpiError,
     AcpiTable,
 };
 use bit_field::BitField;
@@ -21,6 +22,7 @@ pub enum MadtError {
     InvalidLocalNmiLine,
     MpsIntiInvalidPolarity,
     MpsIntiInvalidTriggerMode,
+    WakeupApsTimeout,
 }
 
 /// Represents the MADT - this contains the MADT header fields. You can then iterate over a `Madt`
@@ -60,6 +62,15 @@ impl fmt::Display for Madt {
 }
 
 impl Madt {
+    pub fn get_mpwk_mailbox_addr(&self) -> Result<u64, AcpiError> {
+        for entry in self.entries() {
+            if let MadtEntry::MultiprocessorWakeup(entry) = entry {
+                return Ok(entry.mailbox_address);
+            }
+        }
+        Err(AcpiError::InvalidMadt(MadtError::UnexpectedEntry))
+    }
+
     #[cfg(feature = "allocator_api")]
     pub fn parse_interrupt_model_in<'a, A>(
         &self,
@@ -766,6 +777,36 @@ pub struct MultiprocessorWakeupEntry {
     pub mailbox_address: u64,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum MpProtectedModeWakeupCommand {
+    Noop = 0,
+    Wakeup = 1,
+    Sleep = 2,
+    AcceptPages = 3,
+}
+
+impl From<u16> for MpProtectedModeWakeupCommand {
+    fn from(value: u16) -> Self {
+        match value {
+            0 => MpProtectedModeWakeupCommand::Noop,
+            1 => MpProtectedModeWakeupCommand::Wakeup,
+            2 => MpProtectedModeWakeupCommand::Sleep,
+            3 => MpProtectedModeWakeupCommand::AcceptPages,
+            _ => panic!("Invalid value for MpProtectedModeWakeupCommand"),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct MultiprocessorWakeupMailbox {
+    pub command: u16,
+    _reserved: u16,
+    pub apic_id: u32,
+    pub wakeup_vector: u64,
+    pub reserved_for_os: [u64; 254],
+    reserved_for_firmware: [u64; 256],
+}
+
 #[cfg(feature = "allocator_api")]
 fn parse_mps_inti_flags(flags: u16) -> crate::AcpiResult<(Polarity, TriggerMode)> {
     let polarity = match flags.get_bits(0..2) {

acpi/src/managed_slice.rs

@@ -16,7 +16,7 @@ where
     allocator: A,
 }
 
-impl<'a, T, A> ManagedSlice<'a, T, A>
+impl<T, A> ManagedSlice<'_, T, A>
 where
     A: Allocator,
 {
@@ -34,13 +34,13 @@ where
 }
 
 #[cfg(feature = "alloc")]
-impl<'a, T> ManagedSlice<'a, T, alloc::alloc::Global> {
+impl<T> ManagedSlice<'_, T, alloc::alloc::Global> {
     pub fn new(len: usize) -> AcpiResult<Self> {
         Self::new_in(len, alloc::alloc::Global)
     }
 }
 
-impl<'a, T, A> Drop for ManagedSlice<'a, T, A>
+impl<T, A> Drop for ManagedSlice<'_, T, A>
 where
     A: Allocator,
 {
@@ -54,7 +54,7 @@ where
     }
 }
 
-impl<'a, T, A> core::ops::Deref for ManagedSlice<'a, T, A>
+impl<T, A> core::ops::Deref for ManagedSlice<'_, T, A>
 where
     A: Allocator,
 {
@@ -65,7 +65,7 @@ where
     }
 }
 
-impl<'a, T, A> core::ops::DerefMut for ManagedSlice<'a, T, A>
+impl<T, A> core::ops::DerefMut for ManagedSlice<'_, T, A>
 where
     A: Allocator,
 {