style: fix Python formatting and lint issues

LDagnachew · LDagnachew · commit 8fd863fbbbde · 2026-01-06T01:26:44.000Z
Update Python files to comply with Black and pylint checks. These
changes are formatting-only and do not alter functionality.

Signed-off-by: LDagnachew &lt;leulmdagnachew@gmail.com&gt;
diff --git a/src/vmm/src/devices/virtio/block/virtio/device.rs b/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_DISCARD,
+    VIRTIO_BLK_F_DISCARD, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_RO, VIRTIO_BLK_ID_BYTES,
 };
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::generated::virtio_ids::VIRTIO_ID_BLOCK;
@@ -298,7 +298,9 @@ impl VirtioBlock {
             .map_err(VirtioBlockError::RateLimiter)?
             .unwrap_or_default();
 
-        let mut avail_features = (1u64 << VIRTIO_F_VERSION_1) | (1u64 << VIRTIO_RING_F_EVENT_IDX) | (1u64 << VIRTIO_BLK_F_DISCARD);
+        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;
diff --git a/src/vmm/src/devices/virtio/block/virtio/io/async_io.rs b/src/vmm/src/devices/virtio/block/virtio/io/async_io.rs
@@ -238,18 +238,13 @@ impl AsyncFileEngine {
         let wrapped_user_data = WrappedRequest::new(req);
 
         self.ring
-            .push(Operation::fallocate(
-                0,
-                len,
-                offset,
-                wrapped_user_data,
-            ))
+            .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)
     }
diff --git a/src/vmm/src/devices/virtio/block/virtio/io/mod.rs b/src/vmm/src/devices/virtio/block/virtio/io/mod.rs
@@ -6,9 +6,10 @@ 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;
 
+use libc::{FALLOC_FL_KEEP_SIZE, FALLOC_FL_PUNCH_HOLE, c_int, off64_t};
+
 pub use self::async_io::{AsyncFileEngine, AsyncIoError};
 pub use self::sync_io::{SyncFileEngine, SyncIoError};
 use crate::device_manager::mmio::MMIO_LEN;
@@ -78,7 +79,6 @@ impl FileEngine {
         Ok(())
     }
 
