clippy: Address the issue 'needless-borrow'

Issue from beta verion of clippy:

Error:    --> vm-virtio/src/queue.rs:700:59
    |
700 |             if let Some(used_event) = self.get_used_event(&mem) {
    |                                                           ^^^^ help: change this to: `mem`
    |
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow

Signed-off-by: Bo Chen <chen.bo@intel.com>

arch/src/aarch64/fdt.rs

@@ -196,7 +196,7 @@ fn create_gic_node(fdt: &mut FdtWriter, gic_device: &dyn GicDevice) -> FdtWriter
     // interrupt source. The type shall be a <u32> and the value shall be 3 if no PPI affinity description
     // is required.
     fdt.property_u32("#interrupt-cells", 3)?;
-    fdt.property_array_u64("reg", &gic_reg_prop)?;
+    fdt.property_array_u64("reg", gic_reg_prop)?;
     fdt.property_u32("phandle", GIC_PHANDLE)?;
     fdt.property_u32("#address-cells", 2)?;
     fdt.property_u32("#size-cells", 2)?;
@@ -215,7 +215,7 @@ fn create_gic_node(fdt: &mut FdtWriter, gic_device: &dyn GicDevice) -> FdtWriter
         fdt.property_null("msi-controller")?;
         fdt.property_u32("phandle", MSI_PHANDLE)?;
         let msi_reg_prop = gic_device.msi_properties();
-        fdt.property_array_u64("reg", &msi_reg_prop)?;
+        fdt.property_array_u64("reg", msi_reg_prop)?;
         fdt.end_node(msic_node)?;
     }
 

arch/src/aarch64/gic/dist_regs.rs

@@ -152,7 +152,7 @@ pub fn set_dist_regs(gic: &Arc<dyn hypervisor::Device>, state: &[u32]) -> Result
 
     for dreg in VGIC_DIST_REGS {
         let mut base = dreg.base + REG_SIZE as u32 * dreg.bpi as u32;
-        let end = compute_reg_len(gic, &dreg, base)?;
+        let end = compute_reg_len(gic, dreg, base)?;
 
         while base < end {
             let val = state[idx];
@@ -169,7 +169,7 @@ pub fn get_dist_regs(gic: &Arc<dyn hypervisor::Device>) -> Result<Vec<u32>> {
 
     for dreg in VGIC_DIST_REGS {
         let mut base = dreg.base + REG_SIZE as u32 * dreg.bpi as u32;
-        let end = compute_reg_len(gic, &dreg, base)?;
+        let end = compute_reg_len(gic, dreg, base)?;
 
         while base < end {
             let val: u32 = 0;

arch/src/aarch64/gic/gicv3.rs

@@ -107,19 +107,19 @@ pub mod kvm {
         /// Save the state of GIC.
         fn state(&self, gicr_typers: &[u64]) -> Result<Gicv3State> {
             // Flush redistributors pending tables to guest RAM.
-            save_pending_tables(&self.device()).map_err(Error::SavePendingTables)?;
+            save_pending_tables(self.device()).map_err(Error::SavePendingTables)?;
 
             let gicd_ctlr =
-                read_ctlr(&self.device()).map_err(Error::SaveDistributorCtrlRegisters)?;
+                read_ctlr(self.device()).map_err(Error::SaveDistributorCtrlRegisters)?;
 
             let dist_state =
-                get_dist_regs(&self.device()).map_err(Error::SaveDistributorRegisters)?;
+                get_dist_regs(self.device()).map_err(Error::SaveDistributorRegisters)?;
 
-            let rdist_state = get_redist_regs(&self.device(), &gicr_typers)
+            let rdist_state = get_redist_regs(self.device(), gicr_typers)
                 .map_err(Error::SaveRedistributorRegisters)?;
 
             let icc_state =
-                get_icc_regs(&self.device(), &gicr_typers).map_err(Error::SaveIccRegisters)?;
+                get_icc_regs(self.device(), gicr_typers).map_err(Error::SaveIccRegisters)?;
 
             Ok(Gicv3State {
                 dist: dist_state,
@@ -131,16 +131,16 @@ pub mod kvm {
 
         /// Restore the state of GIC.
         fn set_state(&mut self, gicr_typers: &[u64], state: &Gicv3State) -> Result<()> {
-            write_ctlr(&self.device(), state.gicd_ctlr)
+            write_ctlr(self.device(), state.gicd_ctlr)
                 .map_err(Error::RestoreDistributorCtrlRegisters)?;
 
-            set_dist_regs(&self.device(), &state.dist)
+            set_dist_regs(self.device(), &state.dist)
                 .map_err(Error::RestoreDistributorRegisters)?;
 
-            set_redist_regs(&self.device(), gicr_typers, &state.rdist)
+            set_redist_regs(self.device(), gicr_typers, &state.rdist)
                 .map_err(Error::RestoreRedistributorRegisters)?;
 
-            set_icc_regs(&self.device(), &gicr_typers, &state.icc)
+            set_icc_regs(self.device(), gicr_typers, &state.icc)
                 .map_err(Error::RestoreIccRegisters)?;
 
             Ok(())

arch/src/aarch64/gic/redist_regs.rs

@@ -142,14 +142,14 @@ pub fn get_redist_regs(gic: &Arc<dyn hypervisor::Device>, gicr_typer: &[u64]) ->
     let mut idx: usize = 0;
     access_redists_aux(
         gic,
-        &gicr_typer,
+        gicr_typer,
         &mut state,
         VGIC_RDIST_REGS,
         &mut idx,
         false,
     )?;
 
-    access_redists_aux(gic, &gicr_typer, &mut state, VGIC_SGI_REGS, &mut idx, false)?;
+    access_redists_aux(gic, gicr_typer, &mut state, VGIC_SGI_REGS, &mut idx, false)?;
     Ok(state)
 }