Merge branch 'rust-osdev:main' into main

Author: volcaxiao

acpi/src/lib.rs

@@ -149,6 +149,43 @@ pub enum AcpiError {
     AllocError,
 }
 
+macro_rules! read_root_table {
+    ($signature_name:ident, $address:ident, $acpi_handler:ident) => {{
+        #[repr(transparent)]
+        struct RootTable {
+            header: SdtHeader,
+        }
+
+        unsafe impl AcpiTable for RootTable {
+            const SIGNATURE: Signature = Signature::$signature_name;
+
+            fn header(&self) -> &SdtHeader {
+                &self.header
+            }
+        }
+
+        // Map and validate root table
+        // SAFETY: Addresses from a validated RSDP are also guaranteed to be valid.
+        let table_mapping = unsafe { read_table::<_, RootTable>($acpi_handler.clone(), $address) }?;
+
+        // Convert `table_mapping` to header mapping for storage
+        // Avoid requesting table unmap twice (from both original and converted `table_mapping`s)
+        let table_mapping = mem::ManuallyDrop::new(table_mapping);
+        // SAFETY: `SdtHeader` is equivalent to `Sdt` memory-wise
+        let table_mapping = unsafe {
+            PhysicalMapping::new(
+                table_mapping.physical_start(),
+                table_mapping.virtual_start().cast::<SdtHeader>(),
+                table_mapping.region_length(),
+                table_mapping.mapped_length(),
+                $acpi_handler.clone(),
+            )
+        };
+
+        table_mapping
+    }};
+}
+
 /// Type capable of enumerating the existing ACPI tables on the system.
 ///
 ///
@@ -199,61 +236,44 @@ where
     ///
     /// ### 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> {
-        macro_rules! read_root_table {
-            ($signature_name:ident, $address_getter:ident) => {{
-                #[repr(transparent)]
-                struct RootTable {
-                    header: SdtHeader,
-                }
-
-                unsafe impl AcpiTable for RootTable {
-                    const SIGNATURE: Signature = Signature::$signature_name;
-
-                    fn header(&self) -> &SdtHeader {
-                        &self.header
-                    }
-                }
+        let revision = rsdp_mapping.revision();
+        let root_table_mapping = if revision == 0 {
+            /*
+             * We're running on ACPI Version 1.0. We should use the 32-bit RSDT address.
+             */
+            let table_phys_start = rsdp_mapping.rsdt_address() as usize;
+            drop(rsdp_mapping);
+            read_root_table!(RSDT, table_phys_start, handler)
+        } else {
+            /*
+             * We're running on ACPI Version 2.0+. We should use the 64-bit XSDT address, truncated
+             * to 32 bits on x86.
+             */
+            let table_phys_start = rsdp_mapping.xsdt_address() as usize;
+            drop(rsdp_mapping);
+            read_root_table!(XSDT, table_phys_start, handler)
+        };
 
-                // Unmap RSDP as soon as possible
-                let table_phys_start = rsdp_mapping.$address_getter() as usize;
-                drop(rsdp_mapping);
-
-                // Map and validate root table
-                // SAFETY: Addresses from a validated RSDP are also guaranteed to be valid.
-                let table_mapping = unsafe { read_table::<_, RootTable>(handler.clone(), table_phys_start) }?;
-
-                // Convert `table_mapping` to header mapping for storage
-                // Avoid requesting table unmap twice (from both original and converted `table_mapping`s)
-                let table_mapping = mem::ManuallyDrop::new(table_mapping);
-                // SAFETY: `SdtHeader` is equivalent to `Sdt` memory-wise
-                let table_mapping = unsafe {
-                    PhysicalMapping::new(
-                        table_mapping.physical_start(),
-                        table_mapping.virtual_start().cast::<SdtHeader>(),
-                        table_mapping.region_length(),
-                        table_mapping.mapped_length(),
-                        handler.clone(),
-                    )
-                };
-
-                table_mapping
-            }};
-        }
+        Ok(Self { mapping: root_table_mapping, revision, handler })
+    }
 
-        let revision = rsdp_mapping.revision();
+    /// 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.
+    pub unsafe fn from_rsdt(handler: H, revision: u8, address: usize) -> AcpiResult<Self> {
         let root_table_mapping = if revision == 0 {
             /*
              * We're running on ACPI Version 1.0. We should use the 32-bit RSDT address.
              */
 
-            read_root_table!(RSDT, rsdt_address)
+            read_root_table!(RSDT, address, handler)
         } else {
             /*
              * We're running on ACPI Version 2.0+. We should use the 64-bit XSDT address, truncated
              * to 32 bits on x86.
              */
 
-            read_root_table!(XSDT, xsdt_address)
+            read_root_table!(XSDT, address, handler)
         };
 
         Ok(Self { mapping: root_table_mapping, revision, handler })
@@ -490,9 +510,7 @@ where
                 log::warn!("Found invalid SDT at physical address {:p}: {:?}", table_phys_ptr, r);
                 continue;
             }
-            let result = header_mapping.clone();
-            drop(header_mapping);
-            return Some(result);
+            return Some(*header_mapping);
         }
     }
 }