-
     pub fn file(&self) -> &File {
         match self {
             FileEngine::Async(engine) => engine.file(),
@@ -182,7 +182,6 @@ impl FileEngine {
         count: u32,
         req: PendingRequest,
     ) -> Result<FileEngineOk, RequestError<BlockIoError>> {
-
         match self {
             FileEngine::Async(engine) => match engine.push_discard(offset, count, req) {
                 Ok(_) => Ok(FileEngineOk::Submitted),
@@ -191,7 +190,7 @@ impl FileEngine {
                     error: BlockIoError::Async(err.error),
                 }),
             },
-            FileEngine::Sync(engine) => match engine.discard(offset,count) {
+            FileEngine::Sync(engine) => match engine.discard(offset, count) {
                 Ok(count) => Ok(FileEngineOk::Executed(RequestOk { req, count })),
                 Err(err) => Err(RequestError {
                     req,
diff --git a/src/vmm/src/devices/virtio/block/virtio/io/sync_io.rs b/src/vmm/src/devices/virtio/block/virtio/io/sync_io.rs
@@ -3,9 +3,9 @@
 
 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 libc::{FALLOC_FL_KEEP_SIZE, FALLOC_FL_PUNCH_HOLE, c_int, off64_t};
 use vm_memory::{GuestMemoryError, ReadVolatile, WriteVolatile};
 
 use crate::vstate::memory::{GuestAddress, GuestMemory, GuestMemoryMmap};
@@ -21,7 +21,7 @@ pub enum SyncIoError {
     /// Transfer: {0}
     Transfer(GuestMemoryError),
     /// Discard: {0}
-    Discard(std::io::Error)
+    Discard(std::io::Error),
 }
 
 #[derive(Debug)]
@@ -37,7 +37,6 @@ impl SyncFileEngine {
         SyncFileEngine { file }
     }
 
-
     pub fn file(&self) -> &File {
         &self.file
     }
@@ -87,13 +86,27 @@ impl SyncFileEngine {
     }
 
     pub fn discard(&mut self, offset: u64, len: u32) -> Result<u32, SyncIoError> {
-
+        // Do checked conversion to avoid possible wrap/cast issues on 64-bit systems.
+        let off_i64 = i64::try_from(offset).map_err(|_| {
+            SyncIoError::Discard(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "offset overflow",
+            ))
+        })?;
+
+        let len_i64: i64 = len.into();
+
+        // SAFETY: calling libc::fallocate is safe here because:
+        // - `self.file.as_raw_fd()` is a valid file descriptor owned by this struct,
+        // - `off_i64` and `len_i64` are validated copies of the incoming unsigned values converted
+        //   to the C `off64_t` type, and
+        // - the syscall is properly checked for an error return value.
         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,
+                off_i64,
+                len_i64,
             );
             if ret != 0 {
                 return Err(SyncIoError::Discard(std::io::Error::last_os_error()));
@@ -102,7 +115,14 @@ impl SyncFileEngine {
         Ok(len)
     }
 
-    pub fn fallocate(fd: c_int, mode: i32, offset: off64_t, len: off64_t) -> Result<(), std::io::Error> {
+    pub fn fallocate(
+        fd: c_int,
+        mode: i32,
+        offset: off64_t,
+        len: off64_t,
+    ) -> Result<(), std::io::Error> {
+        // SAFETY: calling libc::fallocate is safe because we're passing plain C-compatible
+        // integer types (fd, mode, offset, len) and we check the integer return value.
         let ret: i32 = unsafe { libc::fallocate(fd, mode, offset, len) };
         if ret == 0 {
             Ok(())
diff --git a/src/vmm/src/devices/virtio/block/virtio/request.rs b/src/vmm/src/devices/virtio/block/virtio/request.rs
@@ -15,13 +15,13 @@ use crate::devices::virtio::block::virtio::device::DiskProperties;
 use crate::devices::virtio::block::virtio::metrics::BlockDeviceMetrics;
 pub use crate::devices::virtio::generated::virtio_blk::{
     VIRTIO_BLK_ID_BYTES, VIRTIO_BLK_S_IOERR, VIRTIO_BLK_S_OK, VIRTIO_BLK_S_UNSUPP,
-    VIRTIO_BLK_T_FLUSH, VIRTIO_BLK_T_GET_ID, VIRTIO_BLK_T_IN, VIRTIO_BLK_T_OUT,
-    VIRTIO_BLK_T_DISCARD
+    VIRTIO_BLK_T_DISCARD, VIRTIO_BLK_T_FLUSH, VIRTIO_BLK_T_GET_ID, VIRTIO_BLK_T_IN,
+    VIRTIO_BLK_T_OUT,
 };
 use crate::devices::virtio::queue::DescriptorChain;
 use crate::logger::{IncMetric, error};
 use crate::rate_limiter::{RateLimiter, TokenType};
-use crate::vstate::memory::{ByteValued, Bytes, GuestAddress, GuestMemoryMmap, Address};
+use crate::vstate::memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemoryMmap};
 
 #[derive(Debug, derive_more::From)]
 pub enum IoErr {
@@ -249,6 +249,8 @@ pub struct DiscardSegment {
     num_sectors: u32,
     flags: u32,
 }
+// SAFETY: Safe because `DiscardSegment` only contains plain data (POD) with no padding-dependent
+// invariants.
 unsafe impl ByteValued for DiscardSegment {}
 
 #[derive(Debug, PartialEq, Eq)]
@@ -279,7 +281,7 @@ impl Request {
             data_addr: GuestAddress(0),
             data_len: 0,
             status_addr: GuestAddress(0),
-            discard_segments: None
+            discard_segments: None,
         };
 
         let data_desc;
@@ -341,27 +343,30 @@ impl Request {
             }
             RequestType::Discard => {
                 // Validate data length
-                let segment_size = std::mem::size_of::<DiscardSegment>() as u32;
-                if data_desc.len % segment_size != 0 {
+                let segment_size = std::mem::size_of::<DiscardSegment>();
+                if (data_desc.len as usize) % segment_size != 0 {
                     return Err(VirtioBlockError::InvalidDataLength);
                 }
 
                 // Calculate number of segments
-                let num_segments = data_desc.len / segment_size;
+                let num_segments = (data_desc.len as usize) / segment_size;
                 if num_segments == 0 {
                     return Err(VirtioBlockError::InvalidDiscardRequest);
                 }
-                let mut segments = Vec::with_capacity(num_segments as usize);
+                let mut segments = Vec::with_capacity(num_segments);
 
                 // Populate DiscardSegments vector
                 for i in 0..num_segments {
                     let offset = i * segment_size;
-                    let segment: DiscardSegment = mem.read_obj(data_desc.addr.unchecked_add(offset as u64))
+                    let segment: DiscardSegment = mem
+                        .read_obj(data_desc.addr.unchecked_add(offset as u64))
                         .map_err(VirtioBlockError::GuestMemory)?;
                     if segment.flags & !0x1 != 0 {
                         return Err(VirtioBlockError::InvalidDiscardFlags);
                     }
-                    let end_sector = segment.sector.checked_add(segment.num_sectors as u64)
+                    let end_sector = segment
+                        .sector
+                        .checked_add(segment.num_sectors as u64)
                         .ok_or(VirtioBlockError::SectorOverflow)?;
                     if end_sector > num_disk_sectors {
                         return Err(VirtioBlockError::BeyondDiskSize);
@@ -372,7 +377,8 @@ impl Request {
                 // Assign to req.discard_segments
                 req.discard_segments = Some(segments);
                 req.data_len = data_desc.len;
-                status_desc = data_desc.next_descriptor()
+                status_desc = data_desc
+                    .next_descriptor()
                     .ok_or(VirtioBlockError::DescriptorChainTooShort)?;
                 if !status_desc.is_write_only() {
                     return Err(VirtioBlockError::UnexpectedReadOnlyDescriptor);
diff --git a/src/vmm/src/io_uring/operation/mod.rs b/src/vmm/src/io_uring/operation/mod.rs
@@ -116,6 +116,7 @@ impl<T: Debug> Operation<T> {
         }
     }
 
+    /// Construct a fallocate operation.
     pub fn fallocate(fd: FixedFd, len: u32, offset: u64, user_data: T) -> Self {
         Self {
             fd,
@@ -127,7 +128,7 @@ impl<T: Debug> Operation<T> {
             user_data,
         }
     }
-    
+
     pub(crate) fn fd(&self) -> FixedFd {
         self.fd
     }
diff --git a/tests/integration_tests/functional/test_discard.py b/tests/integration_tests/functional/test_discard.py
@@ -1,5 +1,10 @@
-import pytest
+# ...existing code...
+# Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Integration test for discard (VIRTIO_BLK_T_DISCARD)."""
+
 import os
+
 import host_tools.drive as drive_tools
 
 
@@ -30,9 +35,11 @@ def test_discard_support(uvm_plain_rw):
 
     vm.ssh.run("mount -o remount,discard /")
     exit_code, stdout, _ = vm.ssh.run("mount | grep /dev/vda")
-    assert exit_code == 0, f"Failed to remount root filesystem with discard option: {stdout}"
+    assert (
+        exit_code == 0
+    ), f"Failed to remount root filesystem with discard option: {stdout}"
 
     exit_code, stdout, _ = vm.ssh.run("fstrim -v /")
     assert exit_code == 0, f"fstrim -v failed: {stdout}"
     assert "trimmed" in stdout, f"Unexpected fstrim output: {stdout}"
-    vm.kill()
+    vm.kill()

Original file line number	Diff line number	Diff line change
`@@ -116,6 +116,7 @@ impl<T: Debug> Operation<T> {`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
	`119`	`+ /// Construct a fallocate operation.`
`119`	`120`	`pub fn fallocate(fd: FixedFd, len: u32, offset: u64, user_data: T) -> Self {`
`120`	`121`	`Self {`
`121`	`122`	`fd,`
`@@ -127,7 +128,7 @@ impl<T: Debug> Operation<T> {`
`127`	`128`	`user_data,`
`128`	`129`	`}`
`129`	`130`	`}`
`130`		`-`
	`131`	`+`
`131`	`132`	`pub(crate) fn fd(&self) -> FixedFd {`
`132`	`133`	`self.fd`
`133`	`134`	`}`