acpi: don't gate allocator_api on a feature

Author: IsaacWoods

acpi/Cargo.toml

@@ -15,6 +15,5 @@ bitflags = "2.5.0"
 log = "0.4.20"
 
 [features]
-default = ["allocator_api", "alloc"]
-allocator_api = []
-alloc = ["allocator_api"]
+default = ["alloc"]
+alloc = []

acpi/src/lib.rs

@@ -53,8 +53,7 @@
  */
 
 #![no_std]
-#![deny(unsafe_op_in_unsafe_fn)]
-#![cfg_attr(feature = "allocator_api", feature(allocator_api))]
+#![feature(allocator_api)]
 
 #[cfg_attr(test, macro_use)]
 #[cfg(test)]
@@ -69,35 +68,28 @@ pub mod fadt;
 pub mod handler;
 pub mod hpet;
 pub mod madt;
+pub mod managed_slice;
 pub mod mcfg;
+pub mod platform;
 pub mod rsdp;
 pub mod sdt;
 pub mod spcr;
 
-#[cfg(feature = "allocator_api")]
-mod managed_slice;
-#[cfg(feature = "allocator_api")]
-pub use managed_slice::*;
-
-#[cfg(feature = "allocator_api")]
-pub mod platform;
-#[cfg(feature = "allocator_api")]
-pub use crate::platform::{interrupt::InterruptModel, PlatformInfo};
-
-#[cfg(feature = "allocator_api")]
-pub use crate::mcfg::PciConfigRegions;
-
+pub use crate::{
+    mcfg::PciConfigRegions,
+    platform::{interrupt::InterruptModel, PlatformInfo},
+};
 pub use fadt::PowerProfile;
 pub use handler::{AcpiHandler, PhysicalMapping};
 pub use hpet::HpetInfo;
 pub use madt::MadtError;
 
 use crate::sdt::{SdtHeader, Signature};
-use core::mem;
+use core::{alloc::Allocator, mem};
 use rsdp::Rsdp;
 
 /// Result type used by error-returning functions.
-pub type AcpiResult<T> = core::result::Result<T, AcpiError>;
+pub type AcpiResult<T> = Result<T, AcpiError>;
 
 /// All types representing ACPI tables should implement this trait.
 ///
@@ -179,13 +171,9 @@ macro_rules! read_root_table {
     }};
 }
 
-/// Type capable of enumerating the existing ACPI tables on the system.
-///
-///
-/// ### Implementation Note
-///
-/// When using the `allocator_api`±`alloc` features, [`PlatformInfo::new()`] or [`PlatformInfo::new_in()`] provide
-/// a much cleaner API for enumerating ACPI structures once an `AcpiTables` has been constructed.
+/// `AcpiTables` represents all of the enumerable ACPI tables on the system, and is the main type
+/// to construct and use from the crate. `PlatformInfo` provides a higher-level interface to some
+/// of the data contained in the tables, and may be easier to use for common use-cases.
 #[derive(Debug)]
 pub struct AcpiTables<H: AcpiHandler> {
     mapping: PhysicalMapping<H, SdtHeader>,
@@ -376,12 +364,11 @@ where
         PlatformInfo::new(self)
     }
 
-    /// Convenience method for contructing a [`PlatformInfo`]. This is one of the first things you should usually do
+    /// Construct 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
-        A: core::alloc::Allocator + Clone,
+        A: Allocator + Clone,
     {
         PlatformInfo::new_in(self, allocator)
     }

acpi/src/madt.rs

@@ -1,24 +1,22 @@
 use crate::{
+    managed_slice::ManagedSlice,
+    platform::{
+        interrupt::{InterruptModel, Polarity, TriggerMode},
+        ProcessorInfo,
+    },
     sdt::{ExtendedField, SdtHeader, Signature},
     AcpiError,
+    AcpiResult,
     AcpiTable,
 };
 use bit_field::BitField;
 use core::{
+    alloc::Allocator,
     marker::{PhantomData, PhantomPinned},
     mem,
     pin::Pin,
 };
 
