feat(aarch64): ability to work with wide registers

- Updated `kvm-bindings` to 1.4 which changes `get/set_one_reg` methods.
- Updated internal representation of aarch64 registers

Now we are able to work with register wider then 128 bits.
All registers are stored in the `Aarch64RegisterVec` in one byte array.
This way registers of different sizes can be efficiently stored
and iterated on.
Supported sizes are: 8, 16, 32, 64, 128, 256, 512, 1024, 2048 bits
(all sizes supported by KVM).
Register size is determined by the ID of the register.
Interactions with registers are happening using `Aarch64RegisterRef`
or `Aarch64RegisterRefMut`.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

Cargo.lock

@@ -1,6 +1,7 @@
 // Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use vmm::arch::aarch64::regs::RegSize;
 use vmm::cpu_config::aarch64::custom_cpu_template::RegisterModifier;
 use vmm::cpu_config::templates::{CpuConfiguration, CustomCpuTemplate, RegisterValueFilter};
 
@@ -10,7 +11,18 @@ pub fn config_to_template(cpu_config: &CpuConfiguration) -> CustomCpuTemplate {
     let mut reg_modifiers: Vec<RegisterModifier> = cpu_config
         .regs
         .iter()
-        .map(|reg| reg_modifier!(reg.id, reg.value))
+        .map(|reg| match reg.size() {
+            RegSize::U32 => {
+                reg_modifier!(reg.id, u128::from(reg.value::<u32, 4>()))
+            }
+            RegSize::U64 => {
+                reg_modifier!(reg.id, u128::from(reg.value::<u64, 8>()))
+            }
+            RegSize::U128 => {
+                reg_modifier!(reg.id, reg.value::<u128, 16>())
+            }
+            _ => unreachable!("Only 32, 64 and 128 bit wide registers are supported"),
+        })
         .collect();
     reg_modifiers.sort_by_key(|modifier| modifier.addr);
 
@@ -19,41 +31,38 @@ pub fn config_to_template(cpu_config: &CpuConfiguration) -> CustomCpuTemplate {
 
 #[cfg(test)]
 mod tests {
-    use vmm::arch::aarch64::regs::Aarch64Register;
+    use vmm::arch::aarch64::regs::{Aarch64RegisterRef, Aarch64RegisterVec};
 
     use super::*;
 
-    fn build_sample_regs() -> Vec<Aarch64Register> {
-        vec![
-            Aarch64Register {
-                id: 0x0,
-                value: 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff,
-            },
-            Aarch64Register {
-                id: 0xffff_ffff_ffff_ffff,
-                value: 0x0000_ffff_0000_ffff_0000_ffff_0000_ffff,
-            },
-            Aarch64Register {
-                id: 0x1,
-                value: 0x0000_ffff_0000_ffff_0000_ffff_0000_ffff,
-            },
-        ]
+    // These are used as IDs to satisfy requirenments
+    // of `Aarch64RegisterRef::new`
+    const KVM_REG_SIZE_U32: u64 = 0x0020000000000000;
+    const KVM_REG_SIZE_U64: u64 = 0x0030000000000000;
+    const KVM_REG_SIZE_U128: u64 = 0x0040000000000000;
+
+    fn build_sample_regs() -> Aarch64RegisterVec {
+        let mut v = Aarch64RegisterVec::default();
+        v.push(Aarch64RegisterRef::new(
+            KVM_REG_SIZE_U128,
+            &0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff_u128.to_le_bytes(),
+        ));
+        v.push(Aarch64RegisterRef::new(
+            KVM_REG_SIZE_U32,
+            &0x0000_ffff_u32.to_le_bytes(),
+        ));
+        v.push(Aarch64RegisterRef::new(
+            KVM_REG_SIZE_U64,
+            &0x0000_ffff_0000_ffff_u64.to_le_bytes(),
+        ));
+        v
     }
 
     fn build_expected_reg_modifiers() -> Vec<RegisterModifier> {
         vec![
-            reg_modifier!(
-                0x0000_0000_0000_0000,
-                0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff
-            ),
-            reg_modifier!(
-                0x0000_0000_0000_0001,
-                0x0000_ffff_0000_ffff_0000_ffff_0000_ffff
-            ),
-            reg_modifier!(
-                0xffff_ffff_ffff_ffff,
-                0x0000_ffff_0000_ffff_0000_ffff_0000_ffff
-            ),
+            reg_modifier!(KVM_REG_SIZE_U32, 0x0000_ffff),
+            reg_modifier!(KVM_REG_SIZE_U64, 0x0000_ffff_0000_ffff),
+            reg_modifier!(KVM_REG_SIZE_U128, 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff),
         ]
     }
 

src/cpu-template-helper/src/template/dump/aarch64.rs

@@ -14,7 +14,7 @@ bitflags = "2.0.2"
 derive_more = { version = "0.99.17", default-features = false, features = ["from", "display"] }
 event-manager = "0.3.0"
 kvm-bindings = { version = "0.6.0", features = ["fam-wrappers"] }
-kvm-ioctls = "0.12.0"
+kvm-ioctls = "0.14.0"
 lazy_static = "1.4.0"
 libc = "0.2.117"
 linux-loader = "0.9.0"

src/vmm/Cargo.toml

@@ -9,6 +9,8 @@ pub mod gic;
 pub mod layout;
 /// Logic for configuring aarch64 registers.
 pub mod regs;
+/// Helper methods for VcpuFd.
+pub mod vcpu;
 
 use std::cmp::min;
 use std::collections::HashMap;