forward the vCPU exit code to the VMM

Signed-off-by: Serban Iorga <[email protected]>

Author: Serban Iorga

src/vmm/src/lib.rs

@@ -1271,7 +1271,21 @@ impl Vmm {
             match self.epoll_context.dispatch_table[event.data as usize] {
                 Some(EpollDispatch::Exit) => {
                     self.exit_evt.read().map_err(Error::EventFd)?;
-                    self.stop(i32::from(FC_EXIT_CODE_OK));
+
+                    // Query each vcpu for the exit_code.
+                    // If the exit_code can't be found on any vcpu, it means that the exit signal
+                    // has been issued by the i8042 controller in which case we exit with
+                    // FC_EXIT_CODE_OK.
+                    let exit_code = self
+                        .vcpus_handles
+                        .iter()
+                        .find_map(|handle| match handle.response_receiver().try_recv() {
+                            Ok(VcpuResponse::Exited(exit_code)) => Some(exit_code),
+                            _ => None,
+                        })
+                        .unwrap_or(FC_EXIT_CODE_OK);
+
+                    self.stop(i32::from(exit_code));
                 }
                 Some(EpollDispatch::Stdin) => {
                     let mut out = [0u8; 64];

src/vmm/src/vstate.rs

@@ -14,7 +14,7 @@ use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
 use std::thread;
 
 use super::TimestampUs;
-use arch;
+use super::FC_EXIT_CODE_GENERIC_ERROR;
 #[cfg(target_arch = "aarch64")]
 use arch::aarch64::gic::GICDevice;
 #[cfg(target_arch = "x86_64")]
@@ -30,6 +30,7 @@ use kvm_bindings::{kvm_userspace_memory_region, KVM_API_VERSION};
 use kvm_ioctls::*;
 use logger::{Metric, METRICS};
 use seccomp::{BpfProgram, SeccompFilter};
+use std::sync::Barrier;
 use utils::eventfd::EventFd;
 use utils::signal::{register_signal_handler, sigrtmin, Killable};
 use utils::sm::StateMachine;
@@ -1002,7 +1003,7 @@ impl Vcpu {
                 // Emulation was interrupted, check external events.
                 Ok(VcpuEmulation::Interrupted) => break,
                 // Emulation errors lead to vCPU exit.
-                Err(_) => return StateMachine::next(Self::exited),
+                Err(_) => return self.exit(FC_EXIT_CODE_GENERIC_ERROR),
             }
         }
 
@@ -1032,7 +1033,7 @@ impl Vcpu {
             // Unhandled exit of the other end.
             Err(TryRecvError::Disconnected) => {
                 // Move to 'exited' state.
-                state = StateMachine::next(Self::exited);
+                state = self.exit(FC_EXIT_CODE_GENERIC_ERROR);
             }
             // All other events or lack thereof have no effect on current 'running' state.
             Err(TryRecvError::Empty) => (),
@@ -1058,18 +1059,33 @@ impl Vcpu {
             // Unhandled exit of the other end.
             Err(_) => {
                 // Move to 'exited' state.
-                StateMachine::next(Self::exited)
+                self.exit(FC_EXIT_CODE_GENERIC_ERROR)
             }
         }
     }
 
-    // This is the main loop of the `Exited` state.
-    fn exited(&mut self) -> StateMachine<Self> {
+    // Transition to the exited state
+    fn exit(&mut self, exit_code: u8) -> StateMachine<Self> {
+        self.response_sender
+            .send(VcpuResponse::Exited(exit_code))
+            .expect("failed to send Exited status");
+
         if let Err(e) = self.exit_evt.write(1) {
             METRICS.vcpu.failures.inc();
             error!("Failed signaling vcpu exit event: {}", e);
         }
+
         // State machine reached its end.
+        StateMachine::next(Self::exited)
+    }
+
+    // This is the main loop of the `Exited` state.
+    fn exited(&mut self) -> StateMachine<Self> {
+        // Wait indefinitely.
+        // The VMM thread will kill the entire process.
+        let barrier = Barrier::new(2);
+        barrier.wait();
+
         StateMachine::finish(Self::exited)
     }
 }
@@ -1114,6 +1130,8 @@ pub enum VcpuResponse {
     Paused,
     /// Vcpu is resumed.
     Resumed,
+    /// Vcpu is stopped.
+    Exited(u8),
 }
 
 /// Wrapper over Vcpu that hides the underlying interactions with the Vcpu thread.

tests/integration_tests/build/test_coverage.py

@@ -19,7 +19,7 @@
 
 import host_tools.cargo_build as host  # pylint: disable=import-error
 
-COVERAGE_TARGET_PCT = 85.05
+COVERAGE_TARGET_PCT = 84.90
 COVERAGE_MAX_DELTA = 0.05
 
 CARGO_KCOV_REL_PATH = os.path.join(host.CARGO_BUILD_REL_PATH, 'kcov')