Change CPUThreads struct to use abomonation for serialization instead of serde

Author: hunhoffe

Cargo.lock

@@ -53,21 +53,23 @@ gdbstub = { git = "https://github.com/daniel5151/gdbstub.git", branch = "dev/0.6
 gdbstub_arch = { git = "https://github.com/daniel5151/gdbstub.git", branch = "dev/0.6" }
 # Optional external libraries:
 addr2line = { version = "0.16", default-features = false, features = ["rustc-demangle"], optional = true }
-abomonation = { git="https://github.com/hunhoffe/abomonation.git", branch="no-std", default-features = false, optional = true }
-core2 = { version = "0.3", default-features = false, features = [ "alloc" ], optional = true }
 smoltcp = { version = "0.8.0", default-features = false, features = [ "alloc", "log", "proto-ipv4", "proto-igmp", "proto-dhcpv4", "socket-raw", "socket-icmp", "socket-udp", "socket-tcp" ], optional = true }
 
 [[bin]]
 name = "nrk"
 path = "src/main.rs"
 
 [target.'cfg(target_os = "none")'.dependencies]
+abomonation = { git="https://github.com/hunhoffe/abomonation.git", branch="no-std", default-features = false, optional = true }
+core2 = { version = "0.3", default-features = false, features = [ "alloc" ], optional = true }
 serde = { version = "1", default-features = false, features = ["alloc", "derive"], optional = true }
 serde_cbor = { version = "0.11", default-features = false, optional = true }
 
 [target.'cfg(not(target_os = "none"))'.dependencies]
 libc = { version = "0.2.53", default-features = false }
 csv = "1.1"
+abomonation = { git="https://github.com/hunhoffe/abomonation.git", branch="no-std", default-features = false, optional = true }
+core2 = { version = "0.3", default-features = false, features = [ "alloc" ], optional = true }
 serde = { version = "1" }
 serde_cbor = { version = "0.11" }
 rand = { version = "0.8", features = ["small_rng"] }
@@ -86,7 +88,7 @@ testutils = { path = "testutils" }
 cc = "1.0"
 
 [features]
-default = ["addr2line", "serde", "serde_cbor"]
+default = ["addr2line", "serde", "serde_cbor", "core2", "abomonation"]
 # Enable Ethernet based networking.
 ethernet = ["smoltcp"]
 # Enable shared memory based communication.
@@ -95,7 +97,7 @@ shmem = []
 # kernels that communicate with the control-plane for coarse-grained policy
 # decisions. Use in combination with `shmem` or `ethernet` feature to control
 # transport.
-rackscale = ["core2", "abomonation", "rpc"]
+rackscale = ["rpc"]
 # server code (supply --kgdb to run.py).
 gdb = []
 

kernel/Cargo.toml

@@ -5,6 +5,7 @@ use alloc::boxed::Box;
 use alloc::vec::Vec;
 use core::convert::TryInto;
 
+use abomonation::encode;
 use fallible_collections::{FallibleVec, FallibleVecGlobal};
 use log::{debug, info, trace, warn};
 use x86::bits64::paging::{PAddr, VAddr, BASE_PAGE_SIZE, LARGE_PAGE_SIZE};
@@ -80,8 +81,14 @@ impl<T: Arch86SystemDispatch> SystemDispatch<u64> for T {
             })?;
         }
 
-        // TODO(dependency): Get rid of serde/serde_cbor, use something sane instead
-        let serialized = serde_cbor::to_vec(&return_threads).unwrap();
+        // We know that we will need room for at least all of the hw threads. abomonation
+        // may increase size as needed.
+        let mut serialized =
+            Vec::try_with_capacity(num_threads * core::mem::size_of::<kpi::system::CpuThread>())
+                .expect("Failed to allocate memory for serialized data");
+        unsafe { encode(&return_threads, &mut serialized) }
+            .expect("Failed to serialize hw_threads");
+
         if serialized.len() <= vaddr_buf_len as usize {
             let mut user_slice = UserSlice::new(
                 current_pid()?,

kernel/src/arch/x86_64/syscall.rs

@@ -9,6 +9,7 @@ license = "MIT OR Apache-2.0"
 x86 = { version = "0.52", features = ["unstable"] }
 abomonation = { git="https://github.com/hunhoffe/abomonation.git", branch="no-std", default-features = false }
 bitflags = "1.2"
+core2 = { version = "0.3", default-features = false, features = [ "alloc" ] }
 serde = { version = "1.0", default-features = false, features = ["derive", "alloc"] }
 serde_cbor = { version = "0.11", default-features = false, features = ["alloc"] }
 log = "0.4"

lib/kpi/Cargo.toml

@@ -44,6 +44,8 @@ impl CoreToken {
     }
 }
 
+// TODO: still use serde instead of abomonation because abomonation doesn't
+// know how to handle 'static string.
 #[derive(Serialize, Deserialize, Debug, Default, Copy, Clone, Eq, PartialEq)]
 pub struct ProcessInfo {
     pub has_tls: bool,

lib/kpi/src/process.rs

@@ -6,6 +6,8 @@
 
 use alloc::vec::Vec;
 
+use abomonation::decode;
+
 use crate::{syscall, *};
 
 use crate::system::{CoreId, CpuThread};
@@ -30,8 +32,18 @@ impl System {
             let len = len as usize;
             debug_assert!(len <= buf.len());
             buf.resize(len, 0);
-            let deserialized: Vec<CpuThread> = serde_cbor::from_slice(&buf).unwrap();
-            Ok(deserialized)
+            if let Some((deserialized, remaining)) =
+                unsafe { decode::<Vec<CpuThread>>(&mut buf[..len]) }
+            {
+                if remaining.len() > 0 {
+                    Err(SystemCallError::InternalError)
+                } else {
+                    // This does perform a copy, which is less than ideal.
+                    Ok(deserialized.to_vec())
+                }
+            } else {
+                Err(SystemCallError::InternalError)
+            }
         } else {
             Err(SystemCallError::from(r))
         }

lib/kpi/src/syscalls/system.rs

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 //! Data structures to exchange system-wide information between kernel and user-space.
-
-use serde::{Deserialize, Serialize};
+use abomonation::{unsafe_abomonate, Abomonation};
+use core2::io::Result as IOResult;
+use core2::io::Write;
 
 /// A system global ID for a CPU hardware thread.
 pub type GlobalThreadId = usize;
@@ -20,7 +21,7 @@ pub type PackageId = usize;
 /// Affinity region, a NUMA node (consists of a bunch of threads/core/packages and memory regions).
 pub type NodeId = usize;
 
-#[derive(Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq, Debug)]
+#[derive(Ord, PartialOrd, Eq, PartialEq, Debug, Copy, Clone)]
 pub struct CpuThread {
     /// ID the thread, global within a system.
     pub id: GlobalThreadId,
@@ -33,3 +34,4 @@ pub struct CpuThread {
     /// ID of the thread (relative to the core (usually either 0 or 1)).
     pub thread_id: ThreadId,
 }
+unsafe_abomonate!(CpuThread: id, node_id, package_id, core_id, thread_id);