* [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
@ 2021-02-22 13:23 Hannes Reinecke
2021-02-22 13:23 ` [PATCH 01/31] block: add flag for internal commands Hannes Reinecke
` (33 more replies)
0 siblings, 34 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Hi all,
quite some drivers use internal commands for various purposes, most
commonly sending TMFs or querying the HBA status.
While these commands use the same submission mechanism than normal
I/O commands, they will not be counted as outstanding commands,
requiring those drivers to implement their own mechanism to figure
out outstanding commands.
The block layer already has the concept of 'reserved' tags for
precisely this purpose, namely non-I/O tags which live off a separate
tag pool. That guarantees that these commands can always be sent,
and won't be influenced by tag starvation from the I/O tag pool.
This patchset enables the use of reserved tags for the SCSI midlayer
by allocating a virtual LUN for the HBA itself which just serves
as a resource to allocate valid tags from.
This removes quite some hacks which were required for some
drivers (eg. fnic or snic), and allows the use of tagset
iterators within the drivers.
The entire patchset can be found at
git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
reserved-tags.v7
As usual, comments and reviews are welcome.
Changes to v6:
- Remove patch to drop gdth
- Rework libsas to use a tag per slow task
- Update hisi_sas, pm8001, and mv_sas
Changes to v5:
- Remove patch for csiostor
- Warn on normal commands in scsi_put_reserved_cmd()
- Fixup aacraid to not only scsi_put_internal_cmd() for
reserved commands
- Add 'nr_reserved_cmds' field to host template
- Reshuffle patches
Changes to v4:
- Fixup kbuild warning
- Include reviews from Bart
Changes to v3:
- Kill gdth
- Only convert fnic, snic, hpsa, and aacraid
- Drop command emulation for pseudo host device
- make 'can_queue' exclude the number or reserved tags
- Drop persistent commands proposal
- Sanitize host device handling
Changes to v2:
- Update patches from John Garry
- Use virtual LUN as suggested by Christoph
- Improve SCSI Host device to present a real SCSI device
- Implement 'persistent' commands for AENs
- Convert Megaraid SAS
Changes to v1:
- Make scsi_{get, put}_reserved_cmd() for Scsi host
- Previously we separate scsi_{get, put}_reserved_cmd() for sdev
and scsi_host_get_reserved_cmd() for the host
- Fix how Scsi_Host.can_queue is set in the virtio-scsi change
- Drop Scsi_Host.use_reserved_cmd_q
- Drop scsi_is_reserved_cmd()
- Add support in libsas and associated HBA drivers
- Allocate reserved command in slow task
- Switch hisi_sas to use reserved Scsi command
- Reorder the series a little
- Some tidying
Hannes Reinecke (29):
block: add flag for internal commands
scsi: add scsi_{get,put}_internal_cmd() helper
fnic: use internal commands
fnic: use scsi_host_busy_iter() to traverse commands
fnic: check for started requests in fnic_wq_copy_cleanup_handler()
scsi: use real inquiry data when initialising devices
scsi: Use dummy inquiry data for the host device
scsi: revamp host device handling
snic: use reserved commands
snic: use tagset iter for traversing commands
snic: check for started requests in snic_hba_reset_cmpl_handler()
scsi: implement reserved command handling
hpsa: move hpsa_hba_inquiry after scsi_add_host()
hpsa: use reserved commands
hpsa: use scsi_host_busy_iter() to traverse outstanding commands
hpsa: drop refcount field from CommandList
aacraid: move scsi_add_host()
aacraid: store target id in host_scribble
aacraid: use scsi_get_internal_cmd()
aacraid: use scsi_host_busy_iter() to traverse outstanding commands
mv_sas: kill mvsas_debug_issue_ssp_tmf()
pm8001: kill pm8001_issue_ssp_tmf()
pm8001: kill 'dev' argument from pm8001_exec_internal_task_abort()
pm8001: use libsas-provided domain devices for SATA
libsas: add SCSI target pointer to struct domain_device
libsas: add tag to struct sas_task
hisi_sas: use task tag to reference the slot
mv_sas: use reserved tags and drop private tag allocation
pm8001: use block-layer tags for ccb allocation
John Garry (2):
scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task
scsi: hisi_sas: Use libsas slow task SCSI command
block/blk-exec.c | 5 +
drivers/scsi/aacraid/aachba.c | 137 ++--
drivers/scsi/aacraid/aacraid.h | 10 +-
drivers/scsi/aacraid/commctrl.c | 25 +-
drivers/scsi/aacraid/comminit.c | 2 +-
drivers/scsi/aacraid/commsup.c | 109 ++-
drivers/scsi/aacraid/dpcsup.c | 2 +-
drivers/scsi/aacraid/linit.c | 175 +++--
drivers/scsi/fnic/fnic_scsi.c | 944 +++++++++++--------------
drivers/scsi/hisi_sas/hisi_sas.h | 1 -
drivers/scsi/hisi_sas/hisi_sas_main.c | 137 ++--
drivers/scsi/hisi_sas/hisi_sas_v3_hw.c | 5 +-
drivers/scsi/hosts.c | 3 +
drivers/scsi/hpsa.c | 368 +++++-----
drivers/scsi/hpsa.h | 3 +-
drivers/scsi/hpsa_cmd.h | 1 -
drivers/scsi/libsas/sas_ata.c | 4 +
drivers/scsi/libsas/sas_expander.c | 7 +-
drivers/scsi/libsas/sas_init.c | 63 +-
drivers/scsi/libsas/sas_scsi_host.c | 4 +-
drivers/scsi/mvsas/mv_init.c | 10 +-
drivers/scsi/mvsas/mv_sas.c | 136 +---
drivers/scsi/mvsas/mv_sas.h | 13 +-
drivers/scsi/pm8001/pm8001_hwi.c | 154 ++--
drivers/scsi/pm8001/pm8001_init.c | 24 +-
drivers/scsi/pm8001/pm8001_sas.c | 193 +++--
drivers/scsi/pm8001/pm8001_sas.h | 14 +-
drivers/scsi/pm8001/pm80xx_hwi.c | 143 ++--
drivers/scsi/scsi_devinfo.c | 1 +
drivers/scsi/scsi_lib.c | 55 +-
drivers/scsi/scsi_scan.c | 96 ++-
drivers/scsi/scsi_sysfs.c | 3 +-
drivers/scsi/snic/snic.h | 4 +-
drivers/scsi/snic/snic_main.c | 7 +
drivers/scsi/snic/snic_scsi.c | 525 +++++++-------
include/linux/blk_types.h | 2 +
include/linux/blkdev.h | 5 +
include/scsi/libsas.h | 11 +-
include/scsi/scsi_device.h | 4 +
include/scsi/scsi_host.h | 36 +-
40 files changed, 1647 insertions(+), 1794 deletions(-)
--
2.29.2
^ permalink raw reply [flat|nested] 54+ messages in thread
* [PATCH 01/31] block: add flag for internal commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper Hannes Reinecke
` (32 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Some drivers require to allocate requests for internal command
submission. These request will never be passed through the block
layer, but nevertheless require a valid tag to avoid them clashing
with normal I/O commands.
This patch adds a new request flag REQ_INTERNAL to mark such
requests and a terminates any such commands in blk_execute_rq_nowait()
with a WARN_ON_ONCE to signal such an invalid usage.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
block/blk-exec.c | 5 +++++
include/linux/blk_types.h | 2 ++
include/linux/blkdev.h | 5 +++++
3 files changed, 12 insertions(+)
diff --git a/block/blk-exec.c b/block/blk-exec.c
index 85324d53d072..6869877e0d21 100644
--- a/block/blk-exec.c
+++ b/block/blk-exec.c
@@ -55,6 +55,11 @@ void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
rq->rq_disk = bd_disk;
rq->end_io = done;
+ if (WARN_ON_ONCE(blk_rq_is_internal(rq))) {
+ blk_mq_end_request(rq, BLK_STS_NOTSUPP);
+ return;
+ }
+
blk_account_io_start(rq);
/*
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 866f74261b3b..27e248335ad5 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -424,6 +424,7 @@ enum req_flag_bits {
/* for driver use */
__REQ_DRV,
__REQ_SWAP, /* swapping request. */
+ __REQ_INTERNAL, /* driver-internal command */
__REQ_NR_BITS, /* stops here */
};
@@ -448,6 +449,7 @@ enum req_flag_bits {
#define REQ_DRV (1ULL << __REQ_DRV)
#define REQ_SWAP (1ULL << __REQ_SWAP)
+#define REQ_INTERNAL (1ULL << __REQ_INTERNAL)
#define REQ_FAILFAST_MASK \
(REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index f94ee3089e01..5e1e2a549c37 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -269,6 +269,11 @@ static inline bool blk_rq_is_passthrough(struct request *rq)
return blk_rq_is_scsi(rq) || blk_rq_is_private(rq);
}
+static inline bool blk_rq_is_internal(struct request *rq)
+{
+ return rq->cmd_flags & REQ_INTERNAL;
+}
+
static inline bool bio_is_passthrough(struct bio *bio)
{
unsigned op = bio_op(bio);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
2021-02-22 13:23 ` [PATCH 01/31] block: add flag for internal commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-24 12:12 ` John Garry
2021-02-22 13:23 ` [PATCH 03/31] fnic: use internal commands Hannes Reinecke
` (31 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Add helper functions to allow LLDDs to allocate and free
internal commands.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/scsi_lib.c | 45 ++++++++++++++++++++++++++++++++++++++
include/scsi/scsi_device.h | 4 ++++
2 files changed, 49 insertions(+)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index d0ae586565f8..5cb464972682 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1934,6 +1934,51 @@ void scsi_mq_destroy_tags(struct Scsi_Host *shost)
blk_mq_free_tag_set(&shost->tag_set);
}
+/**
+ * scsi_get_internal_cmd - allocate an internal SCSI command
+ * @sdev: SCSI device from which to allocate the command
+ * @data_direction: Data direction for the allocated command
+ * @op_flags: request allocation flags
+ *
+ * Allocates a SCSI command for internal LLDD use.
+ */
+struct scsi_cmnd *scsi_get_internal_cmd(struct scsi_device *sdev,
+ enum dma_data_direction data_direction, int op_flags)
+{
+ struct request *rq;
+ struct scsi_cmnd *scmd;
+ blk_mq_req_flags_t flags = 0;
+ unsigned int op = REQ_INTERNAL | op_flags;
+
+ op |= (data_direction == DMA_TO_DEVICE) ?
+ REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN;
+ rq = blk_mq_alloc_request(sdev->request_queue, op, flags);
+ if (IS_ERR(rq))
+ return NULL;
+ scmd = blk_mq_rq_to_pdu(rq);
+ scmd->request = rq;
+ scmd->device = sdev;
+ return scmd;
+}
+EXPORT_SYMBOL_GPL(scsi_get_internal_cmd);
+
+/**
+ * scsi_put_internal_cmd - free an internal SCSI command
+ * @scmd: SCSI command to be freed
+ *
+ * Check if @scmd is an internal command, and call
+ * blk_mq_free_request() if true.
+ */
+void scsi_put_internal_cmd(struct scsi_cmnd *scmd)
+{
+ struct request *rq = blk_mq_rq_from_pdu(scmd);
+
+ if (WARN_ON(!blk_rq_is_internal(rq)))
+ return;
+ blk_mq_free_request(rq);
+}
+EXPORT_SYMBOL_GPL(scsi_put_internal_cmd);
+
/**
* scsi_device_from_queue - return sdev associated with a request_queue
* @q: The request queue to return the sdev from
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 1a5c9a3df6d6..d915728cc3c2 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -8,6 +8,7 @@
#include <linux/blkdev.h>
#include <scsi/scsi.h>
#include <linux/atomic.h>
+#include <linux/dma-direction.h>
struct device;
struct request_queue;
@@ -461,6 +462,9 @@ static inline int scsi_execute_req(struct scsi_device *sdev,
return scsi_execute(sdev, cmd, data_direction, buffer,
bufflen, NULL, sshdr, timeout, retries, 0, 0, resid);
}
+struct scsi_cmnd *scsi_get_internal_cmd(struct scsi_device *sdev,
+ enum dma_data_direction data_direction, int op_flags);
+void scsi_put_internal_cmd(struct scsi_cmnd *scmd);
extern void sdev_disable_disk_events(struct scsi_device *sdev);
extern void sdev_enable_disk_events(struct scsi_device *sdev);
extern int scsi_vpd_lun_id(struct scsi_device *, char *, size_t);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 03/31] fnic: use internal commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
2021-02-22 13:23 ` [PATCH 01/31] block: add flag for internal commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 04/31] fnic: use scsi_host_busy_iter() to traverse commands Hannes Reinecke
` (30 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Remove hack to get tag for the reset command by using internal
commands.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/fnic/fnic_scsi.c | 149 ++++++++++++----------------------
1 file changed, 50 insertions(+), 99 deletions(-)
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index 36744968378f..d851e75b0074 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -102,7 +102,7 @@ static const char *fnic_fcpio_status_to_str(unsigned int status)
return fcpio_status_str[status];
}
-static void fnic_cleanup_io(struct fnic *fnic, int exclude_id);
+static void fnic_cleanup_io(struct fnic *fnic);
static inline spinlock_t *fnic_io_lock_hash(struct fnic *fnic,
struct scsi_cmnd *sc)
@@ -638,7 +638,7 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
atomic64_inc(&reset_stats->fw_reset_completions);
/* Clean up all outstanding io requests */
- fnic_cleanup_io(fnic, SCSI_NO_TAG);
+ fnic_cleanup_io(fnic);
atomic64_set(&fnic->fnic_stats.fw_stats.active_fw_reqs, 0);
atomic64_set(&fnic->fnic_stats.io_stats.active_ios, 0);
@@ -1361,7 +1361,7 @@ int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int copy_work_to_do)
return wq_work_done;
}
-static void fnic_cleanup_io(struct fnic *fnic, int exclude_id)
+static void fnic_cleanup_io(struct fnic *fnic)
{
int i;
struct fnic_io_req *io_req;
@@ -1372,9 +1372,6 @@ static void fnic_cleanup_io(struct fnic *fnic, int exclude_id)
struct fnic_stats *fnic_stats = &fnic->fnic_stats;
for (i = 0; i < fnic->fnic_max_tag_id; i++) {
- if (i == exclude_id)
- continue;
-
io_lock = fnic_io_lock_tag(fnic, i);
spin_lock_irqsave(io_lock, flags);
sc = scsi_host_find_tag(fnic->lport->host, i);
@@ -2125,9 +2122,7 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic,
* successfully aborted, 1 otherwise
*/
static int fnic_clean_pending_aborts(struct fnic *fnic,
- struct scsi_cmnd *lr_sc,
- bool new_sc)
-
+ struct scsi_cmnd *lr_sc)
{
int tag, abt_tag;
struct fnic_io_req *io_req;
@@ -2148,7 +2143,7 @@ static int fnic_clean_pending_aborts(struct fnic *fnic,
* ignore this lun reset cmd if issued using new SC
* or cmds that do not belong to this lun
*/
- if (!sc || ((sc == lr_sc) && new_sc) || sc->device != lun_dev) {
+ if (!sc || sc == lr_sc || sc->device != lun_dev) {
spin_unlock_irqrestore(io_lock, flags);
continue;
}
@@ -2287,38 +2282,6 @@ static int fnic_clean_pending_aborts(struct fnic *fnic,
return ret;
}
-/**
- * fnic_scsi_host_start_tag
- * Allocates tagid from host's tag list
- **/
-static inline int
-fnic_scsi_host_start_tag(struct fnic *fnic, struct scsi_cmnd *sc)
-{
- struct request_queue *q = sc->request->q;
- struct request *dummy;
-
- dummy = blk_mq_alloc_request(q, REQ_OP_WRITE, BLK_MQ_REQ_NOWAIT);
- if (IS_ERR(dummy))
- return SCSI_NO_TAG;
-
- sc->tag = sc->request->tag = dummy->tag;
- sc->host_scribble = (unsigned char *)dummy;
-
- return dummy->tag;
-}
-
-/**
- * fnic_scsi_host_end_tag
- * frees tag allocated by fnic_scsi_host_start_tag.
- **/
-static inline void
-fnic_scsi_host_end_tag(struct fnic *fnic, struct scsi_cmnd *sc)
-{
- struct request *dummy = (struct request *)sc->host_scribble;
-
- blk_mq_free_request(dummy);
-}
-
/*
* SCSI Eh thread issues a Lun Reset when one or more commands on a LUN
* fail to get aborted. It calls driver's eh_device_reset with a SCSI command
@@ -2335,19 +2298,19 @@ int fnic_device_reset(struct scsi_cmnd *sc)
spinlock_t *io_lock;
unsigned long flags;
unsigned long start_time = 0;
+ struct scsi_device *sdev = sc->device;
struct scsi_lun fc_lun;
struct fnic_stats *fnic_stats;
struct reset_stats *reset_stats;
int tag = 0;
DECLARE_COMPLETION_ONSTACK(tm_done);
- int tag_gen_flag = 0; /*to track tags allocated by fnic driver*/
- bool new_sc = 0;
+ struct scsi_cmnd *reset_sc = NULL;
/* Wait for rport to unblock */
fc_block_scsi_eh(sc);
/* Get local-port, check ready and link up */
- lp = shost_priv(sc->device->host);
+ lp = shost_priv(sdev->host);
fnic = lport_priv(lp);
fnic_stats = &fnic->fnic_stats;
@@ -2355,10 +2318,10 @@ int fnic_device_reset(struct scsi_cmnd *sc)
atomic64_inc(&reset_stats->device_resets);
- rport = starget_to_rport(scsi_target(sc->device));
+ rport = starget_to_rport(scsi_target(sdev));
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
"Device reset called FCID 0x%x, LUN 0x%llx sc 0x%p\n",
- rport->port_id, sc->device->lun, sc);
+ rport->port_id, sdev->lun, sc);
if (lp->state != LPORT_ST_READY || !(lp->link_up))
goto fnic_device_reset_end;
@@ -2369,42 +2332,30 @@ int fnic_device_reset(struct scsi_cmnd *sc)
goto fnic_device_reset_end;
}
- CMD_FLAGS(sc) = FNIC_DEVICE_RESET;
- /* Allocate tag if not present */
+ reset_sc = scsi_get_internal_cmd(sdev, DMA_NONE, REQ_NOWAIT);
+ if (unlikely(!reset_sc))
+ goto fnic_device_reset_end;
- tag = sc->request->tag;
- if (unlikely(tag < 0)) {
- /*
- * Really should fix the midlayer to pass in a proper
- * request for ioctls...
- */
- tag = fnic_scsi_host_start_tag(fnic, sc);
- if (unlikely(tag == SCSI_NO_TAG))
- goto fnic_device_reset_end;
- tag_gen_flag = 1;
- new_sc = 1;
- }
- io_lock = fnic_io_lock_hash(fnic, sc);
+ CMD_FLAGS(reset_sc) = FNIC_DEVICE_RESET;
+ tag = reset_sc->request->tag;
+ io_lock = fnic_io_lock_hash(fnic, reset_sc);
spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
/*
- * If there is a io_req attached to this command, then use it,
- * else allocate a new one.
+ * Allocate a new io_req.
*/
+ io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
if (!io_req) {
- io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
- if (!io_req) {
- spin_unlock_irqrestore(io_lock, flags);
- goto fnic_device_reset_end;
- }
- memset(io_req, 0, sizeof(*io_req));
- io_req->port_id = rport->port_id;
- CMD_SP(sc) = (char *)io_req;
+ spin_unlock_irqrestore(io_lock, flags);
+ goto fnic_device_reset_end;
}
+ memset(io_req, 0, sizeof(*io_req));
+ io_req->port_id = rport->port_id;
+ CMD_SP(reset_sc) = (char *)io_req;
+
io_req->dr_done = &tm_done;
- CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
- CMD_LR_STATUS(sc) = FCPIO_INVALID_CODE;
+ CMD_STATE(reset_sc) = FNIC_IOREQ_CMD_PENDING;
+ CMD_LR_STATUS(reset_sc) = FCPIO_INVALID_CODE;
spin_unlock_irqrestore(io_lock, flags);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "TAG %x\n", tag);
@@ -2413,15 +2364,15 @@ int fnic_device_reset(struct scsi_cmnd *sc)
* issue the device reset, if enqueue failed, clean up the ioreq
* and break assoc with scsi cmd
*/
- if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
+ if (fnic_queue_dr_io_req(fnic, reset_sc, io_req)) {
spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(reset_sc);
if (io_req)
io_req->dr_done = NULL;
goto fnic_device_reset_clean;
}
spin_lock_irqsave(io_lock, flags);
- CMD_FLAGS(sc) |= FNIC_DEV_RST_ISSUED;
+ CMD_FLAGS(reset_sc) |= FNIC_DEV_RST_ISSUED;
spin_unlock_irqrestore(io_lock, flags);
/*
@@ -2432,16 +2383,16 @@ int fnic_device_reset(struct scsi_cmnd *sc)
msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(reset_sc);
if (!io_req) {
spin_unlock_irqrestore(io_lock, flags);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "io_req is null tag 0x%x sc 0x%p\n", tag, sc);
+ "io_req is null tag 0x%x sc 0x%p\n", tag, reset_sc);
goto fnic_device_reset_end;
}
io_req->dr_done = NULL;
- status = CMD_LR_STATUS(sc);
+ status = CMD_LR_STATUS(reset_sc);
/*
* If lun reset not completed, bail out with failed. io_req
@@ -2451,16 +2402,16 @@ int fnic_device_reset(struct scsi_cmnd *sc)
atomic64_inc(&reset_stats->device_reset_timeouts);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
"Device reset timed out\n");
- CMD_FLAGS(sc) |= FNIC_DEV_RST_TIMED_OUT;
+ CMD_FLAGS(reset_sc) |= FNIC_DEV_RST_TIMED_OUT;
spin_unlock_irqrestore(io_lock, flags);
- int_to_scsilun(sc->device->lun, &fc_lun);
+ int_to_scsilun(sdev->lun, &fc_lun);
/*
* Issue abort and terminate on device reset request.
* If q'ing of terminate fails, retry it after a delay.
*/
while (1) {
spin_lock_irqsave(io_lock, flags);
- if (CMD_FLAGS(sc) & FNIC_DEV_RST_TERM_ISSUED) {
+ if (CMD_FLAGS(reset_sc) & FNIC_DEV_RST_TERM_ISSUED) {
spin_unlock_irqrestore(io_lock, flags);
break;
}
@@ -2473,13 +2424,13 @@ int fnic_device_reset(struct scsi_cmnd *sc)
msecs_to_jiffies(FNIC_ABT_TERM_DELAY_TIMEOUT));
} else {
spin_lock_irqsave(io_lock, flags);
- CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
- CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
+ CMD_FLAGS(reset_sc) |= FNIC_DEV_RST_TERM_ISSUED;
+ CMD_STATE(reset_sc) = FNIC_IOREQ_ABTS_PENDING;
io_req->abts_done = &tm_done;
spin_unlock_irqrestore(io_lock, flags);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
"Abort and terminate issued on Device reset "
- "tag 0x%x sc 0x%p\n", tag, sc);
+ "tag 0x%x sc 0x%p\n", tag, reset_sc);
break;
}
}
@@ -2491,7 +2442,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
break;
} else {
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(reset_sc);
io_req->abts_done = NULL;
goto fnic_device_reset_clean;
}
@@ -2506,7 +2457,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
FNIC_SCSI_DBG(KERN_DEBUG,
fnic->lport->host,
"Device reset completed - failed\n");
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(reset_sc);
goto fnic_device_reset_clean;
}
@@ -2517,7 +2468,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
* the lun reset cmd. If all cmds get cleaned, the lun reset
* succeeds
*/
- if (fnic_clean_pending_aborts(fnic, sc, new_sc)) {
+ if (fnic_clean_pending_aborts(fnic, reset_sc)) {
spin_lock_irqsave(io_lock, flags);
io_req = (struct fnic_io_req *)CMD_SP(sc);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
@@ -2528,35 +2479,35 @@ int fnic_device_reset(struct scsi_cmnd *sc)
/* Clean lun reset command */
spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(reset_sc);
if (io_req)
/* Completed, and successful */
ret = SUCCESS;
fnic_device_reset_clean:
if (io_req)
- CMD_SP(sc) = NULL;
+ CMD_SP(reset_sc) = NULL;
spin_unlock_irqrestore(io_lock, flags);
if (io_req) {
start_time = io_req->start_time;
- fnic_release_ioreq_buf(fnic, io_req, sc);
+ fnic_release_ioreq_buf(fnic, io_req, reset_sc);
mempool_free(io_req, fnic->io_req_pool);
}
fnic_device_reset_end:
- FNIC_TRACE(fnic_device_reset, sc->device->host->host_no,
- sc->request->tag, sc,
+ FNIC_TRACE(fnic_device_reset, sdev->host->host_no,
+ reset_sc->request->tag, reset_sc,
jiffies_to_msecs(jiffies - start_time),
- 0, ((u64)sc->cmnd[0] << 32 |
+ 0, ((u64)reset_sc->cmnd[0] << 32 |
(u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
(u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
(((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
- /* free tag if it is allocated */
- if (unlikely(tag_gen_flag))
- fnic_scsi_host_end_tag(fnic, sc);
+ /* free internal command if it is allocated */
+ if (reset_sc)
+ scsi_put_internal_cmd(reset_sc);
FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
"Returning from device reset %s\n",
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 04/31] fnic: use scsi_host_busy_iter() to traverse commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (2 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 03/31] fnic: use internal commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 05/31] fnic: check for started requests in fnic_wq_copy_cleanup_handler() Hannes Reinecke
` (29 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Use scsi_host_busy_iter() to traverse commands instead of
hand-crafted routines walking the command list.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/fnic/fnic_scsi.c | 801 +++++++++++++++-------------------
1 file changed, 357 insertions(+), 444 deletions(-)
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index d851e75b0074..c7f37afa3069 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -1361,90 +1361,90 @@ int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int copy_work_to_do)
return wq_work_done;
}
-static void fnic_cleanup_io(struct fnic *fnic)
+static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
+ bool reserved)
{
- int i;
+ struct fnic *fnic = data;
struct fnic_io_req *io_req;
unsigned long flags = 0;
- struct scsi_cmnd *sc;
spinlock_t *io_lock;
unsigned long start_time = 0;
struct fnic_stats *fnic_stats = &fnic->fnic_stats;
- for (i = 0; i < fnic->fnic_max_tag_id; i++) {
- io_lock = fnic_io_lock_tag(fnic, i);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(fnic->lport->host, i);
- if (!sc) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- io_req = (struct fnic_io_req *)CMD_SP(sc);
- if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
- !(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
- /*
- * We will be here only when FW completes reset
- * without sending completions for outstanding ios.
- */
- CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
- if (io_req && io_req->dr_done)
- complete(io_req->dr_done);
- else if (io_req && io_req->abts_done)
- complete(io_req->abts_done);
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- } else if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
- if (!io_req) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- CMD_SP(sc) = NULL;
-
- spin_unlock_irqrestore(io_lock, flags);
+ io_lock = fnic_io_lock_tag(fnic, sc->request->tag);
+ spin_lock_irqsave(io_lock, flags);
+ io_req = (struct fnic_io_req *)CMD_SP(sc);
+ if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
+ !(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
/*
- * If there is a scsi_cmnd associated with this io_req, then
- * free the corresponding state
+ * We will be here only when FW completes reset
+ * without sending completions for outstanding ios.
*/
- start_time = io_req->start_time;
- fnic_release_ioreq_buf(fnic, io_req, sc);
- mempool_free(io_req, fnic->io_req_pool);
+ CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
+ if (io_req && io_req->dr_done)
+ complete(io_req->dr_done);
+ else if (io_req && io_req->abts_done)
+ complete(io_req->abts_done);
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ } else if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
+ if (!io_req) {
+ spin_unlock_irqrestore(io_lock, flags);
+ goto cleanup_scsi_cmd;
+ }
- sc->result = DID_TRANSPORT_DISRUPTED << 16;
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "%s: tag:0x%x : sc:0x%p duration = %lu DID_TRANSPORT_DISRUPTED\n",
- __func__, sc->request->tag, sc,
- (jiffies - start_time));
+ CMD_SP(sc) = NULL;
- if (atomic64_read(&fnic->io_cmpl_skip))
- atomic64_dec(&fnic->io_cmpl_skip);
- else
- atomic64_inc(&fnic_stats->io_stats.io_completions);
+ spin_unlock_irqrestore(io_lock, flags);
- /* Complete the command to SCSI */
- if (sc->scsi_done) {
- if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED))
- shost_printk(KERN_ERR, fnic->lport->host,
- "Calling done for IO not issued to fw: tag:0x%x sc:0x%p\n",
- sc->request->tag, sc);
+ /*
+ * If there is a scsi_cmnd associated with this io_req, then
+ * free the corresponding state
+ */
+ start_time = io_req->start_time;
+ fnic_release_ioreq_buf(fnic, io_req, sc);
+ mempool_free(io_req, fnic->io_req_pool);
- FNIC_TRACE(fnic_cleanup_io,
- sc->device->host->host_no, i, sc,
- jiffies_to_msecs(jiffies - start_time),
- 0, ((u64)sc->cmnd[0] << 32 |
- (u64)sc->cmnd[2] << 24 |
- (u64)sc->cmnd[3] << 16 |
- (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
- (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+cleanup_scsi_cmd:
+ sc->result = DID_TRANSPORT_DISRUPTED << 16;
+ FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+ "fnic_cleanup_io: tag:0x%x : sc:0x%p duration = %lu DID_TRANSPORT_DISRUPTED\n",
+ sc->request->tag, sc, (jiffies - start_time));
- sc->scsi_done(sc);
- }
+ if (atomic64_read(&fnic->io_cmpl_skip))
+ atomic64_dec(&fnic->io_cmpl_skip);
+ else
+ atomic64_inc(&fnic_stats->io_stats.io_completions);
+
+ /* Complete the command to SCSI */
+ if (sc->scsi_done) {
+ if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED))
+ shost_printk(KERN_ERR, fnic->lport->host,
+ "Calling done for IO not issued to fw: tag:0x%x sc:0x%p\n",
+ sc->request->tag, sc);
+
+ FNIC_TRACE(fnic_cleanup_io,
+ sc->device->host->host_no, sc->request->tag, sc,
+ jiffies_to_msecs(jiffies - start_time),
+ 0, ((u64)sc->cmnd[0] << 32 |
+ (u64)sc->cmnd[2] << 24 |
+ (u64)sc->cmnd[3] << 16 |
+ (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
+ (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+
+ sc->scsi_done(sc);
}
+ return true;
+}
+
+static void fnic_cleanup_io(struct fnic *fnic)
+{
+ scsi_host_busy_iter(fnic->lport->host,
+ fnic_cleanup_io_iter, fnic);
}
void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
@@ -1555,143 +1555,140 @@ static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
return 0;
}
-static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
+struct fnic_rport_abort_io_iter_data {
+ struct fnic *fnic;
+ u32 port_id;
+ int term_cnt;
+};
+
+static bool fnic_rport_abort_io(struct scsi_cmnd *sc, void *data, bool reserved)
{
- int tag;
- int abt_tag;
- int term_cnt = 0;
+ struct fnic_rport_abort_io_iter_data *iter_data = data;
+ struct fnic *fnic = iter_data->fnic;
+ int abt_tag = sc->request->tag;
struct fnic_io_req *io_req;
spinlock_t *io_lock;
unsigned long flags;
- struct scsi_cmnd *sc;
struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
struct scsi_lun fc_lun;
enum fnic_ioreq_state old_ioreq_state;
- FNIC_SCSI_DBG(KERN_DEBUG,
- fnic->lport->host,
- "fnic_rport_exch_reset called portid 0x%06x\n",
- port_id);
-
- if (fnic->in_remove)
- return;
-
- for (tag = 0; tag < fnic->fnic_max_tag_id; tag++) {
- abt_tag = tag;
- io_lock = fnic_io_lock_tag(fnic, tag);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(fnic->lport->host, tag);
- if (!sc) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
+ io_lock = fnic_io_lock_tag(fnic, abt_tag);
+ spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ io_req = (struct fnic_io_req *)CMD_SP(sc);
- if (!io_req || io_req->port_id != port_id) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
+ if (!io_req || io_req->port_id != iter_data->port_id) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
- (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+ if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
+ (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
+ FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
"fnic_rport_exch_reset dev rst not pending sc 0x%p\n",
sc);
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- /*
- * Found IO that is still pending with firmware and
- * belongs to rport that went away
- */
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
- if (io_req->abts_done) {
- shost_printk(KERN_ERR, fnic->lport->host,
+ /*
+ * Found IO that is still pending with firmware and
+ * belongs to rport that went away
+ */
+ if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
+ if (io_req->abts_done) {
+ shost_printk(KERN_ERR, fnic->lport->host,
"fnic_rport_exch_reset: io_req->abts_done is set "
"state is %s\n",
fnic_ioreq_state_to_str(CMD_STATE(sc)));
- }
+ }
- if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
- shost_printk(KERN_ERR, fnic->lport->host,
- "rport_exch_reset "
- "IO not yet issued %p tag 0x%x flags "
- "%x state %d\n",
- sc, tag, CMD_FLAGS(sc), CMD_STATE(sc));
- }
- old_ioreq_state = CMD_STATE(sc);
- CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
- CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
- atomic64_inc(&reset_stats->device_reset_terminates);
- abt_tag = (tag | FNIC_TAG_DEV_RST);
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "fnic_rport_exch_reset dev rst sc 0x%p\n",
- sc);
- }
+ if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
+ shost_printk(KERN_ERR, fnic->lport->host,
+ "rport_exch_reset "
+ "IO not yet issued %p tag 0x%x flags "
+ "%x state %d\n",
+ sc, abt_tag, CMD_FLAGS(sc), CMD_STATE(sc));
+ }
+ old_ioreq_state = CMD_STATE(sc);
+ CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
+ CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
+ if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+ atomic64_inc(&reset_stats->device_reset_terminates);
+ abt_tag |= FNIC_TAG_DEV_RST;
+ }
+ FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+ "fnic_rport_exch_reset dev rst sc 0x%p\n", sc);
+ BUG_ON(io_req->abts_done);
- BUG_ON(io_req->abts_done);
+ FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+ "fnic_rport_reset_exch: Issuing abts\n");
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "fnic_rport_reset_exch: Issuing abts\n");
+ spin_unlock_irqrestore(io_lock, flags);
+
+ /* Now queue the abort command to firmware */
+ int_to_scsilun(sc->device->lun, &fc_lun);
+ if (fnic_queue_abort_io_req(fnic, abt_tag,
+ FCPIO_ITMF_ABT_TASK_TERM,
+ fc_lun.scsi_lun, io_req)) {
+ /*
+ * Revert the cmd state back to old state, if
+ * it hasn't changed in between. This cmd will get
+ * aborted later by scsi_eh, or cleaned up during
+ * lun reset
+ */
+ spin_lock_irqsave(io_lock, flags);
+ if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
+ CMD_STATE(sc) = old_ioreq_state;
spin_unlock_irqrestore(io_lock, flags);
+ } else {
+ spin_lock_irqsave(io_lock, flags);
+ if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
+ CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
+ else
+ CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
+ spin_unlock_irqrestore(io_lock, flags);
+ atomic64_inc(&term_stats->terminates);
+ iter_data->term_cnt++;
+ }
+ return true;
+}
- /* Now queue the abort command to firmware */
- int_to_scsilun(sc->device->lun, &fc_lun);
+static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
+{
+ struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
+ struct fnic_rport_abort_io_iter_data iter_data = {
+ .fnic = fnic,
+ .port_id = port_id,
+ .term_cnt = 0,
+ };
- if (fnic_queue_abort_io_req(fnic, abt_tag,
- FCPIO_ITMF_ABT_TASK_TERM,
- fc_lun.scsi_lun, io_req)) {
- /*
- * Revert the cmd state back to old state, if
- * it hasn't changed in between. This cmd will get
- * aborted later by scsi_eh, or cleaned up during
- * lun reset
- */
- spin_lock_irqsave(io_lock, flags);
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
- CMD_STATE(sc) = old_ioreq_state;
- spin_unlock_irqrestore(io_lock, flags);
- } else {
- spin_lock_irqsave(io_lock, flags);
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
- CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
- else
- CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
- spin_unlock_irqrestore(io_lock, flags);
- atomic64_inc(&term_stats->terminates);
- term_cnt++;
- }
- }
- if (term_cnt > atomic64_read(&term_stats->max_terminates))
- atomic64_set(&term_stats->max_terminates, term_cnt);
+ FNIC_SCSI_DBG(KERN_DEBUG,
+ fnic->lport->host,
+ "fnic_rport_exch_reset called portid 0x%06x\n",
+ port_id);
+
+ if (fnic->in_remove)
+ return;
+
+ scsi_host_busy_iter(fnic->lport->host, fnic_rport_abort_io,
+ &iter_data);
+ if (iter_data.term_cnt > atomic64_read(&term_stats->max_terminates))
+ atomic64_set(&term_stats->max_terminates, iter_data.term_cnt);
}
void fnic_terminate_rport_io(struct fc_rport *rport)
{
- int tag;
- int abt_tag;
- int term_cnt = 0;
- struct fnic_io_req *io_req;
- spinlock_t *io_lock;
- unsigned long flags;
- struct scsi_cmnd *sc;
- struct scsi_lun fc_lun;
struct fc_rport_libfc_priv *rdata;
struct fc_lport *lport;
struct fnic *fnic;
- struct fc_rport *cmd_rport;
- struct reset_stats *reset_stats;
- struct terminate_stats *term_stats;
- enum fnic_ioreq_state old_ioreq_state;
if (!rport) {
printk(KERN_ERR "fnic_terminate_rport_io: rport is NULL\n");
@@ -1719,108 +1716,7 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
if (fnic->in_remove)
return;
- reset_stats = &fnic->fnic_stats.reset_stats;
- term_stats = &fnic->fnic_stats.term_stats;
-
- for (tag = 0; tag < fnic->fnic_max_tag_id; tag++) {
- abt_tag = tag;
- io_lock = fnic_io_lock_tag(fnic, tag);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(fnic->lport->host, tag);
- if (!sc) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- io_req = (struct fnic_io_req *)CMD_SP(sc);
- if (!io_req) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- cmd_rport = starget_to_rport(scsi_target(sc->device));
- if (rport != cmd_rport) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
- (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "fnic_terminate_rport_io dev rst not pending sc 0x%p\n",
- sc);
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
- /*
- * Found IO that is still pending with firmware and
- * belongs to rport that went away
- */
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
- if (io_req->abts_done) {
- shost_printk(KERN_ERR, fnic->lport->host,
- "fnic_terminate_rport_io: io_req->abts_done is set "
- "state is %s\n",
- fnic_ioreq_state_to_str(CMD_STATE(sc)));
- }
- if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
- FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
- "fnic_terminate_rport_io "
- "IO not yet issued %p tag 0x%x flags "
- "%x state %d\n",
- sc, tag, CMD_FLAGS(sc), CMD_STATE(sc));
- }
- old_ioreq_state = CMD_STATE(sc);
- CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
- CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
- atomic64_inc(&reset_stats->device_reset_terminates);
- abt_tag = (tag | FNIC_TAG_DEV_RST);
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "fnic_terminate_rport_io dev rst sc 0x%p\n", sc);
- }
-
- BUG_ON(io_req->abts_done);
-
- FNIC_SCSI_DBG(KERN_DEBUG,
- fnic->lport->host,
- "fnic_terminate_rport_io: Issuing abts\n");
-
- spin_unlock_irqrestore(io_lock, flags);
-
- /* Now queue the abort command to firmware */
- int_to_scsilun(sc->device->lun, &fc_lun);
-
- if (fnic_queue_abort_io_req(fnic, abt_tag,
- FCPIO_ITMF_ABT_TASK_TERM,
- fc_lun.scsi_lun, io_req)) {
- /*
- * Revert the cmd state back to old state, if
- * it hasn't changed in between. This cmd will get
- * aborted later by scsi_eh, or cleaned up during
- * lun reset
- */
- spin_lock_irqsave(io_lock, flags);
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
- CMD_STATE(sc) = old_ioreq_state;
- spin_unlock_irqrestore(io_lock, flags);
- } else {
- spin_lock_irqsave(io_lock, flags);
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
- CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
- else
- CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
- spin_unlock_irqrestore(io_lock, flags);
- atomic64_inc(&term_stats->terminates);
- term_cnt++;
- }
- }
- if (term_cnt > atomic64_read(&term_stats->max_terminates))
- atomic64_set(&term_stats->max_terminates, term_cnt);
-
+ fnic_rport_exch_reset(fnic, rport->port_id);
}
/*
@@ -2115,163 +2011,174 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic,
return ret;
}
-/*
- * Clean up any pending aborts on the lun
- * For each outstanding IO on this lun, whose abort is not completed by fw,
- * issue a local abort. Wait for abort to complete. Return 0 if all commands
- * successfully aborted, 1 otherwise
- */
-static int fnic_clean_pending_aborts(struct fnic *fnic,
- struct scsi_cmnd *lr_sc)
+struct fnic_pending_aborts_iter_data {
+ struct fnic *fnic;
+ struct scsi_device *lun_dev;
+ int ret;
+};
+
+static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
+ void *data, bool reserved)
{
- int tag, abt_tag;
+ struct fnic_pending_aborts_iter_data *iter_data = data;
+ struct fnic *fnic = iter_data->fnic;
+ struct scsi_device *lun_dev = iter_data->lun_dev;
+ int abt_tag = sc->request->tag;
struct fnic_io_req *io_req;
spinlock_t *io_lock;
unsigned long flags;
- int ret = 0;
- struct scsi_cmnd *sc;
struct scsi_lun fc_lun;
- struct scsi_device *lun_dev = lr_sc->device;
DECLARE_COMPLETION_ONSTACK(tm_done);
enum fnic_ioreq_state old_ioreq_state;
- for (tag = 0; tag < fnic->fnic_max_tag_id; tag++) {
- io_lock = fnic_io_lock_tag(fnic, tag);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(fnic->lport->host, tag);
- /*
- * ignore this lun reset cmd if issued using new SC
- * or cmds that do not belong to this lun
- */
- if (!sc || sc == lr_sc || sc->device != lun_dev) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- io_req = (struct fnic_io_req *)CMD_SP(sc);
-
- if (!io_req || sc->device != lun_dev) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- /*
- * Found IO that is still pending with firmware and
- * belongs to the LUN that we are resetting
- */
- FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
- "Found IO in %s on lun\n",
- fnic_ioreq_state_to_str(CMD_STATE(sc)));
+ if (sc->device != lun_dev)
+ return true;
+ if (reserved)
+ return true;
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
- if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
- (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
- FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
- "%s dev rst not pending sc 0x%p\n", __func__,
- sc);
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
+ io_lock = fnic_io_lock_tag(fnic, abt_tag);
+ spin_lock_irqsave(io_lock, flags);
+ io_req = (struct fnic_io_req *)CMD_SP(sc);
+ if (!io_req) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- if (io_req->abts_done)
- shost_printk(KERN_ERR, fnic->lport->host,
- "%s: io_req->abts_done is set state is %s\n",
- __func__, fnic_ioreq_state_to_str(CMD_STATE(sc)));
- old_ioreq_state = CMD_STATE(sc);
- /*
- * Any pending IO issued prior to reset is expected to be
- * in abts pending state, if not we need to set
- * FNIC_IOREQ_ABTS_PENDING to indicate the IO is abort pending.
- * When IO is completed, the IO will be handed over and
- * handled in this function.
- */
- CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
+ /*
+ * Found IO that is still pending with firmware and
+ * belongs to the LUN that we are resetting
+ */
+ FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+ "Found IO in %s on lun\n",
+ fnic_ioreq_state_to_str(CMD_STATE(sc)));
- BUG_ON(io_req->abts_done);
+ if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
+ if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
+ (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
+ FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
+ "%s dev rst not pending sc 0x%p\n", __func__,
+ sc);
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- abt_tag = tag;
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
- abt_tag |= FNIC_TAG_DEV_RST;
- FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
- "%s: dev rst sc 0x%p\n", __func__, sc);
- }
+ if (io_req->abts_done)
+ shost_printk(KERN_ERR, fnic->lport->host,
+ "%s: io_req->abts_done is set state is %s\n",
+ __func__, fnic_ioreq_state_to_str(CMD_STATE(sc)));
+ old_ioreq_state = CMD_STATE(sc);
+ /*
+ * Any pending IO issued prior to reset is expected to be
+ * in abts pending state, if not we need to set
+ * FNIC_IOREQ_ABTS_PENDING to indicate the IO is abort pending.
+ * When IO is completed, the IO will be handed over and
+ * handled in this function.
+ */
+ CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
- CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
- io_req->abts_done = &tm_done;
- spin_unlock_irqrestore(io_lock, flags);
+ BUG_ON(io_req->abts_done);
- /* Now queue the abort command to firmware */
- int_to_scsilun(sc->device->lun, &fc_lun);
+ if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+ abt_tag |= FNIC_TAG_DEV_RST;
+ FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
+ "%s: dev rst sc 0x%p\n", __func__, sc);
+ }
- if (fnic_queue_abort_io_req(fnic, abt_tag,
- FCPIO_ITMF_ABT_TASK_TERM,
- fc_lun.scsi_lun, io_req)) {
- spin_lock_irqsave(io_lock, flags);
- io_req = (struct fnic_io_req *)CMD_SP(sc);
- if (io_req)
- io_req->abts_done = NULL;
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
- CMD_STATE(sc) = old_ioreq_state;
- spin_unlock_irqrestore(io_lock, flags);
- ret = 1;
- goto clean_pending_aborts_end;
- } else {
- spin_lock_irqsave(io_lock, flags);
- if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
- CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
- spin_unlock_irqrestore(io_lock, flags);
- }
- CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
+ CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
+ io_req->abts_done = &tm_done;
+ spin_unlock_irqrestore(io_lock, flags);
- wait_for_completion_timeout(&tm_done,
- msecs_to_jiffies
- (fnic->config.ed_tov));
+ /* Now queue the abort command to firmware */
+ int_to_scsilun(sc->device->lun, &fc_lun);
- /* Recheck cmd state to check if it is now aborted */
+ if (fnic_queue_abort_io_req(fnic, abt_tag,
+ FCPIO_ITMF_ABT_TASK_TERM,
+ fc_lun.scsi_lun, io_req)) {
spin_lock_irqsave(io_lock, flags);
io_req = (struct fnic_io_req *)CMD_SP(sc);
- if (!io_req) {
- spin_unlock_irqrestore(io_lock, flags);
- CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
- continue;
- }
+ if (io_req)
+ io_req->abts_done = NULL;
+ if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
+ CMD_STATE(sc) = old_ioreq_state;
+ spin_unlock_irqrestore(io_lock, flags);
+ return false;
+ } else {
+ spin_lock_irqsave(io_lock, flags);
+ if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
+ CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
+ spin_unlock_irqrestore(io_lock, flags);
+ }
+ CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
- io_req->abts_done = NULL;
+ wait_for_completion_timeout(&tm_done, msecs_to_jiffies
+ (fnic->config.ed_tov));
- /* if abort is still pending with fw, fail */
- if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
- spin_unlock_irqrestore(io_lock, flags);
- CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
- ret = 1;
- goto clean_pending_aborts_end;
- }
- CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
+ /* Recheck cmd state to check if it is now aborted */
+ spin_lock_irqsave(io_lock, flags);
+ io_req = (struct fnic_io_req *)CMD_SP(sc);
+ if (!io_req) {
+ spin_unlock_irqrestore(io_lock, flags);
+ CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
+ return true;
+ }
- /* original sc used for lr is handled by dev reset code */
- if (sc != lr_sc)
- CMD_SP(sc) = NULL;
+ io_req->abts_done = NULL;
+
+ /* if abort is still pending with fw, fail */
+ if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
spin_unlock_irqrestore(io_lock, flags);
+ CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
+ iter_data->ret = FAILED;
+ return false;
+ }
+ CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
- /* original sc used for lr is handled by dev reset code */
- if (sc != lr_sc) {
- fnic_release_ioreq_buf(fnic, io_req, sc);
- mempool_free(io_req, fnic->io_req_pool);
- }
+ /* original sc used for lr is handled by dev reset code */
+ CMD_SP(sc) = NULL;
+ spin_unlock_irqrestore(io_lock, flags);
- /*
- * Any IO is returned during reset, it needs to call scsi_done
- * to return the scsi_cmnd to upper layer.
- */
- if (sc->scsi_done) {
- /* Set result to let upper SCSI layer retry */
- sc->result = DID_RESET << 16;
- sc->scsi_done(sc);
- }
+ /* original sc used for lr is handled by dev reset code */
+ fnic_release_ioreq_buf(fnic, io_req, sc);
+ mempool_free(io_req, fnic->io_req_pool);
+
+ /*
+ * Any IO is returned during reset, it needs to call scsi_done
+ * to return the scsi_cmnd to upper layer.
+ */
+ if (sc->scsi_done) {
+ /* Set result to let upper SCSI layer retry */
+ sc->result = DID_RESET << 16;
+ sc->scsi_done(sc);
}
+ return true;
+}
+
+/*
+ * Clean up any pending aborts on the lun
+ * For each outstanding IO on this lun, whose abort is not completed by fw,
+ * issue a local abort. Wait for abort to complete. Return 0 if all commands
+ * successfully aborted, 1 otherwise
+ */
+static int fnic_clean_pending_aborts(struct fnic *fnic,
+ struct scsi_cmnd *lr_sc)
+{
+ int ret = SUCCESS;
+ struct fnic_pending_aborts_iter_data iter_data = {
+ .fnic = fnic,
+ .lun_dev = lr_sc->device,
+ .ret = SUCCESS,
+ };
+
+ scsi_host_busy_iter(fnic->lport->host,
+ fnic_pending_aborts_iter, &iter_data);
+ if (iter_data.ret == FAILED) {
+ ret = iter_data.ret;
+ goto clean_pending_aborts_end;
+ }
schedule_timeout(msecs_to_jiffies(2 * fnic->config.ed_tov));
/* walk again to check, if IOs are still pending in fw */
@@ -2726,6 +2633,43 @@ void fnic_exch_mgr_reset(struct fc_lport *lp, u32 sid, u32 did)
}
+static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
+ bool reserved)
+{
+ struct fnic_pending_aborts_iter_data *iter_data = data;
+ struct fnic *fnic = iter_data->fnic;
+ int cmd_state;
+ struct fnic_io_req *io_req;
+ spinlock_t *io_lock;
+ unsigned long flags;
+
+ if (iter_data->lun_dev && sc->device != iter_data->lun_dev)
+ return true;
+
+ io_lock = fnic_io_lock_hash(fnic, sc);
+ spin_lock_irqsave(io_lock, flags);
+
+ io_req = (struct fnic_io_req *)CMD_SP(sc);
+ if (!io_req) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
+
+ /*
+ * Found IO that is still pending with firmware and
+ * belongs to the LUN that we are resetting
+ */
+ FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
+ "Found IO in %s on lun\n",
+ fnic_ioreq_state_to_str(CMD_STATE(sc)));
+ cmd_state = CMD_STATE(sc);
+ spin_unlock_irqrestore(io_lock, flags);
+ if (cmd_state == FNIC_IOREQ_ABTS_PENDING)
+ iter_data->ret = 1;
+
+ return iter_data->ret ? false : true;
+}
+
/*
* fnic_is_abts_pending() is a helper function that
* walks through tag map to check if there is any IOs pending,if there is one,
@@ -2735,49 +2679,18 @@ void fnic_exch_mgr_reset(struct fc_lport *lp, u32 sid, u32 did)
*/
int fnic_is_abts_pending(struct fnic *fnic, struct scsi_cmnd *lr_sc)
{
- int tag;
- struct fnic_io_req *io_req;
- spinlock_t *io_lock;
- unsigned long flags;
- int ret = 0;
- struct scsi_cmnd *sc;
- struct scsi_device *lun_dev = NULL;
+ struct fnic_pending_aborts_iter_data iter_data = {
+ .fnic = fnic,
+ .lun_dev = NULL,
+ .ret = 0,
+ };
if (lr_sc)
- lun_dev = lr_sc->device;
+ iter_data.lun_dev = lr_sc->device;
/* walk again to check, if IOs are still pending in fw */
- for (tag = 0; tag < fnic->fnic_max_tag_id; tag++) {
- sc = scsi_host_find_tag(fnic->lport->host, tag);
- /*
- * ignore this lun reset cmd or cmds that do not belong to
- * this lun
- */
- if (!sc || (lr_sc && (sc->device != lun_dev || sc == lr_sc)))
- continue;
-
- io_lock = fnic_io_lock_hash(fnic, sc);
- spin_lock_irqsave(io_lock, flags);
-
- io_req = (struct fnic_io_req *)CMD_SP(sc);
+ scsi_host_busy_iter(fnic->lport->host,
+ fnic_abts_pending_iter, &iter_data);
- if (!io_req || sc->device != lun_dev) {
- spin_unlock_irqrestore(io_lock, flags);
- continue;
- }
-
- /*
- * Found IO that is still pending with firmware and
- * belongs to the LUN that we are resetting
- */
- FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
- "Found IO in %s on lun\n",
- fnic_ioreq_state_to_str(CMD_STATE(sc)));
-
- if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
- ret = 1;
- spin_unlock_irqrestore(io_lock, flags);
- }
-
- return ret;
+ return iter_data.ret;
}
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 05/31] fnic: check for started requests in fnic_wq_copy_cleanup_handler()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (3 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 04/31] fnic: use scsi_host_busy_iter() to traverse commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 06/31] scsi: use real inquiry data when initialising devices Hannes Reinecke
` (28 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
fnic_wq_copy_cleanup_handler() is using scsi_host_find_tag() to
map id to a scsi command. However, as per discussion on the mailinglist
scsi_host_find_tag() might return a non-started request, so we need
to check the returned command with blk_mq_request_started() to avoid
the function tripping over a non-initialized command.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/fnic/fnic_scsi.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index c7f37afa3069..19324b52c089 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -1466,7 +1466,7 @@ void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
return;
sc = scsi_host_find_tag(fnic->lport->host, id);
- if (!sc)
+ if (!sc || !blk_mq_request_started(sc->request))
return;
io_lock = fnic_io_lock_hash(fnic, sc);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 06/31] scsi: use real inquiry data when initialising devices
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (4 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 05/31] fnic: check for started requests in fnic_wq_copy_cleanup_handler() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 07/31] scsi: Use dummy inquiry data for the host device Hannes Reinecke
` (27 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Use dummy inquiry data when initialising devices and not just
some 'nullnullnull' string.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/scsi_scan.c | 34 +++++++++++++++++++++++++---------
1 file changed, 25 insertions(+), 9 deletions(-)
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 9af50e6f94c4..11aec38250ca 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -81,7 +81,27 @@
#define SCSI_SCAN_TARGET_PRESENT 1
#define SCSI_SCAN_LUN_PRESENT 2
-static const char *scsi_null_device_strs = "nullnullnullnull";
+/*
+ * Dummy inquiry for virtual LUNs:
+ *
+ * standard INQUIRY: [qualifier indicates no connected LU]
+ * PQual=1 Device_type=31 RMB=0 LU_CONG=0 version=0x05 [SPC-3]
+ * [AERC=0] [TrmTsk=0] NormACA=0 HiSUP=0 Resp_data_format=2
+ * SCCS=0 ACC=0 TPGS=0 3PC=0 Protect=0 [BQue=0]
+ * EncServ=0 MultiP=0 [MChngr=0] [ACKREQQ=0] Addr16=0
+ * [RelAdr=0] WBus16=0 Sync=0 [Linked=0] [TranDis=0] CmdQue=0
+ * length=36 (0x24) Peripheral device type: no physical device on this lu
+ * Vendor identification: LINUX
+ * Product identification: VIRTUALLUN
+ * Product revision level: 1.0
+ */
+static const unsigned char scsi_null_inquiry[36] = {
+ 0x3f, 0x00, 0x05, 0x02, 0x1f, 0x00, 0x00, 0x00,
+ 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x20, 0x20, 0x20,
+ 0x56, 0x49, 0x52, 0x54, 0x55, 0x41, 0x4c, 0x4c,
+ 0x55, 0x4e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x31, 0x2e, 0x30, 0x20
+};
#define MAX_SCSI_LUNS 512
@@ -224,9 +244,10 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
if (!sdev)
goto out;
- sdev->vendor = scsi_null_device_strs;
- sdev->model = scsi_null_device_strs;
- sdev->rev = scsi_null_device_strs;
+ sdev->type = scsi_null_inquiry[0] & 0x1f;
+ sdev->vendor = scsi_null_inquiry + 8;
+ sdev->model = scsi_null_inquiry + 16;
+ sdev->rev = scsi_null_inquiry + 32;
sdev->host = shost;
sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
sdev->id = starget->id;
@@ -253,11 +274,6 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
* slave_configure function */
sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
- /*
- * Some low level driver could use device->type
- */
- sdev->type = -1;
-
/*
* Assume that the device will have handshaking problems,
* and then fix this field later if it turns out it
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 07/31] scsi: Use dummy inquiry data for the host device
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (5 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 06/31] scsi: use real inquiry data when initialising devices Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 08/31] scsi: revamp host device handling Hannes Reinecke
` (26 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Attach the dummy inquiry data to the scsi host device and use it
to check if any given device is a scsi host device.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/scsi_scan.c | 17 +++++++++++++++--
drivers/scsi/scsi_sysfs.c | 3 ++-
include/scsi/scsi_host.h | 7 ++++---
3 files changed, 21 insertions(+), 6 deletions(-)
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 11aec38250ca..234b1cd6b50d 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1921,9 +1921,11 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
goto out;
sdev = scsi_alloc_sdev(starget, 0, NULL);
- if (sdev)
+ if (sdev) {
sdev->borken = 0;
- else
+ sdev->inquiry = (unsigned char *)scsi_null_inquiry;
+ sdev->inquiry_len = sizeof(scsi_null_inquiry);
+ } else
scsi_target_reap(starget);
put_device(&starget->dev);
out:
@@ -1948,3 +1950,14 @@ void scsi_free_host_dev(struct scsi_device *sdev)
}
EXPORT_SYMBOL(scsi_free_host_dev);
+/**
+ * scsi_device_is_host_dev - Check if a scsi device is a host device
+ * @sdev: SCSI device to test
+ *
+ * Returns: true if @sdev is a host device, false otherwise
+ */
+bool scsi_device_is_host_dev(struct scsi_device *sdev)
+{
+ return ((const unsigned char *)sdev->inquiry == scsi_null_inquiry);
+}
+EXPORT_SYMBOL_GPL(scsi_device_is_host_dev);
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index b6378c8ca783..64b51ebdca76 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -496,7 +496,8 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)
kfree_rcu(vpd_pg80, rcu);
if (vpd_pg89)
kfree_rcu(vpd_pg89, rcu);
- kfree(sdev->inquiry);
+ if (!scsi_device_is_host_dev(sdev))
+ kfree(sdev->inquiry);
kfree(sdev);
if (parent)
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index e30fd963b97d..b077ad9c666b 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -788,14 +788,15 @@ void scsi_host_busy_iter(struct Scsi_Host *,
struct class_container;
/*
- * These two functions are used to allocate and free a pseudo device
- * which will connect to the host adapter itself rather than any
- * physical device. You must deallocate when you are done with the
+ * These three functions are used to allocate, free, and test for
+ * a pseudo device which will connect to the host adapter itself rather
+ * than any physical device. You must deallocate when you are done with the
* thing. This physical pseudo-device isn't real and won't be available
* from any high-level drivers.
*/
extern void scsi_free_host_dev(struct scsi_device *);
extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
+bool scsi_device_is_host_dev(struct scsi_device *);
/*
* DIF defines the exchange of protection information between
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 08/31] scsi: revamp host device handling
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (6 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 07/31] scsi: Use dummy inquiry data for the host device Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-24 13:12 ` John Garry
2021-02-22 13:23 ` [PATCH 09/31] snic: use reserved commands Hannes Reinecke
` (25 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Ensure that the host device is excluded from scanning by setting
the BLIST_NOLUN flag, and avoid it being presented in sysfs.
Also move the device id from using the ->this_id value as target
id (which is a bit odd as it's typically is set to -1 anyway) to
using ->max_channel + 1 as the channel number and '0' as the
target id.
With that the host device is now handled like any other scsi device,
which means we can drop the scsi_put_host_dev() function and let
scsi_forget_host() etc handle the deallocation.
We only need to ensure that the host device is deallocated last
is the driver might need it to send commands during teardown.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/scsi_devinfo.c | 1 +
drivers/scsi/scsi_scan.c | 55 +++++++++++++++++++------------------
include/scsi/scsi_host.h | 13 +++++----
3 files changed, 37 insertions(+), 32 deletions(-)
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index d92cec12454c..e70d87c5342b 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -195,6 +195,7 @@ static struct {
{"Intel", "Multi-Flex", NULL, BLIST_NO_RSOC},
{"iRiver", "iFP Mass Driver", NULL, BLIST_NOT_LOCKABLE | BLIST_INQUIRY_36},
{"LASOUND", "CDX7405", "3.10", BLIST_MAX5LUN | BLIST_SINGLELUN},
+ {"LINUX", "VIRTUALLUN", NULL, BLIST_NOLUN},
{"Marvell", "Console", NULL, BLIST_SKIP_VPD_PAGES},
{"Marvell", "91xx Config", "1.01", BLIST_SKIP_VPD_PAGES},
{"MATSHITA", "PD-1", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 234b1cd6b50d..573cf3a3ca28 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1094,6 +1094,15 @@ static int scsi_probe_and_add_lun(struct scsi_target *starget,
if (!sdev)
goto out;
+ if (scsi_device_is_host_dev(sdev)) {
+ bflags = scsi_get_device_flags(sdev,
+ sdev->vendor,
+ sdev->model);
+ if (bflagsp)
+ *bflagsp = bflags;
+ return SCSI_SCAN_LUN_PRESENT;
+ }
+
result = kmalloc(result_len, GFP_KERNEL |
((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
if (!result)
@@ -1712,6 +1721,9 @@ static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
/* If device is already visible, skip adding it to sysfs */
if (sdev->is_visible)
continue;
+ /* Host devices should never be visible in sysfs */
+ if (scsi_device_is_host_dev(sdev))
+ continue;
if (!scsi_host_scan_allowed(shost) ||
scsi_sysfs_add_sdev(sdev) != 0)
__scsi_remove_device(sdev);
@@ -1876,12 +1888,16 @@ EXPORT_SYMBOL(scsi_scan_host);
void scsi_forget_host(struct Scsi_Host *shost)
{
- struct scsi_device *sdev;
+ struct scsi_device *sdev, *host_sdev = NULL;
unsigned long flags;
restart:
spin_lock_irqsave(shost->host_lock, flags);
list_for_each_entry(sdev, &shost->__devices, siblings) {
+ if (scsi_device_is_host_dev(sdev)) {
+ host_sdev = sdev;
+ continue;
+ }
if (sdev->sdev_state == SDEV_DEL)
continue;
spin_unlock_irqrestore(shost->host_lock, flags);
@@ -1889,10 +1905,13 @@ void scsi_forget_host(struct Scsi_Host *shost)
goto restart;
}
spin_unlock_irqrestore(shost->host_lock, flags);
+ /* Remove host device last, might be needed to send commands */
+ if (host_sdev)
+ __scsi_remove_device(host_sdev);
}
/**
- * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself
+ * scsi_get_host_dev - Create a virtual scsi_device to the host adapter
* @shost: Host that needs a scsi_device
*
* Lock status: None assumed.
@@ -1900,13 +1919,12 @@ void scsi_forget_host(struct Scsi_Host *shost)
* Returns: The scsi_device or NULL
*
* Notes:
- * Attach a single scsi_device to the Scsi_Host - this should
- * be made to look like a "pseudo-device" that points to the
- * HA itself.
- *
- * Note - this device is not accessible from any high-level
- * drivers (including generics), which is probably not
- * optimal. We can add hooks later to attach.
+ * Attach a single scsi_device to the Scsi_Host. The primary aim
+ * for this device is to serve as a container from which valid
+ * scsi commands can be allocated from. Each scsi command will carry
+ * an unused/free command tag, which then can be used by the LLDD to
+ * send internal or passthrough commands without having to find a
+ * valid command tag internally.
*/
struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
{
@@ -1916,7 +1934,8 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
mutex_lock(&shost->scan_mutex);
if (!scsi_host_scan_allowed(shost))
goto out;
- starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
+ starget = scsi_alloc_target(&shost->shost_gendev,
+ shost->max_channel + 1, 0);
if (!starget)
goto out;
@@ -1934,22 +1953,6 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
}
EXPORT_SYMBOL(scsi_get_host_dev);
-/**
- * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself
- * @sdev: Host device to be freed
- *
- * Lock status: None assumed.
- *
- * Returns: Nothing
- */
-void scsi_free_host_dev(struct scsi_device *sdev)
-{
- BUG_ON(sdev->id != sdev->host->this_id);
-
- __scsi_remove_device(sdev);
-}
-EXPORT_SYMBOL(scsi_free_host_dev);
-
/**
* scsi_device_is_host_dev - Check if a scsi device is a host device
* @sdev: SCSI device to test
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index b077ad9c666b..ecc2d9dcfdf3 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -788,14 +788,15 @@ void scsi_host_busy_iter(struct Scsi_Host *,
struct class_container;
/*
- * These three functions are used to allocate, free, and test for
- * a pseudo device which will connect to the host adapter itself rather
- * than any physical device. You must deallocate when you are done with the
- * thing. This physical pseudo-device isn't real and won't be available
+ * These functions are used to allocate and test a pseudo device
+ * which will refer to the host adapter itself rather than any
+ * physical device. The device will be deallocated together with
+ * all other scsi devices, so there is no need to have a separate
+ * function to free it.
+ * This device will not show up in sysfs and won't be available
* from any high-level drivers.
*/
-extern void scsi_free_host_dev(struct scsi_device *);
-extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
+struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
bool scsi_device_is_host_dev(struct scsi_device *);
/*
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 09/31] snic: use reserved commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (7 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 08/31] scsi: revamp host device handling Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 10/31] snic: use tagset iter for traversing commands Hannes Reinecke
` (24 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Allocate a host device and use internal commands
for host and device reset.
This allows us to remove the special handling of
host and bus reset commands.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/snic/snic.h | 4 +-
drivers/scsi/snic/snic_main.c | 7 ++
drivers/scsi/snic/snic_scsi.c | 159 ++++++++++++++--------------------
3 files changed, 73 insertions(+), 97 deletions(-)
diff --git a/drivers/scsi/snic/snic.h b/drivers/scsi/snic/snic.h
index f4c666285bba..5a2428033190 100644
--- a/drivers/scsi/snic/snic.h
+++ b/drivers/scsi/snic/snic.h
@@ -59,7 +59,6 @@
*/
#define SNIC_TAG_ABORT BIT(30) /* Tag indicating abort */
#define SNIC_TAG_DEV_RST BIT(29) /* Tag for device reset */
-#define SNIC_TAG_IOCTL_DEV_RST BIT(28) /* Tag for User Device Reset */
#define SNIC_TAG_MASK (BIT(24) - 1) /* Mask for lookup */
#define SNIC_NO_TAG -1
@@ -278,6 +277,7 @@ struct snic {
/* Scsi Host info */
struct Scsi_Host *shost;
+ struct scsi_device *shost_dev;
/* vnic related structures */
struct vnic_dev_bar bar0;
@@ -380,7 +380,7 @@ int snic_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
int snic_abort_cmd(struct scsi_cmnd *);
int snic_device_reset(struct scsi_cmnd *);
int snic_host_reset(struct scsi_cmnd *);
-int snic_reset(struct Scsi_Host *, struct scsi_cmnd *);
+int snic_reset(struct Scsi_Host *);
void snic_shutdown_scsi_cleanup(struct snic *);
diff --git a/drivers/scsi/snic/snic_main.c b/drivers/scsi/snic/snic_main.c
index 14f4ce665e58..ce0e7ab4ef1d 100644
--- a/drivers/scsi/snic/snic_main.c
+++ b/drivers/scsi/snic/snic_main.c
@@ -303,6 +303,7 @@ static int
snic_add_host(struct Scsi_Host *shost, struct pci_dev *pdev)
{
int ret = 0;
+ struct snic *snic = shost_priv(shost);
ret = scsi_add_host(shost, &pdev->dev);
if (ret) {
@@ -313,6 +314,12 @@ snic_add_host(struct Scsi_Host *shost, struct pci_dev *pdev)
return ret;
}
+ snic->shost_dev = scsi_get_host_dev(shost);
+ if (!snic->shost_dev) {
+ SNIC_HOST_ERR(shost,
+ "snic: scsi_get_virtual_dev failed\n");
+ return -ENOMEM;
+ }
SNIC_BUG_ON(shost->work_q != NULL);
snprintf(shost->work_q_name, sizeof(shost->work_q_name), "scsi_wq_%d",
shost->host_no);
diff --git a/drivers/scsi/snic/snic_scsi.c b/drivers/scsi/snic/snic_scsi.c
index 6dd0ff188bb4..f5aca883b693 100644
--- a/drivers/scsi/snic/snic_scsi.c
+++ b/drivers/scsi/snic/snic_scsi.c
@@ -77,7 +77,7 @@ static const char * const snic_io_status_str[] = {
[SNIC_STAT_FATAL_ERROR] = "SNIC_STAT_FATAL_ERROR",
};
-static void snic_scsi_cleanup(struct snic *, int);
+static void snic_scsi_cleanup(struct snic *);
const char *
snic_state_to_str(unsigned int state)
@@ -867,7 +867,6 @@ snic_process_itmf_cmpl(struct snic *snic,
break;
case SNIC_TAG_DEV_RST:
- case SNIC_TAG_DEV_RST | SNIC_TAG_IOCTL_DEV_RST:
snic_proc_dr_cmpl_locked(snic, fwreq, cmpl_stat, cmnd_id, sc);
spin_unlock_irqrestore(io_lock, flags);
ret = 0;
@@ -920,7 +919,6 @@ static void
snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
{
struct scsi_cmnd *sc = NULL;
- struct snic_req_info *rqi = NULL;
struct snic_itmf_cmpl *itmf_cmpl = NULL;
ulong ctx;
u32 cmnd_id;
@@ -938,14 +936,6 @@ snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
"Itmf_cmpl: nterm %u , flags 0x%x\n",
le32_to_cpu(itmf_cmpl->nterminated), itmf_cmpl->flags);
- /* spl case, dev reset issued through ioctl */
- if (cmnd_id & SNIC_TAG_IOCTL_DEV_RST) {
- rqi = (struct snic_req_info *) ctx;
- sc = rqi->sc;
-
- goto ioctl_dev_rst;
- }
-
if ((cmnd_id & SNIC_TAG_MASK) >= snic->max_tag_id) {
SNIC_HOST_ERR(snic->shost,
"Itmf_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
@@ -958,7 +948,6 @@ snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
sc = scsi_host_find_tag(snic->shost, cmnd_id & SNIC_TAG_MASK);
WARN_ON_ONCE(!sc);
-ioctl_dev_rst:
if (!sc) {
atomic64_inc(&snic->s_stats.io.sc_null);
SNIC_HOST_ERR(snic->shost,
@@ -974,13 +963,13 @@ snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
static void
-snic_hba_reset_scsi_cleanup(struct snic *snic, struct scsi_cmnd *sc)
+snic_hba_reset_scsi_cleanup(struct snic *snic)
{
struct snic_stats *st = &snic->s_stats;
long act_ios = 0, act_fwreqs = 0;
SNIC_SCSI_DBG(snic->shost, "HBA Reset scsi cleanup.\n");
- snic_scsi_cleanup(snic, snic_cmd_tag(sc));
+ snic_scsi_cleanup(snic);
/* Update stats on pending IOs */
act_ios = atomic64_read(&st->io.active);
@@ -1021,17 +1010,6 @@ snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
"reset_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n",
typ, hdr_stat, cmnd_id, hid, ctx);
- /* spl case, host reset issued through ioctl */
- if (cmnd_id == SCSI_NO_TAG) {
- rqi = (struct snic_req_info *) ctx;
- SNIC_HOST_INFO(snic->shost,
- "reset_cmpl:Tag %d ctx %lx cmpl stat %s\n",
- cmnd_id, ctx, snic_io_status_to_str(hdr_stat));
- sc = rqi->sc;
-
- goto ioctl_hba_rst;
- }
-
if (cmnd_id >= snic->max_tag_id) {
SNIC_HOST_ERR(snic->shost,
"reset_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
@@ -1042,7 +1020,6 @@ snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
}
sc = scsi_host_find_tag(snic->shost, cmnd_id);
-ioctl_hba_rst:
if (!sc) {
atomic64_inc(&snic->s_stats.io.sc_null);
SNIC_HOST_ERR(snic->shost,
@@ -1089,7 +1066,7 @@ snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
spin_unlock_irqrestore(io_lock, flags);
/* scsi cleanup */
- snic_hba_reset_scsi_cleanup(snic, sc);
+ snic_hba_reset_scsi_cleanup(snic);
SNIC_BUG_ON(snic_get_state(snic) != SNIC_OFFLINE &&
snic_get_state(snic) != SNIC_FWRESET);
@@ -1359,7 +1336,7 @@ snic_issue_tm_req(struct snic *snic,
int tmf)
{
struct snic_host_req *tmreq = NULL;
- int req_id = 0, tag = snic_cmd_tag(sc);
+ int tag = snic_cmd_tag(sc);
int ret = 0;
if (snic_get_state(snic) == SNIC_FWRESET)
@@ -1372,13 +1349,10 @@ snic_issue_tm_req(struct snic *snic,
tmf, rqi, tag);
- if (tmf == SNIC_ITMF_LUN_RESET) {
+ if (tmf == SNIC_ITMF_LUN_RESET)
tmreq = snic_dr_req_init(snic, rqi);
- req_id = SCSI_NO_TAG;
- } else {
+ else
tmreq = snic_abort_req_init(snic, rqi);
- req_id = tag;
- }
if (!tmreq) {
ret = -ENOMEM;
@@ -1386,17 +1360,17 @@ snic_issue_tm_req(struct snic *snic,
goto tmreq_err;
}
- ret = snic_queue_itmf_req(snic, tmreq, sc, tmf, req_id);
+ ret = snic_queue_itmf_req(snic, tmreq, sc, tmf, tag);
tmreq_err:
if (ret) {
SNIC_HOST_ERR(snic->shost,
- "issu_tmreq: Queueing ITMF(%d) Req, sc %p rqi %p req_id %d tag %x fails err = %d\n",
- tmf, sc, rqi, req_id, tag, ret);
+ "issu_tmreq: Queing ITMF(%d) Req, sc %p rqi %p tag %x fails err = %d\n",
+ tmf, sc, rqi, tag, ret);
} else {
SNIC_SCSI_DBG(snic->shost,
- "issu_tmreq: Queueing ITMF(%d) Req, sc %p, rqi %p, req_id %d tag %x - Success.\n",
- tmf, sc, rqi, req_id, tag);
+ "issu_tmreq: Queuing ITMF(%d) Req, sc %p, rqi %p, tag %x - Success.\n",
+ tmf, sc, rqi, tag);
}
atomic_dec(&snic->ios_inflight);
@@ -2146,7 +2120,7 @@ snic_device_reset(struct scsi_cmnd *sc)
struct Scsi_Host *shost = sc->device->host;
struct snic *snic = shost_priv(shost);
struct snic_req_info *rqi = NULL;
- int tag = snic_cmd_tag(sc);
+ struct scsi_cmnd *reset_sc = NULL;
int start_time = jiffies;
int ret = FAILED;
int dr_supp = 0;
@@ -2170,42 +2144,41 @@ snic_device_reset(struct scsi_cmnd *sc)
goto dev_rst_end;
}
- /* There is no tag when lun reset is issue through ioctl. */
- if (unlikely(tag <= SNIC_NO_TAG)) {
- SNIC_HOST_INFO(snic->shost,
- "Devrst: LUN Reset Recvd thru IOCTL.\n");
+ reset_sc = scsi_get_internal_cmd(sc->device, DMA_NONE, REQ_NOWAIT);
+ if (!reset_sc)
+ goto dev_rst_end;
- rqi = snic_req_init(snic, 0);
- if (!rqi)
- goto dev_rst_end;
+ rqi = snic_req_init(snic, 0);
+ if (!rqi)
+ goto dev_rst_end;
- memset(scsi_cmd_priv(sc), 0,
- sizeof(struct snic_internal_io_state));
- CMD_SP(sc) = (char *)rqi;
- CMD_FLAGS(sc) = SNIC_NO_FLAGS;
+ memset(scsi_cmd_priv(reset_sc), 0,
+ sizeof(struct snic_internal_io_state));
+ CMD_SP(reset_sc) = (char *)rqi;
+ CMD_FLAGS(reset_sc) = SNIC_NO_FLAGS;
- /* Add special tag for dr coming from user spc */
- rqi->tm_tag = SNIC_TAG_IOCTL_DEV_RST;
- rqi->sc = sc;
- }
+ rqi->sc = reset_sc;
- ret = snic_send_dr_and_wait(snic, sc);
+ ret = snic_send_dr_and_wait(snic, reset_sc);
if (ret) {
SNIC_HOST_ERR(snic->shost,
"Devrst: IO w/ Tag %x Failed w/ err = %d\n",
- tag, ret);
+ snic_cmd_tag(reset_sc), ret);
- snic_unlink_and_release_req(snic, sc, 0);
+ snic_unlink_and_release_req(snic, reset_sc, 0);
goto dev_rst_end;
}
- ret = snic_dr_finish(snic, sc);
+ ret = snic_dr_finish(snic, reset_sc);
dev_rst_end:
- SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
- jiffies_to_msecs(jiffies - start_time),
- 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
+ if (reset_sc) {
+ SNIC_TRC(snic->shost->host_no, snic_cmd_tag(reset_sc), (ulong) reset_sc,
+ jiffies_to_msecs(jiffies - start_time),
+ 0, SNIC_TRC_CMD(reset_sc), SNIC_TRC_CMD_STATE_FLAGS(reset_sc));
+ scsi_put_internal_cmd(reset_sc);
+ }
SNIC_SCSI_DBG(snic->shost,
"Devrst: Returning from Device Reset : %s\n",
@@ -2225,10 +2198,11 @@ snic_device_reset(struct scsi_cmnd *sc)
* snic_issue_hba_reset : Queues FW Reset Request.
*/
static int
-snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
+snic_issue_hba_reset(struct snic *snic)
{
struct snic_req_info *rqi = NULL;
struct snic_host_req *req = NULL;
+ struct scsi_cmnd *reset_sc;
spinlock_t *io_lock = NULL;
DECLARE_COMPLETION_ONSTACK(wait);
unsigned long flags;
@@ -2237,30 +2211,31 @@ snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
rqi = snic_req_init(snic, 0);
if (!rqi) {
ret = -ENOMEM;
-
goto hba_rst_end;
}
- if (snic_cmd_tag(sc) == SCSI_NO_TAG) {
- memset(scsi_cmd_priv(sc), 0,
- sizeof(struct snic_internal_io_state));
- SNIC_HOST_INFO(snic->shost, "issu_hr:Host reset thru ioctl.\n");
- rqi->sc = sc;
+ reset_sc = scsi_get_internal_cmd(snic->shost_dev,
+ DMA_NONE, REQ_NOWAIT);
+ if (!reset_sc) {
+ ret = -EBUSY;
+ goto hba_rst_end_put;
}
-
+ memset(scsi_cmd_priv(reset_sc), 0,
+ sizeof(struct snic_internal_io_state));
+ rqi->sc = reset_sc;
req = rqi_to_req(rqi);
- io_lock = snic_io_lock_hash(snic, sc);
+ io_lock = snic_io_lock_hash(snic, reset_sc);
spin_lock_irqsave(io_lock, flags);
- SNIC_BUG_ON(CMD_SP(sc) != NULL);
- CMD_STATE(sc) = SNIC_IOREQ_PENDING;
- CMD_SP(sc) = (char *) rqi;
- CMD_FLAGS(sc) |= SNIC_IO_INITIALIZED;
+ SNIC_BUG_ON(CMD_SP(reset_sc) != NULL);
+ CMD_STATE(reset_sc) = SNIC_IOREQ_PENDING;
+ CMD_SP(reset_sc) = (char *) rqi;
+ CMD_FLAGS(reset_sc) |= SNIC_IO_INITIALIZED;
snic->remove_wait = &wait;
spin_unlock_irqrestore(io_lock, flags);
/* Initialize Request */
- snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(sc),
+ snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(reset_sc),
snic->config.hid, 0, (ulong) rqi);
req->u.reset.flags = 0;
@@ -2275,7 +2250,7 @@ snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
}
spin_lock_irqsave(io_lock, flags);
- CMD_FLAGS(sc) |= SNIC_HOST_RESET_ISSUED;
+ CMD_FLAGS(reset_sc) |= SNIC_HOST_RESET_ISSUED;
spin_unlock_irqrestore(io_lock, flags);
atomic64_inc(&snic->s_stats.reset.hba_resets);
SNIC_HOST_INFO(snic->shost, "Queued HBA Reset Successfully.\n");
@@ -2292,13 +2267,14 @@ snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
spin_lock_irqsave(io_lock, flags);
snic->remove_wait = NULL;
- rqi = (struct snic_req_info *) CMD_SP(sc);
- CMD_SP(sc) = NULL;
+ rqi = (struct snic_req_info *) CMD_SP(reset_sc);
+ CMD_SP(reset_sc) = NULL;
spin_unlock_irqrestore(io_lock, flags);
if (rqi)
snic_req_free(snic, rqi);
+ scsi_put_internal_cmd(reset_sc);
ret = 0;
return ret;
@@ -2306,10 +2282,13 @@ snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
hba_rst_err:
spin_lock_irqsave(io_lock, flags);
snic->remove_wait = NULL;
- rqi = (struct snic_req_info *) CMD_SP(sc);
- CMD_SP(sc) = NULL;
+ rqi = (struct snic_req_info *) CMD_SP(reset_sc);
+ CMD_SP(reset_sc) = NULL;
spin_unlock_irqrestore(io_lock, flags);
+hba_rst_end_put:
+ if (reset_sc)
+ scsi_put_internal_cmd(reset_sc);
if (rqi)
snic_req_free(snic, rqi);
@@ -2322,7 +2301,7 @@ snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
} /* end of snic_issue_hba_reset */
int
-snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc)
+snic_reset(struct Scsi_Host *shost)
{
struct snic *snic = shost_priv(shost);
enum snic_state sv_state;
@@ -2351,7 +2330,7 @@ snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc)
while (atomic_read(&snic->ios_inflight))
schedule_timeout(msecs_to_jiffies(1));
- ret = snic_issue_hba_reset(snic, sc);
+ ret = snic_issue_hba_reset(snic);
if (ret) {
SNIC_HOST_ERR(shost,
"reset:Host Reset Failed w/ err %d.\n",
@@ -2390,7 +2369,7 @@ snic_host_reset(struct scsi_cmnd *sc)
sc, sc->cmnd[0], sc->request,
snic_cmd_tag(sc), CMD_FLAGS(sc));
- ret = snic_reset(shost, sc);
+ ret = snic_reset(shost);
SNIC_TRC(shost->host_no, snic_cmd_tag(sc), (ulong) sc,
jiffies_to_msecs(jiffies - start_time),
@@ -2432,7 +2411,7 @@ snic_cmpl_pending_tmreq(struct snic *snic, struct scsi_cmnd *sc)
* snic_scsi_cleanup: Walks through tag map and releases the reqs
*/
static void
-snic_scsi_cleanup(struct snic *snic, int ex_tag)
+snic_scsi_cleanup(struct snic *snic)
{
struct snic_req_info *rqi = NULL;
struct scsi_cmnd *sc = NULL;
@@ -2444,19 +2423,9 @@ snic_scsi_cleanup(struct snic *snic, int ex_tag)
SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n");
for (tag = 0; tag < snic->max_tag_id; tag++) {
- /* Skip ex_tag */
- if (tag == ex_tag)
- continue;
-
io_lock = snic_io_lock_tag(snic, tag);
spin_lock_irqsave(io_lock, flags);
sc = scsi_host_find_tag(snic->shost, tag);
- if (!sc) {
- spin_unlock_irqrestore(io_lock, flags);
-
- continue;
- }
-
if (unlikely(snic_tmreq_pending(sc))) {
/*
* When FW Completes reset w/o sending completions
@@ -2516,7 +2485,7 @@ snic_shutdown_scsi_cleanup(struct snic *snic)
{
SNIC_HOST_INFO(snic->shost, "Shutdown time SCSI Cleanup.\n");
- snic_scsi_cleanup(snic, SCSI_NO_TAG);
+ snic_scsi_cleanup(snic);
} /* end of snic_shutdown_scsi_cleanup */
/*
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 10/31] snic: use tagset iter for traversing commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (8 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 09/31] snic: use reserved commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 11/31] snic: check for started requests in snic_hba_reset_cmpl_handler() Hannes Reinecke
` (23 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Use the tagset iter to traverse active commands during device and
hba reset.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/snic/snic_scsi.c | 366 +++++++++++++++++-----------------
1 file changed, 187 insertions(+), 179 deletions(-)
diff --git a/drivers/scsi/snic/snic_scsi.c b/drivers/scsi/snic/snic_scsi.c
index f5aca883b693..16502633287a 100644
--- a/drivers/scsi/snic/snic_scsi.c
+++ b/drivers/scsi/snic/snic_scsi.c
@@ -1641,90 +1641,97 @@ snic_abort_cmd(struct scsi_cmnd *sc)
return ret;
}
+struct snic_cmd_pending_iter_data {
+ struct snic *snic;
+ struct scsi_device *sdev;
+ int ret;
+};
-
-static int
-snic_is_abts_pending(struct snic *snic, struct scsi_cmnd *lr_sc)
+static bool
+snic_is_abts_pending_iter(struct scsi_cmnd *sc, void *data, bool reserved)
{
+ struct snic_cmd_pending_iter_data *iter_data = data;
struct snic_req_info *rqi = NULL;
- struct scsi_cmnd *sc = NULL;
- struct scsi_device *lr_sdev = NULL;
spinlock_t *io_lock = NULL;
- u32 tag;
unsigned long flags;
- if (lr_sc)
- lr_sdev = lr_sc->device;
+ if (reserved)
+ return true;
- /* walk through the tag map, an dcheck if IOs are still pending in fw*/
- for (tag = 0; tag < snic->max_tag_id; tag++) {
- io_lock = snic_io_lock_tag(snic, tag);
-
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(snic->shost, tag);
-
- if (!sc || (lr_sc && (sc->device != lr_sdev || sc == lr_sc))) {
- spin_unlock_irqrestore(io_lock, flags);
+ if (iter_data->sdev && iter_data->sdev != sc->device)
+ return true;
- continue;
- }
+ io_lock = snic_io_lock_hash(iter_data->snic, sc);
+ spin_lock_irqsave(io_lock, flags);
- rqi = (struct snic_req_info *) CMD_SP(sc);
- if (!rqi) {
- spin_unlock_irqrestore(io_lock, flags);
+ rqi = (struct snic_req_info *) CMD_SP(sc);
+ if (!rqi) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- continue;
- }
+ /*
+ * Found IO that is still pending w/ firmware and belongs to
+ * the LUN that is under reset, if lr_sc != NULL
+ */
+ SNIC_SCSI_DBG(iter_data->snic->shost, "Found IO in %s on LUN\n",
+ snic_ioreq_state_to_str(CMD_STATE(sc)));
- /*
- * Found IO that is still pending w/ firmware and belongs to
- * the LUN that is under reset, if lr_sc != NULL
- */
- SNIC_SCSI_DBG(snic->shost, "Found IO in %s on LUN\n",
- snic_ioreq_state_to_str(CMD_STATE(sc)));
+ if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
+ iter_data->ret = 1;
+ spin_unlock_irqrestore(io_lock, flags);
- if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
- spin_unlock_irqrestore(io_lock, flags);
+ return true;
+}
- return 1;
- }
+static int
+snic_is_abts_pending(struct snic *snic, struct scsi_device *lr_sdev)
+{
+ struct snic_cmd_pending_iter_data iter_data = {
+ .snic = snic,
+ .sdev = lr_sdev,
+ .ret = 0,
+ };
- spin_unlock_irqrestore(io_lock, flags);
- }
+ /* walk through the tag map, an dcheck if IOs are still pending in fw*/
+ scsi_host_busy_iter(snic->shost,
+ snic_is_abts_pending_iter, &iter_data);
- return 0;
+ return iter_data.ret;
} /* end of snic_is_abts_pending */
-static int
-snic_dr_clean_single_req(struct snic *snic,
- u32 tag,
- struct scsi_device *lr_sdev)
+static bool
+snic_dr_clean_single_req(struct scsi_cmnd *sc, void *data, bool reserved)
{
struct snic_req_info *rqi = NULL;
struct snic_tgt *tgt = NULL;
- struct scsi_cmnd *sc = NULL;
spinlock_t *io_lock = NULL;
u32 sv_state = 0, tmf = 0;
DECLARE_COMPLETION_ONSTACK(tm_done);
unsigned long flags;
int ret = 0;
+ struct snic_cmd_pending_iter_data *iter_data = data;
+ struct snic *snic = iter_data->snic;
- io_lock = snic_io_lock_tag(snic, tag);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(snic->shost, tag);
+ if (reserved)
+ return true;
- /* Ignore Cmd that don't belong to Lun Reset device */
- if (!sc || sc->device != lr_sdev)
- goto skip_clean;
+ if (sc->device != iter_data->sdev)
+ return true;
+ io_lock = snic_io_lock_hash(snic, sc);
+ spin_lock_irqsave(io_lock, flags);
rqi = (struct snic_req_info *) CMD_SP(sc);
-
- if (!rqi)
- goto skip_clean;
+ if (!rqi) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
- if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
- goto skip_clean;
+ if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
+ }
if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) &&
@@ -1733,8 +1740,8 @@ snic_dr_clean_single_req(struct snic *snic,
SNIC_SCSI_DBG(snic->shost,
"clean_single_req: devrst is not pending sc 0x%p\n",
sc);
-
- goto skip_clean;
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;
}
SNIC_SCSI_DBG(snic->shost,
@@ -1777,7 +1784,7 @@ snic_dr_clean_single_req(struct snic *snic,
if (ret) {
SNIC_HOST_ERR(snic->shost,
"clean_single_req_err:sc %p, tag %d abt failed. tm_tag %d flags 0x%llx\n",
- sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
+ sc, snic_cmd_tag(sc), rqi->tm_tag, CMD_FLAGS(sc));
spin_lock_irqsave(io_lock, flags);
rqi = (struct snic_req_info *) CMD_SP(sc);
@@ -1788,8 +1795,9 @@ snic_dr_clean_single_req(struct snic *snic,
if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
CMD_STATE(sc) = sv_state;
- ret = 1;
- goto skip_clean;
+ iter_data->ret = 1;
+ spin_unlock_irqrestore(io_lock, flags);
+ return false;
}
spin_lock_irqsave(io_lock, flags);
@@ -1806,7 +1814,8 @@ snic_dr_clean_single_req(struct snic *snic,
rqi = (struct snic_req_info *) CMD_SP(sc);
if (!rqi) {
CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
- goto skip_clean;
+ spin_unlock_irqrestore(io_lock, flags);
+ return true;;
}
rqi->abts_done = NULL;
@@ -1814,14 +1823,13 @@ snic_dr_clean_single_req(struct snic *snic,
if (CMD_ABTS_STATUS(sc) == SNIC_INVALID_CODE) {
SNIC_HOST_ERR(snic->shost,
"clean_single_req_err:sc %p tag %d abt still pending w/ fw, tm_tag %d flags 0x%llx\n",
- sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
+ sc, snic_cmd_tag(sc), rqi->tm_tag, CMD_FLAGS(sc));
CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE;
- ret = 1;
-
- goto skip_clean;
+ iter_data->ret = 1;
+ spin_unlock_irqrestore(io_lock, flags);
+ return false;
}
-
CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
CMD_SP(sc) = NULL;
spin_unlock_irqrestore(io_lock, flags);
@@ -1831,39 +1839,31 @@ snic_dr_clean_single_req(struct snic *snic,
sc->result = (DID_ERROR << 16);
sc->scsi_done(sc);
- ret = 0;
-
- return ret;
-
-skip_clean:
- spin_unlock_irqrestore(io_lock, flags);
-
- return ret;
+ return true;
} /* end of snic_dr_clean_single_req */
static int
-snic_dr_clean_pending_req(struct snic *snic, struct scsi_cmnd *lr_sc)
+snic_dr_clean_pending_req(struct snic *snic, struct scsi_device *lr_sdev)
{
- struct scsi_device *lr_sdev = lr_sc->device;
- u32 tag = 0;
int ret = FAILED;
+ struct snic_cmd_pending_iter_data iter_data = {
+ .snic = snic,
+ .sdev = lr_sdev,
+ .ret = 0,
+ };
- for (tag = 0; tag < snic->max_tag_id; tag++) {
- if (tag == snic_cmd_tag(lr_sc))
- continue;
+ scsi_host_busy_iter(snic->shost,
+ snic_dr_clean_single_req, &iter_data);
+ if (iter_data.ret) {
+ SNIC_HOST_ERR(snic->shost, "clean_err = %d\n", iter_data.ret);
- ret = snic_dr_clean_single_req(snic, tag, lr_sdev);
- if (ret) {
- SNIC_HOST_ERR(snic->shost, "clean_err:tag = %d\n", tag);
-
- goto clean_err;
- }
+ goto clean_err;
}
schedule_timeout(msecs_to_jiffies(100));
/* Walk through all the cmds and check abts status. */
- if (snic_is_abts_pending(snic, lr_sc)) {
+ if (snic_is_abts_pending(snic, lr_sdev)) {
ret = FAILED;
goto clean_err;
@@ -1950,7 +1950,7 @@ snic_dr_finish(struct snic *snic, struct scsi_cmnd *sc)
* succeeds.
*/
- ret = snic_dr_clean_pending_req(snic, sc);
+ ret = snic_dr_clean_pending_req(snic, sc->device);
if (ret) {
spin_lock_irqsave(io_lock, flags);
SNIC_SCSI_DBG(snic->shost,
@@ -2407,77 +2407,79 @@ snic_cmpl_pending_tmreq(struct snic *snic, struct scsi_cmnd *sc)
complete(rqi->abts_done);
}
-/*
- * snic_scsi_cleanup: Walks through tag map and releases the reqs
- */
-static void
-snic_scsi_cleanup(struct snic *snic)
+static bool
+snic_scsi_cleanup_iter(struct scsi_cmnd *sc, void *data, bool rsvd)
{
+ struct snic *snic = data;
struct snic_req_info *rqi = NULL;
- struct scsi_cmnd *sc = NULL;
spinlock_t *io_lock = NULL;
unsigned long flags;
- int tag;
+ int tag = snic_cmd_tag(sc);
u64 st_time = 0;
- SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n");
-
- for (tag = 0; tag < snic->max_tag_id; tag++) {
- io_lock = snic_io_lock_tag(snic, tag);
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(snic->shost, tag);
- if (unlikely(snic_tmreq_pending(sc))) {
- /*
- * When FW Completes reset w/o sending completions
- * for outstanding ios.
- */
- snic_cmpl_pending_tmreq(snic, sc);
- spin_unlock_irqrestore(io_lock, flags);
-
- continue;
- }
-
- rqi = (struct snic_req_info *) CMD_SP(sc);
- if (!rqi) {
- spin_unlock_irqrestore(io_lock, flags);
+ io_lock = snic_io_lock_hash(snic, sc);
+ spin_lock_irqsave(io_lock, flags);
+ if (unlikely(snic_tmreq_pending(sc))) {
+ /*
+ * When FW Completes reset w/o sending completions
+ * for outstanding ios.
+ */
+ snic_cmpl_pending_tmreq(snic, sc);
+ spin_unlock_irqrestore(io_lock, flags);
- goto cleanup;
- }
+ return true;
+ }
+ rqi = (struct snic_req_info *) CMD_SP(sc);
+ if (!rqi) {
+ spin_unlock_irqrestore(io_lock, flags);
+ goto cleanup;
+ }
- SNIC_SCSI_DBG(snic->shost,
- "sc_clean: sc %p, rqi %p, tag %d flags 0x%llx\n",
- sc, rqi, tag, CMD_FLAGS(sc));
+ SNIC_SCSI_DBG(snic->shost,
+ "sc_clean: sc %p, rqi %p, tag %d flags 0x%llx\n",
+ sc, rqi, tag, CMD_FLAGS(sc));
- CMD_SP(sc) = NULL;
- CMD_FLAGS(sc) |= SNIC_SCSI_CLEANUP;
- spin_unlock_irqrestore(io_lock, flags);
- st_time = rqi->start_time;
+ CMD_SP(sc) = NULL;
+ CMD_FLAGS(sc) |= SNIC_SCSI_CLEANUP;
+ spin_unlock_irqrestore(io_lock, flags);
+ st_time = rqi->start_time;
- SNIC_HOST_INFO(snic->shost,
- "sc_clean: Releasing rqi %p : flags 0x%llx\n",
- rqi, CMD_FLAGS(sc));
+ SNIC_HOST_INFO(snic->shost,
+ "sc_clean: Releasing rqi %p : flags 0x%llx\n",
+ rqi, CMD_FLAGS(sc));
- snic_release_req_buf(snic, rqi, sc);
+ snic_release_req_buf(snic, rqi, sc);
cleanup:
- sc->result = DID_TRANSPORT_DISRUPTED << 16;
- SNIC_HOST_INFO(snic->shost,
- "sc_clean: DID_TRANSPORT_DISRUPTED for sc %p, Tag %d flags 0x%llx rqi %p duration %u msecs\n",
- sc, sc->request->tag, CMD_FLAGS(sc), rqi,
- jiffies_to_msecs(jiffies - st_time));
+ sc->result = DID_TRANSPORT_DISRUPTED << 16;
+ SNIC_HOST_INFO(snic->shost,
+ "sc_clean: DID_TRANSPORT_DISRUPTED for sc %p, Tag %d flags 0x%llx rqi %p duration %u msecs\n",
+ sc, tag, CMD_FLAGS(sc), rqi,
+ jiffies_to_msecs(jiffies - st_time));
- /* Update IO stats */
- snic_stats_update_io_cmpl(&snic->s_stats);
+ /* Update IO stats */
+ snic_stats_update_io_cmpl(&snic->s_stats);
- if (sc->scsi_done) {
- SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
- jiffies_to_msecs(jiffies - st_time), 0,
- SNIC_TRC_CMD(sc),
- SNIC_TRC_CMD_STATE_FLAGS(sc));
+ if (sc->scsi_done) {
+ SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
+ jiffies_to_msecs(jiffies - st_time), 0,
+ SNIC_TRC_CMD(sc),
+ SNIC_TRC_CMD_STATE_FLAGS(sc));
- sc->scsi_done(sc);
- }
+ sc->scsi_done(sc);
}
+ return true;
+}
+
+/*
+ * snic_scsi_cleanup: Walks through tag map and releases the reqs
+ */
+static void
+snic_scsi_cleanup(struct snic *snic)
+{
+ SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n");
+
+ scsi_host_busy_iter(snic->shost, snic_scsi_cleanup_iter, snic);
} /* end of snic_scsi_cleanup */
void
@@ -2574,6 +2576,40 @@ snic_internal_abort_io(struct snic *snic, struct scsi_cmnd *sc, int tmf)
return ret;
} /* end of snic_internal_abort_io */
+struct snic_tgt_scsi_abort_io_iter_data {
+ struct snic *snic;
+ struct snic_tgt *tgt;
+ int tmf;
+ int abt_cnt;
+};
+
+static bool
+snic_tgt_scsi_abort_io_iter(struct scsi_cmnd *sc, void *data, bool reserved)
+{
+ struct snic_tgt_scsi_abort_io_iter_data *iter_data = data;
+ struct snic_tgt *sc_tgt = NULL;
+ int ret;
+
+ if (reserved)
+ return true;
+
+ sc_tgt = starget_to_tgt(scsi_target(sc->device));
+ if (sc_tgt != iter_data->tgt)
+ return true;
+
+ ret = snic_internal_abort_io(iter_data->snic, sc, iter_data->tmf);
+ if (ret < 0) {
+ SNIC_HOST_ERR(iter_data->snic->shost,
+ "tgt_abt_io: Tag %x, Failed w err = %d\n",
+ snic_cmd_tag(sc), ret);
+ return true;
+ }
+
+ if (ret == SUCCESS)
+ iter_data->abt_cnt++;
+ return true;
+}
+
/*
* snic_tgt_scsi_abort_io : called by snic_tgt_del
*/
@@ -2581,11 +2617,10 @@ int
snic_tgt_scsi_abort_io(struct snic_tgt *tgt)
{
struct snic *snic = NULL;
- struct scsi_cmnd *sc = NULL;
- struct snic_tgt *sc_tgt = NULL;
- spinlock_t *io_lock = NULL;
- unsigned long flags;
- int ret = 0, tag, abt_cnt = 0, tmf = 0;
+ struct snic_tgt_scsi_abort_io_iter_data iter_data = {
+ .tgt = tgt,
+ .abt_cnt = 0,
+ };
if (!tgt)
return -1;
@@ -2594,43 +2629,16 @@ snic_tgt_scsi_abort_io(struct snic_tgt *tgt)
SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: Cleaning Pending IOs.\n");
if (tgt->tdata.typ == SNIC_TGT_DAS)
- tmf = SNIC_ITMF_ABTS_TASK;
+ iter_data.tmf = SNIC_ITMF_ABTS_TASK;
else
- tmf = SNIC_ITMF_ABTS_TASK_TERM;
-
- for (tag = 0; tag < snic->max_tag_id; tag++) {
- io_lock = snic_io_lock_tag(snic, tag);
-
- spin_lock_irqsave(io_lock, flags);
- sc = scsi_host_find_tag(snic->shost, tag);
- if (!sc) {
- spin_unlock_irqrestore(io_lock, flags);
-
- continue;
- }
+ iter_data.tmf = SNIC_ITMF_ABTS_TASK_TERM;
+ iter_data.snic = snic;
- sc_tgt = starget_to_tgt(scsi_target(sc->device));
- if (sc_tgt != tgt) {
- spin_unlock_irqrestore(io_lock, flags);
-
- continue;
- }
- spin_unlock_irqrestore(io_lock, flags);
-
- ret = snic_internal_abort_io(snic, sc, tmf);
- if (ret < 0) {
- SNIC_HOST_ERR(snic->shost,
- "tgt_abt_io: Tag %x, Failed w err = %d\n",
- tag, ret);
-
- continue;
- }
-
- if (ret == SUCCESS)
- abt_cnt++;
- }
+ scsi_host_busy_iter(snic->shost,
+ snic_tgt_scsi_abort_io_iter, &iter_data);
- SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: abt_cnt = %d\n", abt_cnt);
+ SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: abt_cnt = %d\n",
+ iter_data.abt_cnt);
return 0;
} /* end of snic_tgt_scsi_abort_io */
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 11/31] snic: check for started requests in snic_hba_reset_cmpl_handler()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (9 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 10/31] snic: use tagset iter for traversing commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 12/31] scsi: implement reserved command handling Hannes Reinecke
` (22 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
snic_hba_reset_cmpl_handler() is using scsi_host_find_tag() to
map id to a scsi command. However, as per discussion on the mailinglist
scsi_host_find_tag() might return a non-started request, so we need
to check the returned command with blk_mq_request_started() to avoid
the function tripping over a non-initialized command.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/snic/snic_scsi.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/scsi/snic/snic_scsi.c b/drivers/scsi/snic/snic_scsi.c
index 16502633287a..904eba42727c 100644
--- a/drivers/scsi/snic/snic_scsi.c
+++ b/drivers/scsi/snic/snic_scsi.c
@@ -1020,7 +1020,7 @@ snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
}
sc = scsi_host_find_tag(snic->shost, cmnd_id);
- if (!sc) {
+ if (!sc || !blk_mq_request_started(sc->request)) {
atomic64_inc(&snic->s_stats.io.sc_null);
SNIC_HOST_ERR(snic->shost,
"reset_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n",
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 12/31] scsi: implement reserved command handling
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (10 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 11/31] snic: check for started requests in snic_hba_reset_cmpl_handler() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 13/31] hpsa: move hpsa_hba_inquiry after scsi_add_host() Hannes Reinecke
` (21 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Quite some drivers are using management commands internally, which
typically use the same hardware tag pool (ie they are being allocated
from the same hardware resources) as the 'normal' I/O commands.
These commands are set aside before allocating the block-mq tag bitmap,
so they'll never show up as busy in the tag map.
The block-layer, OTOH, already has 'reserved_tags' to handle precisely
this situation.
So this patch adds a new field 'nr_reserved_cmds' to the SCSI host
template to instruct the block layer to set aside a tag space for these
management commands by using reserved tags.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/hosts.c | 3 +++
drivers/scsi/scsi_lib.c | 10 +++++++++-
include/scsi/scsi_host.h | 22 +++++++++++++++++++++-
3 files changed, 33 insertions(+), 2 deletions(-)
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 2f162603876f..661ed7696562 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -469,6 +469,9 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
if (sht->virt_boundary_mask)
shost->virt_boundary_mask = sht->virt_boundary_mask;
+ if (sht->nr_reserved_cmds)
+ shost->nr_reserved_cmds = sht->nr_reserved_cmds;
+
device_initialize(&shost->shost_gendev);
dev_set_name(&shost->shost_gendev, "host%d", shost->host_no);
shost->shost_gendev.bus = &scsi_bus_type;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 5cb464972682..90af1ab6f4f5 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1916,7 +1916,9 @@ int scsi_mq_setup_tags(struct Scsi_Host *shost)
else
tag_set->ops = &scsi_mq_ops_no_commit;
tag_set->nr_hw_queues = shost->nr_hw_queues ? : 1;
- tag_set->queue_depth = shost->can_queue;
+ tag_set->queue_depth =
+ shost->can_queue + shost->nr_reserved_cmds;
+ tag_set->reserved_tags = shost->nr_reserved_cmds;
tag_set->cmd_size = cmd_size;
tag_set->numa_node = NUMA_NO_NODE;
tag_set->flags = BLK_MQ_F_SHOULD_MERGE;
@@ -1941,6 +1943,9 @@ void scsi_mq_destroy_tags(struct Scsi_Host *shost)
* @op_flags: request allocation flags
*
* Allocates a SCSI command for internal LLDD use.
+ * If 'nr_reserved_commands' is spectified by the host the
+ * command will be allocated from the reserved tag pool;
+ * otherwise the normal tag pool will be used.
*/
struct scsi_cmnd *scsi_get_internal_cmd(struct scsi_device *sdev,
enum dma_data_direction data_direction, int op_flags)
@@ -1950,6 +1955,9 @@ struct scsi_cmnd *scsi_get_internal_cmd(struct scsi_device *sdev,
blk_mq_req_flags_t flags = 0;
unsigned int op = REQ_INTERNAL | op_flags;
+ if (sdev->host->nr_reserved_cmds)
+ flags = BLK_MQ_REQ_RESERVED;
+
op |= (data_direction == DMA_TO_DEVICE) ?
REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN;
rq = blk_mq_alloc_request(sdev->request_queue, op, flags);
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index ecc2d9dcfdf3..e826658bcecf 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -348,10 +348,19 @@ struct scsi_host_template {
/*
* This determines if we will use a non-interrupt driven
* or an interrupt driven scheme. It is set to the maximum number
- * of simultaneous commands a single hw queue in HBA will accept.
+ * of simultaneous commands a single hw queue in HBA will accept
+ * excluding internal commands.
*/
int can_queue;
+ /*
+ * This determines how many commands the HBA will set aside
+ * for internal commands. This number will be added to
+ * @can_queue to calcumate the maximum number of simultaneous
+ * commands sent to the host.
+ */
+ int nr_reserved_cmds;
+
/*
* In many instances, especially where disconnect / reconnect are
* supported, our host also has an ID on the SCSI bus. If this is
@@ -599,6 +608,11 @@ struct Scsi_Host {
unsigned short max_cmd_len;
int this_id;
+
+ /*
+ * Number of commands this host can handle at the same time.
+ * This excludes reserved commands as specified by nr_reserved_cmds.
+ */
int can_queue;
short cmd_per_lun;
short unsigned int sg_tablesize;
@@ -616,6 +630,12 @@ struct Scsi_Host {
* the total queue depth is can_queue.
*/
unsigned nr_hw_queues;
+
+ /*
+ * Number of reserved commands to allocate, if any.
+ */
+ unsigned nr_reserved_cmds;
+
unsigned active_mode:2;
unsigned unchecked_isa_dma:1;
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 13/31] hpsa: move hpsa_hba_inquiry after scsi_add_host()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (11 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 12/31] scsi: implement reserved command handling Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 14/31] hpsa: use reserved commands Hannes Reinecke
` (20 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke, Don Brace
Move hpsa_hba_inquiry to after scsi_add_host() so that the host
is fully initialized.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Tested-by: Don Brace <don.brace@microchip.com>
---
drivers/scsi/hpsa.c | 37 +++++++++++++++++++------------------
1 file changed, 19 insertions(+), 18 deletions(-)
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 337d3aa91945..1603982dd5e8 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -5851,6 +5851,22 @@ static int hpsa_scsi_host_alloc(struct ctlr_info *h)
return 0;
}
+static void hpsa_hba_inquiry(struct ctlr_info *h)
+{
+ int rc;
+
+#define HBA_INQUIRY_BYTE_COUNT 64
+ h->hba_inquiry_data = kmalloc(HBA_INQUIRY_BYTE_COUNT, GFP_KERNEL);
+ if (!h->hba_inquiry_data)
+ return;
+ rc = hpsa_scsi_do_inquiry(h, RAID_CTLR_LUNID, 0,
+ h->hba_inquiry_data, HBA_INQUIRY_BYTE_COUNT);
+ if (rc != 0) {
+ kfree(h->hba_inquiry_data);
+ h->hba_inquiry_data = NULL;
+ }
+}
+
static int hpsa_scsi_add_host(struct ctlr_info *h)
{
int rv;
@@ -5860,6 +5876,9 @@ static int hpsa_scsi_add_host(struct ctlr_info *h)
dev_err(&h->pdev->dev, "scsi_add_host failed\n");
return rv;
}
+
+ hpsa_hba_inquiry(h);
+
scsi_scan_host(h->scsi_host);
return 0;
}
@@ -7912,22 +7931,6 @@ static int hpsa_pci_init(struct ctlr_info *h)
return err;
}
-static void hpsa_hba_inquiry(struct ctlr_info *h)
-{
- int rc;
-
-#define HBA_INQUIRY_BYTE_COUNT 64
- h->hba_inquiry_data = kmalloc(HBA_INQUIRY_BYTE_COUNT, GFP_KERNEL);
- if (!h->hba_inquiry_data)
- return;
- rc = hpsa_scsi_do_inquiry(h, RAID_CTLR_LUNID, 0,
- h->hba_inquiry_data, HBA_INQUIRY_BYTE_COUNT);
- if (rc != 0) {
- kfree(h->hba_inquiry_data);
- h->hba_inquiry_data = NULL;
- }
-}
-
static int hpsa_init_reset_devices(struct pci_dev *pdev, u32 board_id)
{
int rc, i;
@@ -8832,8 +8835,6 @@ static int hpsa_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
/* Turn the interrupts on so we can service requests */
h->access.set_intr_mask(h, HPSA_INTR_ON);
- hpsa_hba_inquiry(h);
-
h->lastlogicals = kzalloc(sizeof(*(h->lastlogicals)), GFP_KERNEL);
if (!h->lastlogicals)
dev_info(&h->pdev->dev,
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 14/31] hpsa: use reserved commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (12 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 13/31] hpsa: move hpsa_hba_inquiry after scsi_add_host() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-03-11 22:03 ` michael.christie
2021-02-22 13:23 ` [PATCH 15/31] hpsa: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
` (19 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke, Don Brace
Enable the use of reserved commands, and drop the hand-crafted
command allocation.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Tested-by: Don Brace <don.brace@microchip.com>
---
drivers/scsi/hpsa.c | 204 +++++++++++++++++---------------------------
drivers/scsi/hpsa.h | 3 +-
2 files changed, 78 insertions(+), 129 deletions(-)
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 1603982dd5e8..506cd9faa7b9 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -245,10 +245,6 @@ static struct hpsa_scsi_dev_t
*hpsa_find_device_by_sas_rphy(struct ctlr_info *h,
struct sas_rphy *rphy);
-#define SCSI_CMD_BUSY ((struct scsi_cmnd *)&hpsa_cmd_busy)
-static const struct scsi_cmnd hpsa_cmd_busy;
-#define SCSI_CMD_IDLE ((struct scsi_cmnd *)&hpsa_cmd_idle)
-static const struct scsi_cmnd hpsa_cmd_idle;
static int number_of_controllers;
static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id);
@@ -266,7 +262,7 @@ static int hpsa_compat_ioctl(struct scsi_device *dev, unsigned int cmd,
#endif
static void cmd_free(struct ctlr_info *h, struct CommandList *c);
-static struct CommandList *cmd_alloc(struct ctlr_info *h);
+static struct CommandList *cmd_alloc(struct ctlr_info *h, u8 direction);
static void cmd_tagged_free(struct ctlr_info *h, struct CommandList *c);
static struct CommandList *cmd_tagged_alloc(struct ctlr_info *h,
struct scsi_cmnd *scmd);
@@ -347,7 +343,7 @@ static inline struct ctlr_info *shost_to_hba(struct Scsi_Host *sh)
static inline bool hpsa_is_cmd_idle(struct CommandList *c)
{
- return c->scsi_cmd == SCSI_CMD_IDLE;
+ return c->scsi_cmd == NULL;
}
/* extract sense key, asc, and ascq from sense data. -1 means invalid. */
@@ -2459,7 +2455,12 @@ static void hpsa_cmd_resolve_events(struct ctlr_info *h,
* this command has completed. Then, check to see if the handler is
* waiting for this command, and, if so, wake it.
*/
- c->scsi_cmd = SCSI_CMD_IDLE;
+ if (c->scsi_cmd && c->cmd_type == CMD_IOCTL_PEND) {
+ struct scsi_cmnd *scmd = c->scsi_cmd;
+
+ scsi_put_internal_cmd(scmd);
+ }
+ c->scsi_cmd = NULL;
mb(); /* Declare command idle before checking for pending events. */
if (dev) {
atomic_dec(&dev->commands_outstanding);
@@ -3001,7 +3002,7 @@ static int hpsa_do_receive_diagnostic(struct ctlr_info *h, u8 *scsi3addr,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
if (fill_cmd(c, RECEIVE_DIAGNOSTIC, h, buf, bufsize,
page, scsi3addr, TYPE_CMD)) {
rc = -1;
@@ -3053,7 +3054,7 @@ static int hpsa_scsi_do_inquiry(struct ctlr_info *h, unsigned char *scsi3addr,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
if (fill_cmd(c, HPSA_INQUIRY, h, buf, bufsize,
page, scsi3addr, TYPE_CMD)) {
@@ -3081,7 +3082,7 @@ static int hpsa_send_reset(struct ctlr_info *h, struct hpsa_scsi_dev_t *dev,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_NONE);
c->device = dev;
/* fill_cmd can't fail here, no data buffer to map. */
@@ -3307,7 +3308,7 @@ static int hpsa_get_raid_map(struct ctlr_info *h,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
if (fill_cmd(c, HPSA_GET_RAID_MAP, h, &this_device->raid_map,
sizeof(this_device->raid_map), 0,
@@ -3349,7 +3350,7 @@ static int hpsa_bmic_sense_subsystem_information(struct ctlr_info *h,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
rc = fill_cmd(c, BMIC_SENSE_SUBSYSTEM_INFORMATION, h, buf, bufsize,
0, RAID_CTLR_LUNID, TYPE_CMD);
@@ -3380,7 +3381,7 @@ static int hpsa_bmic_id_controller(struct ctlr_info *h,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
rc = fill_cmd(c, BMIC_IDENTIFY_CONTROLLER, h, buf, bufsize,
0, RAID_CTLR_LUNID, TYPE_CMD);
@@ -3409,7 +3410,7 @@ static int hpsa_bmic_id_physical_device(struct ctlr_info *h,
struct CommandList *c;
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
rc = fill_cmd(c, BMIC_IDENTIFY_PHYSICAL_DEVICE, h, buf, bufsize,
0, RAID_CTLR_LUNID, TYPE_CMD);
if (rc)
@@ -3486,7 +3487,7 @@ static void hpsa_get_enclosure_info(struct ctlr_info *h,
goto out;
}
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
rc = fill_cmd(c, BMIC_SENSE_STORAGE_BOX_PARAMS, h, bssbp,
sizeof(*bssbp), 0, RAID_CTLR_LUNID, TYPE_CMD);
@@ -3742,7 +3743,7 @@ static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
unsigned char scsi3addr[8];
struct ErrorInfo *ei;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
/* address the controller */
memset(scsi3addr, 0, sizeof(scsi3addr));
@@ -3883,7 +3884,7 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
#define ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS 0x04
#define ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ 0x02
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_NONE);
(void) fill_cmd(c, TEST_UNIT_READY, h, NULL, 0, 0, scsi3addr, TYPE_CMD);
rc = hpsa_scsi_do_simple_cmd(h, c, DEFAULT_REPLY_QUEUE,
@@ -5539,7 +5540,6 @@ static void hpsa_cmd_init(struct ctlr_info *h, int index,
c->ErrDesc.Addr = cpu_to_le64((u64) err_dma_handle);
c->ErrDesc.Len = cpu_to_le32((u32) sizeof(*c->err_info));
c->h = h;
- c->scsi_cmd = SCSI_CMD_IDLE;
}
static void hpsa_preinitialize_commands(struct ctlr_info *h)
@@ -5834,12 +5834,12 @@ static int hpsa_scsi_host_alloc(struct ctlr_info *h)
sh->io_port = 0;
sh->n_io_port = 0;
- sh->this_id = -1;
sh->max_channel = 3;
sh->max_cmd_len = MAX_COMMAND_SIZE;
sh->max_lun = HPSA_MAX_LUN;
sh->max_id = HPSA_MAX_LUN;
sh->can_queue = h->nr_cmds - HPSA_NRESERVED_CMDS;
+ sh->nr_reserved_cmds = HPSA_NRESERVED_CMDS;
sh->cmd_per_lun = sh->can_queue;
sh->sg_tablesize = h->maxsgentries;
sh->transportt = hpsa_sas_transport_template;
@@ -5876,30 +5876,18 @@ static int hpsa_scsi_add_host(struct ctlr_info *h)
dev_err(&h->pdev->dev, "scsi_add_host failed\n");
return rv;
}
-
+ h->raid_ctrl_sdev = scsi_get_host_dev(h->scsi_host);
+ if (!h->raid_ctrl_sdev) {
+ dev_err(&h->pdev->dev,
+ "allocate raid controller device failed\n");
+ return -ENOMEM;
+ }
hpsa_hba_inquiry(h);
scsi_scan_host(h->scsi_host);
return 0;
}
-/*
- * The block layer has already gone to the trouble of picking out a unique,
- * small-integer tag for this request. We use an offset from that value as
- * an index to select our command block. (The offset allows us to reserve the
- * low-numbered entries for our own uses.)
- */
-static int hpsa_get_cmd_index(struct scsi_cmnd *scmd)
-{
- int idx = scmd->request->tag;
-
- if (idx < 0)
- return idx;
-
- /* Offset to leave space for internal cmds. */
- return idx += HPSA_NRESERVED_CMDS;
-}
-
/*
* Send a TEST_UNIT_READY command to the specified LUN using the specified
* reply queue; returns zero if the unit is ready, and non-zero otherwise.
@@ -5983,7 +5971,7 @@ static int wait_for_device_to_become_ready(struct ctlr_info *h,
int rc = 0;
struct CommandList *c;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_NONE);
/*
* If no specific reply queue was requested, then send the TUR
@@ -6056,7 +6044,7 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
if (lockup_detected(h)) {
snprintf(msg, sizeof(msg),
"cmd %d RESET FAILED, lockup detected",
- hpsa_get_cmd_index(scsicmd));
+ scsicmd->request->tag);
hpsa_show_dev_msg(KERN_WARNING, h, dev, msg);
rc = FAILED;
goto return_reset_status;
@@ -6066,7 +6054,7 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
if (detect_controller_lockup(h)) {
snprintf(msg, sizeof(msg),
"cmd %d RESET FAILED, new lockup detected",
- hpsa_get_cmd_index(scsicmd));
+ scsicmd->request->tag);
hpsa_show_dev_msg(KERN_WARNING, h, dev, msg);
rc = FAILED;
goto return_reset_status;
@@ -6128,12 +6116,12 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
static struct CommandList *cmd_tagged_alloc(struct ctlr_info *h,
struct scsi_cmnd *scmd)
{
- int idx = hpsa_get_cmd_index(scmd);
+ int idx = scmd->request->tag;
struct CommandList *c = h->cmd_pool + idx;
- if (idx < HPSA_NRESERVED_CMDS || idx >= h->nr_cmds) {
+ if (idx < 0 || idx >= h->nr_cmds) {
dev_err(&h->pdev->dev, "Bad block tag: %d not in [%d..%d]\n",
- idx, HPSA_NRESERVED_CMDS, h->nr_cmds - 1);
+ idx, 0, h->nr_cmds - 1);
/* The index value comes from the block layer, so if it's out of
* bounds, it's probably not our bug.
*/
@@ -6170,80 +6158,52 @@ static void cmd_tagged_free(struct ctlr_info *h, struct CommandList *c)
* else to free it, because it is accessed by index.
*/
(void)atomic_dec(&c->refcount);
+ c->scsi_cmd = NULL;
}
-/*
- * For operations that cannot sleep, a command block is allocated at init,
- * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
- * which ones are free or in use. Lock must be held when calling this.
- * cmd_free() is the complement.
- * This function never gives up and returns NULL. If it hangs,
- * another thread must call cmd_free() to free some tags.
- */
-
-static struct CommandList *cmd_alloc(struct ctlr_info *h)
+static struct CommandList *cmd_alloc(struct ctlr_info *h, u8 direction)
{
+ struct scsi_cmnd *scmd;
struct CommandList *c;
- int refcount, i;
- int offset = 0;
-
- /*
- * There is some *extremely* small but non-zero chance that that
- * multiple threads could get in here, and one thread could
- * be scanning through the list of bits looking for a free
- * one, but the free ones are always behind him, and other
- * threads sneak in behind him and eat them before he can
- * get to them, so that while there is always a free one, a
- * very unlucky thread might be starved anyway, never able to
- * beat the other threads. In reality, this happens so
- * infrequently as to be indistinguishable from never.
- *
- * Note that we start allocating commands before the SCSI host structure
- * is initialized. Since the search starts at bit zero, this
- * all works, since we have at least one command structure available;
- * however, it means that the structures with the low indexes have to be
- * reserved for driver-initiated requests, while requests from the block
- * layer will use the higher indexes.
- */
-
- for (;;) {
- i = find_next_zero_bit(h->cmd_pool_bits,
- HPSA_NRESERVED_CMDS,
- offset);
- if (unlikely(i >= HPSA_NRESERVED_CMDS)) {
- offset = 0;
- continue;
- }
- c = h->cmd_pool + i;
- refcount = atomic_inc_return(&c->refcount);
- if (unlikely(refcount > 1)) {
- cmd_free(h, c); /* already in use */
- offset = (i + 1) % HPSA_NRESERVED_CMDS;
- continue;
- }
- set_bit(i & (BITS_PER_LONG - 1),
- h->cmd_pool_bits + (i / BITS_PER_LONG));
- break; /* it's ours now. */
+ int idx;
+
+ scmd = scsi_get_internal_cmd(h->raid_ctrl_sdev,
+ (direction & XFER_WRITE) ?
+ DMA_TO_DEVICE : DMA_FROM_DEVICE,
+ REQ_NOWAIT);
+ if (!scmd) {
+ dev_warn(&h->pdev->dev, "failed to allocate reserved cmd\n");
+ return NULL;
+ }
+ idx = scmd->request->tag;
+ c = cmd_tagged_alloc(h, scmd);
+ if (!c) {
+ dev_warn(&h->pdev->dev, "failed to allocate reserved cmd %u\n",
+ idx);
+ scsi_put_internal_cmd(scmd);
+ return NULL;
}
- hpsa_cmd_partial_init(h, i, c);
+ hpsa_cmd_partial_init(h, idx, c);
+ c->scsi_cmd = scmd;
c->device = NULL;
+ c->cmd_type = CMD_IOCTL_PEND;
+ dev_dbg(&h->pdev->dev, "using reserved cmd %u\n", idx);
return c;
}
-/*
- * This is the complementary operation to cmd_alloc(). Note, however, in some
- * corner cases it may also be used to free blocks allocated by
- * cmd_tagged_alloc() in which case the ref-count decrement does the trick and
- * the clear-bit is harmless.
- */
static void cmd_free(struct ctlr_info *h, struct CommandList *c)
{
- if (atomic_dec_and_test(&c->refcount)) {
- int i;
+ struct scsi_cmnd *scmd = c->scsi_cmd;
- i = c - h->cmd_pool;
- clear_bit(i & (BITS_PER_LONG - 1),
- h->cmd_pool_bits + (i / BITS_PER_LONG));
+ if (!scmd) {
+ dev_warn(&h->pdev->dev, "freeing idle cmd\n");
+ return;
+ }
+ cmd_tagged_free(h, c);
+ if (c->cmd_type == CMD_IOCTL_PEND) {
+ dev_dbg(&h->pdev->dev, "returning reserved cmd %u\n",
+ scmd->request->tag);
+ scsi_put_internal_cmd(scmd);
}
}
@@ -6410,11 +6370,8 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h,
memset(buff, 0, iocommand->buf_size);
}
}
- c = cmd_alloc(h);
+ c = cmd_alloc(h, iocommand->Request.Type.Direction);
- /* Fill in the command type */
- c->cmd_type = CMD_IOCTL_PEND;
- c->scsi_cmd = SCSI_CMD_BUSY;
/* Fill in Command Header */
c->Header.ReplyQueue = 0; /* unused in simple mode */
if (iocommand->buf_size > 0) { /* buffer to fill */
@@ -6527,10 +6484,8 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h,
data_ptr += sz;
sg_used++;
}
- c = cmd_alloc(h);
+ c = cmd_alloc(h, ioc->Request.Type.Direction);
- c->cmd_type = CMD_IOCTL_PEND;
- c->scsi_cmd = SCSI_CMD_BUSY;
c->Header.ReplyQueue = 0;
c->Header.SGList = (u8) sg_used;
c->Header.SGTotal = cpu_to_le16(sg_used);
@@ -6661,7 +6616,7 @@ static void hpsa_send_host_reset(struct ctlr_info *h, u8 reset_type)
{
struct CommandList *c;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_NONE);
/* fill_cmd can't fail here, no data buffer to map */
(void) fill_cmd(c, HPSA_DEVICE_RESET_MSG, h, NULL, 0, 0,
@@ -6682,8 +6637,6 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
{
enum dma_data_direction dir = DMA_NONE;
- c->cmd_type = CMD_IOCTL_PEND;
- c->scsi_cmd = SCSI_CMD_BUSY;
c->Header.ReplyQueue = 0;
if (buff != NULL && size > 0) {
c->Header.SGList = 1;
@@ -7995,8 +7948,6 @@ static int hpsa_init_reset_devices(struct pci_dev *pdev, u32 board_id)
static void hpsa_free_cmd_pool(struct ctlr_info *h)
{
- kfree(h->cmd_pool_bits);
- h->cmd_pool_bits = NULL;
if (h->cmd_pool) {
dma_free_coherent(&h->pdev->dev,
h->nr_cmds * sizeof(struct CommandList),
@@ -8017,17 +7968,13 @@ static void hpsa_free_cmd_pool(struct ctlr_info *h)
static int hpsa_alloc_cmd_pool(struct ctlr_info *h)
{
- h->cmd_pool_bits = kcalloc(DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG),
- sizeof(unsigned long),
- GFP_KERNEL);
h->cmd_pool = dma_alloc_coherent(&h->pdev->dev,
h->nr_cmds * sizeof(*h->cmd_pool),
&h->cmd_pool_dhandle, GFP_KERNEL);
h->errinfo_pool = dma_alloc_coherent(&h->pdev->dev,
h->nr_cmds * sizeof(*h->errinfo_pool),
&h->errinfo_pool_dhandle, GFP_KERNEL);
- if ((h->cmd_pool_bits == NULL)
- || (h->cmd_pool == NULL)
+ if ((h->cmd_pool == NULL)
|| (h->errinfo_pool == NULL)) {
dev_err(&h->pdev->dev, "out of memory in %s", __func__);
goto clean_up;
@@ -8908,7 +8855,7 @@ static void hpsa_flush_cache(struct ctlr_info *h)
if (!flush_buf)
return;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_NONE);
if (fill_cmd(c, HPSA_CACHE_FLUSH, h, flush_buf, 4, 0,
RAID_CTLR_LUNID, TYPE_CMD)) {
@@ -8943,7 +8890,7 @@ static void hpsa_disable_rld_caching(struct ctlr_info *h)
if (!options)
return;
- c = cmd_alloc(h);
+ c = cmd_alloc(h, XFER_READ);
/* first, get the current diag options settings */
if (fill_cmd(c, BMIC_SENSE_DIAG_OPTIONS, h, options, 4, 0,
@@ -8993,11 +8940,10 @@ static void __hpsa_shutdown(struct pci_dev *pdev)
struct ctlr_info *h;
h = pci_get_drvdata(pdev);
- /* Turn board interrupts off and send the flush cache command
- * sendcmd will turn off interrupt, and send the flush...
- * To write all data in the battery backed cache to disks
+ /*
+ * Turn board interrupts off;
+ * flush cache command has already been sent.
*/
- hpsa_flush_cache(h);
h->access.set_intr_mask(h, HPSA_INTR_OFF);
hpsa_free_irqs(h); /* init_one 4 */
hpsa_disable_interrupt_mode(h); /* pci_init 2 */
@@ -9005,6 +8951,7 @@ static void __hpsa_shutdown(struct pci_dev *pdev)
static void hpsa_shutdown(struct pci_dev *pdev)
{
+ hpsa_flush_cache(pci_get_drvdata(pdev));
__hpsa_shutdown(pdev);
pci_disable_device(pdev);
}
@@ -9049,6 +8996,7 @@ static void hpsa_remove_one(struct pci_dev *pdev)
* when multipath is enabled. There can be SYNCHRONIZE CACHE
* operations which cannot complete and will hang the system.
*/
+ hpsa_flush_cache(h);
if (h->scsi_host)
scsi_remove_host(h->scsi_host); /* init_one 8 */
/* includes hpsa_free_irqs - init_one 4 */
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 99b0750850b2..93e9fd9b931c 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -206,7 +206,6 @@ struct ctlr_info {
dma_addr_t ioaccel2_cmd_pool_dhandle;
struct ErrorInfo *errinfo_pool;
dma_addr_t errinfo_pool_dhandle;
- unsigned long *cmd_pool_bits;
int scan_finished;
u8 scan_waiting : 1;
spinlock_t scan_lock;
@@ -216,6 +215,8 @@ struct ctlr_info {
spinlock_t devlock; /* to protect hba[ctlr]->dev[]; */
int ndevices; /* number of used elements in .dev[] array. */
struct hpsa_scsi_dev_t *dev[HPSA_MAX_DEVICES];
+ struct scsi_device *raid_ctrl_sdev;
+
/*
* Performant mode tables.
*/
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 15/31] hpsa: use scsi_host_busy_iter() to traverse outstanding commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (13 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 14/31] hpsa: use reserved commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 16/31] hpsa: drop refcount field from CommandList Hannes Reinecke
` (18 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Replace all hand-crafted command iterations with
scsi_host_busy_iter() calls.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/hpsa.c | 117 +++++++++++++++++++++++++-------------------
1 file changed, 67 insertions(+), 50 deletions(-)
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 506cd9faa7b9..c0f46f11789b 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -1817,30 +1817,26 @@ static int hpsa_add_device(struct ctlr_info *h, struct hpsa_scsi_dev_t *device)
return rc;
}
-static int hpsa_find_outstanding_commands_for_dev(struct ctlr_info *h,
- struct hpsa_scsi_dev_t *dev)
-{
- int i;
- int count = 0;
-
- for (i = 0; i < h->nr_cmds; i++) {
- struct CommandList *c = h->cmd_pool + i;
- int refcount = atomic_inc_return(&c->refcount);
-
- if (refcount > 1 && hpsa_cmd_dev_match(h, c, dev,
- dev->scsi3addr)) {
- unsigned long flags;
+struct hpsa_command_iter_data {
+ struct ctlr_info *h;
+ struct hpsa_scsi_dev_t *dev;
+ unsigned char *scsi3addr;
+ int count;
+};
- spin_lock_irqsave(&h->lock, flags); /* Implied MB */
- if (!hpsa_is_cmd_idle(c))
- ++count;
- spin_unlock_irqrestore(&h->lock, flags);
- }
+static bool hpsa_find_outstanding_commands_iter(struct scsi_cmnd *sc,
+ void *data, bool reserved)
+{
+ struct hpsa_command_iter_data *iter_data = data;
+ struct ctlr_info *h = iter_data->h;
+ struct hpsa_scsi_dev_t *dev = iter_data->dev;
+ struct CommandList *c = h->cmd_pool + sc->request->tag;
- cmd_free(h, c);
+ if (hpsa_cmd_dev_match(h, c, dev, dev->scsi3addr)) {
+ iter_data->count++;
+ return false;
}
-
- return count;
+ return true;
}
#define NUM_WAIT 20
@@ -1850,13 +1846,20 @@ static void hpsa_wait_for_outstanding_commands_for_dev(struct ctlr_info *h,
int cmds = 0;
int waits = 0;
int num_wait = NUM_WAIT;
+ struct hpsa_command_iter_data iter_data = {
+ .h = h,
+ .dev = device,
+ };
if (device->external)
num_wait = HPSA_EH_PTRAID_TIMEOUT;
while (1) {
- cmds = hpsa_find_outstanding_commands_for_dev(h, device);
- if (cmds == 0)
+ iter_data.count = 0;
+ scsi_host_busy_iter(h->scsi_host,
+ hpsa_find_outstanding_commands_iter,
+ &iter_data);
+ if (iter_data.count == 0)
break;
if (++waits > num_wait)
break;
@@ -8145,27 +8148,34 @@ static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
kfree(h); /* init_one 1 */
}
+static bool fail_all_outstanding_cmds_iter(struct scsi_cmnd *sc, void *data,
+ bool reserved)
+{
+ struct hpsa_command_iter_data *iter_data = data;
+ struct ctlr_info *h = iter_data->h;
+ struct CommandList *c = h->cmd_pool + sc->request->tag;
+
+ c->err_info->CommandStatus = CMD_CTLR_LOCKUP;
+ finish_cmd(c);
+ atomic_dec(&h->commands_outstanding);
+ iter_data->count++;
+
+ return true;
+}
+
/* Called when controller lockup detected. */
static void fail_all_outstanding_cmds(struct ctlr_info *h)
{
- int i, refcount;
- struct CommandList *c;
- int failcount = 0;
+ struct hpsa_command_iter_data iter_data = {
+ .h = h,
+ .count = 0,
+ };
flush_workqueue(h->resubmit_wq); /* ensure all cmds are fully built */
- for (i = 0; i < h->nr_cmds; i++) {
- c = h->cmd_pool + i;
- refcount = atomic_inc_return(&c->refcount);
- if (refcount > 1) {
- c->err_info->CommandStatus = CMD_CTLR_LOCKUP;
- finish_cmd(c);
- atomic_dec(&h->commands_outstanding);
- failcount++;
- }
- cmd_free(h, c);
- }
+ scsi_host_busy_iter(h->scsi_host,
+ fail_all_outstanding_cmds_iter, &iter_data);
dev_warn(&h->pdev->dev,
- "failed %d commands in fail_all\n", failcount);
+ "failed %d commands in fail_all\n", iter_data.count);
}
static void set_lockup_detected_for_all_cpus(struct ctlr_info *h, u32 value)
@@ -9464,22 +9474,29 @@ static int is_accelerated_cmd(struct CommandList *c)
return c->cmd_type == CMD_IOACCEL1 || c->cmd_type == CMD_IOACCEL2;
}
+static bool hpsa_drain_accel_commands_iter(struct scsi_cmnd *sc, void *data,
+ bool reserved)
+{
+ struct hpsa_command_iter_data *iter_data = data;
+ struct ctlr_info *h = iter_data->h;
+ struct CommandList *c = h->cmd_pool + sc->request->tag;
+
+ iter_data->count += is_accelerated_cmd(c);
+ return true;
+}
+
static void hpsa_drain_accel_commands(struct ctlr_info *h)
{
- struct CommandList *c = NULL;
- int i, accel_cmds_out;
- int refcount;
+ struct hpsa_command_iter_data iter_data = {
+ .h = h,
+ };
do { /* wait for all outstanding ioaccel commands to drain out */
- accel_cmds_out = 0;
- for (i = 0; i < h->nr_cmds; i++) {
- c = h->cmd_pool + i;
- refcount = atomic_inc_return(&c->refcount);
- if (refcount > 1) /* Command is allocated */
- accel_cmds_out += is_accelerated_cmd(c);
- cmd_free(h, c);
- }
- if (accel_cmds_out <= 0)
+ iter_data.count = 0;
+ scsi_host_busy_iter(h->scsi_host,
+ hpsa_drain_accel_commands_iter,
+ &iter_data);
+ if (iter_data.count <= 0)
break;
msleep(100);
} while (1);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 16/31] hpsa: drop refcount field from CommandList
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (14 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 15/31] hpsa: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 17/31] aacraid: move scsi_add_host() Hannes Reinecke
` (17 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke, Hannes Reinecke
Field is now unused, so drop it.
Signed-off-by: Hannes Reinecke <hare@suse.com>
---
drivers/scsi/hpsa.c | 12 ++----------
drivers/scsi/hpsa_cmd.h | 1 -
2 files changed, 2 insertions(+), 11 deletions(-)
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index c0f46f11789b..38f6a7589653 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -5530,8 +5530,8 @@ static void hpsa_cmd_init(struct ctlr_info *h, int index,
{
dma_addr_t cmd_dma_handle, err_dma_handle;
- /* Zero out all of commandlist except the last field, refcount */
- memset(c, 0, offsetof(struct CommandList, refcount));
+ /* Zero out all of commandlist */
+ memset(c, 0, sizeof(struct CommandList));
c->Header.tag = cpu_to_le64((u64) (index << DIRECT_LOOKUP_SHIFT));
cmd_dma_handle = h->cmd_pool_dhandle + index * sizeof(*c);
c->err_info = h->errinfo_pool + index;
@@ -5553,7 +5553,6 @@ static void hpsa_preinitialize_commands(struct ctlr_info *h)
struct CommandList *c = h->cmd_pool + i;
hpsa_cmd_init(h, i, c);
- atomic_set(&c->refcount, 0);
}
}
@@ -6148,19 +6147,12 @@ static struct CommandList *cmd_tagged_alloc(struct ctlr_info *h,
return NULL;
}
- atomic_inc(&c->refcount);
-
hpsa_cmd_partial_init(h, idx, c);
return c;
}
static void cmd_tagged_free(struct ctlr_info *h, struct CommandList *c)
{
- /*
- * Release our reference to the block. We don't need to do anything
- * else to free it, because it is accessed by index.
- */
- (void)atomic_dec(&c->refcount);
c->scsi_cmd = NULL;
}
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index 46df2e3ff89b..aaccb520b858 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -450,7 +450,6 @@ struct CommandList {
int abort_pending;
struct hpsa_scsi_dev_t *device;
- atomic_t refcount; /* Must be last to avoid memset in hpsa_cmd_init() */
} __aligned(COMMANDLIST_ALIGNMENT);
/* Max S/G elements in I/O accelerator command */
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 17/31] aacraid: move scsi_add_host()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (15 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 16/31] hpsa: drop refcount field from CommandList Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 18/31] aacraid: store target id in host_scribble Hannes Reinecke
` (16 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke, Hannes Reinecke
Move the call to scsi_add_host() so that the Scsi_Host structure
is initialized before any I/O is sent.
Signed-off-by: Hannes Reinecke <hare@suse.com>
---
drivers/scsi/aacraid/linit.c | 31 +++++++++++++++----------------
1 file changed, 15 insertions(+), 16 deletions(-)
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 3168915adaa7..e5d89b309c3a 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -1639,6 +1639,9 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
shost->irq = pdev->irq;
shost->unique_id = unique_id;
shost->max_cmd_len = 16;
+ shost->max_id = MAXIMUM_NUM_CONTAINERS;
+ shost->max_lun = AAC_MAX_LUN;
+ shost->sg_tablesize = HBA_MAX_SG_SEPARATE;
if (aac_cfg_major == AAC_CHARDEV_NEEDS_REINIT)
aac_init_char();
@@ -1677,7 +1680,7 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
aac->base_size = AAC_MIN_FOOTPRINT_SIZE;
if ((*aac_drivers[index].init)(aac)) {
error = -ENODEV;
- goto out_unmap;
+ goto out_free_fibs;
}
if (aac->sync_mode) {
@@ -1703,9 +1706,15 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
printk(KERN_ERR "aacraid: Unable to create command thread.\n");
error = PTR_ERR(aac->thread);
aac->thread = NULL;
- goto out_deinit;
+ goto out_unmap;
}
+ pci_set_drvdata(pdev, shost);
+
+ error = scsi_add_host(shost, &pdev->dev);
+ if (error)
+ goto out_deinit;
+
aac->maximum_num_channels = aac_drivers[index].channels;
error = aac_get_adapter_info(aac);
if (error < 0)
@@ -1764,18 +1773,6 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
if (!aac->sa_firmware && aac_drivers[index].quirks & AAC_QUIRK_SRC)
aac_intr_normal(aac, 0, 2, 0, NULL);
- /*
- * dmb - we may need to move the setting of these parms somewhere else once
- * we get a fib that can report the actual numbers
- */
- shost->max_lun = AAC_MAX_LUN;
-
- pci_set_drvdata(pdev, shost);
-
- error = scsi_add_host(shost, &pdev->dev);
- if (error)
- goto out_deinit;
-
aac_scan_host(aac);
pci_enable_pcie_error_reporting(pdev);
@@ -1792,10 +1789,12 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
aac->comm_addr, aac->comm_phys);
kfree(aac->queues);
aac_adapter_ioremap(aac, 0);
- kfree(aac->fibs);
kfree(aac->fsa_dev);
+ out_free_fibs:
+ kfree(aac->fibs);
out_free_host:
scsi_host_put(shost);
+ pci_set_drvdata(pdev, NULL);
out_disable_pdev:
pci_disable_device(pdev);
out:
@@ -1903,9 +1902,9 @@ static void aac_remove_one(struct pci_dev *pdev)
struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
aac_cancel_rescan_worker(aac);
- scsi_remove_host(shost);
__aac_shutdown(aac);
+ scsi_remove_host(shost);
aac_fib_map_free(aac);
dma_free_coherent(&aac->pdev->dev, aac->comm_size, aac->comm_addr,
aac->comm_phys);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 18/31] aacraid: store target id in host_scribble
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (16 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 17/31] aacraid: move scsi_add_host() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 19/31] aacraid: use scsi_get_internal_cmd() Hannes Reinecke
` (15 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
The probe_container mechanism requires a target id to be present,
even if the device itself isn't present (yet).
As we're now allocating internal commands the target id of the
device is immutable, so store the requested target id in the
host_scribble field.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/aacraid/aachba.c | 53 +++++++++++++++++++++++++----------
1 file changed, 38 insertions(+), 15 deletions(-)
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 4ca5e13a26a6..97967e4e904c 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -609,9 +609,11 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd)
static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd)
{
- struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
+ struct aac_dev *dev = (struct aac_dev *)(scsicmd->device->host->hostdata);
+ struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev;
- if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1))
+ if (scmd_id(scsicmd) < dev->maximum_num_containers &&
+ (fsa_dev_ptr[scmd_id(scsicmd)].valid & 1))
return aac_scsi_cmd(scsicmd);
scsicmd->result = DID_NO_CONNECT << 16;
@@ -624,6 +626,7 @@ static void _aac_probe_container2(void * context, struct fib * fibptr)
struct fsa_dev_info *fsa_dev_ptr;
int (*callback)(struct scsi_cmnd *);
struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context;
+ int cid = scmd_id(scsicmd);
int i;
@@ -631,12 +634,15 @@ static void _aac_probe_container2(void * context, struct fib * fibptr)
return;
scsicmd->SCp.Status = 0;
+ if (scsicmd->host_scribble)
+ cid = *(int *)scsicmd->host_scribble;
+
fsa_dev_ptr = fibptr->dev->fsa_dev;
- if (fsa_dev_ptr) {
+ if (fsa_dev_ptr && cid < fibptr->dev->maximum_num_containers) {
struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr);
__le32 sup_options2;
- fsa_dev_ptr += scmd_id(scsicmd);
+ fsa_dev_ptr += cid;
sup_options2 =
fibptr->dev->supplement_adapter_info.supported_options2;
@@ -671,7 +677,6 @@ static void _aac_probe_container2(void * context, struct fib * fibptr)
scsicmd->SCp.Status = le32_to_cpu(dresp->count);
}
aac_fib_complete(fibptr);
- aac_fib_free(fibptr);
callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr);
scsicmd->SCp.ptr = NULL;
(*callback)(scsicmd);
@@ -683,6 +688,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
struct scsi_cmnd * scsicmd;
struct aac_mount * dresp;
struct aac_query_mount *dinfo;
+ int cid;
int status;
dresp = (struct aac_mount *) fib_data(fibptr);
@@ -695,10 +701,15 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
}
}
scsicmd = (struct scsi_cmnd *) context;
-
if (!aac_valid_context(scsicmd, fibptr))
return;
-
+ cid = scmd_id(scsicmd);
+ if (scsicmd->host_scribble)
+ cid = *(int *)scsicmd->host_scribble;
+ if (cid >= fibptr->dev->maximum_num_containers) {
+ _aac_probe_container2(context, fibptr);
+ return;
+ }
aac_fib_init(fibptr);
dinfo = (struct aac_query_mount *)fib_data(fibptr);
@@ -709,7 +720,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
else
dinfo->command = cpu_to_le32(VM_NameServe64);
- dinfo->count = cpu_to_le32(scmd_id(scsicmd));
+ dinfo->count = cpu_to_le32(cid);
dinfo->type = cpu_to_le32(FT_FILESYS);
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
@@ -732,10 +743,20 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *))
{
+ struct aac_dev * dev;
struct fib * fibptr;
int status = -ENOMEM;
+ int cid = scmd_id(scsicmd);
- if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) {
+ dev = (struct aac_dev *)scsicmd->device->host->hostdata;
+ if (scsicmd->host_scribble) {
+ cid = *(int *)scsicmd->host_scribble;
+ if (cid > dev->maximum_num_containers) {
+ status = -ENODEV;
+ goto out_status;
+ }
+ }
+ if ((fibptr = aac_fib_alloc(dev))) {
struct aac_query_mount *dinfo;
aac_fib_init(fibptr);
@@ -748,7 +769,7 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
else
dinfo->command = cpu_to_le32(VM_NameServe);
- dinfo->count = cpu_to_le32(scmd_id(scsicmd));
+ dinfo->count = cpu_to_le32(cid);
dinfo->type = cpu_to_le32(FT_FILESYS);
scsicmd->SCp.ptr = (char *)callback;
scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
@@ -772,10 +793,11 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
aac_fib_free(fibptr);
}
}
+out_status:
if (status < 0) {
- struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
- if (fsa_dev_ptr) {
- fsa_dev_ptr += scmd_id(scsicmd);
+ struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev;
+ if (fsa_dev_ptr && cid < dev->maximum_num_containers) {
+ fsa_dev_ptr += cid;
if ((fsa_dev_ptr->valid & 1) == 0) {
fsa_dev_ptr->valid = 0;
return (*callback)(scsicmd);
@@ -794,7 +816,7 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
*/
static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd)
{
- scsicmd->device = NULL;
+ scsicmd->host_scribble = NULL;
return 0;
}
@@ -815,6 +837,7 @@ int aac_probe_container(struct aac_dev *dev, int cid)
return -ENOMEM;
}
scsicmd->scsi_done = aac_probe_container_scsi_done;
+ scsicmd->host_scribble = (unsigned char *)&cid;
scsicmd->device = scsidev;
scsidev->sdev_state = 0;
@@ -822,7 +845,7 @@ int aac_probe_container(struct aac_dev *dev, int cid)
scsidev->host = dev->scsi_host_ptr;
if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0)
- while (scsicmd->device == scsidev)
+ while (scsicmd->host_scribble == (unsigned char *)&cid)
schedule();
kfree(scsidev);
status = scsicmd->SCp.Status;
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 19/31] aacraid: use scsi_get_internal_cmd()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (17 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 18/31] aacraid: store target id in host_scribble Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 20/31] aacraid: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
` (14 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
From: Hannes Reinecke <hare@suse.com>
Use scsi_get_internal_cmd() to allocate internal commands.
And move scsi_add_host() such that it's allocated early enough
to provide tags for the initialisation commands.
Signed-off-by: Hannes Reinecke <hare@suse.com>
---
drivers/scsi/aacraid/aachba.c | 92 +++++++++++++++------------------
drivers/scsi/aacraid/aacraid.h | 10 ++--
drivers/scsi/aacraid/commctrl.c | 25 +++++----
drivers/scsi/aacraid/comminit.c | 2 +-
drivers/scsi/aacraid/commsup.c | 60 ++++++++++-----------
drivers/scsi/aacraid/dpcsup.c | 2 +-
drivers/scsi/aacraid/linit.c | 13 +++--
7 files changed, 102 insertions(+), 102 deletions(-)
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 97967e4e904c..8bcf76ed4239 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -360,7 +360,7 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
int status = 0;
struct fib * fibptr;
- if (!(fibptr = aac_fib_alloc(dev)))
+ if (!(fibptr = aac_fib_alloc(dev, DMA_FROM_DEVICE)))
return -ENOMEM;
aac_fib_init(fibptr);
@@ -457,7 +457,7 @@ int aac_get_containers(struct aac_dev *dev)
struct aac_get_container_count_resp *dresp;
int maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
- if (!(fibptr = aac_fib_alloc(dev)))
+ if (!(fibptr = aac_fib_alloc(dev, DMA_FROM_DEVICE)))
return -ENOMEM;
aac_fib_init(fibptr);
@@ -741,61 +741,56 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
}
}
-static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *))
+static int _aac_probe_container(struct fib * fibptr, int (*callback)(struct scsi_cmnd *))
{
+ struct scsi_cmnd *scsicmd = fibptr->scmd;
struct aac_dev * dev;
- struct fib * fibptr;
int status = -ENOMEM;
+ struct aac_query_mount *dinfo;
int cid = scmd_id(scsicmd);
dev = (struct aac_dev *)scsicmd->device->host->hostdata;
if (scsicmd->host_scribble) {
- cid = *(int *)scsicmd->host_scribble;
- if (cid > dev->maximum_num_containers) {
+ cid = *(unsigned int *)scsicmd->host_scribble;
+ if (cid >= dev->maximum_num_containers) {
status = -ENODEV;
goto out_status;
}
}
- if ((fibptr = aac_fib_alloc(dev))) {
- struct aac_query_mount *dinfo;
- aac_fib_init(fibptr);
+ aac_fib_init(fibptr);
- dinfo = (struct aac_query_mount *)fib_data(fibptr);
+ dinfo = (struct aac_query_mount *)fib_data(fibptr);
- if (fibptr->dev->supplement_adapter_info.supported_options2 &
- AAC_OPTION_VARIABLE_BLOCK_SIZE)
- dinfo->command = cpu_to_le32(VM_NameServeAllBlk);
- else
- dinfo->command = cpu_to_le32(VM_NameServe);
+ if (fibptr->dev->supplement_adapter_info.supported_options2 &
+ AAC_OPTION_VARIABLE_BLOCK_SIZE)
+ dinfo->command = cpu_to_le32(VM_NameServeAllBlk);
+ else
+ dinfo->command = cpu_to_le32(VM_NameServe);
- dinfo->count = cpu_to_le32(cid);
- dinfo->type = cpu_to_le32(FT_FILESYS);
- scsicmd->SCp.ptr = (char *)callback;
- scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
+ dinfo->count = cpu_to_le32(cid);
+ dinfo->type = cpu_to_le32(FT_FILESYS);
+ scsicmd->SCp.ptr = (char *)callback;
+ scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
- status = aac_fib_send(ContainerCommand,
+ status = aac_fib_send(ContainerCommand,
fibptr,
sizeof(struct aac_query_mount),
FsaNormal,
0, 1,
_aac_probe_container1,
(void *) scsicmd);
- /*
- * Check that the command queued to the controller
- */
- if (status == -EINPROGRESS)
- return 0;
-
- if (status < 0) {
- scsicmd->SCp.ptr = NULL;
- aac_fib_complete(fibptr);
- aac_fib_free(fibptr);
- }
- }
+ /*
+ * Check that the command queued to the controller
+ */
+ if (status == -EINPROGRESS)
+ return 0;
out_status:
if (status < 0) {
struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev;
+
+ scsicmd->SCp.ptr = NULL;
+ aac_fib_complete(fibptr);
if (fsa_dev_ptr && cid < dev->maximum_num_containers) {
fsa_dev_ptr += cid;
if ((fsa_dev_ptr->valid & 1) == 0) {
@@ -827,29 +822,23 @@ static void aac_probe_container_scsi_done(struct scsi_cmnd *scsi_cmnd)
int aac_probe_container(struct aac_dev *dev, int cid)
{
- struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL);
- struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL);
+ struct fib *fibptr;
+ struct scsi_cmnd *scsicmd;
int status;
- if (!scsicmd || !scsidev) {
- kfree(scsicmd);
- kfree(scsidev);
+ fibptr = aac_fib_alloc(dev, DMA_FROM_DEVICE);
+ if (!fibptr)
return -ENOMEM;
- }
+
+ scsicmd = fibptr->scmd;
scsicmd->scsi_done = aac_probe_container_scsi_done;
scsicmd->host_scribble = (unsigned char *)&cid;
- scsicmd->device = scsidev;
- scsidev->sdev_state = 0;
- scsidev->id = cid;
- scsidev->host = dev->scsi_host_ptr;
-
- if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0)
+ if (_aac_probe_container(fibptr, aac_probe_container_callback1) == 0)
while (scsicmd->host_scribble == (unsigned char *)&cid)
schedule();
- kfree(scsidev);
status = scsicmd->SCp.Status;
- kfree(scsicmd);
+ aac_fib_free(fibptr);
return status;
}
@@ -1694,7 +1683,7 @@ static int aac_send_safw_bmic_cmd(struct aac_dev *dev,
return 0;
/* allocate FIB */
- fibptr = aac_fib_alloc(dev);
+ fibptr = aac_fib_alloc(dev, DMA_BIDIRECTIONAL);
if (!fibptr)
return -ENOMEM;
@@ -2059,7 +2048,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
struct aac_bus_info *command;
struct aac_bus_info_response *bus_info;
- if (!(fibptr = aac_fib_alloc(dev)))
+ if (!(fibptr = aac_fib_alloc(dev, DMA_FROM_DEVICE)))
return -ENOMEM;
aac_fib_init(fibptr);
@@ -2106,7 +2095,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
if (rcode >= 0)
memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
if (rcode == -ERESTARTSYS) {
- fibptr = aac_fib_alloc(dev);
+ fibptr = aac_fib_alloc(dev, DMA_FROM_DEVICE);
if (!fibptr)
return -ENOMEM;
}
@@ -2816,6 +2805,8 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
if (((fsa_dev_ptr[cid].valid & 1) == 0) ||
(fsa_dev_ptr[cid].sense_data.sense_key ==
NOT_READY)) {
+ struct fib * fibptr;
+
switch (scsicmd->cmnd[0]) {
case SERVICE_ACTION_IN_16:
if (!(dev->raw_io_interface) ||
@@ -2828,7 +2819,8 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
case TEST_UNIT_READY:
if (dev->in_reset)
return -1;
- return _aac_probe_container(scsicmd,
+ fibptr = aac_fib_alloc_tag(dev, scsicmd);
+ return _aac_probe_container(fibptr,
aac_probe_container_callback2);
default:
break;
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index e3e4ecbea726..3cd7f33497d8 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -1291,13 +1291,16 @@ struct fsa_dev_info {
};
struct fib {
- void *next; /* this is used by the allocator */
s16 type;
s16 size;
/*
* The Adapter that this I/O is destined for.
*/
struct aac_dev *dev;
+ /*
+ * The associated scsi command
+ */
+ struct scsi_cmnd *scmd;
/*
* This is the event the sendfib routine will wait on if the
* caller did not pass one and this is synch io.
@@ -1552,7 +1555,6 @@ struct aac_dev
*/
struct fib *fibs;
- struct fib *free_fib;
spinlock_t fib_lock;
struct mutex ioctl_mutex;
@@ -1597,6 +1599,7 @@ struct aac_dev
size_t comm_size;
struct Scsi_Host *scsi_host_ptr;
+ struct scsi_device *scsi_host_dev;
int maximum_num_containers;
int maximum_num_physicals;
int maximum_num_channels;
@@ -1729,6 +1732,7 @@ struct aac_dev
#define FIB_CONTEXT_FLAG_NATIVE_HBA_TMF (0x00000020)
#define FIB_CONTEXT_FLAG_SCSI_CMD (0x00000040)
#define FIB_CONTEXT_FLAG_EH_RESET (0x00000080)
+#define FIB_CONTEXT_FLAG_INTERNAL_CMD (0x00000100)
/*
* Define the command values
@@ -2686,7 +2690,7 @@ void aac_free_irq(struct aac_dev *dev);
int aac_setup_safw_adapter(struct aac_dev *dev);
const char *aac_driverinfo(struct Scsi_Host *);
void aac_fib_vector_assign(struct aac_dev *dev);
-struct fib *aac_fib_alloc(struct aac_dev *dev);
+struct fib *aac_fib_alloc(struct aac_dev *dev, int direction);
struct fib *aac_fib_alloc_tag(struct aac_dev *dev, struct scsi_cmnd *scmd);
int aac_fib_setup(struct aac_dev *dev);
void aac_fib_map_free(struct aac_dev *dev);
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 1b1da162f5f6..65c6079cfa94 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -55,7 +55,7 @@ static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
if (dev->in_reset) {
return -EBUSY;
}
- fibptr = aac_fib_alloc(dev);
+ fibptr = aac_fib_alloc(dev, DMA_BIDIRECTIONAL);
if(fibptr == NULL) {
return -ENOMEM;
}
@@ -478,7 +478,7 @@ static int check_revision(struct aac_dev *dev, void __user *arg)
*/
static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
{
- struct fib* srbfib;
+ struct fib* srbfib = NULL;
int status;
struct aac_srb *srbcmd = NULL;
struct aac_hba_cmd_req *hbacmd = NULL;
@@ -509,12 +509,6 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n"));
return -EPERM;
}
- /*
- * Allocate and initialize a Fib then setup a SRB command
- */
- if (!(srbfib = aac_fib_alloc(dev))) {
- return -ENOMEM;
- }
memset(sg_list, 0, sizeof(sg_list)); /* cleanup may take issue */
if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
@@ -561,6 +555,15 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
rcode = -EINVAL;
goto cleanup;
}
+
+ /*
+ * Allocate and initialize a Fib
+ */
+ if (!(srbfib = aac_fib_alloc(dev, data_dir))) {
+ rcode = -ENOMEM;
+ goto cleanup;
+ }
+
actual_fibsize = sizeof(struct aac_srb) - sizeof(struct sgentry) +
((user_srbcmd->sg.count & 0xff) * sizeof(struct sgentry));
actual_fibsize64 = actual_fibsize + (user_srbcmd->sg.count & 0xff) *
@@ -988,8 +991,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
if (rcode != -ERESTARTSYS) {
for (i = 0; i <= sg_indx; i++)
kfree(sg_list[i]);
- aac_fib_complete(srbfib);
- aac_fib_free(srbfib);
+ if (srbfib) {
+ aac_fib_complete(srbfib);
+ aac_fib_free(srbfib);
+ }
}
return rcode;
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 355b16f0b145..0d5be76891b0 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -327,7 +327,7 @@ int aac_send_shutdown(struct aac_dev * dev)
aac_wait_for_io_completion(dev);
- fibctx = aac_fib_alloc(dev);
+ fibctx = aac_fib_alloc(dev, DMA_NONE);
if (!fibctx)
return -ENOMEM;
aac_fib_init(fibctx);
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 0ae0d1fa2b50..96c8226309ba 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -173,7 +173,6 @@ int aac_fib_setup(struct aac_dev * dev)
fibptr->dev = dev;
fibptr->hw_fib_va = hw_fib;
fibptr->data = (void *) fibptr->hw_fib_va->data;
- fibptr->next = fibptr+1; /* Forward chain the fibs */
init_completion(&fibptr->event_wait);
spin_lock_init(&fibptr->event_lock);
hw_fib->header.XferState = cpu_to_le32(0xffffffff);
@@ -200,14 +199,6 @@ int aac_fib_setup(struct aac_dev * dev)
*/
aac_fib_vector_assign(dev);
- /*
- * Add the fib chain to the free list
- */
- dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL;
- /*
- * Set 8 fibs aside for management tools
- */
- dev->free_fib = &dev->fibs[dev->scsi_host_ptr->can_queue];
return 0;
}
@@ -233,7 +224,7 @@ struct fib *aac_fib_alloc_tag(struct aac_dev *dev, struct scsi_cmnd *scmd)
fibptr->type = FSAFS_NTC_FIB_CONTEXT;
fibptr->callback_data = NULL;
fibptr->callback = NULL;
- fibptr->flags = 0;
+ fibptr->scmd = scmd;
return fibptr;
}
@@ -241,36 +232,30 @@ struct fib *aac_fib_alloc_tag(struct aac_dev *dev, struct scsi_cmnd *scmd)
/**
* aac_fib_alloc - allocate a fib
* @dev: Adapter to allocate the fib for
+ * @direction: DMA data direction
*
* Allocate a fib from the adapter fib pool. If the pool is empty we
* return NULL.
*/
-struct fib *aac_fib_alloc(struct aac_dev *dev)
+struct fib *aac_fib_alloc(struct aac_dev *dev, int direction)
{
- struct fib * fibptr;
+ struct scsi_cmnd *scmd;
+ struct fib * fibptr = NULL;
unsigned long flags;
+
spin_lock_irqsave(&dev->fib_lock, flags);
- fibptr = dev->free_fib;
- if(!fibptr){
- spin_unlock_irqrestore(&dev->fib_lock, flags);
- return fibptr;
+ scmd = scsi_get_internal_cmd(dev->scsi_host_dev, direction,
+ REQ_NOWAIT);
+ if (scmd) {
+ fibptr = aac_fib_alloc_tag(dev, scmd);
+ fibptr->flags |= FIB_CONTEXT_FLAG_INTERNAL_CMD;
}
- dev->free_fib = fibptr->next;
spin_unlock_irqrestore(&dev->fib_lock, flags);
- /*
- * Set the proper node type code and node byte size
- */
- fibptr->type = FSAFS_NTC_FIB_CONTEXT;
+ if (!fibptr)
+ return NULL;
+
fibptr->size = sizeof(struct fib);
- /*
- * Null out fields that depend on being zero at the start of
- * each I/O
- */
- fibptr->hw_fib_va->header.XferState = 0;
- fibptr->flags = 0;
- fibptr->callback = NULL;
- fibptr->callback_data = NULL;
return fibptr;
}
@@ -298,8 +283,15 @@ void aac_fib_free(struct fib *fibptr)
(void*)fibptr,
le32_to_cpu(fibptr->hw_fib_va->header.XferState));
}
- fibptr->next = fibptr->dev->free_fib;
- fibptr->dev->free_fib = fibptr;
+ if (fibptr->scmd) {
+ struct scsi_cmnd *scmd = fibptr->scmd;
+
+ fibptr->scmd = NULL;
+ if (fibptr->flags & FIB_CONTEXT_FLAG_INTERNAL_CMD) {
+ scsi_put_internal_cmd(scmd);
+ fibptr->flags &= ~FIB_CONTEXT_FLAG_INTERNAL_CMD;
+ }
+ }
spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags);
}
@@ -1663,7 +1655,7 @@ int aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
retval = unblock_retval;
if ((forced < 2) && (retval == -ENODEV)) {
/* Unwind aac_send_shutdown() IOP_RESET unsupported/disabled */
- struct fib * fibctx = aac_fib_alloc(aac);
+ struct fib * fibctx = aac_fib_alloc(aac, DMA_NONE);
if (fibctx) {
struct aac_pause *cmd;
int status;
@@ -2290,7 +2282,7 @@ static int aac_send_wellness_command(struct aac_dev *dev, char *wellness_str,
int ret = -ENOMEM;
u32 vbus, vid;
- fibptr = aac_fib_alloc(dev);
+ fibptr = aac_fib_alloc(dev, DMA_TO_DEVICE);
if (!fibptr)
goto out;
@@ -2388,7 +2380,7 @@ static int aac_send_hosttime(struct aac_dev *dev, struct timespec64 *now)
struct fib *fibptr;
__le32 *info;
- fibptr = aac_fib_alloc(dev);
+ fibptr = aac_fib_alloc(dev, DMA_TO_DEVICE);
if (!fibptr)
goto out;
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index fbe334c59f37..9424792432ec 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -315,7 +315,7 @@ unsigned int aac_intr_normal(struct aac_dev *dev, u32 index, int isAif,
struct fib *fibctx;
struct aac_aifcmd *cmd;
- fibctx = aac_fib_alloc(dev);
+ fibctx = aac_fib_alloc(dev, DMA_FROM_DEVICE);
if (!fibctx)
return 1;
aac_fib_init(fibctx);
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index e5d89b309c3a..ab3762c01738 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -714,7 +714,7 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
return ret;
/* start a HBA_TMF_ABORT_TASK TMF request */
- fib = aac_fib_alloc(aac);
+ fib = aac_fib_alloc(aac, DMA_NONE);
if (!fib)
return ret;
@@ -925,7 +925,7 @@ static int aac_eh_dev_reset(struct scsi_cmnd *cmd)
pr_err("%s: Host device reset request. SCSI hang ?\n",
AAC_DRIVERNAME);
- fib = aac_fib_alloc(aac);
+ fib = aac_fib_alloc(aac, DMA_NONE);
if (!fib)
return ret;
@@ -988,7 +988,7 @@ static int aac_eh_target_reset(struct scsi_cmnd *cmd)
pr_err("%s: Host target reset request. SCSI hang ?\n",
AAC_DRIVERNAME);
- fib = aac_fib_alloc(aac);
+ fib = aac_fib_alloc(aac, DMA_NONE);
if (!fib)
return ret;
@@ -1641,6 +1641,7 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
shost->max_cmd_len = 16;
shost->max_id = MAXIMUM_NUM_CONTAINERS;
shost->max_lun = AAC_MAX_LUN;
+ shost->nr_reserved_cmds = AAC_NUM_MGT_FIB;
shost->sg_tablesize = HBA_MAX_SG_SEPARATE;
if (aac_cfg_major == AAC_CHARDEV_NEEDS_REINIT)
@@ -1715,6 +1716,10 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
if (error)
goto out_deinit;
+ aac->scsi_host_dev = scsi_get_host_dev(shost);
+ if (!aac->scsi_host_dev)
+ goto out_remove_host;
+
aac->maximum_num_channels = aac_drivers[index].channels;
error = aac_get_adapter_info(aac);
if (error < 0)
@@ -1790,6 +1795,8 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
kfree(aac->queues);
aac_adapter_ioremap(aac, 0);
kfree(aac->fsa_dev);
+ out_remove_host:
+ scsi_remove_host(shost);
out_free_fibs:
kfree(aac->fibs);
out_free_host:
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 20/31] aacraid: use scsi_host_busy_iter() to traverse outstanding commands
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (18 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 19/31] aacraid: use scsi_get_internal_cmd() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 21/31] mv_sas: kill mvsas_debug_issue_ssp_tmf() Hannes Reinecke
` (13 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Instead of walking the array of potential commands and trying to figure out
which one might be pending the driver should be using
scsi_host_busy_iter() to traverse all outstanding commands.
And for command abort we can now lookup the fibs directly as we now have
a 1:1 mapping between request tags and fibs.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/aacraid/commsup.c | 49 ++++++------
drivers/scsi/aacraid/linit.c | 131 ++++++++++++++-------------------
2 files changed, 84 insertions(+), 96 deletions(-)
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 96c8226309ba..d4c63ba1a89f 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -1465,6 +1465,32 @@ static void aac_schedule_bus_scan(struct aac_dev *aac)
aac_schedule_src_reinit_aif_worker(aac);
}
+static bool aac_close_sync_fib_iter(struct scsi_cmnd *command, void *data,
+ bool reserved)
+{
+ struct Scsi_Host *host = command->device->host;
+ struct aac_dev *aac = (struct aac_dev *)host->hostdata;
+ struct fib *fib = &aac->fibs[command->request->tag];
+ int *retval = data;
+ __le32 XferState = fib->hw_fib_va->header.XferState;
+ bool is_response_expected = false;
+
+ if (!(XferState & cpu_to_le32(NoResponseExpected | Async)) &&
+ (XferState & cpu_to_le32(ResponseExpected)))
+ is_response_expected = true;
+
+ if (is_response_expected
+ || fib->flags & FIB_CONTEXT_FLAG_WAIT) {
+ unsigned long flagv;
+ spin_lock_irqsave(&fib->event_lock, flagv);
+ complete(&fib->event_wait);
+ spin_unlock_irqrestore(&fib->event_lock, flagv);
+ schedule();
+ *retval = 0;
+ }
+ return true;
+}
+
static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
{
int index, quirks;
@@ -1473,7 +1499,6 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
int jafo = 0;
int bled;
u64 dmamask;
- int num_of_fibs = 0;
/*
* Assumptions:
@@ -1507,27 +1532,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
* Loop through the fibs, close the synchronous FIBS
*/
retval = 1;
- num_of_fibs = aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB;
- for (index = 0; index < num_of_fibs; index++) {
-
- struct fib *fib = &aac->fibs[index];
- __le32 XferState = fib->hw_fib_va->header.XferState;
- bool is_response_expected = false;
-
- if (!(XferState & cpu_to_le32(NoResponseExpected | Async)) &&
- (XferState & cpu_to_le32(ResponseExpected)))
- is_response_expected = true;
-
- if (is_response_expected
- || fib->flags & FIB_CONTEXT_FLAG_WAIT) {
- unsigned long flagv;
- spin_lock_irqsave(&fib->event_lock, flagv);
- complete(&fib->event_wait);
- spin_unlock_irqrestore(&fib->event_lock, flagv);
- schedule();
- retval = 0;
- }
- }
+ scsi_host_busy_iter(host, aac_close_sync_fib_iter, &retval);
/* Give some extra time for ioctls to complete. */
if (retval == 0)
ssleep(2);
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index ab3762c01738..52c29cc55846 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -681,7 +681,8 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
struct scsi_device * dev = cmd->device;
struct Scsi_Host * host = dev->host;
struct aac_dev * aac = (struct aac_dev *)host->hostdata;
- int count, found;
+ struct fib *fib;
+ int count;
u32 bus, cid;
int ret = FAILED;
@@ -691,26 +692,20 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
bus = aac_logical_to_phys(scmd_channel(cmd));
cid = scmd_id(cmd);
if (aac->hba_map[bus][cid].devtype == AAC_DEVTYPE_NATIVE_RAW) {
- struct fib *fib;
struct aac_hba_tm_req *tmf;
int status;
u64 address;
pr_err("%s: Host adapter abort request (%d,%d,%d,%d)\n",
- AAC_DRIVERNAME,
- host->host_no, sdev_channel(dev), sdev_id(dev), (int)dev->lun);
-
- found = 0;
- for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
- fib = &aac->fibs[count];
- if (*(u8 *)fib->hw_fib_va != 0 &&
- (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) &&
- (fib->callback_data == cmd)) {
- found = 1;
- break;
- }
- }
- if (!found)
+ AAC_DRIVERNAME, host->host_no,
+ sdev_channel(dev), sdev_id(dev), (int)dev->lun);
+
+ fib = &aac->fibs[cmd->request->tag];
+ if (*(u8 *)fib->hw_fib_va != 0 &&
+ (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) &&
+ (fib->callback_data == cmd))
+ ret = SUCCESS;
+ if (ret == FAILED)
return ret;
/* start a HBA_TMF_ABORT_TASK TMF request */
@@ -772,20 +767,13 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
* Mark associated FIB to not complete,
* eh handler does this
*/
- for (count = 0;
- count < (host->can_queue + AAC_NUM_MGT_FIB);
- ++count) {
- struct fib *fib = &aac->fibs[count];
-
- if (fib->hw_fib_va->header.XferState &&
- (fib->flags & FIB_CONTEXT_FLAG) &&
- (fib->callback_data == cmd)) {
- fib->flags |=
- FIB_CONTEXT_FLAG_TIMED_OUT;
- cmd->SCp.phase =
- AAC_OWNER_ERROR_HANDLER;
- ret = SUCCESS;
- }
+ fib = &aac->fibs[cmd->request->tag];
+ if (fib->hw_fib_va->header.XferState &&
+ (fib->flags & FIB_CONTEXT_FLAG) &&
+ (fib->callback_data == cmd)) {
+ fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT;
+ cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
+ ret = SUCCESS;
}
break;
case TEST_UNIT_READY:
@@ -793,27 +781,14 @@ static int aac_eh_abort(struct scsi_cmnd* cmd)
* Mark associated FIB to not complete,
* eh handler does this
*/
- for (count = 0;
- count < (host->can_queue + AAC_NUM_MGT_FIB);
- ++count) {
- struct scsi_cmnd *command;
- struct fib *fib = &aac->fibs[count];
-
- command = fib->callback_data;
-
- if ((fib->hw_fib_va->header.XferState &
- cpu_to_le32
- (Async | NoResponseExpected)) &&
- (fib->flags & FIB_CONTEXT_FLAG) &&
- ((command)) &&
- (command->device == cmd->device)) {
- fib->flags |=
- FIB_CONTEXT_FLAG_TIMED_OUT;
- command->SCp.phase =
- AAC_OWNER_ERROR_HANDLER;
- if (command == cmd)
- ret = SUCCESS;
- }
+ fib = &aac->fibs[cmd->request->tag];
+ if ((fib->hw_fib_va->header.XferState &
+ cpu_to_le32(Async | NoResponseExpected)) &&
+ (fib->flags & FIB_CONTEXT_FLAG) &&
+ (fib->callback_data == cmd)) {
+ fib->flags |= FIB_CONTEXT_FLAG_TIMED_OUT;
+ cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
+ ret = SUCCESS;
}
break;
}
@@ -1021,6 +996,36 @@ static int aac_eh_target_reset(struct scsi_cmnd *cmd)
return ret;
}
+static bool aac_eh_bus_reset_iter(struct scsi_cmnd *cmd, void *data,
+ bool reserved)
+{
+ struct Scsi_Host *host = cmd->device->host;
+ struct aac_dev *aac = (struct aac_dev *)host->hostdata;
+ struct fib *fib = &aac->fibs[cmd->request->tag];
+ int *cmd_bus = data;
+
+ if (fib->hw_fib_va->header.XferState &&
+ (fib->flags & FIB_CONTEXT_FLAG) &&
+ (fib->flags & FIB_CONTEXT_FLAG_SCSI_CMD)) {
+ struct aac_hba_map_info *info;
+ u32 bus, cid;
+
+ if (cmd != (struct scsi_cmnd *)fib->callback_data)
+ return true;
+ bus = aac_logical_to_phys(scmd_channel(cmd));
+ if (bus != *cmd_bus)
+ return true;
+ cid = scmd_id(cmd);
+ info = &aac->hba_map[bus][cid];
+ if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS ||
+ info->devtype != AAC_DEVTYPE_NATIVE_RAW) {
+ fib->flags |= FIB_CONTEXT_FLAG_EH_RESET;
+ cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
+ }
+ }
+ return true;
+}
+
/*
* aac_eh_bus_reset - Bus reset command handling
* @scsi_cmd: SCSI command block causing the reset
@@ -1038,29 +1043,7 @@ static int aac_eh_bus_reset(struct scsi_cmnd* cmd)
cmd_bus = aac_logical_to_phys(scmd_channel(cmd));
/* Mark the assoc. FIB to not complete, eh handler does this */
- for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) {
- struct fib *fib = &aac->fibs[count];
-
- if (fib->hw_fib_va->header.XferState &&
- (fib->flags & FIB_CONTEXT_FLAG) &&
- (fib->flags & FIB_CONTEXT_FLAG_SCSI_CMD)) {
- struct aac_hba_map_info *info;
- u32 bus, cid;
-
- cmd = (struct scsi_cmnd *)fib->callback_data;
- bus = aac_logical_to_phys(scmd_channel(cmd));
- if (bus != cmd_bus)
- continue;
- cid = scmd_id(cmd);
- info = &aac->hba_map[bus][cid];
- if (bus >= AAC_MAX_BUSES || cid >= AAC_MAX_TARGETS ||
- info->devtype != AAC_DEVTYPE_NATIVE_RAW) {
- fib->flags |= FIB_CONTEXT_FLAG_EH_RESET;
- cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER;
- }
- }
- }
-
+ scsi_host_busy_iter(host, aac_eh_bus_reset_iter, &cmd_bus);
pr_err("%s: Host bus reset request. SCSI hang ?\n", AAC_DRIVERNAME);
/*
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 21/31] mv_sas: kill mvsas_debug_issue_ssp_tmf()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (19 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 20/31] aacraid: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 22/31] pm8001: kill pm8001_issue_ssp_tmf() Hannes Reinecke
` (12 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Just a wrapper around mvs_exec_internal_tmf_task(), so call
it directly and kill the wrapper.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/mvsas/mv_sas.c | 33 +++++++++++----------------------
1 file changed, 11 insertions(+), 22 deletions(-)
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index 1acea528f27f..543b435f4c8c 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -1275,11 +1275,14 @@ static void mvs_tmf_timedout(struct timer_list *t)
#define MVS_TASK_TIMEOUT 20
static int mvs_exec_internal_tmf_task(struct domain_device *dev,
- void *parameter, u32 para_len, struct mvs_tmf_task *tmf)
+ u8 *lun, struct mvs_tmf_task *tmf)
{
int res, retry;
struct sas_task *task = NULL;
+ if (!(dev->tproto & SAS_PROTOCOL_SSP))
+ return TMF_RESP_FUNC_ESUPP;
+
for (retry = 0; retry < 3; retry++) {
task = sas_alloc_slow_task(GFP_KERNEL);
if (!task)
@@ -1288,7 +1291,7 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
task->dev = dev;
task->task_proto = dev->tproto;
- memcpy(&task->ssp_task, parameter, para_len);
+ memcpy(task->ssp_task.LUN, lun, 8);
task->task_done = mvs_task_done;
task->slow_task->timer.function = mvs_tmf_timedout;
@@ -1349,20 +1352,6 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
return res;
}
-static int mvs_debug_issue_ssp_tmf(struct domain_device *dev,
- u8 *lun, struct mvs_tmf_task *tmf)
-{
- struct sas_ssp_task ssp_task;
- if (!(dev->tproto & SAS_PROTOCOL_SSP))
- return TMF_RESP_FUNC_ESUPP;
-
- memcpy(ssp_task.LUN, lun, 8);
-
- return mvs_exec_internal_tmf_task(dev, &ssp_task,
- sizeof(ssp_task), tmf);
-}
-
-
/* Standard mandates link reset for ATA (type 0)
and hard reset for SSP (type 1) , only for RECOVERY */
static int mvs_debug_I_T_nexus_reset(struct domain_device *dev)
@@ -1388,7 +1377,7 @@ int mvs_lu_reset(struct domain_device *dev, u8 *lun)
tmf_task.tmf = TMF_LU_RESET;
mvi_dev->dev_status = MVS_DEV_EH;
- rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun, &tmf_task);
if (rc == TMF_RESP_FUNC_COMPLETE) {
spin_lock_irqsave(&mvi->lock, flags);
mvs_release_task(mvi, dev);
@@ -1445,7 +1434,7 @@ int mvs_query_task(struct sas_task *task)
tmf_task.tmf = TMF_QUERY_TASK;
tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
- rc = mvs_debug_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
switch (rc) {
/* The task is still in Lun, release it then */
case TMF_RESP_FUNC_SUCC:
@@ -1500,7 +1489,7 @@ int mvs_abort_task(struct sas_task *task)
tmf_task.tmf = TMF_ABORT_TASK;
tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
- rc = mvs_debug_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
/* if successful, clear the task and callback forwards.*/
if (rc == TMF_RESP_FUNC_COMPLETE) {
@@ -1543,7 +1532,7 @@ int mvs_abort_task_set(struct domain_device *dev, u8 *lun)
struct mvs_tmf_task tmf_task;
tmf_task.tmf = TMF_ABORT_TASK_SET;
- rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun, &tmf_task);
return rc;
}
@@ -1554,7 +1543,7 @@ int mvs_clear_aca(struct domain_device *dev, u8 *lun)
struct mvs_tmf_task tmf_task;
tmf_task.tmf = TMF_CLEAR_ACA;
- rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun, &tmf_task);
return rc;
}
@@ -1565,7 +1554,7 @@ int mvs_clear_task_set(struct domain_device *dev, u8 *lun)
struct mvs_tmf_task tmf_task;
tmf_task.tmf = TMF_CLEAR_TASK_SET;
- rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
+ rc = mvs_exec_internal_tmf_task(dev, lun, &tmf_task);
return rc;
}
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 22/31] pm8001: kill pm8001_issue_ssp_tmf()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (20 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 21/31] mv_sas: kill mvsas_debug_issue_ssp_tmf() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 23/31] pm8001: kill 'dev' argument from pm8001_exec_internal_task_abort() Hannes Reinecke
` (11 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Just a wrapper around pm8001_exec_internal_tmf_task(), so call it
directly and kill the wrapper.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/pm8001/pm8001_sas.c | 42 +++++++++++++-------------------
1 file changed, 17 insertions(+), 25 deletions(-)
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index a98d4496ff8b..6e1c1bbbfdd9 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -697,16 +697,15 @@ static void pm8001_tmf_timedout(struct timer_list *t)
/**
* pm8001_exec_internal_tmf_task - execute some task management commands.
* @dev: the wanted device.
+ * @lun: the logical unit number of the device
* @tmf: which task management wanted to be take.
- * @para_len: para_len.
- * @parameter: ssp task parameter.
*
* when errors or exception happened, we may want to do something, for example
* abort the issued task which result in this execption, it is done by calling
* this function, note it is also with the task execute interface.
*/
static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
- void *parameter, u32 para_len, struct pm8001_tmf_task *tmf)
+ u8 *lun, struct pm8001_tmf_task *tmf)
{
int res, retry;
struct sas_task *task = NULL;
@@ -714,6 +713,9 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
struct pm8001_device *pm8001_dev = dev->lldd_dev;
DECLARE_COMPLETION_ONSTACK(completion_setstate);
+ if (!(dev->tproto & SAS_PROTOCOL_SSP))
+ return TMF_RESP_FUNC_ESUPP;
+
for (retry = 0; retry < 3; retry++) {
task = sas_alloc_slow_task(GFP_KERNEL);
if (!task)
@@ -721,7 +723,7 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
task->dev = dev;
task->task_proto = dev->tproto;
- memcpy(&task->ssp_task, parameter, para_len);
+ memcpy(task->ssp_task.LUN, lun, 8);
task->task_done = pm8001_task_done;
task->slow_task->timer.function = pm8001_tmf_timedout;
task->slow_task->timer.expires = jiffies + PM8001_TASK_TIMEOUT*HZ;
@@ -897,18 +899,6 @@ void pm8001_dev_gone(struct domain_device *dev)
pm8001_dev_gone_notify(dev);
}
-static int pm8001_issue_ssp_tmf(struct domain_device *dev,
- u8 *lun, struct pm8001_tmf_task *tmf)
-{
- struct sas_ssp_task ssp_task;
- if (!(dev->tproto & SAS_PROTOCOL_SSP))
- return TMF_RESP_FUNC_ESUPP;
-
- memcpy((u8 *)&ssp_task.LUN, lun, 8);
- return pm8001_exec_internal_tmf_task(dev, &ssp_task, sizeof(ssp_task),
- tmf);
-}
-
/* retry commands by ha, by task and/or by device */
void pm8001_open_reject_retry(
struct pm8001_hba_info *pm8001_ha,
@@ -1114,7 +1104,7 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
wait_for_completion(&completion_setstate);
} else {
tmf_task.tmf = TMF_LU_RESET;
- rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+ rc = pm8001_exec_internal_tmf_task(dev, lun, &tmf_task);
}
/* If failed, fall-through I_T_Nexus reset */
pm8001_dbg(pm8001_ha, EH, "for device[%x]:rc=%d\n",
@@ -1145,10 +1135,10 @@ int pm8001_query_task(struct sas_task *task)
return rc;
}
pm8001_dbg(pm8001_ha, EH, "Query:[%16ph]\n", cmnd->cmnd);
- tmf_task.tmf = TMF_QUERY_TASK;
+ tmf_task.tmf = TMF_QUERY_TASK;
tmf_task.tag_of_task_to_be_managed = tag;
- rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
+ rc = pm8001_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
switch (rc) {
/* The task is still in Lun, release it then */
case TMF_RESP_FUNC_SUCC:
@@ -1216,9 +1206,11 @@ int pm8001_abort_task(struct sas_task *task)
int_to_scsilun(cmnd->device->lun, &lun);
tmf_task.tmf = TMF_ABORT_TASK;
tmf_task.tag_of_task_to_be_managed = tag;
- rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
- pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- pm8001_dev->sas_device, 0, tag);
+ rc = pm8001_exec_internal_tmf_task(dev, lun.scsi_lun,
+ &tmf_task);
+ if (rc == TMF_RESP_FUNC_SUCC)
+ pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+ pm8001_dev->sas_device, 0, tag);
} else if (task->task_proto & SAS_PROTOCOL_SATA ||
task->task_proto & SAS_PROTOCOL_STP) {
if (pm8001_ha->chip_id == chip_8006) {
@@ -1328,7 +1320,7 @@ int pm8001_abort_task_set(struct domain_device *dev, u8 *lun)
struct pm8001_tmf_task tmf_task;
tmf_task.tmf = TMF_ABORT_TASK_SET;
- return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+ return pm8001_exec_internal_tmf_task(dev, lun, &tmf_task);
}
int pm8001_clear_aca(struct domain_device *dev, u8 *lun)
@@ -1336,7 +1328,7 @@ int pm8001_clear_aca(struct domain_device *dev, u8 *lun)
struct pm8001_tmf_task tmf_task;
tmf_task.tmf = TMF_CLEAR_ACA;
- return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+ return pm8001_exec_internal_tmf_task(dev, lun, &tmf_task);
}
int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
@@ -1348,5 +1340,5 @@ int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
pm8001_dbg(pm8001_ha, EH, "I_T_L_Q clear task set[%x]\n",
pm8001_dev->device_id);
tmf_task.tmf = TMF_CLEAR_TASK_SET;
- return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+ return pm8001_exec_internal_tmf_task(dev, lun, &tmf_task);
}
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 23/31] pm8001: kill 'dev' argument from pm8001_exec_internal_task_abort()
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (21 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 22/31] pm8001: kill pm8001_issue_ssp_tmf() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 24/31] pm8001: use libsas-provided domain devices for SATA Hannes Reinecke
` (10 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
'dev' is always pm8001_dev->sas_device, so we can kill it.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/pm8001/pm8001_sas.c | 31 ++++++++++++++++---------------
1 file changed, 16 insertions(+), 15 deletions(-)
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index 6e1c1bbbfdd9..01e91347eb41 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -791,9 +791,10 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
static int
pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
- struct pm8001_device *pm8001_dev, struct domain_device *dev, u32 flag,
+ struct pm8001_device *pm8001_dev, u32 flag,
u32 task_tag)
{
+ struct domain_device *dev = pm8001_dev->sas_device;
int res, retry;
u32 ccb_tag;
struct pm8001_ccb_info *ccb;
@@ -879,8 +880,8 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
pm8001_dev->device_id, pm8001_dev->dev_type);
if (atomic_read(&pm8001_dev->running_req)) {
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
- pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
- dev, 1, 0);
+ pm8001_exec_internal_task_abort(pm8001_ha,
+ pm8001_dev, 1, 0);
while (atomic_read(&pm8001_dev->running_req))
msleep(20);
spin_lock_irqsave(&pm8001_ha->lock, flags);
@@ -1003,8 +1004,8 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
goto out;
}
msleep(2000);
- rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
- dev, 1, 0);
+ rc = pm8001_exec_internal_task_abort(pm8001_ha,
+ pm8001_dev, 1, 0);
if (rc) {
pm8001_dbg(pm8001_ha, EH, "task abort failed %x\n"
"with rc %d\n", pm8001_dev->device_id, rc);
@@ -1049,8 +1050,8 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
goto out;
}
/* send internal ssp/sata/smp abort command to FW */
- rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
- dev, 1, 0);
+ rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+ 1, 0);
msleep(100);
/* deregister the target device */
@@ -1065,8 +1066,8 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
wait_for_completion(&completion_setstate);
} else {
/* send internal ssp/sata/smp abort command to FW */
- rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
- dev, 1, 0);
+ rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+ 1, 0);
msleep(100);
/* deregister the target device */
@@ -1094,8 +1095,8 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
DECLARE_COMPLETION_ONSTACK(completion_setstate);
if (dev_is_sata(dev)) {
struct sas_phy *phy = sas_get_local_phy(dev);
- rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
- dev, 1, 0);
+ rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+ 1, 0);
rc = sas_phy_reset(phy, 1);
sas_put_local_phy(phy);
pm8001_dev->setds_completion = &completion_setstate;
@@ -1210,7 +1211,7 @@ int pm8001_abort_task(struct sas_task *task)
&tmf_task);
if (rc == TMF_RESP_FUNC_SUCC)
pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- pm8001_dev->sas_device, 0, tag);
+ 0, tag);
} else if (task->task_proto & SAS_PROTOCOL_SATA ||
task->task_proto & SAS_PROTOCOL_STP) {
if (pm8001_ha->chip_id == chip_8006) {
@@ -1279,7 +1280,7 @@ int pm8001_abort_task(struct sas_task *task)
* going to free the task.
*/
ret = pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, pm8001_dev->sas_device, 1, tag);
+ pm8001_dev, 1, tag);
if (ret)
goto out;
ret = wait_for_completion_timeout(
@@ -1296,13 +1297,13 @@ int pm8001_abort_task(struct sas_task *task)
wait_for_completion(&completion);
} else {
rc = pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, pm8001_dev->sas_device, 0, tag);
+ pm8001_dev, 0, tag);
}
rc = TMF_RESP_FUNC_COMPLETE;
} else if (task->task_proto & SAS_PROTOCOL_SMP) {
/* SMP */
rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- pm8001_dev->sas_device, 0, tag);
+ 0, tag);
}
out:
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 24/31] pm8001: use libsas-provided domain devices for SATA
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (22 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 23/31] pm8001: kill 'dev' argument from pm8001_exec_internal_task_abort() Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 25/31] libsas: add SCSI target pointer to struct domain_device Hannes Reinecke
` (9 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
The pm8001 driver assumes that libsas does not provide any domain
devices for SATA, which is actually not true.
So use the libsas-provided domain devices for SATA and don't
allocate private ones.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/pm8001/pm8001_hwi.c | 14 +-------------
drivers/scsi/pm8001/pm80xx_hwi.c | 15 +--------------
2 files changed, 2 insertions(+), 27 deletions(-)
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index 49bf2f70a470..3998fcd69acb 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -1749,7 +1749,7 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct host_to_dev_fis fis;
- struct domain_device *dev;
+ struct domain_device *dev = pm8001_ha_dev->sas_device;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_HOST_OPSTART;
@@ -1768,17 +1768,6 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
return;
}
- /* allocate domain device by ourselves as libsas
- * is not going to provide any
- */
- dev = kzalloc(sizeof(struct domain_device), GFP_ATOMIC);
- if (!dev) {
- sas_free_task(task);
- pm8001_tag_free(pm8001_ha, ccb_tag);
- pm8001_dbg(pm8001_ha, FAIL,
- "Domain device cannot be allocated\n");
- return;
- }
task->dev = dev;
task->dev->lldd_dev = pm8001_ha_dev;
@@ -1810,7 +1799,6 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
if (res) {
sas_free_task(task);
pm8001_tag_free(pm8001_ha, ccb_tag);
- kfree(dev);
}
}
diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
index 84315560e8e1..bc1929b230c4 100644
--- a/drivers/scsi/pm8001/pm80xx_hwi.c
+++ b/drivers/scsi/pm8001/pm80xx_hwi.c
@@ -1824,7 +1824,7 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct host_to_dev_fis fis;
- struct domain_device *dev;
+ struct domain_device *dev = pm8001_ha_dev->sas_device;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_HOST_OPSTART;
@@ -1843,18 +1843,6 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
return;
}
- /* allocate domain device by ourselves as libsas
- * is not going to provide any
- */
- dev = kzalloc(sizeof(struct domain_device), GFP_ATOMIC);
- if (!dev) {
- sas_free_task(task);
- pm8001_tag_free(pm8001_ha, ccb_tag);
- pm8001_dbg(pm8001_ha, FAIL,
- "Domain device cannot be allocated\n");
- return;
- }
-
task->dev = dev;
task->dev->lldd_dev = pm8001_ha_dev;
@@ -1888,7 +1876,6 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
if (res) {
sas_free_task(task);
pm8001_tag_free(pm8001_ha, ccb_tag);
- kfree(dev);
}
}
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 25/31] libsas: add SCSI target pointer to struct domain_device
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (23 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 24/31] pm8001: use libsas-provided domain devices for SATA Hannes Reinecke
@ 2021-02-22 13:23 ` Hannes Reinecke
2021-02-22 13:24 ` [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task Hannes Reinecke
` (8 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:23 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Add a pointer to the SCSI target which corresponds to the
domain device.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/libsas/sas_scsi_host.c | 2 ++
include/scsi/libsas.h | 1 +
2 files changed, 3 insertions(+)
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 1bf939818c98..ae247aed857f 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -830,6 +830,7 @@ int sas_target_alloc(struct scsi_target *starget)
kref_get(&found_dev->kref);
starget->hostdata = found_dev;
+ found_dev->starget = starget;
return 0;
}
@@ -919,6 +920,7 @@ void sas_target_destroy(struct scsi_target *starget)
return;
starget->hostdata = NULL;
+ found_dev->starget = NULL;
sas_put_device(found_dev);
}
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
index 9271d7a49b90..3a024eced38c 100644
--- a/include/scsi/libsas.h
+++ b/include/scsi/libsas.h
@@ -175,6 +175,7 @@ struct domain_device {
struct domain_device *parent;
struct list_head siblings; /* devices on the same level */
+ struct scsi_target *starget; /* Corresponding SCSI target device */
struct asd_sas_port *port; /* shortcut to root of the tree */
struct sas_phy *phy;
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (24 preceding siblings ...)
2021-02-22 13:23 ` [PATCH 25/31] libsas: add SCSI target pointer to struct domain_device Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-03-09 11:22 ` luojiaxing
2021-02-22 13:24 ` [PATCH 27/31] libsas: add tag to struct sas_task Hannes Reinecke
` (7 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
From: John Garry <john.garry@huawei.com>
Allocate a Scsi_cmd for SAS slow tasks, so they can be accounted for in
the blk-mq layer.
Signed-off-by: John Garry <john.garry@huawei.com>
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/hisi_sas/hisi_sas_main.c | 56 ++++++++++++++++--------
drivers/scsi/libsas/sas_expander.c | 7 ++-
drivers/scsi/libsas/sas_init.c | 61 ++++++++++++++++++++++++---
drivers/scsi/mvsas/mv_sas.c | 5 ++-
drivers/scsi/pm8001/pm8001_hwi.c | 9 +++-
drivers/scsi/pm8001/pm8001_sas.c | 39 +++++++++++------
drivers/scsi/pm8001/pm80xx_hwi.c | 9 +++-
include/scsi/libsas.h | 8 +++-
8 files changed, 148 insertions(+), 46 deletions(-)
diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
index a979edfd9a78..6a69a90a1b82 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_main.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
@@ -15,6 +15,7 @@ static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
static int
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
struct domain_device *device,
+ struct scsi_lun *lun,
int abort_flag, int tag);
static int hisi_sas_softreset_ata_disk(struct domain_device *device);
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
@@ -1055,15 +1056,17 @@ static void hisi_sas_dev_gone(struct domain_device *device)
struct hisi_sas_device *sas_dev = device->lldd_dev;
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
struct device *dev = hisi_hba->dev;
+ struct scsi_lun lun;
int ret = 0;
dev_info(dev, "dev[%d:%x] is gone\n",
sas_dev->device_id, sas_dev->dev_type);
down(&hisi_hba->sem);
+ int_to_scsilun(0, &lun);
if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV, 0);
+ &lun, HISI_SAS_INT_ABT_DEV, 0);
hisi_sas_dereg_device(hisi_hba, device);
@@ -1191,12 +1194,21 @@ static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
{
struct hisi_sas_device *sas_dev = device->lldd_dev;
struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
+ struct sas_ha_struct *sha = &hisi_hba->sha;
struct device *dev = hisi_hba->dev;
struct sas_task *task;
int res, retry;
for (retry = 0; retry < TASK_RETRY; retry++) {
- task = sas_alloc_slow_task(GFP_KERNEL);
+ struct scsilun lun;
+
+ int_to_scsilun(0, &lun);
+ if (!dev_is_sata) {
+ struct sas_ssp_task ssp_task = parameter;
+
+ memcpy(lun.scsi_lun, ssp_task.LUN, 8);
+ }
+ task = sas_alloc_slow_task(sha, device, &lun, GFP_KERNEL);
if (!task)
return -ENOMEM;
@@ -1494,7 +1506,9 @@ static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
{
struct device *dev = hisi_hba->dev;
int port_no, rc, i;
+ struct scsi_lun lun;
+ int_to_scsilun(0, &lun);
for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
struct domain_device *device = sas_dev->sas_device;
@@ -1503,7 +1517,7 @@ static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
continue;
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV, 0);
+ &lun, HISI_SAS_INT_ABT_DEV, 0);
if (rc < 0)
dev_err(dev, "STP reject: abort dev failed %d\n", rc);
}
@@ -1653,7 +1667,7 @@ static int hisi_sas_abort_task(struct sas_task *task)
&tmf_task);
rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_CMD, tag);
+ &lun, HISI_SAS_INT_ABT_CMD, tag);
if (rc2 < 0) {
dev_err(dev, "abort task: internal abort (%d)\n", rc2);
return TMF_RESP_FUNC_FAILED;
@@ -1673,9 +1687,9 @@ static int hisi_sas_abort_task(struct sas_task *task)
} else if (task->task_proto & SAS_PROTOCOL_SATA ||
task->task_proto & SAS_PROTOCOL_STP) {
if (task->dev->dev_type == SAS_SATA_DEV) {
+ int_to_scsilun(0, &lun);
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV,
- 0);
+ &lun, HISI_SAS_INT_ABT_DEV, 0);
if (rc < 0) {
dev_err(dev, "abort task: internal abort failed\n");
goto out;
@@ -1689,8 +1703,9 @@ static int hisi_sas_abort_task(struct sas_task *task)
u32 tag = slot->idx;
struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
+ int_to_scsilun(0, &lun);
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_CMD, tag);
+ &lun, HISI_SAS_INT_ABT_CMD, tag);
if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
task->lldd_task) {
/*
@@ -1716,7 +1731,7 @@ static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
int rc;
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV, 0);
+ (struct scsi_lun *)lun, HISI_SAS_INT_ABT_DEV, 0);
if (rc < 0) {
dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
return TMF_RESP_FUNC_FAILED;
@@ -1804,10 +1819,12 @@ static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
{
struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
struct device *dev = hisi_hba->dev;
+ struct scsi_lun lun;
int rc;
+ int_to_scsilun(0, &lun);
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV, 0);
+ &lun, HISI_SAS_INT_ABT_DEV, 0);
if (rc < 0) {
dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
return TMF_RESP_FUNC_FAILED;
@@ -1837,7 +1854,7 @@ static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
/* Clear internal IO and then lu reset */
rc = hisi_sas_internal_task_abort(hisi_hba, device,
- HISI_SAS_INT_ABT_DEV, 0);
+ (struct scsi_lun *)lun, HISI_SAS_INT_ABT_DEV, 0);
if (rc < 0) {
dev_err(dev, "lu_reset: internal abort failed\n");
goto out;
@@ -2018,6 +2035,7 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
* abort command for single IO command or a device
* @hisi_hba: host controller struct
* @device: domain device
+ * @lun: logical unit number
* @abort_flag: mode of operation, device or single IO
* @tag: tag of IO to be aborted (only relevant to single
* IO mode)
@@ -2025,12 +2043,15 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
*/
static int
_hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
- struct domain_device *device, int abort_flag,
- int tag, struct hisi_sas_dq *dq)
+ struct domain_device *device,
+ struct scsi_lun *lun,
+ int abort_flag, int tag,
+ struct hisi_sas_dq *dq)
{
- struct sas_task *task;
struct hisi_sas_device *sas_dev = device->lldd_dev;
+ struct sas_ha_struct *sha = &hisi_hba->sha;
struct device *dev = hisi_hba->dev;
+ struct sas_task *task;
int res;
/*
@@ -2042,7 +2063,8 @@ _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
if (!hisi_hba->hw->prep_abort)
return TMF_RESP_FUNC_FAILED;
- task = sas_alloc_slow_task(GFP_KERNEL);
+ task = sas_alloc_slow_task(sha, device,
+ (struct scsi_lun *)lun, GFP_KERNEL);
if (!task)
return -ENOMEM;
@@ -2115,6 +2137,7 @@ _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
static int
hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
struct domain_device *device,
+ struct scsi_lun *lun,
int abort_flag, int tag)
{
struct hisi_sas_slot *slot;
@@ -2127,7 +2150,7 @@ hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
slot = &hisi_hba->slot_info[tag];
dq = &hisi_hba->dq[slot->dlvry_queue];
return _hisi_sas_internal_task_abort(hisi_hba, device,
- abort_flag, tag, dq);
+ lun, abort_flag, tag, dq);
case HISI_SAS_INT_ABT_DEV:
for (i = 0; i < hisi_hba->cq_nvecs; i++) {
struct hisi_sas_cq *cq = &hisi_hba->cq[i];
@@ -2137,8 +2160,7 @@ hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
continue;
dq = &hisi_hba->dq[i];
rc = _hisi_sas_internal_task_abort(hisi_hba, device,
- abort_flag, tag,
- dq);
+ lun, abort_flag, tag, dq);
if (rc)
return rc;
}
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 8d6bcc19359f..9e4a7c85a037 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -56,9 +56,12 @@ static int smp_execute_task_sg(struct domain_device *dev,
{
int res, retry;
struct sas_task *task = NULL;
+ struct sas_ha_struct *ha = dev->port->ha;
struct sas_internal *i =
- to_sas_internal(dev->port->ha->core.shost->transportt);
+ to_sas_internal(ha->core.shost->transportt);
+ struct scsi_lun lun;
+ int_to_scsilun(0, &lun);
mutex_lock(&dev->ex_dev.cmd_mutex);
for (retry = 0; retry < 3; retry++) {
if (test_bit(SAS_DEV_GONE, &dev->state)) {
@@ -66,7 +69,7 @@ static int smp_execute_task_sg(struct domain_device *dev,
break;
}
- task = sas_alloc_slow_task(GFP_KERNEL);
+ task = sas_alloc_slow_task(ha, dev, &lun, GFP_KERNEL);
if (!task) {
res = -ENOMEM;
break;
diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
index 2b0f98ca6ec3..9d0448b76a2f 100644
--- a/drivers/scsi/libsas/sas_init.c
+++ b/drivers/scsi/libsas/sas_init.c
@@ -14,6 +14,7 @@
#include <scsi/sas_ata.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_device.h>
+#include <scsi/scsi_tcq.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_sas.h>
@@ -37,16 +38,36 @@ struct sas_task *sas_alloc_task(gfp_t flags)
}
EXPORT_SYMBOL_GPL(sas_alloc_task);
-struct sas_task *sas_alloc_slow_task(gfp_t flags)
+struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
+ struct domain_device *dev,
+ struct scsi_lun *lun, gfp_t flags)
{
struct sas_task *task = sas_alloc_task(flags);
- struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags);
+ struct Scsi_Host *shost = ha->core.shost;
+ struct sas_task_slow *slow;
- if (!task || !slow) {
- if (task)
- kmem_cache_free(sas_task_cache, task);
- kfree(slow);
+ if (!task)
return NULL;
+
+ slow = kzalloc(sizeof(*slow), flags);
+ if (!slow)
+ goto out_err_slow;
+
+ if (shost->nr_reserved_cmds) {
+ struct scsi_device *sdev;
+
+ if (dev && dev->starget) {
+ sdev = scsi_device_lookup_by_target(dev->starget,
+ scsilun_to_int(lun));
+ if (!sdev)
+ goto out_err_scmd;
+ } else
+ sdev = ha->core.shost_dev;
+ slow->scmd = scsi_get_internal_cmd(sdev, DMA_BIDIRECTIONAL,
+ REQ_NOWAIT);
+ if (!slow->scmd)
+ goto out_err_scmd;
+ ASSIGN_SAS_TASK(slow->scmd, task);
}
task->slow_task = slow;
@@ -55,13 +76,31 @@ struct sas_task *sas_alloc_slow_task(gfp_t flags)
init_completion(&slow->completion);
return task;
+
+out_err_scmd:
+ kfree(slow);
+out_err_slow:
+ kmem_cache_free(sas_task_cache, task);
+ return NULL;
}
EXPORT_SYMBOL_GPL(sas_alloc_slow_task);
void sas_free_task(struct sas_task *task)
{
if (task) {
- kfree(task->slow_task);
+ /*
+ * It could be good to just introduce separate sas_free_slow_task() to
+ * avoid the following in the fastpath.
+ */
+ if (task->slow_task) {
+ struct scsi_cmnd *scmd = task->slow_task->scmd;
+
+ if (scmd) {
+ ASSIGN_SAS_TASK(scmd, NULL);
+ scsi_put_internal_cmd(scmd);
+ }
+ kfree(task->slow_task);
+ }
kmem_cache_free(sas_task_cache, task);
}
}
@@ -95,6 +134,7 @@ void sas_hash_addr(u8 *hashed, const u8 *sas_addr)
int sas_register_ha(struct sas_ha_struct *sas_ha)
{
+ struct Scsi_Host *shost = sas_ha->core.shost;
char name[64];
int error = 0;
@@ -111,6 +151,13 @@ int sas_register_ha(struct sas_ha_struct *sas_ha)
sas_ha->event_thres = SAS_PHY_SHUTDOWN_THRES;
+ if (shost->nr_reserved_cmds) {
+ sas_ha->core.shost_dev = scsi_get_host_dev(shost);
+ if (!sas_ha->core.shost_dev) {
+ pr_notice("couldn't register sas host device\n");
+ return -ENOMEM;
+ }
+ }
error = sas_register_phys(sas_ha);
if (error) {
pr_notice("couldn't register sas phys:%d\n", error);
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index 543b435f4c8c..99bdb88b3e86 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -1278,13 +1278,16 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
u8 *lun, struct mvs_tmf_task *tmf)
{
int res, retry;
+ struct sas_ha_struct *ha = dev->port->ha;
struct sas_task *task = NULL;
+ struct scsi_lun scsilun;
if (!(dev->tproto & SAS_PROTOCOL_SSP))
return TMF_RESP_FUNC_ESUPP;
+ memcpy(scsilun.scsi_lun, lun, 8);
for (retry = 0; retry < 3; retry++) {
- task = sas_alloc_slow_task(GFP_KERNEL);
+ task = sas_alloc_slow_task(ha, dev, &scsilun, GFP_KERNEL);
if (!task)
return -ENOMEM;
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index 3998fcd69acb..105962b0c815 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -1701,6 +1701,7 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
struct task_abort_req task_abort;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_ABORT;
+ struct scsi_lun lun;
int ret;
if (!pm8001_ha_dev) {
@@ -1708,7 +1709,9 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
return;
}
- task = sas_alloc_slow_task(GFP_ATOMIC);
+ int_to_scsilun(0, &lun);
+ task = sas_alloc_slow_task(pm8001_ha->sas, pm8001_ha_dev->sas_device,
+ &lun, GFP_ATOMIC);
if (!task) {
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
@@ -1752,8 +1755,10 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
struct domain_device *dev = pm8001_ha_dev->sas_device;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_HOST_OPSTART;
+ struct scsi_lun lun;;
- task = sas_alloc_slow_task(GFP_ATOMIC);
+ int_to_scsilun(0, &lun);
+ task = sas_alloc_slow_task(pm8001_ha->sas, dev, &lun, GFP_ATOMIC);
if (!task) {
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index 01e91347eb41..b1f12d671611 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -717,7 +717,9 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
return TMF_RESP_FUNC_ESUPP;
for (retry = 0; retry < 3; retry++) {
- task = sas_alloc_slow_task(GFP_KERNEL);
+ task = sas_alloc_slow_task(pm8001_ha->sas,
+ pm8001_dev->sas_device,
+ (struct scsi_lun *)lun, GFP_KERNEL);
if (!task)
return -ENOMEM;
@@ -791,7 +793,7 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
static int
pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
- struct pm8001_device *pm8001_dev, u32 flag,
+ struct pm8001_device *pm8001_dev, u8 *lun, u32 flag,
u32 task_tag)
{
struct domain_device *dev = pm8001_dev->sas_device;
@@ -801,7 +803,8 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
struct sas_task *task = NULL;
for (retry = 0; retry < 3; retry++) {
- task = sas_alloc_slow_task(GFP_KERNEL);
+ task = sas_alloc_slow_task(pm8001_ha->sas, dev,
+ (struct scsi_lun *)lun, GFP_KERNEL);
if (!task)
return -ENOMEM;
@@ -875,13 +878,15 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
spin_lock_irqsave(&pm8001_ha->lock, flags);
if (pm8001_dev) {
u32 device_id = pm8001_dev->device_id;
+ struct scsi_lun lun;
+ int_to_scsilun(0, &lun);
pm8001_dbg(pm8001_ha, DISC, "found dev[%d:%x] is gone.\n",
pm8001_dev->device_id, pm8001_dev->dev_type);
if (atomic_read(&pm8001_dev->running_req)) {
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, 1, 0);
+ pm8001_dev, lun.scsi_lun, 1, 0);
while (atomic_read(&pm8001_dev->running_req))
msleep(20);
spin_lock_irqsave(&pm8001_ha->lock, flags);
@@ -991,6 +996,9 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
phy = sas_get_local_phy(dev);
if (dev_is_sata(dev)) {
+ struct scsi_lun lun;
+
+ int_to_scsilun(0, &lun);
if (scsi_is_sas_phy_local(phy)) {
rc = 0;
goto out;
@@ -1005,7 +1013,7 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
}
msleep(2000);
rc = pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, 1, 0);
+ pm8001_dev, lun.scsi_lun, 1, 0);
if (rc) {
pm8001_dbg(pm8001_ha, EH, "task abort failed %x\n"
"with rc %d\n", pm8001_dev->device_id, rc);
@@ -1032,7 +1040,9 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
struct pm8001_device *pm8001_dev;
struct pm8001_hba_info *pm8001_ha;
struct sas_phy *phy;
+ struct scsi_lun lun;
+ int_to_scsilun(0, &lun);
if (!dev || !dev->lldd_dev)
return -1;
@@ -1051,7 +1061,7 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
}
/* send internal ssp/sata/smp abort command to FW */
rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- 1, 0);
+ lun.scsi_lun, 1, 0);
msleep(100);
/* deregister the target device */
@@ -1067,7 +1077,7 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
} else {
/* send internal ssp/sata/smp abort command to FW */
rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- 1, 0);
+ lun.scsi_lun, 1, 0);
msleep(100);
/* deregister the target device */
@@ -1095,8 +1105,8 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
DECLARE_COMPLETION_ONSTACK(completion_setstate);
if (dev_is_sata(dev)) {
struct sas_phy *phy = sas_get_local_phy(dev);
- rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- 1, 0);
+ rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+ lun, 1, 0);
rc = sas_phy_reset(phy, 1);
sas_put_local_phy(phy);
pm8001_dev->setds_completion = &completion_setstate;
@@ -1211,9 +1221,10 @@ int pm8001_abort_task(struct sas_task *task)
&tmf_task);
if (rc == TMF_RESP_FUNC_SUCC)
pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- 0, tag);
+ lun.scsi_lun, 0, tag);
} else if (task->task_proto & SAS_PROTOCOL_SATA ||
task->task_proto & SAS_PROTOCOL_STP) {
+ memset(lun.scsi_lun, 0, sizeof(lun.scsi_lun));
if (pm8001_ha->chip_id == chip_8006) {
DECLARE_COMPLETION_ONSTACK(completion_reset);
DECLARE_COMPLETION_ONSTACK(completion);
@@ -1280,7 +1291,7 @@ int pm8001_abort_task(struct sas_task *task)
* going to free the task.
*/
ret = pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, 1, tag);
+ pm8001_dev, lun.scsi_lun, 1, tag);
if (ret)
goto out;
ret = wait_for_completion_timeout(
@@ -1297,13 +1308,15 @@ int pm8001_abort_task(struct sas_task *task)
wait_for_completion(&completion);
} else {
rc = pm8001_exec_internal_task_abort(pm8001_ha,
- pm8001_dev, 0, tag);
+ pm8001_dev, lun.scsi_lun, 0, tag);
}
rc = TMF_RESP_FUNC_COMPLETE;
} else if (task->task_proto & SAS_PROTOCOL_SMP) {
/* SMP */
+
+ int_to_scsilun(0, &lun);
rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
- 0, tag);
+ lun.scsi_lun, 0, tag);
}
out:
diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
index bc1929b230c4..03bfb4d72895 100644
--- a/drivers/scsi/pm8001/pm80xx_hwi.c
+++ b/drivers/scsi/pm8001/pm80xx_hwi.c
@@ -1772,6 +1772,7 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
struct task_abort_req task_abort;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_ABORT;
+ struct scsi_lun lun;
int ret;
if (!pm8001_ha_dev) {
@@ -1779,7 +1780,9 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
return;
}
- task = sas_alloc_slow_task(GFP_ATOMIC);
+ int_to_scsilun(0, &lun);
+ task = sas_alloc_slow_task(pm8001_ha->sas,pm8001_ha_dev->sas_device,
+ &lun, GFP_ATOMIC);
if (!task) {
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
@@ -1827,8 +1830,10 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
struct domain_device *dev = pm8001_ha_dev->sas_device;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_SATA_HOST_OPSTART;
+ struct scsi_lun lun;
- task = sas_alloc_slow_task(GFP_ATOMIC);
+ int_to_scsilun(0, &lun);
+ task = sas_alloc_slow_task(pm8001_ha->sas, dev, &lun, GFP_ATOMIC);
if (!task) {
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
index 3a024eced38c..9b8c06a8329a 100644
--- a/include/scsi/libsas.h
+++ b/include/scsi/libsas.h
@@ -349,7 +349,7 @@ struct asd_sas_phy {
struct scsi_core {
struct Scsi_Host *shost;
-
+ struct scsi_device *shost_dev;
};
enum sas_ha_state {
@@ -605,6 +605,7 @@ struct sas_task_slow {
struct timer_list timer;
struct completion completion;
struct sas_task *task;
+ struct scsi_cmnd *scmd;
};
#define SAS_TASK_STATE_PENDING 1
@@ -614,7 +615,10 @@ struct sas_task_slow {
#define SAS_TASK_AT_INITIATOR 16
extern struct sas_task *sas_alloc_task(gfp_t flags);
-extern struct sas_task *sas_alloc_slow_task(gfp_t flags);
+extern struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
+ struct domain_device *dev,
+ struct scsi_lun *lun,
+ gfp_t flags);
extern void sas_free_task(struct sas_task *task);
struct sas_domain_function_template {
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 27/31] libsas: add tag to struct sas_task
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (25 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-02-22 13:24 ` [PATCH 28/31] scsi: hisi_sas: Use libsas slow task SCSI command Hannes Reinecke
` (6 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
All block layer commands now have a tag, so we should be storing
it in the sas_task structure for easier lookup.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/libsas/sas_ata.c | 4 ++++
drivers/scsi/libsas/sas_init.c | 2 ++
drivers/scsi/libsas/sas_scsi_host.c | 2 +-
include/scsi/libsas.h | 2 ++
4 files changed, 9 insertions(+), 1 deletion(-)
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 024e5a550759..2b05ca68d091 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -214,6 +214,10 @@ static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
else
task->data_dir = qc->dma_dir;
task->scatter = qc->sg;
+ if (qc->scsicmd)
+ task->tag = qc->scsicmd->request->tag;
+ else
+ task->tag = qc->tag;
task->ata_task.retry_count = 1;
task->task_state_flags = SAS_TASK_STATE_PENDING;
qc->lldd_task = task;
diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
index 9d0448b76a2f..a2f1789c7a6a 100644
--- a/drivers/scsi/libsas/sas_init.c
+++ b/drivers/scsi/libsas/sas_init.c
@@ -53,6 +53,7 @@ struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
if (!slow)
goto out_err_slow;
+ task->tag = -1;
if (shost->nr_reserved_cmds) {
struct scsi_device *sdev;
@@ -67,6 +68,7 @@ struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
REQ_NOWAIT);
if (!slow->scmd)
goto out_err_scmd;
+ task->tag = slow->scmd->request->tag;
ASSIGN_SAS_TASK(slow->scmd, task);
}
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index ae247aed857f..37b9ca483522 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -149,7 +149,7 @@ static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8);
task->ssp_task.task_attr = TASK_ATTR_SIMPLE;
task->ssp_task.cmd = cmd;
-
+ task->tag = cmd->request->tag;
task->scatter = scsi_sglist(cmd);
task->num_scatter = scsi_sg_count(cmd);
task->total_xfer_len = scsi_bufflen(cmd);
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
index 9b8c06a8329a..d047b7734343 100644
--- a/include/scsi/libsas.h
+++ b/include/scsi/libsas.h
@@ -590,6 +590,8 @@ struct sas_task {
u32 total_xfer_len;
u8 data_dir:2; /* Use PCI_DMA_... */
+ u32 tag;
+
struct task_status_struct task_status;
void (*task_done)(struct sas_task *);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 28/31] scsi: hisi_sas: Use libsas slow task SCSI command
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (26 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 27/31] libsas: add tag to struct sas_task Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-02-22 13:24 ` [PATCH 29/31] hisi_sas: use task tag to reference the slot Hannes Reinecke
` (5 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi
From: John Garry <john.garry@huawei.com>
Now that a SCSI command can be allocated for a libsas slow tasks, make the
task prep code use it.
Signed-off-by: John Garry <john.garry@huawei.com>
---
drivers/scsi/hisi_sas/hisi_sas_main.c | 17 ++++++++++-------
drivers/scsi/hisi_sas/hisi_sas_v3_hw.c | 5 +++--
2 files changed, 13 insertions(+), 9 deletions(-)
diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
index 6a69a90a1b82..af653f4393ea 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_main.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
@@ -179,15 +179,11 @@ static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
set_bit(slot_idx, bitmap);
}
-static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
- struct scsi_cmnd *scsi_cmnd)
+static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba)
{
int index;
void *bitmap = hisi_hba->slot_index_tags;
- if (scsi_cmnd)
- return scsi_cmnd->request->tag;
-
spin_lock(&hisi_hba->lock);
index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
hisi_hba->last_slot_index + 1);
@@ -444,6 +440,8 @@ static int hisi_sas_task_prep(struct sas_task *task,
} else {
scmd = task->uldd_task;
}
+ } else {
+ scmd = task->slow_task->scmd;
}
if (scmd) {
@@ -484,8 +482,10 @@ static int hisi_sas_task_prep(struct sas_task *task,
if (hisi_hba->hw->slot_index_alloc)
rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
+ else if (scmd)
+ rc = scmd->request->tag;
else
- rc = hisi_sas_slot_index_alloc(hisi_hba, scmd);
+ rc = hisi_sas_slot_index_alloc(hisi_hba);
if (rc < 0)
goto err_out_dif_dma_unmap;
@@ -1975,7 +1975,9 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
port = to_hisi_sas_port(sas_port);
/* simply get a slot and send abort command */
- rc = hisi_sas_slot_index_alloc(hisi_hba, NULL);
+ rc = = task->tag;
+ if (rc < 0)
+ rc = hisi_sas_slot_index_alloc(hisi_hba);
if (rc < 0)
goto err_out;
@@ -2683,6 +2685,7 @@ int hisi_sas_probe(struct platform_device *pdev,
} else {
shost->can_queue = HISI_SAS_UNRESERVED_IPTT;
shost->cmd_per_lun = HISI_SAS_UNRESERVED_IPTT;
+ shost->nr_reserved_cmds = HISI_SAS_RESERVED_IPTT;
}
sha->sas_ha_name = DRV_NAME;
diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
index 4580e081e489..c728c782e21a 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
@@ -4720,8 +4720,9 @@ hisi_sas_v3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
shost->max_lun = ~0;
shost->max_channel = 1;
shost->max_cmd_len = 16;
- shost->can_queue = HISI_SAS_UNRESERVED_IPTT;
- shost->cmd_per_lun = HISI_SAS_UNRESERVED_IPTT;
+ shost->can_queue = HISI_SAS_MAX_COMMANDS;
+ shost->cmd_per_lun = HISI_SAS_MAX_COMMANDS;
+ shost->nr_reserved_cmds = HISI_SAS_RESERVED_IPTT;
sha->sas_ha_name = DRV_NAME;
sha->dev = dev;
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 29/31] hisi_sas: use task tag to reference the slot
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (27 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 28/31] scsi: hisi_sas: Use libsas slow task SCSI command Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-03-10 1:54 ` luojiaxing
2021-02-22 13:24 ` [PATCH 30/31] mv_sas: use reserved tags and drop private tag allocation Hannes Reinecke
` (4 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Use the task task to reference the command slot and drop the
internal slot bitmap.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/hisi_sas/hisi_sas.h | 1 -
drivers/scsi/hisi_sas/hisi_sas_main.c | 78 ++-------------------------
2 files changed, 5 insertions(+), 74 deletions(-)
diff --git a/drivers/scsi/hisi_sas/hisi_sas.h b/drivers/scsi/hisi_sas/hisi_sas.h
index 2401a9575215..6efe980789ee 100644
--- a/drivers/scsi/hisi_sas/hisi_sas.h
+++ b/drivers/scsi/hisi_sas/hisi_sas.h
@@ -419,7 +419,6 @@ struct hisi_hba {
struct workqueue_struct *wq;
int slot_index_count;
- int last_slot_index;
int last_dev_id;
unsigned long *slot_index_tags;
unsigned long reject_stp_links_msk;
diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
index af653f4393ea..6402c4e4befa 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_main.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
@@ -155,62 +155,6 @@ void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
}
EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);
-static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
-{
- void *bitmap = hisi_hba->slot_index_tags;
-
- clear_bit(slot_idx, bitmap);
-}
-
-static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
-{
- if (hisi_hba->hw->slot_index_alloc ||
- slot_idx >= HISI_SAS_UNRESERVED_IPTT) {
- spin_lock(&hisi_hba->lock);
- hisi_sas_slot_index_clear(hisi_hba, slot_idx);
- spin_unlock(&hisi_hba->lock);
- }
-}
-
-static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
-{
- void *bitmap = hisi_hba->slot_index_tags;
-
- set_bit(slot_idx, bitmap);
-}
-
-static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba)
-{
- int index;
- void *bitmap = hisi_hba->slot_index_tags;
-
- spin_lock(&hisi_hba->lock);
- index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
- hisi_hba->last_slot_index + 1);
- if (index >= hisi_hba->slot_index_count) {
- index = find_next_zero_bit(bitmap,
- hisi_hba->slot_index_count,
- HISI_SAS_UNRESERVED_IPTT);
- if (index >= hisi_hba->slot_index_count) {
- spin_unlock(&hisi_hba->lock);
- return -SAS_QUEUE_FULL;
- }
- }
- hisi_sas_slot_index_set(hisi_hba, index);
- hisi_hba->last_slot_index = index;
- spin_unlock(&hisi_hba->lock);
-
- return index;
-}
-
-static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
-{
- int i;
-
- for (i = 0; i < hisi_hba->slot_index_count; ++i)
- hisi_sas_slot_index_clear(hisi_hba, i);
-}
-
void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
struct hisi_sas_slot *slot)
{
@@ -246,8 +190,6 @@ void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
spin_unlock(&sas_dev->lock);
memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
-
- hisi_sas_slot_index_free(hisi_hba, slot->idx);
}
EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
@@ -482,10 +424,8 @@ static int hisi_sas_task_prep(struct sas_task *task,
if (hisi_hba->hw->slot_index_alloc)
rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
- else if (scmd)
- rc = scmd->request->tag;
else
- rc = hisi_sas_slot_index_alloc(hisi_hba);
+ rc = scmd->request->tag;
if (rc < 0)
goto err_out_dif_dma_unmap;
@@ -1975,9 +1915,10 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
port = to_hisi_sas_port(sas_port);
/* simply get a slot and send abort command */
- rc = = task->tag;
- if (rc < 0)
- rc = hisi_sas_slot_index_alloc(hisi_hba);
+ if (hisi_hha->hw->slot_index_alloc)
+ rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
+ else
+ rc = = task->tag;
if (rc < 0)
goto err_out;
@@ -2440,12 +2381,6 @@ int hisi_sas_alloc(struct hisi_hba *hisi_hba)
if (!hisi_hba->breakpoint)
goto err_out;
- hisi_hba->slot_index_count = max_command_entries;
- s = hisi_hba->slot_index_count / BITS_PER_BYTE;
- hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
- if (!hisi_hba->slot_index_tags)
- goto err_out;
-
s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
&hisi_hba->initial_fis_dma,
@@ -2460,9 +2395,6 @@ int hisi_sas_alloc(struct hisi_hba *hisi_hba)
if (!hisi_hba->sata_breakpoint)
goto err_out;
- hisi_sas_slot_index_init(hisi_hba);
- hisi_hba->last_slot_index = HISI_SAS_UNRESERVED_IPTT;
-
hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
if (!hisi_hba->wq) {
dev_err(dev, "sas_alloc: failed to create workqueue\n");
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 30/31] mv_sas: use reserved tags and drop private tag allocation
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (28 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 29/31] hisi_sas: use task tag to reference the slot Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-02-22 13:24 ` [PATCH 31/31] pm8001: use block-layer tags for ccb allocation Hannes Reinecke
` (3 subsequent siblings)
33 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Switch to use reserved tags. With that all tags are maintained
by the block layer and we can drop the private tag allocation.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/mvsas/mv_init.c | 10 +---
drivers/scsi/mvsas/mv_sas.c | 98 ++++++++----------------------------
drivers/scsi/mvsas/mv_sas.h | 13 +++--
3 files changed, 27 insertions(+), 94 deletions(-)
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index 6aa2697c4a15..befcce55a705 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -142,7 +142,6 @@ static void mvs_free(struct mvs_info *mvi)
scsi_host_put(mvi->shost);
list_for_each_entry(mwq, &mvi->wq_list, entry)
cancel_delayed_work(&mwq->work_q);
- kfree(mvi->tags);
kfree(mvi);
}
@@ -284,10 +283,6 @@ static int mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
printk(KERN_DEBUG "failed to create dma pool %s.\n", pool_name);
goto err_out;
}
- mvi->tags_num = slot_nr;
-
- /* Initialize tags */
- mvs_tag_init(mvi);
return 0;
err_out:
return 1;
@@ -369,10 +364,6 @@ static struct mvs_info *mvs_pci_alloc(struct pci_dev *pdev,
mvi->sas = sha;
mvi->shost = shost;
- mvi->tags = kzalloc(MVS_CHIP_SLOT_SZ>>3, GFP_KERNEL);
- if (!mvi->tags)
- goto err_out;
-
if (MVS_CHIP_DISP->chip_ioremap(mvi))
goto err_out;
if (!mvs_alloc(mvi, shost))
@@ -471,6 +462,7 @@ static void mvs_post_sas_ha_init(struct Scsi_Host *shost,
else
can_queue = MVS_CHIP_SLOT_SZ;
+ shost->nr_reserved_cmds = 2;
shost->sg_tablesize = min_t(u16, SG_ALL, MVS_MAX_SG);
shost->can_queue = can_queue;
mvi->shost->cmd_per_lun = MVS_QUEUE_SIZE;
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index 99bdb88b3e86..a2b52a67bfa7 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -9,55 +9,6 @@
#include "mv_sas.h"
-static int mvs_find_tag(struct mvs_info *mvi, struct sas_task *task, u32 *tag)
-{
- if (task->lldd_task) {
- struct mvs_slot_info *slot;
- slot = task->lldd_task;
- *tag = slot->slot_tag;
- return 1;
- }
- return 0;
-}
-
-void mvs_tag_clear(struct mvs_info *mvi, u32 tag)
-{
- void *bitmap = mvi->tags;
- clear_bit(tag, bitmap);
-}
-
-void mvs_tag_free(struct mvs_info *mvi, u32 tag)
-{
- mvs_tag_clear(mvi, tag);
-}
-
-void mvs_tag_set(struct mvs_info *mvi, unsigned int tag)
-{
- void *bitmap = mvi->tags;
- set_bit(tag, bitmap);
-}
-
-inline int mvs_tag_alloc(struct mvs_info *mvi, u32 *tag_out)
-{
- unsigned int index, tag;
- void *bitmap = mvi->tags;
-
- index = find_first_zero_bit(bitmap, mvi->tags_num);
- tag = index;
- if (tag >= mvi->tags_num)
- return -SAS_QUEUE_FULL;
- mvs_tag_set(mvi, tag);
- *tag_out = tag;
- return 0;
-}
-
-void mvs_tag_init(struct mvs_info *mvi)
-{
- int i;
- for (i = 0; i < mvi->tags_num; ++i)
- mvs_tag_clear(mvi, i);
-}
-
static struct mvs_info *mvs_find_dev_mvi(struct domain_device *dev)
{
unsigned long i = 0, j = 0, hi = 0;
@@ -762,10 +713,13 @@ static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf
n_elem = task->num_scatter;
}
- rc = mvs_tag_alloc(mvi, &tag);
- if (rc)
+ if (task->tag == -1) {
+ dev_printk(KERN_ERR, mvi->dev,
+ "invalid sas_task tag\n");
+ rc = -EINVAL;
goto err_out;
-
+ }
+ tag = task->tag;
slot = &mvi->slot_info[tag];
task->lldd_task = NULL;
@@ -775,7 +729,7 @@ static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf
slot->buf = dma_pool_zalloc(mvi->dma_pool, GFP_ATOMIC, &slot->buf_dma);
if (!slot->buf) {
rc = -ENOMEM;
- goto err_out_tag;
+ goto err_out;
}
tei.task = task;
@@ -822,8 +776,6 @@ static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf
err_out_slot_buf:
dma_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
-err_out_tag:
- mvs_tag_free(mvi, tag);
err_out:
dev_printk(KERN_ERR, mvi->dev, "mvsas prep failed[%d]!\n", rc);
@@ -864,12 +816,6 @@ int mvs_queue_command(struct sas_task *task, gfp_t gfp_flags)
return mvs_task_exec(task, gfp_flags, NULL, 0, NULL);
}
-static void mvs_slot_free(struct mvs_info *mvi, u32 rx_desc)
-{
- u32 slot_idx = rx_desc & RXQ_SLOT_MASK;
- mvs_tag_clear(mvi, slot_idx);
-}
-
static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
struct mvs_slot_info *slot, u32 slot_idx)
{
@@ -907,7 +853,6 @@ static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
slot->task = NULL;
slot->port = NULL;
slot->slot_tag = 0xFFFFFFFF;
- mvs_slot_free(mvi, slot_idx);
}
static void mvs_update_wideport(struct mvs_info *mvi, int phy_no)
@@ -1416,7 +1361,6 @@ int mvs_I_T_nexus_reset(struct domain_device *dev)
/* optional SAM-3 */
int mvs_query_task(struct sas_task *task)
{
- u32 tag;
struct scsi_lun lun;
struct mvs_tmf_task tmf_task;
int rc = TMF_RESP_FUNC_FAILED;
@@ -1424,18 +1368,15 @@ int mvs_query_task(struct sas_task *task)
if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
struct scsi_cmnd * cmnd = (struct scsi_cmnd *)task->uldd_task;
struct domain_device *dev = task->dev;
- struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
- struct mvs_info *mvi = mvi_dev->mvi_info;
int_to_scsilun(cmnd->device->lun, &lun);
- rc = mvs_find_tag(mvi, task, &tag);
- if (rc == 0) {
+ if (task->tag == -1) {
rc = TMF_RESP_FUNC_FAILED;
return rc;
}
tmf_task.tmf = TMF_QUERY_TASK;
- tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
+ tmf_task.tag_of_task_to_be_managed = cpu_to_le16(task->tag);
rc = mvs_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
switch (rc) {
@@ -1461,7 +1402,6 @@ int mvs_abort_task(struct sas_task *task)
struct mvs_info *mvi;
int rc = TMF_RESP_FUNC_FAILED;
unsigned long flags;
- u32 tag;
if (!mvi_dev) {
mv_printk("Device has removed\n");
@@ -1482,15 +1422,14 @@ int mvs_abort_task(struct sas_task *task)
struct scsi_cmnd * cmnd = (struct scsi_cmnd *)task->uldd_task;
int_to_scsilun(cmnd->device->lun, &lun);
- rc = mvs_find_tag(mvi, task, &tag);
- if (rc == 0) {
+ if (task->tag == -1) {
mv_printk("No such tag in %s\n", __func__);
rc = TMF_RESP_FUNC_FAILED;
return rc;
}
tmf_task.tmf = TMF_ABORT_TASK;
- tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
+ tmf_task.tag_of_task_to_be_managed = cpu_to_le16(task->tag);
rc = mvs_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
@@ -1712,7 +1651,8 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
task->task_state_flags |= SAS_TASK_STATE_DONE;
/* race condition*/
- aborted = task->task_state_flags & SAS_TASK_STATE_ABORTED;
+ aborted = (task->task_state_flags & SAS_TASK_STATE_ABORTED) ||
+ (flags & MVS_SLOT_CMPL_SLOT_RESET);
spin_unlock(&task->task_state_lock);
memset(tstat, 0, sizeof(*tstat));
@@ -1730,7 +1670,7 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
}
/* when no device attaching, go ahead and complete by error handling*/
- if (unlikely(!mvi_dev || flags)) {
+ if (unlikely(!mvi_dev || (flags & MVS_SLOT_CMPL_PHY_GONE))) {
if (!mvi_dev)
mv_dprintk("port has not device.\n");
tstat->stat = SAS_PHY_DOWN;
@@ -1843,7 +1783,7 @@ void mvs_do_release_task(struct mvs_info *mvi,
slot_idx, slot->slot_tag, task);
MVS_CHIP_DISP->command_active(mvi, slot_idx);
- mvs_slot_complete(mvi, slot_idx, 1);
+ mvs_slot_complete(mvi, slot_idx, MVS_SLOT_CMPL_PHY_GONE);
}
}
@@ -2064,14 +2004,16 @@ int mvs_int_rx(struct mvs_info *mvi, bool self_clear)
rx_desc = le32_to_cpu(mvi->rx[rx_prod_idx + 1]);
if (likely(rx_desc & RXQ_DONE))
- mvs_slot_complete(mvi, rx_desc, 0);
+ mvs_slot_complete(mvi, rx_desc, MVS_SLOT_CMPL_NONE);
if (rx_desc & RXQ_ATTN) {
attn = true;
} else if (rx_desc & RXQ_ERR) {
if (!(rx_desc & RXQ_DONE))
- mvs_slot_complete(mvi, rx_desc, 0);
+ mvs_slot_complete(mvi, rx_desc,
+ MVS_SLOT_CMPL_NONE);
} else if (rx_desc & RXQ_SLOT_RESET) {
- mvs_slot_free(mvi, rx_desc);
+ mvs_slot_complete(mvi, rx_desc,
+ MVS_SLOT_CMPL_SLOT_RESET);
}
}
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index 327fdd5ee962..480a5129eff4 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -83,6 +83,12 @@ enum dev_reset {
MVS_PHY_TUNE = 2,
};
+enum mvs_slot_complete_flags {
+ MVS_SLOT_CMPL_NONE = 0,
+ MVS_SLOT_CMPL_PHY_GONE = 1,
+ MVS_SLOT_CMPL_SLOT_RESET = 2,
+};
+
struct mvs_info;
struct mvs_prv_info;
@@ -370,8 +376,6 @@ struct mvs_info {
u32 chip_id;
const struct mvs_chip_info *chip;
- int tags_num;
- unsigned long *tags;
/* further per-slot information */
struct mvs_phy phy[MVS_MAX_PHYS];
struct mvs_port port[MVS_MAX_PHYS];
@@ -424,11 +428,6 @@ struct mvs_task_exec_info {
/******************** function prototype *********************/
void mvs_get_sas_addr(void *buf, u32 buflen);
-void mvs_tag_clear(struct mvs_info *mvi, u32 tag);
-void mvs_tag_free(struct mvs_info *mvi, u32 tag);
-void mvs_tag_set(struct mvs_info *mvi, unsigned int tag);
-int mvs_tag_alloc(struct mvs_info *mvi, u32 *tag_out);
-void mvs_tag_init(struct mvs_info *mvi);
void mvs_iounmap(void __iomem *regs);
int mvs_ioremap(struct mvs_info *mvi, int bar, int bar_ex);
void mvs_phys_reset(struct mvs_info *mvi, u32 phy_mask, int hard);
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* [PATCH 31/31] pm8001: use block-layer tags for ccb allocation
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (29 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 30/31] mv_sas: use reserved tags and drop private tag allocation Hannes Reinecke
@ 2021-02-22 13:24 ` Hannes Reinecke
2021-02-23 12:31 ` John Garry
2021-02-23 10:16 ` [PATCHv7 00/31] scsi: enable reserved commands for LLDDs John Garry
` (2 subsequent siblings)
33 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-22 13:24 UTC (permalink / raw)
To: Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi,
Hannes Reinecke
Always allocate a command from the block layer whenever we need a
tag. With that we can drop the internal ccb bitmap and allow the
block layer control tag allocation.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/pm8001/pm8001_hwi.c | 131 +++++++++++++++---------------
drivers/scsi/pm8001/pm8001_init.c | 24 +++---
drivers/scsi/pm8001/pm8001_sas.c | 107 +++++++++---------------
drivers/scsi/pm8001/pm8001_sas.h | 14 ++--
drivers/scsi/pm8001/pm80xx_hwi.c | 119 +++++++++++++--------------
5 files changed, 183 insertions(+), 212 deletions(-)
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index 105962b0c815..4bb3debc7458 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -1554,13 +1554,14 @@ void pm8001_work_fn(struct work_struct *work)
t->task_state_flags |= SAS_TASK_STATE_DONE;
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags1);
- pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x "
+ "resp 0x%x stat 0x%x but aborted by upper layer!\n",
t, pw->handler, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags1);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
t->task_done(t);
@@ -1694,8 +1695,6 @@ int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha, void *data,
static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
struct pm8001_device *pm8001_ha_dev)
{
- int res;
- u32 ccb_tag;
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct task_abort_req task_abort;
@@ -1720,13 +1719,16 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
task->task_done = pm8001_task_done;
- res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
- if (res)
+ if (task->tag == -1) {
+ sas_free_task(task);
+ pm8001_dbg(pm8001_ha, FAIL,
+ "cannot allocate tag\n");
return;
+ }
- ccb = &pm8001_ha->ccb_info[ccb_tag];
+ ccb = &pm8001_ha->ccb_info[task->tag];
ccb->device = pm8001_ha_dev;
- ccb->ccb_tag = ccb_tag;
+ ccb->ccb_tag = task->tag;
ccb->task = task;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -1734,13 +1736,12 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
memset(&task_abort, 0, sizeof(task_abort));
task_abort.abort_all = cpu_to_le32(1);
task_abort.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
- task_abort.tag = cpu_to_le32(ccb_tag);
+ task_abort.tag = cpu_to_le32(task->tag);
ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort,
sizeof(task_abort), 0);
if (ret)
- pm8001_tag_free(pm8001_ha, ccb_tag);
-
+ sas_free_task(task);
}
static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
@@ -1748,7 +1749,6 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
{
struct sata_start_req sata_cmd;
int res;
- u32 ccb_tag;
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct host_to_dev_fis fis;
@@ -1766,8 +1766,7 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
}
task->task_done = pm8001_task_done;
- res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
- if (res) {
+ if (task->tag == -1) {
sas_free_task(task);
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate tag !!!\n");
return;
@@ -1776,9 +1775,9 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
task->dev = dev;
task->dev->lldd_dev = pm8001_ha_dev;
- ccb = &pm8001_ha->ccb_info[ccb_tag];
+ ccb = &pm8001_ha->ccb_info[task->tag];
ccb->device = pm8001_ha_dev;
- ccb->ccb_tag = ccb_tag;
+ ccb->ccb_tag = task->tag;
ccb->task = task;
pm8001_ha_dev->id |= NCQ_READ_LOG_FLAG;
pm8001_ha_dev->id |= NCQ_2ND_RLE_FLAG;
@@ -1794,17 +1793,15 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
fis.lbal = 0x10;
fis.sector_count = 0x1;
- sata_cmd.tag = cpu_to_le32(ccb_tag);
+ sata_cmd.tag = cpu_to_le32(task->tag);
sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
sata_cmd.ncqtag_atap_dir_m |= ((0x1 << 7) | (0x5 << 9));
memcpy(&sata_cmd.sata_fis, &fis, sizeof(struct host_to_dev_fis));
res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd,
sizeof(sata_cmd), 0);
- if (res) {
+ if (res)
sas_free_task(task);
- pm8001_tag_free(pm8001_ha, ccb_tag);
- }
}
/**
@@ -2039,12 +2036,13 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
t->task_state_flags |= SAS_TASK_STATE_DONE;
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x "
+ "resp 0x%x stat 0x%x but aborted by upper layer!\n",
t, status, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -2207,12 +2205,13 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
t->task_state_flags |= SAS_TASK_STATE_DONE;
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x "
+ "resp 0x%x stat 0x%x but aborted by upper layer!\n",
t, event, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -2336,8 +2335,6 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
/* clear bit for read log */
pm8001_dev->id = pm8001_dev->id & 0x7FFFFFFF;
pm8001_send_abort_all(pm8001_ha, pm8001_dev);
- /* Free the tag */
- pm8001_tag_free(pm8001_ha, tag);
sas_free_task(t);
return;
}
@@ -2450,7 +2447,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2466,7 +2463,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2488,7 +2485,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2559,7 +2556,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_DS_NON_OPERATIONAL);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2579,7 +2576,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_DS_IN_ERROR);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2608,12 +2605,13 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ "task 0x%p done with io_status 0x%x resp 0x%x "
+ "stat 0x%x but aborted by upper layer!\n",
t, status, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
}
}
@@ -2713,7 +2711,7 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_COMPLETE;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2806,12 +2804,13 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ "task 0x%p done with io_status 0x%x resp 0x%x "
+ "stat 0x%x but aborted by upper layer!\n",
t, event, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
}
}
@@ -2990,12 +2989,13 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
t->task_state_flags |= SAS_TASK_STATE_DONE;
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x "
+ "resp 0x%x stat 0x%x but aborted by upper layer!\n",
t, status, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -3659,11 +3659,10 @@ int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
t->task_state_flags |= SAS_TASK_STATE_DONE;
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();
if (pm8001_dev->id & NCQ_ABORT_ALL_FLAG) {
- pm8001_tag_free(pm8001_ha, tag);
sas_free_task(t);
/* clear the flag */
pm8001_dev->id &= 0xBFFFFFFF;
@@ -4301,15 +4300,15 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
spin_unlock_irqrestore(&task->task_state_lock,
flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p resp 0x%x stat 0x%x but aborted by upper layer\n",
+ "task 0x%p resp 0x%x stat 0x%x but "
+ "aborted by upper layer\n",
task, ts->resp,
ts->stat);
- pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, task, ccb);
} else {
spin_unlock_irqrestore(&task->task_state_lock,
flags);
- pm8001_ccb_task_free_done(pm8001_ha, task,
- ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, task, ccb);
return 0;
}
}
@@ -4398,9 +4397,9 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
circularQ = &pm8001_ha->inbnd_q_tbl[0];
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
- return rc;
+ tag = pm8001_tag_alloc(pm8001_ha, dev);
+ if (tag == -1)
+ return -SAS_QUEUE_FULL;
ccb = &pm8001_ha->ccb_info[tag];
ccb->device = pm8001_dev;
ccb->ccb_tag = tag;
@@ -4434,6 +4433,8 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
SAS_ADDR_SIZE);
rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
sizeof(payload), 0);
+ if (rc)
+ pm8001_tag_free(pm8001_ha, tag);
return rc;
}
@@ -4612,10 +4613,10 @@ int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
fw_control_context->len = ioctl_payload->rd_length;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
memset(&nvmd_req, 0, sizeof(nvmd_req));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc) {
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1) {
kfree(fw_control_context);
- return rc;
+ return -SAS_QUEUE_FULL;
}
ccb = &pm8001_ha->ccb_info[tag];
ccb->ccb_tag = tag;
@@ -4708,8 +4709,8 @@ int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
&ioctl_payload->func_specific,
ioctl_payload->wr_length);
memset(&nvmd_req, 0, sizeof(nvmd_req));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc) {
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1) {
kfree(fw_control_context);
return -EBUSY;
}
@@ -4836,8 +4837,8 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
fw_control_context->virtAddr = buffer;
fw_control_context->phys_addr = phys_addr;
fw_control_context->len = fw_control->len;
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc) {
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1) {
kfree(fw_control_context);
return -EBUSY;
}
@@ -4938,8 +4939,8 @@ pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
u32 tag;
u32 opc = OPC_INB_SET_DEVICE_STATE;
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, pm8001_dev->sas_device);
+ if (tag == -1)
return -1;
ccb = &pm8001_ha->ccb_info[tag];
ccb->ccb_tag = tag;
@@ -4950,6 +4951,8 @@ pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
payload.nds = cpu_to_le32(state);
rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
sizeof(payload), 0);
+ if (rc)
+ pm8001_tag_free(pm8001_ha, tag);
return rc;
}
@@ -4964,8 +4967,8 @@ pm8001_chip_sas_re_initialization(struct pm8001_hba_info *pm8001_ha)
u32 tag;
u32 opc = OPC_INB_SAS_RE_INITIALIZE;
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1)
return -ENOMEM;
ccb = &pm8001_ha->ccb_info[tag];
ccb->ccb_tag = tag;
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index bd626ef876da..93eb1dcf03bc 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -177,7 +177,6 @@ static void pm8001_free(struct pm8001_hba_info *pm8001_ha)
}
PM8001_CHIP_DISP->chip_iounmap(pm8001_ha);
flush_workqueue(pm8001_wq);
- kfree(pm8001_ha->tags);
kfree(pm8001_ha);
}
@@ -263,14 +262,13 @@ static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha);
* @ent: PCI device ID structure to match on
*/
static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
- const struct pci_device_id *ent)
+ const struct pci_device_id *ent)
{
int i, count = 0, rc = 0;
u32 ci_offset, ib_offset, ob_offset, pi_offset;
struct inbound_queue_table *circularQ;
spin_lock_init(&pm8001_ha->lock);
- spin_lock_init(&pm8001_ha->bitmap_lock);
pm8001_dbg(pm8001_ha, INIT, "pm8001_alloc: PHY:%x\n",
pm8001_ha->chip->n_phy);
@@ -414,8 +412,6 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
atomic_set(&pm8001_ha->devices[i].running_req, 0);
}
pm8001_ha->flags = PM8001F_INIT_TIME;
- /* Initialize tags */
- pm8001_tag_init(pm8001_ha);
return 0;
err_out_shost:
@@ -621,7 +617,7 @@ static int pm8001_prep_sas_ha_init(struct Scsi_Host *shost,
* @shost: scsi host which has been allocated outside
* @chip_info: our ha struct.
*/
-static void pm8001_post_sas_ha_init(struct Scsi_Host *shost,
+static bool pm8001_post_sas_ha_init(struct Scsi_Host *shost,
const struct pm8001_chip_info *chip_info)
{
int i = 0;
@@ -642,6 +638,12 @@ static void pm8001_post_sas_ha_init(struct Scsi_Host *shost,
sha->sas_addr = &pm8001_ha->sas_addr[0];
sha->num_phys = chip_info->n_phy;
sha->core.shost = shost;
+
+ pm8001_ha->host_dev = scsi_get_host_dev(pm8001_ha->shost);
+ if (!pm8001_ha->host_dev)
+ return false;
+
+ return true;
}
/**
@@ -1136,7 +1138,11 @@ static int pm8001_pci_probe(struct pci_dev *pdev,
if (rc)
goto err_out_shost;
- pm8001_post_sas_ha_init(shost, chip);
+ if (!pm8001_post_sas_ha_init(shost, chip)) {
+ pm8001_dbg(pm8001_ha, FAIL,
+ "pm8001_post_sas_ha_init failed\n");
+ goto err_out_shost;
+ }
rc = sas_register_ha(SHOST_TO_SAS_HA(shost));
if (rc) {
pm8001_dbg(pm8001_ha, FAIL,
@@ -1184,10 +1190,6 @@ pm8001_init_ccb_tag(struct pm8001_hba_info *pm8001_ha, struct Scsi_Host *shost,
can_queue = ccb_count - PM8001_RESERVE_SLOT;
shost->can_queue = can_queue;
- pm8001_ha->tags = kzalloc(ccb_count, GFP_KERNEL);
- if (!pm8001_ha->tags)
- goto err_out;
-
/* Memory region for ccb_info*/
pm8001_ha->ccb_info =
kcalloc(ccb_count, sizeof(struct pm8001_ccb_info), GFP_KERNEL);
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index b1f12d671611..ae15e690a856 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -41,22 +41,6 @@
#include <linux/slab.h>
#include "pm8001_sas.h"
-/**
- * pm8001_find_tag - from sas task to find out tag that belongs to this task
- * @task: the task sent to the LLDD
- * @tag: the found tag associated with the task
- */
-static int pm8001_find_tag(struct sas_task *task, u32 *tag)
-{
- if (task->lldd_task) {
- struct pm8001_ccb_info *ccb;
- ccb = task->lldd_task;
- *tag = ccb->ccb_tag;
- return 1;
- }
- return 0;
-}
-
/**
* pm8001_tag_free - free the no more needed tag
* @pm8001_ha: our hba struct
@@ -64,38 +48,33 @@ static int pm8001_find_tag(struct sas_task *task, u32 *tag)
*/
void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag)
{
- void *bitmap = pm8001_ha->tags;
- clear_bit(tag, bitmap);
+ struct scsi_cmnd *scmd = scsi_host_find_tag(pm8001_ha->shost, tag);
+ struct sas_task *task;
+
+ if (WARN_ON(!scmd))
+ return;
+ task = (void *)scmd->host_scribble;
+ sas_free_task(task);
}
/**
* pm8001_tag_alloc - allocate a empty tag for task used.
* @pm8001_ha: our hba struct
- * @tag_out: the found empty tag .
+ * @dev: device from which the tag should be allocated or NULL
*/
-inline int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha, u32 *tag_out)
+inline u32 pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha,
+ struct domain_device *dev)
{
- unsigned int tag;
- void *bitmap = pm8001_ha->tags;
- unsigned long flags;
+ struct sas_task *task;
+ struct scsi_lun lun;
- spin_lock_irqsave(&pm8001_ha->bitmap_lock, flags);
- tag = find_first_zero_bit(bitmap, pm8001_ha->tags_num);
- if (tag >= pm8001_ha->tags_num) {
- spin_unlock_irqrestore(&pm8001_ha->bitmap_lock, flags);
- return -SAS_QUEUE_FULL;
- }
- set_bit(tag, bitmap);
- spin_unlock_irqrestore(&pm8001_ha->bitmap_lock, flags);
- *tag_out = tag;
- return 0;
-}
+ int_to_scsilun(0, &lun);
+ task = sas_alloc_slow_task(pm8001_ha->sas, dev,
+ &lun, GFP_KERNEL);
+ if (!task)
+ return -1;
-void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha)
-{
- int i;
- for (i = 0; i < pm8001_ha->tags_num; ++i)
- pm8001_tag_free(pm8001_ha, i);
+ return task->tag;
}
/**
@@ -381,7 +360,7 @@ static int pm8001_task_exec(struct sas_task *task,
struct pm8001_port *port = NULL;
struct sas_task *t = task;
struct pm8001_ccb_info *ccb;
- u32 tag = 0xdeadbeef, rc = 0, n_elem = 0;
+ u32 rc = 0, n_elem = 0;
unsigned long flags = 0;
enum sas_protocol task_proto = t->task_proto;
@@ -425,10 +404,13 @@ static int pm8001_task_exec(struct sas_task *task,
continue;
}
}
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ if (task->tag == -1) {
+ dev_printk(KERN_ERR, pm8001_ha->dev,
+ "invalid sas_task tag\n");
+ rc = -EINVAL;
goto err_out;
- ccb = &pm8001_ha->ccb_info[tag];
+ }
+ ccb = &pm8001_ha->ccb_info[task->tag];
if (!sas_protocol_ata(task_proto)) {
if (t->num_scatter) {
@@ -438,7 +420,7 @@ static int pm8001_task_exec(struct sas_task *task,
t->data_dir);
if (!n_elem) {
rc = -ENOMEM;
- goto err_out_tag;
+ goto err_out;
}
}
} else {
@@ -447,7 +429,7 @@ static int pm8001_task_exec(struct sas_task *task,
t->lldd_task = ccb;
ccb->n_elem = n_elem;
- ccb->ccb_tag = tag;
+ ccb->ccb_tag = task->tag;
ccb->task = t;
ccb->device = pm8001_dev;
switch (task_proto) {
@@ -477,8 +459,7 @@ static int pm8001_task_exec(struct sas_task *task,
if (rc) {
pm8001_dbg(pm8001_ha, IO, "rc is %x\n", rc);
- atomic_dec(&pm8001_dev->running_req);
- goto err_out_tag;
+ goto err_out;
}
/* TODO: select normal or high priority */
spin_lock(&t->task_state_lock);
@@ -488,8 +469,6 @@ static int pm8001_task_exec(struct sas_task *task,
rc = 0;
goto out_done;
-err_out_tag:
- pm8001_tag_free(pm8001_ha, tag);
err_out:
dev_printk(KERN_ERR, pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc);
if (!sas_protocol_ata(task_proto))
@@ -517,10 +496,9 @@ int pm8001_queue_command(struct sas_task *task, gfp_t gfp_flags)
* @pm8001_ha: our hba card information
* @ccb: the ccb which attached to ssp task
* @task: the task to be free.
- * @ccb_idx: ccb index.
*/
void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
- struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx)
+ struct sas_task *task, struct pm8001_ccb_info *ccb)
{
if (!ccb->task)
return;
@@ -548,7 +526,6 @@ void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
ccb->task = NULL;
ccb->ccb_tag = 0xFFFFFFFF;
ccb->open_retry = 0;
- pm8001_tag_free(pm8001_ha, ccb_idx);
}
/**
@@ -798,7 +775,6 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
{
struct domain_device *dev = pm8001_dev->sas_device;
int res, retry;
- u32 ccb_tag;
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
@@ -815,17 +791,17 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
task->slow_task->timer.expires = jiffies + PM8001_TASK_TIMEOUT * HZ;
add_timer(&task->slow_task->timer);
- res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
- if (res)
- goto ex_err;
- ccb = &pm8001_ha->ccb_info[ccb_tag];
+ if (task->tag == -1)
+ return -SAS_QUEUE_FULL;
+
+ ccb = &pm8001_ha->ccb_info[task->tag];
ccb->device = pm8001_dev;
- ccb->ccb_tag = ccb_tag;
+ ccb->ccb_tag = task->tag;
ccb->task = task;
ccb->n_elem = 0;
res = PM8001_CHIP_DISP->task_abort(pm8001_ha,
- pm8001_dev, flag, task_tag, ccb_tag);
+ pm8001_dev, flag, task_tag, task->tag);
if (res) {
del_timer(&task->slow_task->timer);
@@ -961,11 +937,11 @@ void pm8001_open_reject_retry(
& SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&task->task_state_lock,
flags1);
- pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, task, ccb);
} else {
spin_unlock_irqrestore(&task->task_state_lock,
flags1);
- pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, task, ccb);
mb();/* in order to force CPU ordering */
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
task->task_done(task);
@@ -1126,7 +1102,6 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
/* optional SAM-3 */
int pm8001_query_task(struct sas_task *task)
{
- u32 tag = 0xdeadbeef;
struct scsi_lun lun;
struct pm8001_tmf_task tmf_task;
int rc = TMF_RESP_FUNC_FAILED;
@@ -1140,14 +1115,13 @@ int pm8001_query_task(struct sas_task *task)
pm8001_find_ha_by_dev(dev);
int_to_scsilun(cmnd->device->lun, &lun);
- rc = pm8001_find_tag(task, &tag);
- if (rc == 0) {
+ if (task->tag == -1) {
rc = TMF_RESP_FUNC_FAILED;
return rc;
}
pm8001_dbg(pm8001_ha, EH, "Query:[%16ph]\n", cmnd->cmnd);
tmf_task.tmf = TMF_QUERY_TASK;
- tmf_task.tag_of_task_to_be_managed = tag;
+ tmf_task.tag_of_task_to_be_managed = task->tag;
rc = pm8001_exec_internal_tmf_task(dev, lun.scsi_lun, &tmf_task);
switch (rc) {
@@ -1196,8 +1170,7 @@ int pm8001_abort_task(struct sas_task *task)
return TMF_RESP_FUNC_FAILED;
}
- ret = pm8001_find_tag(task, &tag);
- if (ret == 0) {
+ if (task->tag < 0) {
pm8001_info(pm8001_ha, "no tag for task:%p\n", task);
return TMF_RESP_FUNC_FAILED;
}
diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
index 039ed91e9841..d7ec43fd61bb 100644
--- a/drivers/scsi/pm8001/pm8001_sas.h
+++ b/drivers/scsi/pm8001/pm8001_sas.h
@@ -472,7 +472,6 @@ struct pm8001_hba_info {
struct list_head list;
unsigned long flags;
spinlock_t lock;/* host-wide lock */
- spinlock_t bitmap_lock;
struct pci_dev *pdev;/* our device */
struct device *dev;
struct pm8001_hba_memspace io_mem[6];
@@ -504,11 +503,11 @@ struct pm8001_hba_info {
u8 sas_addr[SAS_ADDR_SIZE];
struct sas_ha_struct *sas;/* SCSI/SAS glue */
struct Scsi_Host *shost;
+ struct scsi_device *host_dev;
u32 chip_id;
const struct pm8001_chip_info *chip;
struct completion *nvmd_completion;
int tags_num;
- unsigned long *tags;
struct pm8001_phy phy[PM8001_MAX_PHYS];
struct pm8001_port port[PM8001_MAX_PHYS];
u32 id;
@@ -631,11 +630,11 @@ struct fw_control_ex {
extern struct workqueue_struct *pm8001_wq;
/******************** function prototype *********************/
-int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha, u32 *tag_out);
-void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha);
+u32 pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha,
+ struct domain_device *dev);
u32 pm8001_get_ncq_tag(struct sas_task *task, u32 *tag);
void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
- struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx);
+ struct sas_task *task, struct pm8001_ccb_info *ccb);
int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
void *funcdata);
void pm8001_scan_start(struct Scsi_Host *shost);
@@ -732,10 +731,9 @@ extern struct device_attribute *pm8001_host_attrs[];
static inline void
pm8001_ccb_task_free_done(struct pm8001_hba_info *pm8001_ha,
- struct sas_task *task, struct pm8001_ccb_info *ccb,
- u32 ccb_idx)
+ struct sas_task *task, struct pm8001_ccb_info *ccb)
{
- pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb_idx);
+ pm8001_ccb_task_free(pm8001_ha, task, ccb);
smp_mb(); /*in order to force CPU ordering*/
spin_unlock(&pm8001_ha->lock);
task->task_done(task);
diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
index 03bfb4d72895..a024ed79721f 100644
--- a/drivers/scsi/pm8001/pm80xx_hwi.c
+++ b/drivers/scsi/pm8001/pm80xx_hwi.c
@@ -1188,8 +1188,8 @@ pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha)
u32 page_code;
memset(&payload, 0, sizeof(struct set_ctrl_cfg_req));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1)
return -1;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -1234,9 +1234,9 @@ pm80xx_set_sas_protocol_timer_config(struct pm8001_hba_info *pm8001_ha)
memset(&payload, 0, sizeof(struct set_ctrl_cfg_req));
memset(&SASConfigPage, 0, sizeof(SASProtocolTimerConfig_t));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
- if (rc)
+ if (tag == -1)
return -1;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -1395,8 +1395,8 @@ static int pm80xx_encrypt_update(struct pm8001_hba_info *pm8001_ha)
u32 opc = OPC_INB_KEK_MANAGEMENT;
memset(&payload, 0, sizeof(struct kek_mgmt_req));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1)
return -1;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -1765,8 +1765,6 @@ pm80xx_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha, u8 vec)
static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
struct pm8001_device *pm8001_ha_dev)
{
- int res;
- u32 ccb_tag;
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct task_abort_req task_abort;
@@ -1791,15 +1789,15 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
task->task_done = pm8001_task_done;
- res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
- if (res) {
+ if (task->tag == -1) {
sas_free_task(task);
+ pm8001_dbg(pm8001_ha, FAIL, "invalid task tag\n");
return;
}
- ccb = &pm8001_ha->ccb_info[ccb_tag];
+ ccb = &pm8001_ha->ccb_info[task->tag];
ccb->device = pm8001_ha_dev;
- ccb->ccb_tag = ccb_tag;
+ ccb->ccb_tag = task->tag;
ccb->task = task;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -1807,15 +1805,13 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
memset(&task_abort, 0, sizeof(task_abort));
task_abort.abort_all = cpu_to_le32(1);
task_abort.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
- task_abort.tag = cpu_to_le32(ccb_tag);
+ task_abort.tag = cpu_to_le32(task->tag);
ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort,
sizeof(task_abort), 0);
pm8001_dbg(pm8001_ha, FAIL, "Executing abort task end\n");
- if (ret) {
+ if (ret)
sas_free_task(task);
- pm8001_tag_free(pm8001_ha, ccb_tag);
- }
}
static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
@@ -1823,7 +1819,6 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
{
struct sata_start_req sata_cmd;
int res;
- u32 ccb_tag;
struct pm8001_ccb_info *ccb;
struct sas_task *task = NULL;
struct host_to_dev_fis fis;
@@ -1841,19 +1836,17 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
}
task->task_done = pm8001_task_done;
- res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
- if (res) {
+ if (task->tag == -1) {
sas_free_task(task);
pm8001_dbg(pm8001_ha, FAIL, "cannot allocate tag !!!\n");
return;
}
-
task->dev = dev;
task->dev->lldd_dev = pm8001_ha_dev;
- ccb = &pm8001_ha->ccb_info[ccb_tag];
+ ccb = &pm8001_ha->ccb_info[task->tag];
ccb->device = pm8001_ha_dev;
- ccb->ccb_tag = ccb_tag;
+ ccb->ccb_tag = task->tag;
ccb->task = task;
ccb->n_elem = 0;
pm8001_ha_dev->id |= NCQ_READ_LOG_FLAG;
@@ -1870,7 +1863,7 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
fis.lbal = 0x10;
fis.sector_count = 0x1;
- sata_cmd.tag = cpu_to_le32(ccb_tag);
+ sata_cmd.tag = cpu_to_le32(task->tag);
sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
sata_cmd.ncqtag_atap_dir_m_dad |= ((0x1 << 7) | (0x5 << 9));
memcpy(&sata_cmd.sata_fis, &fis, sizeof(struct host_to_dev_fis));
@@ -1878,10 +1871,8 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd,
sizeof(sata_cmd), 0);
pm8001_dbg(pm8001_ha, FAIL, "Executing read log end\n");
- if (res) {
+ if (res)
sas_free_task(task);
- pm8001_tag_free(pm8001_ha, ccb_tag);
- }
}
/**
@@ -2176,10 +2167,10 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
t, status, ts->resp, ts->stat);
if (t->slow_task)
complete(&t->slow_task->completion);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -2356,12 +2347,13 @@ static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ "task 0x%p done with event 0x%x resp 0x%x "
+ "stat 0x%x but aborted by upper layer!\n",
t, event, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -2606,7 +2598,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2622,7 +2614,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2646,7 +2638,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2717,7 +2709,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_DS_NON_OPERATIONAL);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2737,7 +2729,7 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
IO_DS_IN_ERROR);
ts->resp = SAS_TASK_UNDELIVERED;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2772,10 +2764,10 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
t, status, ts->resp, ts->stat);
if (t->slow_task)
complete(&t->slow_task->completion);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
}
}
@@ -2880,7 +2872,7 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
ts->resp = SAS_TASK_COMPLETE;
ts->stat = SAS_QUEUE_FULL;
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
return;
}
break;
@@ -2987,12 +2979,13 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n",
+ "task 0x%p done with io_status 0x%x resp 0x%x "
+ "stat 0x%x but aborted by upper layer!\n",
t, event, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free_done(pm8001_ha, t, ccb);
}
}
@@ -3195,12 +3188,13 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
spin_unlock_irqrestore(&t->task_state_lock, flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p done with io_status 0x%x resp 0x%xstat 0x%x but aborted by upper layer!\n",
+ "task 0x%p done with io_status 0x%x resp 0x%x "
+ "stat 0x%x but aborted by upper layer!\n",
t, status, ts->resp, ts->stat);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
} else {
spin_unlock_irqrestore(&t->task_state_lock, flags);
- pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, t, ccb);
mb();/* in order to force CPU ordering */
t->task_done(t);
}
@@ -4697,17 +4691,16 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
spin_unlock_irqrestore(&task->task_state_lock,
flags);
pm8001_dbg(pm8001_ha, FAIL,
- "task 0x%p resp 0x%x stat 0x%x but aborted by upper layer\n",
+ "task 0x%p resp 0x%x stat 0x%x "
+ "but aborted by upper layer\n",
task, ts->resp,
ts->stat);
- pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+ pm8001_ccb_task_free(pm8001_ha, task, ccb);
return 0;
} else {
spin_unlock_irqrestore(&task->task_state_lock,
flags);
- pm8001_ccb_task_free_done(pm8001_ha, task,
- ccb, tag);
- atomic_dec(&pm8001_ha_dev->running_req);
+ pm8001_ccb_task_free_done(pm8001_ha, task, ccb);
return 0;
}
}
@@ -4800,9 +4793,9 @@ static int pm80xx_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
circularQ = &pm8001_ha->inbnd_q_tbl[0];
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
- return rc;
+ tag = pm8001_tag_alloc(pm8001_ha, dev);
+ if (tag == -1)
+ return -1;
ccb = &pm8001_ha->ccb_info[tag];
ccb->device = pm8001_dev;
ccb->ccb_tag = tag;
@@ -4859,14 +4852,13 @@ static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
u32 phyId, u32 phy_op)
{
u32 tag;
- int rc;
struct local_phy_ctl_req payload;
struct inbound_queue_table *circularQ;
u32 opc = OPC_INB_LOCAL_PHY_CONTROL;
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
- return rc;
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1)
+ return -1;
circularQ = &pm8001_ha->inbnd_q_tbl[0];
payload.tag = cpu_to_le32(tag);
payload.phyop_phyid =
@@ -4917,9 +4909,11 @@ static void mpi_set_phy_profile_req(struct pm8001_hba_info *pm8001_ha,
u32 opc = OPC_INB_SET_PHY_PROFILE;
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1) {
pm8001_dbg(pm8001_ha, FAIL, "Invalid tag\n");
+ return;
+ }
circularQ = &pm8001_ha->inbnd_q_tbl[0];
payload.tag = cpu_to_le32(tag);
payload.ppc_phyid = (((operation & 0xF) << 8) | (phyid & 0xFF));
@@ -4959,10 +4953,11 @@ void pm8001_set_phy_profile_single(struct pm8001_hba_info *pm8001_ha,
memset(&payload, 0, sizeof(payload));
- rc = pm8001_tag_alloc(pm8001_ha, &tag);
- if (rc)
+ tag = pm8001_tag_alloc(pm8001_ha, NULL);
+ if (tag == -1) {
pm8001_dbg(pm8001_ha, INIT, "Invalid tag\n");
-
+ return;
+ }
circularQ = &pm8001_ha->inbnd_q_tbl[0];
opc = OPC_INB_SET_PHY_PROFILE;
--
2.29.2
^ permalink raw reply related [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (30 preceding siblings ...)
2021-02-22 13:24 ` [PATCH 31/31] pm8001: use block-layer tags for ccb allocation Hannes Reinecke
@ 2021-02-23 10:16 ` John Garry
2021-02-23 17:50 ` John Garry
2021-03-06 15:11 ` Don.Brace
2021-03-11 23:53 ` michael.christie
33 siblings, 1 reply; 54+ messages in thread
From: John Garry @ 2021-02-23 10:16 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Viswas.G
On 22/02/2021 13:23, Hannes Reinecke wrote:
> Hi all,
+
>
> quite some drivers use internal commands for various purposes, most
> commonly sending TMFs or querying the HBA status.
> While these commands use the same submission mechanism than normal
> I/O commands, they will not be counted as outstanding commands,
> requiring those drivers to implement their own mechanism to figure
> out outstanding commands.
> The block layer already has the concept of 'reserved' tags for
> precisely this purpose, namely non-I/O tags which live off a separate
> tag pool. That guarantees that these commands can always be sent,
> and won't be influenced by tag starvation from the I/O tag pool.
> This patchset enables the use of reserved tags for the SCSI midlayer
> by allocating a virtual LUN for the HBA itself which just serves
> as a resource to allocate valid tags from.
> This removes quite some hacks which were required for some
> drivers (eg. fnic or snic), and allows the use of tagset
> iterators within the drivers.
>
> The entire patchset can be found at
>
> git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
> reserved-tags.v7
Thanks for doing this, I'll have a look.
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 31/31] pm8001: use block-layer tags for ccb allocation
2021-02-22 13:24 ` [PATCH 31/31] pm8001: use block-layer tags for ccb allocation Hannes Reinecke
@ 2021-02-23 12:31 ` John Garry
0 siblings, 0 replies; 54+ messages in thread
From: John Garry @ 2021-02-23 12:31 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Viswas.G, Jinpu Wang
On 22/02/2021 13:24, Hannes Reinecke wrote:
> @ -4398,9 +4397,9 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
> circularQ = &pm8001_ha->inbnd_q_tbl[0];
>
> memset(&payload, 0, sizeof(payload));
> - rc = pm8001_tag_alloc(pm8001_ha, &tag);
> - if (rc)
> - return rc;
> + tag = pm8001_tag_alloc(pm8001_ha, dev);
> + if (tag == -1)
> + return -SAS_QUEUE_FULL;
> ccb = &pm8001_ha->ccb_info[tag];
> ccb->device = pm8001_dev;
> ccb->ccb_tag = tag;
> @@ -4434,6 +4433,8 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
> SAS_ADDR_SIZE);
> rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload,
> sizeof(payload), 0);
So this above code means that we send on queue #0 always.
However, since we hope to use managed interrupt in the future, the
interrupt for queue may be offline.
That's why I don't like storing a tag in sas_task structure. We already
can get it elsewhere in the structure.
I would rather get it from sas_task.slow_task in this case, which saves
the request/scsi_cmd pointer, and we can use blk_mq_unique_tag_to_hwq()
here to get the tag and queue index.
Thanks,
John
> + if (rc)
> + pm8001_tag_free(pm8001_ha, tag);
> return rc;
> }
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-23 10:16 ` [PATCHv7 00/31] scsi: enable reserved commands for LLDDs John Garry
@ 2021-02-23 17:50 ` John Garry
2021-02-24 6:54 ` Hannes Reinecke
0 siblings, 1 reply; 54+ messages in thread
From: John Garry @ 2021-02-23 17:50 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Viswas.G
On 23/02/2021 10:16, John Garry wrote:
> On 22/02/2021 13:23, Hannes Reinecke wrote:
>> Hi all,
>
> +
>
>>
>> quite some drivers use internal commands for various purposes, most
>> commonly sending TMFs or querying the HBA status.
>> While these commands use the same submission mechanism than normal
>> I/O commands, they will not be counted as outstanding commands,
>> requiring those drivers to implement their own mechanism to figure
>> out outstanding commands.
>> The block layer already has the concept of 'reserved' tags for
>> precisely this purpose, namely non-I/O tags which live off a separate
>> tag pool. That guarantees that these commands can always be sent,
>> and won't be influenced by tag starvation from the I/O tag pool.
>> This patchset enables the use of reserved tags for the SCSI midlayer
>> by allocating a virtual LUN for the HBA itself which just serves
>> as a resource to allocate valid tags from.
>> This removes quite some hacks which were required for some
>> drivers (eg. fnic or snic), and allows the use of tagset
>> iterators within the drivers.
>>
>> The entire patchset can be found at
>>
>> git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
>> reserved-tags.v7
>
>
> Thanks for doing this, I'll have a look.
So I got this working eventually for hisi_sas - a few fixes needed:
https://github.com/hisilicon/kernel-dev/commits/private-topic-sas-5.11-resv7
I'll have a look at the core patches tomorrow. However, at this point,
how about convert just a couple of drivers (the ones which you can test)
to get it merged as a start? 31 patches is too many.
thanks,
John
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-23 17:50 ` John Garry
@ 2021-02-24 6:54 ` Hannes Reinecke
2021-02-24 8:55 ` John Garry
0 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-24 6:54 UTC (permalink / raw)
To: John Garry, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Viswas.G
On 2/23/21 6:50 PM, John Garry wrote:
> On 23/02/2021 10:16, John Garry wrote:
>> On 22/02/2021 13:23, Hannes Reinecke wrote:
>>> Hi all,
>>
>> +
>>
>>>
>>> quite some drivers use internal commands for various purposes, most
>>> commonly sending TMFs or querying the HBA status.
>>> While these commands use the same submission mechanism than normal
>>> I/O commands, they will not be counted as outstanding commands,
>>> requiring those drivers to implement their own mechanism to figure
>>> out outstanding commands.
>>> The block layer already has the concept of 'reserved' tags for
>>> precisely this purpose, namely non-I/O tags which live off a separate
>>> tag pool. That guarantees that these commands can always be sent,
>>> and won't be influenced by tag starvation from the I/O tag pool.
>>> This patchset enables the use of reserved tags for the SCSI midlayer
>>> by allocating a virtual LUN for the HBA itself which just serves
>>> as a resource to allocate valid tags from.
>>> This removes quite some hacks which were required for some
>>> drivers (eg. fnic or snic), and allows the use of tagset
>>> iterators within the drivers.
>>>
>>> The entire patchset can be found at
>>>
>>> git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
>>> reserved-tags.v7
>>
>>
>> Thanks for doing this, I'll have a look.
>
> So I got this working eventually for hisi_sas - a few fixes needed:
> https://github.com/hisilicon/kernel-dev/commits/private-topic-sas-5.11-resv7
>
>
> I'll have a look at the core patches tomorrow. However, at this point,
> how about convert just a couple of drivers (the ones which you can test)
> to get it merged as a start? 31 patches is too many.
>
Yeah, I know. Actually, I just sent it out so that you can have a look
at my libsas slow task rework.
But I can easily split it off for just fnic/snic/aacraid/hpsa, and leave
the libsas slow task stuff for the next round.
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
hare@suse.de +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-24 6:54 ` Hannes Reinecke
@ 2021-02-24 8:55 ` John Garry
0 siblings, 0 replies; 54+ messages in thread
From: John Garry @ 2021-02-24 8:55 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Viswas.G
On 24/02/2021 06:54, Hannes Reinecke wrote:
>>
>> So I got this working eventually for hisi_sas - a few fixes needed:
>> https://github.com/hisilicon/kernel-dev/commits/private-topic-sas-5.11-resv7
>>
>>
>> I'll have a look at the core patches tomorrow. However, at this point,
>> how about convert just a couple of drivers (the ones which you can
>> test) to get it merged as a start? 31 patches is too many.
>>
> Yeah, I know. Actually, I just sent it out so that you can have a look
> at my libsas slow task rework.
>
Fine, but obviously that libsas and users stuff needs more work.
> But I can easily split it off for just fnic/snic/aacraid/hpsa, and leave
> the libsas slow task stuff for the next round.
I think that's better. But even then, it's still a large patchset. Maybe
1 or 2 drivers is enough to start with... and whatever you can test, as
I don't have HW to test those.
Thanks,
John
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper
2021-02-22 13:23 ` [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper Hannes Reinecke
@ 2021-02-24 12:12 ` John Garry
0 siblings, 0 replies; 54+ messages in thread
From: John Garry @ 2021-02-24 12:12 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 22/02/2021 13:23, Hannes Reinecke wrote:
> Add helper functions to allow LLDDs to allocate and free
> internal commands.
>
> Signed-off-by: Hannes Reinecke <hare@suse.de>
same comments as v6 apply :)
As does RB tag
> ---
> drivers/scsi/scsi_lib.c | 45 ++++++++++++++++++++++++++++++++++++++
> include/scsi/scsi_device.h | 4 ++++
> 2 files changed, 49 insertions(+)
>
> diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
> index d0ae586565f8..5cb464972682 100644
> --- a/drivers/scsi/scsi_lib.c
> +++ b/drivers/scsi/scsi_lib.c
> @@ -1934,6 +1934,51 @@ void scsi_mq_destroy_tags(struct Scsi_Host *shost)
> blk_mq_free_tag_set(&shost->tag_set);
> }
>
> +/**
> + * scsi_get_internal_cmd - allocate an internal SCSI command
> + * @sdev: SCSI device from which to allocate the command
> + * @data_direction: Data direction for the allocated command
> + * @op_flags: request allocation flags
> + *
> + * Allocates a SCSI command for internal LLDD use.
> + */
> +struct scsi_cmnd *scsi_get_internal_cmd(struct scsi_device *sdev,
> + enum dma_data_direction data_direction, int op_flags)
> +{
> + struct request *rq;
> + struct scsi_cmnd *scmd;
> + blk_mq_req_flags_t flags = 0;
> + unsigned int op = REQ_INTERNAL | op_flags;
> +
> + op |= (data_direction == DMA_TO_DEVICE) ?
> + REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN;
> + rq = blk_mq_alloc_request(sdev->request_queue, op, flags);
> + if (IS_ERR(rq))
> + return NULL;
> + scmd = blk_mq_rq_to_pdu(rq);
> + scmd->request = rq;
> + scmd->device = sdev;
> + return scmd;
> +}
> +EXPORT_SYMBOL_GPL(scsi_get_internal_cmd);
> +
> +/**
> + * scsi_put_internal_cmd - free an internal SCSI command
> + * @scmd: SCSI command to be freed
> + *
> + * Check if @scmd is an internal command, and call
> + * blk_mq_free_request() if true.
> + */
> +void scsi_put_internal_cmd(struct scsi_cmnd *scmd)
> +{
> + struct request *rq = blk_mq_rq_from_pdu(scmd);
> +
> + if (WARN_ON(!blk_rq_is_internal(rq)))
> + return;
Still not sure if we need this.... best cc jens on series in future for
view on complete changes
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 08/31] scsi: revamp host device handling
2021-02-22 13:23 ` [PATCH 08/31] scsi: revamp host device handling Hannes Reinecke
@ 2021-02-24 13:12 ` John Garry
2021-02-24 14:24 ` Hannes Reinecke
0 siblings, 1 reply; 54+ messages in thread
From: John Garry @ 2021-02-24 13:12 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 22/02/2021 13:23, Hannes Reinecke wrote:
> void scsi_forget_host(struct Scsi_Host *shost)
> {
> - struct scsi_device *sdev;
> + struct scsi_device *sdev, *host_sdev = NULL;
> unsigned long flags;
>
> restart:
> spin_lock_irqsave(shost->host_lock, flags);
> list_for_each_entry(sdev, &shost->__devices, siblings) {
> + if (scsi_device_is_host_dev(sdev)) {
> + host_sdev = sdev;
Is there actually a limit of 1x host_sdev always?
> + continue;
> + }
> if (sdev->sdev_state == SDEV_DEL)
> continue;
> spin_unlock_irqrestore(shost->host_lock, flags);
> @@ -1889,10 +1905,13 @@ void scsi_forget_host(struct Scsi_Host *shost)
> goto restart;
> }
> spin_unlock_irqrestore(shost->host_lock, flags);
> + /* Remove host device last, might be needed to send commands */
> + if (host_sdev)
> + __scsi_remove_device(host_sdev);
> }
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 08/31] scsi: revamp host device handling
2021-02-24 13:12 ` John Garry
@ 2021-02-24 14:24 ` Hannes Reinecke
2021-02-24 14:31 ` John Garry
0 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-24 14:24 UTC (permalink / raw)
To: John Garry, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 2/24/21 2:12 PM, John Garry wrote:
> On 22/02/2021 13:23, Hannes Reinecke wrote:
>> void scsi_forget_host(struct Scsi_Host *shost)
>> {
>> - struct scsi_device *sdev;
>> + struct scsi_device *sdev, *host_sdev = NULL;
>> unsigned long flags;
>> restart:
>> spin_lock_irqsave(shost->host_lock, flags);
>> list_for_each_entry(sdev, &shost->__devices, siblings) {
>> + if (scsi_device_is_host_dev(sdev)) {
>> + host_sdev = sdev;
>
> Is there actually a limit of 1x host_sdev always?
>
I would have thought so, as the whole point of having a host device is
that you have a (virtual) device which simulates access to the host itself.
And as such has a 1:1 relationship to the HBA.
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
hare@suse.de +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 08/31] scsi: revamp host device handling
2021-02-24 14:24 ` Hannes Reinecke
@ 2021-02-24 14:31 ` John Garry
2021-02-24 14:35 ` Hannes Reinecke
0 siblings, 1 reply; 54+ messages in thread
From: John Garry @ 2021-02-24 14:31 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 24/02/2021 14:24, Hannes Reinecke wrote:
> On 2/24/21 2:12 PM, John Garry wrote:
>> On 22/02/2021 13:23, Hannes Reinecke wrote:
>>> void scsi_forget_host(struct Scsi_Host *shost)
>>> {
>>> - struct scsi_device *sdev;
>>> + struct scsi_device *sdev, *host_sdev = NULL;
>>> unsigned long flags;
>>> restart:
>>> spin_lock_irqsave(shost->host_lock, flags);
>>> list_for_each_entry(sdev, &shost->__devices, siblings) {
>>> + if (scsi_device_is_host_dev(sdev)) {
>>> + host_sdev = sdev;
>> Is there actually a limit of 1x host_sdev always?
>>
> I would have thought so, as the whole point of having a host device is
> that you have a (virtual) device which simulates access to the host itself.
> And as such has a 1:1 relationship to the HBA.
Sure, but I think that each call to scsi_get_host_dev() for the same
host will give a new sdev each time, right?
We should protect against what is sensible and what is possible - not
always the same :)
Thanks,
John
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 08/31] scsi: revamp host device handling
2021-02-24 14:31 ` John Garry
@ 2021-02-24 14:35 ` Hannes Reinecke
0 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-02-24 14:35 UTC (permalink / raw)
To: John Garry, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 2/24/21 3:31 PM, John Garry wrote:
> On 24/02/2021 14:24, Hannes Reinecke wrote:
>> On 2/24/21 2:12 PM, John Garry wrote:
>>> On 22/02/2021 13:23, Hannes Reinecke wrote:
>>>> void scsi_forget_host(struct Scsi_Host *shost)
>>>> {
>>>> - struct scsi_device *sdev;
>>>> + struct scsi_device *sdev, *host_sdev = NULL;
>>>> unsigned long flags;
>>>> restart:
>>>> spin_lock_irqsave(shost->host_lock, flags);
>>>> list_for_each_entry(sdev, &shost->__devices, siblings) {
>>>> + if (scsi_device_is_host_dev(sdev)) {
>>>> + host_sdev = sdev;
>>> Is there actually a limit of 1x host_sdev always?
>>>
>> I would have thought so, as the whole point of having a host device is
>> that you have a (virtual) device which simulates access to the host
>> itself.
>> And as such has a 1:1 relationship to the HBA.
>
> Sure, but I think that each call to scsi_get_host_dev() for the same
> host will give a new sdev each time, right?
>
> We should protect against what is sensible and what is possible - not
> always the same :)
>
The original implementation, yes.
With my patch series, no.
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
hare@suse.de +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
^ permalink raw reply [flat|nested] 54+ messages in thread
* RE: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (31 preceding siblings ...)
2021-02-23 10:16 ` [PATCHv7 00/31] scsi: enable reserved commands for LLDDs John Garry
@ 2021-03-06 15:11 ` Don.Brace
2021-03-16 17:57 ` Don.Brace
2021-03-11 23:53 ` michael.christie
33 siblings, 1 reply; 54+ messages in thread
From: Don.Brace @ 2021-03-06 15:11 UTC (permalink / raw)
To: hare, martin.petersen; +Cc: james.bottomley, hch, john.garry, linux-scsi
-----Original Message-----
From: Hannes Reinecke [mailto:hare@suse.de]
Subject: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
Hi all,
quite some drivers use internal commands for various purposes, most commonly sending TMFs or querying the HBA status.
While these commands use the same submission mechanism than normal I/O commands, they will not be counted as outstanding commands, requiring those drivers to implement their own mechanism to figure out outstanding commands.
The block layer already has the concept of 'reserved' tags for precisely this purpose, namely non-I/O tags which live off a separate tag pool. That guarantees that these commands can always be sent, and won't be influenced by tag starvation from the I/O tag pool.
This patchset enables the use of reserved tags for the SCSI midlayer by allocating a virtual LUN for the HBA itself which just serves as a resource to allocate valid tags from.
This removes quite some hacks which were required for some drivers (eg. fnic or snic), and allows the use of tagset iterators within the drivers.
The entire patchset can be found at
git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
reserved-tags.v7
Don: Cloned and kernel built. I'll have some test results by end of next week or so...
Thanks,
Don
--
2.29.2
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task
2021-02-22 13:24 ` [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task Hannes Reinecke
@ 2021-03-09 11:22 ` luojiaxing
2021-03-09 14:05 ` John Garry
0 siblings, 1 reply; 54+ messages in thread
From: luojiaxing @ 2021-03-09 11:22 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi
Hi, Hannes, john
I found some tiny coding issues of this patch. check below.
And if someone else have already point out, please ignore.
On 2021/2/22 21:24, Hannes Reinecke wrote:
> From: John Garry <john.garry@huawei.com>
>
> Allocate a Scsi_cmd for SAS slow tasks, so they can be accounted for in
> the blk-mq layer.
>
> Signed-off-by: John Garry <john.garry@huawei.com>
> Signed-off-by: Hannes Reinecke <hare@suse.de>
> ---
> drivers/scsi/hisi_sas/hisi_sas_main.c | 56 ++++++++++++++++--------
> drivers/scsi/libsas/sas_expander.c | 7 ++-
> drivers/scsi/libsas/sas_init.c | 61 ++++++++++++++++++++++++---
> drivers/scsi/mvsas/mv_sas.c | 5 ++-
> drivers/scsi/pm8001/pm8001_hwi.c | 9 +++-
> drivers/scsi/pm8001/pm8001_sas.c | 39 +++++++++++------
> drivers/scsi/pm8001/pm80xx_hwi.c | 9 +++-
> include/scsi/libsas.h | 8 +++-
> 8 files changed, 148 insertions(+), 46 deletions(-)
>
> diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
> index a979edfd9a78..6a69a90a1b82 100644
> --- a/drivers/scsi/hisi_sas/hisi_sas_main.c
> +++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
> @@ -15,6 +15,7 @@ static int hisi_sas_debug_issue_ssp_tmf(struct domain_device *device,
> static int
> hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> struct domain_device *device,
> + struct scsi_lun *lun,
> int abort_flag, int tag);
> static int hisi_sas_softreset_ata_disk(struct domain_device *device);
> static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
> @@ -1055,15 +1056,17 @@ static void hisi_sas_dev_gone(struct domain_device *device)
> struct hisi_sas_device *sas_dev = device->lldd_dev;
> struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
> struct device *dev = hisi_hba->dev;
> + struct scsi_lun lun;
> int ret = 0;
>
> dev_info(dev, "dev[%d:%x] is gone\n",
> sas_dev->device_id, sas_dev->dev_type);
>
> down(&hisi_hba->sem);
> + int_to_scsilun(0, &lun);
> if (!test_bit(HISI_SAS_RESET_BIT, &hisi_hba->flags)) {
> hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV, 0);
> + &lun, HISI_SAS_INT_ABT_DEV, 0);
>
> hisi_sas_dereg_device(hisi_hba, device);
>
> @@ -1191,12 +1194,21 @@ static int hisi_sas_exec_internal_tmf_task(struct domain_device *device,
> {
> struct hisi_sas_device *sas_dev = device->lldd_dev;
> struct hisi_hba *hisi_hba = sas_dev->hisi_hba;
> + struct sas_ha_struct *sha = &hisi_hba->sha;
> struct device *dev = hisi_hba->dev;
> struct sas_task *task;
> int res, retry;
>
> for (retry = 0; retry < TASK_RETRY; retry++) {
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + struct scsilun lun;
This should be "struct scsi_lun lun"
> +
> + int_to_scsilun(0, &lun);
> + if (!dev_is_sata) {
should be " if (!dev_is_sata(device)) "
> + struct sas_ssp_task ssp_task = parameter;
And I think it should be
const struct sas_ssp_task *ssp_task = parameter;
> +
> + memcpy(lun.scsi_lun, ssp_task.LUN, 8);
memcpy(lun.scsi_lun, ssp_task->LUN, 8);
> + }
> + task = sas_alloc_slow_task(sha, device, &lun, GFP_KERNEL);
> if (!task)
> return -ENOMEM;
>
> @@ -1494,7 +1506,9 @@ static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
> {
> struct device *dev = hisi_hba->dev;
> int port_no, rc, i;
> + struct scsi_lun lun;
>
> + int_to_scsilun(0, &lun);
> for (i = 0; i < HISI_SAS_MAX_DEVICES; i++) {
> struct hisi_sas_device *sas_dev = &hisi_hba->devices[i];
> struct domain_device *device = sas_dev->sas_device;
> @@ -1503,7 +1517,7 @@ static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
> continue;
>
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV, 0);
> + &lun, HISI_SAS_INT_ABT_DEV, 0);
> if (rc < 0)
> dev_err(dev, "STP reject: abort dev failed %d\n", rc);
> }
> @@ -1653,7 +1667,7 @@ static int hisi_sas_abort_task(struct sas_task *task)
> &tmf_task);
>
> rc2 = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_CMD, tag);
> + &lun, HISI_SAS_INT_ABT_CMD, tag);
> if (rc2 < 0) {
> dev_err(dev, "abort task: internal abort (%d)\n", rc2);
> return TMF_RESP_FUNC_FAILED;
> @@ -1673,9 +1687,9 @@ static int hisi_sas_abort_task(struct sas_task *task)
> } else if (task->task_proto & SAS_PROTOCOL_SATA ||
> task->task_proto & SAS_PROTOCOL_STP) {
> if (task->dev->dev_type == SAS_SATA_DEV) {
> + int_to_scsilun(0, &lun);
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV,
> - 0);
> + &lun, HISI_SAS_INT_ABT_DEV, 0);
> if (rc < 0) {
> dev_err(dev, "abort task: internal abort failed\n");
> goto out;
> @@ -1689,8 +1703,9 @@ static int hisi_sas_abort_task(struct sas_task *task)
> u32 tag = slot->idx;
> struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
>
> + int_to_scsilun(0, &lun);
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_CMD, tag);
> + &lun, HISI_SAS_INT_ABT_CMD, tag);
> if (((rc < 0) || (rc == TMF_RESP_FUNC_FAILED)) &&
> task->lldd_task) {
> /*
> @@ -1716,7 +1731,7 @@ static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
> int rc;
>
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV, 0);
> + (struct scsi_lun *)lun, HISI_SAS_INT_ABT_DEV, 0);
> if (rc < 0) {
> dev_err(dev, "abort task set: internal abort rc=%d\n", rc);
> return TMF_RESP_FUNC_FAILED;
> @@ -1804,10 +1819,12 @@ static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
> {
> struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);
> struct device *dev = hisi_hba->dev;
> + struct scsi_lun lun;
> int rc;
>
> + int_to_scsilun(0, &lun);
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV, 0);
> + &lun, HISI_SAS_INT_ABT_DEV, 0);
> if (rc < 0) {
> dev_err(dev, "I_T nexus reset: internal abort (%d)\n", rc);
> return TMF_RESP_FUNC_FAILED;
> @@ -1837,7 +1854,7 @@ static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
>
> /* Clear internal IO and then lu reset */
> rc = hisi_sas_internal_task_abort(hisi_hba, device,
> - HISI_SAS_INT_ABT_DEV, 0);
> + (struct scsi_lun *)lun, HISI_SAS_INT_ABT_DEV, 0);
> if (rc < 0) {
> dev_err(dev, "lu_reset: internal abort failed\n");
> goto out;
> @@ -2018,6 +2035,7 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
> * abort command for single IO command or a device
> * @hisi_hba: host controller struct
> * @device: domain device
> + * @lun: logical unit number
> * @abort_flag: mode of operation, device or single IO
> * @tag: tag of IO to be aborted (only relevant to single
> * IO mode)
> @@ -2025,12 +2043,15 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
> */
> static int
> _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> - struct domain_device *device, int abort_flag,
> - int tag, struct hisi_sas_dq *dq)
> + struct domain_device *device,
> + struct scsi_lun *lun,
> + int abort_flag, int tag,
> + struct hisi_sas_dq *dq)
> {
> - struct sas_task *task;
> struct hisi_sas_device *sas_dev = device->lldd_dev;
> + struct sas_ha_struct *sha = &hisi_hba->sha;
> struct device *dev = hisi_hba->dev;
> + struct sas_task *task;
> int res;
>
> /*
> @@ -2042,7 +2063,8 @@ _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> if (!hisi_hba->hw->prep_abort)
> return TMF_RESP_FUNC_FAILED;
>
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + task = sas_alloc_slow_task(sha, device,
> + (struct scsi_lun *)lun, GFP_KERNEL);
> if (!task)
> return -ENOMEM;
>
> @@ -2115,6 +2137,7 @@ _hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> static int
> hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> struct domain_device *device,
> + struct scsi_lun *lun,
> int abort_flag, int tag)
> {
> struct hisi_sas_slot *slot;
> @@ -2127,7 +2150,7 @@ hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> slot = &hisi_hba->slot_info[tag];
> dq = &hisi_hba->dq[slot->dlvry_queue];
> return _hisi_sas_internal_task_abort(hisi_hba, device,
> - abort_flag, tag, dq);
> + lun, abort_flag, tag, dq);
> case HISI_SAS_INT_ABT_DEV:
> for (i = 0; i < hisi_hba->cq_nvecs; i++) {
> struct hisi_sas_cq *cq = &hisi_hba->cq[i];
> @@ -2137,8 +2160,7 @@ hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba,
> continue;
> dq = &hisi_hba->dq[i];
> rc = _hisi_sas_internal_task_abort(hisi_hba, device,
> - abort_flag, tag,
> - dq);
> + lun, abort_flag, tag, dq);
> if (rc)
> return rc;
> }
> diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
> index 8d6bcc19359f..9e4a7c85a037 100644
> --- a/drivers/scsi/libsas/sas_expander.c
> +++ b/drivers/scsi/libsas/sas_expander.c
> @@ -56,9 +56,12 @@ static int smp_execute_task_sg(struct domain_device *dev,
> {
> int res, retry;
> struct sas_task *task = NULL;
> + struct sas_ha_struct *ha = dev->port->ha;
> struct sas_internal *i =
> - to_sas_internal(dev->port->ha->core.shost->transportt);
> + to_sas_internal(ha->core.shost->transportt);
> + struct scsi_lun lun;
>
> + int_to_scsilun(0, &lun);
> mutex_lock(&dev->ex_dev.cmd_mutex);
> for (retry = 0; retry < 3; retry++) {
> if (test_bit(SAS_DEV_GONE, &dev->state)) {
> @@ -66,7 +69,7 @@ static int smp_execute_task_sg(struct domain_device *dev,
> break;
> }
>
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + task = sas_alloc_slow_task(ha, dev, &lun, GFP_KERNEL);
> if (!task) {
> res = -ENOMEM;
> break;
> diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
> index 2b0f98ca6ec3..9d0448b76a2f 100644
> --- a/drivers/scsi/libsas/sas_init.c
> +++ b/drivers/scsi/libsas/sas_init.c
> @@ -14,6 +14,7 @@
> #include <scsi/sas_ata.h>
> #include <scsi/scsi_host.h>
> #include <scsi/scsi_device.h>
> +#include <scsi/scsi_tcq.h>
> #include <scsi/scsi_transport.h>
> #include <scsi/scsi_transport_sas.h>
>
> @@ -37,16 +38,36 @@ struct sas_task *sas_alloc_task(gfp_t flags)
> }
> EXPORT_SYMBOL_GPL(sas_alloc_task);
>
> -struct sas_task *sas_alloc_slow_task(gfp_t flags)
> +struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
> + struct domain_device *dev,
> + struct scsi_lun *lun, gfp_t flags)
> {
> struct sas_task *task = sas_alloc_task(flags);
> - struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags);
> + struct Scsi_Host *shost = ha->core.shost;
> + struct sas_task_slow *slow;
>
> - if (!task || !slow) {
> - if (task)
> - kmem_cache_free(sas_task_cache, task);
> - kfree(slow);
> + if (!task)
> return NULL;
> +
> + slow = kzalloc(sizeof(*slow), flags);
> + if (!slow)
> + goto out_err_slow;
> +
> + if (shost->nr_reserved_cmds) {
> + struct scsi_device *sdev;
> +
> + if (dev && dev->starget) {
> + sdev = scsi_device_lookup_by_target(dev->starget,
> + scsilun_to_int(lun));
> + if (!sdev)
> + goto out_err_scmd;
> + } else
> + sdev = ha->core.shost_dev;
> + slow->scmd = scsi_get_internal_cmd(sdev, DMA_BIDIRECTIONAL,
> + REQ_NOWAIT);
> + if (!slow->scmd)
> + goto out_err_scmd;
> + ASSIGN_SAS_TASK(slow->scmd, task);
> }
>
> task->slow_task = slow;
> @@ -55,13 +76,31 @@ struct sas_task *sas_alloc_slow_task(gfp_t flags)
> init_completion(&slow->completion);
>
> return task;
> +
> +out_err_scmd:
> + kfree(slow);
> +out_err_slow:
> + kmem_cache_free(sas_task_cache, task);
> + return NULL;
> }
> EXPORT_SYMBOL_GPL(sas_alloc_slow_task);
>
> void sas_free_task(struct sas_task *task)
> {
> if (task) {
> - kfree(task->slow_task);
> + /*
> + * It could be good to just introduce separate sas_free_slow_task() to
> + * avoid the following in the fastpath.
> + */
> + if (task->slow_task) {
> + struct scsi_cmnd *scmd = task->slow_task->scmd;
> +
> + if (scmd) {
> + ASSIGN_SAS_TASK(scmd, NULL);
> + scsi_put_internal_cmd(scmd);
> + }
> + kfree(task->slow_task);
> + }
> kmem_cache_free(sas_task_cache, task);
> }
> }
> @@ -95,6 +134,7 @@ void sas_hash_addr(u8 *hashed, const u8 *sas_addr)
>
> int sas_register_ha(struct sas_ha_struct *sas_ha)
> {
> + struct Scsi_Host *shost = sas_ha->core.shost;
> char name[64];
> int error = 0;
>
> @@ -111,6 +151,13 @@ int sas_register_ha(struct sas_ha_struct *sas_ha)
>
> sas_ha->event_thres = SAS_PHY_SHUTDOWN_THRES;
>
> + if (shost->nr_reserved_cmds) {
> + sas_ha->core.shost_dev = scsi_get_host_dev(shost);
> + if (!sas_ha->core.shost_dev) {
> + pr_notice("couldn't register sas host device\n");
> + return -ENOMEM;
> + }
> + }
> error = sas_register_phys(sas_ha);
> if (error) {
> pr_notice("couldn't register sas phys:%d\n", error);
> diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
> index 543b435f4c8c..99bdb88b3e86 100644
> --- a/drivers/scsi/mvsas/mv_sas.c
> +++ b/drivers/scsi/mvsas/mv_sas.c
> @@ -1278,13 +1278,16 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
> u8 *lun, struct mvs_tmf_task *tmf)
> {
> int res, retry;
> + struct sas_ha_struct *ha = dev->port->ha;
> struct sas_task *task = NULL;
> + struct scsi_lun scsilun;
>
> if (!(dev->tproto & SAS_PROTOCOL_SSP))
> return TMF_RESP_FUNC_ESUPP;
>
> + memcpy(scsilun.scsi_lun, lun, 8);
> for (retry = 0; retry < 3; retry++) {
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + task = sas_alloc_slow_task(ha, dev, &scsilun, GFP_KERNEL);
> if (!task)
> return -ENOMEM;
>
> diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
> index 3998fcd69acb..105962b0c815 100644
> --- a/drivers/scsi/pm8001/pm8001_hwi.c
> +++ b/drivers/scsi/pm8001/pm8001_hwi.c
> @@ -1701,6 +1701,7 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
> struct task_abort_req task_abort;
> struct inbound_queue_table *circularQ;
> u32 opc = OPC_INB_SATA_ABORT;
> + struct scsi_lun lun;
> int ret;
>
> if (!pm8001_ha_dev) {
> @@ -1708,7 +1709,9 @@ static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
> return;
> }
>
> - task = sas_alloc_slow_task(GFP_ATOMIC);
> + int_to_scsilun(0, &lun);
> + task = sas_alloc_slow_task(pm8001_ha->sas, pm8001_ha_dev->sas_device,
> + &lun, GFP_ATOMIC);
>
> if (!task) {
> pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
> @@ -1752,8 +1755,10 @@ static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
> struct domain_device *dev = pm8001_ha_dev->sas_device;
> struct inbound_queue_table *circularQ;
> u32 opc = OPC_INB_SATA_HOST_OPSTART;
> + struct scsi_lun lun;;
>
> - task = sas_alloc_slow_task(GFP_ATOMIC);
> + int_to_scsilun(0, &lun);
> + task = sas_alloc_slow_task(pm8001_ha->sas, dev, &lun, GFP_ATOMIC);
>
> if (!task) {
> pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
> diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
> index 01e91347eb41..b1f12d671611 100644
> --- a/drivers/scsi/pm8001/pm8001_sas.c
> +++ b/drivers/scsi/pm8001/pm8001_sas.c
> @@ -717,7 +717,9 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
> return TMF_RESP_FUNC_ESUPP;
>
> for (retry = 0; retry < 3; retry++) {
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + task = sas_alloc_slow_task(pm8001_ha->sas,
> + pm8001_dev->sas_device,
> + (struct scsi_lun *)lun, GFP_KERNEL);
> if (!task)
> return -ENOMEM;
>
> @@ -791,7 +793,7 @@ static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
>
> static int
> pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
> - struct pm8001_device *pm8001_dev, u32 flag,
> + struct pm8001_device *pm8001_dev, u8 *lun, u32 flag,
> u32 task_tag)
> {
> struct domain_device *dev = pm8001_dev->sas_device;
> @@ -801,7 +803,8 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
> struct sas_task *task = NULL;
>
> for (retry = 0; retry < 3; retry++) {
> - task = sas_alloc_slow_task(GFP_KERNEL);
> + task = sas_alloc_slow_task(pm8001_ha->sas, dev,
> + (struct scsi_lun *)lun, GFP_KERNEL);
> if (!task)
> return -ENOMEM;
>
> @@ -875,13 +878,15 @@ static void pm8001_dev_gone_notify(struct domain_device *dev)
> spin_lock_irqsave(&pm8001_ha->lock, flags);
> if (pm8001_dev) {
> u32 device_id = pm8001_dev->device_id;
> + struct scsi_lun lun;
>
> + int_to_scsilun(0, &lun);
> pm8001_dbg(pm8001_ha, DISC, "found dev[%d:%x] is gone.\n",
> pm8001_dev->device_id, pm8001_dev->dev_type);
> if (atomic_read(&pm8001_dev->running_req)) {
> spin_unlock_irqrestore(&pm8001_ha->lock, flags);
> pm8001_exec_internal_task_abort(pm8001_ha,
> - pm8001_dev, 1, 0);
> + pm8001_dev, lun.scsi_lun, 1, 0);
> while (atomic_read(&pm8001_dev->running_req))
> msleep(20);
> spin_lock_irqsave(&pm8001_ha->lock, flags);
> @@ -991,6 +996,9 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
> phy = sas_get_local_phy(dev);
>
> if (dev_is_sata(dev)) {
> + struct scsi_lun lun;
> +
> + int_to_scsilun(0, &lun);
> if (scsi_is_sas_phy_local(phy)) {
> rc = 0;
> goto out;
> @@ -1005,7 +1013,7 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
> }
> msleep(2000);
> rc = pm8001_exec_internal_task_abort(pm8001_ha,
> - pm8001_dev, 1, 0);
> + pm8001_dev, lun.scsi_lun, 1, 0);
> if (rc) {
> pm8001_dbg(pm8001_ha, EH, "task abort failed %x\n"
> "with rc %d\n", pm8001_dev->device_id, rc);
> @@ -1032,7 +1040,9 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
> struct pm8001_device *pm8001_dev;
> struct pm8001_hba_info *pm8001_ha;
> struct sas_phy *phy;
> + struct scsi_lun lun;
>
> + int_to_scsilun(0, &lun);
> if (!dev || !dev->lldd_dev)
> return -1;
>
> @@ -1051,7 +1061,7 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
> }
> /* send internal ssp/sata/smp abort command to FW */
> rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
> - 1, 0);
> + lun.scsi_lun, 1, 0);
> msleep(100);
>
> /* deregister the target device */
> @@ -1067,7 +1077,7 @@ int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
> } else {
> /* send internal ssp/sata/smp abort command to FW */
> rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
> - 1, 0);
> + lun.scsi_lun, 1, 0);
> msleep(100);
>
> /* deregister the target device */
> @@ -1095,8 +1105,8 @@ int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
> DECLARE_COMPLETION_ONSTACK(completion_setstate);
> if (dev_is_sata(dev)) {
> struct sas_phy *phy = sas_get_local_phy(dev);
> - rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
> - 1, 0);
> + rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
> + lun, 1, 0);
> rc = sas_phy_reset(phy, 1);
> sas_put_local_phy(phy);
> pm8001_dev->setds_completion = &completion_setstate;
> @@ -1211,9 +1221,10 @@ int pm8001_abort_task(struct sas_task *task)
> &tmf_task);
> if (rc == TMF_RESP_FUNC_SUCC)
> pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
> - 0, tag);
> + lun.scsi_lun, 0, tag);
> } else if (task->task_proto & SAS_PROTOCOL_SATA ||
> task->task_proto & SAS_PROTOCOL_STP) {
> + memset(lun.scsi_lun, 0, sizeof(lun.scsi_lun));
> if (pm8001_ha->chip_id == chip_8006) {
> DECLARE_COMPLETION_ONSTACK(completion_reset);
> DECLARE_COMPLETION_ONSTACK(completion);
> @@ -1280,7 +1291,7 @@ int pm8001_abort_task(struct sas_task *task)
> * going to free the task.
> */
> ret = pm8001_exec_internal_task_abort(pm8001_ha,
> - pm8001_dev, 1, tag);
> + pm8001_dev, lun.scsi_lun, 1, tag);
> if (ret)
> goto out;
> ret = wait_for_completion_timeout(
> @@ -1297,13 +1308,15 @@ int pm8001_abort_task(struct sas_task *task)
> wait_for_completion(&completion);
> } else {
> rc = pm8001_exec_internal_task_abort(pm8001_ha,
> - pm8001_dev, 0, tag);
> + pm8001_dev, lun.scsi_lun, 0, tag);
> }
> rc = TMF_RESP_FUNC_COMPLETE;
> } else if (task->task_proto & SAS_PROTOCOL_SMP) {
> /* SMP */
> +
> + int_to_scsilun(0, &lun);
> rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
> - 0, tag);
> + lun.scsi_lun, 0, tag);
>
> }
> out:
> diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
> index bc1929b230c4..03bfb4d72895 100644
> --- a/drivers/scsi/pm8001/pm80xx_hwi.c
> +++ b/drivers/scsi/pm8001/pm80xx_hwi.c
> @@ -1772,6 +1772,7 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
> struct task_abort_req task_abort;
> struct inbound_queue_table *circularQ;
> u32 opc = OPC_INB_SATA_ABORT;
> + struct scsi_lun lun;
> int ret;
>
> if (!pm8001_ha_dev) {
> @@ -1779,7 +1780,9 @@ static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
> return;
> }
>
> - task = sas_alloc_slow_task(GFP_ATOMIC);
> + int_to_scsilun(0, &lun);
> + task = sas_alloc_slow_task(pm8001_ha->sas,pm8001_ha_dev->sas_device,
> + &lun, GFP_ATOMIC);
>
> if (!task) {
> pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task\n");
> @@ -1827,8 +1830,10 @@ static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
> struct domain_device *dev = pm8001_ha_dev->sas_device;
> struct inbound_queue_table *circularQ;
> u32 opc = OPC_INB_SATA_HOST_OPSTART;
> + struct scsi_lun lun;
>
> - task = sas_alloc_slow_task(GFP_ATOMIC);
> + int_to_scsilun(0, &lun);
> + task = sas_alloc_slow_task(pm8001_ha->sas, dev, &lun, GFP_ATOMIC);
>
> if (!task) {
> pm8001_dbg(pm8001_ha, FAIL, "cannot allocate task !!!\n");
> diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
> index 3a024eced38c..9b8c06a8329a 100644
> --- a/include/scsi/libsas.h
> +++ b/include/scsi/libsas.h
> @@ -349,7 +349,7 @@ struct asd_sas_phy {
>
> struct scsi_core {
> struct Scsi_Host *shost;
> -
> + struct scsi_device *shost_dev;
> };
>
> enum sas_ha_state {
> @@ -605,6 +605,7 @@ struct sas_task_slow {
> struct timer_list timer;
> struct completion completion;
> struct sas_task *task;
> + struct scsi_cmnd *scmd;
> };
>
> #define SAS_TASK_STATE_PENDING 1
> @@ -614,7 +615,10 @@ struct sas_task_slow {
> #define SAS_TASK_AT_INITIATOR 16
>
> extern struct sas_task *sas_alloc_task(gfp_t flags);
> -extern struct sas_task *sas_alloc_slow_task(gfp_t flags);
> +extern struct sas_task *sas_alloc_slow_task(struct sas_ha_struct *ha,
> + struct domain_device *dev,
> + struct scsi_lun *lun,
> + gfp_t flags);
> extern void sas_free_task(struct sas_task *task);
>
> struct sas_domain_function_template {
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task
2021-03-09 11:22 ` luojiaxing
@ 2021-03-09 14:05 ` John Garry
2021-03-11 8:51 ` luojiaxing
0 siblings, 1 reply; 54+ messages in thread
From: John Garry @ 2021-03-09 14:05 UTC (permalink / raw)
To: luojiaxing, Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 09/03/2021 11:22, luojiaxing wrote:
> Hi, Hannes, john
>
>
> I found some tiny coding issues of this patch. check below.
>
> And if someone else have already point out, please ignore.
>
JFYI, I have put the patches on this following branch, and fixed up to
get building+working:
https://github.com/hisilicon/kernel-dev/commits/private-topic-sas-5.11-resv7
Thanks,
John
>
> On 2021/2/22 21:24, Hannes Reinecke wrote:
>> From: John Garry <john.garry@huawei.com>
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 29/31] hisi_sas: use task tag to reference the slot
2021-02-22 13:24 ` [PATCH 29/31] hisi_sas: use task tag to reference the slot Hannes Reinecke
@ 2021-03-10 1:54 ` luojiaxing
0 siblings, 0 replies; 54+ messages in thread
From: luojiaxing @ 2021-03-10 1:54 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi
On 2021/2/22 21:24, Hannes Reinecke wrote:
> Use the task task to reference the command slot and drop the
> internal slot bitmap.
>
> Signed-off-by: Hannes Reinecke <hare@suse.de>
> ---
> drivers/scsi/hisi_sas/hisi_sas.h | 1 -
> drivers/scsi/hisi_sas/hisi_sas_main.c | 78 ++-------------------------
> 2 files changed, 5 insertions(+), 74 deletions(-)
>
> diff --git a/drivers/scsi/hisi_sas/hisi_sas.h b/drivers/scsi/hisi_sas/hisi_sas.h
> index 2401a9575215..6efe980789ee 100644
> --- a/drivers/scsi/hisi_sas/hisi_sas.h
> +++ b/drivers/scsi/hisi_sas/hisi_sas.h
> @@ -419,7 +419,6 @@ struct hisi_hba {
> struct workqueue_struct *wq;
>
> int slot_index_count;
> - int last_slot_index;
> int last_dev_id;
> unsigned long *slot_index_tags;
> unsigned long reject_stp_links_msk;
> diff --git a/drivers/scsi/hisi_sas/hisi_sas_main.c b/drivers/scsi/hisi_sas/hisi_sas_main.c
> index af653f4393ea..6402c4e4befa 100644
> --- a/drivers/scsi/hisi_sas/hisi_sas_main.c
> +++ b/drivers/scsi/hisi_sas/hisi_sas_main.c
> @@ -155,62 +155,6 @@ void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
> }
> EXPORT_SYMBOL_GPL(hisi_sas_stop_phys);
>
> -static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
> -{
> - void *bitmap = hisi_hba->slot_index_tags;
> -
> - clear_bit(slot_idx, bitmap);
> -}
> -
> -static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
> -{
> - if (hisi_hba->hw->slot_index_alloc ||
> - slot_idx >= HISI_SAS_UNRESERVED_IPTT) {
> - spin_lock(&hisi_hba->lock);
> - hisi_sas_slot_index_clear(hisi_hba, slot_idx);
> - spin_unlock(&hisi_hba->lock);
> - }
> -}
> -
> -static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
> -{
> - void *bitmap = hisi_hba->slot_index_tags;
> -
> - set_bit(slot_idx, bitmap);
> -}
> -
> -static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba)
> -{
> - int index;
> - void *bitmap = hisi_hba->slot_index_tags;
> -
> - spin_lock(&hisi_hba->lock);
> - index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
> - hisi_hba->last_slot_index + 1);
> - if (index >= hisi_hba->slot_index_count) {
> - index = find_next_zero_bit(bitmap,
> - hisi_hba->slot_index_count,
> - HISI_SAS_UNRESERVED_IPTT);
> - if (index >= hisi_hba->slot_index_count) {
> - spin_unlock(&hisi_hba->lock);
> - return -SAS_QUEUE_FULL;
> - }
> - }
> - hisi_sas_slot_index_set(hisi_hba, index);
> - hisi_hba->last_slot_index = index;
> - spin_unlock(&hisi_hba->lock);
> -
> - return index;
> -}
> -
> -static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
> -{
> - int i;
> -
> - for (i = 0; i < hisi_hba->slot_index_count; ++i)
> - hisi_sas_slot_index_clear(hisi_hba, i);
> -}
> -
> void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
> struct hisi_sas_slot *slot)
> {
> @@ -246,8 +190,6 @@ void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
> spin_unlock(&sas_dev->lock);
>
> memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
> -
> - hisi_sas_slot_index_free(hisi_hba, slot->idx);
> }
> EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
>
> @@ -482,10 +424,8 @@ static int hisi_sas_task_prep(struct sas_task *task,
>
> if (hisi_hba->hw->slot_index_alloc)
> rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
> - else if (scmd)
> - rc = scmd->request->tag;
> else
> - rc = hisi_sas_slot_index_alloc(hisi_hba);
> + rc = scmd->request->tag;
>
> if (rc < 0)
> goto err_out_dif_dma_unmap;
> @@ -1975,9 +1915,10 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id,
> port = to_hisi_sas_port(sas_port);
>
> /* simply get a slot and send abort command */
> - rc = = task->tag;
> - if (rc < 0)
> - rc = hisi_sas_slot_index_alloc(hisi_hba);
> + if (hisi_hha->hw->slot_index_alloc)
hisi_hha is wrong , it should be hisi_hba
> + rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
> + else
> + rc = = task->tag;
Delete unnecessary "="
> if (rc < 0)
> goto err_out;
>
> @@ -2440,12 +2381,6 @@ int hisi_sas_alloc(struct hisi_hba *hisi_hba)
> if (!hisi_hba->breakpoint)
> goto err_out;
>
> - hisi_hba->slot_index_count = max_command_entries;
> - s = hisi_hba->slot_index_count / BITS_PER_BYTE;
> - hisi_hba->slot_index_tags = devm_kzalloc(dev, s, GFP_KERNEL);
> - if (!hisi_hba->slot_index_tags)
> - goto err_out;
> -
> s = sizeof(struct hisi_sas_initial_fis) * HISI_SAS_MAX_PHYS;
> hisi_hba->initial_fis = dmam_alloc_coherent(dev, s,
> &hisi_hba->initial_fis_dma,
> @@ -2460,9 +2395,6 @@ int hisi_sas_alloc(struct hisi_hba *hisi_hba)
> if (!hisi_hba->sata_breakpoint)
> goto err_out;
>
> - hisi_sas_slot_index_init(hisi_hba);
> - hisi_hba->last_slot_index = HISI_SAS_UNRESERVED_IPTT;
> -
> hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
> if (!hisi_hba->wq) {
> dev_err(dev, "sas_alloc: failed to create workqueue\n");
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task
2021-03-09 14:05 ` John Garry
@ 2021-03-11 8:51 ` luojiaxing
0 siblings, 0 replies; 54+ messages in thread
From: luojiaxing @ 2021-03-11 8:51 UTC (permalink / raw)
To: John Garry, Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 2021/3/9 22:05, John Garry wrote:
> On 09/03/2021 11:22, luojiaxing wrote:
>> Hi, Hannes, john
>>
>>
>> I found some tiny coding issues of this patch. check below.
>>
>> And if someone else have already point out, please ignore.
>>
>
> JFYI, I have put the patches on this following branch, and fixed up to
> get building+working:
> https://github.com/hisilicon/kernel-dev/commits/private-topic-sas-5.11-resv7
>
Thanks, I will run some full test on it later. If other issue is found,
we discuss then
Jiaxing
>
> Thanks,
> John
>
>>
>> On 2021/2/22 21:24, Hannes Reinecke wrote:
>>> From: John Garry <john.garry@huawei.com>
>
>
> .
>
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 14/31] hpsa: use reserved commands
2021-02-22 13:23 ` [PATCH 14/31] hpsa: use reserved commands Hannes Reinecke
@ 2021-03-11 22:03 ` michael.christie
2021-05-03 9:36 ` Hannes Reinecke
0 siblings, 1 reply; 54+ messages in thread
From: michael.christie @ 2021-03-11 22:03 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi, Don Brace
On 2/22/21 7:23 AM, Hannes Reinecke wrote:
> -
> -static struct CommandList *cmd_alloc(struct ctlr_info *h)
> +static struct CommandList *cmd_alloc(struct ctlr_info *h, u8 direction)
> {
> + struct scsi_cmnd *scmd;
> struct CommandList *c;
> - int refcount, i;
> - int offset = 0;
> -
> - /*
> - * There is some *extremely* small but non-zero chance that that
> - * multiple threads could get in here, and one thread could
> - * be scanning through the list of bits looking for a free
> - * one, but the free ones are always behind him, and other
> - * threads sneak in behind him and eat them before he can
> - * get to them, so that while there is always a free one, a
> - * very unlucky thread might be starved anyway, never able to
> - * beat the other threads. In reality, this happens so
> - * infrequently as to be indistinguishable from never.
> - *
> - * Note that we start allocating commands before the SCSI host structure
> - * is initialized. Since the search starts at bit zero, this
> - * all works, since we have at least one command structure available;
> - * however, it means that the structures with the low indexes have to be
> - * reserved for driver-initiated requests, while requests from the block
> - * layer will use the higher indexes.
> - */
> -
> - for (;;) {
> - i = find_next_zero_bit(h->cmd_pool_bits,
> - HPSA_NRESERVED_CMDS,
> - offset);
> - if (unlikely(i >= HPSA_NRESERVED_CMDS)) {
> - offset = 0;
> - continue;
> - }
> - c = h->cmd_pool + i;
> - refcount = atomic_inc_return(&c->refcount);
> - if (unlikely(refcount > 1)) {
> - cmd_free(h, c); /* already in use */
> - offset = (i + 1) % HPSA_NRESERVED_CMDS;
> - continue;
> - }
> - set_bit(i & (BITS_PER_LONG - 1),
> - h->cmd_pool_bits + (i / BITS_PER_LONG));
> - break; /* it's ours now. */
> + int idx;
> +
> + scmd = scsi_get_internal_cmd(h->raid_ctrl_sdev,
> + (direction & XFER_WRITE) ?
> + DMA_TO_DEVICE : DMA_FROM_DEVICE,
> + REQ_NOWAIT);
> + if (!scmd) {
> + dev_warn(&h->pdev->dev, "failed to allocate reserved cmd\n");
> + return NULL;
I think in the orig code cmd_alloc would always return a non null pointer.
It looks like we would always just keep looping.
Now, it looks like we could fail from the above code where we return NULL.
I was not sure if it's maybe impossible to hit the "return NULL" becuase we
only call this function when we know there will be a cmd availale. If we
can fail then the cmd_alloc callers should check for NULL now I think.
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
` (32 preceding siblings ...)
2021-03-06 15:11 ` Don.Brace
@ 2021-03-11 23:53 ` michael.christie
2021-03-12 16:08 ` Hannes Reinecke
33 siblings, 1 reply; 54+ messages in thread
From: michael.christie @ 2021-03-11 23:53 UTC (permalink / raw)
To: Hannes Reinecke, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi
On 2/22/21 7:23 AM, Hannes Reinecke wrote:
> Hi all,
>
> quite some drivers use internal commands for various purposes, most
> commonly sending TMFs or querying the HBA status.
> While these commands use the same submission mechanism than normal
> I/O commands, they will not be counted as outstanding commands,
> requiring those drivers to implement their own mechanism to figure
> out outstanding commands.
> The block layer already has the concept of 'reserved' tags for
> precisely this purpose, namely non-I/O tags which live off a separate
> tag pool. That guarantees that these commands can always be sent,
> and won't be influenced by tag starvation from the I/O tag pool.
> This patchset enables the use of reserved tags for the SCSI midlayer
> by allocating a virtual LUN for the HBA itself which just serves
> as a resource to allocate valid tags from.
> This removes quite some hacks which were required for some
> drivers (eg. fnic or snic), and allows the use of tagset
> iterators within the drivers.
>
Hey Hannes,
I was trying to port some iscsi patches to this set. One question I had
is how to handle if my driver implements init_cmd_priv, and wants to use
the reserved cmds for a non scsi IO. My case I want to use them for cmds
like a iscsi nop/ping, device/target reset or login request.
There is no bit to way to tell if at init_cmd_priv time the cmd will be
for a reserved or non reserved cmd right? If not, I was wondering should
I do:
1. in libiscsi, allocate an array of size $reserved_cmds with non_scsi_cmds
structs. When I need to do a non scsi cmd do blk_mq_get_tag on the host's
tags to get a reserved tag then use that to lookup a struct in my array?
2. in libiscsi when I need to do a non scsi cmd do a scsi_get_internal_cmd.
At this time allocate the non_scsi_cmd struct parts.
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-03-11 23:53 ` michael.christie
@ 2021-03-12 16:08 ` Hannes Reinecke
2021-03-17 17:09 ` John Garry
0 siblings, 1 reply; 54+ messages in thread
From: Hannes Reinecke @ 2021-03-12 16:08 UTC (permalink / raw)
To: michael.christie, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi
On 3/12/21 12:53 AM, michael.christie@oracle.com wrote:
> On 2/22/21 7:23 AM, Hannes Reinecke wrote:
>> Hi all,
>>
>> quite some drivers use internal commands for various purposes, most
>> commonly sending TMFs or querying the HBA status.
>> While these commands use the same submission mechanism than normal
>> I/O commands, they will not be counted as outstanding commands,
>> requiring those drivers to implement their own mechanism to figure
>> out outstanding commands.
>> The block layer already has the concept of 'reserved' tags for
>> precisely this purpose, namely non-I/O tags which live off a separate
>> tag pool. That guarantees that these commands can always be sent,
>> and won't be influenced by tag starvation from the I/O tag pool.
>> This patchset enables the use of reserved tags for the SCSI midlayer
>> by allocating a virtual LUN for the HBA itself which just serves
>> as a resource to allocate valid tags from.
>> This removes quite some hacks which were required for some
>> drivers (eg. fnic or snic), and allows the use of tagset
>> iterators within the drivers.
>>
>
> Hey Hannes,
>
> I was trying to port some iscsi patches to this set. One question I had
> is how to handle if my driver implements init_cmd_priv, and wants to use
> the reserved cmds for a non scsi IO. My case I want to use them for cmds
> like a iscsi nop/ping, device/target reset or login request.
>
> There is no bit to way to tell if at init_cmd_priv time the cmd will be
> for a reserved or non reserved cmd right? If not, I was wondering should
> I do:
>
> 1. in libiscsi, allocate an array of size $reserved_cmds with non_scsi_cmds
> structs. When I need to do a non scsi cmd do blk_mq_get_tag on the host's
> tags to get a reserved tag then use that to lookup a struct in my array?
>
> 2. in libiscsi when I need to do a non scsi cmd do a scsi_get_internal_cmd.
> At this time allocate the non_scsi_cmd struct parts.
>
You sure you will need to allocate additional stuff?
The request already comes with the request, scsi, and driver private
bits (ie the additional space from .cmd_size) allocated.
And yes, you can tell in init_cmd_priv() if the command is coming from
the private pool; I had a helper 'req_is_reserved' once, I thought it's
still there ...
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
hare@suse.de +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
^ permalink raw reply [flat|nested] 54+ messages in thread
* RE: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-03-06 15:11 ` Don.Brace
@ 2021-03-16 17:57 ` Don.Brace
2021-03-29 21:47 ` Don.Brace
0 siblings, 1 reply; 54+ messages in thread
From: Don.Brace @ 2021-03-16 17:57 UTC (permalink / raw)
To: Don.Brace, hare, martin.petersen
Cc: james.bottomley, hch, john.garry, linux-scsi
-----Original Message-----
Subject: RE: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
-----Original Message-----
From: Hannes Reinecke [mailto:hare@suse.de]
Subject: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
Hi all,
quite some drivers use internal commands for various purposes, most commonly sending TMFs or querying the HBA status.
While these commands use the same submission mechanism than normal I/O commands, they will not be counted as outstanding commands, requiring those drivers to implement their own mechanism to figure out outstanding commands.
The block layer already has the concept of 'reserved' tags for precisely this purpose, namely non-I/O tags which live off a separate tag pool. That guarantees that these commands can always be sent, and won't be influenced by tag starvation from the I/O tag pool.
This patchset enables the use of reserved tags for the SCSI midlayer by allocating a virtual LUN for the HBA itself which just serves as a resource to allocate valid tags from.
This removes quite some hacks which were required for some drivers (eg. fnic or snic), and allows the use of tagset iterators within the drivers.
The entire patchset can be found at
git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
reserved-tags.v7
Don: Cloned and kernel built. I'll have some test results by end of next week or so...
Thanks,
Don
--
2.29.2
Don:
03/16/2021
Have run a lot of heavy I/O tests. The driver/OS holds together until there are reset operations. The resets do not complete because of 1 patch pending on Martin Peterson's 5.13/scsi-queue tree
f749d8b7a989 scsi: hpsa: Correct dev cmds outstanding for retried cmds
and pending patch
https://patchwork.kernel.org/project/linux-scsi/patch/161540317205.18786.5821926127237311408.stgit@brunhilda/ hpsa: fix regression issue for old controllers
My testing consisted of running 7 operations in parallel using a lot of HBA, LVs, and AIO LVs.
1. mkfs
2. mount
3. rsync to mounted volumes
4. fio to mounted file systems.
5. umount
6. fsck
7. fio to raw disks.
So far, so good, but I need to add in tests that exercise the reserved slots. I'll start that soon after I complete my resulting logfile checks.
Thanks,
Don
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-03-12 16:08 ` Hannes Reinecke
@ 2021-03-17 17:09 ` John Garry
0 siblings, 0 replies; 54+ messages in thread
From: John Garry @ 2021-03-17 17:09 UTC (permalink / raw)
To: Hannes Reinecke, michael.christie, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, linux-scsi
On 12/03/2021 16:08, Hannes Reinecke wrote:
> On 3/12/21 12:53 AM, michael.christie@oracle.com wrote:
>> On 2/22/21 7:23 AM, Hannes Reinecke wrote:
>>> Hi all,
>>>
>>> quite some drivers use internal commands for various purposes, most
>>> commonly sending TMFs or querying the HBA status.
>>> While these commands use the same submission mechanism than normal
>>> I/O commands, they will not be counted as outstanding commands,
>>> requiring those drivers to implement their own mechanism to figure
>>> out outstanding commands.
>>> The block layer already has the concept of 'reserved' tags for
>>> precisely this purpose, namely non-I/O tags which live off a separate
>>> tag pool. That guarantees that these commands can always be sent,
>>> and won't be influenced by tag starvation from the I/O tag pool.
>>> This patchset enables the use of reserved tags for the SCSI midlayer
>>> by allocating a virtual LUN for the HBA itself which just serves
>>> as a resource to allocate valid tags from.
>>> This removes quite some hacks which were required for some
>>> drivers (eg. fnic or snic), and allows the use of tagset
>>> iterators within the drivers.
>>>
>>
>> Hey Hannes,
>>
>> I was trying to port some iscsi patches to this set. One question I had
>> is how to handle if my driver implements init_cmd_priv, and wants to use
>> the reserved cmds for a non scsi IO. My case I want to use them for cmds
>> like a iscsi nop/ping, device/target reset or login request.
>>
>> There is no bit to way to tell if at init_cmd_priv time the cmd will be
>> for a reserved or non reserved cmd right? If not, I was wondering should
>> I do:
If I'm not mistaken, init_cmd_priv has no in-tree user today. Any plans
to add one ... to see what it's about?
Thanks,
John
>>
>> 1. in libiscsi, allocate an array of size $reserved_cmds with non_scsi_cmds
>> structs. When I need to do a non scsi cmd do blk_mq_get_tag on the host's
>> tags to get a reserved tag then use that to lookup a struct in my array?
>>
>> 2. in libiscsi when I need to do a non scsi cmd do a scsi_get_internal_cmd.
>> At this time allocate the non_scsi_cmd struct parts.
>>
> You sure you will need to allocate additional stuff?
> The request already comes with the request, scsi, and driver private
> bits (ie the additional space from .cmd_size) allocated.
>
> And yes, you can tell in init_cmd_priv() if the command is coming from
> the private pool; I had a helper 'req_is_reserved' once, I thought it's
> still there ...
>
> Cheers,
>
> Hannes
>
^ permalink raw reply [flat|nested] 54+ messages in thread
* RE: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
2021-03-16 17:57 ` Don.Brace
@ 2021-03-29 21:47 ` Don.Brace
0 siblings, 0 replies; 54+ messages in thread
From: Don.Brace @ 2021-03-29 21:47 UTC (permalink / raw)
To: hare, martin.petersen; +Cc: james.bottomley, hch, john.garry, linux-scsi
-----Original Message-----
From: Don Brace - C33706
Sent: Tuesday, March 16, 2021 12:58 PM
To: Don Brace - C33706 <Don.Brace@microchip.com>; hare@suse.de; martin.petersen@oracle.com
Cc: james.bottomley@hansenpartnership.com; hch@lst.de; john.garry@huawei.com; linux-scsi@vger.kernel.org
Subject: RE: [PATCHv7 00/31] scsi: enable reserved commands for LLDDs
Hi all,
quite some drivers use internal commands for various purposes, most commonly sending TMFs or querying the HBA status.
While these commands use the same submission mechanism than normal I/O commands, they will not be counted as outstanding commands, requiring those drivers to implement their own mechanism to figure out outstanding commands.
The block layer already has the concept of 'reserved' tags for precisely this purpose, namely non-I/O tags which live off a separate tag pool. That guarantees that these commands can always be sent, and won't be influenced by tag starvation from the I/O tag pool.
This patchset enables the use of reserved tags for the SCSI midlayer by allocating a virtual LUN for the HBA itself which just serves as a resource to allocate valid tags from.
This removes quite some hacks which were required for some drivers (eg. fnic or snic), and allows the use of tagset iterators within the drivers.
The entire patchset can be found at
git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel.git
reserved-tags.v7
Don: Cloned and kernel built. I'll have some test results by end of next week or so...
Thanks,
Don
--
2.29.2
Don:
03/16/2021
Have run a lot of heavy I/O tests. The driver/OS holds together until there are reset operations. The resets do not complete because of 1 patch pending on Martin Peterson's 5.13/scsi-queue tree
f749d8b7a989 scsi: hpsa: Correct dev cmds outstanding for retried cmds and pending patch https://patchwork.kernel.org/project/linux-scsi/patch/161540317205.18786.5821926127237311408.stgit@brunhilda/ hpsa: fix regression issue for old controllers
My testing consisted of running 7 operations in parallel using a lot of HBA, LVs, and AIO LVs.
1. mkfs
2. mount
3. rsync to mounted volumes
4. fio to mounted file systems.
5. umount
6. fsck
7. fio to raw disks.
So far, so good, but I need to add in tests that exercise the reserved slots. I'll start that soon after I complete my resulting logfile checks.
Thanks,
Don
03/29/2021
Don: After applying my patch
commit 6651ea81e097b369ececdc53d1e04bc40955d92a (HEAD -> reserved-tags.v7)
Author: Don Brace <don.brace@microchip.com>
Date: Mon Feb 15 16:26:57 2021 -0600
scsi: hpsa: Correct dev cmds outstanding for retried cmds
I re-ran my Heavy I/O scripts and testing held up.
For the hpsa driver:
Acked-by: Don Brace <don.brace@microchip.com>
Tested-by: Don Brace <don.brace@microchip.com>
^ permalink raw reply [flat|nested] 54+ messages in thread
* Re: [PATCH 14/31] hpsa: use reserved commands
2021-03-11 22:03 ` michael.christie
@ 2021-05-03 9:36 ` Hannes Reinecke
0 siblings, 0 replies; 54+ messages in thread
From: Hannes Reinecke @ 2021-05-03 9:36 UTC (permalink / raw)
To: michael.christie, Martin K. Petersen
Cc: James Bottomley, Christoph Hellwig, John Garry, linux-scsi, Don Brace
On 3/11/21 11:03 PM, michael.christie@oracle.com wrote:
> On 2/22/21 7:23 AM, Hannes Reinecke wrote:
>> -
>> -static struct CommandList *cmd_alloc(struct ctlr_info *h)
>> +static struct CommandList *cmd_alloc(struct ctlr_info *h, u8 direction)
>> {
>> + struct scsi_cmnd *scmd;
>> struct CommandList *c;
>> - int refcount, i;
>> - int offset = 0;
>> -
>> - /*
>> - * There is some *extremely* small but non-zero chance that that
>> - * multiple threads could get in here, and one thread could
>> - * be scanning through the list of bits looking for a free
>> - * one, but the free ones are always behind him, and other
>> - * threads sneak in behind him and eat them before he can
>> - * get to them, so that while there is always a free one, a
>> - * very unlucky thread might be starved anyway, never able to
>> - * beat the other threads. In reality, this happens so
>> - * infrequently as to be indistinguishable from never.
>> - *
>> - * Note that we start allocating commands before the SCSI host structure
>> - * is initialized. Since the search starts at bit zero, this
>> - * all works, since we have at least one command structure available;
>> - * however, it means that the structures with the low indexes have to be
>> - * reserved for driver-initiated requests, while requests from the block
>> - * layer will use the higher indexes.
>> - */
>> -
>> - for (;;) {
>> - i = find_next_zero_bit(h->cmd_pool_bits,
>> - HPSA_NRESERVED_CMDS,
>> - offset);
>> - if (unlikely(i >= HPSA_NRESERVED_CMDS)) {
>> - offset = 0;
>> - continue;
>> - }
>> - c = h->cmd_pool + i;
>> - refcount = atomic_inc_return(&c->refcount);
>> - if (unlikely(refcount > 1)) {
>> - cmd_free(h, c); /* already in use */
>> - offset = (i + 1) % HPSA_NRESERVED_CMDS;
>> - continue;
>> - }
>> - set_bit(i & (BITS_PER_LONG - 1),
>> - h->cmd_pool_bits + (i / BITS_PER_LONG));
>> - break; /* it's ours now. */
>> + int idx;
>> +
>> + scmd = scsi_get_internal_cmd(h->raid_ctrl_sdev,
>> + (direction & XFER_WRITE) ?
>> + DMA_TO_DEVICE : DMA_FROM_DEVICE,
>> + REQ_NOWAIT);
>> + if (!scmd) {
>> + dev_warn(&h->pdev->dev, "failed to allocate reserved cmd\n");
>> + return NULL;
>
> I think in the orig code cmd_alloc would always return a non null pointer.
> It looks like we would always just keep looping.
>
> Now, it looks like we could fail from the above code where we return NULL.
> I was not sure if it's maybe impossible to hit the "return NULL" becuase we
> only call this function when we know there will be a cmd availale. If we
> can fail then the cmd_alloc callers should check for NULL now I think.
>
Yes, that's indeed the case with this patch.
But seeing that the original code would spin until a tag becomes
available we can drop the REQ_NOWAIT flags and should get roughly the
same behaviour as we have now.
Will be updating the patch.
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
hare@suse.de +49 911 74053 688
SUSE Software Solutions Germany GmbH, Maxfeldstr. 5, 90409 Nürnberg
HRB 36809 (AG Nürnberg), GF: Felix Imendörffer
^ permalink raw reply [flat|nested] 54+ messages in thread
end of thread, other threads:[~2021-05-03 9:36 UTC | newest]
Thread overview: 54+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-02-22 13:23 [PATCHv7 00/31] scsi: enable reserved commands for LLDDs Hannes Reinecke
2021-02-22 13:23 ` [PATCH 01/31] block: add flag for internal commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 02/31] scsi: add scsi_{get,put}_internal_cmd() helper Hannes Reinecke
2021-02-24 12:12 ` John Garry
2021-02-22 13:23 ` [PATCH 03/31] fnic: use internal commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 04/31] fnic: use scsi_host_busy_iter() to traverse commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 05/31] fnic: check for started requests in fnic_wq_copy_cleanup_handler() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 06/31] scsi: use real inquiry data when initialising devices Hannes Reinecke
2021-02-22 13:23 ` [PATCH 07/31] scsi: Use dummy inquiry data for the host device Hannes Reinecke
2021-02-22 13:23 ` [PATCH 08/31] scsi: revamp host device handling Hannes Reinecke
2021-02-24 13:12 ` John Garry
2021-02-24 14:24 ` Hannes Reinecke
2021-02-24 14:31 ` John Garry
2021-02-24 14:35 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 09/31] snic: use reserved commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 10/31] snic: use tagset iter for traversing commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 11/31] snic: check for started requests in snic_hba_reset_cmpl_handler() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 12/31] scsi: implement reserved command handling Hannes Reinecke
2021-02-22 13:23 ` [PATCH 13/31] hpsa: move hpsa_hba_inquiry after scsi_add_host() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 14/31] hpsa: use reserved commands Hannes Reinecke
2021-03-11 22:03 ` michael.christie
2021-05-03 9:36 ` Hannes Reinecke
2021-02-22 13:23 ` [PATCH 15/31] hpsa: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 16/31] hpsa: drop refcount field from CommandList Hannes Reinecke
2021-02-22 13:23 ` [PATCH 17/31] aacraid: move scsi_add_host() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 18/31] aacraid: store target id in host_scribble Hannes Reinecke
2021-02-22 13:23 ` [PATCH 19/31] aacraid: use scsi_get_internal_cmd() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 20/31] aacraid: use scsi_host_busy_iter() to traverse outstanding commands Hannes Reinecke
2021-02-22 13:23 ` [PATCH 21/31] mv_sas: kill mvsas_debug_issue_ssp_tmf() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 22/31] pm8001: kill pm8001_issue_ssp_tmf() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 23/31] pm8001: kill 'dev' argument from pm8001_exec_internal_task_abort() Hannes Reinecke
2021-02-22 13:23 ` [PATCH 24/31] pm8001: use libsas-provided domain devices for SATA Hannes Reinecke
2021-02-22 13:23 ` [PATCH 25/31] libsas: add SCSI target pointer to struct domain_device Hannes Reinecke
2021-02-22 13:24 ` [PATCH 26/31] scsi: libsas,hisi_sas,mvsas,pm8001: Allocate Scsi_cmd for slow task Hannes Reinecke
2021-03-09 11:22 ` luojiaxing
2021-03-09 14:05 ` John Garry
2021-03-11 8:51 ` luojiaxing
2021-02-22 13:24 ` [PATCH 27/31] libsas: add tag to struct sas_task Hannes Reinecke
2021-02-22 13:24 ` [PATCH 28/31] scsi: hisi_sas: Use libsas slow task SCSI command Hannes Reinecke
2021-02-22 13:24 ` [PATCH 29/31] hisi_sas: use task tag to reference the slot Hannes Reinecke
2021-03-10 1:54 ` luojiaxing
2021-02-22 13:24 ` [PATCH 30/31] mv_sas: use reserved tags and drop private tag allocation Hannes Reinecke
2021-02-22 13:24 ` [PATCH 31/31] pm8001: use block-layer tags for ccb allocation Hannes Reinecke
2021-02-23 12:31 ` John Garry
2021-02-23 10:16 ` [PATCHv7 00/31] scsi: enable reserved commands for LLDDs John Garry
2021-02-23 17:50 ` John Garry
2021-02-24 6:54 ` Hannes Reinecke
2021-02-24 8:55 ` John Garry
2021-03-06 15:11 ` Don.Brace
2021-03-16 17:57 ` Don.Brace
2021-03-29 21:47 ` Don.Brace
2021-03-11 23:53 ` michael.christie
2021-03-12 16:08 ` Hannes Reinecke
2021-03-17 17:09 ` John Garry
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.