examples: enable message-passing-interface-rs example for no-std and promote it to a common example (#254)

Author: asir66

examples/Makefile

@@ -28,7 +28,6 @@ FEATURES ?=
 # Define example categories based on std/no-std support
 # STD-only examples (require STD=y to build)
 STD_ONLY_EXAMPLES = \
-	message_passing_interface-rs \
 	tls_client-rs \
 	tls_server-rs \
 	secure_db_abstraction-rs
@@ -50,6 +49,7 @@ COMMON_EXAMPLES = \
 	hello_world-rs \
 	hotp-rs \
 	inter_ta-rs \
+	message_passing_interface-rs \
 	property-rs \
 	random-rs \
 	secure_storage-rs \

examples/message_passing_interface-rs/host/Cargo.toml

@@ -30,6 +30,7 @@ edition = "2018"
 url = "=2.5.0"
 proto = { path = "../proto" }
 optee-teec = { path = "../../../optee-teec" }
+serde_json = "1.0"
 
 [profile.release]
 lto = true

examples/message_passing_interface-rs/host/Makefile

@@ -38,4 +38,3 @@ strip: host
 
 clean:
 	@cargo clean
-

examples/message_passing_interface-rs/host/src/main.rs

@@ -15,9 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use optee_teec::{
-    Context, ErrorKind, Operation, ParamNone, ParamTmpRef, ParamType, ParamValue, Uuid,
-};
+use optee_teec::{Context, ErrorKind, Operation, ParamNone, ParamTmpRef, Uuid};
 
 type Result<T> = optee_teec::Result<T>;
 
@@ -53,24 +51,23 @@ impl EnclaveClient {
 
     pub fn invoke(&mut self, input: &proto::EnclaveInput) -> Result<proto::EnclaveOutput> {
         let command_id = input.command as u32;
-        let mut serialized_input = proto::serde_json::to_vec(input).map_err(|e| {
+        let mut serialized_input = serde_json::to_vec(input).map_err(|e| {
             eprintln!("Failed to serialize input: {}", e);
             ErrorKind::BadParameters
         })?;
 
         let p0 = ParamTmpRef::new_input(serialized_input.as_mut_slice());
         let p1 = ParamTmpRef::new_output(&mut self.buffer);
-        let p2 = ParamValue::new(0, 0, ParamType::ValueInout);
 
-        let mut operation = Operation::new(0, p0, p1, p2, ParamNone);
+        let mut operation = Operation::new(0, p0, p1, ParamNone, ParamNone);
 
         let uuid = Uuid::parse_str(&self.uuid)?;
         let mut session = self.context.open_session(uuid)?;
         session.invoke_command(command_id, &mut operation)?;
-        let len = operation.parameters().2.a() as usize;
+        let len = operation.parameters().1.updated_size();
 
-        let output: proto::EnclaveOutput = proto::serde_json::from_slice(&self.buffer[0..len])
-            .map_err(|e| {
+        let output: proto::EnclaveOutput =
+            serde_json::from_slice(&self.buffer[0..len]).map_err(|e| {
                 eprintln!("Failed to deserialize output: {}", e);
                 ErrorKind::BadParameters
             })?;

examples/message_passing_interface-rs/proto/Cargo.toml

@@ -26,5 +26,4 @@ edition = "2018"
 
 [dependencies]
 num_enum = { version = "0.7.3", default-features = false }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde = { version = "1.0", default-features = false, features = ["derive"] }

examples/message_passing_interface-rs/proto/src/lib.rs

@@ -15,9 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#![no_std]
+
+extern crate alloc;
+
+use alloc::string::String;
 use num_enum::FromPrimitive;
 use serde::{Serialize, Deserialize};
-pub use serde_json;
 
 #[derive(Serialize, Deserialize, FromPrimitive, Debug, Copy, Clone)]
 #[repr(u32)]

examples/message_passing_interface-rs/ta/Cargo.lock

@@ -24,16 +24,21 @@ repository = "https://github.com/apache/teaclave-trustzone-sdk.git"
 description = "An example of Rust OP-TEE TrustZone SDK."
 edition = "2018"
 
+[features]
+default = []
+std = ["optee-utee/std", "optee-utee-sys/std"]
+
 [dependencies]
 proto = { path = "../proto" }
-optee-utee-sys = { path = "../../../optee-utee/optee-utee-sys", features = ["std"] }
-optee-utee = { path = "../../../optee-utee", features = ["std"] }
+optee-utee-sys = { path = "../../../optee-utee/optee-utee-sys" }
+optee-utee = { path = "../../../optee-utee" }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 
 [build-dependencies]
 proto = { path = "../proto" }
 optee-utee-build = { path = "../../../optee-utee-build" }
 
 [profile.release]
 panic = "abort"
-lto = false
+lto = true
 opt-level = 1

examples/message_passing_interface-rs/ta/Cargo.toml

@@ -15,28 +15,38 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# STD-ONLY example
-
 UUID ?= $(shell cat "../uuid.txt")
 
-TARGET ?= aarch64-unknown-optee
+TARGET ?= aarch64-unknown-linux-gnu
 CROSS_COMPILE ?= aarch64-linux-gnu-
 OBJCOPY := $(CROSS_COMPILE)objcopy
 # Configure the linker to use GCC, which works on both cross-compilation and ARM machines
 LINKER_CFG := target.$(TARGET).linker=\"$(CROSS_COMPILE)gcc\"
 
+# fix for the error: "unwinding panics are not supported without std" reported by clippy
+# Set panic=abort for std and no-std
+RUSTFLAGS := -C panic=abort
+ifeq ($(BUILDER),xargo)
+EXTRA_FLAGS =
+else
+EXTRA_FLAGS = -Z build-std=core,alloc -Z build-std-features=panic_immediate_abort
+endif
+
 TA_SIGN_KEY ?= $(TA_DEV_KIT_DIR)/keys/default_ta.pem
 SIGN := $(TA_DEV_KIT_DIR)/scripts/sign_encrypt.py
 OUT_DIR := $(CURDIR)/target/$(TARGET)/release
 
+BUILDER ?= cargo
+FEATURES ?= 
+
 all: clippy ta strip sign
 
 clippy:
 	@cargo fmt
-	@xargo clippy --target $(TARGET) -- -D warnings -D clippy::unwrap_used -D clippy::expect_used -D clippy::panic
+	@RUSTFLAGS="$(RUSTFLAGS)" $(BUILDER) clippy --target $(TARGET) $(EXTRA_FLAGS) $(FEATURES) -- -D warnings -D clippy::unwrap_used -D clippy::expect_used -D clippy::panic
 
 ta: clippy
-	@xargo build --target $(TARGET) --release --config $(LINKER_CFG)
+	@RUSTFLAGS="$(RUSTFLAGS)" $(BUILDER) build --target $(TARGET) --release $(FEATURES) --config $(LINKER_CFG) $(EXTRA_FLAGS)
 
 strip: ta
 	@$(OBJCOPY) --strip-unneeded $(OUT_DIR)/ta $(OUT_DIR)/stripped_ta

examples/message_passing_interface-rs/ta/Makefile

@@ -15,14 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#![cfg_attr(not(feature = "std"), no_std)]
 #![no_main]
 
+extern crate alloc;
+
+use alloc::format;
 use optee_utee::{
     ta_close_session, ta_create, ta_destroy, ta_invoke_command, ta_open_session, trace_println,
 };
 use optee_utee::{ErrorKind, Parameters, Result};
 use proto::{self, Command};
-use std::io::Write;
 
 fn handle_invoke(command: Command, input: proto::EnclaveInput) -> Result<proto::EnclaveOutput> {
     match command {
@@ -69,23 +72,26 @@ fn invoke_command(cmd_id: u32, params: &mut Parameters) -> Result<()> {
     trace_println!("[+] TA invoke command");
     let mut p0 = unsafe { params.0.as_memref()? };
     let mut p1 = unsafe { params.1.as_memref()? };
-    let mut p2 = unsafe { params.2.as_value()? };
 
-    let input: proto::EnclaveInput = proto::serde_json::from_slice(p0.buffer()).map_err(|e| {
+    let input: proto::EnclaveInput = serde_json::from_slice(p0.buffer()).map_err(|e| {
         trace_println!("Failed to deserialize input: {}", e);
         ErrorKind::BadFormat
     })?;
     let output = handle_invoke(Command::from(cmd_id), input)?;
 
-    let output_vec = proto::serde_json::to_vec(&output).map_err(|e| {
+    let output_vec = serde_json::to_vec(&output).map_err(|e| {
         trace_println!("Failed to serialize output: {}", e);
         ErrorKind::BadFormat
     })?;
-    p1.buffer().write_all(&output_vec).map_err(|e| {
-        trace_println!("Failed to write output: {}", e);
-        ErrorKind::BadParameters
-    })?;
-    p2.set_a(output_vec.len() as u32);
+
+    let len = output_vec.len();
+    if len > p1.buffer().len() {
+        trace_println!("Buffer too small, cannot copy all bytes");
+        return Err(ErrorKind::BadParameters.into());
+    }
+
+    p1.buffer()[..len].copy_from_slice(&output_vec);
+    p1.set_updated_size(len);
 
     Ok(())
 }