fix clippy

Author: szy

src/vmm/config.rs

@@ -4,17 +4,21 @@ use axvm::{
     config::{AxVMConfig, AxVMCrateConfig, VmMemMappingType},
 };
 use core::alloc::Layout;
-use fdt_parser::Fdt;
 use memory_addr::MemoryAddr;
 
 use crate::vmm::{VM, images::ImageLoader, vm_list::push_vm};
 
 #[cfg(target_arch = "aarch64")]
 use crate::vmm::fdt::*;
 
+#[cfg(target_arch = "aarch64")]
+use fdt_parser::Fdt;
+
+#[cfg(target_arch = "aarch64")]
+use alloc::vec::Vec;
+
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
-use alloc::vec::Vec;
 use lazyinit::LazyInit;
 use spin::Mutex;
 
@@ -48,16 +52,12 @@ pub mod config {
         let mut configs = Vec::new();
 
         if let Ok(entries) = fs::read_dir(config_dir) {
-            for entry in entries {
-                if let Ok(entry) = entry {
-                    let path = entry.path();
-                    // Check if the file has a .toml extension
-                    let path_str = path.as_str();
-                    if path_str.ends_with(".toml") {
-                        if let Ok(content) = fs::read_to_string(path_str) {
-                            configs.push(content);
-                        }
-                    }
+            for entry in entries.flatten() {
+                let path = entry.path();
+                // Check if the file has a .toml extension
+                let path_str = path.as_str();
+                if path_str.ends_with(".toml") && let Ok(content) = fs::read_to_string(path_str) {
+                    configs.push(content);
                 }
             }
         }
@@ -74,6 +74,7 @@ pub mod config {
     include!(concat!(env!("OUT_DIR"), "/vm_configs.rs"));
 }
 
+#[cfg(target_arch = "aarch64")]
 pub fn get_developer_provided_dtb(
     vm_cfg: &AxVMConfig,
     crate_config: &AxVMCrateConfig,
@@ -94,7 +95,7 @@ pub fn get_developer_provided_dtb(
             use axerrno::ax_err_type;
             use std::io::{BufReader, Read};
             if let Some(dtb_path) = &crate_config.kernel.dtb_path {
-                let (dtb_file, dtb_size) = crate::vmm::images::open_image_file(&dtb_path).unwrap();
+                let (dtb_file, dtb_size) = crate::vmm::images::open_image_file(dtb_path).unwrap();
                 info!("DTB file in fs, size: 0x{:x}", dtb_size);
 
                 let mut file = BufReader::new(dtb_file);
@@ -133,7 +134,7 @@ pub fn get_vm_dtb_arc(vm_cfg: &AxVMConfig) -> Option<Arc<[u8]>> {
 fn handle_fdt_operations(vm_config: &mut AxVMConfig, vm_create_config: &AxVMCrateConfig) {
     let host_fdt_bytes = get_host_fdt();
     let host_fdt = Fdt::from_bytes(host_fdt_bytes)
-        .map_err(|e| format!("Failed to parse FDT: {:#?}", e))
+        .map_err(|e| format!("Failed to parse FDT: {e:#?}"))
         .expect("Failed to parse FDT");
     set_phys_cpu_sets(vm_config, &host_fdt, vm_create_config);
 
@@ -185,8 +186,12 @@ pub fn init_guest_vms() {
             );
         }
 
+        #[cfg(target_arch = "aarch64")]
         let mut vm_config = AxVMConfig::from(vm_create_config.clone());
 
+        #[cfg(not(target_arch = "aarch64"))]
+        let vm_config = AxVMConfig::from(vm_create_config.clone());
+
         // Handle FDT-related operations for aarch64
         #[cfg(target_arch = "aarch64")]
         handle_fdt_operations(&mut vm_config, &vm_create_config);

src/vmm/fdt/create.rs

@@ -24,7 +24,7 @@ use crate::vmm::{VMRef, images::load_vm_image_from_memory};
 /// Returns the generated DTB data
 pub fn crate_guest_fdt(
     fdt: &Fdt,
-    passthrough_device_names: &Vec<String>,
+    passthrough_device_names: &[String],
     crate_config: &AxVMCrateConfig,
 ) -> Vec<u8> {
     let mut fdt_writer = FdtWriter::new().unwrap();
@@ -96,9 +96,7 @@ pub fn crate_guest_fdt(
     }
     assert_eq!(previous_node_level, 0);
 
-    let guest_fdt_bytes = fdt_writer.finish().unwrap();
-
-    guest_fdt_bytes
+    fdt_writer.finish().unwrap()
 }
 
 /// Generate guest FDT cache the result
@@ -133,29 +131,29 @@ enum NodeAction {
 fn determine_node_action(
     node: &Node,
     node_path: &str,
-    passthrough_device_names: &Vec<String>,
+    passthrough_device_names: &[String],
 ) -> NodeAction {
     if node.name() == "/" {
         // Special handling for root node
-        return NodeAction::RootNode;
+        NodeAction::RootNode
     } else if node.name().starts_with("memory") {
         // Skip memory nodes, will add them later
-        return NodeAction::Skip;
+        NodeAction::Skip
     } else if node_path.starts_with("/cpus") {
-        return NodeAction::CpuNode;
+        NodeAction::CpuNode
     } else if passthrough_device_names.contains(&node_path.to_string()) {
         // Fully matched passthrough device node
-        return NodeAction::IncludeAsPassthroughDevice;
+        NodeAction::IncludeAsPassthroughDevice
     }
     // Check if the node is a descendant of a passthrough device (by path inclusion and level validation)
     else if is_descendant_of_passthrough_device(node_path, node.level, passthrough_device_names) {
-        return NodeAction::IncludeAsChildNode;
+        NodeAction::IncludeAsChildNode
     }
     // Check if the node is an ancestor of a passthrough device (by path inclusion and level validation)
     else if is_ancestor_of_passthrough_device(node_path, passthrough_device_names) {
-        return NodeAction::IncludeAsAncestorNode;
+        NodeAction::IncludeAsAncestorNode
     } else {
-        return NodeAction::Skip;
+        NodeAction::Skip
     }
 }
 
@@ -165,7 +163,7 @@ fn determine_node_action(
 fn is_descendant_of_passthrough_device(
     node_path: &str,
     node_level: usize,
-    passthrough_device_names: &Vec<String>,
+    passthrough_device_names: &[String],
 ) -> bool {
     for passthrough_path in passthrough_device_names {
         // Check if the current node is a descendant of a passthrough device
@@ -180,9 +178,9 @@ fn is_descendant_of_passthrough_device(
 
                 // If passthrough_path is the root node "/", then its child node level should be 2
                 // Otherwise, the child node level should be higher than the parent node level
-                if passthrough_path == "/" && current_node_level >= 2 {
-                    return true;
-                } else if passthrough_path != "/" && current_node_level > expected_parent_level {
+                if (passthrough_path == "/" && current_node_level >= 2)
+                    || (passthrough_path != "/" && current_node_level > expected_parent_level)
+                {
                     return true;
                 }
             }
@@ -210,11 +208,11 @@ fn handle_node_level_change(
 /// Determine if node is an ancestor of passthrough device
 fn is_ancestor_of_passthrough_device(
     node_path: &str,
-    passthrough_device_names: &Vec<String>,
+    passthrough_device_names: &[String],
 ) -> bool {
     for passthrough_path in passthrough_device_names {
         // Check if the current node is an ancestor of a passthrough device
-        if passthrough_path.starts_with(&node_path) && passthrough_path.len() > node_path.len() {
+        if passthrough_path.starts_with(node_path) && passthrough_path.len() > node_path.len() {
             // Ensure it is a true ancestor path (separated by /)
             let next_char = passthrough_path.chars().nth(node_path.len()).unwrap_or(' ');
             if next_char == '/' || node_path == "/" {
@@ -226,36 +224,33 @@ fn is_ancestor_of_passthrough_device(
 }
 
 /// Determine if CPU node is needed
-fn need_cpu_node(phys_cpu_ids: &Vec<usize>, node: &Node, node_path: &str) -> bool {
+fn need_cpu_node(phys_cpu_ids: &[usize], node: &Node, node_path: &str) -> bool {
     let mut should_include_node = false;
 
     if !node_path.starts_with("/cpus/cpu@") {
         should_include_node = true;
-    } else {
-        if let Some(mut cpu_reg) = node.reg() {
-            if let Some(reg_entry) = cpu_reg.next() {
-                let cpu_address = reg_entry.address as usize;
-                debug!(
-                    "Checking CPU node {} with address 0x{:x}",
-                    node.name(),
-                    cpu_address
-                );
-                // Check if this CPU address is in the configured phys_cpu_ids
-                if phys_cpu_ids.contains(&cpu_address) {
-                    should_include_node = true;
-                    debug!(
-                        "CPU node {} with address 0x{:x} is in phys_cpu_ids, including in guest FDT",
-                        node.name(),
-                        cpu_address
-                    );
-                } else {
-                    debug!(
-                        "CPU node {} with address 0x{:x} is NOT in phys_cpu_ids, skipping",
-                        node.name(),
-                        cpu_address
-                    );
-                }
-            }
+    } else if let Some(mut cpu_reg) = node.reg()
+        && let Some(reg_entry) = cpu_reg.next() {
+        let cpu_address = reg_entry.address as usize;
+        debug!(
+            "Checking CPU node {} with address 0x{:x}",
+            node.name(),
+            cpu_address
+        );
+        // Check if this CPU address is in the configured phys_cpu_ids
+        if phys_cpu_ids.contains(&cpu_address) {
+            should_include_node = true;
+            debug!(
+                "CPU node {} with address 0x{:x} is in phys_cpu_ids, including in guest FDT",
+                node.name(),
+                cpu_address
+            );
+        } else {
+            debug!(
+                "CPU node {} with address 0x{:x} is NOT in phys_cpu_ids, skipping",
+                node.name(),
+                cpu_address
+            );
         }
     }
     should_include_node
@@ -415,7 +410,5 @@ pub fn update_cpu_node(fdt: &Fdt, host_fdt: &Fdt, crate_config: &AxVMCrateConfig
     }
     assert_eq!(previous_node_level, 0);
 
-    let guest_fdt_bytes = new_fdt.finish().unwrap();
-
-    guest_fdt_bytes
+    new_fdt.finish().unwrap()
 }

src/vmm/fdt/device.rs

@@ -178,11 +178,10 @@ pub fn find_all_passthrough_devices(vm_cfg: &mut AxVMConfig, fdt: &Fdt) -> Vec<S
 
 /// Build the full path of a node based on node level relationships
 /// Build the path by traversing all nodes and constructing paths based on level relationships to avoid path conflicts for nodes with the same name
-pub fn build_node_path(all_nodes: &Vec<Node>, target_index: usize) -> String {
+pub fn build_node_path(all_nodes: &[Node], target_index: usize) -> String {
     let mut path_stack: Vec<String> = Vec::new();
 
-    for i in 0..=target_index {
-        let node = &all_nodes[i];
+    for node in all_nodes.iter().take(target_index + 1) {
         let level = node.level;
 
         if level == 1 {
@@ -215,16 +214,15 @@ pub fn build_optimized_node_cache<'a>(fdt: &'a Fdt) -> BTreeMap<String, Vec<Node
 
     for (index, node) in all_nodes.iter().enumerate() {
         let node_path = build_node_path(&all_nodes, index);
-        if let Some(existing_nodes) = node_cache.get(&node_path) {
-            if !existing_nodes.is_empty() {
-                error!(
-                    "Duplicate node path found: {} for node '{}' at level {}, existing node: '{}'",
-                    node_path,
-                    node.name(),
-                    node.level,
-                    existing_nodes[0].name()
-                );
-            }
+        if let Some(existing_nodes) = node_cache.get(&node_path)
+            && !existing_nodes.is_empty() {
+            error!(
+                "Duplicate node path found: {} for node '{}' at level {}, existing node: '{}'",
+                node_path,
+                node.name(),
+                node.level,
+                existing_nodes[0].name()
+            );
         }
 
         trace!(
@@ -233,7 +231,7 @@ pub fn build_optimized_node_cache<'a>(fdt: &'a Fdt) -> BTreeMap<String, Vec<Node
         );
         node_cache
             .entry(node_path)
-            .or_insert_with(Vec::new)
+            .or_default()
             .push(node.clone());
     }
 
@@ -372,9 +370,8 @@ fn get_cells_count_for_property(prop_name: &str, cells_info: &BTreeMap<String, u
         "power-domains" => "#power-domain-cells",
         "phys" => "#phy-cells",
         "interrupts" | "interrupts-extended" => "#interrupt-cells",
-        "gpios" | _ if prop_name.ends_with("-gpios") || prop_name.ends_with("-gpio") => {
-            "#gpio-cells"
-        }
+        "gpios" => "#gpio-cells",
+        _ if prop_name.ends_with("-gpios") || prop_name.ends_with("-gpio") => "#gpio-cells",
         "dmas" => "#dma-cells",
         "thermal-sensors" => "#thermal-sensor-cells",
         "sound-dai" => "#sound-dai-cells",
@@ -405,7 +402,7 @@ fn parse_phandle_property(
     for (phandle, specifiers) in phandle_refs {
         if let Some((device_path, _cells_info)) = phandle_map.get(&phandle) {
             let spec_info = if !specifiers.is_empty() {
-                format!(" (specifiers: {:?})", specifiers)
+                format!(" (specifiers: {specifiers:?})")
             } else {
                 String::new()
             };
@@ -504,7 +501,7 @@ fn get_descendant_nodes_by_path<'a>(
     };
 
     // Traverse node_cache, find all nodes with parent path as prefix
-    for (path, _nodes) in node_cache {
+    for path in node_cache.keys() {
         // Check if path has parent path as prefix (and is not the parent path itself)
         if path.starts_with(&search_prefix) && path.len() > search_prefix.len() {
             // This is a descendant node path, add to results