Implement free for vtpm-td

Signed-off-by: Min Xu <min.m.xu@intel.com>

Author: mxu9

Cargo.lock

@@ -17,6 +17,8 @@ function clean() {
     pushd tpm
     make clean
     popd
+
+    cargo clean
 }
 
 function build() {

deps/rust-tpm-20-ref/sh_script/build.sh

@@ -4,6 +4,7 @@
 
 // TBD:
 extern void *__fw_malloc(size_t n);
+extern void __fw_free(void *p);
 extern uint32_t __fw_rdrand32(void);
 
 void *malloc(size_t n)
@@ -13,7 +14,7 @@ void *malloc(size_t n)
 
 void free(void *p)
 {
-    return;
+    __fw_free(p);
 }
 
 void *realloc(void *p, size_t n)

deps/rust-tpm-20-ref/smallc/src/stdlib/__need_impl_stdlib.c

@@ -1,47 +1,12 @@
+// Copyright (c) 2022 - 2023 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
 #![no_std]
 #![feature(naked_functions)]
 
 extern crate alloc;
 use core::arch::asm;
-#[no_mangle]
-pub extern "C" fn __fw_debug_msg(msg: *const u8, len: usize) {
-    let msg = unsafe {
-        let r = core::slice::from_raw_parts(msg, len);
-        core::str::from_utf8_unchecked(r)
-    };
-    log::info!("{}", msg);
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_debug_buffer(buffer: *const u8, len: usize) {
-    let buf = unsafe { core::slice::from_raw_parts(buffer, len) };
-    log::info!("buffer {:x?}\n", buf);
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_abort() {
-    panic!("abort called");
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_rdrand32() -> u32 {
-    unsafe {
-        let mut ret: u32 = 0;
-        for _ in 0..10 {
-            if core::arch::x86_64::_rdrand32_step(&mut ret) == 1 {
-                return ret;
-            }
-        }
-        panic!("Failed to obtain random data");
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn __fw_malloc(s: usize) -> *mut u8 {
-    use alloc::alloc::Layout;
-    alloc::alloc::alloc(Layout::from_size_align(s, 1).unwrap())
-}
-
 #[naked]
 #[no_mangle]
 pub unsafe extern "C" fn ___chkstk_ms() {

deps/rust-tpm-20-ref/src/lib.rs

@@ -9,3 +9,8 @@ edition = "2021"
 global = { path = "../global" }
 log = "0.4.13"
 rust-tpm-20-ref = { path = "../../deps/rust-tpm-20-ref" }
+spin = "0.9.2"
+
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]

src/tpm/Cargo.toml

@@ -21,6 +21,7 @@ use self::tpm2_provision::tpm2_provision_ek;
 extern crate alloc;
 
 pub mod cty;
+pub mod std_lib;
 pub mod tpm2_cmd_rsp;
 pub mod tpm2_digests;
 pub mod tpm2_pcr;
@@ -130,42 +131,3 @@ pub fn terminate_tpm() {
     }
     GLOBAL_TPM_DATA.lock().set_tpm_active(false);
 }
-
-#[no_mangle]
-pub extern "C" fn __fw_debug_msg(msg: *const u8, len: usize) {
-    let msg = unsafe {
-        let r = core::slice::from_raw_parts(msg, len);
-        core::str::from_utf8_unchecked(r)
-    };
-    log::info!("{}", msg);
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_debug_buffer(buffer: *const u8, len: usize) {
-    let buf = unsafe { core::slice::from_raw_parts(buffer, len) };
-    log::info!("buffer {:x?}\n", buf);
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_abort() {
-    panic!("abort called");
-}
-
-#[no_mangle]
-pub extern "C" fn __fw_rdrand32() -> u32 {
-    unsafe {
-        let mut ret: u32 = 0;
-        for _ in 0..10 {
-            if core::arch::x86_64::_rdrand32_step(&mut ret) == 1 {
-                return ret;
-            }
-        }
-        panic!("Failed to obtain random data");
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn __fw_malloc(s: usize) -> *mut u8 {
-    use alloc::alloc::Layout;
-    alloc::alloc::alloc(Layout::from_size_align(s, 1).unwrap())
-}

src/tpm/src/lib.rs

@@ -0,0 +1,67 @@
+// Copyright (c) 2022 - 2023 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(not(test), no_std)]
+#![cfg_attr(test, allow(unused_imports))]
+#![feature(alloc_error_handler)]
+#![feature(naked_functions)]
+use alloc::collections::BTreeMap;
+use core::alloc::Layout;
+#[allow(unused, non_snake_case, non_upper_case_globals, non_camel_case_types)]
+use core::{ffi::c_void, ptr::null_mut};
+use lazy_static::lazy_static;
+use spin::Mutex;
+
+extern crate alloc;
+
+#[no_mangle]
+pub extern "C" fn __fw_debug_msg(msg: *const u8, len: usize) {
+    let msg = unsafe {
+        let r = core::slice::from_raw_parts(msg, len);
+        core::str::from_utf8_unchecked(r)
+    };
+    log::info!("{}", msg);
+}
+
+#[no_mangle]
+pub extern "C" fn __fw_debug_buffer(buffer: *const u8, len: usize) {
+    let buf = unsafe { core::slice::from_raw_parts(buffer, len) };
+    log::info!("buffer {:x?}\n", buf);
+}
+
+#[no_mangle]
+pub extern "C" fn __fw_abort() {
+    panic!("abort called");
+}
+
+#[no_mangle]
+pub extern "C" fn __fw_rdrand32() -> u32 {
+    unsafe {
+        let mut ret: u32 = 0;
+        for _ in 0..10 {
+            if core::arch::x86_64::_rdrand32_step(&mut ret) == 1 {
+                return ret;
+            }
+        }
+        panic!("Failed to obtain random data");
+    }
+}
+
+lazy_static! {
+    static ref MALLOC_TABLE: Mutex<BTreeMap<usize, usize>> = Mutex::new(BTreeMap::new());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn __fw_malloc(size: usize) -> *mut c_void {
+    let addr = alloc::alloc::alloc(Layout::from_size_align_unchecked(size, 1)) as *mut c_void;
+    MALLOC_TABLE.lock().insert(addr as usize, size);
+    addr
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn __fw_free(ptr: *mut c_void) {
+    if let Some(size) = MALLOC_TABLE.lock().get(&(ptr as usize)) {
+        alloc::alloc::dealloc(ptr as *mut u8, Layout::from_size_align_unchecked(*size, 1))
+    }
+}