snapshot: serialize snapshots using CBOR

The main motivation for this change is support more efficient
snapshotting of binary data for virtio-gpu 3d backends. It isn't
expected to make much of a difference for existing snapshot support.

Even though this adds a new dependency, the overall crosvm binary size
goes down a bit (-30kb). From some quick experimentation, I noticed that
only switching to `ciborium::Value` (from `serde_json::Value`) netted a
bigger binary size drop, so it is probably the conversion to/from
`AnySnapshot` that is responsible.

Excluding the RAM snapshot file, the total snapshot size goes from 108K
to 88K.

Quick and not completely trustworthy benchmarking results on Cuttlefish
(with virtio-gpu 2D backend):

    snapshot time (seconds):
        before: 4.275 4.259 4.265 4.271
        after:  4.212 4.152 4.162 4.153

    restore time (seconds):
        before: 35.843 25.404 35.778 25.467
        after:  25.121 25.401 25.361 25.331

Ignoring the 35 second restore times (probably from some interference),
there is a tiny latency improvement.

Bug: 369615058
Change-Id: I904bb7fb50951b727fc90541ffce10652b580705
Reviewed-on: https://chromium-review.googlesource.com/c/crosvm/crosvm/+/6161914
Reviewed-by: Daniel Verkamp <[email protected]>
Reviewed-by: Elie Kheirallah <[email protected]>
Commit-Queue: Frederick Mayle <[email protected]>
Auto-Submit: Frederick Mayle <[email protected]>

Author: fkm3

Cargo.lock

@@ -117,6 +117,7 @@ exclude = [
 ]
 
 [workspace.dependencies]
+ciborium = "0.2.2"
 tokio = { version = "1.29.1", features = ["net", "rt-multi-thread", "time", "sync", "macros"] }
 snapshot = { path = "snapshot" }
 

Cargo.toml

@@ -103,6 +103,7 @@ virtio-media = { version = "0.0.7", optional = true }
 vm_control = { path = "../vm_control" }
 vm_memory = { path = "../vm_memory" }
 zerocopy = { version = "0.8.13", features = ["derive"] }
+ciborium = { workspace = true }
 
 [target.'cfg(any(target_os = "android", target_os = "linux"))'.dependencies]
 android_audio = { path = "../android_audio" }

devices/Cargo.toml

@@ -6,7 +6,6 @@
 
 use std::fs;
 use std::fs::File;
-use std::io::BufReader;
 use std::io::BufWriter;
 use std::io::Seek;
 use std::io::Write;
