refactor: rename vmm::io_uring::bindings to vmm::io_uring::gen

This is the last step we need to make sure that all bindgen generated
things are inside modules called "gen".

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

Author: roypat

src/vmm/src/io_uring/bindings.rs renamed to src/vmm/src/io_uring/gen.rs

@@ -4,7 +4,7 @@
 #![warn(missing_docs)]
 
 #[allow(clippy::undocumented_unsafe_blocks)]
-mod bindings;
+mod gen;
 pub mod operation;
 mod probe;
 mod queue;
@@ -16,7 +16,7 @@ use std::fs::File;
 use std::io::Error as IOError;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 
-use bindings::io_uring_params;
+use gen::io_uring_params;
 use operation::{Cqe, FixedFd, OpCode, Operation};
 use probe::{ProbeWrapper, PROBE_LEN};
 pub use queue::completion::CQueueError;
@@ -112,7 +112,7 @@ impl<T: Debug> IoUring<T> {
     ) -> Result<Self, IoUringError> {
         let mut params = io_uring_params {
             // Create the ring as disabled, so that we may register restrictions.
-            flags: bindings::IORING_SETUP_R_DISABLED,
+            flags: gen::IORING_SETUP_R_DISABLED,
 
             ..Default::default()
         };
@@ -252,7 +252,7 @@ impl<T: Debug> IoUring<T> {
             libc::syscall(
                 libc::SYS_io_uring_register,
                 self.fd.as_raw_fd(),
-                bindings::IORING_REGISTER_ENABLE_RINGS,
+                gen::IORING_REGISTER_ENABLE_RINGS,
                 std::ptr::null::<libc::c_void>(),
                 0,
             )
@@ -277,7 +277,7 @@ impl<T: Debug> IoUring<T> {
             libc::syscall(
                 libc::SYS_io_uring_register,
                 self.fd.as_raw_fd(),
-                bindings::IORING_REGISTER_FILES,
+                gen::IORING_REGISTER_FILES,
                 files
                     .iter()
                     .map(|f| f.as_raw_fd())
@@ -301,7 +301,7 @@ impl<T: Debug> IoUring<T> {
             libc::syscall(
                 libc::SYS_io_uring_register,
                 self.fd.as_raw_fd(),
-                bindings::IORING_REGISTER_EVENTFD,
+                gen::IORING_REGISTER_EVENTFD,
                 (&fd) as *const _,
                 1,
             )
@@ -320,10 +320,10 @@ impl<T: Debug> IoUring<T> {
             libc::syscall(
                 libc::SYS_io_uring_register,
                 self.fd.as_raw_fd(),
-                bindings::IORING_REGISTER_RESTRICTIONS,
+                gen::IORING_REGISTER_RESTRICTIONS,
                 restrictions
                     .iter()
-                    .map(bindings::io_uring_restriction::from)
+                    .map(gen::io_uring_restriction::from)
                     .collect::<Vec<_>>()
                     .as_mut_slice()
                     .as_mut_ptr(),
@@ -341,7 +341,7 @@ impl<T: Debug> IoUring<T> {
         // An alternative fix would be to keep an internal counter that tracks the number of
         // submitted entries that haven't been completed and makes sure it doesn't exceed
         // (2 * num_entries).
-        if (params.features & bindings::IORING_FEAT_NODROP) == 0 {
+        if (params.features & gen::IORING_FEAT_NODROP) == 0 {
             return Err(IoUringError::UnsupportedFeature("IORING_FEAT_NODROP"));
         }
 
@@ -356,7 +356,7 @@ impl<T: Debug> IoUring<T> {
             libc::syscall(
                 libc::SYS_io_uring_register,
                 self.fd.as_raw_fd(),
-                bindings::IORING_REGISTER_PROBE,
+                gen::IORING_REGISTER_PROBE,
                 probes.as_mut_fam_struct_ptr(),
                 PROBE_LEN,
             )
@@ -367,7 +367,7 @@ impl<T: Debug> IoUring<T> {
         let supported_opcodes: HashSet<u8> = probes
             .as_slice()
             .iter()
-            .filter(|op| ((u32::from(op.flags)) & bindings::IO_URING_OP_SUPPORTED) != 0)
+            .filter(|op| ((u32::from(op.flags)) & gen::IO_URING_OP_SUPPORTED) != 0)
             .map(|op| op.op)
             .collect();
 

src/vmm/src/io_uring/mod.rs

@@ -3,7 +3,7 @@
 
 use std::fmt::Debug;
 
-use crate::io_uring::bindings::io_uring_cqe;
+use crate::io_uring::gen::io_uring_cqe;
 use crate::vstate::memory::ByteValued;
 
 // SAFETY: Struct is POD and contains no references or niches.

src/vmm/src/io_uring/operation/cqe.rs

@@ -12,7 +12,7 @@ use std::fmt::{self, Debug};
 pub use cqe::Cqe;
 pub(crate) use sqe::Sqe;
 
-use crate::io_uring::bindings::{self, io_uring_sqe, IOSQE_FIXED_FILE_BIT};
+use crate::io_uring::gen::{self, io_uring_sqe, IOSQE_FIXED_FILE_BIT};
 
 /// The index of a registered fd.
 pub type FixedFd = u32;
@@ -24,11 +24,11 @@ pub type FixedFd = u32;
 /// Supported operation types.
 pub enum OpCode {
     /// Read operation.
-    Read = bindings::IORING_OP_READ as u8,
+    Read = gen::IORING_OP_READ as u8,
     /// Write operation.
-    Write = bindings::IORING_OP_WRITE as u8,
+    Write = gen::IORING_OP_WRITE as u8,
     /// Fsync operation.
-    Fsync = bindings::IORING_OP_FSYNC as u8,
+    Fsync = gen::IORING_OP_FSYNC as u8,
 }
 
 // Useful for outputting errors.
@@ -120,7 +120,7 @@ impl<T: Debug> Operation<T> {
     // Needed for proptesting.
     #[cfg(test)]
     pub(crate) fn set_linked(&mut self) {
-        self.flags |= 1 << bindings::IOSQE_IO_LINK_BIT;
+        self.flags |= 1 << gen::IOSQE_IO_LINK_BIT;
     }
 
     /// Transform the operation into an `Sqe`.

src/vmm/src/io_uring/operation/mod.rs

@@ -3,7 +3,7 @@
 
 use std::fmt::{self};
 
-use crate::io_uring::bindings::io_uring_sqe;
+use crate::io_uring::gen::io_uring_sqe;
 use crate::vstate::memory::ByteValued;
 
 // SAFETY: Struct is POD and contains no references or niches.

src/vmm/src/io_uring/operation/sqe.rs

@@ -4,7 +4,7 @@
 use utils::fam::{FamStruct, FamStructWrapper};
 use utils::generate_fam_struct_impl;
 
-use crate::io_uring::bindings::{io_uring_probe, io_uring_probe_op};
+use crate::io_uring::gen::{io_uring_probe, io_uring_probe_op};
 
 // There is no max for the number of operations returned by probing. So we fallback to using the
 // number of values representable in a u8;

src/vmm/src/io_uring/probe.rs

@@ -9,7 +9,7 @@ use std::sync::atomic::Ordering;
 use vm_memory::{Bytes, VolatileMemory, VolatileMemoryError};
 
 use super::mmap::{mmap, MmapError};
-use crate::io_uring::bindings;
+use crate::io_uring::gen;
 use crate::io_uring::operation::Cqe;
 use crate::vstate::memory::MmapRegion;
 
@@ -43,15 +43,15 @@ pub(crate) struct CompletionQueue {
 impl CompletionQueue {
     pub(crate) fn new(
         io_uring_fd: RawFd,
-        params: &bindings::io_uring_params,
+        params: &gen::io_uring_params,
     ) -> Result<Self, CQueueError> {
         let offsets = params.cq_off;
 
         // Map the CQ_ring. The actual size of the ring is `num_entries * size_of(entry_type)`.
         // To this we add an offset as per the io_uring specifications.
         let ring_size = (params.cq_off.cqes as usize)
-            + (params.cq_entries as usize) * std::mem::size_of::<bindings::io_uring_cqe>();
-        let cqes = mmap(ring_size, io_uring_fd, bindings::IORING_OFF_CQ_RING.into())?;
+            + (params.cq_entries as usize) * std::mem::size_of::<gen::io_uring_cqe>();
+        let cqes = mmap(ring_size, io_uring_fd, gen::IORING_OFF_CQ_RING.into())?;
 
         let ring = cqes.as_volatile_slice();
         let ring_mask = ring.read_obj(offsets.ring_mask as usize)?;
@@ -86,8 +86,8 @@ impl CompletionQueue {
 
         // validate that we have smth to fetch
         if Wrapping(unmasked_tail) - self.unmasked_head > Wrapping(0) {
-            let cqe: bindings::io_uring_cqe = ring.read_obj(
-                self.cqes_off + (head as usize) * std::mem::size_of::<bindings::io_uring_cqe>(),
+            let cqe: gen::io_uring_cqe = ring.read_obj(
+                self.cqes_off + (head as usize) * std::mem::size_of::<gen::io_uring_cqe>(),
             )?;
 
             // increase the head

src/vmm/src/io_uring/queue/completion.rs

@@ -12,7 +12,7 @@ use utils::syscall::SyscallReturnCode;
 use vm_memory::{VolatileMemory, VolatileMemoryError};
 
 use super::mmap::{mmap, MmapError};
-use crate::io_uring::bindings;
+use crate::io_uring::gen;
 use crate::io_uring::operation::Sqe;
 use crate::vstate::memory::{Bytes, MmapRegion};
 
@@ -54,7 +54,7 @@ pub(crate) struct SubmissionQueue {
 impl SubmissionQueue {
     pub(crate) fn new(
         io_uring_fd: RawFd,
-        params: &bindings::io_uring_params,
+        params: &gen::io_uring_params,
     ) -> Result<Self, SQueueError> {
         let (ring, sqes) = Self::mmap(io_uring_fd, params)?;
         let ring_slice = ring.as_volatile_slice();
@@ -99,10 +99,11 @@ impl SubmissionQueue {
         }
 
         // retrieve and populate the sqe
-        if let Err(err) = self.sqes.as_volatile_slice().write_obj(
-            sqe.0,
-            (tail as usize) * mem::size_of::<bindings::io_uring_sqe>(),
-        ) {
+        if let Err(err) = self
+            .sqes
+            .as_volatile_slice()
+            .write_obj(sqe.0, (tail as usize) * mem::size_of::<gen::io_uring_sqe>())
+        {
             return Err((SQueueError::VolatileMemory(err), sqe.user_data()));
         }
 
@@ -128,7 +129,7 @@ impl SubmissionQueue {
         let mut flags = 0;
 
         if min_complete > 0 {
-            flags |= bindings::IORING_ENTER_GETEVENTS;
+            flags |= gen::IORING_ENTER_GETEVENTS;
         }
         // SAFETY: Safe because values are valid and we check the return value.
         let submitted = SyscallReturnCode(unsafe {
@@ -154,28 +155,19 @@ impl SubmissionQueue {
 
     fn mmap(
         io_uring_fd: RawFd,
-        params: &bindings::io_uring_params,
+        params: &gen::io_uring_params,
     ) -> Result<(MmapRegion, MmapRegion), SQueueError> {
         // map the SQ_ring. The actual size of the ring is `num_entries * size_of(entry_type)`.
         // To this we add an offset as per the io_uring specifications.
         let sqe_ring_size =
             (params.sq_off.array as usize) + (params.sq_entries as usize) * mem::size_of::<u32>();
 
-        let sqe_ring = mmap(
-            sqe_ring_size,
-            io_uring_fd,
-            bindings::IORING_OFF_SQ_RING.into(),
-        )?;
+        let sqe_ring = mmap(sqe_ring_size, io_uring_fd, gen::IORING_OFF_SQ_RING.into())?;
 
         // map the SQEs.
-        let sqes_array_size =
-            (params.sq_entries as usize) * mem::size_of::<bindings::io_uring_sqe>();
+        let sqes_array_size = (params.sq_entries as usize) * mem::size_of::<gen::io_uring_sqe>();
 
-        let sqes = mmap(
-            sqes_array_size,
-            io_uring_fd,
-            bindings::IORING_OFF_SQES.into(),
-        )?;
+        let sqes = mmap(sqes_array_size, io_uring_fd, gen::IORING_OFF_SQES.into())?;
 
         Ok((sqe_ring, sqes))
     }

src/vmm/src/io_uring/queue/submission.rs

@@ -12,7 +12,7 @@
 
 use std::convert::From;
 
-use crate::io_uring::bindings;
+use crate::io_uring::gen;
 use crate::io_uring::operation::OpCode;
 
 /// Adds support for restricting the operations allowed by io_uring.
@@ -24,7 +24,7 @@ pub enum Restriction {
     RequireFixedFds,
 }
 
-impl From<&Restriction> for bindings::io_uring_restriction {
+impl From<&Restriction> for gen::io_uring_restriction {
     fn from(restriction: &Restriction) -> Self {
         use Restriction::*;
 
@@ -33,13 +33,13 @@ impl From<&Restriction> for bindings::io_uring_restriction {
 
         match restriction {
             AllowOpCode(opcode) => {
-                instance.opcode = u16::try_from(bindings::IORING_RESTRICTION_SQE_OP).unwrap();
+                instance.opcode = u16::try_from(gen::IORING_RESTRICTION_SQE_OP).unwrap();
                 instance.__bindgen_anon_1.sqe_op = *opcode as u8;
             }
             RequireFixedFds => {
                 instance.opcode =
-                    u16::try_from(bindings::IORING_RESTRICTION_SQE_FLAGS_REQUIRED).unwrap();
-                instance.__bindgen_anon_1.sqe_flags = 1 << bindings::IOSQE_FIXED_FILE_BIT;
+                    u16::try_from(gen::IORING_RESTRICTION_SQE_FLAGS_REQUIRED).unwrap();
+                instance.__bindgen_anon_1.sqe_flags = 1 << gen::IOSQE_FIXED_FILE_BIT;
             }
         };
 

src/vmm/src/io_uring/restriction.rs

@@ -153,7 +153,7 @@ fc-bindgen \
     --allowlist-type "io_uring_.+" \
     --allowlist-type "io_.qring_offsets" \
     "amazonlinux-v5.10.y/include/uapi/linux/io_uring.h" \
-    >src/vmm/src/io_uring/bindings.rs
+    >src/vmm/src/io_uring/gen.rs
 
 # Apply any patches
 info "Apply patches"