Move request logic into a separate crate (#2745)

This moves the trivial echo code from the UEFI app code into a separate crate.

The goals are two-fold:
(a) First, the UEFI app crate should only be kind of hardware abstraction layer, with no cleverness of its own. All logic should be somewhere else.
(b) Second, this allows us to create a bare-metal 'kernel' which offers a similar abstraction layer, and use the common runtime library shared with the UEFI app.

Author: andrisaar

Cargo.lock

@@ -14,6 +14,7 @@ members = [
   "experimental/trusted_shuffler/trusted_shuffler",
   "experimental/uefi/client",
   "experimental/uefi/loader",
+  "experimental/uefi/runtime",
   "oak_functions/abi",
   "oak_functions/client/rust",
   "oak_functions/examples/benchmark/module",

Cargo.toml

@@ -12,10 +12,8 @@ support_emulated_runner = []
 [dependencies]
 uefi = { version = "*", features = ["exts"] }
 uefi-services = "*"
-log = { version = "*" }
-ciborium = { version = "*", default-features = false }
-ciborium-io = "*"
 oak_remote_attestation = { path = "../../../remote_attestation/rust" }
+runtime = { path = "../runtime" }
 
 [dev-dependencies]
 anyhow = { version = "*", default-features = false }

experimental/uefi/app/Cargo.lock

@@ -24,11 +24,7 @@
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]
 
-#[macro_use]
-extern crate log;
-extern crate alloc;
-
-use ciborium::{de, ser};
+use runtime::echo;
 use uefi::{prelude::*, table::runtime::ResetType};
 
 mod serial;
@@ -68,44 +64,9 @@ fn main(handle: Handle, system_table: &mut SystemTable<Boot>) -> Status {
 
     writeln!(system_table.stdout(), "Hello World!").unwrap();
 
-    serial_echo(handle, system_table.boot_services(), ECHO_SERIAL_PORT_INDEX).unwrap();
-}
-
-// Opens the index-th serial port on the system and echoes back all frames sent over the serial
-// port.
-//
-// Panics if the index-th serial port does not exist.
-//
-// Arguments:
-//    * `handle` - UEFI handle of the agent (eg of the UEFI app)
-//    * `boot_services` - reference to the UEFI Boot Services struct (obtained from the system
-//      table)
-//    * `index` - index of the serial port, zero-based.
-//
-//  Normally does not return, unless an error is raised.
-fn serial_echo(handle: Handle, bt: &BootServices, index: usize) -> Result<!, uefi::Error<()>> {
-    let mut serial = serial::Serial::get(handle, bt, index)?;
-    loop {
-        let msg: alloc::vec::Vec<u8> = de::from_reader(&mut serial).map_err(|err| match err {
-            de::Error::Io(err) => err,
-            de::Error::Syntax(idx) => {
-                error!("Error reading data at index {}", idx);
-                uefi::Error::from(Status::INVALID_PARAMETER)
-            }
-            de::Error::Semantic(_, err) => {
-                error!("Error parsing cbor data: {:?}", err);
-                uefi::Error::from(Status::INVALID_PARAMETER)
-            }
-            de::Error::RecursionLimitExceeded => uefi::Error::from(Status::ABORTED),
-        })?;
-        ser::into_writer(&msg, &mut serial).map_err(|err| match err {
-            ser::Error::Io(err) => err,
-            ser::Error::Value(msg) => {
-                error!("Error serializing value: {}", msg);
-                uefi::Error::from(Status::INVALID_PARAMETER)
-            }
-        })?;
-    }
+    let mut serial =
+        serial::Serial::get(handle, system_table.boot_services(), ECHO_SERIAL_PORT_INDEX).unwrap();
+    echo::echo(&mut serial).unwrap();
 }
 
 #[cfg(test)]

experimental/uefi/app/Cargo.toml

@@ -71,24 +71,16 @@ impl<'boot> Serial<'boot> {
     }
 }
 
-impl<'boot> ciborium_io::Write for Serial<'boot> {
+impl<'boot> runtime::Channel for Serial<'boot> {
     type Error = Error<()>;
 
-    fn write_all(&mut self, data: &[u8]) -> Result<(), Self::Error> {
+    fn send(&mut self, data: &[u8]) -> Result<(), Self::Error> {
         self.serial.write(data).discard_errdata()
     }
 
-    fn flush(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-}
-
-impl<'boot> ciborium_io::Read for Serial<'boot> {
-    type Error = Error<()>;
-
     // Try to fill the buffer, ignoring any timeout errors. Any other errors
     // are propagated upward.
-    fn read_exact(&mut self, data: &mut [u8]) -> Result<(), Self::Error> {
+    fn recv(&mut self, data: &mut [u8]) -> Result<(), Self::Error> {
         let mut bytes_read = 0;
         while bytes_read < data.len() {
             let len = self.read(&mut data[bytes_read..])?;

experimental/uefi/app/src/main.rs

@@ -0,0 +1,10 @@
+[package]
+name = "runtime"
+version = "0.1.0"
+authors = ["Andri Saar <[email protected]>"]
+edition = "2021"
+license = "Apache-2.0"
+
+[dependencies]
+ciborium = { version = "*", default-features = false }
+ciborium-io = "*"

experimental/uefi/app/src/serial.rs

@@ -0,0 +1,58 @@
+//
+// Copyright 2022 The Project Oak Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+extern crate alloc;
+
+use crate::Channel;
+use alloc::vec::Vec;
+use ciborium::{de, ser};
+
+#[derive(Debug)]
+pub enum Error<T> {
+    // An error occured while deserializing.
+    De(ciborium::de::Error<T>),
+
+    // An error occured while serializing.
+    Ser(ciborium::ser::Error<T>),
+}
+
+impl<E> ciborium_io::Write for &mut dyn Channel<Error = E> {
+    type Error = E;
+
+    fn write_all(&mut self, data: &[u8]) -> Result<(), Self::Error> {
+        self.send(data)
+    }
+
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<E> ciborium_io::Read for &mut dyn Channel<Error = E> {
+    type Error = E;
+
+    fn read_exact(&mut self, data: &mut [u8]) -> Result<(), Self::Error> {
+        self.recv(data)
+    }
+}
+
+// Echoes all input on the interface back out.
+pub fn echo<E: core::fmt::Debug>(mut channel: &mut dyn Channel<Error = E>) -> Result<!, Error<E>> {
+    loop {
+        let msg: Vec<u8> = de::from_reader(&mut channel).map_err(Error::De)?;
+        ser::into_writer(&msg, &mut channel).map_err(Error::Ser)?;
+    }
+}

experimental/uefi/runtime/Cargo.toml

@@ -0,0 +1,28 @@
+//
+// Copyright 2022 The Project Oak Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#![no_std]
+#![feature(never_type)]
+
+pub mod echo;
+
+/// Basic hardware abstraction layer for sending data.
+pub trait Channel {
+    type Error;
+
+    fn send(&mut self, data: &[u8]) -> Result<(), Self::Error>;
+    fn recv(&mut self, data: &mut [u8]) -> Result<(), Self::Error>;
+}