refactor: introduce mib_to_bytes helper

Left-shifting by 20 to convert MiB to bytes is ubiquitous in our
codebase, but probably somewhat arcane to people not familiar with low
level stuff. Let's define a helper for the conversion.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/vmm/src/arch/x86_64/mod.rs

@@ -35,7 +35,7 @@ use linux_loader::loader::elf::start_info::{
 
 use crate::arch::{BootProtocol, InitrdConfig, SYSTEM_MEM_SIZE, SYSTEM_MEM_START};
 use crate::device_manager::resources::ResourceAllocator;
-use crate::utils::u64_to_usize;
+use crate::utils::{mib_to_bytes, u64_to_usize};
 use crate::vstate::memory::{
     Address, GuestAddress, GuestMemory, GuestMemoryMmap, GuestMemoryRegion,
 };
@@ -71,7 +71,7 @@ pub enum ConfigurationError {
 pub const FIRST_ADDR_PAST_32BITS: u64 = 1 << 32;
 
 /// Size of MMIO gap at top of 32-bit address space.
-pub const MEM_32BIT_GAP_SIZE: u64 = 768 << 20;
+pub const MEM_32BIT_GAP_SIZE: u64 = mib_to_bytes(768) as u64;
 /// The start of the memory area reserved for MMIO devices.
 pub const MMIO_MEM_START: u64 = FIRST_ADDR_PAST_32BITS - MEM_32BIT_GAP_SIZE;
 /// The size of the memory area reserved for MMIO devices.
@@ -397,7 +397,7 @@ mod tests {
         );
 
         // Now assigning some memory that falls before the 32bit memory hole.
-        let mem_size = 128 << 20;
+        let mem_size = mib_to_bytes(128);
         let gm = arch_mem(mem_size);
         let mut resource_allocator = ResourceAllocator::new().unwrap();
         configure_system(
@@ -422,7 +422,7 @@ mod tests {
         .unwrap();
 
         // Now assigning some memory that is equal to the start of the 32bit memory hole.
-        let mem_size = 3328 << 20;
+        let mem_size = mib_to_bytes(3328);
         let gm = arch_mem(mem_size);
         let mut resource_allocator = ResourceAllocator::new().unwrap();
         configure_system(
@@ -447,7 +447,7 @@ mod tests {
         .unwrap();
 
         // Now assigning some memory that falls after the 32bit memory hole.
-        let mem_size = 3330 << 20;
+        let mem_size = mib_to_bytes(3330);
         let gm = arch_mem(mem_size);
         let mut resource_allocator = ResourceAllocator::new().unwrap();
         configure_system(

src/vmm/src/builder.rs

@@ -1050,6 +1050,7 @@ pub(crate) mod tests {
     use crate::mmds::data_store::{Mmds, MmdsVersion};
     use crate::mmds::ns::MmdsNetworkStack;
     use crate::test_utils::{single_region_mem, single_region_mem_at};
+    use crate::utils::mib_to_bytes;
     use crate::vmm_config::balloon::{BALLOON_DEV_ID, BalloonBuilder, BalloonDeviceConfig};
     use crate::vmm_config::boot_source::DEFAULT_KERNEL_CMDLINE;
     use crate::vmm_config::drive::{BlockBuilder, BlockDeviceConfig};
@@ -1113,7 +1114,7 @@ pub(crate) mod tests {
     }
 
     pub(crate) fn default_vmm() -> Vmm {
-        let (kvm, mut vm, guest_memory) = setup_vm_with_memory(128 << 20);
+        let (kvm, mut vm, guest_memory) = setup_vm_with_memory(mib_to_bytes(128));
 
         let mmio_device_manager = MMIODeviceManager::new();
         let acpi_device_manager = ACPIDeviceManager::new();

src/vmm/src/devices/virtio/vsock/event_handler.rs

@@ -477,9 +477,10 @@ mod tests {
         use crate::arch::x86_64::{FIRST_ADDR_PAST_32BITS, MEM_32BIT_GAP_SIZE};
         use crate::devices::virtio::vsock::packet::VSOCK_PKT_HDR_SIZE;
         use crate::test_utils::multi_region_mem;
+        use crate::utils::mib_to_bytes;
         use crate::vstate::memory::GuestAddress;
 
-        const MIB: usize = 1 << 20;
+        const MIB: usize = mib_to_bytes(1);
 
         let mut test_ctx = TestContext::new();
         test_ctx.mem = multi_region_mem(&[

src/vmm/src/resources.rs

@@ -13,6 +13,7 @@ use crate::logger::info;
 use crate::mmds;
 use crate::mmds::data_store::{Mmds, MmdsVersion};
 use crate::mmds::ns::MmdsNetworkStack;
+use crate::utils::mib_to_bytes;
 use crate::utils::net::ipv4addr::is_link_local_valid;
 use crate::vmm_config::balloon::*;
 use crate::vmm_config::boot_source::{
@@ -462,7 +463,8 @@ impl VmResources {
                 self.machine_config.huge_pages,
             )
         } else {
-            let regions = crate::arch::arch_memory_regions(self.machine_config.mem_size_mib << 20);
+            let regions =
+                crate::arch::arch_memory_regions(mib_to_bytes(self.machine_config.mem_size_mib));
             GuestMemoryMmap::anonymous(
                 regions.into_iter(),
                 self.machine_config.track_dirty_pages,

src/vmm/src/utils/mod.rs

@@ -13,6 +13,9 @@ pub mod sm;
 use std::num::Wrapping;
 use std::result::Result;
 
+/// How many bits to left-shift by to convert MiB to bytes
+const MIB_TO_BYTES_SHIFT: usize = 20;
+
 /// Return the default page size of the platform, in bytes.
 pub fn get_page_size() -> Result<usize, vmm_sys_util::errno::Error> {
     // SAFETY: Safe because the parameters are valid.
@@ -45,3 +48,8 @@ pub const fn usize_to_u64(num: usize) -> u64 {
 pub const fn wrap_usize_to_u32(num: usize) -> Wrapping<u32> {
     Wrapping(((num as u64) & 0xFFFFFFFF) as u32)
 }
+
+/// Converts MiB to Bytes
+pub const fn mib_to_bytes(mib: usize) -> usize {
+    mib << MIB_TO_BYTES_SHIFT
+}

src/vmm/src/vstate/memory.rs

@@ -23,7 +23,7 @@ use vmm_sys_util::errno;
 
 use crate::DirtyBitmap;
 use crate::arch::arch_memory_regions;
-use crate::utils::{get_page_size, u64_to_usize};
+use crate::utils::{get_page_size, mib_to_bytes, u64_to_usize};
 use crate::vmm_config::machine_config::HugePageConfig;
 
 /// Type of GuestMemoryMmap.
@@ -72,7 +72,7 @@ where
         huge_pages: HugePageConfig,
     ) -> Result<Self, MemoryError> {
         let memfd_file = create_memfd(mem_size_mib, huge_pages.into())?.into_file();
-        let regions = arch_memory_regions(mem_size_mib << 20).into_iter();
+        let regions = arch_memory_regions(mib_to_bytes(mem_size_mib)).into_iter();
 
         Self::create(
             regions,
@@ -330,7 +330,7 @@ fn create_memfd(
     size: usize,
     hugetlb_size: Option<memfd::HugetlbSize>,
 ) -> Result<memfd::Memfd, MemoryError> {
-    let mem_size = size << 20;
+    let mem_size = mib_to_bytes(size);
     // Create a memfd.
     let opts = memfd::MemfdOptions::default()
         .hugetlb(hugetlb_size)
@@ -713,7 +713,7 @@ mod tests {
     #[test]
     fn test_create_memfd() {
         let size = 1;
-        let size_mb = 1 << 20;
+        let size_mb = mib_to_bytes(1) as u64;
 
         let memfd = create_memfd(size, None).unwrap();
 

src/vmm/src/vstate/vcpu/mod.rs

@@ -786,6 +786,7 @@ pub(crate) mod tests {
     use crate::devices::BusDevice;
     use crate::devices::bus::DummyDevice;
     use crate::seccomp::get_empty_filters;
+    use crate::utils::mib_to_bytes;
     use crate::utils::signal::validate_signal_num;
     use crate::vstate::kvm::Kvm;
     use crate::vstate::memory::{GuestAddress, GuestMemoryMmap};
@@ -973,7 +974,7 @@ pub(crate) mod tests {
     fn vcpu_configured_for_boot() -> (VcpuHandle, EventFd, GuestMemoryMmap) {
         Vcpu::register_kick_signal_handler();
         // Need enough mem to boot linux.
-        let mem_size = 64 << 20;
+        let mem_size = mib_to_bytes(64);
         let (kvm, _, mut vcpu, vm_mem) = setup_vcpu(mem_size);
 
         let vcpu_exit_evt = vcpu.exit_evt.try_clone().unwrap();

src/vmm/src/vstate/vm/mod.rs

@@ -143,6 +143,7 @@ impl Vm {
 pub(crate) mod tests {
     use super::*;
     use crate::test_utils::single_region_mem;
+    use crate::utils::mib_to_bytes;
     use crate::vstate::kvm::Kvm;
     use crate::vstate::memory::GuestMemoryMmap;
 
@@ -197,7 +198,7 @@ pub(crate) mod tests {
     #[test]
     fn test_create_vcpus() {
         let vcpu_count = 2;
-        let (_, mut vm, _) = setup_vm_with_memory(128 << 20);
+        let (_, mut vm, _) = setup_vm_with_memory(mib_to_bytes(128));
 
         let (vcpu_vec, _) = vm.create_vcpus(vcpu_count).unwrap();