refactor(vmm): rename items related to serializable MSRs

Rename items (functions, variables and methods) related to serializable
MSRs. Previously they were named `msr_list` or `supported_msrs` that
were confusing or difficult to guess their usage from their names.

Signed-off-by: Takahiro Itazuri <[email protected]>

Author: zulinx86

src/vmm/src/arch/x86_64/msr.rs

@@ -136,7 +136,7 @@ macro_rules! MSR_RANGE {
 }
 
 // List of MSRs that can be serialized. List is sorted in ascending order of MSRs addresses.
-static ALLOWED_MSR_RANGES: &[MsrRange] = &[
+static SERIALIZABLE_MSR_RANGES: &[MsrRange] = &[
     MSR_RANGE!(MSR_IA32_P5_MC_ADDR),
     MSR_RANGE!(MSR_IA32_P5_MC_TYPE),
     MSR_RANGE!(MSR_IA32_TSC),
@@ -242,7 +242,9 @@ pub fn msr_should_serialize(index: u32) -> bool {
     if index == MSR_IA32_MCG_CTL {
         return false;
     };
-    ALLOWED_MSR_RANGES.iter().any(|range| range.contains(index))
+    SERIALIZABLE_MSR_RANGES
+        .iter()
+        .any(|range| range.contains(index))
 }
 
 /// Creates and populates required MSR entries for booting Linux on X86_64.
@@ -315,12 +317,12 @@ pub fn set_msrs(
         })
 }
 
-/// Returns the list of supported, serializable MSRs.
+/// Returns the list of supported and serializable MSR indices.
 ///
 /// # Arguments
 ///
 /// * `kvm_fd` - Structure that holds the KVM's fd.
