chore(aarch64): update set_reg error message

Format register id in hex and print the value was attempted to be set.

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

Author: ShadowCurse

src/vmm/src/arch/aarch64/regs.rs

@@ -404,6 +404,31 @@ impl<'a> Aarch64RegisterRef<'a> {
         T::from_slice(self.data)
     }
 
+    /// Returns a string with hex formatted value of the register.
+    pub fn value_str(&self) -> String {
+        fn byte_to_hex(byte: u8) -> (u8, u8) {
+            static HEX_TABLE: [u8; 16] = [
+                b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c', b'd',
+                b'e', b'f',
+            ];
+
+            let hi = HEX_TABLE[(byte >> 4) as usize];
+            let lo = HEX_TABLE[(byte & 0xF) as usize];
+            (hi, lo)
+        }
+        let s = self
+            .data
+            .iter()
+            .rev()
+            .flat_map(|v| {
+                let (hi, lo) = byte_to_hex(*v);
+                [hi, lo]
+            })
+            .collect();
+        let hex = unsafe { String::from_utf8_unchecked(s) };
+        format!("0x{hex}")
+    }
+
     /// Returns register data as a byte slice
     pub fn as_slice(&self) -> &[u8] {
         self.data
@@ -695,6 +720,32 @@ mod tests {
         assert_eq!(reg_ref.value::<u64, 8>(), 69);
     }
 
+    #[test]
+    fn test_reg_ref_value_str() {
+        let bytes = 0x10_u8.to_le_bytes();
+        let reg_ref = Aarch64RegisterRef::new(KVM_REG_SIZE_U8 as u64, &bytes);
+        assert_eq!(reg_ref.value_str(), "0x10");
+
+        let bytes = 0x1020_u16.to_le_bytes();
+        let reg_ref = Aarch64RegisterRef::new(KVM_REG_SIZE_U16, &bytes);
+        assert_eq!(reg_ref.value_str(), "0x1020");
+
+        let bytes = 0x10203040_u32.to_le_bytes();
+        let reg_ref = Aarch64RegisterRef::new(KVM_REG_SIZE_U32, &bytes);
+        assert_eq!(reg_ref.value_str(), "0x10203040");
+
+        let bytes = 0x1020304050607080_u64.to_le_bytes();
+        let reg_ref = Aarch64RegisterRef::new(KVM_REG_SIZE_U64, &bytes);
+        assert_eq!(reg_ref.value_str(), "0x1020304050607080");
+
+        let bytes = [
+            0x71, 0x61, 0x51, 0x41, 0x31, 0x21, 0x11, 0x90, 0x80, 0x70, 0x60, 0x50, 0x40, 0x30,
+            0x20, 0x10,
+        ];
+        let reg_ref = Aarch64RegisterRef::new(KVM_REG_SIZE_U128, &bytes);
+        assert_eq!(reg_ref.value_str(), "0x10203040506070809011213141516171");
+    }
+
     /// Should panic because ID has different size from a slice length.
     /// - Size in ID: 128
     /// - Length of slice: 1

src/vmm/src/arch/aarch64/vcpu.rs

@@ -30,8 +30,8 @@ use crate::vstate::vm::Vm;
 pub enum VcpuArchError {
     /// Failed to get register {0}: {1}
     GetOneReg(u64, kvm_ioctls::Error),
-    /// Failed to set register {0}: {1}
-    SetOneReg(u64, kvm_ioctls::Error),
+    /// Failed to set register {0:#x} to value {1}: {2}
+    SetOneReg(u64, String, kvm_ioctls::Error),
     /// Failed to retrieve list of registers: {0}
     GetRegList(kvm_ioctls::Error),
     /// Failed to get multiprocessor state: {0}
@@ -178,7 +178,11 @@ impl KvmVcpu {
     ) -> Result<(), KvmVcpuError> {
         for reg in vcpu_config.cpu_config.regs.iter() {
             self.fd.set_one_reg(reg.id, reg.as_slice()).map_err(|err| {
-                KvmVcpuError::ApplyCpuTemplate(VcpuArchError::SetOneReg(reg.id, err))
+                KvmVcpuError::ApplyCpuTemplate(VcpuArchError::SetOneReg(
+                    reg.id,
+                    reg.value_str(),
+                    err,
+                ))
             })?;
         }
 
@@ -322,7 +326,9 @@ impl KvmVcpu {
         let id = arm64_core_reg_id!(KVM_REG_SIZE_U64, pstate);
         self.fd
             .set_one_reg(id, &PSTATE_FAULT_BITS_64.to_le_bytes())
-            .map_err(|err| VcpuArchError::SetOneReg(id, err))?;
+            .map_err(|err| {
+                VcpuArchError::SetOneReg(id, format!("{PSTATE_FAULT_BITS_64:#x}"), err)
+            })?;
 
         // Other vCPUs are powered off initially awaiting PSCI wakeup.
         if self.index == 0 {
@@ -331,17 +337,18 @@ impl KvmVcpu {
             let id = arm64_core_reg_id!(KVM_REG_SIZE_U64, pc);
             self.fd
                 .set_one_reg(id, &boot_ip.to_le_bytes())
-                .map_err(|err| VcpuArchError::SetOneReg(id, err))?;
+                .map_err(|err| VcpuArchError::SetOneReg(id, format!("{boot_ip:#x}"), err))?;
 
             // Last mandatory thing to set -> the address pointing to the FDT (also called DTB).
             // "The device tree blob (dtb) must be placed on an 8-byte boundary and must
             // not exceed 2 megabytes in size." -> https://www.kernel.org/doc/Documentation/arm64/booting.txt.
             // We are choosing to place it the end of DRAM. See `get_fdt_addr`.
             let regs0 = offset_of!(user_pt_regs, regs) + kreg_off;
             let id = arm64_core_reg_id!(KVM_REG_SIZE_U64, regs0);
+            let fdt_addr = get_fdt_addr(mem);
             self.fd
-                .set_one_reg(id, &get_fdt_addr(mem).to_le_bytes())
-                .map_err(|err| VcpuArchError::SetOneReg(id, err))?;
+                .set_one_reg(id, &fdt_addr.to_le_bytes())
+                .map_err(|err| VcpuArchError::SetOneReg(id, format!("{fdt_addr:#x}"), err))?;
 
             // Reset the physical counter for the guest. This way we avoid guest reading
             // host physical counter.
@@ -357,7 +364,9 @@ impl KvmVcpu {
             if optional_capabilities.counter_offset {
                 self.fd
                     .set_one_reg(KVM_REG_ARM_PTIMER_CNT, &[0; 8])
-                    .map_err(|err| VcpuArchError::SetOneReg(id, err))?;
+                    .map_err(|err| {
+                        VcpuArchError::SetOneReg(id, format!("{KVM_REG_ARM_PTIMER_CNT:#x}"), err)
+                    })?;
             }
         }
         Ok(())
@@ -409,7 +418,7 @@ impl KvmVcpu {
     pub fn set_register(&self, reg: Aarch64RegisterRef) -> Result<(), VcpuArchError> {
         self.fd
             .set_one_reg(reg.id, reg.as_slice())
-            .map_err(|e| VcpuArchError::SetOneReg(reg.id, e))?;
+            .map_err(|e| VcpuArchError::SetOneReg(reg.id, reg.value_str(), e))?;
         Ok(())
     }
 
@@ -569,6 +578,7 @@ mod tests {
             err.unwrap_err(),
             KvmVcpuError::ConfigureRegisters(VcpuArchError::SetOneReg(
                 0x6030000000100042,
+                String::new(),
                 kvm_ioctls::Error::new(9)
             ))
         );
@@ -626,7 +636,7 @@ mod tests {
         let res = vcpu.restore_state(&faulty_vcpu_state);
         assert!(matches!(
             res.unwrap_err(),
-            KvmVcpuError::RestoreState(VcpuArchError::SetOneReg(0, _))
+            KvmVcpuError::RestoreState(VcpuArchError::SetOneReg(0, _, _))
         ));
 
         vcpu.init(&[]).unwrap();
@@ -696,7 +706,7 @@ mod tests {
         let res = vcpu.setup_boot_regs(0x0, &mem, &optional_capabilities);
         assert!(matches!(
             res.unwrap_err(),
-            VcpuArchError::SetOneReg(0x6030000000100042, _)
+            VcpuArchError::SetOneReg(0x6030000000100042, _, _)
         ));
 
         vcpu.init_vcpu().unwrap();