build: Update to Rust 1.70.0

Update the Rust version to 1.70.0 and fix new
`ambiguous_glob_reexports` warnings.

Signed-off-by: Jonathan Woollett-Light <[email protected]>

Author: Jonathan Woollett-Light

src/vmm/src/builder.rs

@@ -71,7 +71,7 @@ pub enum StartMicrovmError {
     CreateGuestConfig(#[from] GuestConfigError),
     /// Internal errors are due to resource exhaustion.
     #[error("Cannot create network device. {}", format!("{:?}", .0).replace('\"', ""))]
-    CreateNetDevice(crate::devices::virtio::net::Error),
+    CreateNetDevice(crate::devices::virtio::net::NetError),
     /// Failed to create a `RateLimiter` object.
     #[error("Cannot create RateLimiter: {0}")]
     CreateRateLimiter(io::Error),
@@ -1674,7 +1674,7 @@ pub mod tests {
         let err = AttachBlockDevice(io::Error::from_raw_os_error(0));
         let _ = format!("{}{:?}", err, err);
 
-        let err = CreateNetDevice(crate::devices::virtio::net::Error::EventFd(
+        let err = CreateNetDevice(crate::devices::virtio::net::NetError::EventFd(
             io::Error::from_raw_os_error(0),
         ));
         let _ = format!("{}{:?}", err, err);

src/vmm/src/device_manager/persist.rs

@@ -20,9 +20,9 @@ use super::mmio::*;
 #[cfg(target_arch = "aarch64")]
 use crate::arch::DeviceType;
 use crate::devices::virtio::balloon::persist::{BalloonConstructorArgs, BalloonState};
-use crate::devices::virtio::balloon::{Balloon, Error as BalloonError};
+use crate::devices::virtio::balloon::{Balloon, BalloonError};
 use crate::devices::virtio::block::persist::{BlockConstructorArgs, BlockState};
-use crate::devices::virtio::block::{Block, Error as BlockError};
+use crate::devices::virtio::block::{Block, BlockError};
 use crate::devices::virtio::net::persist::{Error as NetError, NetConstructorArgs, NetState};
 use crate::devices::virtio::net::Net;
 use crate::devices::virtio::persist::{MmioTransportConstructorArgs, MmioTransportState};

src/vmm/src/devices/mod.rs

@@ -23,7 +23,7 @@ pub(crate) fn report_net_event_fail(err: Error) {
     METRICS.net.event_fails.inc();
 }
 
-pub(crate) fn report_balloon_event_fail(err: virtio::balloon::Error) {
+pub(crate) fn report_balloon_event_fail(err: virtio::balloon::BalloonError) {
     error!("{:?}", err);
     METRICS.balloon.event_fails.inc();
 }

src/vmm/src/devices/virtio/balloon/device.rs

@@ -18,14 +18,15 @@ use virtio_gen::virtio_blk::VIRTIO_F_VERSION_1;
 use super::super::{ActivateResult, DeviceState, Queue, VirtioDevice, TYPE_BALLOON};
 use super::util::{compact_page_frame_numbers, remove_range};
 use super::{
-    BALLOON_DEV_ID, DEFLATE_INDEX, INFLATE_INDEX, MAX_PAGES_IN_DESC, MAX_PAGE_COMPACT_BUFFER,
-    MIB_TO_4K_PAGES, NUM_QUEUES, QUEUE_SIZES, STATS_INDEX, VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
-    VIRTIO_BALLOON_F_STATS_VQ, VIRTIO_BALLOON_PFN_SHIFT, VIRTIO_BALLOON_S_AVAIL,
-    VIRTIO_BALLOON_S_CACHES, VIRTIO_BALLOON_S_HTLB_PGALLOC, VIRTIO_BALLOON_S_HTLB_PGFAIL,
-    VIRTIO_BALLOON_S_MAJFLT, VIRTIO_BALLOON_S_MEMFREE, VIRTIO_BALLOON_S_MEMTOT,
-    VIRTIO_BALLOON_S_MINFLT, VIRTIO_BALLOON_S_SWAP_IN, VIRTIO_BALLOON_S_SWAP_OUT,
+    BALLOON_DEV_ID, BALLOON_NUM_QUEUES, BALLOON_QUEUE_SIZES, DEFLATE_INDEX, INFLATE_INDEX,
+    MAX_PAGES_IN_DESC, MAX_PAGE_COMPACT_BUFFER, MIB_TO_4K_PAGES, STATS_INDEX,
+    VIRTIO_BALLOON_F_DEFLATE_ON_OOM, VIRTIO_BALLOON_F_STATS_VQ, VIRTIO_BALLOON_PFN_SHIFT,
+    VIRTIO_BALLOON_S_AVAIL, VIRTIO_BALLOON_S_CACHES, VIRTIO_BALLOON_S_HTLB_PGALLOC,
+    VIRTIO_BALLOON_S_HTLB_PGFAIL, VIRTIO_BALLOON_S_MAJFLT, VIRTIO_BALLOON_S_MEMFREE,
+    VIRTIO_BALLOON_S_MEMTOT, VIRTIO_BALLOON_S_MINFLT, VIRTIO_BALLOON_S_SWAP_IN,
+    VIRTIO_BALLOON_S_SWAP_OUT,
 };
-use crate::devices::virtio::balloon::Error as BalloonError;
+use crate::devices::virtio::balloon::BalloonError;
 use crate::devices::virtio::{IrqTrigger, IrqType};
 
 const SIZE_OF_U32: usize = std::mem::size_of::<u32>();
@@ -134,7 +135,7 @@ pub struct Balloon {
 
     // Transport related fields.
     pub(crate) queues: Vec<Queue>,
-    pub(crate) queue_evts: [EventFd; NUM_QUEUES],
+    pub(crate) queue_evts: [EventFd; BALLOON_NUM_QUEUES],
     pub(crate) device_state: DeviceState,
     pub(crate) irq_trigger: IrqTrigger,
 
@@ -173,7 +174,7 @@ impl Balloon {
             EventFd::new(libc::EFD_NONBLOCK).map_err(BalloonError::EventFd)?,
         ];
 
-        let mut queues: Vec<Queue> = QUEUE_SIZES.iter().map(|&s| Queue::new(s)).collect();
+        let mut queues: Vec<Queue> = BALLOON_QUEUE_SIZES.iter().map(|&s| Queue::new(s)).collect();
 
         // The VirtIO specification states that the statistics queue should
         // not be present at all if the statistics are not enabled.
@@ -589,7 +590,7 @@ pub(crate) mod tests {
 
     use utils::vm_memory::GuestAddress;
 
-    use super::super::CONFIG_SPACE_SIZE;
+    use super::super::BALLOON_CONFIG_SPACE_SIZE;
     use super::*;
     use crate::check_metric_after_block;
     use crate::devices::report_balloon_event_fail;
@@ -716,21 +717,24 @@ pub(crate) mod tests {
         };
         assert_eq!(balloon.config(), cfg);
 
-        let mut actual_config_space = [0u8; CONFIG_SPACE_SIZE];
+        let mut actual_config_space = [0u8; BALLOON_CONFIG_SPACE_SIZE];
         balloon.read_config(0, &mut actual_config_space);
         // The first 4 bytes are num_pages, the last 4 bytes are actual_pages.
         // The config space is little endian.
         // 0x10 MB in the constructor corresponds to 0x1000 pages in the
         // config space.
-        let expected_config_space: [u8; CONFIG_SPACE_SIZE] =
+        let expected_config_space: [u8; BALLOON_CONFIG_SPACE_SIZE] =
             [0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
         assert_eq!(actual_config_space, expected_config_space);
 
         // Invalid read.
-        let expected_config_space: [u8; CONFIG_SPACE_SIZE] =
+        let expected_config_space: [u8; BALLOON_CONFIG_SPACE_SIZE] =
             [0xd, 0xe, 0xa, 0xd, 0xb, 0xe, 0xe, 0xf];
         actual_config_space = expected_config_space;
-        balloon.read_config(CONFIG_SPACE_SIZE as u64 + 1, &mut actual_config_space);
+        balloon.read_config(
+            BALLOON_CONFIG_SPACE_SIZE as u64 + 1,
+            &mut actual_config_space,
+        );
 
         // Validate read failed (the config space was not updated).
         assert_eq!(actual_config_space, expected_config_space);
@@ -740,11 +744,11 @@ pub(crate) mod tests {
     fn test_virtio_write_config() {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
 
-        let expected_config_space: [u8; CONFIG_SPACE_SIZE] =
+        let expected_config_space: [u8; BALLOON_CONFIG_SPACE_SIZE] =
             [0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
         balloon.write_config(0, &expected_config_space);
 
-        let mut actual_config_space = [0u8; CONFIG_SPACE_SIZE];
+        let mut actual_config_space = [0u8; BALLOON_CONFIG_SPACE_SIZE];
         balloon.read_config(0, &mut actual_config_space);
         assert_eq!(actual_config_space, expected_config_space);
 
@@ -1043,7 +1047,7 @@ pub(crate) mod tests {
         assert_eq!(balloon.num_pages(), 0x100);
         assert!(balloon.update_size(16).is_ok());
 
-        let mut actual_config = vec![0; CONFIG_SPACE_SIZE];
+        let mut actual_config = vec![0; BALLOON_CONFIG_SPACE_SIZE];
         balloon.read_config(0, &mut actual_config);
         assert_eq!(actual_config, vec![0x0, 0x10, 0x0, 0x0, 0x34, 0x12, 0, 0]);
         assert_eq!(balloon.num_pages(), 0x1000);

src/vmm/src/devices/virtio/balloon/mod.rs

@@ -2,23 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod device;
-pub mod event_handler;
+mod event_handler;
 pub mod persist;
 pub mod test_utils;
 mod util;
 
 use utils::vm_memory::GuestMemoryError;
 
 pub use self::device::{Balloon, BalloonConfig, BalloonStats};
-pub use self::event_handler::*;
 
 /// Device ID used in MMIO device identification.
 /// Because Balloon is unique per-vm, this ID can be hardcoded.
 pub const BALLOON_DEV_ID: &str = "balloon";
-pub const CONFIG_SPACE_SIZE: usize = 8;
-pub const QUEUE_SIZE: u16 = 256;
-pub const NUM_QUEUES: usize = 3;
-pub const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE, QUEUE_SIZE, QUEUE_SIZE];
+pub const BALLOON_CONFIG_SPACE_SIZE: usize = 8;
+pub const BALLOON_QUEUE_SIZE: u16 = 256;
+pub const BALLOON_NUM_QUEUES: usize = 3;
+pub const BALLOON_QUEUE_SIZES: [u16; BALLOON_NUM_QUEUES] =
+    [BALLOON_QUEUE_SIZE, BALLOON_QUEUE_SIZE, BALLOON_QUEUE_SIZE];
 // Number of 4K pages in a MiB.
 pub const MIB_TO_4K_PAGES: u32 = 256;
 // The maximum number of pages that can be received in a single descriptor.
@@ -52,7 +52,7 @@ const VIRTIO_BALLOON_S_HTLB_PGALLOC: u16 = 8;
 const VIRTIO_BALLOON_S_HTLB_PGFAIL: u16 = 9;
 
 #[derive(Debug)]
-pub enum Error {
+pub enum BalloonError {
     /// Activation error.
     Activate(super::ActivateError),
     /// No balloon device found.
@@ -94,4 +94,4 @@ pub enum RemoveRegionError {
     RegionNotFound,
 }
 
-pub type Result<T> = std::result::Result<T, Error>;
+pub type BalloonResult<T> = std::result::Result<T, BalloonError>;

src/vmm/src/devices/virtio/balloon/persist.rs

@@ -93,7 +93,7 @@ pub struct BalloonConstructorArgs {
 impl Persist<'_> for Balloon {
     type State = BalloonState;
     type ConstructorArgs = BalloonConstructorArgs;
-    type Error = super::Error;
+    type Error = super::BalloonError;
 
     fn save(&self) -> Self::State {
         BalloonState {
@@ -116,15 +116,20 @@ impl Persist<'_> for Balloon {
         // num_pages because we will overwrite them after.
         let mut balloon = Balloon::new(0, false, state.stats_polling_interval_s, true)?;
 
-        let mut num_queues = NUM_QUEUES;
+        let mut num_queues = BALLOON_NUM_QUEUES;
         // As per the virtio 1.1 specification, the statistics queue
         // should not exist if the statistics are not enabled.
         if state.stats_polling_interval_s == 0 {
             num_queues -= 1;
         }
         balloon.queues = state
             .virtio_state
-            .build_queues_checked(&constructor_args.mem, TYPE_BALLOON, num_queues, QUEUE_SIZE)
+            .build_queues_checked(
+                &constructor_args.mem,
+                TYPE_BALLOON,
+                num_queues,
+                BALLOON_QUEUE_SIZE,
+            )
             .map_err(|_| Self::Error::QueueRestoreError)?;
         balloon.irq_trigger.irq_status =
             Arc::new(AtomicUsize::new(state.virtio_state.interrupt_status));

src/vmm/src/devices/virtio/balloon/test_utils.rs

@@ -8,12 +8,12 @@ use std::u32;
 use crate::devices::virtio::test_utils::VirtQueue;
 #[cfg(test)]
 use crate::devices::virtio::{
-    balloon::NUM_QUEUES, Balloon, IrqType, DEFLATE_INDEX, INFLATE_INDEX, STATS_INDEX,
+    balloon::BALLOON_NUM_QUEUES, Balloon, IrqType, DEFLATE_INDEX, INFLATE_INDEX, STATS_INDEX,
 };
 
 #[cfg(test)]
 pub fn invoke_handler_for_queue_event(b: &mut Balloon, queue_index: usize) {
-    assert!(queue_index < NUM_QUEUES);
+    assert!(queue_index < BALLOON_NUM_QUEUES);
     // Trigger the queue event.
     b.queue_evts[queue_index].write(1).unwrap();
     // Handle event.