fix: Unblock virtio-blk discard by permitting fallocate in seccomp

Refactor unmap, fstrim, and discard logic to replace the deprecated
discard_support branch and unify the block device discard path.

Signed-off-by: LDagnachew <[email protected]>

Author: LDagnachew

resources/seccomp/aarch64-unknown-linux-musl.json

@@ -85,6 +85,10 @@
                 "syscall": "lseek",
                 "comment": "Used by the block device"
             },
+            {
+                "syscall": "fallocate",
+                "comment": "Used by the block device for discard (hole punching)"
+            },
             {
                 "syscall": "mremap",
                 "comment": "Used for re-allocating large memory regions, for example vectors"

resources/seccomp/x86_64-unknown-linux-musl.json

@@ -85,6 +85,10 @@
                 "syscall": "lseek",
                 "comment": "Used by the block device"
             },
+            {
+                "syscall": "fallocate",
+                "comment": "Used by the block device for discard (hole punching)"
+            },
             {
                 "syscall": "mremap",
                 "comment": "Used for re-allocating large memory regions, for example vectors"

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

@@ -27,7 +27,7 @@ use crate::devices::virtio::block::CacheType;
 use crate::devices::virtio::block::virtio::metrics::{BlockDeviceMetrics, BlockMetricsPerDevice};
 use crate::devices::virtio::device::{ActiveState, DeviceState, VirtioDevice};
 use crate::devices::virtio::generated::virtio_blk::{
-    VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_RO, VIRTIO_BLK_ID_BYTES,
+    VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_RO, VIRTIO_BLK_ID_BYTES, VIRTIO_BLK_F_DISCARD,
 };
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::generated::virtio_ids::VIRTIO_ID_BLOCK;
@@ -298,7 +298,7 @@ impl VirtioBlock {
             .map_err(VirtioBlockError::RateLimiter)?
             .unwrap_or_default();
 
-        let mut avail_features = (1u64 << VIRTIO_F_VERSION_1) | (1u64 << VIRTIO_RING_F_EVENT_IDX);
+        let mut avail_features = (1u64 << VIRTIO_F_VERSION_1) | (1u64 << VIRTIO_RING_F_EVENT_IDX) | (1u64 << VIRTIO_BLK_F_DISCARD);
 
         if config.cache_type == CacheType::Writeback {
             avail_features |= 1u64 << VIRTIO_BLK_F_FLUSH;

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

@@ -110,7 +110,6 @@ impl AsyncFileEngine {
         Ok(())
     }
 
-    #[cfg(test)]
     pub fn file(&self) -> &File {
         &self.file
     }
@@ -230,6 +229,27 @@ impl AsyncFileEngine {
         Ok(())
     }
 
+    pub fn push_discard(
+        &mut self,
+        offset: u64,
+        len: u32,
+        req: PendingRequest,
+    ) -> Result<(), RequestError<AsyncIoError>> {
+        let wrapped_user_data = WrappedRequest::new(req);
+
+        self.ring
+            .push(Operation::fallocate(
+                0,
+                len,
+                offset,
+                wrapped_user_data,
+            ))
+            .map_err(|(io_uring_error, data)| RequestError {
+                req: data.req,
+                error: AsyncIoError::IoUring(io_uring_error),
+            })
+    }
+    
     fn do_pop(&mut self) -> Result<Option<Cqe<WrappedRequest>>, AsyncIoError> {
         self.ring.pop().map_err(AsyncIoError::IoUring)
     }

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

@@ -6,9 +6,12 @@ pub mod sync_io;
 
 use std::fmt::Debug;
 use std::fs::File;
+use libc::{c_int, off64_t, FALLOC_FL_KEEP_SIZE, FALLOC_FL_PUNCH_HOLE};
+use std::os::unix::io::AsRawFd;
 
 pub use self::async_io::{AsyncFileEngine, AsyncIoError};
 pub use self::sync_io::{SyncFileEngine, SyncIoError};
+use crate::device_manager::mmio::MMIO_LEN;
 use crate::devices::virtio::block::virtio::PendingRequest;
 use crate::devices::virtio::block::virtio::device::FileEngineType;
 use crate::vstate::memory::{GuestAddress, GuestMemoryMmap};
@@ -75,7 +78,7 @@ impl FileEngine {
         Ok(())
     }
 
-    #[cfg(test)]
+
     pub fn file(&self) -> &File {
         match self {
             FileEngine::Async(engine) => engine.file(),
@@ -172,6 +175,31 @@ impl FileEngine {
             FileEngine::Sync(engine) => engine.flush().map_err(BlockIoError::Sync),
         }
     }
+
+    pub fn discard(
+        &mut self,
+        offset: u64,
+        count: u32,
+        req: PendingRequest,
+    ) -> Result<FileEngineOk, RequestError<BlockIoError>> {
+
+        match self {
+            FileEngine::Async(engine) => match engine.push_discard(offset, count, req) {
+                Ok(_) => Ok(FileEngineOk::Submitted),
+                Err(err) => Err(RequestError {
+                    req: err.req,
+                    error: BlockIoError::Async(err.error),
+                }),
+            },
+            FileEngine::Sync(engine) => match engine.discard(offset,count) {
+                Ok(count) => Ok(FileEngineOk::Executed(RequestOk { req, count })),
+                Err(err) => Err(RequestError {
+                    req,
+                    error: BlockIoError::Sync(err),
+                }),
+            },
+        }
+    }
 }
 
 #[cfg(test)]

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

@@ -3,6 +3,8 @@
 
 use std::fs::File;
 use std::io::{Seek, SeekFrom, Write};
+use libc::{c_int, off64_t, FALLOC_FL_KEEP_SIZE, FALLOC_FL_PUNCH_HOLE};
+use std::os::unix::io::AsRawFd;
 
 use vm_memory::{GuestMemoryError, ReadVolatile, WriteVolatile};
 
@@ -18,6 +20,8 @@ pub enum SyncIoError {
     SyncAll(std::io::Error),
     /// Transfer: {0}
     Transfer(GuestMemoryError),
+    /// Discard: {0}
+    Discard(std::io::Error)
 }
 
 #[derive(Debug)]
@@ -33,7 +37,7 @@ impl SyncFileEngine {
         SyncFileEngine { file }
     }
 
-    #[cfg(test)]
+
     pub fn file(&self) -> &File {
         &self.file
     }
@@ -81,4 +85,29 @@ impl SyncFileEngine {
         // Sync data out to physical media on host.
         self.file.sync_all().map_err(SyncIoError::SyncAll)
     }
+
+    pub fn discard(&mut self, offset: u64, len: u32) -> Result<u32, SyncIoError> {
+
+        unsafe {
+            let ret = libc::fallocate(
+                self.file.as_raw_fd(),
+                libc::FALLOC_FL_PUNCH_HOLE | libc::FALLOC_FL_KEEP_SIZE,
+                offset as i64,
+                len as i64,
+            );
+            if ret != 0 {
+                return Err(SyncIoError::Discard(std::io::Error::last_os_error()));
+            }
+        }
+        Ok(len)
+    }
+
+    pub fn fallocate(fd: c_int, mode: i32, offset: off64_t, len: off64_t) -> Result<(), std::io::Error> {
+        let ret: i32 = unsafe { libc::fallocate(fd, mode, offset, len) };
+        if ret == 0 {
+            Ok(())
+        } else {
+            Err(std::io::Error::last_os_error())
+        }
+    }
 }

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

@@ -157,6 +157,8 @@ pub struct BlockDeviceMetrics {
     pub invalid_reqs_count: SharedIncMetric,
     /// Number of flushes operation triggered on this block device.
     pub flush_count: SharedIncMetric,
+    /// Number of discard operation triggered on this block device.
+    pub discard_count: SharedIncMetric,
     /// Number of events triggered on the queue of this block device.
     pub queue_event_count: SharedIncMetric,
     /// Number of events ratelimiter-related.
@@ -210,6 +212,7 @@ impl BlockDeviceMetrics {
         self.invalid_reqs_count
             .add(other.invalid_reqs_count.fetch_diff());
         self.flush_count.add(other.flush_count.fetch_diff());
+        self.discard_count.add(other.discard_count.fetch_diff());
         self.queue_event_count
             .add(other.queue_event_count.fetch_diff());
         self.rate_limiter_event_count

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

@@ -63,4 +63,12 @@ pub enum VirtioBlockError {
     RateLimiter(std::io::Error),
     /// Persistence error: {0}
     Persist(crate::devices::virtio::persist::PersistError),
+    /// Sector overflow in discard segment
+    SectorOverflow,
+    /// Discard segment exceeds disk size
+    BeyondDiskSize,
+    /// Invalid flags in discard segment
+    InvalidDiscardFlags,
+    /// Invalid discard request (e.g., empty segments)
+    InvalidDiscardRequest,
 }