Import from Firecracker

Signed-off-by: Adrian Catangiu <[email protected]>

Author: acatangiu

Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "versionize"
+version = "0.1.0"
+authors = ["Amazon Firecracker team <[email protected]>"]
+
+[dependencies]
+serde = ">=1.0.27"
+serde_derive = ">=1.0.27"
+bincode = "1.2.1"
+versionize_derive = { git = "https://github.com/firecracker-microvm/versionize_derive" }
+crc64 = "1.0.0"
+vm-memory = { version = ">=0.2.0" }
+vmm-sys-util = ">=0.4.0"
+
+[build-dependencies]
+proc-macro2 = ">=1.0"
+quote = ">=1.0"
+syn = { version = ">=1.0.13", features=["default","full"]}
+versionize_derive = { git = "https://github.com/firecracker-microvm/versionize_derive" }

src/crc.rs

@@ -0,0 +1,122 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Implements readers and writers that compute a CRC64 checksum on the bytes
+//! read/written.
+
+use crc64::crc64;
+use std::io::{Read, Write};
+
+/// Computes CRC64 checksums from read bytes.
+pub struct CRC64Reader<T> {
+    reader: T,
+    crc64: u64,
+}
+
+impl<T> CRC64Reader<T>
+where
+    T: Read,
+{
+    /// Create a new reader.
+    pub fn new(reader: T) -> Self {
+        CRC64Reader { crc64: 0, reader }
+    }
+    /// Returns the current checksum value.
+    pub fn checksum(&self) -> u64 {
+        self.crc64
+    }
+}
+
+impl<T> Read for CRC64Reader<T>
+where
+    T: Read,
+{
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let bytes_read = self.reader.read(buf)?;
+        self.crc64 = crc64(self.crc64, &buf[..bytes_read]);
+        Ok(bytes_read)
+    }
+}
+
+/// Computes CRC64 checksums from written bytes.
+pub struct CRC64Writer<T> {
+    writer: T,
+    crc64: u64,
+}
+
+impl<T> CRC64Writer<T>
+where
+    T: Write,
+{
+    /// Create a new writer.
+    pub fn new(writer: T) -> Self {
+        CRC64Writer { crc64: 0, writer }
+    }
+
+    /// Returns the current checksum value.
+    pub fn checksum(&self) -> u64 {
+        self.crc64
+    }
+}
+
+impl<T> Write for CRC64Writer<T>
+where
+    T: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let bytes_written = self.writer.write(buf)?;
+        self.crc64 = crc64(self.crc64, &buf[..bytes_written]);
+        Ok(bytes_written)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.writer.flush()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{CRC64Reader, CRC64Writer, Read, Write};
+
+    #[test]
+    fn test_crc_new() {
+        let buf = vec![1; 5];
+        let mut slice = buf.as_slice();
+        let crc_reader = CRC64Reader::new(&mut slice);
+        assert_eq!(crc_reader.crc64, 0);
+        assert_eq!(crc_reader.reader, &[1; 5]);
+        assert_eq!(crc_reader.checksum(), 0);
+
+        let mut buf = vec![0; 5];
+        let mut slice = buf.as_mut_slice();
+        let crc_writer = CRC64Writer::new(&mut slice);
+        assert_eq!(crc_writer.crc64, 0);
+        assert_eq!(crc_writer.writer, &[0; 5]);
+        assert_eq!(crc_writer.checksum(), 0);
+    }
+
+    #[test]
+    fn test_crc_read() {
+        let buf = vec![1, 2, 3, 4, 5];
+        let mut read_buf = vec![0; 16];
+
+        let mut slice = buf.as_slice();
+        let mut crc_reader = CRC64Reader::new(&mut slice);
+        crc_reader.read_to_end(&mut read_buf).unwrap();
+        assert_eq!(crc_reader.checksum(), 0xFB04_60DE_0638_3654);
+        assert_eq!(crc_reader.checksum(), crc_reader.crc64);
+    }
+
+    #[test]
+    fn test_crc_write() {
+        let mut buf = vec![0; 16];
+        let write_buf = vec![123; 16];
+
+        let mut slice = buf.as_mut_slice();
+        let mut crc_writer = CRC64Writer::new(&mut slice);
+        crc_writer.write_all(&write_buf.as_slice()).unwrap();
+        crc_writer.flush().unwrap();
+        assert_eq!(crc_writer.checksum(), 0x29D5_3572_1632_6566);
+        assert_eq!(crc_writer.checksum(), crc_writer.crc64);
+    }
+}

src/lib.rs

@@ -0,0 +1,78 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+#![deny(missing_docs)]
+
+//! Provides version tolerant serialization and deserialization facilities and
+//! implements a persistent storage format for Firecracker state snapshots.
+//! The `Versionize` trait defines a generic interface that serializable state structures
+//! need to implement.
+//!
+//! `VersionMap` exposes an API that maps the individual structure versions to
+//! a root version (see above: the data version for example). This mapping is required
+//! both when serializing or deserializing structures as we need to know which version of structure
+//! to serialize for a given target **data version
+//!
+extern crate bincode;
+extern crate crc64;
+extern crate serde;
+extern crate serde_derive;
+extern crate versionize_derive;
+extern crate vm_memory;
+extern crate vmm_sys_util;
+
+pub mod crc;
+mod primitives;
+pub mod version_map;
+
+use std::any::TypeId;
+use std::io::{Read, Write};
+pub use version_map::VersionMap;
+use versionize_derive::Versionize;
+
+/// Versioned serialization error definitions.
+#[derive(Debug, PartialEq)]
+pub enum VersionizeError {
+    /// An IO error occured.
+    Io(i32),
+    /// A serialization error.
+    Serialize(String),
+    /// A deserialization error.
+    Deserialize(String),
+    /// A user generated semantic error.
+    Semantic(String),
+}
+
+/// Versioned serialization/deserialization result.
+pub type VersionizeResult<T> = std::result::Result<T, VersionizeError>;
+
+/// Trait that provides an interface for version aware serialization and deserialization.
+pub trait Versionize {
+    /// Serializes `self` to `target_verion` using the specficifed `writer` and `version_map`.
+    fn serialize<W: Write>(
+        &self,
+        writer: &mut W,
+        version_map: &VersionMap,
+        target_version: u16,
+    ) -> VersionizeResult<()>;
+
+    /// Returns a new instance of `Self` by deserialzing from `source_version` using the
+    /// specficifed `reader` and `version_map`.
+    fn deserialize<R: Read>(
+        reader: &mut R,
+        version_map: &VersionMap,
+        source_version: u16,
+    ) -> VersionizeResult<Self>
+    where
+        Self: Sized;
+
+    /// Returns the `Self` type id.
+    fn type_id() -> std::any::TypeId
+    where
+        Self: 'static,
+    {
+        TypeId::of::<Self>()
+    }
+
+    /// Returns latest `Self` version number.
+    fn version() -> u16;
+}