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/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> {
-    let header = kata_sdk_request::<LogRequest, SDKReplyHeader>(
+pub fn sdk_log(msg: &str) -> Result<(), SDKRuntimeError> {
+    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> {
-    let response = kata_sdk_request::<ReadKeyRequest, ReadKeyResponse>(
+pub fn sdk_read_key<'a>(key: &str, keyval: &'a mut [u8]) -> Result<&'a [u8], SDKRuntimeError> {
+    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> {
-    let header = kata_sdk_request::<WriteKeyRequest, SDKReplyHeader>(
+pub fn sdk_write_key(key: &str, value: &[u8]) -> Result<(), SDKRuntimeError> {
+    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> {
-    let header = kata_sdk_request::<DeleteKeyRequest, SDKReplyHeader>(
+pub fn sdk_delete_key(key: &str) -> Result<(), SDKRuntimeError> {
+    let header = sdk_request::<DeleteKeyRequest, SDKReplyHeader>(
         SDKRuntimeRequest::DeleteKey,
         &DeleteKeyRequest { key },
     )?;