@@ -82,12 +81,9 @@ impl SnapshotFile {
     }
 
     fn read(&mut self) -> anyhow::Result<AnySnapshot> {
-        let data: AnySnapshot = {
-            let mut reader = BufReader::new(&self.file);
-
-            serde_json::from_reader(&mut reader)
-                .context("failed to read snapshot data from snapshot temp file")?
-        };
+        // NOTE: No BufReader because ciborium::from_reader has an internal buffer.
+        let data: AnySnapshot = ciborium::from_reader(&mut self.file)
+            .context("failed to read snapshot data from snapshot temp file")?;
 
         self.file
             .rewind()
@@ -100,7 +96,7 @@ impl SnapshotFile {
         {
             let mut writer = BufWriter::new(&self.file);
 
-            serde_json::to_writer(&mut writer, &data)
+            ciborium::into_writer(&data, &mut writer)
                 .context("failed to write data to snasphot temp file")?;
 
             writer

devices/src/proxy.rs

@@ -294,8 +294,8 @@ pub struct DeviceRequestHandler<T: VhostUserDevice> {
 }
 
 enum DeviceStateThread {
-    Save(WorkerThread<serde_json::Result<()>>),
-    Load(WorkerThread<serde_json::Result<DeviceRequestHandlerSnapshot>>),
+    Save(WorkerThread<Result<(), ciborium::ser::Error<std::io::Error>>>),
+    Load(WorkerThread<Result<DeviceRequestHandlerSnapshot, ciborium::de::Error<std::io::Error>>>),
 }
 
 #[derive(Serialize, Deserialize)]
@@ -747,7 +747,8 @@ impl<T: VhostUserDevice> vmm_vhost::Backend for DeviceRequestHandler<T> {
                 // Spawn thread to write the serialized bytes.
                 self.device_state_thread = Some(DeviceStateThread::Save(WorkerThread::start(
                     "device_state_save",
-                    move |_kill_event| serde_json::to_writer(&mut fd, &snapshot),
+                    // TODO: should probably use BufWriter
+                    move |_kill_event| ciborium::into_writer(&snapshot, &mut fd),
                 )));
                 Ok(None)
             }
@@ -756,7 +757,7 @@ impl<T: VhostUserDevice> vmm_vhost::Backend for DeviceRequestHandler<T> {
                 // `check_device_state`.
                 self.device_state_thread = Some(DeviceStateThread::Load(WorkerThread::start(
                     "device_state_load",
-                    move |_kill_event| serde_json::from_reader(&mut fd),
+                    move |_kill_event| ciborium::from_reader(&mut fd),
                 )));
                 Ok(None)
             }

devices/src/virtio/vhost/user/device/handler.rs

@@ -12,6 +12,28 @@ there is no way to fetch this state atomically, we have to freeze the guest (VCP
 backends. Similarly, on restore we must freeze in the same way to prevent partially restored state
 from being modified.
 
+## Snapshot format
+
+The snapshot format is not stable. Currently, the output is a directory, where most VM components
+are snapshotted to separate files using CBOR encoding.
+
+When debugging snapshots, you may want to inspect the CBOR files. One tool available is
+[cbor-cli](https://docs.rs/crate/cbor-cli/latest). You can run `cargo install cbor-cli`, then use it
+to view a file as JSON, e.g.
+
+```
+$ cbor export --format=json /tmp/crosvm-snapshot/irqchip | jq
+{
+  "mp_state": [
+    "Halted",
+    "Halted",
+    "Halted",
+    "Halted"
+  ],
+  "pit_state": {
+...
+```
+
 ## Snapshotting a running VM
 
 In code, this is implemented by

docs/book/src/architecture/snapshotting.md

@@ -12,3 +12,4 @@ base = { path = "../base" }
 crypto = { path = "../vendor/generic/crypto", package = "crypto_generic" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+ciborium = { workspace = true }

snapshot/Cargo.toml

@@ -14,15 +14,15 @@
 /// it will technically work, but the result might not match what you'd get if you directly
 /// serialized the original value. That should be OK as long as the serialization and
 /// deserialization paths make symmetric use of `AnySnapshot`.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub struct AnySnapshot(serde_json::Value);
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct AnySnapshot(ciborium::Value);
 
 impl AnySnapshot {
     pub fn to_any(x: impl serde::Serialize) -> anyhow::Result<Self> {
-        Ok(AnySnapshot(serde_json::to_value(x)?))
+        Ok(AnySnapshot(ciborium::Value::serialized(&x)?))
     }
 
     pub fn from_any<T: serde::de::DeserializeOwned>(x: Self) -> anyhow::Result<T> {
-        Ok(serde_json::from_value(x.0)?)
+        Ok(x.0.deserialized()?)
     }
 }

snapshot/src/any_snapshot.rs

@@ -117,7 +117,7 @@ impl SnapshotWriter {
     /// Creates a snapshot fragment from a serialized representation of `v`.
     pub fn write_fragment<T: serde::Serialize>(&self, name: &str, v: &T) -> Result<()> {
         let mut w = std::io::BufWriter::new(self.raw_fragment(name)?);
-        serde_json::to_writer(&mut w, v)?;
+        ciborium::into_writer(v, &mut w)?;
         w.flush()?;
         Ok(())
     }
@@ -199,8 +199,8 @@ impl SnapshotReader {
 
     /// Reads a fragment.
     pub fn read_fragment<T: serde::de::DeserializeOwned>(&self, name: &str) -> Result<T> {
-        serde_json::from_reader(std::io::BufReader::new(self.raw_fragment(name)?))
-            .with_context(|| format!("failed to parse json from snapshot fragment named {}", name))
+        // NOTE: No BufReader because ciborium::from_reader has an internal buffer.
+        Ok(ciborium::from_reader(self.raw_fragment(name)?)?)
     }
 
     /// Reads the names of all fragments in this namespace.