chore: Remove 4.14 related io_uring checks

io_uring is not supported on 4.14 hosts. Since firecracker-microvm#4689 dropped
support for 4.14 hosts, and 5.10 does support io_uring, remove various
checks related to unsupported (4.14) host kernels.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/utils/src/kernel_version.rs

@@ -89,24 +89,6 @@ pub fn min_kernel_version_for_io_uring() -> KernelVersion {
     KernelVersion::new(5, 10, 51)
 }
 
-#[macro_export]
-macro_rules! skip_if_io_uring_unsupported {
-    () => {
-        if KernelVersion::get().unwrap() < min_kernel_version_for_io_uring() {
-            return;
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! skip_if_io_uring_supported {
-    () => {
-        if KernelVersion::get().unwrap() >= min_kernel_version_for_io_uring() {
-            return;
-        }
-    };
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/vmm/src/devices/virtio/block/virtio/device.rs

@@ -16,7 +16,6 @@ use std::sync::Arc;
 use block_io::FileEngine;
 use serde::{Deserialize, Serialize};
 use utils::eventfd::EventFd;
-use utils::kernel_version::{min_kernel_version_for_io_uring, KernelVersion};
 use utils::u64_to_usize;
 
 use super::io::async_io;
@@ -50,16 +49,6 @@ pub enum FileEngineType {
     Sync,
 }
 
-impl FileEngineType {
-    /// Whether the Async engine is supported on the current host kernel.
-    pub fn is_supported(&self) -> Result<bool, utils::kernel_version::KernelVersionError> {
-        match self {
-            Self::Async if KernelVersion::get()? < min_kernel_version_for_io_uring() => Ok(false),
-            _ => Ok(true),
-        }
-    }
-}
-
 /// Helper object for setting up all `Block` fields derived from its backing file.
 #[derive(Debug)]
 pub struct DiskProperties {
@@ -687,7 +676,6 @@ mod tests {
     use std::thread;
     use std::time::Duration;
 
-    use utils::skip_if_io_uring_unsupported;
     use utils::tempfile::TempFile;
 
     use super::*;
@@ -1555,9 +1543,6 @@ mod tests {
 
     #[test]
     fn test_io_engine_throttling() {
-        // skip this test if kernel < 5.10 since in this case the sync engine will be used.
-        skip_if_io_uring_unsupported!();
-
         // FullSQueue BlockError
         {
             let mut block = default_block(FileEngineType::Async);

src/vmm/src/devices/virtio/block/virtio/io/mod.rs

@@ -30,8 +30,6 @@ pub enum BlockIoError {
     Sync(SyncIoError),
     /// Async error: {0}
     Async(AsyncIoError),
-    /// Unsupported engine type: {0:?}
-    UnsupportedEngine(FileEngineType),
     /// Could not get kernel version: {0}
     GetKernelVersion(utils::kernel_version::KernelVersionError),
 }
@@ -64,12 +62,6 @@ impl<T: Debug> FileEngine<T> {
         file: File,
         engine_type: FileEngineType,
     ) -> Result<FileEngine<T>, BlockIoError> {
-        if !engine_type
-            .is_supported()
-            .map_err(BlockIoError::GetKernelVersion)?
-        {
-            return Err(BlockIoError::UnsupportedEngine(engine_type));
-        }
         match engine_type {
             FileEngineType::Async => Ok(FileEngine::Async(
                 AsyncFileEngine::from_file(file).map_err(BlockIoError::Async)?,
@@ -199,13 +191,11 @@ pub mod tests {
     use std::os::unix::ffi::OsStrExt;
     use std::os::unix::io::FromRawFd;
 
-    use utils::kernel_version::{min_kernel_version_for_io_uring, KernelVersion};
     use utils::tempfile::TempFile;
-    use utils::{skip_if_io_uring_supported, skip_if_io_uring_unsupported, u64_to_usize};
+    use utils::u64_to_usize;
 
     use super::*;
     use crate::devices::virtio::block::virtio::device::FileEngineType;
-    use crate::devices::virtio::block::virtio::request::PendingRequest;
     use crate::vmm_config::machine_config::HugePageConfig;
     use crate::vstate::memory::{Bitmap, Bytes, GuestMemory, GuestMemoryExtension};
 
@@ -275,19 +265,6 @@ pub mod tests {
         }
     }
 
-    #[test]
-    fn test_unsupported_engine_type() {
-        skip_if_io_uring_supported!();
-
-        assert!(matches!(
-            FileEngine::<PendingRequest>::from_file(
-                TempFile::new().unwrap().into_file(),
-                FileEngineType::Async
-            ),
-            Err(BlockIoError::UnsupportedEngine(FileEngineType::Async))
-        ));
-    }
-
     #[test]
     fn test_sync() {
         // Check invalid file
@@ -367,8 +344,6 @@ pub mod tests {
 
     #[test]
     fn test_async() {
-        skip_if_io_uring_unsupported!();
-
         // Check invalid file
         let file = unsafe { File::from_raw_fd(-2) };
         FileEngine::<()>::from_file(file, FileEngineType::Async).unwrap_err();

src/vmm/src/devices/virtio/block/virtio/persist.rs

@@ -18,7 +18,6 @@ use crate::devices::virtio::device::{DeviceState, IrqTrigger};
 use crate::devices::virtio::gen::virtio_blk::VIRTIO_BLK_F_RO;
 use crate::devices::virtio::persist::VirtioDeviceState;
 use crate::devices::virtio::TYPE_BLOCK;
-use crate::logger::warn;
 use crate::rate_limiter::persist::RateLimiterState;
 use crate::rate_limiter::RateLimiter;
 use crate::snapshot::Persist;
@@ -97,21 +96,7 @@ impl Persist<'_> for VirtioBlock {
             state.disk_path.clone(),
             is_read_only,
             state.file_engine_type.into(),
-        )
-        .or_else(|err| match err {
-            VirtioBlockError::FileEngine(io::BlockIoError::UnsupportedEngine(
-                FileEngineType::Async,
-            )) => {
-                // If the kernel does not support `Async`, fallback to `Sync`.
-                warn!(
-                    "The \"Async\" io_engine is supported for kernels starting with {}. \
-                     Defaulting to \"Sync\" mode.",
-                    utils::kernel_version::min_kernel_version_for_io_uring()
-                );
-                DiskProperties::new(state.disk_path.clone(), is_read_only, FileEngineType::Sync)
-            }
-            other => Err(other),
-        })?;
+        )?;
 
         let queue_evts = [EventFd::new(libc::EFD_NONBLOCK).map_err(VirtioBlockError::EventFd)?];
 
@@ -214,49 +199,6 @@ mod tests {
         assert_eq!(FileEngineType::Sync, FileEngineTypeState::Sync.into());
         // Test default impl.
         assert_eq!(FileEngineTypeState::default(), FileEngineTypeState::Sync);
-
-        let f = TempFile::new().unwrap();
-        f.as_file().set_len(0x1000).unwrap();
-
-        if !FileEngineType::Async.is_supported().unwrap() {
-            // Test what happens when restoring an Async engine on a kernel that does not support
-            // it.
-
-            let config = VirtioBlockConfig {
-                drive_id: "test".to_string(),
-                path_on_host: f.as_path().to_str().unwrap().to_string(),
-                is_root_device: false,
-                partuuid: None,
-                is_read_only: false,
-                cache_type: CacheType::Writeback,
-                rate_limiter: None,
-                // Need to use Sync because it will otherwise return an error.
-                // We'll overwrite the state instead.
-                file_engine_type: FileEngineType::Sync,
-            };
-
-            let block = VirtioBlock::new(config).unwrap();
-
-            // Save the block device.
-            let mut mem = vec![0; 4096];
-
-            let mut block_state = <VirtioBlock as Persist>::save(&block);
-            // Overwrite the engine type state with Async.
-            block_state.file_engine_type = FileEngineTypeState::Async;
-
-            Snapshot::serialize(&mut mem.as_mut_slice(), &block_state).unwrap();
-
-            // Restore the block device.
-            let restored_block = VirtioBlock::restore(
-                BlockConstructorArgs { mem: default_mem() },
-                &Snapshot::deserialize(&mut mem.as_slice()).unwrap(),
-            )
-            .unwrap();
-
-            // On kernels that don't support io_uring, the restore() function will catch the
-            // `UnsupportedEngine` error and default to Sync.
-            assert_eq!(restored_block.file_engine_type(), FileEngineType::Sync);
-        }
     }
 
     #[test]

src/vmm/src/io_uring/mod.rs

@@ -389,8 +389,6 @@ mod tests {
     use proptest::prelude::*;
     use proptest::strategy::Strategy;
     use proptest::test_runner::{Config, TestRunner};
-    use utils::kernel_version::{min_kernel_version_for_io_uring, KernelVersion};
-    use utils::skip_if_io_uring_unsupported;
     use utils::syscall::SyscallReturnCode;
     use utils::tempfile::TempFile;
     use vm_memory::VolatileMemory;
@@ -475,7 +473,6 @@ mod tests {
 
     #[test]
     fn proptest_read_write_correctness() {
-        skip_if_io_uring_unsupported!();
         // Performs a sequence of random read and write operations on two files, with sync and
         // async IO, respectively.
         // Verifies that the files are identical afterwards and that the read operations returned

src/vmm/tests/io_uring.rs

@@ -10,8 +10,6 @@ use std::time::Duration;
 
 use utils::epoll::{ControlOperation, Epoll, EpollEvent, EventSet};
 use utils::eventfd::EventFd;
-use utils::kernel_version::{min_kernel_version_for_io_uring, KernelVersion};
-use utils::skip_if_io_uring_unsupported;
 use utils::tempfile::TempFile;
 use vm_memory::VolatileMemory;
 use vmm::vstate::memory::{Bytes, MmapRegion};
@@ -93,8 +91,6 @@ const NUM_ENTRIES: u32 = 128;
 
 #[test]
 fn test_ring_new() {
-    skip_if_io_uring_unsupported!();
-
     // Invalid entries count: 0.
     assert!(matches!(
         IoUring::<u8>::new(0, vec![], vec![], None),
@@ -110,7 +106,6 @@ fn test_ring_new() {
 
 #[test]
 fn test_eventfd() {
-    skip_if_io_uring_unsupported!();
     // Test that events get delivered.
     let eventfd = EventFd::new(0).unwrap();
 
@@ -145,8 +140,6 @@ fn test_eventfd() {
 
 #[test]
 fn test_restrictions() {
-    skip_if_io_uring_unsupported!();
-
     // Check that only the allowlisted opcodes are permitted.
     {
         let file = TempFile::new().unwrap().into_file();
@@ -180,8 +173,6 @@ fn test_restrictions() {
 
 #[test]
 fn test_ring_push() {
-    skip_if_io_uring_unsupported!();
-
     // Forgot to register file.
     {
         let buf = [0; 4];
@@ -267,8 +258,6 @@ fn test_ring_push() {
 
 #[test]
 fn test_ring_submit() {
-    skip_if_io_uring_unsupported!();
-
     {
         let file = TempFile::new().unwrap().into_file();
         let mut ring = IoUring::new(NUM_ENTRIES, vec![&file], vec![], None).unwrap();
@@ -298,8 +287,6 @@ fn test_ring_submit() {
 
 #[test]
 fn test_submit_and_wait_all() {
-    skip_if_io_uring_unsupported!();
-
     let file = TempFile::new().unwrap().into_file();
     let mut ring = IoUring::new(NUM_ENTRIES, vec![&file], vec![], None).unwrap();
     let user_data: u8 = 71;
@@ -345,8 +332,6 @@ fn test_submit_and_wait_all() {
 
 #[test]
 fn test_write() {
-    skip_if_io_uring_unsupported!();
-
     // Test that writing the sorted values 1-100 into a file works correctly.
 
     const NUM_BYTES: usize = 100;
@@ -386,8 +371,6 @@ fn test_write() {
 
 #[test]
 fn test_read() {
-    skip_if_io_uring_unsupported!();
-
     // Test that reading the sorted values 1-100 from a file works correctly.
 
     const NUM_BYTES: usize = 100;