[PATCH v3 09/11] scsi: mpt3sas: Serialize interrupt-time sdev block with hostdata teardown

From: Jeff Layton

Date: Wed Nov 18 2026 - 18:10:49 EST


On DELAY_NOT_RESPONDING, the event callback runs
_scsih_block_io_device() at interrupt time. This function walks the
sdevs with shost_for_each_device(). It uses sdev->hostdata and its
sas_target, and holds no lock.

The sdev reference pins only the scsi_device. __scsi_remove_device()
can still call ->sdev_destroy() at the same time, for example when a
scan fails to probe a new LUN. scsih_sdev_destroy() frees hostdata,
which causes a use-after-free. scsi_target_reap() frees the hostdata of
the target, after sdev_destroy.

Add ioc->block_lock. Take it:

- in _scsih_block_io_device(), for each sdev
- around the code that sets and clears sdev->hostdata in
scsih_sdev_init() and scsih_sdev_destroy()

The sdev is on shost->__devices before sdev_init. Because the driver
publishes hostdata under the lock, the lock also orders the sas_target
store. While the lock is held and hostdata is non-NULL, hostdata and
its target are live.

Fixes: f92363d12359 ("[SCSI] mpt3sas: add new driver supporting 12GB SAS")
Signed-off-by: Jeff Layton <jlayton@xxxxxxxxxx>
---
drivers/scsi/mpt3sas/mpt3sas_base.h | 2 ++
drivers/scsi/mpt3sas/mpt3sas_scsih.c | 30 ++++++++++++++++++++++--------
2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/drivers/scsi/mpt3sas/mpt3sas_base.h b/drivers/scsi/mpt3sas/mpt3sas_base.h
index 47255bf9cdda..419fdf164fc6 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_base.h
+++ b/drivers/scsi/mpt3sas/mpt3sas_base.h
@@ -1249,6 +1249,7 @@ typedef void (*MPT3SAS_FLUSH_RUNNING_CMDS)(struct MPT3SAS_ADAPTER *ioc);
* @pcie_device_list: pcie device object list
* @pcie_device_init_list: pcie device object list (used only at init time)
* @pcie_device_lock:
+ * @block_lock: serializes sdev blocking against sdev hostdata teardown
* @io_missing_delay: time for IO completed by fw when PDR enabled
* @device_missing_delay: time for device missing by fw when PDR enabled
* @sas_id : used for setting volume target IDs
@@ -1482,6 +1483,7 @@ struct MPT3SAS_ADAPTER {
struct list_head pcie_device_list;
struct list_head pcie_device_init_list;
spinlock_t pcie_device_lock;
+ spinlock_t block_lock;

struct list_head raid_device_list;
spinlock_t raid_device_lock;
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 1269446eec4e..09dfa3124ebf 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -2132,12 +2132,17 @@ scsih_sdev_init(struct scsi_device *sdev)
sas_target_priv_data = starget->hostdata;
sas_target_priv_data->num_luns++;
sas_device_priv_data->sas_target = sas_target_priv_data;
+
+ shost = dev_to_shost(&starget->dev);
+ ioc = shost_priv(shost);
+
+ /* _scsih_block_io_device() may already see this sdev */
+ spin_lock_irqsave(&ioc->block_lock, flags);
sdev->hostdata = sas_device_priv_data;
+ spin_unlock_irqrestore(&ioc->block_lock, flags);
if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT))
sdev->no_uld_attach = 1;

- shost = dev_to_shost(&starget->dev);
- ioc = shost_priv(shost);
if (starget->channel == RAID_CHANNEL) {
spin_lock_irqsave(&ioc->raid_device_lock, flags);
raid_device = _scsih_raid_device_find_by_id(ioc,
@@ -2189,6 +2194,7 @@ scsih_sdev_init(struct scsi_device *sdev)
static void
scsih_sdev_destroy(struct scsi_device *sdev)
{
+ struct MPT3SAS_DEVICE *sas_device_priv_data;
struct MPT3SAS_TARGET *sas_target_priv_data;
struct scsi_target *starget;
struct Scsi_Host *shost;
@@ -2231,8 +2237,11 @@ scsih_sdev_destroy(struct scsi_device *sdev)
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
}

- kfree(sdev->hostdata);
+ spin_lock_irqsave(&ioc->block_lock, flags);
+ sas_device_priv_data = sdev->hostdata;
sdev->hostdata = NULL;
+ spin_unlock_irqrestore(&ioc->block_lock, flags);
+ kfree(sas_device_priv_data);
}

/**
@@ -4384,26 +4393,30 @@ _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle)
struct MPT3SAS_DEVICE *sas_device_priv_data;
struct scsi_device *sdev;
struct _sas_device *sas_device;
+ unsigned long flags;

sas_device = mpt3sas_get_sdev_by_handle(ioc, handle);

shost_for_each_device(sdev, ioc->shost) {
+ spin_lock_irqsave(&ioc->block_lock, flags);
sas_device_priv_data = sdev->hostdata;
if (!sas_device_priv_data)
- continue;
+ goto next;
if (sas_device_priv_data->sas_target->handle != handle)
- continue;
+ goto next;
if (sas_device_priv_data->block)
- continue;
+ goto next;
if (sas_device && sas_device->pend_sas_rphy_add)
- continue;
+ goto next;
if (sas_device_priv_data->ignore_delay_remove) {
sdev_printk(KERN_INFO, sdev,
"%s skip device_block for SES handle(0x%04x)\n",
__func__, sas_device_priv_data->sas_target->handle);
- continue;
+ goto next;
}
_scsih_internal_device_block(sdev, sas_device_priv_data);
+next:
+ spin_unlock_irqrestore(&ioc->block_lock, flags);
}

if (sas_device)
@@ -13697,6 +13710,7 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
spin_lock_init(&ioc->raid_device_lock);
spin_lock_init(&ioc->pcie_device_lock);
spin_lock_init(&ioc->diag_trigger_lock);
+ spin_lock_init(&ioc->block_lock);

INIT_LIST_HEAD(&ioc->sas_device_list);
INIT_LIST_HEAD(&ioc->sas_device_init_list);

--
2.56.1