feat: allow loading older snapshots

Now that we have logic for translating snapshot formats, we can allow
the /snapshot/load API to parse v1.10 and v1.12 snapshots. We change the
logic that parses the snapshot file to first read the version from the
file and then (if needed) translate it to the expected v1.14 version.

Currently older versions supported are v1.10 and v1.12.

Signed-off-by: Babis Chalios <babis.chalios@e2b.dev>

Author: bchalios

src/vmm/src/persist/mod.rs

@@ -11,6 +11,7 @@ use std::os::unix::io::AsRawFd;
 use std::os::unix::net::UnixStream;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
+use std::time::Instant;
 
 use semver::Version;
 use serde::{Deserialize, Serialize};
@@ -29,7 +30,7 @@ use crate::device_manager::{DevicePersistError, DevicesState};
 use crate::logger::{info, warn};
 use crate::resources::VmResources;
 use crate::seccomp::BpfThreadMap;
-use crate::snapshot::Snapshot;
+use crate::snapshot::{Snapshot, SnapshotError, SnapshotHdr};
 use crate::utils::u64_to_usize;
 use crate::vmm_config::boot_source::BootSourceConfig;
 use crate::vmm_config::instance_info::InstanceInfo;
@@ -451,10 +452,36 @@ pub enum SnapshotStateFromFileError {
 fn snapshot_state_from_file(
     snapshot_path: &Path,
 ) -> Result<MicrovmState, SnapshotStateFromFileError> {
-    let mut snapshot_reader = File::open(snapshot_path)?;
-    let snapshot = Snapshot::load(&mut snapshot_reader)?;
+    let start = Instant::now();
 
-    Ok(snapshot.data)
+    let data = std::fs::read(snapshot_path)?;
+    let version = SnapshotHdr::load(&mut data.as_slice())?.version;
+
+    let mut snapshot_reader = data.as_slice();
+    let data = match (version.major, version.minor) {
+        (8, 0) => Snapshot::load(&mut snapshot_reader)?.data,
+        (6, 0) => {
+            let v12_state = Snapshot::<v1_12::MicrovmState>::load(&mut snapshot_reader)?;
+            MicrovmState::try_from(v12_state.data).unwrap()
+        }
+        (4, 0) => {
+            let v10_state = Snapshot::<v1_10::MicrovmState>::load(&mut snapshot_reader)?;
+            let v12_state = v1_12::MicrovmState::from(v10_state.data);
+            MicrovmState::try_from(v12_state).unwrap()
+        }
+        _ => {
+            return Err(SnapshotStateFromFileError::Load(
+                SnapshotError::InvalidFormatVersion(version),
+            ));
+        }
+    };
+
+    info!(
+        "Loading snapshot file took {} usec",
+        start.elapsed().as_micros()
+    );
+
+    Ok(data)
 }
 
 /// Error type for [`guest_memory_from_file`].

src/vmm/src/snapshot/mod.rs

@@ -81,26 +81,21 @@ fn serialize<S: Serialize, W: Write>(data: &S, write: &mut W) -> Result<(), Snap
 
 /// Firecracker snapshot header
 #[derive(Debug, Serialize, Deserialize)]
-struct SnapshotHdr {
+pub struct SnapshotHdr {
     /// magic value
-    magic: u64,
+    pub magic: u64,
     /// Snapshot data version
-    version: Version,
+    pub version: Version,
 }
 
 impl SnapshotHdr {
-    fn load(buf: &mut &[u8]) -> Result<Self, SnapshotError> {
+    pub(crate) fn load(buf: &mut &[u8]) -> Result<Self, SnapshotError> {
         let (hdr, bytes_read) = bincode::serde::decode_from_slice::<Self, _>(buf, BINCODE_CONFIG)?;
 
         if hdr.magic != SNAPSHOT_MAGIC_ID {
             return Err(SnapshotError::InvalidMagic(hdr.magic));
         }
 
-        if hdr.version.major != SNAPSHOT_VERSION.major || hdr.version.minor > SNAPSHOT_VERSION.minor
-        {
-            return Err(SnapshotError::InvalidFormatVersion(hdr.version));
-        }
-
         *buf = &buf[bytes_read..];
 
         Ok(hdr)