Propagate SEV platform errors from ioctl calls

This information is way more helpful than just the errno returned from
the ioctl.

Signed-off-by: Connor Kuehl <[email protected]>

Author: Connor Kuehl

src/launch/launcher.rs

@@ -34,7 +34,8 @@ impl<'a, U: AsRawFd, V: AsRawFd> Launcher<'a, New, U, V> {
         };
 
         let mut cmd = Command::from(launcher.sev, &Init);
-        INIT.ioctl(launcher.kvm, &mut cmd)?;
+        INIT.ioctl(launcher.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
 
         Ok(launcher)
     }
@@ -43,7 +44,9 @@ impl<'a, U: AsRawFd, V: AsRawFd> Launcher<'a, New, U, V> {
     pub fn start(self, start: Start) -> Result<Launcher<'a, Started, U, V>> {
         let mut launch_start = LaunchStart::new(&start.policy, &start.cert, &start.session);
         let mut cmd = Command::from_mut(self.sev, &mut launch_start);
-        LAUNCH_START.ioctl(self.kvm, &mut cmd)?;
+        LAUNCH_START
+            .ioctl(self.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
 
         let next = Launcher {
             state: Started(launch_start.into()),
@@ -60,7 +63,9 @@ impl<'a, U: AsRawFd, V: AsRawFd> Launcher<'a, Started, U, V> {
     pub fn update_data(&mut self, data: &[u8]) -> Result<()> {
         let launch_update_data = LaunchUpdateData::new(data);
         let mut cmd = Command::from(self.sev, &launch_update_data);
-        LAUNCH_UPDATE_DATA.ioctl(self.kvm, &mut cmd)?;
+        LAUNCH_UPDATE_DATA
+            .ioctl(self.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
         Ok(())
     }
 
@@ -69,7 +74,9 @@ impl<'a, U: AsRawFd, V: AsRawFd> Launcher<'a, Started, U, V> {
         let mut measurement = MaybeUninit::uninit();
         let mut launch_measure = LaunchMeasure::new(&mut measurement);
         let mut cmd = Command::from_mut(self.sev, &mut launch_measure);
-        LAUNCH_MEASUREMENT.ioctl(self.kvm, &mut cmd)?;
+        LAUNCH_MEASUREMENT
+            .ioctl(self.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
 
         let next = Launcher {
             state: Measured(self.state.0, unsafe { measurement.assume_init() }),
@@ -95,14 +102,18 @@ impl<'a, U: AsRawFd, V: AsRawFd> Launcher<'a, Measured, U, V> {
     pub fn inject(&mut self, secret: Secret, guest: usize) -> Result<()> {
         let launch_secret = LaunchSecret::new(&secret.header, guest, &secret.ciphertext[..]);
         let mut cmd = Command::from(self.sev, &launch_secret);
-        LAUNCH_SECRET.ioctl(self.kvm, &mut cmd)?;
+        LAUNCH_SECRET
+            .ioctl(self.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
         Ok(())
     }
 
     /// Complete the SEV launch process.
     pub fn finish(self) -> Result<Handle> {
         let mut cmd = Command::from(self.sev, &LaunchFinish);
-        LAUNCH_FINISH.ioctl(self.kvm, &mut cmd)?;
+        LAUNCH_FINISH
+            .ioctl(self.kvm, &mut cmd)
+            .map_err(|e| cmd.encapsulate(e))?;
         Ok(self.state.0)
     }
 }

src/launch/linux/ioctl.rs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::firmware::{Error, Indeterminate};
 use crate::impl_const_id;
 use crate::kvm::types::*;
 use iocuddle::*;
@@ -84,4 +85,11 @@ impl<'a, T: Id> Command<'a, T> {
             _phantom: PhantomData,
         }
     }
+
+    pub fn encapsulate(&self, err: std::io::Error) -> Indeterminate<Error> {
+        match self.error {
+            0 => Indeterminate::<Error>::from(err),
+            _ => Indeterminate::<Error>::from(self.error as u32),
+        }
+    }
 }