acpi/src/madt.rs

@@ -293,6 +293,8 @@ impl Madt {
                     local_apic_address = entry.local_apic_address;
                 }
 
+                MadtEntry::MultiprocessorWakeup(_) => {}
+
                 _ => {
                     return Err(AcpiError::InvalidMadt(MadtError::UnexpectedEntry));
                 }

aml_tester/src/main.rs

@@ -12,7 +12,8 @@
 use aml::{AmlContext, DebugVerbosity};
 use clap::{Arg, ArgAction, ArgGroup};
 use std::{
-    collections::HashSet,
+    cell::RefCell,
+    collections::{HashMap, HashSet},
     ffi::OsStr,
     fs::{self, File},
     io::{Read, Write},
@@ -30,19 +31,23 @@ enum CompilationOutcome {
 }
 
 fn main() -> std::io::Result<()> {
-    log::set_logger(&Logger).unwrap();
-    log::set_max_level(log::LevelFilter::Trace);
-
-    let matches = clap::Command::new("aml_tester")
+    let mut cmd = clap::Command::new("aml_tester")
         .version("v0.1.0")
         .author("Isaac Woods")
         .about("Compiles and tests ASL files")
         .arg(Arg::new("no_compile").long("no-compile").action(ArgAction::SetTrue).help("Don't compile asl to aml"))
         .arg(Arg::new("reset").long("reset").action(ArgAction::SetTrue).help("Clear namespace after each file"))
         .arg(Arg::new("path").short('p').long("path").required(false).action(ArgAction::Set).value_name("DIR"))
         .arg(Arg::new("files").action(ArgAction::Append).value_name("FILE.{asl,aml}"))
-        .group(ArgGroup::new("files_list").args(["path", "files"]).required(true))
-        .get_matches();
+        .group(ArgGroup::new("files_list").args(["path", "files"]).required(true));
+    if std::env::args().count() <= 1 {
+        cmd.print_help()?;
+        return Ok(());
+    }
+    log::set_logger(&Logger).unwrap();
+    log::set_max_level(log::LevelFilter::Trace);
+
+    let matches = cmd.get_matches();
 
     // Get an initial list of files - may not work correctly on non-UTF8 OsString
     let files: Vec<String> = if matches.contains_id("path") {
@@ -110,17 +115,23 @@ fn main() -> std::io::Result<()> {
 
     // Make a list of the files we have processed, and skip them if we see them again
     let mut dedup_list: HashSet<PathBuf> = HashSet::new();
-
+    let summaries: RefCell<HashSet<(PathBuf, &str)>> = RefCell::new(HashSet::new());
     // Filter down to the final list of AML files
     let aml_files = compiled_files
         .iter()
         .filter_map(|outcome| match outcome {
             CompilationOutcome::IsAml(path) => Some(path.clone()),
             CompilationOutcome::Newer(path) => Some(path.clone()),
             CompilationOutcome::Succeeded(path) => Some(path.clone()),
-            CompilationOutcome::Ignored | CompilationOutcome::Failed(_) | CompilationOutcome::NotCompiled(_) => {
+            CompilationOutcome::Failed(path) => {
+                summaries.borrow_mut().insert((path.clone(), "COMPILE FAILED"));
                 None
             }
+            CompilationOutcome::NotCompiled(path) => {
+                summaries.borrow_mut().insert((path.clone(), "NotCompiled"));
+                None
+            }
+            CompilationOutcome::Ignored => None,
         })
         .filter(|path| {
             if dedup_list.contains(path) {
@@ -138,7 +149,7 @@ fn main() -> std::io::Result<()> {
         print!("Testing AML file: {:?}... ", file_entry);
         std::io::stdout().flush().unwrap();
 
-        let mut file = File::open(file_entry).unwrap();
+        let mut file = File::open(&file_entry).unwrap();
         let mut contents = Vec::new();
         file.read_to_end(&mut contents).unwrap();
 
@@ -152,18 +163,25 @@ fn main() -> std::io::Result<()> {
             Ok(()) => {
                 println!("{}OK{}", termion::color::Fg(termion::color::Green), termion::style::Reset);
                 println!("Namespace: {:#?}", context.namespace);
+                summaries.borrow_mut().insert((file_entry, "PASS"));
                 (passed + 1, failed)
             }
 
             Err(err) => {
                 println!("{}Failed ({:?}){}", termion::color::Fg(termion::color::Red), err, termion::style::Reset);
                 println!("Namespace: {:#?}", context.namespace);
+                summaries.borrow_mut().insert((file_entry, "PARSE FAIL"));
                 (passed, failed + 1)
             }
         }
     });
 
-    println!("Test results: {} passed, {} failed", passed, failed);
+    // Print summaries
+    println!("Summary:");
+    for (file, status) in summaries.borrow().iter() {
+        println!("{:<50}: {}", file.to_str().unwrap(), status);
+    }
+    println!("\nTest results:\n\tpassed:{}\n\tfailed:{}", passed, failed);
     Ok(())
 }