misc: clippy: add needless_pass_by_value

This is a follow-up of [0]. # Advantages - This saves dozens of unneeded clone()s across the whole code base - Makes it much easier to reason about how parameters are used (often we passed owned Arc/Rc versions without actually needing ownership) # Exceptions For certain code paths, the alternatives would require awkward or overly complex code, and in some cases the functions are the logical owners of the values they take. In those cases, I've added #[allow(clippy::needless_pass_by_value)]. This does not mean that one should not improve this in the future. [0] 6a86c157af Signed-off-by: Philipp Schuster <philipp.schuster@cyberus-technology.de> On-behalf-of: SAP philipp.schuster@sap.com
2026-08-05 02:19:16 +00:00 · 2025-11-26 14:00:44 +01:00
parent ed4af3a005
commit c53781bf5f
53 changed files with 273 additions and 231 deletions
--- a/virtio-devices/src/balloon.rs
+++ b/virtio-devices/src/balloon.rs
@@ -342,8 +342,8 @@ impl BalloonEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.inflate_queue_evt.as_raw_fd(), INFLATE_QUEUE_EVENT)?;
@@ -639,7 +639,7 @@ impl VirtioDevice for Balloon {
            Thread::VirtioBalloon,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;
        self.common.epoll_threads = Some(epoll_threads);

--- a/virtio-devices/src/block.rs
+++ b/virtio-devices/src/block.rs
@@ -531,8 +531,8 @@ impl BlockEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), QUEUE_AVAIL_EVENT)?;
@@ -987,7 +987,7 @@ impl VirtioDevice for Block {
                Thread::VirtioBlock,
                &mut epoll_threads,
                &self.exit_evt,
-                move || handler.run(paused, paused_sync.unwrap()),
+                move || handler.run(&paused, paused_sync.as_ref().unwrap()),
            )?;
        }

--- a/virtio-devices/src/console.rs
+++ b/virtio-devices/src/console.rs
@@ -284,8 +284,8 @@ impl ConsoleEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.input_queue_evt.as_raw_fd(), INPUT_QUEUE_EVENT)?;
@@ -752,7 +752,7 @@ impl VirtioDevice for Console {
            Thread::VirtioConsole,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;

        self.common.epoll_threads = Some(epoll_threads);
--- a/virtio-devices/src/epoll_helper.rs
+++ b/virtio-devices/src/epoll_helper.rs
@@ -10,8 +10,8 @@

 use std::fs::File;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::sync::Barrier;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Barrier};
 use std::thread;

 use log::info;
@@ -153,8 +153,8 @@ impl EpollHelper {

    pub fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
        handler: &mut dyn EpollHelperHandler,
    ) -> std::result::Result<(), EpollHelperError> {
        self.run_with_timeout(paused, paused_sync, handler, -1, false)
@@ -163,8 +163,8 @@ impl EpollHelper {
    #[cfg(not(fuzzing))]
    pub fn run_with_timeout(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
        handler: &mut dyn EpollHelperHandler,
        timeout: i32,
        enable_event_list: bool,
@@ -250,8 +250,8 @@ impl EpollHelper {
    // and return when no epoll events are active
    pub fn run_with_timeout(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
        handler: &mut dyn EpollHelperHandler,
        _timeout: i32,
        _enable_event_list: bool,
--- a/virtio-devices/src/iommu.rs
+++ b/virtio-devices/src/iommu.rs
@@ -727,8 +727,8 @@ impl IommuEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.request_queue_evt.as_raw_fd(), REQUEST_Q_EVENT)?;
@@ -1110,7 +1110,7 @@ impl VirtioDevice for Iommu {
            Thread::VirtioIommu,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;

        self.common.epoll_threads = Some(epoll_threads);
--- a/virtio-devices/src/mem.rs
+++ b/virtio-devices/src/mem.rs
@@ -669,8 +669,8 @@ impl MemEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), QUEUE_AVAIL_EVENT)?;
@@ -879,13 +879,13 @@ impl Mem {

    pub fn remove_dma_mapping_handler(
        &mut self,
-        source: VirtioMemMappingSource,
+        source: &VirtioMemMappingSource,
    ) -> result::Result<(), Error> {
        let handler = self
            .dma_mapping_handlers
            .lock()
            .unwrap()
-            .remove(&source)
+            .remove(source)
            .ok_or(Error::InvalidDmaMappingHandler)?;

        let config = self.config.lock().unwrap();
@@ -1003,7 +1003,7 @@ impl VirtioDevice for Mem {
            Thread::VirtioMem,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;
        self.common.epoll_threads = Some(epoll_threads);

--- a/virtio-devices/src/net.rs
+++ b/virtio-devices/src/net.rs
@@ -75,8 +75,8 @@ impl NetCtrlEpollHandler {

    pub fn run_ctrl(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> std::result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), CTRL_QUEUE_EVENT)?;
@@ -266,8 +266,8 @@ impl NetEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt_pair.0.as_raw_fd(), RX_QUEUE_EVENT)?;
@@ -736,7 +736,7 @@ impl VirtioDevice for Net {
                Thread::VirtioNetCtl,
                &mut epoll_threads,
                &self.exit_evt,
-                move || ctrl_handler.run_ctrl(paused, paused_sync.unwrap()),
+                move || ctrl_handler.run_ctrl(&paused, paused_sync.as_ref().unwrap()),
            )?;
            self.ctrl_queue_epoll_thread = Some(epoll_threads.remove(0));
        }
@@ -814,7 +814,7 @@ impl VirtioDevice for Net {
                Thread::VirtioNet,
                &mut epoll_threads,
                &self.exit_evt,
-                move || handler.run(paused, paused_sync.unwrap()),
+                move || handler.run(&paused, paused_sync.as_ref().unwrap()),
            )?;
        }

--- a/virtio-devices/src/pmem.rs
+++ b/virtio-devices/src/pmem.rs
@@ -217,8 +217,8 @@ impl PmemEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), QUEUE_AVAIL_EVENT)?;
@@ -414,7 +414,7 @@ impl VirtioDevice for Pmem {
                Thread::VirtioPmem,
                &mut epoll_threads,
                &self.exit_evt,
-                move || handler.run(paused, paused_sync.unwrap()),
+                move || handler.run(&paused, paused_sync.as_ref().unwrap()),
            )?;

            self.common.epoll_threads = Some(epoll_threads);
--- a/virtio-devices/src/rng.rs
+++ b/virtio-devices/src/rng.rs
@@ -104,8 +104,8 @@ impl RngEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), QUEUE_AVAIL_EVENT)?;
@@ -281,7 +281,7 @@ impl VirtioDevice for Rng {
                Thread::VirtioRng,
                &mut epoll_threads,
                &self.exit_evt,
-                move || handler.run(paused, paused_sync.unwrap()),
+                move || handler.run(&paused, paused_sync.as_ref().unwrap()),
            )?;

            self.common.epoll_threads = Some(epoll_threads);
