kata: rename kata-sdk-interface to sdk-interface

Rename the cate and functions to better identify things as
application-specific.

Change-Id: Ie4c888f6b0c0b66c2d4cfb6e0fb3b5b1e0b82c48
GitOrigin-RevId: 5ea9e1204023f717bbb63dcc0cf0579c1359e2da

apps/rust/fibonacci/Cargo.toml

@@ -34,6 +34,6 @@ crate-type = ["staticlib"]
 
 [dependencies]
 kata-os-common = { path = "../../system/components/kata-os-common", default-features = false }
-kata-sdk-interface = { path = "../../system/components/SDKRuntime/kata-sdk-interface" }
 libkata = { path = "../libkata" }
 log = "0.4"
+sdk-interface = { path = "../../system/components/SDKRuntime/sdk-interface" }

apps/rust/fibonacci/fibonacci.rs

@@ -17,7 +17,7 @@ extern crate alloc;
 extern crate libkata;
 use alloc::format;
 use kata_os_common::allocator;
-use kata_sdk_interface::kata_sdk_log;
+use sdk_interface::sdk_log;
 
 // How many Fibonacci numbers to write to the log.
 const LOG_FIBONACCI_LIMIT: u64 = 80;
@@ -48,7 +48,7 @@ impl Fibonacci {
     }
 
     pub fn log(&self, interrupt_count: ICount) {
-        let _ = kata_sdk_log(&format!(
+        let _ = sdk_log(&format!(
             "n == {}; f == {:x}; interrupt_count == {}; rdtime == {}; virt_sec ~= {:2}",
             self.n,
             self.f1,
@@ -100,7 +100,7 @@ pub fn main() {
         allocator::ALLOCATOR.init(HEAP.as_mut_ptr() as _, HEAP.len());
     }
 
-    let _ = kata_sdk_log("Fibonacci");
+    let _ = sdk_log("Fibonacci");
     let mut interrupt_count: ICount = 0;
     let mut fib = Fibonacci::new();
     loop {

apps/rust/hello/Cargo.toml

@@ -35,6 +35,6 @@ crate-type = ["staticlib"]
 [dependencies]
 cstr_core = { version = "0.2.3", default-features = false }
 kata-os-common = { path = "../../system/components/kata-os-common", default-features = false }
-kata-sdk-interface = { path = "../../system/components/SDKRuntime/kata-sdk-interface" }
 libkata = { path = "../libkata" }
 log = "0.4"
+sdk-interface = { path = "../../system/components/SDKRuntime/sdk-interface" }

apps/rust/hello/hello.rs

@@ -8,8 +8,8 @@
 
 extern crate libkata;
 use kata_os_common::logger::KataLogger;
-use kata_sdk_interface::*;
 use log::info;
+use sdk_interface::*;
 
 // Message output is sent through the kata-os-logger which calls logger_log
 // to deliver data to the console. Redict to the sdk.
@@ -17,7 +17,7 @@ use log::info;
 #[allow(unused_variables)]
 pub fn logger_log(_level: u8, msg: *const cstr_core::c_char) {
     if let Ok(str) = unsafe { cstr_core::CStr::from_ptr(msg) }.to_str() {
-        let _ = kata_sdk_log(str);
+        let _ = sdk_log(str);
     }
 }
 
@@ -28,9 +28,9 @@ pub fn main() {
     log::set_logger(&KATA_LOGGER).unwrap();
     log::set_max_level(log::LevelFilter::Trace);
 
-    match kata_sdk_ping() {
+    match sdk_ping() {
         Ok(_) => info!("ping!"),
-        Err(e) => info!("kata_sdk_ping failed: {:?}", e),
+        Err(e) => info!("sdk_ping failed: {:?}", e),
     }
     info!("I am a Rust app, hear me log!");
     info!("Done, wimper ...");

apps/rust/keyval/Cargo.toml

@@ -35,6 +35,6 @@ crate-type = ["staticlib"]
 [dependencies]
 cstr_core = { version = "0.2.3", default-features = false }
 kata-os-common = { path = "../../system/components/kata-os-common", default-features = false }
-kata-sdk-interface = { path = "../../system/components/SDKRuntime/kata-sdk-interface" }
 libkata = { path = "../libkata" }
 log = "0.4"
+sdk-interface = { path = "../../system/components/SDKRuntime/sdk-interface" }

apps/rust/keyval/keyval.rs

@@ -13,7 +13,7 @@ use alloc::string::String;
 use kata_os_common::allocator;
 use kata_os_common::logger::KataLogger;
 use kata_os_common::sel4_sys;
-use kata_sdk_interface::*;
+use sdk_interface::*;
 use SDKRuntimeError::*;
 
 // Message output is sent through the kata-os-logger which calls logger_log
@@ -46,30 +46,30 @@ pub fn main(_a0: u32, _a1: u32, _a2: u32, _a3: u32) {
 
     const KEY: &str = "foo";
     let mut keyval: KeyValueData = [0u8; KEY_VALUE_DATA_SIZE];
-    let _ = match kata_sdk_read_key(KEY, &mut keyval) {
+    let _ = match sdk_read_key(KEY, &mut keyval) {
-        Err(SDKReadKeyFailed) => kata_sdk_log("read(foo) failed as expected"),
+        Err(SDKReadKeyFailed) => sdk_log("read(foo) failed as expected"),
-        Err(e) => kata_sdk_log(&format!("read error {:?}", e)),
+        Err(e) => sdk_log(&format!("read error {:?}", e)),
-        Ok(kv) => kata_sdk_log(&format!("read returned {:?}", kv)),
+        Ok(kv) => sdk_log(&format!("read returned {:?}", kv)),
     };
     keyval
         .split_at_mut(3)
         .0
         .copy_from_slice(String::from("123").as_bytes());
-    let _ = match kata_sdk_write_key(KEY, &keyval) {
+    let _ = match sdk_write_key(KEY, &keyval) {
-        Ok(_) => kata_sdk_log("write ok"),
+        Ok(_) => sdk_log("write ok"),
-        Err(e) => kata_sdk_log(&format!("write error {:?}", e)),
+        Err(e) => sdk_log(&format!("write error {:?}", e)),
     };
-    let _ = match kata_sdk_read_key(KEY, &mut keyval) {
+    let _ = match sdk_read_key(KEY, &mut keyval) {
-        Err(SDKReadKeyFailed) => kata_sdk_log("read(foo) failed as expected"),
+        Err(SDKReadKeyFailed) => sdk_log("read(foo) failed as expected"),
-        Err(e) => kata_sdk_log(&format!("read failed: {:?}", e)),
+        Err(e) => sdk_log(&format!("read failed: {:?}", e)),
-        Ok(kv) => kata_sdk_log(&format!("read returned {:?}", kv)),
+        Ok(kv) => sdk_log(&format!("read returned {:?}", kv)),
     };
-    let _ = match kata_sdk_delete_key(KEY) {
+    let _ = match sdk_delete_key(KEY) {
-        Ok(_) => kata_sdk_log("delete ok"),
+        Ok(_) => sdk_log("delete ok"),
-        Err(e) => kata_sdk_log(&format!("delete error {:?}", e)),
+        Err(e) => sdk_log(&format!("delete error {:?}", e)),
     };
-    let _ = match kata_sdk_delete_key(KEY) {
+    let _ = match sdk_delete_key(KEY) {
-        Ok(_) => kata_sdk_log("delete ok (for missing key)"),
+        Ok(_) => sdk_log("delete ok (for missing key)"),
-        Err(e) => kata_sdk_log(&format!("delete error {:?}", e)),
+        Err(e) => sdk_log(&format!("delete error {:?}", e)),
     };
 }

apps/system/components/SDKRuntime/Cargo.toml

@@ -16,9 +16,10 @@
 
 members = [
     "kata-sdk-component",
-    "kata-sdk-interface",
     "kata-sdk-manager",
     "kata-sdk-runtime",
+
+    "sdk-interface",
 ]
 resolver = "2"
 

apps/system/components/SDKRuntime/kata-sdk-component/Cargo.toml

@@ -28,11 +28,11 @@ CONFIG_KERNEL_MCS = []
 cstr_core = { version = "0.2.3", default-features = false }
 kata-os-common = { path = "../../kata-os-common" }
 kata-memory-interface = { path = "../../MemoryManager/kata-memory-interface" }
-kata-sdk-interface = { path = "../kata-sdk-interface" }
 kata-sdk-manager = { path = "../kata-sdk-manager" }
 kata-sdk-runtime = { path = "../kata-sdk-runtime" }
 log = { version = "0.4", features = ["release_max_level_info"] }
 postcard = { version = "0.7", features = ["alloc"], default-features = false }
+sdk-interface = { path = "../sdk-interface" }
 static_assertions = "1.1"
 
 [lib]

apps/system/components/SDKRuntime/kata-sdk-component/src/run.rs

@@ -40,19 +40,20 @@ use kata_os_common::camkes::{seL4_CPath, Camkes};
 use kata_os_common::copyregion::CopyRegion;
 use kata_os_common::cspace_slot::CSpaceSlot;
 use kata_os_common::sel4_sys;
-use kata_sdk_interface::KeyValueData;
-use kata_sdk_interface::SDKAppId;
-use kata_sdk_interface::SDKError;
-use kata_sdk_interface::SDKReplyHeader;
-use kata_sdk_interface::SDKRuntimeError;
-use kata_sdk_interface::SDKRuntimeInterface;
-use kata_sdk_interface::SDKRuntimeRequest;
-use kata_sdk_interface::SDKRUNTIME_REQUEST_DATA_SIZE;
 use kata_sdk_manager::SDKManagerError;
 use kata_sdk_manager::SDKManagerInterface;
 use kata_sdk_runtime::KataSDKRuntime;
 use log::error;
 
+use sdk_interface::KeyValueData;
+use sdk_interface::SDKAppId;
+use sdk_interface::SDKError;
+use sdk_interface::SDKReplyHeader;
+use sdk_interface::SDKRuntimeError;
+use sdk_interface::SDKRuntimeInterface;
+use sdk_interface::SDKRuntimeRequest;
+use sdk_interface::SDKRUNTIME_REQUEST_DATA_SIZE;
+
 use sel4_sys::seL4_CNode_Delete;
 use sel4_sys::seL4_CPtr;
 use sel4_sys::seL4_CapRights;
@@ -181,7 +182,7 @@ pub unsafe extern "C" fn run() -> ! {
                 .as_mut()
                 .split_at_mut(SDKRUNTIME_REQUEST_DATA_SIZE);
             let request_slice = &*request_slice; // NB: immutable alias
-            match postcard::take_from_bytes::<kata_sdk_interface::SDKRequestHeader>(request_slice) {
+            match postcard::take_from_bytes::<sdk_interface::SDKRequestHeader>(request_slice) {
                 Ok((header, args_slice)) => {
                     let app_id = sdk_runtime_badge as SDKAppId; // XXX safe?
                     if let Err(status) = match header.request {
@@ -240,7 +241,7 @@ fn log_request(
     request_slice: &[u8],
     _reply_slice: &mut [u8],
 ) -> Result<(), SDKError> {
-    let request = postcard::from_bytes::<kata_sdk_interface::LogRequest>(request_slice)
+    let request = postcard::from_bytes::<sdk_interface::LogRequest>(request_slice)
         .map_err(deserialize_failure)?;
     let msg = core::str::from_utf8(request.msg).map_err(|_| SDKError::InvalidString)?;
     unsafe { KATA_SDK.log(app_id, msg) }
@@ -251,13 +252,13 @@ fn read_key_request(
     request_slice: &[u8],
     reply_slice: &mut [u8],
 ) -> Result<(), SDKError> {
-    let request = postcard::from_bytes::<kata_sdk_interface::ReadKeyRequest>(request_slice)
+    let request = postcard::from_bytes::<sdk_interface::ReadKeyRequest>(request_slice)
         .map_err(deserialize_failure)?;
     #[allow(clippy::uninit_assumed_init)]
     let mut keyval: KeyValueData = unsafe { ::core::mem::MaybeUninit::uninit().assume_init() };
     let value = unsafe { KATA_SDK.read_key(app_id, request.key, &mut keyval)? };
     let _ = postcard::to_slice(
-        &kata_sdk_interface::ReadKeyResponse {
+        &sdk_interface::ReadKeyResponse {
             header: SDKReplyHeader::new(SDKRuntimeError::SDKSuccess),
             value,
         },
@@ -272,10 +273,10 @@ fn write_key_request(
     request_slice: &[u8],
     _reply_slice: &mut [u8],
 ) -> Result<(), SDKError> {
-    let request = postcard::from_bytes::<kata_sdk_interface::WriteKeyRequest>(request_slice)
+    let request = postcard::from_bytes::<sdk_interface::WriteKeyRequest>(request_slice)
         .map_err(deserialize_failure)?;
     // NB: the serialized data are variable length so copy to convert
-    let mut keyval = [0u8; kata_sdk_interface::KEY_VALUE_DATA_SIZE];
+    let mut keyval = [0u8; sdk_interface::KEY_VALUE_DATA_SIZE];
     keyval[..request.value.len()].copy_from_slice(request.value);
     unsafe { KATA_SDK.write_key(app_id, request.key, &keyval) }
 }
@@ -285,7 +286,7 @@ fn delete_key_request(
     request_slice: &[u8],
     _reply_slice: &mut [u8],
 ) -> Result<(), SDKError> {
-    let request = postcard::from_bytes::<kata_sdk_interface::DeleteKeyRequest>(request_slice)
+    let request = postcard::from_bytes::<sdk_interface::DeleteKeyRequest>(request_slice)
         .map_err(deserialize_failure)?;
     unsafe { KATA_SDK.delete_key(app_id, request.key) }
 }

apps/system/components/SDKRuntime/kata-sdk-runtime/Cargo.toml

@@ -21,8 +21,8 @@ edition = "2021"
 hashbrown = { version = "0.11", features = ["ahash-compile-time-rng"] }
 kata-os-common = { path = "../../kata-os-common" }
 kata-security-interface = { path = "../../SecurityCoordinator/kata-security-interface" }
-kata-sdk-interface = { path = "../kata-sdk-interface" }
 kata-sdk-manager = { path = "../kata-sdk-manager" }
 log = { version = "0.4", features = ["release_max_level_info"] }
+sdk-interface = { path = "../sdk-interface" }
 smallstr = "0.2"
 spin = "0.9"

apps/system/components/SDKRuntime/kata-sdk-runtime/src/lib.rs

@@ -17,12 +17,12 @@
 
 use kata_os_common::camkes::seL4_CPath;
 use kata_os_common::sel4_sys;
-use kata_sdk_interface::error::SDKError;
-use kata_sdk_interface::KeyValueData;
-use kata_sdk_interface::SDKAppId;
-use kata_sdk_interface::SDKRuntimeInterface;
 use kata_sdk_manager::SDKManagerError;
 use kata_sdk_manager::SDKManagerInterface;
+use sdk_interface::error::SDKError;
+use sdk_interface::KeyValueData;
+use sdk_interface::SDKAppId;
+use sdk_interface::SDKRuntimeInterface;
 use spin::Mutex;
 
 use sel4_sys::seL4_CPtr;

apps/system/components/SDKRuntime/kata-sdk-runtime/src/runtime/mod.rs

@@ -17,16 +17,16 @@ use hashbrown::HashMap;
 use kata_os_common::camkes::seL4_CPath;
 use kata_os_common::cspace_slot::CSpaceSlot;
 use kata_os_common::sel4_sys;
-use kata_sdk_interface::error::SDKError;
-use kata_sdk_interface::KeyValueData;
-use kata_sdk_interface::SDKAppId;
-use kata_sdk_interface::SDKRuntimeInterface;
 use kata_sdk_manager::SDKManagerError;
 use kata_sdk_manager::SDKManagerInterface;
 use kata_security_interface::kata_security_delete_key;
 use kata_security_interface::kata_security_read_key;
 use kata_security_interface::kata_security_write_key;
 use log::{error, info};
+use sdk_interface::error::SDKError;
+use sdk_interface::KeyValueData;
+use sdk_interface::SDKAppId;
+use sdk_interface::SDKRuntimeInterface;
 use smallstr::SmallString;
 
 use sel4_sys::seL4_CPtr;

apps/system/components/SDKRuntime/sdk-interface/Cargo.toml

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 [package]
-name = "kata-sdk-interface"
+name = "sdk-interface"
 version = "0.1.0"
 edition = "2021"
 

apps/system/components/SDKRuntime/sdk-interface/src/lib.rs

@@ -13,8 +13,6 @@
 // limitations under the License.
 
 //! KataOS SDK application runtime interfaces.
-//! These can also be used from KataOS services (for testing) by first
-//! setting up the KATA_SDK_* data (e.g. using kata_sdk_manager_get_endpoint)
 
 #![cfg_attr(not(test), no_std)]
 
@@ -191,7 +189,7 @@ pub trait SDKRuntimeInterface {
 //   This would align request arguments to the page boundary which might
 //   be useful and having the reply inline would mean SDKRuntime could
 //   send a meaningful error back when unable to map the page frame.
-fn kata_sdk_request<'a, S: Serialize, D: Deserialize<'a>>(
+fn sdk_request<'a, S: Serialize, D: Deserialize<'a>>(
     request: SDKRuntimeRequest,
     request_args: &S,
 ) -> Result<D, SDKRuntimeError> {
@@ -225,17 +223,17 @@ fn kata_sdk_request<'a, S: Serialize, D: Deserialize<'a>>(
 /// Rust client-side wrapper for the ping method.
 #[inline]
 #[allow(dead_code)]
-pub fn kata_sdk_ping() -> Result<(), SDKRuntimeError> {
+pub fn sdk_ping() -> Result<(), SDKRuntimeError> {
     let header =
-        kata_sdk_request::<PingRequest, SDKReplyHeader>(SDKRuntimeRequest::Ping, &PingRequest {})?;
+        sdk_request::<PingRequest, SDKReplyHeader>(SDKRuntimeRequest::Ping, &PingRequest {})?;
     header.into()
 }
 
 /// Rust client-side wrapper for the log method.
 #[inline]
 #[allow(dead_code)]
-pub fn kata_sdk_log(msg: &str) -> Result<(), SDKRuntimeError> {
+pub fn sdk_log(msg: &str) -> Result<(), SDKRuntimeError> {
-    let header = kata_sdk_request::<LogRequest, SDKReplyHeader>(
+    let header = sdk_request::<LogRequest, SDKReplyHeader>(
         SDKRuntimeRequest::Log,
         &LogRequest {
             msg: msg.as_bytes(),
@@ -248,8 +246,8 @@ pub fn kata_sdk_log(msg: &str) -> Result<(), SDKRuntimeError> {
 // TODO(sleffler): _mut variant?
 #[inline]
 #[allow(dead_code)]
-pub fn kata_sdk_read_key<'a>(key: &str, keyval: &'a mut [u8]) -> Result<&'a [u8], SDKRuntimeError> {
+pub fn sdk_read_key<'a>(key: &str, keyval: &'a mut [u8]) -> Result<&'a [u8], SDKRuntimeError> {
-    let response = kata_sdk_request::<ReadKeyRequest, ReadKeyResponse>(
+    let response = sdk_request::<ReadKeyRequest, ReadKeyResponse>(
         SDKRuntimeRequest::ReadKey,
         &ReadKeyRequest { key },
     )?;
@@ -266,8 +264,8 @@ pub fn kata_sdk_read_key<'a>(key: &str, keyval: &'a mut [u8]) -> Result<&'a [u8]
 /// Rust client-side wrapper for the write key method.
 #[inline]
 #[allow(dead_code)]
-pub fn kata_sdk_write_key(key: &str, value: &[u8]) -> Result<(), SDKRuntimeError> {
+pub fn sdk_write_key(key: &str, value: &[u8]) -> Result<(), SDKRuntimeError> {
-    let header = kata_sdk_request::<WriteKeyRequest, SDKReplyHeader>(
+    let header = sdk_request::<WriteKeyRequest, SDKReplyHeader>(
         SDKRuntimeRequest::WriteKey,
         &WriteKeyRequest { key, value },
     )?;
@@ -277,8 +275,8 @@ pub fn kata_sdk_write_key(key: &str, value: &[u8]) -> Result<(), SDKRuntimeError
 /// Rust client-side wrapper for the delete key method.
 #[inline]
 #[allow(dead_code)]
-pub fn kata_sdk_delete_key(key: &str) -> Result<(), SDKRuntimeError> {
+pub fn sdk_delete_key(key: &str) -> Result<(), SDKRuntimeError> {
-    let header = kata_sdk_request::<DeleteKeyRequest, SDKReplyHeader>(
+    let header = sdk_request::<DeleteKeyRequest, SDKReplyHeader>(
         SDKRuntimeRequest::DeleteKey,
         &DeleteKeyRequest { key },
     )?;