add RtcStateSer

This provides serialization capabilities to RTCState,
and is defined in the vm-superio-ser crate.
RtcStateSer mirrors the state structure from vm-superio and
derives the required (de)serialization/versioning traits
(i.e. Serialize, Deserialize, Versionize).

Signed-off-by: Laura Loghin <lauralg@amazon.com>

Author: lauralt

coverage_config_x86_64.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 98.6,
+  "coverage_score": 96.5,
   "exclude_path": "",
   "crate_features": ""
 }

crates/vm-superio-ser/src/lib.rs

@@ -8,3 +8,7 @@
 //! implement the `Serialize`, `Deserialize` and `Versionize` traits as well.
 
 #![deny(missing_docs)]
+
+pub mod rtc_pl031;
+
+pub use rtc_pl031::RtcStateSer;

crates/vm-superio-ser/src/rtc_pl031.rs

@@ -0,0 +1,93 @@
+// Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+//! Provides a wrapper over an `RtcState` that has serialization capabilities.
+//!
+//! This module defines the `RtcStateSer` abstraction which mirrors the
+//! `RtcState` from the base crate, and adds on top of it derives for
+//! the `Serialize`, `Deserialize` and `Versionize` traits.
+
+use serde::{Deserialize, Serialize};
+use versionize::{VersionMap, Versionize, VersionizeResult};
+use versionize_derive::Versionize;
+use vm_superio::RtcState;
+
+/// Wrapper over an `RtcState` that has serialization capabilities.
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize, Versionize)]
+pub struct RtcStateSer {
+    /// The load register.
+    pub lr: u32,
+    /// The offset applied to the counter to get the RTC value.
+    pub offset: i64,
+    /// The MR register.
+    pub mr: u32,
+    /// The interrupt mask.
+    pub imsc: u32,
+    /// The raw interrupt value.
+    pub ris: u32,
+}
+
+impl From<&RtcStateSer> for RtcState {
+    fn from(state: &RtcStateSer) -> Self {
+        RtcState {
+            lr: state.lr,
+            offset: state.offset,
+            mr: state.mr,
+            imsc: state.imsc,
+            ris: state.ris,
+        }
+    }
+}
+
+impl RtcStateSer {
+    /// Creates a new `RtcStateSer` from a reference to an `RtcState` object.
+    pub fn new(state: &RtcState) -> RtcStateSer {
+        RtcStateSer {
+            lr: state.lr,
+            offset: state.offset,
+            mr: state.mr,
+            imsc: state.imsc,
+            ris: state.ris,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vm_superio::rtc_pl031::NoEvents;
+    use vm_superio::Rtc;
+
+    #[test]
+    fn test_state_ser() {
+        let mut rtc = Rtc::default();
+        let mut data = [0; 4];
+
+        // Do some operations with the RTC.
+        // Get the RTC value with a load register of 0 (the initial value).
+        rtc.read(0x000, &mut data);
+
+        let data2 = [1; 4];
+        // Write to LR register.
+        rtc.write(0x008, &data2);
+
+        let state = rtc.state();
+        let ser_state = RtcStateSer::new(&state);
+
+        let state_after_restore = RtcState::from(&ser_state);
+        let mut rtc_after_restore = Rtc::from_state(&state_after_restore, NoEvents);
+
+        // Reading from the LR register should return the same value as before saving the state.
+        rtc_after_restore.read(0x008, &mut data);
+        assert_eq!(data, data2);
+
+        // Check that the old and the new state are identical when using the intermediate
+        // `RtcStateSer` object as well.
+        assert_eq!(state.lr, state_after_restore.lr);
+        assert_eq!(state.ris, state_after_restore.ris);
+        assert_eq!(state.imsc, state_after_restore.imsc);
+        assert_eq!(state.offset, state_after_restore.offset);
+        assert_eq!(state.mr, state_after_restore.mr);
+    }
+}

crates/vm-superio/src/lib.rs

@@ -22,7 +22,7 @@ pub mod rtc_pl031;
 pub mod serial;
 
 pub use i8042::I8042Device;
-pub use rtc_pl031::Rtc;
+pub use rtc_pl031::{Rtc, RtcState};
 pub use serial::Serial;
 
 use std::result::Result;

crates/vm-superio/src/rtc_pl031.rs

@@ -203,7 +203,7 @@ impl<EV: RtcEvents> Rtc<EV> {
 
             // A struct implementing RtcEvents for tracking the occurrence of
             // significant events.
-            events
+            events,
         }
     }