riscv64: Introduce serde feature

Implement `serde` for basic RISC-V register structures to help VM
snapshotting.

Signed-off-by: Ruoqing He <[email protected]>

Author: RuoqingHe

CHANGELOG.md

@@ -3,7 +3,7 @@
 
 ### Added
 
-- RISC-V KVM bindings for Linux kernel v6.9.
+- RISC-V KVM bindings for Linux kernel v6.9, including serialization support.
 
 ### Changed
 

src/lib.rs

@@ -12,13 +12,13 @@
 #[macro_use]
 extern crate vmm_sys_util;
 
-#[cfg(all(feature = "serde", not(target_arch = "riscv64")))]
+#[cfg(feature = "serde")]
 extern crate serde;
 
-#[cfg(all(feature = "serde", not(target_arch = "riscv64")))]
+#[cfg(feature = "serde")]
 extern crate zerocopy;
 
-#[cfg(all(feature = "serde", not(target_arch = "riscv64")))]
+#[cfg(feature = "serde")]
 #[macro_use]
 mod serialize;
 

src/riscv64/bindings.rs

@@ -630,6 +630,10 @@ pub type __wsum = __u32;
 pub type __poll_t = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct user_regs_struct {
     pub pc: ::std::os::raw::c_ulong,
     pub ra: ::std::os::raw::c_ulong,
@@ -1592,6 +1596,10 @@ fn bindgen_test_layout_kvm_sregs() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_config {
     pub isa: ::std::os::raw::c_ulong,
     pub zicbom_block_size: ::std::os::raw::c_ulong,
@@ -1688,6 +1696,10 @@ fn bindgen_test_layout_kvm_riscv_config() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_core {
     pub regs: user_regs_struct,
     pub mode: ::std::os::raw::c_ulong,
@@ -1729,6 +1741,10 @@ fn bindgen_test_layout_kvm_riscv_core() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_csr {
     pub sstatus: ::std::os::raw::c_ulong,
     pub sie: ::std::os::raw::c_ulong,
@@ -1869,6 +1885,10 @@ fn bindgen_test_layout_kvm_riscv_csr() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_aia_csr {
     pub siselect: ::std::os::raw::c_ulong,
     pub iprio1: ::std::os::raw::c_ulong,
@@ -1965,6 +1985,10 @@ fn bindgen_test_layout_kvm_riscv_aia_csr() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_smstateen_csr {
     pub sstateen0: ::std::os::raw::c_ulong,
 }
@@ -1996,6 +2020,10 @@ fn bindgen_test_layout_kvm_riscv_smstateen_csr() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_timer {
     pub frequency: __u64,
     pub time: __u64,
@@ -2128,6 +2156,10 @@ pub const KVM_RISCV_SBI_EXT_ID_KVM_RISCV_SBI_EXT_MAX: KVM_RISCV_SBI_EXT_ID = 11;
 pub type KVM_RISCV_SBI_EXT_ID = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_riscv_sbi_sta {
     pub shmem_lo: ::std::os::raw::c_ulong,
     pub shmem_hi: ::std::os::raw::c_ulong,
@@ -6387,6 +6419,10 @@ fn bindgen_test_layout_kvm_vapic_addr() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_mp_state {
     pub mp_state: __u32,
 }
@@ -7549,6 +7585,10 @@ fn bindgen_test_layout_kvm_reg_list() {
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+)]
 pub struct kvm_one_reg {
     pub id: __u64,
     pub addr: __u64,

src/riscv64/mod.rs

@@ -8,6 +8,9 @@ pub mod bindings;
 #[cfg(feature = "fam-wrappers")]
 pub mod fam_wrappers;
 
+#[cfg(feature = "serde")]
+mod serialize;
+
 pub use self::bindings::*;
 #[cfg(feature = "fam-wrappers")]
 pub use self::fam_wrappers::*;

src/riscv64/serialize.rs

@@ -0,0 +1,96 @@
+// Copyright 2024 © Institute of Software, CAS. All rights reserved.
+// Copyright 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use bindings::{
+    kvm_mp_state, kvm_one_reg, kvm_riscv_aia_csr, kvm_riscv_config, kvm_riscv_core, kvm_riscv_csr,
+    kvm_riscv_sbi_sta, kvm_riscv_smstateen_csr, kvm_riscv_timer, user_regs_struct,
+};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use zerocopy::{transmute, AsBytes};
+
+serde_impls! {
+    kvm_mp_state,
+    kvm_one_reg,
+    kvm_riscv_config,
+    kvm_riscv_core,
+    user_regs_struct,
+    kvm_riscv_csr,
+    kvm_riscv_aia_csr,
+    kvm_riscv_smstateen_csr,
+    kvm_riscv_timer,
+    kvm_riscv_sbi_sta
+}
+
+#[cfg(test)]
+mod tests {
+    use bindings::*;
+    use serde::{Deserialize, Serialize};
+
+    fn is_serde<T: Serialize + for<'de> Deserialize<'de> + Default>() {
+        let serialized = bincode::serialize(&T::default()).unwrap();
+        let deserialized = bincode::deserialize::<T>(serialized.as_ref()).unwrap();
+        let serialized_again = bincode::serialize(&deserialized).unwrap();
+        // Compare the serialized state after a roundtrip, to work around issues with
+        // bindings not implementing `PartialEq`.
+        assert_eq!(serialized, serialized_again);
+    }
+
+    #[test]
+    fn static_assert_serde_implementations() {
+        // This test statically (= at compile-time) asserts that various bindgen generated
+        // structures implement serde's `Serialize` and `Deserialize` traits.
+        // This is to make sure that we do not accidentally remove those implementations
+        // when regenerating bindings. If this test fails to compile, please add
+        //
+        // #[cfg_attr(
+        //     feature = "serde",
+        //     derive(zerocopy::AsBytes, zerocopy::FromBytes, zerocopy::FromZeroes)
+        // )]
+        //
+        // to all structures causing compilation errors (we need the zerocopy traits, as the
+        // `Serialize` and `Deserialize` implementations are provided by the `serde_impls!` macro
+        // above, which implements serialization based on zerocopy's `FromBytes` and `AsBytes`
+        // traits that it expects to be derived).
+        //
+        // NOTE: This only include "top-level" items, and does not list out bindgen-anonymous types
+        // (e.g. types like `kvm_vcpu_events__bindgen_ty_5`). These types can change name across
+        // bindgen versions. If after re-adding the derives to all the below items you can compile
+        // errors about anonymous types not implementing `Serialize`/`Deserialize`, please also add
+        // the derives to all anonymous types references in the definitions of the below items.
+
+        is_serde::<kvm_mp_state>();
+        is_serde::<kvm_one_reg>();
+        is_serde::<kvm_riscv_config>();
+        is_serde::<kvm_riscv_core>();
+        is_serde::<user_regs_struct>();
+        is_serde::<kvm_riscv_csr>();
+        is_serde::<kvm_riscv_aia_csr>();
+        is_serde::<kvm_riscv_smstateen_csr>();
+        is_serde::<kvm_riscv_timer>();
+        is_serde::<kvm_riscv_sbi_sta>();
+    }
+
+    fn is_serde_json<T: Serialize + for<'de> Deserialize<'de> + Default>() {
+        let serialized = serde_json::to_string(&T::default()).unwrap();
+        let deserialized = serde_json::from_str::<T>(serialized.as_ref()).unwrap();
+        let serialized_again = serde_json::to_string(&deserialized).unwrap();
+        // Compare the serialized state after a roundtrip, to work around issues with
+        // bindings not implementing `PartialEq`.
+        assert_eq!(serialized, serialized_again);
+    }
+
+    #[test]
+    fn test_json_serde() {
+        is_serde_json::<kvm_mp_state>();
+        is_serde_json::<kvm_one_reg>();
+        is_serde_json::<kvm_riscv_config>();
+        is_serde_json::<kvm_riscv_core>();
+        is_serde_json::<user_regs_struct>();
+        is_serde_json::<kvm_riscv_csr>();
+        is_serde_json::<kvm_riscv_aia_csr>();
+        is_serde_json::<kvm_riscv_smstateen_csr>();
+        is_serde_json::<kvm_riscv_timer>();
+        is_serde_json::<kvm_riscv_sbi_sta>();
+    }
+}