-pub fn supported_guest_msrs(kvm_fd: &Kvm) -> Result<MsrList> {
+pub fn get_msrs_to_save(kvm_fd: &Kvm) -> Result<MsrList> {
     let mut msr_list = kvm_fd
         .get_msr_index_list()
         .map_err(Error::GetSupportedModelSpecificRegisters)?;
@@ -338,7 +340,7 @@ mod tests {
 
     #[test]
     fn test_msr_allowlist() {
-        for range in ALLOWED_MSR_RANGES.iter() {
+        for range in SERIALIZABLE_MSR_RANGES.iter() {
             for msr in range.base..(range.base + range.nmsrs) {
                 let should = !matches!(msr, MSR_IA32_MCG_CTL);
                 assert_eq!(msr_should_serialize(msr), should);

src/vmm/src/guest_config/x86_64/mod.rs

@@ -45,7 +45,7 @@ pub struct CpuConfiguration {
     pub msrs: HashMap<u32, u64>,
 
     /// Set of supported MSRs
-    pub supported_msrs: HashSet<u32>,
+    pub msrs_to_save: HashSet<u32>,
 
     /// Architectural MSPs required for boot
     pub msr_boot_entries: Vec<kvm_msr_entry>,
@@ -69,7 +69,7 @@ impl CpuConfiguration {
         Ok(Self {
             cpuid: supported_cpuid,
             msrs: Default::default(),
-            supported_msrs: Default::default(),
+            msrs_to_save: Default::default(),
             msr_boot_entries: create_boot_msr_entries(),
         })
     }
@@ -106,13 +106,13 @@ impl CpuConfiguration {
                 // C3, T2 and T2A currently don't have extra MSRs to save/set.
                 match template {
                     StaticCpuTemplate::T2S => {
-                        config.supported_msrs.extend(msr_entries_to_save());
+                        config.msrs_to_save.extend(msr_entries_to_save());
                         static_cpu_templates::t2s::update_t2s_msr_entries(
                             &mut config.msr_boot_entries,
                         );
                     }
                     StaticCpuTemplate::T2CL => {
-                        config.supported_msrs.extend(msr_entries_to_save());
+                        config.msrs_to_save.extend(msr_entries_to_save());
                         static_cpu_templates::t2cl::update_t2cl_msr_entries(
                             &mut config.msr_boot_entries,
                         );
@@ -130,7 +130,7 @@ impl CpuConfiguration {
         let Self {
             mut cpuid,
             mut msrs,
-            supported_msrs,
+            msrs_to_save,
             msr_boot_entries,
         } = self;
 
@@ -188,7 +188,7 @@ impl CpuConfiguration {
         Ok(Self {
             cpuid,
             msrs,
-            supported_msrs,
+            msrs_to_save,
             msr_boot_entries,
         })
     }
@@ -266,7 +266,7 @@ mod tests {
         CpuConfiguration {
             cpuid: Cpuid::Intel(IntelCpuid(BTreeMap::new())),
             msrs: Default::default(),
-            supported_msrs: Default::default(),
+            msrs_to_save: Default::default(),
             msr_boot_entries: Default::default(),
         }
     }
@@ -275,7 +275,7 @@ mod tests {
         CpuConfiguration {
             cpuid: static_cpu_templates::t2::t2(),
             msrs: HashMap::from([(0x8000, 0b1000), (0x9999, 0b1010)]),
-            supported_msrs: Default::default(),
+            msrs_to_save: Default::default(),
             msr_boot_entries: Default::default(),
         }
     }
@@ -284,7 +284,7 @@ mod tests {
         CpuConfiguration {
             cpuid: static_cpu_templates::t2::t2(),
             msrs: HashMap::from([(0x8000, 0b1000), (0x8001, 0b1010)]),
-            supported_msrs: Default::default(),
+            msrs_to_save: Default::default(),
             msr_boot_entries: Default::default(),
         }
     }

src/vmm/src/vstate/vcpu/x86_64.rs

@@ -191,7 +191,7 @@ pub struct KvmVcpu {
     pub pio_bus: Option<devices::Bus>,
     pub mmio_bus: Option<devices::Bus>,
 
-    msr_list: HashSet<u32>,
+    msrs_to_save: HashSet<u32>,
 }
 
 impl KvmVcpu {
@@ -209,7 +209,7 @@ impl KvmVcpu {
             fd: kvm_vcpu,
             pio_bus: None,
             mmio_bus: None,
-            msr_list: vm.supported_msrs().as_slice().iter().copied().collect(),
+            msrs_to_save: vm.msrs_to_save().as_slice().iter().copied().collect(),
         })
     }
 
@@ -228,8 +228,8 @@ impl KvmVcpu {
         vcpu_config: &VcpuConfig,
     ) -> std::result::Result<(), KvmVcpuConfigureError> {
         let mut cpuid = vcpu_config.cpu_config.cpuid.clone();
-        self.msr_list
-            .extend(vcpu_config.cpu_config.supported_msrs.iter());
+        self.msrs_to_save
+            .extend(vcpu_config.cpu_config.msrs_to_save.iter());
         let msr_boot_entries = vcpu_config.cpu_config.msr_boot_entries.clone();
 
         // Apply machine specific changes to CPUID.
@@ -264,7 +264,7 @@ impl KvmVcpu {
         // the extra MSRs that we need to save based on a dependency map.
         let extra_msrs = crate::guest_config::cpuid::common::msrs_to_save_by_cpuid(&kvm_cpuid)
             .map_err(KvmVcpuConfigureError::MsrsToSaveByCpuid)?;
-        self.msr_list.extend(extra_msrs);
+        self.msrs_to_save.extend(extra_msrs);
 
         // By this point we know that at snapshot, the list of MSRs we need to
         // save is `architectural MSRs` + `MSRs inferred through CPUID` + `other
@@ -321,11 +321,11 @@ impl KvmVcpu {
         // more than KVM_MAX_MSR_ENTRIES in the snapshot, so we use a Vec<Msrs>
         // to allow an unlimited number.
         let mut all_msrs: Vec<Msrs> = Vec::new();
-        let msr_list: Vec<&u32> = self.msr_list.iter().collect();
+        let msrs_to_save: Vec<&u32> = self.msrs_to_save.iter().collect();
 
         // KVM only supports getting KVM_MAX_MSR_ENTRIES at a time so chunk
         // them up into `Msrs` so it's easy to pass to the ioctl.
-        for chunk in msr_list.chunks(KVM_MAX_MSR_ENTRIES) {
+        for chunk in msrs_to_save.chunks(KVM_MAX_MSR_ENTRIES) {
             let mut msrs = Msrs::new(chunk.len()).map_err(Error::Fam)?;
             let msr_entries = msrs.as_mut_slice();
             assert_eq!(chunk.len(), msr_entries.len());

src/vmm/src/vstate/vm.rs

@@ -116,7 +116,7 @@ pub struct Vm {
     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     supported_cpuid: CpuId,
     #[cfg(target_arch = "x86_64")]
-    supported_msrs: MsrList,
+    msrs_to_save: MsrList,
 
     // Arm specific fields.
     // On aarch64 we need to keep around the fd obtained by creating the VGIC device.
@@ -246,13 +246,13 @@ impl Vm {
         let supported_cpuid = kvm
             .get_supported_cpuid(KVM_MAX_CPUID_ENTRIES)
             .map_err(Error::VmFd)?;
-        let supported_msrs =
-            crate::arch::x86_64::msr::supported_guest_msrs(kvm).map_err(Error::GuestMsrs)?;
+        let msrs_to_save =
+            crate::arch::x86_64::msr::get_msrs_to_save(kvm).map_err(Error::GuestMsrs)?;
 
         Ok(Vm {
             fd: vm_fd,
             supported_cpuid,
-            supported_msrs,
+            msrs_to_save,
         })
     }
 
@@ -261,9 +261,9 @@ impl Vm {
         &self.supported_cpuid
     }
 
-    /// Returns a ref to the supported `MsrList` for this Vm.
-    pub fn supported_msrs(&self) -> &MsrList {
-        &self.supported_msrs
+    /// Returns a ref to the list of serializable MSR indices.
+    pub fn msrs_to_save(&self) -> &MsrList {
+        &self.msrs_to_save
     }
 
     /// Restores the KVM VM state.