iommufd-ioctls: Add ioctl wrappers for vIOMMU/vDevice operations

Extend the iommufd ioctl wrapper library to enable userspace VMMs to
build virtual IOMMU that can leverage hardware IOMMU acceleration.

Added ioctl wrappers:
- IOMMU_DESTROY: Generic destruction of iommufd objects
- IOMMU_HWPT_ALLOC: Allocate hardware page tables for nested translation
- IOMMUFD_GET_HW_INFO: Query physical IOMMU hardware capabilities
- IOMMUFD_HWPT_INVALIDATE: Invalidate cached page table entries
- IOMMU_VIOMMU_ALLOC: Allocate virtual IOMMU instances backed by hardware
- IOMMU_VDEVICE_ALLOC: Allocate virtual devices under a vIOMMU

By exposing these hardware-accelerated operations to userspace, VMMs can
implement nested IOMMU virtualization where the physical IOMMU hardware
directly processes guest page tables, eliminating expensive emulation and
VM exits for IOMMU operations.

Signed-off-by: Bo Chen <bchen@crusoe.ai>

Author: likebreath

iommufd-ioctls/src/iommufd_ioctls.rs

@@ -26,16 +26,46 @@ impl IommuFd {
         Ok(IommuFd { iommufd })
     }
 
+    pub fn destroy_iommufd(&self, id: u32) -> Result<()> {
+        let destroy_data = iommu_destroy {
+            size: std::mem::size_of::<iommu_destroy>() as u32,
+            id,
+            ..Default::default()
+        };
+        iommufd_syscall::destroy_iommufd(self, &destroy_data)
+    }
+
     pub fn alloc_iommu_ioas(&self, alloc_data: &mut iommu_ioas_alloc) -> Result<()> {
         iommufd_syscall::alloc_iommu_ioas(self, alloc_data)
     }
 
     pub fn map_iommu_ioas(&self, map: &iommu_ioas_map) -> Result<()> {
         iommufd_syscall::map_iommu_ioas(self, map)
     }
+
     pub fn unmap_iommu_ioas(&self, unmap: &mut iommu_ioas_unmap) -> Result<()> {
         iommufd_syscall::unmap_iommu_ioas(self, unmap)
     }
+
+    pub fn alloc_iommu_hwpt(&self, hwpt_alloc: &mut iommu_hwpt_alloc) -> Result<()> {
+        iommufd_syscall::alloc_iommu_hwpt(self, hwpt_alloc)
+    }
+
+    pub fn get_hw_info(&self, hw_info: &mut iommu_hw_info) -> Result<()> {
+        iommufd_syscall::get_hw_info(self, hw_info)
+    }
+
+    pub fn invalidate_hwpt(&self, hwpt_invalidate: &mut iommu_hwpt_invalidate) -> Result<()> {
+        iommufd_syscall::invalidate_hwpt(self, hwpt_invalidate)
+    }
+
+    pub fn alloc_iommu_viommu(&self, viommu_alloc: &mut iommu_viommu_alloc) -> Result<()> {
+        iommufd_syscall::alloc_iommu_viommu(self, viommu_alloc)
+    }
+
+    pub fn alloc_iommu_vdevice(&self, vdevice_alloc: &mut iommu_vdevice_alloc) -> Result<()> {
+        iommufd_syscall::alloc_iommu_vdevice(self, vdevice_alloc)
+    }
 }
 
 impl AsRawFd for IommuFd {
@@ -44,6 +74,7 @@ impl AsRawFd for IommuFd {
     }
 }
 
