[PATCH v3 01/11] scsi: mpt3sas: Don't leave requeued firmware events pending at teardown
From: Jeff Layton
Date: Wed Nov 18 2026 - 18:10:54 EST
When a topology change event finds a busy device,
_scsih_fw_event_requeue() retries the event. It queues the event's
delayed_work on firmware_event_thread, with a one-second delay.
_scsih_fw_event_cleanup_queue() cancels only the event's work, not its
delayed_work. Thus the timer stays armed. Then scsih_remove() destroys
the workqueue. After the workqueue is freed, the timer queues
_firmware_event_work_delayed() on it:
BUG: KASAN: slab-use-after-free in __queue_work+0xa12/0xb50
Read of size 4 at addr ffff88814fefd1c0 by task swapper/10/0
__queue_work
call_timer_fn
__run_timer_base
...
Allocated by task 11:
__alloc_workqueue
alloc_workqueue_noprof
_scsih_probe [mpt3sas]
Freed by task 0:
kfree
rcu_core
...
workqueue: cannot queue _firmware_event_work_delayed [mpt3sas] on wq fw_event_mpt3sas0
The cleanup does not wait for a running topology change event. If such
an event finds a busy device, it requeues itself. This can occur after
the cleanup passes the event.
Fix this:
- In the cleanup, cancel the delayed_work of a requeued event.
- Do not requeue an event while the cleanup runs or while the driver
removes the host. Do this check under fw_event_lock, which the
cleanup also takes.
- Instead of a requeue, drop the reference that the work held.
Previously, this reference leaked when firmware_event_thread was
NULL.
- Also drop the reference if the delayed_work cannot be queued.
Cleanups can overlap. Thus one cleanup can clear fw_events_cleanup
while another cleanup cancels the delayed_work. The cancel disables
the delayed_work.
- Initialize the delayed_work when the driver allocates the event, not
at the first requeue. Thus a cleanup never cancels the delayed_work
before it is initialized.
Fixes: ad5957193107 ("scsi: mpt3sas: Add firmware event requeue support for busy devices")
Signed-off-by: Jeff Layton <jlayton@xxxxxxxxxx>
---
drivers/scsi/mpt3sas/mpt3sas_scsih.c | 49 ++++++++++++++++++++++++++++--------
1 file changed, 38 insertions(+), 11 deletions(-)
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 04255286a2a6..545913123d01 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -320,6 +320,11 @@ static struct fw_event_work *alloc_fw_event_work(int len)
return NULL;
kref_init(&fw_event->refcount);
+ /*
+ * Initialize the delayed_work up front: a cleanup may cancel it
+ * while the event is being requeued.
+ */
+ INIT_DELAYED_WORK(&fw_event->delayed_work, _firmware_event_work_delayed);
return fw_event;
}
@@ -3696,6 +3701,9 @@ _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
*
* Context: This function will acquire ioc->fw_event_lock.
*
+ * The reference held by the work that ran @fw_event passes to the delayed
+ * work. If the event can't be requeued, that reference is dropped.
+ *
* Return nothing.
*/
static void
@@ -3704,20 +3712,31 @@ _scsih_fw_event_requeue(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work
{
unsigned long flags;
- if (ioc->firmware_event_thread == NULL)
- return;
-
spin_lock_irqsave(&ioc->fw_event_lock, flags);
+ /*
+ * Don't rearm the event while the queue is being flushed or the
+ * host is going away. _scsih_fw_event_cleanup_queue() may already
+ * be past it, and the timer could then fire after the workqueue
+ * has been destroyed.
+ */
+ if (!ioc->firmware_event_thread || ioc->remove_host ||
+ ioc->fw_events_cleanup)
+ goto drop;
+ fw_event->delayed_work_active = 1;
+ /*
+ * Cleanups can overlap, and one can clear fw_events_cleanup while
+ * another is cancelling, and so disabling, the delayed work.
+ */
+ if (!queue_delayed_work(ioc->firmware_event_thread,
+ &fw_event->delayed_work, msecs_to_jiffies(delay)))
+ goto drop;
fw_event_work_get(fw_event);
list_add_tail(&fw_event->list, &ioc->fw_event_list);
- if (!fw_event->delayed_work_active) {
- fw_event->delayed_work_active = 1;
- INIT_DELAYED_WORK(&fw_event->delayed_work,
- _firmware_event_work_delayed);
- }
- queue_delayed_work(ioc->firmware_event_thread, &fw_event->delayed_work,
- msecs_to_jiffies(delay));
spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
+ return;
+drop:
+ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
+ fw_event_work_put(fw_event);
}
/**
@@ -3869,9 +3888,17 @@ _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc)
*
* If it did execute, we wait for it to finish, and the put will
* happen from _firmware_event_work()
+ *
+ * An event requeued by _scsih_fw_event_requeue() is pending
+ * on its delayed_work instead, and its timer must not fire
+ * after the workqueue is destroyed.
*/
- if (cancel_work_sync(&fw_event->work))
+ if (fw_event->delayed_work_active) {
+ if (cancel_delayed_work_sync(&fw_event->delayed_work))
+ fw_event_work_put(fw_event);
+ } else if (cancel_work_sync(&fw_event->work)) {
fw_event_work_put(fw_event);
+ }
}
ioc->fw_events_cleanup = 0;
--
2.56.1