acpi: fix clippy warnings and run clippy in CI (#230)

Now that all warnings have been fixed for the acpi crate, run clippy
as part of CI. Once the warnings for the rest of the crates are fixed,
they can be included in the CI run.

Author: 00xc

.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/src/handler.rs

@@ -51,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>,

acpi/src/lib.rs

@@ -28,7 +28,7 @@
 //! * 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**
+//!   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
@@ -200,7 +200,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()?;
@@ -212,6 +214,10 @@ 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
     /// 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`
@@ -222,7 +228,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 {
@@ -247,7 +255,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 {
             /*
@@ -408,7 +418,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,
@@ -431,7 +443,7 @@ where
     handler: H,
 }
 
-impl<'t, H> Iterator for SsdtIterator<'t, H>
+impl<H> Iterator for SsdtIterator<'_, H>
 where
     H: AcpiHandler,
 {
@@ -479,7 +491,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

@@ -53,11 +53,8 @@ unsafe impl AcpiTable for Madt {
 impl Madt {
     pub fn get_mpwk_mailbox_addr(&self) -> Result<u64, AcpiError> {
         for entry in self.entries() {
-            match entry {
-                MadtEntry::MultiprocessorWakeup(entry) => {
-                    return Ok(entry.mailbox_address);
-                }
-                _ => {}
+            if let MadtEntry::MultiprocessorWakeup(entry) = entry {
+                return Ok(entry.mailbox_address);
             }
         }
         Err(AcpiError::InvalidMadt(MadtError::UnexpectedEntry))

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,
 {

acpi/src/platform/mod.rs

@@ -102,7 +102,7 @@ where
 }
 
 #[cfg(feature = "alloc")]
-impl<'a> PlatformInfo<'a, alloc::alloc::Global> {
+impl PlatformInfo<'_, alloc::alloc::Global> {
     pub fn new<H>(tables: &AcpiTables<H>) -> AcpiResult<Self>
     where
         H: AcpiHandler,
@@ -111,7 +111,7 @@ impl<'a> PlatformInfo<'a, alloc::alloc::Global> {
     }
 }
 
-impl<'a, A> PlatformInfo<'a, A>
+impl<A> PlatformInfo<'_, A>
 where
     A: Allocator + Clone,
 {