virtio/fs: implement an ioctl to receive exit_code

For the container use case, we need to relay the exit code from
userspace in the microVM all the way to the process using libkrun to
launch the VMM.

Since ioctls are passed mostly unmodified from userspace in the guest
to the virtio-fs device, we can use them as a mechanism for transporting
this information without requiring any specific support in the guest's
kernel.

Here we create an AtomicI32 and wire it up between virtio-fs and Vmm,
using it as exit code if userspace has set it to some value other than
i32::MAX. Otherwise, we keep using the vCPU exit code, as we did before.

Signed-off-by: Sergio Lopez <[email protected]>

Author: slp

src/devices/src/virtio/fs/device.rs

@@ -2,7 +2,7 @@
 use crossbeam_channel::Sender;
 use std::cmp;
 use std::io::Write;
-use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicI32, AtomicU64, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
@@ -54,6 +54,7 @@ pub struct Fs {
     passthrough_cfg: passthrough::Config,
     worker_thread: Option<JoinHandle<()>>,
     worker_stopfd: EventFd,
+    exit_code: Arc<AtomicI32>,
     #[cfg(target_os = "macos")]
     map_sender: Option<Sender<MemoryMapping>>,
 }
@@ -62,6 +63,7 @@ impl Fs {
     pub(crate) fn with_queues(
         fs_id: String,
         shared_dir: String,
+        exit_code: Arc<AtomicI32>,
         queues: Vec<VirtQueue>,
     ) -> super::Result<Fs> {
         let mut queue_events = Vec::new();
@@ -97,17 +99,18 @@ impl Fs {
             passthrough_cfg: fs_cfg,
             worker_thread: None,
             worker_stopfd: EventFd::new(EFD_NONBLOCK).map_err(FsError::EventFd)?,
+            exit_code,
             #[cfg(target_os = "macos")]
             map_sender: None,
         })
     }
 