--- a/virtio-devices/src/seccomp_filters.rs
+++ b/virtio-devices/src/seccomp_filters.rs
@@ -11,6 +11,7 @@ use seccompiler::{
    SeccompFilter, SeccompRule,
 };

+#[derive(Clone, Copy)]
 pub enum Thread {
    VirtioBalloon,
    VirtioBlock,
--- a/virtio-devices/src/transport/pci_common_config.rs
+++ b/virtio-devices/src/transport/pci_common_config.rs
@@ -82,6 +82,8 @@ pub struct VirtioPciCommonConfigState {
 const VRING_DESC_ELEMENT_SIZE: usize = 16;
 const VRING_AVAIL_ELEMENT_SIZE: usize = 2;
 const VRING_USED_ELEMENT_SIZE: usize = 8;
+
+#[derive(Copy, Clone)]
 pub enum VringType {
    Desc,
    Avail,
@@ -191,6 +193,7 @@ impl VirtioPciCommonConfig {
        }
    }

+    #[allow(clippy::needless_pass_by_value)]
    pub fn write(
        &mut self,
        offset: u64,
@@ -297,6 +300,7 @@ impl VirtioPciCommonConfig {
        }
    }

+    #[allow(clippy::needless_pass_by_value)]
    fn read_common_config_dword(&self, offset: u64, device: Arc<Mutex<dyn VirtioDevice>>) -> u32 {
        debug!("read_common_config_dword: offset 0x{offset:x}");
        match offset {
@@ -319,6 +323,7 @@ impl VirtioPciCommonConfig {
        }
    }

+    #[allow(clippy::needless_pass_by_value)]
    fn write_common_config_dword(
        &mut self,
        offset: u64,
--- a/virtio-devices/src/vhost_user/blk.rs
+++ b/virtio-devices/src/vhost_user/blk.rs
@@ -297,7 +297,7 @@ impl VirtioDevice for Blk {

        let mut handler = self.vu_common.activate(
            mem,
-            queues,
+            &queues,
            interrupt_cb,
            self.common.acked_features,
            backend_req_handler,
@@ -316,7 +316,7 @@ impl VirtioDevice for Blk {
            Thread::VirtioVhostBlock,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;
        self.epoll_thread = Some(epoll_threads.remove(0));

--- a/virtio-devices/src/vhost_user/fs.rs
+++ b/virtio-devices/src/vhost_user/fs.rs
@@ -277,7 +277,7 @@ impl VirtioDevice for Fs {

        let mut handler = self.vu_common.activate(
            mem,
-            queues,
+            &queues,
            interrupt_cb,
            self.common.acked_features,
            backend_req_handler,
@@ -295,7 +295,7 @@ impl VirtioDevice for Fs {
            Thread::VirtioVhostFs,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;
        self.epoll_thread = Some(epoll_threads.remove(0));

--- a/virtio-devices/src/vhost_user/mod.rs
+++ b/virtio-devices/src/vhost_user/mod.rs
@@ -183,8 +183,8 @@ pub struct VhostUserEpollHandler<S: VhostUserFrontendReqHandler> {
 impl<S: VhostUserFrontendReqHandler> VhostUserEpollHandler<S> {
    pub fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> std::result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event_custom(
@@ -221,14 +221,16 @@ impl<S: VhostUserFrontendReqHandler> VhostUserEpollHandler<S> {
            )))
        })?;

+        let queues = self
+            .queues
+            .iter()
+            .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
+            .collect::<Vec<_>>();
        // Initialize the backend
        vhost_user
            .reinitialize_vhost_user(
                self.mem.memory().deref(),
-                self.queues
-                    .iter()
-                    .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
-                    .collect(),
+                &queues,
                self.virtio_interrupt.as_ref(),
                self.acked_features,
                self.acked_protocol_features,
@@ -305,7 +307,7 @@ impl VhostUserCommon {
    pub fn activate<T: VhostUserFrontendReqHandler>(
        &mut self,
        mem: GuestMemoryAtomic<GuestMemoryMmap>,
-        queues: Vec<(usize, Queue, EventFd)>,
+        queues: &[(usize, Queue, EventFd)],
        interrupt_cb: Arc<dyn VirtioInterrupt>,
        acked_features: u64,
        backend_req_handler: Option<FrontendReqHandler<T>>,
@@ -325,14 +327,15 @@ impl VhostUserCommon {
            return Err(ActivateError::BadActivate);
        }
        let vu = self.vu.as_ref().unwrap();
+        let queues = queues
+            .iter()
+            .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
+            .collect::<Vec<_>>();
        vu.lock()
            .unwrap()
            .setup_vhost_user(
                &mem.memory(),
-                queues
-                    .iter()
-                    .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
-                    .collect(),
+                &queues,
                interrupt_cb.as_ref(),
                acked_features,
                &backend_req_handler,
--- a/virtio-devices/src/vhost_user/net.rs
+++ b/virtio-devices/src/vhost_user/net.rs
@@ -336,7 +336,7 @@ impl VirtioDevice for Net {
                Thread::VirtioVhostNetCtl,
                &mut epoll_threads,
                &self.exit_evt,
-                move || ctrl_handler.run_ctrl(paused, paused_sync.unwrap()),
+                move || ctrl_handler.run_ctrl(&paused, paused_sync.as_ref().unwrap()),
            )?;
            self.ctrl_queue_epoll_thread = Some(epoll_threads.remove(0));
        }
@@ -353,7 +353,7 @@ impl VirtioDevice for Net {

        let mut handler = self.vu_common.activate(
            mem,
-            queues,
+            &queues,
            interrupt_cb,
            backend_acked_features,
            backend_req_handler,
@@ -371,7 +371,7 @@ impl VirtioDevice for Net {
            Thread::VirtioVhostNet,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;
        self.epoll_thread = Some(epoll_threads.remove(0));

--- a/virtio-devices/src/vhost_user/vu_common_ctrl.rs
+++ b/virtio-devices/src/vhost_user/vu_common_ctrl.rs
@@ -156,7 +156,7 @@ impl VhostUserHandle {
    pub fn setup_vhost_user<S: VhostUserFrontendReqHandler>(
        &mut self,
        mem: &GuestMemoryMmap,
-        queues: Vec<(usize, Queue, EventFd)>,
+        queues: &[(usize, Queue, EventFd)],
        virtio_interrupt: &dyn VirtioInterrupt,
        acked_features: u64,
        backend_req_handler: &Option<FrontendReqHandler<S>>,
@@ -340,7 +340,7 @@ impl VhostUserHandle {
    pub fn reinitialize_vhost_user<S: VhostUserFrontendReqHandler>(
        &mut self,
        mem: &GuestMemoryMmap,
-        queues: Vec<(usize, Queue, EventFd)>,
+        queues: &[(usize, Queue, EventFd)],
        virtio_interrupt: &dyn VirtioInterrupt,
        acked_features: u64,
        acked_protocol_features: u64,
--- a/virtio-devices/src/vsock/device.rs
+++ b/virtio-devices/src/vsock/device.rs
@@ -201,8 +201,8 @@ where

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evts[0].as_raw_fd(), RX_QUEUE_EVENT)?;
@@ -463,7 +463,7 @@ where
            Thread::VirtioVsock,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;

        self.common.epoll_threads = Some(epoll_threads);
--- a/virtio-devices/src/watchdog.rs
+++ b/virtio-devices/src/watchdog.rs
@@ -121,8 +121,8 @@ impl WatchdogEpollHandler {

    fn run(
        &mut self,
-        paused: Arc<AtomicBool>,
-        paused_sync: Arc<Barrier>,
+        paused: &AtomicBool,
+        paused_sync: &Barrier,
    ) -> result::Result<(), EpollHelperError> {
        let mut helper = EpollHelper::new(&self.kill_evt, &self.pause_evt)?;
        helper.add_event(self.queue_evt.as_raw_fd(), QUEUE_AVAIL_EVENT)?;
@@ -369,7 +369,7 @@ impl VirtioDevice for Watchdog {
            Thread::VirtioWatchdog,
            &mut epoll_threads,
            &self.exit_evt,
-            move || handler.run(paused, paused_sync.unwrap()),
+            move || handler.run(&paused, paused_sync.as_ref().unwrap()),
        )?;

        self.common.epoll_threads = Some(epoll_threads);