-#[cfg(feature = "allocator_api")]
-use crate::{
-    platform::{
-        interrupt::{InterruptModel, Polarity, TriggerMode},
-        ProcessorInfo,
-    },
-    AcpiResult,
-};
-
 #[derive(Debug)]
 pub enum MadtError {
     UnexpectedEntry,
@@ -69,13 +67,12 @@ impl Madt {
         Err(AcpiError::InvalidMadt(MadtError::UnexpectedEntry))
     }
 
-    #[cfg(feature = "allocator_api")]
     pub fn parse_interrupt_model_in<A>(
         self: Pin<&Self>,
         allocator: A,
     ) -> AcpiResult<(InterruptModel<A>, Option<ProcessorInfo<A>>)>
     where
-        A: core::alloc::Allocator + Clone,
+        A: Allocator + Clone,
     {
         /*
          * We first do a pass through the MADT to determine which interrupt model is being used.
@@ -114,13 +111,12 @@ impl Madt {
         Ok((InterruptModel::Unknown, None))
     }
 
-    #[cfg(feature = "allocator_api")]
     fn parse_apic_model_in<A>(
         self: Pin<&Self>,
         allocator: A,
     ) -> AcpiResult<(InterruptModel<A>, Option<ProcessorInfo<A>>)>
     where
-        A: core::alloc::Allocator + Clone,
+        A: Allocator + Clone,
     {
         use crate::platform::{
             interrupt::{
@@ -157,12 +153,11 @@ impl Madt {
             }
         }
 
-        let mut io_apics = crate::ManagedSlice::new_in(io_apic_count, allocator.clone())?;
-        let mut interrupt_source_overrides = crate::ManagedSlice::new_in(iso_count, allocator.clone())?;
-        let mut nmi_sources = crate::ManagedSlice::new_in(nmi_source_count, allocator.clone())?;
-        let mut local_apic_nmi_lines = crate::ManagedSlice::new_in(local_nmi_line_count, allocator.clone())?;
-        let mut application_processors =
-            crate::ManagedSlice::new_in(processor_count.saturating_sub(1), allocator)?; // Subtract one for the BSP
+        let mut io_apics = ManagedSlice::new_in(io_apic_count, allocator.clone())?;
+        let mut interrupt_source_overrides = ManagedSlice::new_in(iso_count, allocator.clone())?;
+        let mut nmi_sources = ManagedSlice::new_in(nmi_source_count, allocator.clone())?;
+        let mut local_apic_nmi_lines = ManagedSlice::new_in(local_nmi_line_count, allocator.clone())?;
+        let mut application_processors = ManagedSlice::new_in(processor_count.saturating_sub(1), allocator)?; // Subtract one for the BSP
         let mut boot_processor = None;
 
         io_apic_count = 0;
@@ -678,20 +673,19 @@ pub struct MultiprocessorWakeupMailbox {
     pub reserved_for_firmware: [u64; 256],
 }
 
-#[cfg(feature = "allocator_api")]
-fn parse_mps_inti_flags(flags: u16) -> crate::AcpiResult<(Polarity, TriggerMode)> {
+fn parse_mps_inti_flags(flags: u16) -> AcpiResult<(Polarity, TriggerMode)> {
     let polarity = match flags.get_bits(0..2) {
         0b00 => Polarity::SameAsBus,
         0b01 => Polarity::ActiveHigh,
         0b11 => Polarity::ActiveLow,
-        _ => return Err(crate::AcpiError::InvalidMadt(MadtError::MpsIntiInvalidPolarity)),
+        _ => return Err(AcpiError::InvalidMadt(MadtError::MpsIntiInvalidPolarity)),
     };
 
     let trigger_mode = match flags.get_bits(2..4) {
         0b00 => TriggerMode::SameAsBus,
         0b01 => TriggerMode::Edge,
         0b11 => TriggerMode::Level,
-        _ => return Err(crate::AcpiError::InvalidMadt(MadtError::MpsIntiInvalidTriggerMode)),
+        _ => return Err(AcpiError::InvalidMadt(MadtError::MpsIntiInvalidTriggerMode)),
     };
 
     Ok((polarity, trigger_mode))

acpi/src/mcfg.rs

@@ -1,45 +1,47 @@
 use crate::{
+    managed_slice::ManagedSlice,
     sdt::{SdtHeader, Signature},
+    AcpiHandler,
+    AcpiResult,
     AcpiTable,
+    AcpiTables,
 };
-use core::{mem, slice};
+use core::{alloc::Allocator, fmt, mem, ops::RangeInclusive, slice};
 
 /// Describes a set of regions of physical memory used to access the PCIe configuration space. A
 /// region is created for each entry in the MCFG. Given the segment group, bus, device number, and
 /// function of a PCIe device, the `physical_address` method on this will give you the physical
 /// address of the start of that device function's configuration space (each function has 4096
 /// bytes of configuration space in PCIe).
-#[cfg(feature = "allocator_api")]
 pub struct PciConfigRegions<A>
 where
-    A: core::alloc::Allocator,
+    A: Allocator,
 {
-    regions: crate::ManagedSlice<McfgEntry, A>,
+    regions: ManagedSlice<McfgEntry, A>,
 }
 
 #[cfg(feature = "alloc")]
 impl<'a> PciConfigRegions<alloc::alloc::Global> {
-    pub fn new<H>(tables: &crate::AcpiTables<H>) -> crate::AcpiResult<PciConfigRegions<alloc::alloc::Global>>
+    pub fn new<H>(tables: &AcpiTables<H>) -> AcpiResult<PciConfigRegions<alloc::alloc::Global>>
     where
-        H: crate::AcpiHandler,
+        H: AcpiHandler,
     {
         Self::new_in(tables, alloc::alloc::Global)
     }
 }
 
-#[cfg(feature = "allocator_api")]
 impl<A> PciConfigRegions<A>
 where
-    A: core::alloc::Allocator,
+    A: Allocator,
 {
-    pub fn new_in<H>(tables: &crate::AcpiTables<H>, allocator: A) -> crate::AcpiResult<PciConfigRegions<A>>
+    pub fn new_in<H>(tables: &AcpiTables<H>, allocator: A) -> AcpiResult<PciConfigRegions<A>>
     where
-        H: crate::AcpiHandler,
+        H: AcpiHandler,
     {
         let mcfg = tables.find_table::<Mcfg>()?;
         let mcfg_entries = mcfg.entries();
 
-        let mut regions = crate::ManagedSlice::new_in(mcfg_entries.len(), allocator)?;
+        let mut regions = ManagedSlice::new_in(mcfg_entries.len(), allocator)?;
         regions.copy_from_slice(mcfg_entries);
 
         Ok(Self { regions })
@@ -74,7 +76,7 @@ where
 /// Configuration entry describing a valid bus range for the given PCI segment group.
 pub struct PciConfigEntry {
     pub segment_group: u16,
-    pub bus_range: core::ops::RangeInclusive<u8>,
+    pub bus_range: RangeInclusive<u8>,
     pub physical_address: usize,
 }
 
@@ -121,8 +123,8 @@ impl Mcfg {
     pub fn entries(&self) -> &[McfgEntry] {
         let length = self.header.length as usize - mem::size_of::<Mcfg>();
 
-        // Intentionally round down in case length isn't an exact multiple of McfgEntry size
-        // (see rust-osdev/acpi#58)
+        // Intentionally round down in case length isn't an exact multiple of McfgEntry size - this
+        // has been observed on real hardware (see rust-osdev/acpi#58)
         let num_entries = length / mem::size_of::<McfgEntry>();
 
         unsafe {
@@ -132,8 +134,8 @@ impl Mcfg {
     }
 }
 
-impl core::fmt::Debug for Mcfg {
-    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+impl fmt::Debug for Mcfg {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter.debug_struct("Mcfg").field("header", &self.header).field("entries", &self.entries()).finish()
     }
 }

acpi/src/platform/interrupt.rs

@@ -1,4 +1,4 @@
-use crate::ManagedSlice;
+use crate::managed_slice::ManagedSlice;
 use core::alloc::Allocator;
 
 #[derive(Debug, Clone, Copy)]

acpi/src/platform/mod.rs

@@ -4,11 +4,11 @@ use crate::{
     address::GenericAddress,
     fadt::Fadt,
     madt::{Madt, MadtError, MpProtectedModeWakeupCommand, MultiprocessorWakeupMailbox},
+    managed_slice::ManagedSlice,
     AcpiError,
     AcpiHandler,
     AcpiResult,
     AcpiTables,
-    ManagedSlice,
     PowerProfile,
 };
 use core::{alloc::Allocator, mem, ptr};