feat: add support for serialize

Signed-off-by: Woshiluo Luo <[email protected]>

Author: woshiluo

examples/serialize.rs

@@ -0,0 +1,36 @@
+use serde_derive::Serialize;
+use std::io::prelude::*;
+
+const MAX_SIZE: usize = 256 + 32;
+
+fn main() {
+    #[derive(Serialize)]
+    struct Base {
+        pub hello: u32,
+        pub base1: Base1,
+        pub hello2: u32,
+        pub base2: Base1,
+    }
+    #[derive(Serialize)]
+    struct Base1 {
+        pub hello: &'static str,
+    }
+    let mut buf1 = [0u8; MAX_SIZE];
+
+    {
+        let new_base = Base1 { hello: "added" };
+        let patch = serde_device_tree::ser::patch::Patch::new("/base3", &new_base as _);
+        let mut list = [patch];
+        let base = Base {
+            hello: 0xdeedbeef,
+            base1: Base1 {
+                hello: "Hello, World!",
+            },
+            hello2: 0x11223344,
+            base2: Base1 { hello: "Roger" },
+        };
+        serde_device_tree::ser::to_dtb(&base, &mut list, &mut buf1).unwrap();
+    }
+    let mut file = std::fs::File::create("gen.dtb").unwrap();
+    file.write_all(&buf1).unwrap();
+}

src/common.rs

@@ -15,7 +15,7 @@ pub(crate) struct Header {
     pub size_dt_struct: u32,
 }
 
-const DEVICE_TREE_MAGIC: u32 = 0xD00DFEED;
+pub const DEVICE_TREE_MAGIC: u32 = 0xD00DFEED;
 const U32_LEN: u32 = core::mem::size_of::<u32>() as _;
 
 pub(crate) const ALIGN: usize = core::mem::align_of::<usize>();

src/ser/mod.rs

@@ -6,12 +6,16 @@ pub mod string_block;
 use crate::common::*;
 use crate::ser::patch::Patch;
 
+const RSVMAP_LEN: usize = 16;
+
 /// We do run-twice on convert, first time to generate string block, second time todo real
 /// structure.
 pub fn to_dtb<'se, T>(data: &T, list: &'se [Patch<'se>], writer: &'se mut [u8]) -> Result<(), Error>
 where
     T: serde::ser::Serialize,
 {
+    writer.iter_mut().for_each(|x| *x = 0);
+
     let mut offset: usize = 0;
     {
         let mut dst = crate::ser::pointer::Pointer::new(None);
@@ -22,24 +26,37 @@ where
         data.serialize(&mut ser)?;
     };
     list.iter().for_each(|patch| patch.init());
-    {
-        // Write from bottom to top, to avoid overlap.
-        for i in (0..offset).rev() {
-            writer[writer.len() - offset + i] = writer[i];
-            writer[i] = 0;
-        }
-        // TODO: make sure no out of bound.
+    // Write from bottom to top, to avoid overlap.
+    for i in (0..offset).rev() {
+        writer[writer.len() - offset + i] = writer[i];
+        writer[i] = 0;
+    }
+    // TODO: make sure no out of bound.
 
-        // -1 for end zero.
-        let (data_block, string_block) = writer.split_at_mut(writer.len() - offset);
-        let (_, data_block) = data_block.split_at_mut(size_of::<crate::common::Header>());
+    let writer_len = writer.len();
+    let (data_block, string_block) = writer.split_at_mut(writer.len() - offset);
+    let (header, data_block) = data_block.split_at_mut(HEADER_LEN as usize + RSVMAP_LEN);
+    {
         let mut patch_list = crate::ser::patch::PatchList::new(list);
         let mut block = crate::ser::string_block::StringBlock::new(string_block, &mut offset);
         let mut dst = crate::ser::pointer::Pointer::new(Some(data_block));
         let mut ser =
             crate::ser::serializer::Serializer::new(&mut dst, &mut block, &mut patch_list);
-        ser.dst.step_by_u32(FDT_END);
         data.serialize(&mut ser)?;
+        ser.dst.step_by_u32(FDT_END);
+    }
+    {
+        let header = unsafe { &mut *(header.as_mut_ptr() as *mut Header) };
+        header.magic = u32::from_be(DEVICE_TREE_MAGIC);
+        header.total_size = u32::from_be(writer_len as u32);
+        header.off_dt_struct = u32::from_be(HEADER_LEN + RSVMAP_LEN as u32);
+        header.off_dt_strings = u32::from_be((writer_len - offset) as u32);
+        header.off_mem_rsvmap = u32::from_be(HEADER_LEN);
+        header.version = u32::from_be(SUPPORTED_VERSION);
+        header.last_comp_version = u32::from_be(SUPPORTED_VERSION); // TODO: maybe 16
+        header.boot_cpuid_phys = 0; // TODO: wtf is this prop
+        header.size_dt_strings = u32::from_be(offset as u32);
+        header.size_dt_struct = u32::from_be(data_block.len() as u32); // TODO: correct?
     }
     Ok(())
 }

src/ser/serializer.rs

@@ -14,6 +14,7 @@ pub struct Serializer<'se> {
     pub dst: &'se mut Pointer<'se>,
     string_block: &'se mut StringBlock<'se>,
     value_type: ValueType,
+    current_name: &'se str,
     current_dep: usize,
     patch_list: &'se mut PatchList<'se>,
 }
@@ -28,6 +29,7 @@ impl<'se> Serializer<'se> {
             dst,
             string_block: cache,
             current_dep: 0,
+            current_name: "",
             value_type: ValueType::Node,
             patch_list,
         }
@@ -46,8 +48,10 @@ impl<'a, 'se> SerializeDynamicField<'se> for &'a mut Serializer<'se> {
         T: serde::ser::Serialize + ?Sized,
     {
         let prop_header_offset = self.dst.step_by_prop();
-        let old_value_type = self.value_type;
+        let prev_type = self.value_type;
+        let prev_name = self.current_name;
         self.current_dep += 1;
+        self.current_name = key;
         let matched_patch = self.patch_list.step_forward(key, self.current_dep);
 
         match matched_patch {
@@ -75,7 +79,8 @@ impl<'a, 'se> SerializeDynamicField<'se> for &'a mut Serializer<'se> {
             );
         }
 
-        self.value_type = old_value_type;
+        self.value_type = prev_type;
+        self.current_name = prev_name;
         self.dst.step_align();
         self.patch_list.step_back(self.current_dep);
         self.current_dep -= 1;
@@ -373,15 +378,15 @@ impl<'a, 'se> serde::ser::Serializer for &'a mut Serializer<'se> {
 
     fn serialize_struct(
         self,
-        name: &'static str,
+        _name: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStruct, Self::Error> {
         self.dst.step_by_u32(FDT_BEGIN_NODE);
         if self.current_dep == 0 {
             // The name of root node should be empty.
             self.dst.step_by_u32(0);
         } else {
-            self.dst.step_by_name(name);
+            self.dst.step_by_name(self.current_name);
         }
         self.value_type = ValueType::Node;
         Ok(self)
@@ -401,7 +406,7 @@ impl<'a, 'se> serde::ser::Serializer for &'a mut Serializer<'se> {
 #[cfg(test)]
 mod tests {
     use serde_derive::Serialize;
-    const MAX_SIZE: usize = 256;
+    const MAX_SIZE: usize = 256 + 32;
     #[test]
     fn base_ser_test() {
         #[derive(Serialize)]