Apply some suggestions from Clippy

Author: YtvwlD

towboot/src/boot/config_tables.rs

@@ -19,22 +19,17 @@ use uefi::table::cfg::{
 pub(super) fn parse_for_multiboot(info_builder: &mut InfoBuilder) {
     // first, copy all config table pointers
     // TODO: remove this when with_config_table takes a FnMut
-    let config_tables: Vec<ConfigTableEntry> = with_config_table(|s|
-        s.to_vec()
-    );
+    let config_tables: Vec<ConfigTableEntry> = with_config_table(<[ConfigTableEntry]>::to_vec);
     debug!("going through configuration tables...");
     for table in config_tables {
         match table.guid {
-            ACPI_GUID => handle_acpi(&table, info_builder),
-            ACPI2_GUID => handle_acpi(&table, info_builder),
+            ACPI_GUID | ACPI2_GUID => handle_acpi(&table, info_builder),
             DEBUG_IMAGE_INFO_GUID => debug!("ignoring image debug info"),
             DXE_SERVICES_GUID => debug!("ignoring dxe services table"),
             HAND_OFF_BLOCK_LIST_GUID => debug!("ignoring hand-off block list"),
             LZMA_COMPRESS_GUID => debug!("ignoring lzma filesystem"),
-            MEMORY_STATUS_CODE_RECORD_GUID => debug!("ignoring early memory info"),
-            MEMORY_TYPE_INFORMATION_GUID => debug!("ignoring early memory info"),
-            SMBIOS_GUID => handle_smbios(&table, info_builder),
-            SMBIOS3_GUID => handle_smbios(&table, info_builder),
+            MEMORY_STATUS_CODE_RECORD_GUID | MEMORY_TYPE_INFORMATION_GUID => debug!("ignoring early memory info"),
+            SMBIOS_GUID | SMBIOS3_GUID => handle_smbios(&table, info_builder),
             guid => debug!("ignoring table {guid}"),
         }
     }
@@ -43,7 +38,7 @@ pub(super) fn parse_for_multiboot(info_builder: &mut InfoBuilder) {
 /// Parse the ACPI RSDP and create the Multiboot struct for it.
 fn handle_acpi(table: &ConfigTableEntry, info_builder: &mut InfoBuilder) {
     debug!("handling ACPI RSDP");
-    let rsdp = unsafe { *(table.address as *const Rsdp) };
+    let rsdp: Rsdp = unsafe { *(table.address.cast()) };
     if rsdp.validate().is_err() {
         warn!("the RSDP is invalid");
         return;
@@ -90,9 +85,7 @@ fn handle_acpi(table: &ConfigTableEntry, info_builder: &mut InfoBuilder) {
 /// Caveat: The Structure Table pointer in the Entry Point is not adjusted.
 fn handle_smbios(table: &ConfigTableEntry, info_builder: &mut InfoBuilder) {
     debug!("handling SMBIOS table");
-    let bigger_slice = unsafe { slice::from_raw_parts(
-        table.address as *const u8, 128,
-    ) };
+    let bigger_slice = unsafe { slice::from_raw_parts(table.address.cast(), 128) };
     match EntryPoint::search(bigger_slice) {
         Ok(entry_point) => {
             let version = entry_point.to_version();

towboot/src/boot/elf.rs

@@ -28,8 +28,8 @@ impl OurElfLoader {
     /// Create a new instance.
     ///
     /// The parameter is the virtual address of the entry point.
-    pub(super) fn new(entry_point: u64) -> Self {
-        OurElfLoader {
+    pub(super) const fn new(entry_point: u64) -> Self {
+        Self {
             allocations: BTreeMap::new(),
             virtual_entry_point: entry_point,
             physical_entry_point: None,
@@ -46,7 +46,7 @@ impl OurElfLoader {
         for program_header in &binary.program_headers {
             if program_header.p_type == elf::program_header::PT_LOAD {
                 self.allocate(program_header, quirks)?;
-                self.load(program_header.p_vaddr, &data[program_header.file_range()])?;
+                self.load(program_header.p_vaddr, &data[program_header.file_range()]);
             }
         }
         Ok(())
@@ -57,12 +57,10 @@ impl OurElfLoader {
     /// We should have found it in `allocate`,
     /// else fall back to the virtual one and hope for the best.
     pub(super) fn entry_point(&self) -> usize {
-        if let Some(a) = self.physical_entry_point {
-            a
-        } else {
+        self.physical_entry_point.unwrap_or_else(|| {
             warn!("didn't find the entry point while loading sections, assuming virtual = physical");
             self.virtual_entry_point.try_into().unwrap()
-        }
+        })
     }
 
     /// Allocate memory for a segment.
@@ -103,7 +101,7 @@ impl OurElfLoader {
     }
 
     /// Load a segment.
-    fn load(&mut self, base: u64, region: &[u8]) -> Result<(), &'static str> {
+    fn load(&mut self, base: u64, region: &[u8]) {
         // check whether we actually allocated this
         match self.allocations.get_mut(&base) {
             None => panic!("we didn't allocate {base:#x}, but tried to write to it o.O"),
@@ -117,15 +115,14 @@ impl OurElfLoader {
                     "load {} bytes into {:#x} (at {:#x})", region.len(), base, ptr as usize
                 );
                 alloc.as_mut_slice()[0..region.len()].clone_from_slice(region);
-                Ok(())
             },
         }
     }
 }
 
 impl From<OurElfLoader> for Vec<Allocation> {
     /// Gets the allocated memory.
-    fn from(loader: OurElfLoader) -> Vec<Allocation> {
+    fn from(loader: OurElfLoader) -> Self {
         // using .values() would just borrow the values from the hash map
         loader.allocations.into_values().collect()
     }

towboot/src/boot/mod.rs

@@ -59,18 +59,18 @@ impl LoadedKernel {
     /// Load a kernel from a vector.
     /// This requires that the Multiboot header has already been parsed.
     fn new(
-        kernel_vec: Vec<u8>, header: &Header, quirks: &BTreeSet<Quirk>,
+        kernel_bytes: &[u8], header: &Header, quirks: &BTreeSet<Quirk>,
     ) -> Result<Self, Status> {
         if header.get_load_addresses().is_some() && !quirks.contains(&Quirk::ForceElf) {
-            LoadedKernel::new_multiboot(kernel_vec, header, quirks)
+            Self::new_multiboot(kernel_bytes, header, quirks)
         } else {
-            LoadedKernel::new_elf(header, kernel_vec, quirks)
+            Self::new_elf(header, kernel_bytes, quirks)
         }
     }
 
     /// Load a kernel which has its addresses specified inside the Multiboot header.
     fn new_multiboot(
-        kernel_vec: Vec<u8>, header: &Header, quirks: &BTreeSet<Quirk>,
+        kernel_bytes: &[u8], header: &Header, quirks: &BTreeSet<Quirk>,
     ) -> Result<Self, Status> {
         // TODO: Add support for AOut symbols? Do we really know this binary is AOut at this point?
         let addresses = header.get_load_addresses().unwrap();
@@ -82,7 +82,7 @@ impl LoadedKernel {
         let load_offset = addresses.compute_load_offset(header.header_start());
         // allocate
         let kernel_length: usize = addresses.compute_kernel_length(
-            kernel_vec.len().try_into().unwrap()
+            kernel_bytes.len().try_into().unwrap()
         ).try_into().unwrap();
         let mut allocation = Allocation::new_at(
             addresses.load_addr().try_into().unwrap(),
@@ -92,14 +92,12 @@ impl LoadedKernel {
         let kernel_buf = allocation.as_mut_slice();
         // copy from beginning of text to end of data segment and fill the rest with zeroes
         kernel_buf.iter_mut().zip(
-            kernel_vec.iter()
+            kernel_bytes.iter()
             .skip(load_offset.try_into().unwrap())
             .take(kernel_length)
             .chain(core::iter::repeat(&0))
         )
         .for_each(|(dst,src)| *dst = *src);
-        // drop the old vector
-        core::mem::drop(kernel_vec);
 
         let entry_point = get_kernel_uefi_entry(header, quirks)
             .or(header.get_entry_address().map(
@@ -119,20 +117,20 @@ impl LoadedKernel {
 
     /// Load a kernel which uses ELF semantics.
     fn new_elf(
-        header: &Header, kernel_vec: Vec<u8>, quirks: &BTreeSet<Quirk>,
+        header: &Header, kernel_bytes: &[u8], quirks: &BTreeSet<Quirk>,
     ) -> Result<Self, Status> {
-        let mut binary = Elf::parse(kernel_vec.as_slice()).map_err(|msg| {
+        let mut binary = Elf::parse(kernel_bytes).map_err(|msg| {
             error!("failed to parse ELF structure of kernel: {msg}");
             Status::LOAD_ERROR
         })?;
         let mut loader = OurElfLoader::new(binary.entry);
         loader
-            .load_elf(&binary, kernel_vec.as_slice(), quirks)
+            .load_elf(&binary, kernel_bytes, quirks)
             .map_err(|msg| {
                 error!("failed to load kernel: {msg}");
                 Status::LOAD_ERROR
             })?;
-        let symbols = Some(elf::symbols(header, &mut binary, kernel_vec.as_slice()));
+        let symbols = Some(elf::symbols(header, &mut binary, kernel_bytes));
         let entry_point = get_kernel_uefi_entry(header, quirks)
             .or(header.get_entry_address().map(
                 |e| EntryPoint::Multiboot(e as usize)
@@ -206,7 +204,7 @@ fn get_kernel_uefi_entry(
 
 /// Prepare information for the kernel.
 fn prepare_multiboot_information(
-    entry: &Entry, header: Header, load_base_address: Option<u32>,
+    entry: &Entry, header: &Header, load_base_address: Option<u32>,
     modules: &[Allocation], symbols: Option<Symbols>,
     graphics_output: Option<ScopedProtocol<GraphicsOutput>>,
     boot_services_exited: bool,
@@ -316,14 +314,15 @@ impl<'a> PreparedEntry<'a> {
     /// This is non-destructive and will always return.
     pub(crate) fn new(
         entry: &'a Entry, image_fs_handle: Handle,
-    ) -> Result<PreparedEntry<'a>, Status> {
+    ) -> Result<Self, Status> {
         let kernel_vec: Vec<u8> = File::open(&entry.image, image_fs_handle)?.try_into()?;
         let header = Header::from_slice(kernel_vec.as_slice()).ok_or_else(|| {
             error!("invalid Multiboot header");
             Status::LOAD_ERROR
         })?;
         debug!("loaded kernel {:?} to {:?}", header, kernel_vec.as_ptr());
-        let mut loaded_kernel = LoadedKernel::new(kernel_vec, &header, &entry.quirks)?;
+        let mut loaded_kernel = LoadedKernel::new(&kernel_vec, &header, &entry.quirks)?;
+        core::mem::drop(kernel_vec);
         info!("kernel is loaded and bootable");
 
         // Load all modules, fail completely if one fails to load.
@@ -340,7 +339,7 @@ impl<'a> PreparedEntry<'a> {
         let graphics_output = video::setup_video(&header, &entry.quirks);
 
         let multiboot_information = prepare_multiboot_information(
-            entry, header, loaded_kernel.load_base_address, &modules_vec,
+            entry, &header, loaded_kernel.load_base_address, &modules_vec,
             loaded_kernel.symbols_struct(), graphics_output,
             !entry.quirks.contains(&Quirk::DontExitBootServices),
         );
@@ -414,7 +413,7 @@ impl<'a> PreparedEntry<'a> {
         // The kernel is going to need the section headers and symbols.
         core::mem::forget(self.loaded_kernel.symbols);
 
-        self.loaded_kernel.entry_point.jump(signature, info)
+        self.loaded_kernel.entry_point.jump(signature, &info)
     }
 }
 
@@ -435,19 +434,19 @@ enum EntryPoint {
 impl EntryPoint {
     /// Jump to the loaded kernel.
     /// This requires everything else to be ready and won't return.
-    fn jump(self, signature: u32, info: Vec<u8>) -> ! {
+    fn jump(self, signature: u32, info: &[u8]) -> ! {
         if let Self::Uefi(entry_address) = self {
-            self.jump_uefi(entry_address, signature, info)
+            Self::jump_uefi(entry_address, signature, info)
         } else if let Self::Multiboot(entry_address) = self {
-            self.jump_multiboot(entry_address, signature, info)
+            Self::jump_multiboot(entry_address, signature, info)
         } else {
             panic!("invalid entry point")
         }
     }
 
     /// Jump to the loaded kernel, UEFI-style, eg. just passing the information.
     /// This requires everything else to be ready and won't return.
-    fn jump_uefi(self, entry_address: usize, signature: u32, info: Vec<u8>) -> ! {
+    fn jump_uefi(entry_address: usize, signature: u32, info: &[u8]) -> ! {
         debug!("jumping to 0x{entry_address:x}");
         unsafe {
             // TODO: The spec mentions 32 bit registers, even on 64 bit.
@@ -459,15 +458,15 @@ impl EntryPoint {
                 "jmp {}",
                 in(reg) entry_address,
                 in("eax") signature,
-                in("ecx") &info.as_slice()[0],
+                in("ecx") &raw const info[0],
                 options(noreturn),
             );
         }
     }
 
     /// i686-specific part of the Multiboot machine state.
     #[cfg(target_arch = "x86")]
-    fn jump_multiboot(self, entry_address: usize, signature: u32, info: Vec<u8>) -> ! {
+    fn jump_multiboot(entry_address: usize, signature: u32, info: &[u8]) -> ! {
         debug!("preparing machine state and jumping to 0x{entry_address:x}");
 
         // 3.2 Machine state says:
@@ -497,7 +496,7 @@ impl EntryPoint {
                 sym Self::jump_multiboot_common,
                 // LLVM needs some registers (https://github.com/rust-lang/rust/blob/1.67.1/compiler/rustc_target/src/asm/x86.rs#L206)
                 in("eax") signature,
-                in("ecx") &info.as_slice()[0],
+                in("ecx") &raw const info[0],
                 in("edi") entry_address,
                 options(noreturn),
             );
@@ -506,7 +505,7 @@ impl EntryPoint {
 
     /// x86_64-specific part of the Multiboot machine state.
     #[cfg(target_arch = "x86_64")]
-    fn jump_multiboot(self, entry_address: usize, signature: u32, info: Vec<u8>) -> ! {
+    fn jump_multiboot(entry_address: usize, signature: u32, info: &[u8]) -> ! {
         debug!("preparing machine state and jumping to 0x{entry_address:x}");
 
         // 3.2 Machine state says:
@@ -576,7 +575,7 @@ impl EntryPoint {
                 sym Self::jump_multiboot_common,
                 // LLVM needs some registers (https://github.com/rust-lang/rust/blob/1.67.1/compiler/rustc_target/src/asm/x86.rs#L206)
                 in("eax") signature,
-                in("ecx") &info.as_slice()[0],
+                in("ecx") &raw const info[0],
                 in("edi") entry_address,
                 options(noreturn),
             );

towboot/src/mem.rs

@@ -64,7 +64,7 @@ impl Allocation {
     /// You can move the allocated memory later to the correct address by calling
     /// [`move_to_where_it_should_be`], but please keep its safety implications in mind.
     /// This only works for our code and data by default, but this can be
-    /// overridden with the ForceOverwrite quirk.
+    /// overridden with the `ForceOverwrite` quirk.
     ///
     /// [`move_to_where_it_should_be`]: struct.Allocation.html#method.move_to_where_it_should_be
     pub(crate) fn new_at(
@@ -83,7 +83,7 @@ impl Allocation {
             MemoryType::LOADER_DATA,
             count_pages,
         ) {
-            Ok(ptr) => Ok(Allocation {
+            Ok(ptr) => Ok(Self {
                 ptr,
                 offset: page_offset,
                 len: size,
@@ -155,13 +155,13 @@ impl Allocation {
                 get_memory_map();
                 Status::LOAD_ERROR
             })?;
-        Ok(Allocation {
+        Ok(Self {
             ptr, offset: 0, len: size, pages: count_pages, should_be_at: None,
         })
     }
 
     /// Return a slice that references the associated memory.
-    pub(crate) fn as_mut_slice(&mut self) -> &mut [u8] {
+    pub(crate) const fn as_mut_slice(&mut self) -> &mut [u8] {
         unsafe { core::slice::from_raw_parts_mut(
             self.ptr.as_ptr().add(self.offset),
             self.len,
@@ -300,9 +300,8 @@ pub(super) fn prepare_information(
         .iter()
         // find the area starting at 1MB and get its length
         .find(|e| e.base_address() == 1024 * 1024)
-        .map(|e| e.length())
         // if there is none, it's 0KB
-        .unwrap_or(0) / 1024;
+        .map_or(0, |e| e.length()) / 1024;
 
     // When updating either uefi.rs or multiboot2, make sure that the types
     // still match.

towboot/src/menu.rs

@@ -5,7 +5,7 @@ use alloc::string::String;
 
 use uefi::prelude::*;
 use uefi::boot::{EventType, TimerTrigger, Tpl, create_event, set_timer, wait_for_event};
-use uefi::proto::console::text::{Key, ScanCode};
+use uefi::proto::console::text::{Input, Key, ScanCode};
 use uefi::system::{with_stdin, with_stdout};
 
 use log::{error, warn};
@@ -27,7 +27,7 @@ pub fn choose(config: &Config) -> &Entry {
         warn!("default entry is missing, trying the first one");
         config.entries.values().next().expect("no entries")
     });
-    if let Some(0) = config.timeout {
+    if config.timeout == Some(0) {
         return default_entry
     }
     match display_menu(config, default_entry) {
@@ -68,7 +68,7 @@ fn display_menu<'a>(
                 ]
             ).discard_errdata()? {
                 // key
-                0 => match with_stdin(|stdin| stdin.read_key())? {
+                0 => match with_stdin(Input::read_key)? {
                     Some(Key::Special(ScanCode::ESCAPE)) => break,
                     _ => (),
                 },
@@ -108,9 +108,7 @@ fn select_entry(entries: &BTreeMap<String, Entry>) -> uefi::Result<&Entry> {
             // this is safe because we're never calling close_event
             &mut [unsafe { key_event.unsafe_clone() }]
         ).discard_errdata()?;
-        if let Some(Key::Printable(c)) = with_stdin(
-            |stdin| stdin.read_key()
-        )? {
+        if let Some(Key::Printable(c)) = with_stdin(Input::read_key)? {
             match c.into() {
                 '\r' => break, // enter
                 '\u{8}' => {value.pop();}, // backspace

towboot_config/src/config.rs

@@ -19,9 +19,9 @@ pub struct Config {
 
 impl Config {
     /// Determine which files are referenced in the configuration.
-    pub fn needed_files(self: &mut Config) -> Vec<&mut String> {
+    pub fn needed_files(&mut self) -> Vec<&mut String> {
         let mut files = Vec::new();
-        for (_name, entry) in self.entries.iter_mut() {
+        for entry in self.entries.values_mut() {
             files.push(&mut entry.image);
             for module in &mut entry.modules {
                 files.push(&mut module.image);