tests/test-td-payload: Run TDX hardware specific unit test cases inside a VM

Signed-off-by: Wei Liu <wei3.liu@intel.com>

Signed-off-by: haowei <WeiX.Hao@intel.com>

Author: haowqs

tests/test-td-payload/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "test-td-payload"
+version = "0.1.0"
+description = "Run TDX hardware specific unit test cases inside a VM"
+repository = "https://github.com/confidential-containers/td-shim"
+homepage = "https://github.com/confidential-containers"
+license = "BSD-2-Clause-Patent"
+edition = "2018"
+
+[dependencies]
+spin = "0.9.2"
+r-efi = "3.2.0"
+linked_list_allocator = "0.9.0"
+log = "0.4.13"
+td-uefi-pi =  { path = "../../td-uefi-pi" }
+tdx-tdcall = { path = "../../tdx-tdcall" , optional = true }
+td-logger =  { path = "../../td-logger" }
+td-exception =  { path = "../../td-exception" }
+td-layout = { path = "../../td-layout" }
+scroll = { version = "0.10.0", default-features = false, features = ["derive"]}
+serde = { version = "1.0", default-features = false, features = ["derive"]}
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]
+
+[package.metadata.bootloader]
+map-physical-memory = true
+
+[features]
+cet-ss = []
+tdx = ["tdx-tdcall", "td-logger/tdx"]
+main = []

tests/test-td-payload/src/lib.rs

@@ -0,0 +1,60 @@
+// Copyright (c) 2021 Intel Corporation
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+
+#![no_std]
+extern crate alloc;
+
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+pub enum TestResult {
+    Pass,
+    Fail,
+    None,
+}
+
+pub trait TestCase {
+    fn setup(&mut self);
+    fn run(&mut self);
+    fn teardown(&mut self);
+    fn get_name(&mut self) -> String;
+    fn get_result(&mut self) -> TestResult;
+}
+
+pub struct TestSuite {
+    pub testsuite: Vec<Box<dyn TestCase>>,
+    pub passed_cases: u32,
+    pub failed_cases: u32,
+}
+
+impl TestSuite {
+    pub fn run(&mut self) {
+        for tc in self.testsuite.iter_mut() {
+            log::info!("[Test: {}]\n", String::from(tc.get_name()));
+            tc.setup();
+            tc.run();
+            tc.teardown();
+
+            let res = tc.get_result();
+            match res {
+                TestResult::Pass => {
+                    self.passed_cases += 1;
+                    log::info!("[Test: {0}] - Pass\n", tc.get_name());
+                }
+                TestResult::Fail => {
+                    self.failed_cases += 1;
+                    log::info!("[Test: {0}] - Fail\n", tc.get_name());
+                }
+                TestResult::None => {
+                    log::info!("[Test: {0}] - Skip\n", tc.get_name());
+                }
+            }
+
+            log::info!("---------------------------------------------\n")
+        }
+    }
+}

tests/test-td-payload/src/main.rs

