* [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal
@ 2026-11-17 1:54 Qihang
2026-11-17 1:54 ` [PATCH 1/2] iommu/io-pgfault: unlink partial faults before freeing them Qihang
` (2 more replies)
0 siblings, 3 replies; 5+ messages in thread
From: Qihang @ 2026-11-17 1:54 UTC (permalink / raw)
To: Joerg Roedel, Will Deacon; +Cc: Qihang, Robin Murphy, iommu, linux-kernel
iopf_queue_remove_device() kfree()s the entries on
fault_param->partial without unlinking them, leaving the list head
pointing into freed memory. Since a74c077b9021 the fault parameter is
refcounted and can outlive the drain, a report that took its reference
earlier can still list_add() through those pointers. Unlinking
instead turns that into a leak: the late node lands on a parameter
that is no longer on queue->devices, whose final put does not free
partial faults.
This needs a device removed from its iopf queue while a non-last
(partial) request is in flight, with the caller not blocking new reports
for the duration.
Patch 1 unlinks each partial before freeing it, matching
iopf_queue_discard_partial().
Patch 2 adds fault_param->removing, set and tested under
fault_param->lock: a late partial is either drained, or rejected and
freed by report_partial_fault() (-ENODEV). It covers partial-list
admission only; callers must still quiesce reports for the remaining
lifetimes.
Both patches are scoped to fault_param->partial, not the group path,
the attach handle, or paths that never call iopf_queue_remove_device().
Verified on v7.4-rc3 with KASAN + DEBUG_LIST and the iommufd mock
driver, its caller-side IOPF serialization deliberately removed and
test-only delays added; this shows the mechanism, not production
reachability. The runs cover queue-before-removal,
removal-before-insertion, concurrent late reporters and re-enable.
Each round queues one partial before the removal and then races the
late reporters against the drain, so a clean run ends with every node
accounted for: 1800 = 900 + 900 and 3600 = 900 + 2700 (allocated =
drained + rejected), counted at a final removal with no reporter in
flight. Nothing was left on fault_param->partial and KASAN stayed
quiet.
With patch 1 reverted, the report is:
BUG: KASAN: slab-use-after-free in __list_add_valid_or_report
Freed by task 1: kfree <- iopf_queue_remove_device
56 bytes inside a freed 64-byte region (struct iopf_fault, list.prev)
With patch 1 only, the same reproducer runs 1460 rounds without a KASAN
report and leaks one late node per round, which patch 2 addresses.
Reachability on an unmodified production kernel, and any security
impact, remain unconfirmed: the test shows memory corruption and a
KASAN panic on the modified mock driver, not a user-triggerable bug on
a stock kernel.
An AI coding assistant helped find this defect and build the
reproducer and instrumentation, which are available on request along
with the KASAN logs.
^ permalink raw reply [flat|nested] 5+ messages in thread* [PATCH 1/2] iommu/io-pgfault: unlink partial faults before freeing them 2026-11-17 1:54 [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Qihang @ 2026-11-17 1:54 ` Qihang 2026-11-17 1:54 ` [PATCH 2/2] iommu/io-pgfault: reject partial faults after the device is removed Qihang 2026-11-20 7:56 ` [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Baolu Lu 2 siblings, 0 replies; 5+ messages in thread From: Qihang @ 2026-11-17 1:54 UTC (permalink / raw) To: Joerg Roedel, Will Deacon Cc: Qihang, Robin Murphy, iommu, linux-kernel, stable iopf_queue_remove_device() frees the pending partial faults without unlinking them, so fault_param->partial keeps pointing into freed memory. A report that is still in flight can then list_add() through those dangling pointers. The unlink has been missing since iopf_queue_remove_device() was first added, but the race only became reachable with a74c077b9021, which made the fault parameter refcounted and able to outlive the removal. Unlink each entry before freeing it, matching iopf_queue_discard_partial(). This fixes the dangling-list access only: a partial that arrives after the drain now leaks, because the parameter is no longer on queue->devices and its final put does not free partial faults. The next patch gives such a partial a defined fate. Fixes: a74c077b9021 ("iommu: Use refcount for fault data access") Cc: stable@vger.kernel.org Signed-off-by: Qihang <q.h.hack.winter@gmail.com> --- iopf_queue_discard_partial() cannot be called directly from here: it takes queue->lock, which iopf_queue_remove_device() already holds. drivers/iommu/io-pgfault.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/drivers/iommu/io-pgfault.c b/drivers/iommu/io-pgfault.c index c16ff1f..55a3c29 100644 --- a/drivers/iommu/io-pgfault.c +++ b/drivers/iommu/io-pgfault.c @@ -479,8 +479,10 @@ void iopf_queue_remove_device(struct iopf_queue *queue, struct device *dev) goto unlock; mutex_lock(&fault_param->lock); - list_for_each_entry_safe(partial_iopf, next, &fault_param->partial, list) + list_for_each_entry_safe(partial_iopf, next, &fault_param->partial, list) { + list_del(&partial_iopf->list); kfree(partial_iopf); + } list_for_each_entry_safe(group, temp, &fault_param->faults, pending_node) { struct iopf_fault *iopf = &group->last_fault; ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH 2/2] iommu/io-pgfault: reject partial faults after the device is removed 2026-11-17 1:54 [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Qihang 2026-11-17 1:54 ` [PATCH 1/2] iommu/io-pgfault: unlink partial faults before freeing them Qihang @ 2026-11-17 1:54 ` Qihang 2026-11-20 7:56 ` [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Baolu Lu 2 siblings, 0 replies; 5+ messages in thread From: Qihang @ 2026-11-17 1:54 UTC (permalink / raw) To: Joerg Roedel, Will Deacon Cc: Qihang, Robin Murphy, iommu, linux-kernel, stable A report that already holds a reference to the fault_param can still reach report_partial_fault() after iopf_queue_remove_device() drained the partial list. The node it queues there leaks: the parameter is no longer on queue->devices and its final put does not free partial faults. Reject late partial insertions under fault_param->lock: add fault_param->removing, set it in iopf_queue_remove_device() before the drain, and test it in report_partial_fault() under the same lock that the insertion takes, so "check" and "link" cannot be separated. A partial is then either drained or rejected and freed by report_partial_fault() itself, which returns -ENODEV; as for any non-last request, no response is sent. removing is never cleared, since IOPF re-enable allocates a new fault_param. This only protects partial-list admission; callers must still quiesce reports for the remaining lifetimes. It is not a general teardown fix; the cover letter lists the paths it does not cover. Fixes: a74c077b9021 ("iommu: Use refcount for fault data access") Cc: stable@vger.kernel.org Signed-off-by: Qihang <q.h.hack.winter@gmail.com> --- This applies on top of "iommu/io-pgfault: unlink partial faults before freeing them". drivers/iommu/io-pgfault.c | 12 ++++++++++-- include/linux/iommu.h | 3 +++ 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/drivers/iommu/io-pgfault.c b/drivers/iommu/io-pgfault.c index 55a3c29..51d0d1a 100644 --- a/drivers/iommu/io-pgfault.c +++ b/drivers/iommu/io-pgfault.c @@ -64,6 +64,7 @@ static int report_partial_fault(struct iommu_fault_param *fault_param, struct iommu_fault *fault) { struct iopf_fault *iopf; + int ret = 0; iopf = kzalloc_obj(*iopf); if (!iopf) @@ -72,10 +73,16 @@ static int report_partial_fault(struct iommu_fault_param *fault_param, iopf->fault = *fault; mutex_lock(&fault_param->lock); - list_add(&iopf->list, &fault_param->partial); + if (fault_param->removing) + ret = -ENODEV; + else + list_add(&iopf->list, &fault_param->partial); mutex_unlock(&fault_param->lock); - return 0; + if (ret) + kfree(iopf); + + return ret; } static struct iopf_group *iopf_group_alloc(struct iommu_fault_param *iopf_param, @@ -479,6 +486,7 @@ void iopf_queue_remove_device(struct iopf_queue *queue, struct device *dev) goto unlock; mutex_lock(&fault_param->lock); + fault_param->removing = true; list_for_each_entry_safe(partial_iopf, next, &fault_param->partial, list) { list_del(&partial_iopf->list); kfree(partial_iopf); diff --git a/include/linux/iommu.h b/include/linux/iommu.h index ef50437..5d56e66 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -846,6 +846,8 @@ struct iommu_device { * @partial: faults that are part of a Page Request Group for which the last * request hasn't been submitted yet. * @faults: holds the pending faults which need response + * @removing: the device is being removed from the queue, no new partial + * faults may be queued */ struct iommu_fault_param { struct mutex lock; @@ -858,6 +860,7 @@ struct iommu_fault_param { struct list_head partial; struct list_head faults; + bool removing; }; /** ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal 2026-11-17 1:54 [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Qihang 2026-11-17 1:54 ` [PATCH 1/2] iommu/io-pgfault: unlink partial faults before freeing them Qihang 2026-11-17 1:54 ` [PATCH 2/2] iommu/io-pgfault: reject partial faults after the device is removed Qihang @ 2026-11-20 7:56 ` Baolu Lu 2026-11-20 9:26 ` Qihang 2 siblings, 1 reply; 5+ messages in thread From: Baolu Lu @ 2026-11-20 7:56 UTC (permalink / raw) To: Qihang, Joerg Roedel, Will Deacon, Jason Gunthorpe Cc: baolu.lu, Robin Murphy, iommu, linux-kernel On 11/17/2026 9:54 AM, Qihang wrote: > iopf_queue_remove_device() kfree()s the entries on > fault_param->partial without unlinking them, leaving the list head > pointing into freed memory. Since a74c077b9021 the fault parameter is > refcounted and can outlive the drain, a report that took its reference > earlier can still list_add() through those pointers. Unlinking > instead turns that into a leak: the late node lands on a parameter > that is no longer on queue->devices, whose final put does not free > partial faults. > > This needs a device removed from its iopf queue while a non-last > (partial) request is in flight, with the caller not blocking new reports > for the duration. > > Patch 1 unlinks each partial before freeing it, matching > iopf_queue_discard_partial(). > > Patch 2 adds fault_param->removing, set and tested under > fault_param->lock: a late partial is either drained, or rejected and > freed by report_partial_fault() (-ENODEV). It covers partial-list > admission only; callers must still quiesce reports for the remaining > lifetimes. > > Both patches are scoped to fault_param->partial, not the group path, > the attach handle, or paths that never call iopf_queue_remove_device(). > > Verified on v7.4-rc3 with KASAN + DEBUG_LIST and the iommufd mock > driver, its caller-side IOPF serialization deliberately removed and > test-only delays added; this shows the mechanism, not production > reachability. The runs cover queue-before-removal, > removal-before-insertion, concurrent late reporters and re-enable. > Each round queues one partial before the removal and then races the > late reporters against the drain, so a clean run ends with every node > accounted for: 1800 = 900 + 900 and 3600 = 900 + 2700 (allocated = > drained + rejected), counted at a final removal with no reporter in > flight. Nothing was left on fault_param->partial and KASAN stayed > quiet. > > With patch 1 reverted, the report is: > > BUG: KASAN: slab-use-after-free in __list_add_valid_or_report > Freed by task 1: kfree <- iopf_queue_remove_device > 56 bytes inside a freed 64-byte region (struct iopf_fault, list.prev) > > With patch 1 only, the same reproducer runs 1460 rounds without a KASAN > report and leaks one late node per round, which patch 2 addresses. > > Reachability on an unmodified production kernel, and any security > impact, remain unconfirmed: the test shows memory corruption and a > KASAN panic on the modified mock driver, not a user-triggerable bug on > a stock kernel. > > An AI coding assistant helped find this defect and build the > reproducer and instrumentation, which are available on request along > with the KASAN logs. +Jason The issues addressed by both patches are false positives. They rely on a fault being reported for a device after iopf_queue_remove_device() has been called for that device. The iommu driver must not allow that. Pending i/o page faults must be drained before the device is removed from its iommu's io page fault queue. Thanks, baolu ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal 2026-11-20 7:56 ` [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Baolu Lu @ 2026-11-20 9:26 ` Qihang 0 siblings, 0 replies; 5+ messages in thread From: Qihang @ 2026-11-20 9:26 UTC (permalink / raw) To: Baolu Lu Cc: Joerg Roedel, Will Deacon, Jason Gunthorpe, Robin Murphy, iommu, linux-kernel Hi Baolu, Thanks. I agree that the driver must drain pending faults before calling iopf_queue_remove_device(). My selftest removed the mock driver's serialization, so it doesn't establish that fault reporting can overlap removal in an unmodified driver. I'm withdrawing this series and won't resend it. I still have two questions about where the drivers establish that guarantee. On VT-d, blocking_domain_attach_dev() calls iopf_for_domain_remove(old, dev) before device_block_translation(dev). When that drops the last IOPF reference, it calls iopf_queue_remove_device(). On an SM-capable IOMMU, for a device that isn't a real DMA subdevice, the only PRQ drain on this path is reached through device_block_translation() → intel_pasid_tear_down_entry() → intel_iommu_drain_pasid_prq(). By then iopf_refcount is zero, so the drain returns early. In the same file, identity_domain_attach_dev() calls device_block_translation(dev) first and releases the old domain's IOPF reference afterwards. The comment there explains that putting the device in the blocking state leaves the IOPF reference count unchanged. Should blocking_domain_attach_dev() use the same order? If the current order is intentional, what ensures that pending PRQ reports for this device have drained before the last reference is dropped? On AMD, detach_device() calls iopf_queue_flush_dev() immediately before amd_iommu_iopf_remove_device(). The flush helper waits for queued work and documents that the caller must have flushed the low-level queue first. The PPR interrupt thread calls iommu_report_device_fault() directly, so waiting for queued work alone doesn't establish that the thread has finished reporting faults for this device. What in the detach path ensures that PPR reporting for this device has quiesced before the device is removed from the IOPF queue? I may be missing a step in both cases. A pointer would be enough. Thanks, Qihang On Fri, Nov 20, 2026 at 3:56 PM Baolu Lu <baolu.lu@linux.intel.com> wrote: > > On 11/17/2026 9:54 AM, Qihang wrote: > > iopf_queue_remove_device() kfree()s the entries on > > fault_param->partial without unlinking them, leaving the list head > > pointing into freed memory. Since a74c077b9021 the fault parameter is > > refcounted and can outlive the drain, a report that took its reference > > earlier can still list_add() through those pointers. Unlinking > > instead turns that into a leak: the late node lands on a parameter > > that is no longer on queue->devices, whose final put does not free > > partial faults. > > > > This needs a device removed from its iopf queue while a non-last > > (partial) request is in flight, with the caller not blocking new reports > > for the duration. > > > > Patch 1 unlinks each partial before freeing it, matching > > iopf_queue_discard_partial(). > > > > Patch 2 adds fault_param->removing, set and tested under > > fault_param->lock: a late partial is either drained, or rejected and > > freed by report_partial_fault() (-ENODEV). It covers partial-list > > admission only; callers must still quiesce reports for the remaining > > lifetimes. > > > > Both patches are scoped to fault_param->partial, not the group path, > > the attach handle, or paths that never call iopf_queue_remove_device(). > > > > Verified on v7.4-rc3 with KASAN + DEBUG_LIST and the iommufd mock > > driver, its caller-side IOPF serialization deliberately removed and > > test-only delays added; this shows the mechanism, not production > > reachability. The runs cover queue-before-removal, > > removal-before-insertion, concurrent late reporters and re-enable. > > Each round queues one partial before the removal and then races the > > late reporters against the drain, so a clean run ends with every node > > accounted for: 1800 = 900 + 900 and 3600 = 900 + 2700 (allocated = > > drained + rejected), counted at a final removal with no reporter in > > flight. Nothing was left on fault_param->partial and KASAN stayed > > quiet. > > > > With patch 1 reverted, the report is: > > > > BUG: KASAN: slab-use-after-free in __list_add_valid_or_report > > Freed by task 1: kfree <- iopf_queue_remove_device > > 56 bytes inside a freed 64-byte region (struct iopf_fault, list.prev) > > > > With patch 1 only, the same reproducer runs 1460 rounds without a KASAN > > report and leaks one late node per round, which patch 2 addresses. > > > > Reachability on an unmodified production kernel, and any security > > impact, remain unconfirmed: the test shows memory corruption and a > > KASAN panic on the modified mock driver, not a user-triggerable bug on > > a stock kernel. > > > > An AI coding assistant helped find this defect and build the > > reproducer and instrumentation, which are available on request along > > with the KASAN logs. > > +Jason > > The issues addressed by both patches are false positives. They rely on a > fault being reported for a device after iopf_queue_remove_device() has > been called for that device. The iommu driver must not allow that. > Pending i/o page faults must be drained before the device is removed > from its iommu's io page fault queue. > > Thanks, > baolu ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-20 9:26 UTC | newest] Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2026-11-17 1:54 [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Qihang 2026-11-17 1:54 ` [PATCH 1/2] iommu/io-pgfault: unlink partial faults before freeing them Qihang 2026-11-17 1:54 ` [PATCH 2/2] iommu/io-pgfault: reject partial faults after the device is removed Qihang 2026-11-20 7:56 ` [PATCH 0/2] iommu/io-pgfault: reject partial faults after device removal Baolu Lu 2026-11-20 9:26 ` Qihang
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®