+ioctl_io_nr!(IOMMU_DESTROY, IOMMUFD_TYPE as u32, IOMMUFD_CMD_DESTROY);
 ioctl_io_nr!(
     IOMMU_IOAS_ALLOC,
     IOMMUFD_TYPE as u32,
@@ -55,6 +86,31 @@ ioctl_io_nr!(
     IOMMUFD_TYPE as u32,
     IOMMUFD_CMD_IOAS_UNMAP
 );
+ioctl_io_nr!(
+    IOMMU_HWPT_ALLOC,
+    IOMMUFD_TYPE as u32,
+    IOMMUFD_CMD_HWPT_ALLOC
+);
+ioctl_io_nr!(
+    IOMMUFD_GET_HW_INFO,
+    IOMMUFD_TYPE as u32,
+    IOMMUFD_CMD_GET_HW_INFO
+);
+ioctl_io_nr!(
+    IOMMUFD_HWPT_INVALIDATE,
+    IOMMUFD_TYPE as u32,
+    IOMMUFD_CMD_HWPT_INVALIDATE
+);
+ioctl_io_nr!(
+    IOMMU_VIOMMU_ALLOC,
+    IOMMUFD_TYPE as u32,
+    IOMMUFD_CMD_VIOMMU_ALLOC
+);
+ioctl_io_nr!(
+    IOMMU_VDEVICE_ALLOC,
+    IOMMUFD_TYPE as u32,
+    IOMMUFD_CMD_VDEVICE_ALLOC
+);
 
 // Safety:
 // - absolutely trust the underlying kernel
@@ -64,6 +120,19 @@ pub(crate) mod iommufd_syscall {
     use super::*;
     use vmm_sys_util::ioctl::{ioctl_with_mut_ref, ioctl_with_ref};
 
+    pub(crate) fn destroy_iommufd(iommufd: &IommuFd, destroy_data: &iommu_destroy) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'destroy_data' points to initialized memory with expected data structure,
+        // and remains valid for the duration of sysca
+        // 3. The return value is checked.
+        let ret = unsafe { ioctl_with_ref(iommufd, IOMMU_DESTROY(), destroy_data) };
+        if ret < 0 {
+            Err(IommufdError::IommuDestroy(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
     pub(crate) fn alloc_iommu_ioas(
         iommufd: &IommuFd,
         alloc_data: &mut iommu_ioas_alloc,
@@ -94,6 +163,7 @@ pub(crate) mod iommufd_syscall {
             Ok(())
         }
     }
+
     pub(crate) fn unmap_iommu_ioas(iommufd: &IommuFd, unmap: &mut iommu_ioas_unmap) -> Result<()> {
         // SAFETY:
         // 1. The file descriptor provided by 'iommufd' is valid and open.
@@ -107,6 +177,89 @@ pub(crate) mod iommufd_syscall {
             Ok(())
         }
     }
+
+    pub(crate) fn alloc_iommu_hwpt(
+        iommufd: &IommuFd,
+        hwpt_alloc: &mut iommu_hwpt_alloc,
+    ) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'hwpt_alloc' points to initialized memory with expected data structure,
+        // and remains valid for the duration of syscall.
+        // 3. The return value is checked.
+        let ret = unsafe { ioctl_with_mut_ref(iommufd, IOMMU_HWPT_ALLOC(), hwpt_alloc) };
+        if ret < 0 {
+            Err(IommufdError::IommuHwptAlloc(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn get_hw_info(iommufd: &IommuFd, hw_info: &mut iommu_hw_info) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'hw_info' points to initialized memory with expected data structure,
+        // and remains valid for the duration of syscall.
+        // 3. The return value is checked.
+        let ret = unsafe { ioctl_with_mut_ref(iommufd, IOMMUFD_GET_HW_INFO(), hw_info) };
+        if ret < 0 {
+            Err(IommufdError::IommuGetHwInfo(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn invalidate_hwpt(
+        iommufd: &IommuFd,
+        hwpt_invalidate: &mut iommu_hwpt_invalidate,
+    ) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'hwpt_invalidate' points to initialized memory with expected data structure,
+        // and remains valid for the duration of syscall.
+        // 3. The return value is checked.
+        let ret =
+            unsafe { ioctl_with_mut_ref(iommufd, IOMMUFD_HWPT_INVALIDATE(), hwpt_invalidate) };
+        if ret < 0 {
+            Err(IommufdError::IommuHwptInvalidate(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn alloc_iommu_viommu(
+        iommufd: &IommuFd,
+        viommu_alloc: &mut iommu_viommu_alloc,
+    ) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'viommu_alloc' points to initialized memory with expected data structure,
+        // and remains valid for the duration of syscall.
+        // 3. The return value is checked.
+        let ret = unsafe { ioctl_with_mut_ref(iommufd, IOMMU_VIOMMU_ALLOC(), viommu_alloc) };
+        if ret < 0 {
+            Err(IommufdError::IommuViommuAlloc(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(crate) fn alloc_iommu_vdevice(
+        iommufd: &IommuFd,
+        vdevice_alloc: &mut iommu_vdevice_alloc,
+    ) -> Result<()> {
+        // SAFETY:
+        // 1. The file descriptor provided by 'iommufd' is valid and open.
+        // 2. The 'vdevice_alloc' points to initialized memory with expected data structure,
+        // and remains valid for the duration of syscall.
+        // 3. The return value is checked.
+        let ret = unsafe { ioctl_with_mut_ref(iommufd, IOMMU_VDEVICE_ALLOC(), vdevice_alloc) };
+        if ret < 0 {
+            Err(IommufdError::IommuVdeviceAlloc(SysError::last()))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -115,8 +268,14 @@ mod tests {
 
     #[test]
     fn test_iommufd_ioctl_code() {
+        assert_eq!(IOMMU_DESTROY(), 15232);
         assert_eq!(IOMMU_IOAS_ALLOC(), 15233);
         assert_eq!(IOMMU_IOAS_MAP(), 15237);
         assert_eq!(IOMMU_IOAS_UNMAP(), 15238);
+        assert_eq!(IOMMU_HWPT_ALLOC(), 15241);
+        assert_eq!(IOMMUFD_GET_HW_INFO(), 15242);
+        assert_eq!(IOMMUFD_HWPT_INVALIDATE(), 15245);
+        assert_eq!(IOMMU_VIOMMU_ALLOC(), 15248);
+        assert_eq!(IOMMU_VDEVICE_ALLOC(), 15249);
     }
 }

iommufd-ioctls/src/lib.rs

@@ -18,12 +18,24 @@ pub use iommufd_ioctls::*;
 pub enum IommufdError {
     #[error("failed to open /dev/iommufd: {0}")]
     OpenIommufd(#[source] io::Error),
+    #[error("failed to destroy iommufd: {0}")]
+    IommuDestroy(#[source] SysError),
     #[error("failed to allocate IOAS: {0}")]
     IommuIoasAlloc(#[source] SysError),
     #[error("failed to map an IOVA range to the IOAS: {0}")]
     IommuIoasMap(#[source] SysError),
     #[error("failed to unmap an IOVA range from the IOAS: {0}")]
     IommuIoasUnmap(#[source] SysError),
+    #[error("failed to allocate HWPT: {0}")]
+    IommuHwptAlloc(#[source] SysError),
+    #[error("failed to allocate vIOMMU: {0}")]
+    IommuViommuAlloc(#[source] SysError),
+    #[error("failed to allocate vDevice: {0}")]
+    IommuVdeviceAlloc(#[source] SysError),
+    #[error("failed to get HW info: {0}")]
+    IommuGetHwInfo(#[source] SysError),
+    #[error("failed to invalidate HWPT: {0}")]
+    IommuHwptInvalidate(#[source] SysError),
 }
 
 pub type Result<T> = std::result::Result<T, IommufdError>;