Subsystems (6)
From da51b9fedb4a9da22d33ee30ef6d871282e449a0 Mon Sep 17 00:00:00 2001
From: Jacob Pan <[email protected]>
Date: Thu, 2 Apr 2026 21:52:05 -0700
Subject: [PATCH V3 00/10] iommufd: Enable noiommu mode for cdev
VFIO's unsafe_noiommu_mode has long provided a way for userspace drivers to operate on platforms lacking a hardware IOMMU. Today, IOMMUFD also supports No-IOMMU mode for group-based devices under vfio_compat mode. However, IOMMUFD's native character device (cdev) does not yet support No-IOMMU mode, which is the purpose of this patch.
In summary, we have:
|-------------------------+------+---------------| | Device access mode | VFIO | IOMMUFD | |-------------------------+------+---------------| | group /dev/vfio/$GROUP | Yes | Yes | |-------------------------+------+---------------| | cdev /dev/vfio/devices/ | No | This patch | |-------------------------+------+---------------|
Beyond enabling cdev for IOMMUFD, this patch also addresses the following deficiencies in the current No-IOMMU mode suggested by Jason[1]:
- Devices operating under No-IOMMU mode are limited to device-level UAPI access, without container or IOAS-level capabilities. Consequently, user-space drivers lack structured mechanisms for page pinning and often resort to mlock(), which is less robust than pin_user_pages() used for devices backed by a physical IOMMU. For example, mlock() does not prevent page migration.
- There is no architectural mechanism for obtaining physical addresses for DMA. As a workaround, user-space drivers frequently rely on /proc/pagemap tricks or hardcoded values.
By allowing noiommu device access to IOMMUFD IOAS and HWPT objects, this patch brings No-IOMMU mode closer to full citizenship within the IOMMU subsystem. In addition to addressing the two deficiencies mentioned above, the expectation is that it will also enable No-IOMMU devices to seamlessly participate in live update sessions via KHO [2].
Furthermore, these devices will use the IOMMUFD-based ownership checking model for VFIO_DEVICE_PCI_HOT_RESET, eliminating the need for an iommufd_access object as required in a previous attempt [3].
ChangeLog:
V3:
- Improve error handling [3/10] (Mostafa)
- Simplify vfio_device_is_noiommu logic and merged in [6/10] (Mostafa)
- Fix build dependency on !GENERIC_ATOMIC64
- Add comment to explain the design difference over the legacy noiommu VFIO code.[1/10]
V2:
- Fix build dependency by adding IOMMU_SUPPORT in [8/11]
- Add an optimization to scan beyond the first page for a contiguous physical address range and return its length instead of a single page.[4/11]
Since RFC[4]:
- Abandoned dummy iommu driver approach as patch 1-3 absorbed the changes into iommufd.
[1] https://lore.kernel.org/linux-iommu/[email protected]/
[2] https://lore.kernel.org/linux-pci/[email protected]/
[3] https://lore.kernel.org/kvm/[email protected]/
[4] https://lore.kernel.org/linux-iommu/[email protected]/
Thanks,
Jacob
Jacob Pan (7):
iommufd: Add an ioctl IOMMU_IOAS_GET_PA to query PA from IOVA
vfio: Allow null group for noiommu without containers
vfio: Introduce and set noiommu flag on vfio_device
vfio: Enable cdev noiommu mode under iommufd vfio:selftest: Handle VFIO noiommu cdev selftests/vfio: Add iommufd noiommu mode selftest for cdev
Documentation: Update VFIO NOIOMMU mode
Jason Gunthorpe (3):
iommufd: Support a HWPT without an iommu driver for noiommu
iommufd: Move igroup allocation to a function
iommufd: Allow binding to a noiommu device
Documentation/driver-api/vfio.rst | 45 +- drivers/iommu/iommufd/Makefile | 1 + drivers/iommu/iommufd/device.c | 169 ++++-- drivers/iommu/iommufd/hw_pagetable.c | 11 +- drivers/iommu/iommufd/hwpt_noiommu.c | 102 ++++ drivers/iommu/iommufd/io_pagetable.c | 60 ++ drivers/iommu/iommufd/ioas.c | 25 + drivers/iommu/iommufd/iommufd_private.h | 5 + drivers/iommu/iommufd/main.c | 3 + drivers/vfio/Kconfig | 8 +- drivers/vfio/group.c | 35 +- drivers/vfio/iommufd.c | 7 - drivers/vfio/vfio.h | 28 +- drivers/vfio/vfio_main.c | 22 +- include/linux/vfio.h | 10 + include/uapi/linux/iommufd.h | 25 + tools/testing/selftests/vfio/Makefile | 1 + .../lib/include/libvfio/vfio_pci_device.h | 1 + .../selftests/vfio/lib/vfio_pci_device.c | 32 +- .../vfio/vfio_iommufd_noiommu_test.c | 549 ++++++++++++++++++ .../vfio/vfio_pci_liveupdate_kexec_test.c | 9 + 21 files changed, 1054 insertions(+), 94 deletions(-) create mode 100644 drivers/iommu/iommufd/hwpt_noiommu.c create mode 100644 tools/testing/selftests/vfio/vfio_iommufd_noiommu_test.c
Signature · 1 line
2.34.1
PATCH v3 1/10 iommufd: Support a HWPT without an iommu driver for noiommu
From: Jason Gunthorpe <[email protected]>
Create just a little part of a real iommu driver, enough to slot in under the dev_iommu_ops() and allow iommufd to call domain_alloc_paging_flags() and fail everything else.
This allows explicitly creating a HWPT under an IOAS.
---
v3:
- Add comment to explain the design difference over the legacy noiommu VFIO code.
--- drivers/iommu/iommufd/Makefile | 1 + drivers/iommu/iommufd/hw_pagetable.c | 11 ++- drivers/iommu/iommufd/hwpt_noiommu.c | 102 ++++++++++++++++++++++++ drivers/iommu/iommufd/iommufd_private.h | 2 + 4 files changed, 114 insertions(+), 2 deletions(-) create mode 100644 drivers/iommu/iommufd/hwpt_noiommu.c
drivers/iommu/iommufd/Makefile +1 -0
@@ -10,6 +10,7 @@ iommufd-y := \ vfio_compat.o \ viommu.o +iommufd-$(CONFIG_VFIO_NOIOMMU) += hwpt_noiommu.o iommufd-$(CONFIG_IOMMUFD_TEST) += selftest.o obj-$(CONFIG_IOMMUFD) += iommufd.o
drivers/iommu/iommufd/hw_pagetable.c +9 -2
@@ -8,6 +8,13 @@#include "../iommu-priv.h" #include "iommufd_private.h" +static const struct iommu_ops *get_iommu_ops (struct iommufd_device *idev) +{ +if (IS_ENABLED (CONFIG_VFIO_NOIOMMU ) && !idev->igroup->group) +return &iommufd_noiommu_ops; +return dev_iommu_ops (idev->dev); +} +static void __iommufd_hwpt_destroy (struct iommufd_hw_pagetable *hwpt) {if (hwpt->domain)
@@ -114,7 +121,7 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas,IOMMU_HWPT_ALLOC_DIRTY_TRACKING |IOMMU_HWPT_FAULT_ID_VALID |IOMMU_HWPT_ALLOC_PASID ; -const struct iommu_ops *ops =dev_iommu_ops (idev->dev); +const struct iommu_ops *ops =get_iommu_ops (idev);struct iommufd_hwpt_paging *hwpt_paging;struct iommufd_hw_pagetable *hwpt;int rc;
@@ -229,7 +236,7 @@ iommufd_hwpt_nested_alloc(struct iommufd_ctx *ictx, struct iommufd_device *idev, u32 flags, const struct iommu_user_data *user_data) { - const struct iommu_ops *ops = dev_iommu_ops(idev->dev); + const struct iommu_ops *ops = get_iommu_ops(idev);struct iommufd_hwpt_nested *hwpt_nested;struct iommufd_hw_pagetable *hwpt;int rc;
drivers/iommu/iommufd/hwpt_noiommu.c new file +102 -0
102 lines not on this page · raw message
drivers/iommu/iommufd/iommufd_private.h +2 -0
@@ -464,6 +464,8 @@ static inline void iommufd_hw_pagetable_put(struct iommufd_ctx *ictx,refcount_dec (&hwpt->obj.users); } +extern struct iommu_ops iommufd_noiommu_ops; +struct iommufd_attach ;struct iommufd_group {
Signature · 1 line
2.34.1
PATCH v3 2/10 iommufd: Move igroup allocation to a function
In reply to Jacob PanFrom: Jason Gunthorpe <[email protected]>
So it can be reused in the next patch which allows binding to noiommu device.
---
v3:
- Moved null group check out to the next patch (Mostafa)
--- drivers/iommu/iommufd/device.c | 43 +++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 16 deletions(-)
drivers/iommu/iommufd/device.c +27 -16
@@ -56,6 +56,30 @@ static bool iommufd_group_try_get(struct iommufd_group *igroup,return kref_get_unless_zero (&igroup->ref); } +static struct iommufd_group *iommufd_alloc_group (struct iommufd_ctx *ictx, +struct iommu_group *group) +{ +struct iommufd_group *new_igroup; + + new_igroup =kzalloc (sizeof (*new_igroup),GFP_KERNEL ); +if (!new_igroup) +return ERR_PTR (-ENOMEM ); + +kref_init (&new_igroup->ref); +mutex_init (&new_igroup->lock); +xa_init (&new_igroup->pasid_attach); + new_igroup->sw_msi_start =PHYS_ADDR_MAX ; +/* group reference moves into new_igroup */ + new_igroup->group = group; + +/* +* The ictx is not additionally refcounted here becase all objects using +* an igroup must put it before their destroy completes. +*/ + new_igroup->ictx = ictx; +return new_igroup; +} +/* * iommufd needs to store some more data for each iommu_group, we keep a * parallel xarray indexed by iommu_group id to hold this instead of putting it
@@ -87,25 +111,12 @@ static struct iommufd_group *iommufd_get_group(struct iommufd_ctx *ictx, }xa_unlock (&ictx->groups); - new_igroup =kzalloc_obj (*new_igroup); -if (!new_igroup) { + new_igroup =iommufd_alloc_group (ictx, group); +if (IS_ERR (new_igroup)) {iommu_group_put (group); -return ERR_PTR (-ENOMEM ); +return new_igroup; } -kref_init (&new_igroup->ref); -mutex_init (&new_igroup->lock); -xa_init (&new_igroup->pasid_attach); - new_igroup->sw_msi_start =PHYS_ADDR_MAX ; -/* group reference moves into new_igroup */ - new_igroup->group = group; - -/* -* The ictx is not additionally refcounted here becase all objects using -* an igroup must put it before their destroy completes. -*/ - new_igroup->ictx = ictx; -/* * We dropped the lock so igroup is invalid. NULL is a safe and likely * value to assume for the xa_cmpxchg algorithm.
Signature · 1 line
2.34.1
PATCH v3 3/10 iommufd: Allow binding to a noiommu device
In reply to Jacob PanFrom: Jason Gunthorpe <[email protected]>
Allow iommufd to bind devices without an IOMMU (noiommu mode) by creating a dummy IOMMU group for such devices and skipping hwpt operations.
This enables noiommu devices to operate through the same iommufd API as IOMMU- capable devices.
---
v3:
- handle new error cases iommufd_device_bind. (Mostafa)
--- drivers/iommu/iommufd/device.c | 126 +++++++++++++++++++++++---------- 1 file changed, 87 insertions(+), 39 deletions(-)
drivers/iommu/iommufd/device.c +87 -39
@@ -23,6 +23,11 @@ struct iommufd_attach {struct xarray device_array; }; +static bool is_vfio_noiommu (struct iommufd_device *idev) +{ +return !device_iommu_mapped (idev->dev) || !idev->dev->iommu; +} +static void iommufd_group_release (struct kref *kref) { struct iommufd_group *igroup =
@@ -30,9 +35,11 @@ static void iommufd_group_release(struct kref *kref)WARN_ON (!xa_empty (&igroup->pasid_attach)); -xa_cmpxchg (&igroup->ictx->groups,iommu_group_id (igroup->group), igroup, -NULL ,GFP_KERNEL ); -iommu_group_put (igroup->group); +if (igroup->group) { +xa_cmpxchg (&igroup->ictx->groups,iommu_group_id (igroup->group), + igroup,NULL ,GFP_KERNEL ); +iommu_group_put (igroup->group); + }mutex_destroy (&igroup->lock);kfree (igroup); }
@@ -204,32 +211,17 @@ void iommufd_device_destroy(struct iommufd_object *obj)struct iommufd_device *idev = container_of(obj, struct iommufd_device, obj); -iommu_device_release_dma_owner (idev->dev); +if (!is_vfio_noiommu (idev)) +iommu_device_release_dma_owner (idev->dev);iommufd_put_group (idev->igroup);if (!iommufd_selftest_is_mock_dev (idev->dev))iommufd_ctx_put (idev->ictx); } -/** -* iommufd_device_bind - Bind a physical device to an iommu fd -* @ictx: iommufd file descriptor -* @dev: Pointer to a physical device struct -* @id: Output ID number to return to userspace for this device -* -* A successful bind establishes an ownership over the device and returns -* struct iommufd_device pointer, otherwise returns error pointer. -* -* A driver using this API must set driver_managed_dma and must not touch -* the device until this routine succeeds and establishes ownership. -* -* Binding a PCI device places the entire RID under iommufd control. -* -* The caller must undo this with iommufd_device_unbind() -*/ -struct iommufd_device *iommufd_device_bind (struct iommufd_ctx *ictx, -struct device *dev,u32 *id) +static int iommufd_bind_iommu (struct iommufd_device *idev) { -struct iommufd_device *idev; +struct iommufd_ctx *ictx = idev->ictx; +struct device *dev = idev->dev;struct iommufd_group *igroup;int rc;
@@ -238,11 +230,11 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx,* to restore cache coherency. */ if (!device_iommu_capable (dev,IOMMU_CAP_CACHE_COHERENCY )) -return ERR_PTR (-EINVAL ); +return -EINVAL ; - igroup =iommufd_get_group (ictx, dev); + igroup =iommufd_get_group (idev->ictx, dev);if (IS_ERR (igroup)) -return ERR_CAST (igroup); +return PTR_ERR (igroup);/* * For historical compat with VFIO the insecure interrupt path is
@@ -268,21 +260,69 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx,if (rc) goto out_group_put; +/* igroup refcount moves into iommufd_device */ + idev->igroup = igroup; +return 0 ; + +out_group_put: +iommufd_put_group (igroup); +return rc; +} + +/** +* iommufd_device_bind - Bind a physical device to an iommu fd +* @ictx: iommufd file descriptor +* @dev: Pointer to a physical device struct +* @id: Output ID number to return to userspace for this device +* +* A successful bind establishes an ownership over the device and returns +* struct iommufd_device pointer, otherwise returns error pointer. +* +* A driver using this API must set driver_managed_dma and must not touch +* the device until this routine succeeds and establishes ownership. +* +* Binding a PCI device places the entire RID under iommufd control. +* +* The caller must undo this with iommufd_device_unbind() +*/ +struct iommufd_device *iommufd_device_bind (struct iommufd_ctx *ictx, +struct device *dev,u32 *id) +{ +struct iommufd_device *idev; +int rc; + idev =iommufd_object_alloc (ictx, idev,IOMMUFD_OBJ_DEVICE ); -if (IS_ERR (idev)) { - rc =PTR_ERR (idev); - goto out_release_owner; - } +if (IS_ERR (idev)) +return idev; + idev->ictx = ictx; -if (!iommufd_selftest_is_mock_dev (dev)) -iommufd_ctx_get (ictx); idev->dev = dev; idev->enforce_cache_coherency =device_iommu_capable (dev,IOMMU_CAP_ENFORCE_CACHE_COHERENCY ); + +if (!is_vfio_noiommu (idev)) { + rc =iommufd_bind_iommu (idev); +if (rc) + goto err_out; + }else { +struct iommufd_group *igroup; + +/* +* Create a dummy igroup, lots of stuff expects ths igroup to be +* present, but a NULL igroup->group is OK +*/ + igroup =iommufd_alloc_group (ictx,NULL ); +if (IS_ERR (igroup)) { + rc =PTR_ERR (igroup); + goto err_out; + } + idev->igroup = igroup; + } + +if (!iommufd_selftest_is_mock_dev (dev)) +iommufd_ctx_get (ictx);/* The calling driver is a user until iommufd_device_unbind() */ refcount_inc (&idev->obj.users); -/* igroup refcount moves into iommufd_device */ - idev->igroup = igroup;/* * If the caller fails after this success it must call
@@ -294,11 +334,10 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, *id = idev->obj.id;return idev; -out_release_owner: -iommu_device_release_dma_owner (dev); -out_group_put: -iommufd_put_group (igroup); +err_out: +iommufd_object_abort_and_destroy (ictx, &idev->obj);return ERR_PTR (rc); + }EXPORT_SYMBOL_NS_GPL (iommufd_device_bind,"IOMMUFD" );
@@ -512,6 +551,9 @@ static int iommufd_hwpt_attach_device(struct iommufd_hw_pagetable *hwpt,struct iommufd_attach_handle *handle;int rc; +if (is_vfio_noiommu (idev)) +return 0 ; +if (!iommufd_hwpt_compatible_device (hwpt, idev))return -EINVAL ;
@@ -559,6 +601,9 @@ static void iommufd_hwpt_detach_device(struct iommufd_hw_pagetable *hwpt, {struct iommufd_attach_handle *handle; +if (is_vfio_noiommu (idev)) +return ; + handle =iommufd_device_get_attach_handle (idev, pasid);if (pasid ==IOMMU_NO_PASID )iommu_detach_group_handle (hwpt->domain, idev->igroup->group);
@@ -577,6 +622,9 @@ static int iommufd_hwpt_replace_device(struct iommufd_device *idev,struct iommufd_attach_handle *handle, *old_handle;int rc; +if (is_vfio_noiommu (idev)) +return 0 ; +if (!iommufd_hwpt_compatible_device (hwpt, idev))return -EINVAL ;
@@ -652,7 +700,7 @@ int iommufd_hw_pagetable_attach(struct iommufd_hw_pagetable *hwpt, goto err_release_devid; } -if (attach_resv) { +if (attach_resv && !is_vfio_noiommu (idev)) { rc =iommufd_device_attach_reserved_iova (idev, hwpt_paging);if (rc) goto err_release_devid;
Signature · 1 line
2.34.1
Jason Gunthorpe
maintainerRe: [PATCH V3 03/10] iommufd: Allow binding to a noiommu device
Quoted 20 lines · Jacob Pan
From: Jason Gunthorpe <[email protected]>
Allow iommufd to bind devices without an IOMMU (noiommu mode) by creating a dummy IOMMU group for such devices and skipping hwpt operations.
This enables noiommu devices to operate through the same iommufd API as IOMMU- capable devices.
Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Jacob Pan <[email protected]>---
v3:
- handle new error casesiommufd_device_bind. (Mostafa)--- drivers/iommu/iommufd/device.c | 126 +++++++++++++++++++++++---------- 1 file changed, 87 insertions(+), 39 deletions(-)
drivers/iommu/iommufd/device.c struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, · line 339
Quoted 10 lines
drivers/iommu/iommufd/device.c +2
-4@@ -294,11 +334,10 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, *id = idev->obj.id;return idev; -out_release_owner: -iommu_device_release_dma_owner (dev); -out_group_put: -iommufd_put_group (igroup); +err_out: +iommufd_object_abort_and_destroy (ictx, &idev->obj);return ERR_PTR (rc);
I fed this to Sashiko and it pointed out the abort flow here will call iommufd_device_destroy() bit it isn't prepared to handle a partially initialized idev. It looks like igroup is only set once it is sufficiently initialized so:
@@ -211,6 +211,8 @@ void iommufd_device_destroy(struct iommufd_object *obj)
struct iommufd_device *idev =
container_of(obj, struct iommufd_device, obj);
+ if (!idev->igroup)
+ return;
if (!is_vfio_noiommu(idev))
iommu_device_release_dma_owner(idev->dev);
iommufd_put_group(idev->igroup);Should fix it, but lets add a comment because it is pretty fragile:
@@ -335,6 +337,10 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx,
return idev;
err_out:
+ /*
+ * Be careful that iommufd_device_destroy() can handle partial
+ * initialization.
+ */
iommufd_object_abort_and_destroy(ictx, &idev->obj);
return ERR_PTR(rc);Jason
Re: [PATCH V3 03/10] iommufd: Allow binding to a noiommu device
Hi Jason,
Quoted 52 lines · On Thu, 9 Apr 2026 14:06:57 -0300 Jason Gunthorpe <[email protected]> wrote:
Quoted 22 lines · Jacob Pan
From: Jason Gunthorpe <[email protected]>
Allow iommufd to bind devices without an IOMMU (noiommu mode) by creating a dummy IOMMU group for such devices and skipping hwpt operations.
This enables noiommu devices to operate through the same iommufd API as IOMMU- capable devices.
Signed-off-by Jason Gunthorpe <[email protected]>Signed-off-by Jacob Pan <[email protected]>---
v3:
- handle new error casesiommufd_device_bind. (Mostafa)--- drivers/iommu/iommufd/device.c | 126+++++++++++++++++++++++---------- 1 file changed, 87 insertions(+), 39 deletions(-)
drivers/iommu/iommufd/device.c struct iommufd_device · line 339
Quoted 10 lines
drivers/iommu/iommufd/device.c +2
-4@@ -294,11 +334,10 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, *id = idev->obj.id;return idev; -out_release_owner: -iommu_device_release_dma_owner (dev); -out_group_put: -iommufd_put_group (igroup); +err_out: +iommufd_object_abort_and_destroy (ictx, &idev->obj);return ERR_PTR (rc);I fed this to Sashiko and it pointed out the abort flow here will call
iommufd_device_destroy()bit it isn't prepared to handle a partially initialized idev. It looks like igroup is only set once it is sufficiently initialized so:(quoted diff) +2
-0@@ -211,6 +211,8 @@ void iommufd_device_destroy(struct iommufd_object *obj) struct iommufd_device *idev = container_of(obj, struct iommufd_device, obj); + if (!idev->igroup) + return; if (!is_vfio_noiommu(idev)) iommu_device_release_dma_owner(idev->dev); iommufd_put_group(idev->igroup);Should fix it, but lets add a comment because it is pretty fragile:
Review struct iommufd_device · line 345
Quoted 9 lines
(quoted diff) +4
-0@@ -335,6 +337,10 @@ struct iommufd_device *iommufd_device_bind(struct iommufd_ctx *ictx, return idev; err_out: + /* + * Be careful that iommufd_device_destroy() can handle partial + * initialization. + */ iommufd_object_abort_and_destroy(ictx, &idev->obj); return ERR_PTR(rc);
Yeah, will add to the next version.
Tested the error path by faking a failed group allocation, works as expected.
# RUN vfio_noiommu.device_bind_iommufd ...
vfio_iommufd_noiommu_test.c:265:device_bind_iommufd:Expected 0 ) # device_bind_iommufd: Test terminated by assertion
# FAIL vfio_noiommu.device_bind_iommufd
not ok 17 vfio_noiommu.device_bind_iommufd
PATCH v3 4/10 iommufd: Add an ioctl IOMMU_IOAS_GET_PA to query PA from IOVA
In reply to Jacob PanTo support no-IOMMU mode where userspace drivers perform unsafe DMA using physical addresses, introduce a new API to retrieve the physical address of a user-allocated DMA buffer that has been mapped to an IOVA via IOAS. The mapping is backed by mock I/O page tables maintained by generic IOMMUPT framework.
---
v2:
- Scan the contiguous physical-address span beyond the first page and return its length.
--- drivers/iommu/iommufd/io_pagetable.c | 60 +++++++++++++++++++++++++ drivers/iommu/iommufd/ioas.c | 25 +++++++++++ drivers/iommu/iommufd/iommufd_private.h | 3 ++ drivers/iommu/iommufd/main.c | 3 ++ include/uapi/linux/iommufd.h | 25 +++++++++++ 5 files changed, 116 insertions(+)
drivers/iommu/iommufd/io_pagetable.c +60 -0
@@ -849,6 +849,66 @@ int iopt_unmap_iova(struct io_pagetable *iopt, unsigned long iova,return iopt_unmap_iova_range (iopt, iova, iova_last, unmapped); } +int iopt_get_phys (struct io_pagetable *iopt,unsigned long iova,u64 *paddr, +u64 *length) +{ +struct iopt_area *area; +u64 tmp_length =0 ; +u64 tmp_paddr =0 ; +int rc =0 ; + +if (!IS_ENABLED (CONFIG_VFIO_NOIOMMU )) +return -EOPNOTSUPP ; + +down_read (&iopt->iova_rwsem); + area =iopt_area_iter_first (iopt, iova, iova); +if (!area || !area->pages) { + rc = -ENOENT ; + goto unlock_exit; + } + +if (!area->storage_domain || + area->storage_domain->owner != &iommufd_noiommu_ops) { + rc = -EOPNOTSUPP ; + goto unlock_exit; + } + + *paddr =iommu_iova_to_phys (area->storage_domain, iova); +if (!*paddr) { + rc = -EINVAL ; + goto unlock_exit; + } + + tmp_length =PAGE_SIZE ; + tmp_paddr = *paddr; +/* +* Scan the domain for the contiguous physical address length so that +* userspace search can be optimized for fewer ioctls. +*/ +while (iova <iopt_area_last_iova (area)) { +unsigned long next_iova; +u64 next_paddr; + +if (check_add_overflow (iova,PAGE_SIZE , &next_iova)) +break ; + + next_paddr =iommu_iova_to_phys (area->storage_domain, next_iova); + +if (!next_paddr || next_paddr != tmp_paddr +PAGE_SIZE ) +break ; + + iova = next_iova; + tmp_paddr +=PAGE_SIZE ; + tmp_length +=PAGE_SIZE ; + } + *length = tmp_length; + +unlock_exit: +up_read (&iopt->iova_rwsem); + +return rc; +} +int iopt_unmap_all (struct io_pagetable *iopt,unsigned long *unmapped) {/* If the IOVAs are empty then unmap all succeeds */
drivers/iommu/iommufd/ioas.c +25 -0
@@ -375,6 +375,31 @@ int iommufd_ioas_unmap(struct iommufd_ucmd *ucmd)return rc; } +int iommufd_ioas_get_pa (struct iommufd_ucmd *ucmd) +{ +struct iommu_ioas_get_pa *cmd = ucmd->cmd; +struct iommufd_ioas *ioas; +int rc; + +if (cmd->flags || cmd->__reserved) +return -EOPNOTSUPP ; + + ioas =iommufd_get_ioas (ucmd->ictx, cmd->ioas_id); +if (IS_ERR (ioas)) +return PTR_ERR (ioas); + + rc =iopt_get_phys (&ioas->iopt, cmd->iova, &cmd->out_phys, + &cmd->out_length); +if (rc) + goto out_put; + + rc =iommufd_ucmd_respond (ucmd,sizeof (*cmd)); +out_put: +iommufd_put_object (ucmd->ictx, &ioas->obj); + +return rc; +} +static void iommufd_release_all_iova_rwsem (struct iommufd_ctx *ictx,struct xarray *ioas_list) {
drivers/iommu/iommufd/iommufd_private.h +3 -0
@@ -118,6 +118,8 @@ int iopt_map_pages(struct io_pagetable *iopt, struct list_head *pages_list,int iopt_unmap_iova (struct io_pagetable *iopt,unsigned long iova,unsigned long length,unsigned long *unmapped);int iopt_unmap_all (struct io_pagetable *iopt,unsigned long *unmapped); +int iopt_get_phys (struct io_pagetable *iopt,unsigned long iova,u64 *paddr, +u64 *length); int iopt_read_and_clear_dirty_data(struct io_pagetable *iopt, struct iommu_domain *domain,
@@ -346,6 +348,7 @@ int iommufd_ioas_map_file(struct iommufd_ucmd *ucmd);int iommufd_ioas_change_process (struct iommufd_ucmd *ucmd);int iommufd_ioas_copy (struct iommufd_ucmd *ucmd);int iommufd_ioas_unmap (struct iommufd_ucmd *ucmd); +int iommufd_ioas_get_pa (struct iommufd_ucmd *ucmd);int iommufd_ioas_option (struct iommufd_ucmd *ucmd);int iommufd_option_rlimit_mode (struct iommu_option *cmd,struct iommufd_ctx *ictx);
drivers/iommu/iommufd/main.c +3 -0
@@ -432,6 +432,7 @@ union ucmd_buffer {struct iommu_veventq_alloc veventq;struct iommu_vfio_ioas vfio_ioas;struct iommu_viommu_alloc viommu; +struct iommu_ioas_get_pa get_pa;#ifdef CONFIG_IOMMUFD_TEST struct iommu_test_cmd test;#endif
@@ -484,6 +485,8 @@ static const struct iommufd_ioctl_op iommufd_ioctl_ops[] = { struct iommu_ioas_map_file, iova),IOCTL_OP (IOMMU_IOAS_UNMAP ,iommufd_ioas_unmap ,struct iommu_ioas_unmap ,length ), +IOCTL_OP (IOMMU_IOAS_GET_PA ,iommufd_ioas_get_pa ,struct iommu_ioas_get_pa , +out_phys ),IOCTL_OP (IOMMU_OPTION ,iommufd_option ,struct iommu_option ,val64 ),IOCTL_OP (IOMMU_VDEVICE_ALLOC ,iommufd_vdevice_alloc_ioctl , struct iommu_vdevice_alloc, virt_id),
include/uapi/linux/iommufd.h +25 -0
@@ -57,6 +57,7 @@ enum {IOMMUFD_CMD_IOAS_CHANGE_PROCESS =0x92 ,IOMMUFD_CMD_VEVENTQ_ALLOC =0x93 ,IOMMUFD_CMD_HW_QUEUE_ALLOC =0x94 , + IOMMUFD_CMD_IOAS_GET_PA = 0x95, };/**
@@ -219,6 +220,30 @@ struct iommu_ioas_map { };#define IOMMU_IOAS_MAP _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_MAP) +/** +* struct iommu_ioas_get_pa - ioctl(IOMMU_IOAS_GET_PA) +* @size: sizeof(struct iommu_ioas_get_pa) +* @flags: Reserved, must be 0 for now +* @ioas_id: IOAS ID to query IOVA to PA mapping from +* @__reserved: Must be 0 +* @iova: IOVA to query +* @out_length: Number of bytes contiguous physical address starting from phys +* @out_phys: Output physical address the IOVA maps to +* +* Query the physical address backing an IOVA range. The entire range must be +* mapped already. For noiommu devices doing unsafe DMA only. +*/ +struct iommu_ioas_get_pa { +__u32 size; +__u32 flags; +__u32 ioas_id; +__u32 __reserved; +__aligned_u64 iova; +__aligned_u64 out_length; +__aligned_u64 out_phys; +}; +#define IOMMU_IOAS_GET_PA _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_GET_PA) +/** * struct iommu_ioas_map_file - ioctl(IOMMU_IOAS_MAP_FILE) * @size: sizeof(struct iommu_ioas_map_file)
Signature · 1 line
2.34.1
Jason Gunthorpe
maintainerRe: [PATCH V3 04/10] iommufd: Add an ioctl IOMMU_IOAS_GET_PA to query PA from IOVA
drivers/iommu/iommufd/io_pagetable.c int iopt_unmap_iova(struct io_pagetable *iopt, unsigned long iova, · line 883
Quoted 8 lines · Jacob Pan
drivers/iommu/iommufd/io_pagetable.c +8
-0+ *paddr =iommu_iova_to_phys (area->storage_domain, iova); +if (!*paddr) { + rc = -EINVAL ; + goto unlock_exit; + } + + tmp_length =PAGE_SIZE ; + tmp_paddr = *paddr;
shashiko also points out that the length is too long if IOVA is unaligned. We adjust the phys for unaligned IOVA but not the length:
@@ -879,7 +879,7 @@ int iopt_get_phys(struct io_pagetable *iopt, unsigned long iova, u64 *paddr,
goto unlock_exit;
}- tmp_length = PAGE_SIZE;
+ tmp_length = PAGE_SIZE - offset_in_page(iova);
tmp_paddr = *paddr;
/*
* Scan the domain for the contiguous physical address length so thatJason
Re: [PATCH V3 04/10] iommufd: Add an ioctl IOMMU_IOAS_GET_PA to query PA from IOVA
Hi Jason,
Quoted 14 lines · On Thu, 9 Apr 2026 15:26:24 -0300 Jason Gunthorpe <[email protected]> wrote:
drivers/iommu/iommufd/io_pagetable.c int iopt_unmap_iova(struct io_pagetable *iopt, unsigned long iova, · line 883
Quoted 8 lines · Jacob Pan
drivers/iommu/iommufd/io_pagetable.c +8
-0+ *paddr =iommu_iova_to_phys (area->storage_domain, iova); +if (!*paddr) { + rc = -EINVAL ; + goto unlock_exit; + } + + tmp_length =PAGE_SIZE ; + tmp_paddr = *paddr;shashiko also points out that the length is too long if IOVA is unaligned. We adjust the phys for unaligned IOVA but not the length:
Review int iopt_get_phys(struct io_pagetable *iopt, · line 882
Quoted 5 lines
(quoted diff) +1
-1@@ -879,7 +879,7 @@ int iopt_get_phys(struct io_pagetable *iopt, unsigned long iova, u64 *paddr, goto unlock_exit; } - tmp_length = PAGE_SIZE; + tmp_length = PAGE_SIZE - offset_in_page(iova);
Will fix and add an unaligned iova in selftestvfio_iommufd_noiommu_test.
Thanks,
Jacob
PATCH v3 5/10 vfio: Allow null group for noiommu without containers
In reply to Jacob PanIn case of noiommu mode is enabled for VFIO cdev without VFIO container nor IOMMUFD provided compatibility container, there is no need to create a dummy group. Update the group operations to tolerate null group pointer.
--- drivers/vfio/group.c | 14 ++++++++++++++ drivers/vfio/vfio.h | 17 +++++++++++++++++ 2 files changed, 31 insertions(+)
drivers/vfio/group.c +14 -0
@@ -390,6 +390,9 @@ int vfio_device_block_group(struct vfio_device *device)struct vfio_group *group = device->group;int ret =0 ; +if (vfio_null_group_allowed () && !group) +return 0 ; +mutex_lock (&group->group_lock);if (group->opened_file) { ret = -EBUSY ;
@@ -407,6 +410,9 @@ void vfio_device_unblock_group(struct vfio_device *device) {struct vfio_group *group = device->group; +if (vfio_null_group_allowed () && !group) +return ; +mutex_lock (&group->group_lock); group->cdev_device_open_cnt--;mutex_unlock (&group->group_lock);
@@ -598,6 +604,14 @@ static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev,struct vfio_group *group;int ret; +/* +* With noiommu enabled under cdev interface only, there is no need to +* create a vfio_group if the group based containers are not enabled. +* The cdev interface is exclusively used for iommufd. +*/ +if (vfio_null_group_allowed ()) +return NULL ; + iommu_group =iommu_group_alloc ();if (IS_ERR (iommu_group))return ERR_CAST (iommu_group);
drivers/vfio/vfio.h +17 -0
@@ -114,6 +114,18 @@ bool vfio_device_has_container(struct vfio_device *device);int __init vfio_group_init (void );void vfio_group_cleanup (void ); +/* +* With noiommu enabled and no containers are supported, allow devices that +* don't have a dummy group. +*/ +static inline bool vfio_null_group_allowed (void ) +{ +if (vfio_noiommu && (!IS_ENABLED (CONFIG_VFIO_CONTAINER ) && !IS_ENABLED (CONFIG_IOMMUFD_VFIO_CONTAINER ))) +return true; + +return false; +} +static inline bool vfio_device_is_noiommu (struct vfio_device *vdev) { return IS_ENABLED(CONFIG_VFIO_NOIOMMU) &&
@@ -190,6 +202,11 @@ static inline void vfio_group_cleanup(void) { } +static inline bool vfio_null_group_allowed (void ) +{ +return false; +} +static inline bool vfio_device_is_noiommu (struct vfio_device *vdev) {return false;
Signature · 1 line
2.34.1
Jason Gunthorpe
maintainerRe: [PATCH V3 05/10] vfio: Allow null group for noiommu without containers
drivers/vfio/group.c static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev, · line 613
Quoted 11 lines · Jacob Pan
drivers/vfio/group.c +7
-0@@ -598,6 +604,14 @@ static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev,struct vfio_group *group;int ret; +/* +* With noiommu enabled under cdev interface only, there is no need to +* create a vfio_group if the group based containers are not enabled. +* The cdev interface is exclusively used for iommufd. +*/ +if (vfio_null_group_allowed ()) +return NULL ;
Sashiko wondered if this causes a null pointer deref without pointing at a specific case. Claude found a case:
@@ -696,6 +696,9 @@ void vfio_device_remove_group(struct vfio_device *device)
struct vfio_group *group = device->group;
struct iommu_group *iommu_group;+ if (!group)
+ return;
+
if (group->type == VFIO_NO_IOMMU || group->type == VFIO_EMULATED_IOMMU)
iommu_group_remove_device(device->dev);Happens during error unwind in __vfio_register_dev()
It also points out that the hunks are weirdly split between this patch and "vfio: Enable cdev noiommu mode under iommufd" so that things are broken at this point.
I think you should pull the vfio_device_has_group() and related into this patch.
Jason
Re: [PATCH V3 05/10] vfio: Allow null group for noiommu without containers
Hi Jason,
Quoted 29 lines · On Thu, 9 Apr 2026 15:44:16 -0300 Jason Gunthorpe <[email protected]> wrote:
drivers/vfio/group.c static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev, · line 613
Quoted 13 lines · Jacob Pan
(quoted diff) +2
-0@@ -598,6 +604,14 @@ static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev, struct vfio_group *group; int ret; + /* + * With noiommu enabled under cdev interface only, thereis no need to
(quoted diff) +1
-0+ * create a vfio_group if the group based containers arenot enabled.
drivers/vfio/group.c +4
-0+* The cdev interface is exclusively used for iommufd. +*/ +if (vfio_null_group_allowed ()) +return NULL ;Sashiko wondered if this causes a null pointer deref without pointing at a specific case. Claude found a case:
(quoted diff) +3
-0@@ -696,6 +696,9 @@ void vfio_device_remove_group(struct vfio_device *device) struct vfio_group *group = device->group; struct iommu_group *iommu_group; + if (!group) + return; + if (group->type == VFIO_NO_IOMMU || group->type == VFIO_EMULATED_IOMMU) iommu_group_remove_device(device->dev);
Quoted 1 line
Happens during error unwind in
__vfio_register_dev()
will do.
Quoted 7 lines
It also points out that the hunks are weirdly split between this patch and "vfio: Enable cdev noiommu mode under iommufd" so that things are broken at this point.
I think you should pull the
vfio_device_has_group()and related into this patch.
makes sense, will regroup.
PATCH v3 6/10 vfio: Introduce and set noiommu flag on vfio_device
In reply to Jacob PanWhen a VFIO device is added to a noiommu group, set the noiommu flag on the vfio_device structure to indicate that the device operates in noiommu mode.
Also update function signatures to pass vfio_device instead of device, which has the direct access to the noiommu flag.
---
v3:
- Squashed with vfio noiommu logic check patch 7/11 of v2 (Mostafa)
--- drivers/vfio/group.c | 21 +++++++++++---------- drivers/vfio/vfio.h | 3 +-- include/linux/vfio.h | 1 + 3 files changed, 13 insertions(+), 12 deletions(-)
drivers/vfio/group.c +11 -10
@@ -597,7 +597,7 @@ static struct vfio_group *vfio_create_group(struct iommu_group *iommu_group,return ret; } -static struct vfio_group *vfio_noiommu_group_alloc (struct device *dev, +static struct vfio_group *vfio_noiommu_group_alloc (struct vfio_device *vdev,enum vfio_group_type type) {struct iommu_group *iommu_group;
@@ -619,7 +619,7 @@ static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev, ret =iommu_group_set_name (iommu_group,"vfio-noiommu" );if (ret) goto out_put_group; - ret =iommu_group_add_device (iommu_group, dev); + ret =iommu_group_add_device (iommu_group, vdev->dev);if (ret) goto out_put_group;
@@ -634,7 +634,7 @@ static struct vfio_group *vfio_noiommu_group_alloc(struct device *dev,return group; out_remove_device: -iommu_group_remove_device (dev); +iommu_group_remove_device (vdev->dev); out_put_group:iommu_group_put (iommu_group);return ERR_PTR (ret);
@@ -655,23 +655,24 @@ static bool vfio_group_has_device(struct vfio_group *group, struct device *dev)return false; } -static struct vfio_group *vfio_group_find_or_alloc (struct device *dev) +static struct vfio_group *vfio_group_find_or_alloc (struct vfio_device *vdev) {struct iommu_group *iommu_group;struct vfio_group *group; - iommu_group =iommu_group_get (dev); + iommu_group =iommu_group_get (vdev->dev);if (!iommu_group && vfio_noiommu) { + vdev->noiommu =1 ;/* * With noiommu enabled, create an IOMMU group for devices that * don't already have one, implying no IOMMU hardware/driver * exists. Taint the kernel because we're about to give a DMA * capable device to a user without IOMMU protection. */ - group =vfio_noiommu_group_alloc (dev,VFIO_NO_IOMMU ); + group =vfio_noiommu_group_alloc (vdev,VFIO_NO_IOMMU );if (!IS_ERR (group)) {add_taint (TAINT_USER ,LOCKDEP_STILL_OK ); -dev_warn (dev,"Adding kernel taint for vfio-noiommu group on device\n" ); +dev_warn (vdev->dev,"Adding kernel taint for vfio-noiommu group on device\n" ); }return group; }
@@ -682,7 +683,7 @@ static struct vfio_group *vfio_group_find_or_alloc(struct device *dev)mutex_lock (&vfio.group_lock); group =vfio_group_find_from_iommu (iommu_group);if (group) { -if (WARN_ON (vfio_group_has_device (group, dev))) +if (WARN_ON (vfio_group_has_device (group, vdev->dev))) group =ERR_PTR (-EINVAL );else refcount_inc (&group->drivers);
@@ -702,9 +703,9 @@ int vfio_device_set_group(struct vfio_device *device,struct vfio_group *group;if (type ==VFIO_IOMMU ) - group =vfio_group_find_or_alloc (device->dev); + group =vfio_group_find_or_alloc (device);else - group =vfio_noiommu_group_alloc (device->dev, type); + group =vfio_noiommu_group_alloc (device, type);if (IS_ERR (group))return PTR_ERR (group);
drivers/vfio/vfio.h +1 -2
@@ -128,8 +128,7 @@ static inline bool vfio_null_group_allowed(void)static inline bool vfio_device_is_noiommu (struct vfio_device *vdev) { -return IS_ENABLED (CONFIG_VFIO_NOIOMMU ) && - vdev->group->type ==VFIO_NO_IOMMU ; +return IS_ENABLED (CONFIG_VFIO_NOIOMMU ) && vdev->noiommu; }#else struct vfio_group ;
include/linux/vfio.h +1 -0
@@ -72,6 +72,7 @@ struct vfio_device { u8 iommufd_attached:1;#endif u8 cdev_opened:1; + u8 noiommu:1;#ifdef CONFIG_DEBUG_FS /* * debug_root is a static property of the vfio_device
Signature · 1 line
2.34.1
PATCH v3 7/10 vfio: Enable cdev noiommu mode under iommufd
In reply to Jacob PanNow that devices under noiommu mode can bind with IOMMUFD and perform IOAS operations, lift restrictions on cdev from VFIO side.
No IOMMU cdevs are explicitly named with noiommu prefix. e.g.
/dev/vfio/
|-- 7
|-- devices
| `-- noiommu-vfio0
`-- vfio---
v3:
- Add explict dependency on !GENERIC_ATOMIC64
v2:
- Fix build dependency on IOMMU_SUPPORT
--- drivers/vfio/Kconfig | 8 ++++++-- drivers/vfio/iommufd.c | 7 ------- drivers/vfio/vfio.h | 8 +------- drivers/vfio/vfio_main.c | 22 +++++++++++++++++++--- include/linux/vfio.h | 9 +++++++++ 5 files changed, 35 insertions(+), 19 deletions(-)
drivers/vfio/Kconfig +6 -2
@@ -22,8 +22,7 @@ config VFIO_DEVICE_CDEV The VFIO device cdev is another way for userspace to get device access. Userspace gets device fd by opening device cdev under /dev/vfio/devices/vfioX, and then bind the device fd with an iommufd - to set up secure DMA context for device access. This interface does - not support noiommu. + to set up secure DMA context for device access. If you don't know what to do here, say N.
@@ -63,6 +62,11 @@ endif config VFIO_NOIOMMU bool "VFIO No-IOMMU support" depends on VFIO_GROUP + depends on !GENERIC_ATOMIC64 # IOMMU_PT_AMDV1 requires cmpxchg64 + select GENERIC_PT + select IOMMU_PT + select IOMMU_PT_AMDV1 + depends on IOMMU_SUPPORT help VFIO is built on the ability to isolate devices using the IOMMU. Only with an IOMMU can userspace access to DMA capable devices be
drivers/vfio/iommufd.c +0 -7
@@ -25,10 +25,6 @@ int vfio_df_iommufd_bind(struct vfio_device_file *df)lockdep_assert_held (&vdev->dev_set->lock); -/* Returns 0 to permit device opening under noiommu mode */ -if (vfio_device_is_noiommu (vdev)) -return 0 ; -return vdev->ops->bind_iommufd (vdev, ictx, &df->devid); }
@@ -58,9 +54,6 @@ void vfio_df_iommufd_unbind(struct vfio_device_file *df)lockdep_assert_held (&vdev->dev_set->lock); -if (vfio_device_is_noiommu (vdev)) -return ; -if (vdev->ops->unbind_iommufd) vdev->ops->unbind_iommufd (vdev); }
drivers/vfio/vfio.h +1 -7
@@ -376,19 +376,13 @@ void vfio_init_device_cdev(struct vfio_device *device);static inline int vfio_device_add (struct vfio_device *device) { -/* cdev does not support noiommu device */ -if (vfio_device_is_noiommu (device)) -return device_add (&device->device);vfio_init_device_cdev (device);return cdev_device_add (&device->cdev, &device->device); }static inline void vfio_device_del (struct vfio_device *device) { -if (vfio_device_is_noiommu (device)) -device_del (&device->device); -else -cdev_device_del (&device->cdev, &device->device); +cdev_device_del (&device->cdev, &device->device); }int vfio_device_fops_cdev_open (struct inode *inode,struct file *filep);
drivers/vfio/vfio_main.c +19 -3
@@ -332,13 +332,15 @@ static int __vfio_register_dev(struct vfio_device *device,if (!device->dev_set)vfio_assign_device_set (device, device); - ret =dev_set_name (&device->device,"vfio%d" , device->index); + ret =vfio_device_set_group (device, type);if (ret)return ret; - ret =vfio_device_set_group (device, type); +/* Just to be safe, expose to user explicitly noiommu cdev node */ + ret =dev_set_name (&device->device,"%svfio%d" , + device->noiommu ?"noiommu-" :"" , device->index);if (ret) -return ret; + goto err_out;/* * VFIO always sets IOMMU_CACHE because we offer no way for userspace to
@@ -358,6 +360,10 @@ static int __vfio_register_dev(struct vfio_device *device,/* Refcounting can't start until the driver calls register */ refcount_set (&device->refcount,1 ); +/* noiommu device w/o container may have NULL group */ +if (vfio_device_is_noiommu (device) && !vfio_device_has_group (device)) +return 0 ; +vfio_device_group_register (device);vfio_device_debugfs_init (device);
@@ -392,6 +398,16 @@ void vfio_unregister_group_dev(struct vfio_device *device)bool interrupted = false;long rc; +/* +* For noiommu devices without a container, thus no dummy group, +* simply delete and unregister to balance refcount. +*/ +if (device->noiommu && !vfio_device_has_group (device)) { +vfio_device_del (device); +vfio_device_put_registration (device); +return ; + } +/* * Prevent new device opened by userspace via the * VFIO_GROUP_GET_DEVICE_FD in the group path.
include/linux/vfio.h +9 -0
@@ -329,6 +329,10 @@ struct iommu_group *vfio_file_iommu_group(struct file *file);#if IS_ENABLED (CONFIG_VFIO_GROUP )bool vfio_file_is_group (struct file *file);bool vfio_file_has_dev (struct file *file,struct vfio_device *device); +static inline bool vfio_device_has_group (struct vfio_device *device) +{ +return device->group; +}#else static inline bool vfio_file_is_group (struct file *file) {
@@ -339,6 +343,11 @@ static inline bool vfio_file_has_dev(struct file *file, struct vfio_device *devi {return false; } + +static inline bool vfio_device_has_group (struct vfio_device *device) +{ +return false; +}#endif bool vfio_file_is_valid (struct file *file);bool vfio_file_enforced_coherent (struct file *file);
Signature · 1 line
2.34.1
Jason Gunthorpe
maintainerRe: [PATCH V3 07/10] vfio: Enable cdev noiommu mode under iommufd
Quoted 4 lines · Jacob Pan
drivers/vfio/vfio_main.c +0
-0@@ -392,6 +398,16 @@ void vfio_unregister_group_dev(struct vfio_device *device)bool interrupted = false;long rc;
drivers/vfio/vfio_main.c void vfio_unregister_group_dev(struct vfio_device *device) · line 410
Quoted 10 lines
drivers/vfio/vfio_main.c +10
-0+/* +* For noiommu devices without a container, thus no dummy group, +* simply delete and unregister to balance refcount. +*/ +if (device->noiommu && !vfio_device_has_group (device)) { +vfio_device_del (device); +vfio_device_put_registration (device); +return ; + } +
Sashiko points out this can't just skip the waiting even for no-iommu mode, it isn't linked to groups and containers but the lifecylce of the open FD.
Maybe just stick a !group inside vfio_device_group_unregister() is sufficient?
Jason
Re: [PATCH V3 07/10] vfio: Enable cdev noiommu mode under iommufd
Hi Jason,
Quoted 21 lines · On Thu, 9 Apr 2026 15:48:41 -0300 Jason Gunthorpe <[email protected]> wrote:
Quoted 5 lines · Jacob Pan
drivers/vfio/vfio_main.c +1
-0@@ -392,6 +398,16 @@ void vfio_unregister_group_dev(struct vfio_device *device) bool interrupted = false;long rc; +/* drivers/vfio/vfio_main.c void vfio_unregister_group_dev(struct · line 411
Quoted 10 lines
drivers/vfio/vfio_main.c +9
-0+* For noiommu devices without a container, thus no dummy group, +* simply delete and unregister to balance refcount. +*/ +if (device->noiommu && !vfio_device_has_group (device)) { +vfio_device_del (device); +vfio_device_put_registration (device); +return ; + } +Sashiko points out this can't just skip the waiting even for no-iommu mode, it isn't linked to groups and containers but the lifecylce of the open FD.
Quoted 2 lines
Maybe just stick a !group inside
vfio_device_group_unregister()is sufficient?
Yes, will do.
Thanks,
Jacob
PATCH v3 8/10 vfio:selftest: Handle VFIO noiommu cdev
In reply to Jacob PanWith unsafe DMA noiommu mode, the vfio devices are prefixed with noiommu-, e.g./dev/vfio/
|-- devices | `-- noiommu-vfio0 |-- noiommu-0
`-- vfio
Let vfio tests, such as luo kexec test, accommodate the noiommu device files.
--- .../lib/include/libvfio/vfio_pci_device.h | 1 + .../selftests/vfio/lib/vfio_pci_device.c | 32 ++++++++++++++++--- .../vfio/vfio_pci_liveupdate_kexec_test.c | 9 ++++++ 3 files changed, 38 insertions(+), 4 deletions(-)
tools/testing/selftests/vfio/lib/include/libvfio/vfio_pci_device.h +1 -0
@@ -124,6 +124,7 @@ static inline bool vfio_pci_device_match(struct vfio_pci_device *device, }const char *vfio_pci_get_cdev_path (const char *bdf); +int vfio_pci_noiommu_mode_enabled (void );/* Low-level routines for setting up a struct vfio_pci_device */ struct vfio_pci_device *vfio_pci_device_alloc (const char *bdf,struct iommu *iommu);
tools/testing/selftests/vfio/lib/vfio_pci_device.c +28 -4
@@ -225,11 +225,14 @@ void vfio_pci_group_setup(struct vfio_pci_device *device)struct vfio_group_status group_status = { .argsz =sizeof (group_status), }; -char group_path[32 ]; +char group_path[64 ];int group; group =vfio_pci_get_group_from_dev (device->bdf); -snprintf (group_path,sizeof (group_path),"/dev/vfio/%d" , group); +if (vfio_pci_noiommu_mode_enabled ()) +snprintf (group_path,sizeof (group_path),"/dev/vfio/noiommu-%d" , group); +else +snprintf (group_path,sizeof (group_path),"/dev/vfio/%d" , group); device->group_fd =open (group_path,O_RDWR );VFIO_ASSERT_GE (device->group_fd,0 ,"open(%s) failed\n" , group_path);
@@ -294,6 +297,24 @@ static void vfio_pci_device_setup(struct vfio_pci_device *device) device->msi_eventfds[i] =-1 ; } + +int vfio_pci_noiommu_mode_enabled (void ) +{ +const char *path ="/sys/module/vfio/parameters/enable_unsafe_noiommu_mode" ; +FILE *f; +int c; + + f =fopen (path,"re" ); +if (!f) +return 0 ; + + c =fgetc (f); +fclose (f); +if (c =='Y' || c =='y' ) +return 1 ; +return 0 ; +} +const char *vfio_pci_get_cdev_path (const char *bdf) {char dir_path[PATH_MAX ];
@@ -310,8 +331,11 @@ const char *vfio_pci_get_cdev_path(const char *bdf)VFIO_ASSERT_NOT_NULL (dir,"Failed to open directory %s\n" , dir_path);while ((entry =readdir (dir)) !=NULL ) { -/* Find the file that starts with "vfio" */ -if (strncmp ("vfio" , entry->d_name,4 )) +/* Find the file that starts with "noiommu-vfio" or "vfio" */ +if (vfio_pci_noiommu_mode_enabled ()) { +if (strncmp ("noiommu-vfio" , entry->d_name,strlen ("noiommu-vfio" ))) +continue ; + }else if (strncmp ("vfio" , entry->d_name,4 ))continue ;snprintf (cdev_path,PATH_MAX ,"/dev/vfio/devices/%s" , entry->d_name);
tools/testing/selftests/vfio/vfio_pci_liveupdate_kexec_test.c +9 -0
@@ -159,6 +159,15 @@ static void check_open_vfio_device_fails(void)VFIO_ASSERT_EQ (errno,EBUSY );free ((void *)cdev_path); +/* +* In no-IOMMU mode the group lives at /dev/vfio/noiommu-<N> and +* cannot be added to a Type1 IOMMU container, so the container-based +* access check below doesn't apply. The cdev check above already +* covers that the device is inaccessible in this mode. +*/ +if (vfio_pci_noiommu_mode_enabled ()) +return ; +for (i =0 ; i < nr_iommu_modes; i++) {if (!iommu_modes[i].container_path)continue ;
Signature · 1 line
2.34.1
PATCH v3 9/10 selftests/vfio: Add iommufd noiommu mode selftest for cdev
In reply to Jacob PanAdd comprehensive selftest for VFIO device operations with iommufd in noiommu mode. Tests cover:
- Device binding to iommufd
- IOAS (I/O Address Space) allocation, mapping with dummy IOVA
- Retrieve PA from dummy IOVA
- Device attach/detach operations as usual
---
v2:
- Use huge page ioas map to test GET_PA searching for contiguous PA range.
--- tools/testing/selftests/vfio/Makefile | 1 + .../vfio/vfio_iommufd_noiommu_test.c | 549 ++++++++++++++++++ 2 files changed, 550 insertions(+) create mode 100644 tools/testing/selftests/vfio/vfio_iommufd_noiommu_test.c
tools/testing/selftests/vfio/Makefile +1 -0
@@ -9,6 +9,7 @@ CFLAGS = $(KHDR_INCLUDES) TEST_GEN_PROGS += vfio_dma_mapping_test TEST_GEN_PROGS += vfio_dma_mapping_mmio_test TEST_GEN_PROGS += vfio_iommufd_setup_test +TEST_GEN_PROGS += vfio_iommufd_noiommu_test TEST_GEN_PROGS += vfio_pci_device_test TEST_GEN_PROGS += vfio_pci_device_init_perf_test TEST_GEN_PROGS += vfio_pci_driver_test
tools/testing/selftests/vfio/vfio_iommufd_noiommu_test.c new file +549 -0
549 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v3 10/10 Documentation: Update VFIO NOIOMMU mode
In reply to Jacob PanDocument the NOIOMMU mode with newly added cdev support under iommufd.
--- Documentation/driver-api/vfio.rst | 45 +++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-)
Documentation/driver-api/vfio.rst +43 -2
@@ -275,8 +275,6 @@ in a VFIO group. With CONFIG_VFIO_DEVICE_CDEV=y the user can now acquire a device fd by directly opening a character device /dev/vfio/devices/vfioX where "X" is the number allocated uniquely by VFIO for registered devices. -cdev interface does not support noiommu devices, so user should use -the legacy group interface if noiommu is wanted. The cdev only works with IOMMUFD. Both VFIO drivers and applications must adapt to the new cdev security model which requires using
@@ -370,6 +368,49 @@ IOMMUFD IOAS/HWPT to enable userspace DMA:: /* Other device operations as stated in "VFIO Usage Example" */ +VFIO NOIOMMU mode +------------------------------------------------------------------------------- +VFIO also supports a no-IOMMU mode, intended for usages where unsafe DMA can +be performed by userspace drivers w/o physical IOMMU protection. This mode +is controlled by the parameter: + +/sys/module/vfio/parameters/enable_unsafe_noiommu_mode + +Upon enabling this mode, with an assigned device, the user will be presented +with a VFIO group and device file, e.g.:: + + /dev/vfio/ + |-- devices + | `-- noiommu-vfio0 /* VFIO device cdev */ + |-- noiommu-0 /* VFIO group */ + `-- vfio + +The capabilities vary depending on the device programming interface and kernel +configuration used. The following table summarizes the differences: + ++-------------------+---------------------+----------------------+ +| Feature | VFIO group | VFIO device cdev | ++===================+=====================+======================+ +| VFIO device UAPI | Yes | Yes | ++-------------------+---------------------+----------------------+ +| VFIO container | No | No | ++-------------------+---------------------+----------------------+ +| IOMMUFD IOAS | No | Yes* | ++-------------------+---------------------+----------------------+ + +Note that the VFIO container case includes IOMMUFD provided VFIO compatibility +interfaces when either CONFIG_VFIO_CONTAINER or CONFIG_IOMMUFD_VFIO_CONTAINER is +enabled. + +* IOMMUFD UAPI is available for VFIO device cdev to pin and map user memory with + the ability to retrieve physical addresses for DMA command submission. + +A new IOMMUFD ioctl IOMMU_IOAS_GET_PA is added to retrieve the physical address +for a given user virtual address. Note that IOMMU_IOAS_MAP_FIXED_IOVA flag is +ignored in no-IOMMU mode since there is no physical DMA remapping hardware. +tools/testing/selftests/vfio/vfio_iommufd_noiommu_test.c provides an example of +using this ioctl in no-IOMMU mode. + VFIO User API -------------------------------------------------------------------------------
Signature · 1 line
2.34.1