@@ -0,0 +1,177 @@
+// Copyright (c) 2021 Intel Corporation
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+
+#![no_std]
+#![no_main]
+#![allow(unused)]
+#![feature(alloc_error_handler)]
+#[macro_use]
+
+mod lib;
+mod testiorw32;
+mod testiorw8;
+mod testtdinfo;
+mod testtdreport;
+
+extern crate alloc;
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use core::ffi::c_void;
+use core::panic::PanicInfo;
+use linked_list_allocator::LockedHeap;
+use td_layout::memslice;
+
+use crate::lib::{TestResult, TestSuite};
+use crate::testiorw32::Tdiorw32;
+use crate::testiorw8::Tdiorw8;
+use crate::testtdinfo::Tdinfo;
+use crate::testtdreport::Tdreport;
+
+use r_efi::efi::Guid;
+use serde::{Deserialize, Serialize};
+use serde_json::{Result, Value};
+use td_uefi_pi::{fv, hob, pi};
+
+#[derive(Debug, Serialize, Deserialize)]
+// The test cases' data structure corresponds to the test config json data structure
+pub struct TestCases {
+    pub tcs001: Tdinfo,
+    pub tcs002: Tdinfo,
+    pub tcs003: Tdinfo,
+    pub tcs004: Tdreport,
+    pub tcs005: Tdiorw8,
+    pub tcs006: Tdiorw32,
+}
+
+pub const CFV_FFS_HEADER_TEST_CONFIG_GUID: Guid = Guid::from_fields(
+    0xf10e684e,
+    0x3abd,
+    0x20e4,
+    0x59,
+    0x32,
+    &[0x8f, 0x97, 0x3c, 0x35, 0x5e, 0x57],
+); // {F10E684E-3ABD-20E4-5932-8F973C355E57}
+
+#[cfg(not(test))]
+#[panic_handler]
+#[allow(clippy::empty_loop)]
+fn panic(_info: &PanicInfo) -> ! {
+    log::info!("panic ... {:?}\n", _info);
+    loop {}
+}
+
+#[alloc_error_handler]
+#[allow(clippy::empty_loop)]
+fn alloc_error(_info: core::alloc::Layout) -> ! {
+    log::info!("alloc_error ... {:?}\n", _info);
+    panic!("deadloop");
+}
+
+#[cfg(not(test))]
+#[global_allocator]
+static ALLOCATOR: LockedHeap = LockedHeap::empty();
+
+#[cfg(not(test))]
+fn init_heap(heap_start: usize, heap_size: usize) {
+    unsafe {
+        ALLOCATOR.lock().init(heap_start, heap_size);
+    }
+}
+
+#[cfg(not(test))]
+fn build_testcases() -> TestCases {
+    log::info!("Starting get test data from cfv and parse json data\n");
+    let cfv = memslice::get_mem_slice(memslice::SliceType::Config);
+    let json_data = fv::get_file_from_fv(
+        cfv,
+        pi::fv::FV_FILETYPE_RAW,
+        CFV_FFS_HEADER_TEST_CONFIG_GUID,
+    )
+    .unwrap();
+    let json_string = String::from_utf8_lossy(json_data).to_string();
+    // trim zero in json string
+    let json_config = json_string.trim_matches(char::from(0));
+
+    serde_json::from_str(json_config).unwrap()
+}
+
+#[cfg(not(test))]
+#[no_mangle]
+#[cfg_attr(target_os = "uefi", export_name = "efi_main")]
+extern "win64" fn _start(hob: *const c_void) -> ! {
+    use td_layout::runtime::*;
+
+    td_logger::init();
+    log::info!("Starting rust-tdcall-payload hob - {:p}\n", hob);
+
+    // init heap so that we can allocate memory
+    let hob_buffer = unsafe {
+        memslice::get_dynamic_mem_slice_mut(memslice::SliceType::PayloadHob, hob as usize)
+    };
+
+    let hob_size = hob::get_hob_total_size(hob_buffer).unwrap();
+    let hob_list = &hob_buffer[..hob_size];
+
+    init_heap(
+        (hob::get_system_memory_size_below_4gb(hob_list).unwrap() as usize
+            - (TD_PAYLOAD_HOB_SIZE
+                + TD_PAYLOAD_STACK_SIZE
+                + TD_PAYLOAD_SHADOW_STACK_SIZE
+                + TD_PAYLOAD_ACPI_SIZE
+                + TD_PAYLOAD_EVENT_LOG_SIZE) as usize
+            - TD_PAYLOAD_HEAP_SIZE as usize),
+        TD_PAYLOAD_HEAP_SIZE as usize,
+    );
+
+    // create TestSuite to hold the test cases
+    let mut ts = TestSuite {
+        testsuite: Vec::new(),
+        passed_cases: 0,
+        failed_cases: 0,
+    };
+
+    // build test cases with test configuration data in CFV
+    let tcs = build_testcases();
+
+    // Add test cases in ts.testsuite
+    if tcs.tcs001.run {
+        ts.testsuite.push(Box::new(tcs.tcs001));
+    }
+
+    if tcs.tcs002.run {
+        ts.testsuite.push(Box::new(tcs.tcs002));
+    }
+
+    if tcs.tcs003.run {
+        ts.testsuite.push(Box::new(tcs.tcs003));
+    }
+
+    if tcs.tcs004.run {
+        ts.testsuite.push(Box::new(tcs.tcs004));
+    }
+
+    if tcs.tcs005.run {
+        ts.testsuite.push(Box::new(tcs.tcs005));
+    }
+
+    if tcs.tcs006.run {
+        ts.testsuite.push(Box::new(tcs.tcs006));
+    }
+
+    // run the TestSuite which contains the test cases
+    log::info!("---------------------------------------------\n");
+    log::info!("Start to run tests.\n");
+    log::info!("---------------------------------------------\n");
+    ts.run();
+    log::info!(
+        "Test Result: Total run {0} tests; {1} passed; {2} failed\n",
+        ts.testsuite.len(),
+        ts.passed_cases,
+        ts.failed_cases
+    );
+
+    panic!("deadloop");
+}

tests/test-td-payload/src/test.json

@@ -0,0 +1,62 @@
+{	    
+    "tcs001": {
+        "name": "tdinfo001",
+        "expected": {
+            "gpaw": 52,
+            "attributes": 0,
+            "max_vcpus": 1,
+            "num_vcpus": 1,
+            "rsvd": [0,0,0]
+        },
+        "result": "None",
+        "run": true  
+    },
+    "tcs002": {
+        "name": "tdinfo002",
+        "expected": {
+            "gpaw": 52,
+            "attributes": 0,
+            "max_vcpus": 8,
+            "num_vcpus": 8,
+            "rsvd": [0,0,0]
+        },
+        "result": "None",
+        "run": false  
+    },  
+    "tcs003": {
+        "name": "tdinfo003",
+        "expected": {
+            "gpaw": 48,
+            "attributes": 0,
+            "max_vcpus": 1,
+            "num_vcpus": 1,
+            "rsvd": [0,0,0]
+        },
+        "result": "None",
+        "run": false 
+    },
+    "tcs004": {
+        "name": "tdreport001",
+        "input": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        "expected": {
+            "type": 129,
+            "subtype": 0,
+            "version": 0
+        },     
+        "result": "None",
+        "run": true 
+    },
+    "tcs005": {
+        "name": "testiorw8",     
+        "result": "None",
+        "run": true 
+    },
+    "tcs006": {
+        "name": "testiorw32",     
+        "result": "None",
+        "run": true 
+    }
+}