-    pub fn new(fs_id: String, shared_dir: String) -> super::Result<Fs> {
+    pub fn new(fs_id: String, shared_dir: String, exit_code: Arc<AtomicI32>) -> super::Result<Fs> {
         let queues: Vec<VirtQueue> = defs::QUEUE_SIZES
             .iter()
             .map(|&max_size| VirtQueue::new(max_size))
             .collect();
-        Self::with_queues(fs_id, shared_dir, queues)
+        Self::with_queues(fs_id, shared_dir, exit_code, queues)
     }
 
     pub fn id(&self) -> &str {
@@ -226,6 +229,7 @@ impl VirtioDevice for Fs {
             self.shm_region.clone(),
             self.passthrough_cfg.clone(),
             self.worker_stopfd.try_clone().unwrap(),
+            self.exit_code.clone(),
             #[cfg(target_os = "macos")]
             self.map_sender.clone(),
         );

src/devices/src/virtio/fs/filesystem.rs

@@ -13,6 +13,7 @@ use std::ffi::{CStr, CString};
 use std::fs::File;
 use std::io;
 use std::mem;
+use std::sync::atomic::AtomicI32;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -1160,6 +1161,7 @@ pub trait FileSystem {
         arg: u64,
         in_size: u32,
         out_size: u32,
+        exit_code: &Arc<AtomicI32>,
     ) -> io::Result<Vec<u8>> {
         Err(io::Error::from_raw_os_error(bindings::LINUX_ENOSYS))
     }

src/devices/src/virtio/fs/linux/passthrough.rs

@@ -11,12 +11,12 @@ use std::io;
 use std::mem::{self, size_of, MaybeUninit};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
 use caps::{has_cap, CapSet, Capability};
-use nix::request_code_read;
+use nix::{request_code_none, request_code_read};
 
 use vm_memory::ByteValued;
 
@@ -2107,11 +2107,13 @@ impl FileSystem for PassthroughFs {
         handle: Self::Handle,
         _flags: u32,
         cmd: u32,
-        _arg: u64,
+        arg: u64,
         _in_size: u32,
         out_size: u32,
+        exit_code: &Arc<AtomicI32>,
     ) -> io::Result<Vec<u8>> {
         const VIRTIO_IOC_MAGIC: u8 = b'v';
+
         const VIRTIO_IOC_TYPE_EXPORT_FD: u8 = 1;
         const VIRTIO_IOC_EXPORT_FD_SIZE: usize = 2 * mem::size_of::<u64>();
         const VIRTIO_IOC_EXPORT_FD_REQ: u32 = request_code_read!(
@@ -2120,6 +2122,10 @@ impl FileSystem for PassthroughFs {
             VIRTIO_IOC_EXPORT_FD_SIZE
         ) as u32;
 
+        const VIRTIO_IOC_TYPE_EXIT_CODE: u8 = 2;
+        const VIRTIO_IOC_EXIT_CODE_REQ: u32 =
+            request_code_none!(VIRTIO_IOC_MAGIC, VIRTIO_IOC_TYPE_EXIT_CODE) as u32;
+
         match cmd {
             VIRTIO_IOC_EXPORT_FD_REQ => {
                 if out_size as usize != VIRTIO_IOC_EXPORT_FD_SIZE {
@@ -2150,6 +2156,10 @@ impl FileSystem for PassthroughFs {
                 ret.extend_from_slice(&handle.to_ne_bytes());
                 Ok(ret)
             }
+            VIRTIO_IOC_EXIT_CODE_REQ => {
+                exit_code.store(arg as i32, Ordering::SeqCst);
+                Ok(Vec::new())
+            }
             _ => Err(io::Error::from_raw_os_error(libc::EOPNOTSUPP)),
         }
     }

src/devices/src/virtio/fs/macos/passthrough.rs

@@ -14,7 +14,7 @@ use std::mem::MaybeUninit;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::ptr::null_mut;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 use std::time::Duration;
 
@@ -2105,4 +2105,29 @@ impl FileSystem for PassthroughFs {
 
         Ok(())
     }
+
+    fn ioctl(
+        &self,
+        _ctx: Context,
+        _inode: Self::Inode,
+        _handle: Self::Handle,
+        _flags: u32,
+        cmd: u32,
+        arg: u64,
+        _in_size: u32,
+        _out_size: u32,
+        exit_code: &Arc<AtomicI32>,
+    ) -> io::Result<Vec<u8>> {
+        // We can't use nix::request_code_none here since it's system-dependent
+        // and we need the value from Linux.
+        const VIRTIO_IOC_EXIT_CODE_REQ: u32 = 0x7602;
+
+        match cmd {
+            VIRTIO_IOC_EXIT_CODE_REQ => {
+                exit_code.store(arg as i32, Ordering::SeqCst);
+                Ok(Vec::new())
+            }
+            _ => Err(io::Error::from_raw_os_error(libc::EOPNOTSUPP)),
+        }
+    }
 }

src/devices/src/virtio/fs/server.rs

@@ -12,7 +12,8 @@ use std::ffi::{CStr, CString};
 use std::fs::File;
 use std::io::{self, Read, Write};
 use std::mem::size_of;
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::{AtomicI32, AtomicU64, Ordering};
+use std::sync::Arc;
 
 use vm_memory::ByteValued;
 
@@ -83,6 +84,7 @@ impl<F: FileSystem + Sync> Server<F> {
         mut r: Reader,
         w: Writer,
         shm_region: &Option<VirtioShmRegion>,
+        exit_code: &Arc<AtomicI32>,
         #[cfg(target_os = "macos")] map_sender: &Option<Sender<MemoryMapping>>,
     ) -> Result<usize> {
         let in_header: InHeader = r.read_obj().map_err(Error::DecodeMessage)?;
@@ -132,7 +134,7 @@ impl<F: FileSystem + Sync> Server<F> {
             x if x == Opcode::Interrupt as u32 => self.interrupt(in_header),
             x if x == Opcode::Bmap as u32 => self.bmap(in_header, r, w),
             x if x == Opcode::Destroy as u32 => self.destroy(),
-            x if x == Opcode::Ioctl as u32 => self.ioctl(in_header, r, w),
+            x if x == Opcode::Ioctl as u32 => self.ioctl(in_header, r, w, exit_code),
             x if x == Opcode::Poll as u32 => self.poll(in_header, r, w),
             x if x == Opcode::NotifyReply as u32 => self.notify_reply(in_header, r, w),
             x if x == Opcode::BatchForget as u32 => self.batch_forget(in_header, r, w),
@@ -1166,7 +1168,13 @@ impl<F: FileSystem + Sync> Server<F> {
         Ok(0)
     }
 
-    fn ioctl(&self, in_header: InHeader, mut r: Reader, w: Writer) -> Result<usize> {
+    fn ioctl(
+        &self,
+        in_header: InHeader,
+        mut r: Reader,
+        w: Writer,
+        exit_code: &Arc<AtomicI32>,
+    ) -> Result<usize> {
         let IoctlIn {
             fh,
             flags,
@@ -1185,6 +1193,7 @@ impl<F: FileSystem + Sync> Server<F> {
             arg,
             in_size,
             out_size,
+            exit_code,
         ) {
             Ok(data) => {
                 let out = IoctlOut {

src/devices/src/virtio/fs/worker.rs

@@ -4,7 +4,7 @@ use crossbeam_channel::Sender;
 use hvf::MemoryMapping;
 
 use std::os::fd::AsRawFd;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicI32, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread;
 
@@ -32,6 +32,7 @@ pub struct FsWorker {
     shm_region: Option<VirtioShmRegion>,
     server: Server<PassthroughFs>,
     stop_fd: EventFd,
+    exit_code: Arc<AtomicI32>,
     #[cfg(target_os = "macos")]
     map_sender: Option<Sender<MemoryMapping>>,
 }
@@ -49,6 +50,7 @@ impl FsWorker {
         shm_region: Option<VirtioShmRegion>,
         passthrough_cfg: passthrough::Config,
         stop_fd: EventFd,
+        exit_code: Arc<AtomicI32>,
         #[cfg(target_os = "macos")] map_sender: Option<Sender<MemoryMapping>>,
     ) -> Self {
         Self {
@@ -63,6 +65,7 @@ impl FsWorker {
             shm_region,
             server: Server::new(PassthroughFs::new(passthrough_cfg).unwrap()),
             stop_fd,
+            exit_code,
             #[cfg(target_os = "macos")]
             map_sender,
         }
@@ -170,6 +173,7 @@ impl FsWorker {
                 reader,
                 writer,
                 &self.shm_region,
+                &self.exit_code,
                 #[cfg(target_os = "macos")]
                 &self.map_sender,
             ) {

src/vmm/src/builder.rs

@@ -18,6 +18,7 @@ use std::io::{self, Read};
 #[cfg(target_os = "linux")]
 use std::os::fd::AsRawFd;
 use std::path::PathBuf;
+use std::sync::atomic::AtomicI32;
 use std::sync::{Arc, Mutex};
 
 use super::{Error, Vmm};
@@ -763,13 +764,17 @@ pub fn build_microvm(
         )?;
     }
 
+    // We use this atomic to record the exit code set by init/init.c in the VM.
+    let exit_code = Arc::new(AtomicI32::new(i32::MAX));
+
     let mut vmm = Vmm {
         guest_memory,
         arch_memory_info,
         kernel_cmdline,
         vcpus_handles: Vec::new(),
         exit_evt,
         exit_observers: Vec::new(),
+        exit_code: exit_code.clone(),
         vm,
         mmio_device_manager,
         #[cfg(target_arch = "x86_64")]
@@ -808,6 +813,7 @@ pub fn build_microvm(
             _map_sender.clone(),
         )?;
     }
+
     #[cfg(not(feature = "tee"))]
     attach_fs_devices(
         &mut vmm,
@@ -816,6 +822,7 @@ pub fn build_microvm(
         #[cfg(not(feature = "tee"))]
         export_table,
         intc.clone(),
+        exit_code,
         #[cfg(target_os = "macos")]
         _map_sender,
     )?;
@@ -1587,13 +1594,19 @@ fn attach_fs_devices(
     shm_manager: &mut ShmManager,
     #[cfg(not(feature = "tee"))] export_table: Option<ExportTable>,
     intc: IrqChip,
+    exit_code: Arc<AtomicI32>,
     #[cfg(target_os = "macos")] map_sender: Sender<MemoryMapping>,
 ) -> std::result::Result<(), StartMicrovmError> {
     use self::StartMicrovmError::*;
 
     for (i, config) in fs_devs.iter().enumerate() {
         let fs = Arc::new(Mutex::new(
-            devices::virtio::Fs::new(config.fs_id.clone(), config.shared_dir.clone()).unwrap(),
+            devices::virtio::Fs::new(
+                config.fs_id.clone(),
+                config.shared_dir.clone(),
+                exit_code.clone(),
+            )
+            .unwrap(),
         ));
 
         let id = format!("{}{}", String::from(fs.lock().unwrap().id()), i);

src/vmm/src/lib.rs

@@ -40,6 +40,7 @@ use macos::vstate;
 use std::fmt::{Display, Formatter};
 use std::io;
 use std::os::unix::io::AsRawFd;
+use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::{Arc, Mutex};
 #[cfg(target_os = "linux")]
 use std::time::Duration;
@@ -202,6 +203,7 @@ pub struct Vmm {
     exit_evt: EventFd,
     vm: Vm,
     exit_observers: Vec<Arc<Mutex<dyn VmmExitObserver>>>,
+    exit_code: Arc<AtomicI32>,
 
     // Guest VM devices.
     mmio_device_manager: MMIODeviceManager,
@@ -394,15 +396,26 @@ impl Subscriber for Vmm {
             // 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
+            //
+            // The exit code set up by the guest takes preference over the one reported
+            // by either a vcpu or the i8042 controller.
+            let vcpu_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));
+            let vmm_exit_code = self.exit_code.load(Ordering::SeqCst);
+            let exit_code = if vmm_exit_code != i32::MAX {
+                debug!("using vmm exit code: {vmm_exit_code}");
+                vmm_exit_code
+            } else {
+                debug!("using vcpu exit code: {vcpu_exit_code}");
+                vcpu_exit_code as i32
+            };
+            self.stop(exit_code);
         } else {
             error!("Spurious EventManager event for handler: Vmm");
         }