optee_teec: extension: fix macro errors

* Fix usage of Rust types as return values in FFI functions.
* Standardize the function signature to require returning a Result.
* Use inner functions in generated code to prevent unexpected early returns.
* Fix example: supp_plugin-rs.

Author: ivila

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

@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use optee_teec::{Context, Operation, ParamTmpRef, Session, Uuid};
-use optee_teec::{ParamNone};
-use proto::{TA_UUID, Command};
+use optee_teec::{Context, ErrorKind, Operation, ParamNone, ParamTmpRef, Session, Uuid};
+use proto::{Command, TA_UUID};
 
 fn ping_ta(session: &mut Session) -> optee_teec::Result<()> {
     let test_data = [0x36u8; 10];
@@ -34,7 +33,10 @@ fn ping_ta(session: &mut Session) -> optee_teec::Result<()> {
 
 fn main() -> optee_teec::Result<()> {
     let mut ctx = Context::new()?;
-    let uuid = Uuid::parse_str(TA_UUID).unwrap();
+    let uuid = Uuid::parse_str(TA_UUID).map_err(|err| {
+        println!("Invalid TA_UUID: {:?}", err);
+        ErrorKind::BadParameters
+    })?;
     let mut session = ctx.open_session(uuid)?;
 
     ping_ta(&mut session)?;

examples/supp_plugin-rs/plugin/Cargo.toml

@@ -28,9 +28,8 @@ edition = "2018"
 libc = "0.2.48"
 proto = { path = "../proto" }
 optee-teec = { path = "../../../optee-teec" }
-optee-teec-sys = { path = "../../../optee-teec/optee-teec-sys" }
 
-[build_dependencies]
+[build-dependencies]
 uuid = { version = "0.8" }
 proto = { path = "../proto" }
 

examples/supp_plugin-rs/plugin/build.rs

@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use proto;
 use std::env;
 use std::fs::File;
 use std::io::Write;
-use std::path::{PathBuf};
+use std::path::PathBuf;
 use uuid::Uuid;
 
 fn main() -> std::io::Result<()> {
@@ -33,7 +32,7 @@ fn main() -> std::io::Result<()> {
     write!(buffer, "\n")?;
     write!(
         buffer,
-        "const PLUGIN_UUID_STRUCT: optee_teec_sys::TEEC_UUID = optee_teec_sys::TEEC_UUID {{
+        "const PLUGIN_UUID_STRUCT: optee_teec::optee_teec_sys::TEEC_UUID = optee_teec::optee_teec_sys::TEEC_UUID {{
     timeLow: {:#x},
     timeMid: {:#x},
     timeHiAndVersion: {:#x},

examples/supp_plugin-rs/plugin/plugin_static.rs

@@ -16,8 +16,8 @@
 // under the License.
 
 #[no_mangle]
-pub static mut plugin_method: PluginMethod = PluginMethod {
-    name: plugin_name.as_ptr() as *const c_char,
+pub static mut plugin_method: optee_teec::PluginMethod = optee_teec::PluginMethod {
+    name: plugin_name.as_ptr(),
     uuid: PLUGIN_UUID_STRUCT,
     init: _plugin_init,
     invoke: _plugin_invoke,

examples/supp_plugin-rs/plugin/src/lib.rs

@@ -15,30 +15,40 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use libc::{c_char};
-use optee_teec::{PluginMethod, PluginParameters};
-use optee_teec::{plugin_init, plugin_invoke};
-use proto::{PluginCommand};
+use optee_teec::{plugin_init, plugin_invoke, ErrorKind, PluginParameters};
+use proto::PluginCommand;
 
 #[plugin_init]
-fn init() {
-    println!("*plugin*: init");
+fn init() -> optee_teec::Result<()> {
+    println!("*plugin*: init, version: {}", env!("CARGO_PKG_VERSION"));
+    Ok(())
 }
 
 #[plugin_invoke]
-fn invoke(params: &mut PluginParameters) {
+fn invoke(params: &mut PluginParameters) -> optee_teec::Result<()> {
     println!("*plugin*: invoke");
     match PluginCommand::from(params.cmd) {
         PluginCommand::Print => {
-            println!("*plugin*: receive value: {:?} length {:?}", params.inout, params.inout.len());
+            println!(
+                "*plugin*: receive value: {:?} length {:?}",
+                params.inout,
+                params.inout.len()
+            );
 
-            let send_slice: [u8;9] = [0x40;9];
+            let send_slice: [u8; 9] = [0x40; 9];
             params.set_buf_from_slice(&send_slice)?;
-            println!("*plugin*: send value: {:?} length {:?} to ta", send_slice, send_slice.len());
+            println!(
+                "*plugin*: send value: {:?} length {:?} to ta",
+                send_slice,
+                send_slice.len()
+            );
+            Ok(())
+        }
+        _ => {
+            println!("Unsupported plugin command: {:?}", params.cmd);
+            Err(ErrorKind::BadParameters.into())
         }
-        _ => println!("Unsupported plugin command: {:?}", params.cmd),
     }
 }
 
-
 include!(concat!(env!("OUT_DIR"), "/plugin_static.rs"));

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

@@ -27,7 +27,7 @@ pub enum Command {
 }
 
 // If Uuid::parse_str() returns an InvalidLength error, there may be an extra
-// newline in your uuid.txt file. You can remove it by running 
+// newline in your uuid.txt file. You can remove it by running
 // `truncate -s 36 ta_uuid.txt`.
 pub const TA_UUID: &str = &include_str!("../../ta_uuid.txt");
 
@@ -42,6 +42,6 @@ pub enum PluginCommand {
 
 pub const PLUGIN_SUBCMD_NULL: u32 = 0xFFFFFFFF;
 // If Uuid::parse_str() returns an InvalidLength error, there may be an extra
-// newline in your uuid.txt file. You can remove it by running 
+// newline in your uuid.txt file. You can remove it by running
 // `truncate -s 36 plugin_uuid.txt`.
 pub const PLUGIN_UUID: &str = &include_str!("../../plugin_uuid.txt");

examples/supp_plugin-rs/ta/build.rs

@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use proto;
-use optee_utee_build::{TaConfig, RustEdition, Error};
+use optee_utee_build::{Error, RustEdition, TaConfig};
 
 fn main() -> Result<(), Error> {
     let ta_config = TaConfig::new_default_with_cargo_env(proto::TA_UUID)?;

examples/supp_plugin-rs/ta/src/main.rs

@@ -20,11 +20,11 @@
 
 extern crate alloc;
 
+use optee_utee::LoadablePlugin;
 use optee_utee::{
     ta_close_session, ta_create, ta_destroy, ta_invoke_command, ta_open_session, trace_println,
 };
-use optee_utee::{Error, ErrorKind, Parameters, Result, Uuid};
-use optee_utee::{LoadablePlugin};
+use optee_utee::{ErrorKind, Parameters, Result, Uuid};
 use proto::{Command, PluginCommand, PLUGIN_SUBCMD_NULL, PLUGIN_UUID};
 
 #[ta_create]
@@ -52,26 +52,32 @@ fn destroy() {
 #[ta_invoke_command]
 fn invoke_command(cmd_id: u32, params: &mut Parameters) -> Result<()> {
     trace_println!("[+] TA invoke command");
-    let mut p0 = unsafe { params.0.as_memref().unwrap() };
+    let mut p0 = unsafe { params.0.as_memref()? };
     let inbuf = p0.buffer().to_vec();
-    trace_println!("[+] TA received value {:?} then send to plugin", p0.buffer());
-    let uuid = Uuid::parse_str(PLUGIN_UUID).unwrap();
+    trace_println!(
+        "[+] TA received value {:?} then send to plugin",
+        p0.buffer()
+    );
+    let uuid = Uuid::parse_str(PLUGIN_UUID).map_err(|err| {
+        trace_println!("Invalid PluginUuid: {:?}", err);
+        ErrorKind::BadParameters
+    })?;
 
     match Command::from(cmd_id) {
         Command::Ping => {
-            let mut plugin = LoadablePlugin::new(&uuid);
-            let outbuf = plugin.invoke(
-                PluginCommand::Print as u32, 
-                PLUGIN_SUBCMD_NULL, 
-                &inbuf
-            ).unwrap();
+            let plugin = LoadablePlugin::new(&uuid);
+            let outbuf = plugin.invoke(PluginCommand::Print as u32, PLUGIN_SUBCMD_NULL, &inbuf)?;
 
-            trace_println!("[+] TA received out value {:?} outlen {:?}", outbuf, outbuf.len());
+            trace_println!(
+                "[+] TA received out value {:?} outlen {:?}",
+                outbuf,
+                outbuf.len()
+            );
             trace_println!("[+] TA call invoke_supp_plugin finished");
 
             Ok(())
         }
-        _ => Err(Error::new(ErrorKind::BadParameters)),
+        _ => Err(ErrorKind::BadParameters.into()),
     }
 }
 

optee-teec/macros/Cargo.toml

@@ -28,8 +28,8 @@ edition = "2018"
 proc-macro = true
 
 [dependencies]
-quote = "0.6"
-syn = { version = "0.15", features = ["full"] }
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }
 
 # The newer versions of these crates require rustc 1.81, while our custom
 # patched STD version is 1.80, causing compatibility issues. To resolve this,

optee-teec/macros/src/lib.rs

@@ -20,7 +20,7 @@
 extern crate proc_macro;
 
 use proc_macro::TokenStream;
-use quote::quote;
+use quote::{quote, ToTokens};
 use syn::parse_macro_input;
 use syn::spanned::Spanned;
 
@@ -34,38 +34,57 @@ pub fn plugin_init(_args: TokenStream, input: TokenStream) -> TokenStream {
     let f = parse_macro_input!(input as syn::ItemFn);
     let f_vis = &f.vis;
     let f_block = &f.block;
-    let f_decl = &f.decl;
-    let f_inputs = &f_decl.inputs;
+    let f_sig = &f.sig;
+    let f_inputs = &f_sig.inputs;
 
     // check the function signature
-    let valid_signature = f.constness.is_none()
+    let valid_signature = f_sig.constness.is_none()
         && match f_vis {
             syn::Visibility::Inherited => true,
             _ => false,
         }
-        && f.abi.is_none()
+        && f_sig.abi.is_none()
         && f_inputs.len() == 0
-        && f.decl.generics.where_clause.is_none()
-        && f.decl.variadic.is_none();
+        && f_sig.generics.where_clause.is_none()
+        && f_sig.variadic.is_none()
+        && check_return_type(&f);
 
     if !valid_signature {
         return syn::parse::Error::new(
             f.span(),
-            "`#[plugin_init]` function must have signature `fn()`",
+            "`#[plugin_init]` function must have signature `fn() -> optee_teec::Result<()>`",
         )
         .to_compile_error()
         .into();
     }
 
     quote!(
         #[no_mangle]
-        pub fn _plugin_init() -> optee_teec::Result<()> {
-            #f_block
-            Ok(())
+        pub fn _plugin_init() -> optee_teec::optee_teec_sys::TEEC_Result {
+            fn inner() -> optee_teec::Result<()> {
+                #f_block
+            }
+            match inner() {
+                Ok(()) => optee_teec::optee_teec_sys::TEEC_SUCCESS,
+                Err(err) => err.raw_code(),
+            }
         }
     )
     .into()
+}
 
+// check if return_type of the function is `optee_teec::Result<()>`
+fn check_return_type(item_fn: &syn::ItemFn) -> bool {
+    if let syn::ReturnType::Type(_, return_type) = item_fn.sig.output.to_owned() {
+        if let syn::Type::Path(path) = return_type.as_ref() {
+            let expected_type = quote! { optee_teec::Result<()> };
+            let actual_type = path.path.to_token_stream();
+            if expected_type.to_string() == actual_type.to_string() {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 /// Attribute to declare the invoke function of a plugin
@@ -78,50 +97,62 @@ pub fn plugin_invoke(_args: TokenStream, input: TokenStream) -> TokenStream {
     let f = parse_macro_input!(input as syn::ItemFn);
     let f_vis = &f.vis;
     let f_block = &f.block;
-    let f_decl = &f.decl;
-    let f_inputs = &f_decl.inputs;
+    let f_sig = &f.sig;
+    let f_inputs = &f_sig.inputs;
 
     // check the function signature
-    let valid_signature = f.constness.is_none()
+    let valid_signature = f_sig.constness.is_none()
         && match f_vis {
             syn::Visibility::Inherited => true,
             _ => false,
         }
-        && f.abi.is_none()
+        && f_sig.abi.is_none()
         && f_inputs.len() == 1
-        && f.decl.generics.where_clause.is_none()
-        && f.decl.variadic.is_none();
+        && f_sig.generics.where_clause.is_none()
+        && f_sig.variadic.is_none()
+        && check_return_type(&f);
 
     if !valid_signature {
         return syn::parse::Error::new(
             f.span(),
-            "`#[plugin_invoke]` function must have signature `fn(params: &mut PluginParamters)`",
+            concat!(
+                "`#[plugin_invoke]` function must have signature",
+                " `fn(params: &mut PluginParameters) -> optee_teec::Result<()>`"
+            ),
         )
         .to_compile_error()
         .into();
     }
 
+    let params = f_inputs
+        .first()
+        .expect("we have already verified its len")
+        .into_token_stream();
+
     quote!(
         #[no_mangle]
         pub fn _plugin_invoke(
             cmd: u32,
             sub_cmd: u32,
-            data: *mut c_char,
+            data: *mut core::ffi::c_char,
             in_len: u32,
             out_len: *mut u32
-        ) -> optee_teec::Result<()> {
+        ) -> optee_teec::optee_teec_sys::TEEC_Result {
+            fn inner(#params) -> optee_teec::Result<()> {
+                #f_block
+            }
             let mut inbuf = unsafe { std::slice::from_raw_parts_mut(data, in_len as usize) };
-            let mut params = PluginParameters::new(cmd, sub_cmd, inbuf);
-            #f_block
+            let mut params = optee_teec::PluginParameters::new(cmd, sub_cmd, inbuf);
+            if let Err(err) = inner(&mut params) {
+                return err.raw_code();
+            };
             let outslice = params.get_out_slice();
             unsafe {
                 *out_len = outslice.len() as u32;
                 std::ptr::copy(outslice.as_ptr(), data, outslice.len());
-            }
-
-            Ok(())
+            };
+            return optee_teec::optee_teec_sys::TEEC_SUCCESS;
         }
     )
     .into()
-
 }