2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2014-01-17 11:06:53 +00:00
|
|
|
* Copyright (C) 1999 Eric Youngdale
|
|
|
|
* Copyright (C) 2014 Christoph Hellwig
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* SCSI queueing library.
|
|
|
|
* Initial versions: Eric Youngdale (eric@andante.org).
|
|
|
|
* Based upon conversations with large numbers
|
|
|
|
* of people at Linux Expo.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/bio.h>
|
2008-01-15 17:11:46 +00:00
|
|
|
#include <linux/bitops.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/kernel.h>
|
2011-05-27 13:37:25 +00:00
|
|
|
#include <linux/export.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/delay.h>
|
2006-02-14 16:42:07 +00:00
|
|
|
#include <linux/hardirq.h>
|
2007-10-16 09:08:49 +00:00
|
|
|
#include <linux/scatterlist.h>
|
2014-01-17 11:06:53 +00:00
|
|
|
#include <linux/blk-mq.h>
|
2014-10-24 12:27:07 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2015-12-01 09:16:57 +00:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <scsi/scsi.h>
|
2006-06-10 16:01:03 +00:00
|
|
|
#include <scsi/scsi_cmnd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <scsi/scsi_dbg.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_driver.h>
|
|
|
|
#include <scsi/scsi_eh.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
2017-05-02 17:45:03 +00:00
|
|
|
#include <scsi/scsi_transport.h> /* __scsi_init_queue() */
|
2015-08-27 12:16:59 +00:00
|
|
|
#include <scsi/scsi_dh.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-06 10:25:40 +00:00
|
|
|
#include <trace/events/scsi.h>
|
|
|
|
|
2017-04-26 20:47:57 +00:00
|
|
|
#include "scsi_debugfs.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "scsi_priv.h"
|
|
|
|
#include "scsi_logging.h"
|
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
static struct kmem_cache *scsi_sdb_cache;
|
2017-01-03 05:28:41 +00:00
|
|
|
static struct kmem_cache *scsi_sense_cache;
|
|
|
|
static struct kmem_cache *scsi_sense_isadma_cache;
|
|
|
|
static DEFINE_MUTEX(scsi_sense_cache_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-08-30 23:58:42 +00:00
|
|
|
static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd);
|
|
|
|
|
2017-01-03 05:28:41 +00:00
|
|
|
static inline struct kmem_cache *
|
2017-06-02 21:21:52 +00:00
|
|
|
scsi_select_sense_cache(bool unchecked_isa_dma)
|
2017-01-03 05:28:41 +00:00
|
|
|
{
|
2017-06-02 21:21:52 +00:00
|
|
|
return unchecked_isa_dma ? scsi_sense_isadma_cache : scsi_sense_cache;
|
2017-01-03 05:28:41 +00:00
|
|
|
}
|
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
static void scsi_free_sense_buffer(bool unchecked_isa_dma,
|
|
|
|
unsigned char *sense_buffer)
|
2017-01-03 05:28:41 +00:00
|
|
|
{
|
2017-06-02 21:21:52 +00:00
|
|
|
kmem_cache_free(scsi_select_sense_cache(unchecked_isa_dma),
|
|
|
|
sense_buffer);
|
2017-01-03 05:28:41 +00:00
|
|
|
}
|
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
static unsigned char *scsi_alloc_sense_buffer(bool unchecked_isa_dma,
|
2017-01-02 18:55:26 +00:00
|
|
|
gfp_t gfp_mask, int numa_node)
|
2017-01-03 05:28:41 +00:00
|
|
|
{
|
2017-06-02 21:21:52 +00:00
|
|
|
return kmem_cache_alloc_node(scsi_select_sense_cache(unchecked_isa_dma),
|
|
|
|
gfp_mask, numa_node);
|
2017-01-03 05:28:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int scsi_init_sense_cache(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct kmem_cache *cache;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
cache = scsi_select_sense_cache(shost->unchecked_isa_dma);
|
2017-01-03 05:28:41 +00:00
|
|
|
if (cache)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mutex_lock(&scsi_sense_cache_mutex);
|
|
|
|
if (shost->unchecked_isa_dma) {
|
|
|
|
scsi_sense_isadma_cache =
|
|
|
|
kmem_cache_create("scsi_sense_cache(DMA)",
|
|
|
|
SCSI_SENSE_BUFFERSIZE, 0,
|
|
|
|
SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA, NULL);
|
|
|
|
if (!scsi_sense_isadma_cache)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
} else {
|
|
|
|
scsi_sense_cache =
|
|
|
|
kmem_cache_create("scsi_sense_cache",
|
|
|
|
SCSI_SENSE_BUFFERSIZE, 0, SLAB_HWCACHE_ALIGN, NULL);
|
|
|
|
if (!scsi_sense_cache)
|
|
|
|
ret = -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&scsi_sense_cache_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-12-13 11:50:53 +00:00
|
|
|
|
2010-04-16 19:13:15 +00:00
|
|
|
/*
|
|
|
|
* When to reinvoke queueing after a resource shortage. It's 3 msecs to
|
|
|
|
* not change behaviour from the previous unplug mechanism, experimentation
|
|
|
|
* may prove this needs changing.
|
|
|
|
*/
|
|
|
|
#define SCSI_QUEUE_DELAY 3
|
|
|
|
|
2014-01-23 12:55:38 +00:00
|
|
|
static void
|
|
|
|
scsi_set_blocked(struct scsi_cmnd *cmd, int reason)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
|
|
|
struct scsi_device *device = cmd->device;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
struct scsi_target *starget = scsi_target(device);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2005-05-13 15:46:08 +00:00
|
|
|
* Set the appropriate busy bit for the device/host.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* If the host/device isn't busy, assume that something actually
|
|
|
|
* completed, and that we should be able to queue a command now.
|
|
|
|
*
|
|
|
|
* Note that the prior mid-layer assumption that any host could
|
|
|
|
* always queue at least one command is now broken. The mid-layer
|
|
|
|
* will implement a user specifiable stall (see
|
|
|
|
* scsi_host.max_host_blocked and scsi_device.max_device_blocked)
|
|
|
|
* if a command is requeued with no other commands outstanding
|
|
|
|
* either for the device or for the host.
|
|
|
|
*/
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
switch (reason) {
|
|
|
|
case SCSI_MLQUEUE_HOST_BUSY:
|
2014-01-23 11:07:41 +00:00
|
|
|
atomic_set(&host->host_blocked, host->max_host_blocked);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
break;
|
|
|
|
case SCSI_MLQUEUE_DEVICE_BUSY:
|
[SCSI] scsi_lib: pause between error retries
During cable pull tests on our 16G FC adapter, we are seeing errors,
typically reads to close targets, which fail due to CRC or framing
errors caused by the cable being pull (return status DID_ERROR).
The adapter detects the error on one of the first frames received,
marks the FC exchange as dead (further frames go to bit bucket) and
signals the host of the error. This action is so quick, and coupled
with fast host CPUs, creates a scenario in which the midlayer sees
the failure and retries the io almost immediately. We've seen link
traces with the retry on the link while the original i/o is still
being processed by the target. We're also seeing the time window
for the "link to pull-apart" and the physical interface to report
disconnected to be in the few millisecond range. Which means, we're
encountering scenarios where the full retry count is exhausted
(all with error) by the midlayer before the link disconnect state
is detected.
We looked at 8G FC behavior and occasionally see the same behavior,
but as the link was slower, it rarely could exhaust all retries
before the link reported disconnect.
What is needed is a slight delay between io retries due to DID_ERROR
to cover this error. It is inappropriate to put this delay in the
driver, as the error is indistinguishable from other link-related errors,
nor does the driver track whether the io is a retry or not. This is also
easier than tracking between-io-error bursts that are seen in this
scenario.
The patch below updates the retry path so that it inserts a delay as
if the target was busy. The busy delay is on the order of 6ms. This
delay is sufficient to ensure the link down condition is reported
before the retry count is exhausted (at most 1 retry is seen).
Signed-off-by: Alex Iannicelli <alex.iannicelli@emulex.com>
Signed-off-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2011-07-06 16:45:17 +00:00
|
|
|
case SCSI_MLQUEUE_EH_RETRY:
|
2014-01-23 11:07:41 +00:00
|
|
|
atomic_set(&device->device_blocked,
|
|
|
|
device->max_device_blocked);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
break;
|
|
|
|
case SCSI_MLQUEUE_TARGET_BUSY:
|
2014-01-23 11:07:41 +00:00
|
|
|
atomic_set(&starget->target_blocked,
|
|
|
|
starget->max_target_blocked);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-01-23 12:55:38 +00:00
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
static void scsi_mq_requeue_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = cmd->device;
|
|
|
|
|
2017-08-30 23:58:42 +00:00
|
|
|
if (cmd->request->rq_flags & RQF_DONTPREP) {
|
|
|
|
cmd->request->rq_flags &= ~RQF_DONTPREP;
|
|
|
|
scsi_mq_uninit_cmd(cmd);
|
|
|
|
} else {
|
|
|
|
WARN_ON_ONCE(true);
|
|
|
|
}
|
2016-10-29 00:21:41 +00:00
|
|
|
blk_mq_requeue_request(cmd->request, true);
|
2014-01-17 11:06:53 +00:00
|
|
|
put_device(&sdev->sdev_gendev);
|
|
|
|
}
|
|
|
|
|
2014-01-23 12:55:38 +00:00
|
|
|
/**
|
|
|
|
* __scsi_queue_insert - private queue insertion
|
|
|
|
* @cmd: The SCSI command being requeued
|
|
|
|
* @reason: The reason for the requeue
|
|
|
|
* @unbusy: Whether the queue should be unbusied
|
|
|
|
*
|
|
|
|
* This is a private queue insertion. The public interface
|
|
|
|
* scsi_queue_insert() always assumes the queue should be unbusied
|
|
|
|
* because it's always called before the completion. This function is
|
|
|
|
* for a requeue after completion, which should only occur in this
|
|
|
|
* file.
|
|
|
|
*/
|
|
|
|
static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
|
|
|
|
{
|
|
|
|
struct scsi_device *device = cmd->device;
|
|
|
|
struct request_queue *q = device->request_queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd,
|
|
|
|
"Inserting command %p into mlqueue\n", cmd));
|
|
|
|
|
|
|
|
scsi_set_blocked(cmd, reason);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement the counters, since these commands are no longer
|
|
|
|
* active on the host/device.
|
|
|
|
*/
|
2009-01-02 16:42:21 +00:00
|
|
|
if (unbusy)
|
|
|
|
scsi_device_unbusy(device);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2005-04-24 07:08:52 +00:00
|
|
|
* Requeue this command. It will go before all other commands
|
2012-06-29 15:36:07 +00:00
|
|
|
* that are already in the queue. Schedule requeue work under
|
|
|
|
* lock such that the kblockd_schedule_work() call happens
|
|
|
|
* before blk_cleanup_queue() finishes.
|
2010-04-16 19:13:15 +00:00
|
|
|
*/
|
2014-03-28 17:51:15 +00:00
|
|
|
cmd->result = 0;
|
2014-01-17 11:06:53 +00:00
|
|
|
if (q->mq_ops) {
|
|
|
|
scsi_mq_requeue_cmd(cmd);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-24 07:08:52 +00:00
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
[SCSI] fix sym scsi boot hang
On Wed, 2005-09-14 at 18:06 +1000, Anton Blanchard wrote:
> And in particular it looks like the scsi_unprep_request in
> scsi_queue_insert is causing it. The following patch fixes the boot
> problems on the vscsi machine:
OK, my fault. Your fix is almost correct .. I was going to do this
eventually, honest, because there's no need to unprep and reprep a
command that comes in through scsi_queue_insert().
However, I decided to leave it in to exercise the scsi_unprep_request()
path just to make sure it was working. What's happening, I think, is
that we also use this path for retries. Since we kill and reget the
command each time, the retries decrement is never seen, so we're
retrying forever.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-09-14 16:57:42 +00:00
|
|
|
blk_requeue_request(q, cmd->request);
|
2014-04-08 15:15:35 +00:00
|
|
|
kblockd_schedule_work(&device->requeue_work);
|
2012-06-29 15:36:07 +00:00
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-02 16:42:21 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_queue_insert()
|
|
|
|
*
|
|
|
|
* Purpose: Insert a command in the midlevel queue.
|
|
|
|
*
|
|
|
|
* Arguments: cmd - command that we are adding to queue.
|
|
|
|
* reason - why we are inserting command to queue.
|
|
|
|
*
|
|
|
|
* Lock status: Assumed that lock is not held upon entry.
|
|
|
|
*
|
|
|
|
* Returns: Nothing.
|
|
|
|
*
|
|
|
|
* Notes: We do this for one of two cases. Either the host is busy
|
|
|
|
* and it cannot accept any more commands for the time being,
|
|
|
|
* or the device returned QUEUE_FULL and can accept no more
|
|
|
|
* commands.
|
|
|
|
* Notes: This could be called either from an interrupt context or a
|
|
|
|
* normal process context.
|
|
|
|
*/
|
2012-06-29 15:35:05 +00:00
|
|
|
void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
|
2009-01-02 16:42:21 +00:00
|
|
|
{
|
2012-06-29 15:35:05 +00:00
|
|
|
__scsi_queue_insert(cmd, reason, 1);
|
2009-01-02 16:42:21 +00:00
|
|
|
}
|
2016-10-20 13:12:13 +00:00
|
|
|
|
2017-02-23 15:02:36 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_execute - insert request and wait for the result
|
|
|
|
* @sdev: scsi device
|
|
|
|
* @cmd: scsi command
|
|
|
|
* @data_direction: data direction
|
|
|
|
* @buffer: data buffer
|
|
|
|
* @bufflen: len of buffer
|
|
|
|
* @sense: optional sense buffer
|
|
|
|
* @sshdr: optional decoded sense header
|
|
|
|
* @timeout: request timeout in seconds
|
|
|
|
* @retries: number of times to retry request
|
|
|
|
* @flags: flags for ->cmd_flags
|
|
|
|
* @rq_flags: flags for ->rq_flags
|
|
|
|
* @resid: optional residual length
|
|
|
|
*
|
2017-04-20 14:03:01 +00:00
|
|
|
* Returns the scsi_cmnd result field if a command was executed, or a negative
|
|
|
|
* Linux error code if we didn't get that far.
|
2017-02-23 15:02:36 +00:00
|
|
|
*/
|
|
|
|
int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
|
2005-08-28 16:31:14 +00:00
|
|
|
int data_direction, void *buffer, unsigned bufflen,
|
2017-02-14 19:15:58 +00:00
|
|
|
unsigned char *sense, struct scsi_sense_hdr *sshdr,
|
|
|
|
int timeout, int retries, u64 flags, req_flags_t rq_flags,
|
|
|
|
int *resid)
|
2005-06-15 23:48:29 +00:00
|
|
|
{
|
|
|
|
struct request *req;
|
2017-01-27 08:46:29 +00:00
|
|
|
struct scsi_request *rq;
|
2005-06-15 23:48:29 +00:00
|
|
|
int ret = DRIVER_ERROR << 24;
|
|
|
|
|
2017-01-31 15:57:31 +00:00
|
|
|
req = blk_get_request(sdev->request_queue,
|
|
|
|
data_direction == DMA_TO_DEVICE ?
|
|
|
|
REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, __GFP_RECLAIM);
|
2014-08-28 14:15:21 +00:00
|
|
|
if (IS_ERR(req))
|
2011-07-07 20:45:40 +00:00
|
|
|
return ret;
|
2017-01-27 08:46:29 +00:00
|
|
|
rq = scsi_req(req);
|
2005-06-15 23:48:29 +00:00
|
|
|
|
|
|
|
if (bufflen && blk_rq_map_kern(sdev->request_queue, req,
|
2015-11-07 00:28:28 +00:00
|
|
|
buffer, bufflen, __GFP_RECLAIM))
|
2005-06-15 23:48:29 +00:00
|
|
|
goto out;
|
|
|
|
|
2017-01-27 08:46:29 +00:00
|
|
|
rq->cmd_len = COMMAND_SIZE(cmd[0]);
|
|
|
|
memcpy(rq->cmd, cmd, rq->cmd_len);
|
2017-04-05 17:18:12 +00:00
|
|
|
rq->retries = retries;
|
2005-06-15 23:48:29 +00:00
|
|
|
req->timeout = timeout;
|
2016-10-20 13:12:13 +00:00
|
|
|
req->cmd_flags |= flags;
|
|
|
|
req->rq_flags |= rq_flags | RQF_QUIET | RQF_PREEMPT;
|
2005-06-15 23:48:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* head injection *required* here otherwise quiesce won't work
|
|
|
|
*/
|
|
|
|
blk_execute_rq(req->q, NULL, req, 1);
|
|
|
|
|
2008-06-24 18:03:14 +00:00
|
|
|
/*
|
|
|
|
* Some devices (USB mass-storage in particular) may transfer
|
|
|
|
* garbage data together with a residue indicating that the data
|
|
|
|
* is invalid. Prevent the garbage from being misinterpreted
|
|
|
|
* and prevent security leaks by zeroing out the excess data.
|
|
|
|
*/
|
2017-01-27 08:46:29 +00:00
|
|
|
if (unlikely(rq->resid_len > 0 && rq->resid_len <= bufflen))
|
|
|
|
memset(buffer + (bufflen - rq->resid_len), 0, rq->resid_len);
|
2008-06-24 18:03:14 +00:00
|
|
|
|
2008-12-04 05:24:39 +00:00
|
|
|
if (resid)
|
2017-01-27 08:46:29 +00:00
|
|
|
*resid = rq->resid_len;
|
|
|
|
if (sense && rq->sense_len)
|
|
|
|
memcpy(sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
|
2017-02-14 19:15:58 +00:00
|
|
|
if (sshdr)
|
|
|
|
scsi_normalize_sense(rq->sense, rq->sense_len, sshdr);
|
2017-04-20 14:03:01 +00:00
|
|
|
ret = rq->result;
|
2005-06-15 23:48:29 +00:00
|
|
|
out:
|
|
|
|
blk_put_request(req);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2005-08-28 16:31:14 +00:00
|
|
|
EXPORT_SYMBOL(scsi_execute);
|
2005-06-15 23:48:29 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_init_cmd_errh()
|
|
|
|
*
|
|
|
|
* Purpose: Initialize cmd fields related to error handling.
|
|
|
|
*
|
|
|
|
* Arguments: cmd - command that is ready to be queued.
|
|
|
|
*
|
|
|
|
* Notes: This function has the job of initializing a number of
|
|
|
|
* fields related to error handling. Typically this will
|
|
|
|
* be called once for each command, as required.
|
|
|
|
*/
|
2006-07-08 18:42:15 +00:00
|
|
|
static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
cmd->serial_number = 0;
|
2007-12-13 11:47:40 +00:00
|
|
|
scsi_set_resid(cmd, 0);
|
2008-01-13 06:46:13 +00:00
|
|
|
memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (cmd->cmd_len == 0)
|
2008-04-30 08:27:26 +00:00
|
|
|
cmd->cmd_len = scsi_command_size(cmd->cmnd);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void scsi_device_unbusy(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
struct scsi_target *starget = scsi_target(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-01-22 14:29:29 +00:00
|
|
|
atomic_dec(&shost->host_busy);
|
2014-03-26 09:35:00 +00:00
|
|
|
if (starget->can_queue > 0)
|
|
|
|
atomic_dec(&starget->target_busy);
|
2014-01-22 14:29:29 +00:00
|
|
|
|
2005-09-18 20:05:20 +00:00
|
|
|
if (unlikely(scsi_host_in_recovery(shost) &&
|
2014-01-22 14:29:29 +00:00
|
|
|
(shost->host_failed || shost->host_eh_scheduled))) {
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_eh_wakeup(shost);
|
2014-01-22 14:29:29 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-04-11 17:07:01 +00:00
|
|
|
atomic_dec(&sdev->device_busy);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
static void scsi_kick_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
if (q->mq_ops)
|
|
|
|
blk_mq_start_hw_queues(q);
|
|
|
|
else
|
|
|
|
blk_run_queue(q);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Called for single_lun devices on IO completion. Clear starget_sdev_user,
|
|
|
|
* and call blk_run_queue for all the scsi_devices on the target -
|
|
|
|
* including current_sdev first.
|
|
|
|
*
|
|
|
|
* Called with *no* scsi locks held.
|
|
|
|
*/
|
|
|
|
static void scsi_single_lun_run(struct scsi_device *current_sdev)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = current_sdev->host;
|
|
|
|
struct scsi_device *sdev, *tmp;
|
|
|
|
struct scsi_target *starget = scsi_target(current_sdev);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
starget->starget_sdev_user = NULL;
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call blk_run_queue for all LUNs on the target, starting with
|
|
|
|
* current_sdev. We race with others (to set starget_sdev_user),
|
|
|
|
* but in most cases, we will be first. Ideally, each LU on the
|
|
|
|
* target would get some limited time or requests on the target.
|
|
|
|
*/
|
2014-01-17 11:06:53 +00:00
|
|
|
scsi_kick_queue(current_sdev->request_queue);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
if (starget->starget_sdev_user)
|
|
|
|
goto out;
|
|
|
|
list_for_each_entry_safe(sdev, tmp, &starget->devices,
|
|
|
|
same_target_siblings) {
|
|
|
|
if (sdev == current_sdev)
|
|
|
|
continue;
|
|
|
|
if (scsi_device_get(sdev))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2014-01-17 11:06:53 +00:00
|
|
|
scsi_kick_queue(sdev->request_queue);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
|
|
|
|
scsi_device_put(sdev);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:07:41 +00:00
|
|
|
static inline bool scsi_device_is_busy(struct scsi_device *sdev)
|
2008-10-04 18:11:06 +00:00
|
|
|
{
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_read(&sdev->device_busy) >= sdev->queue_depth)
|
|
|
|
return true;
|
|
|
|
if (atomic_read(&sdev->device_blocked) > 0)
|
|
|
|
return true;
|
|
|
|
return false;
|
2008-10-04 18:11:06 +00:00
|
|
|
}
|
|
|
|
|
2014-01-23 11:07:41 +00:00
|
|
|
static inline bool scsi_target_is_busy(struct scsi_target *starget)
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
{
|
2014-03-26 09:35:00 +00:00
|
|
|
if (starget->can_queue > 0) {
|
|
|
|
if (atomic_read(&starget->target_busy) >= starget->can_queue)
|
|
|
|
return true;
|
|
|
|
if (atomic_read(&starget->target_blocked) > 0)
|
|
|
|
return true;
|
|
|
|
}
|
2014-01-23 11:07:41 +00:00
|
|
|
return false;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
}
|
|
|
|
|
2014-01-23 11:07:41 +00:00
|
|
|
static inline bool scsi_host_is_busy(struct Scsi_Host *shost)
|
2008-10-04 18:11:06 +00:00
|
|
|
{
|
2014-01-23 11:07:41 +00:00
|
|
|
if (shost->can_queue > 0 &&
|
|
|
|
atomic_read(&shost->host_busy) >= shost->can_queue)
|
|
|
|
return true;
|
|
|
|
if (atomic_read(&shost->host_blocked) > 0)
|
|
|
|
return true;
|
|
|
|
if (shost->host_self_blocked)
|
|
|
|
return true;
|
|
|
|
return false;
|
2008-10-04 18:11:06 +00:00
|
|
|
}
|
|
|
|
|
2014-02-20 22:20:54 +00:00
|
|
|
static void scsi_starved_list_run(struct Scsi_Host *shost)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-11-11 19:42:35 +00:00
|
|
|
LIST_HEAD(starved_list);
|
2014-02-20 22:20:54 +00:00
|
|
|
struct scsi_device *sdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2008-11-11 19:42:35 +00:00
|
|
|
list_splice_init(&shost->starved_list, &starved_list);
|
|
|
|
|
|
|
|
while (!list_empty(&starved_list)) {
|
2013-07-02 13:05:26 +00:00
|
|
|
struct request_queue *slq;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* As long as shost is accepting commands and we have
|
|
|
|
* starved queues, call blk_run_queue. scsi_request_fn
|
|
|
|
* drops the queue_lock and can add us back to the
|
|
|
|
* starved_list.
|
|
|
|
*
|
|
|
|
* host_lock protects the starved_list and starved_entry.
|
|
|
|
* scsi_request_fn must get the host_lock before checking
|
|
|
|
* or modifying starved_list or starved_entry.
|
|
|
|
*/
|
2008-11-11 19:42:35 +00:00
|
|
|
if (scsi_host_is_busy(shost))
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
break;
|
|
|
|
|
2008-11-11 19:42:35 +00:00
|
|
|
sdev = list_entry(starved_list.next,
|
|
|
|
struct scsi_device, starved_entry);
|
|
|
|
list_del_init(&sdev->starved_entry);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
if (scsi_target_is_busy(scsi_target(sdev))) {
|
|
|
|
list_move_tail(&sdev->starved_entry,
|
|
|
|
&shost->starved_list);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-07-02 13:05:26 +00:00
|
|
|
/*
|
|
|
|
* Once we drop the host lock, a racing scsi_remove_device()
|
|
|
|
* call may remove the sdev from the starved list and destroy
|
|
|
|
* it and the queue. Mitigate by taking a reference to the
|
|
|
|
* queue and never touching the sdev again after we drop the
|
|
|
|
* host lock. Note: if __scsi_remove_device() invokes
|
|
|
|
* blk_cleanup_queue() before the queue is run from this
|
|
|
|
* function then blk_run_queue() will return immediately since
|
|
|
|
* blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
|
|
|
|
*/
|
|
|
|
slq = sdev->request_queue;
|
|
|
|
if (!blk_get_queue(slq))
|
|
|
|
continue;
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
scsi_kick_queue(slq);
|
2013-07-02 13:05:26 +00:00
|
|
|
blk_put_queue(slq);
|
|
|
|
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-11-11 19:42:35 +00:00
|
|
|
/* put any unprocessed entries back */
|
|
|
|
list_splice(&starved_list, &shost->starved_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2014-02-20 22:20:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_run_queue()
|
|
|
|
*
|
|
|
|
* Purpose: Select a proper request queue to serve next
|
|
|
|
*
|
|
|
|
* Arguments: q - last request's queue
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Notes: The previous command was completely finished, start
|
|
|
|
* a new one if possible.
|
|
|
|
*/
|
|
|
|
static void scsi_run_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
|
|
|
|
|
|
|
if (scsi_target(sdev)->single_lun)
|
|
|
|
scsi_single_lun_run(sdev);
|
|
|
|
if (!list_empty(&sdev->host->starved_list))
|
|
|
|
scsi_starved_list_run(sdev->host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
if (q->mq_ops)
|
2017-04-07 18:16:53 +00:00
|
|
|
blk_mq_run_hw_queues(q, false);
|
2014-01-17 11:06:53 +00:00
|
|
|
else
|
|
|
|
blk_run_queue(q);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-05-17 09:04:44 +00:00
|
|
|
void scsi_requeue_run_queue(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct request_queue *q;
|
|
|
|
|
|
|
|
sdev = container_of(work, struct scsi_device, requeue_work);
|
|
|
|
q = sdev->request_queue;
|
|
|
|
scsi_run_queue(q);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_requeue_command()
|
|
|
|
*
|
|
|
|
* Purpose: Handle post-processing of completed commands.
|
|
|
|
*
|
|
|
|
* Arguments: q - queue to operate on
|
|
|
|
* cmd - command that may need to be requeued.
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Notes: After command completion, there may be blocks left
|
|
|
|
* over which weren't finished by the previous command
|
|
|
|
* this can be for a number of reasons - the main one is
|
|
|
|
* I/O errors in the middle of the request, in which case
|
|
|
|
* we need to request the blocks that come after the bad
|
|
|
|
* sector.
|
2005-09-09 15:44:16 +00:00
|
|
|
* Notes: Upon return, cmd is a stale pointer.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd)
|
|
|
|
{
|
2012-06-29 15:34:26 +00:00
|
|
|
struct scsi_device *sdev = cmd->device;
|
2005-09-09 15:44:16 +00:00
|
|
|
struct request *req = cmd->request;
|
2005-04-24 07:06:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
2014-02-20 22:20:58 +00:00
|
|
|
blk_unprep_request(req);
|
|
|
|
req->special = NULL;
|
|
|
|
scsi_put_command(cmd);
|
2005-09-09 15:44:16 +00:00
|
|
|
blk_requeue_request(q, req);
|
2005-04-24 07:06:36 +00:00
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
scsi_run_queue(q);
|
2012-06-29 15:34:26 +00:00
|
|
|
|
|
|
|
put_device(&sdev->sdev_gendev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void scsi_run_host_queues(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
|
|
|
|
shost_for_each_device(sdev, shost)
|
|
|
|
scsi_run_queue(sdev->request_queue);
|
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
static void scsi_uninit_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
2017-01-31 15:57:29 +00:00
|
|
|
if (!blk_rq_is_passthrough(cmd->request)) {
|
2014-01-17 11:06:53 +00:00
|
|
|
struct scsi_driver *drv = scsi_cmd_to_driver(cmd);
|
|
|
|
|
|
|
|
if (drv->uninit_command)
|
|
|
|
drv->uninit_command(cmd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_mq_free_sgtables(struct scsi_cmnd *cmd)
|
|
|
|
{
|
2016-04-04 21:48:07 +00:00
|
|
|
struct scsi_data_buffer *sdb;
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
if (cmd->sdb.table.nents)
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&cmd->sdb.table, true);
|
2016-04-04 21:48:07 +00:00
|
|
|
if (cmd->request->next_rq) {
|
|
|
|
sdb = cmd->request->next_rq->special;
|
|
|
|
if (sdb)
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&sdb->table, true);
|
2016-04-04 21:48:07 +00:00
|
|
|
}
|
2014-01-17 11:06:53 +00:00
|
|
|
if (scsi_prot_sg_count(cmd))
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&cmd->prot_sdb->table, true);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
scsi_mq_free_sgtables(cmd);
|
|
|
|
scsi_uninit_cmd(cmd);
|
2017-06-02 21:21:58 +00:00
|
|
|
scsi_del_cmd_from_list(cmd);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_release_buffers()
|
|
|
|
*
|
2014-05-01 14:51:02 +00:00
|
|
|
* Purpose: Free resources allocate for a scsi_command.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Arguments: cmd - command that we are bailing.
|
|
|
|
*
|
|
|
|
* Lock status: Assumed that no lock is held upon entry.
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Notes: In the event that an upper level driver rejects a
|
|
|
|
* command, we must release resources allocated during
|
|
|
|
* the __init_io() function. Primarily this would involve
|
2014-05-01 14:51:02 +00:00
|
|
|
* the scatter-gather table.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-04-15 10:26:54 +00:00
|
|
|
static void scsi_release_buffers(struct scsi_cmnd *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-05-01 14:51:02 +00:00
|
|
|
if (cmd->sdb.table.nents)
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&cmd->sdb.table, false);
|
2014-05-01 14:51:02 +00:00
|
|
|
|
|
|
|
memset(&cmd->sdb, 0, sizeof(cmd->sdb));
|
|
|
|
|
|
|
|
if (scsi_prot_sg_count(cmd))
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&cmd->prot_sdb->table, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-05-01 14:51:02 +00:00
|
|
|
static void scsi_release_bidi_buffers(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct scsi_data_buffer *bidi_sdb = cmd->request->next_rq->special;
|
|
|
|
|
2016-04-04 21:48:09 +00:00
|
|
|
sg_free_table_chained(&bidi_sdb->table, false);
|
2014-05-01 14:51:02 +00:00
|
|
|
kmem_cache_free(scsi_sdb_cache, bidi_sdb);
|
|
|
|
cmd->request->next_rq->special = NULL;
|
|
|
|
}
|
|
|
|
|
2017-06-03 07:38:04 +00:00
|
|
|
static bool scsi_end_request(struct request *req, blk_status_t error,
|
2014-02-16 14:16:13 +00:00
|
|
|
unsigned int bytes, unsigned int bidi_bytes)
|
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2014-02-16 14:16:13 +00:00
|
|
|
struct scsi_device *sdev = cmd->device;
|
|
|
|
struct request_queue *q = sdev->request_queue;
|
|
|
|
|
|
|
|
if (blk_update_request(req, error, bytes))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Bidi request must be completed as a whole */
|
|
|
|
if (unlikely(bidi_bytes) &&
|
|
|
|
blk_update_request(req->next_rq, error, bidi_bytes))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (blk_queue_add_random(q))
|
|
|
|
add_disk_randomness(req->rq_disk);
|
|
|
|
|
2017-08-30 23:58:39 +00:00
|
|
|
if (!blk_rq_is_scsi(req)) {
|
|
|
|
WARN_ON_ONCE(!(cmd->flags & SCMD_INITIALIZED));
|
|
|
|
cmd->flags &= ~SCMD_INITIALIZED;
|
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
if (req->mq_ctx) {
|
|
|
|
/*
|
2014-09-13 23:40:10 +00:00
|
|
|
* In the MQ case the command gets freed by __blk_mq_end_request,
|
2014-01-17 11:06:53 +00:00
|
|
|
* so we have to do all cleanup that depends on it earlier.
|
|
|
|
*
|
|
|
|
* We also can't kick the queues from irq context, so we
|
|
|
|
* will have to defer it to a workqueue.
|
|
|
|
*/
|
|
|
|
scsi_mq_uninit_cmd(cmd);
|
|
|
|
|
2014-09-13 23:40:10 +00:00
|
|
|
__blk_mq_end_request(req, error);
|
2014-01-17 11:06:53 +00:00
|
|
|
|
|
|
|
if (scsi_target(sdev)->single_lun ||
|
|
|
|
!list_empty(&sdev->host->starved_list))
|
|
|
|
kblockd_schedule_work(&sdev->requeue_work);
|
|
|
|
else
|
2017-04-07 18:16:53 +00:00
|
|
|
blk_mq_run_hw_queues(q, true);
|
2014-01-17 11:06:53 +00:00
|
|
|
} else {
|
|
|
|
unsigned long flags;
|
|
|
|
|
2014-09-16 14:41:13 +00:00
|
|
|
if (bidi_bytes)
|
|
|
|
scsi_release_bidi_buffers(cmd);
|
2017-01-02 18:55:26 +00:00
|
|
|
scsi_release_buffers(cmd);
|
|
|
|
scsi_put_command(cmd);
|
2014-09-16 14:41:13 +00:00
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
blk_finish_request(req, error);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
|
2014-09-06 01:02:09 +00:00
|
|
|
scsi_run_queue(q);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
2014-02-16 14:16:13 +00:00
|
|
|
|
2014-09-06 01:02:09 +00:00
|
|
|
put_device(&sdev->sdev_gendev);
|
2014-02-16 14:16:13 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-01 13:16:23 +00:00
|
|
|
/**
|
|
|
|
* __scsi_error_from_host_byte - translate SCSI error code into errno
|
|
|
|
* @cmd: SCSI command (unused)
|
|
|
|
* @result: scsi error code
|
|
|
|
*
|
2017-06-03 07:38:04 +00:00
|
|
|
* Translate SCSI error code into block errors.
|
2013-07-01 13:16:23 +00:00
|
|
|
*/
|
2017-06-03 07:38:04 +00:00
|
|
|
static blk_status_t __scsi_error_from_host_byte(struct scsi_cmnd *cmd,
|
|
|
|
int result)
|
2011-01-18 09:13:11 +00:00
|
|
|
{
|
2017-06-03 07:38:04 +00:00
|
|
|
switch (host_byte(result)) {
|
2011-01-18 09:13:11 +00:00
|
|
|
case DID_TRANSPORT_FAILFAST:
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_TRANSPORT;
|
2011-01-18 09:13:11 +00:00
|
|
|
case DID_TARGET_FAILURE:
|
2012-01-24 20:38:46 +00:00
|
|
|
set_host_byte(cmd, DID_OK);
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_TARGET;
|
2011-01-18 09:13:11 +00:00
|
|
|
case DID_NEXUS_FAILURE:
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_NEXUS;
|
2013-07-01 13:16:25 +00:00
|
|
|
case DID_ALLOC_FAILURE:
|
|
|
|
set_host_byte(cmd, DID_OK);
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_NOSPC;
|
2013-07-01 13:16:26 +00:00
|
|
|
case DID_MEDIUM_ERROR:
|
|
|
|
set_host_byte(cmd, DID_OK);
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_MEDIUM;
|
2011-01-18 09:13:11 +00:00
|
|
|
default:
|
2017-06-03 07:38:04 +00:00
|
|
|
return BLK_STS_IOERR;
|
2011-01-18 09:13:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_io_completion()
|
|
|
|
*
|
|
|
|
* Purpose: Completion processing for block device I/O requests.
|
|
|
|
*
|
|
|
|
* Arguments: cmd - command that is finished.
|
|
|
|
*
|
|
|
|
* Lock status: Assumed that no lock is held upon entry.
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
2014-05-01 14:51:03 +00:00
|
|
|
* Notes: We will finish off the specified number of sectors. If we
|
|
|
|
* are done, the command block will be released and the queue
|
|
|
|
* function will be goosed. If we are not done then we have to
|
2008-11-03 20:56:47 +00:00
|
|
|
* figure out what to do next:
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-11-03 20:56:47 +00:00
|
|
|
* a) We can call scsi_requeue_command(). The request
|
|
|
|
* will be unprepared and put back on the queue. Then
|
|
|
|
* a new command will be created for it. This should
|
|
|
|
* be used if we made forward progress, or if we want
|
|
|
|
* to switch from READ(10) to READ(6) for example.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2014-05-01 14:51:03 +00:00
|
|
|
* b) We can call __scsi_queue_insert(). The request will
|
2008-11-03 20:56:47 +00:00
|
|
|
* be put back on the queue and retried using the same
|
|
|
|
* command as before, possibly after a delay.
|
|
|
|
*
|
2014-02-16 14:16:13 +00:00
|
|
|
* c) We can call scsi_end_request() with -EIO to fail
|
2008-11-03 20:56:47 +00:00
|
|
|
* the remainder of the request.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-06-23 16:39:09 +00:00
|
|
|
void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int result = cmd->result;
|
2007-07-24 07:28:11 +00:00
|
|
|
struct request_queue *q = cmd->device->request_queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request *req = cmd->request;
|
2017-06-03 07:38:04 +00:00
|
|
|
blk_status_t error = BLK_STS_OK;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2014-10-24 12:26:52 +00:00
|
|
|
bool sense_valid = false;
|
2014-10-24 12:27:01 +00:00
|
|
|
int sense_deferred = 0, level = 0;
|
2008-11-03 20:56:47 +00:00
|
|
|
enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
|
|
|
|
ACTION_DELAYED_RETRY} action;
|
2014-02-11 05:29:52 +00:00
|
|
|
unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (result) {
|
|
|
|
sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
|
|
|
|
if (sense_valid)
|
|
|
|
sense_deferred = scsi_sense_is_deferred(&sshdr);
|
|
|
|
}
|
2006-07-08 18:42:15 +00:00
|
|
|
|
2017-01-31 15:57:29 +00:00
|
|
|
if (blk_rq_is_passthrough(req)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (result) {
|
2017-01-27 08:46:29 +00:00
|
|
|
if (sense_valid) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* SG_IO wants current and deferred errors
|
|
|
|
*/
|
2017-01-27 08:46:29 +00:00
|
|
|
scsi_req(req)->sense_len =
|
|
|
|
min(8 + cmd->sense_buffer[7],
|
|
|
|
SCSI_SENSE_BUFFERSIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-04-02 23:11:52 +00:00
|
|
|
if (!sense_deferred)
|
2011-01-18 09:13:11 +00:00
|
|
|
error = __scsi_error_from_host_byte(cmd, result);
|
2007-03-13 20:53:28 +00:00
|
|
|
}
|
[SCSI] scsi_lib: fix scsi_io_completion's SG_IO error propagation
The following v3.4-rc1 commit unmasked an existing bug in scsi_io_completion's
SG_IO error handling: 47ac56d [SCSI] scsi_error: classify some ILLEGAL_REQUEST
sense as a permanent TARGET_ERROR
Given that certain ILLEGAL_REQUEST are now properly categorized as
TARGET_ERROR the host_byte is being set (before host_byte wasn't ever
set for these ILLEGAL_REQUEST).
In scsi_io_completion, initialize req->errors with cmd->result _after_
the SG_IO block that calls __scsi_error_from_host_byte (which may
modify the host_byte).
Before this fix:
cdb to send: 12 01 01 00 00 00
ioctl(3, SG_IO, {'S', SG_DXFER_NONE, cmd[6]=[12, 01, 01, 00, 00, 00],
mx_sb_len=32, iovec_count=0, dxfer_len=0, timeout=20000, flags=0,
status=02, masked_status=01, sb[19]=[70, 00, 05, 00, 00, 00, 00, 0b,
00, 00, 00, 00, 24, 00, 00, 00, 00, 00, 00], host_status=0x10,
driver_status=0x8, resid=0, duration=0, info=0x1}) = 0
SCSI Status: Check Condition
Sense Information:
sense buffer empty
After:
cdb to send: 12 01 01 00 00 00
ioctl(3, SG_IO, {'S', SG_DXFER_NONE, cmd[6]=[12, 01, 01, 00, 00, 00],
mx_sb_len=32, iovec_count=0, dxfer_len=0, timeout=20000, flags=0,
status=02, masked_status=01, sb[19]=[70, 00, 05, 00, 00, 00, 00, 0b,
00, 00, 00, 00, 24, 00, 00, 00, 00, 00, 00], host_status=0,
driver_status=0x8, resid=0, duration=0, info=0x1}) = 0
SCSI Status: Check Condition
Sense Information:
Fixed format, current; Sense key: Illegal Request
Additional sense: Invalid field in cdb
Raw sense data (in hex):
70 00 05 00 00 00 00 0b 00 00 00 00 24 00 00 00
00 00 00
Reported-by: Paolo Bonzini <pbonzini@redhat.com>
Tested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Babu Moger <babu.moger@netapp.com>
Cc: stable@vger.kernel.org # 3.4
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-05-31 19:05:33 +00:00
|
|
|
/*
|
|
|
|
* __scsi_error_from_host_byte may have reset the host_byte
|
|
|
|
*/
|
2017-04-20 14:03:01 +00:00
|
|
|
scsi_req(req)->result = cmd->result;
|
2017-01-27 08:46:29 +00:00
|
|
|
scsi_req(req)->resid_len = scsi_get_resid(cmd);
|
2009-05-11 08:56:08 +00:00
|
|
|
|
2007-12-13 11:50:53 +00:00
|
|
|
if (scsi_bidi_cmnd(cmd)) {
|
2009-05-11 08:56:08 +00:00
|
|
|
/*
|
|
|
|
* Bidi commands Must be complete as a whole,
|
|
|
|
* both sides at once.
|
|
|
|
*/
|
2017-01-27 08:46:29 +00:00
|
|
|
scsi_req(req->next_rq)->resid_len = scsi_in(cmd)->resid;
|
2017-06-03 07:38:04 +00:00
|
|
|
if (scsi_end_request(req, BLK_STS_OK, blk_rq_bytes(req),
|
2014-02-16 14:16:13 +00:00
|
|
|
blk_rq_bytes(req->next_rq)))
|
|
|
|
BUG();
|
2007-12-13 11:50:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-07-03 17:17:34 +00:00
|
|
|
} else if (blk_rq_bytes(req) == 0 && result && !sense_deferred) {
|
|
|
|
/*
|
2017-01-31 15:57:31 +00:00
|
|
|
* Flush commands do not transfers any data, and thus cannot use
|
2014-07-03 17:17:34 +00:00
|
|
|
* good_bytes != blk_rq_bytes(req) as the signal for an error.
|
|
|
|
* This sets the error explicitly for the problem case.
|
|
|
|
*/
|
|
|
|
error = __scsi_error_from_host_byte(cmd, result);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-01-31 15:57:29 +00:00
|
|
|
/* no bidi support for !blk_rq_is_passthrough yet */
|
2010-08-07 16:17:56 +00:00
|
|
|
BUG_ON(blk_bidi_rq(req));
|
2007-12-13 11:47:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Next deal with any sectors which we were able to correctly
|
|
|
|
* handle.
|
|
|
|
*/
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd,
|
|
|
|
"%u sectors total, %d bytes done.\n",
|
|
|
|
blk_rq_sectors(req), good_bytes));
|
2006-07-02 15:06:28 +00:00
|
|
|
|
2009-03-30 16:55:51 +00:00
|
|
|
/*
|
2017-01-31 15:57:31 +00:00
|
|
|
* Recovered errors need reporting, but they're always treated as
|
|
|
|
* success, so fiddle the result code here. For passthrough requests
|
2017-04-20 14:03:01 +00:00
|
|
|
* we already took a copy of the original into sreq->result which
|
2009-03-30 16:55:51 +00:00
|
|
|
* is what gets returned to the user
|
|
|
|
*/
|
2010-01-03 18:51:15 +00:00
|
|
|
if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
|
|
|
|
/* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
|
|
|
|
* print since caller wants ATA registers. Only occurs on
|
|
|
|
* SCSI ATA PASS_THROUGH commands when CK_COND=1
|
|
|
|
*/
|
|
|
|
if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
|
|
|
|
;
|
2016-10-20 13:12:13 +00:00
|
|
|
else if (!(req->rq_flags & RQF_QUIET))
|
2014-10-24 12:26:45 +00:00
|
|
|
scsi_print_sense(cmd);
|
2009-03-30 16:55:51 +00:00
|
|
|
result = 0;
|
2017-01-31 15:57:31 +00:00
|
|
|
/* for passthrough error may be set */
|
2017-06-03 07:38:04 +00:00
|
|
|
error = BLK_STS_OK;
|
2009-03-30 16:55:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-05-13 19:04:06 +00:00
|
|
|
* special case: failed zero length commands always need to
|
|
|
|
* drop down into the retry code. Otherwise, if we finished
|
|
|
|
* all bytes in the request we are done now.
|
2006-07-02 15:06:28 +00:00
|
|
|
*/
|
2016-05-13 19:04:06 +00:00
|
|
|
if (!(blk_rq_bytes(req) == 0 && error) &&
|
|
|
|
!scsi_end_request(req, error, good_bytes, 0))
|
2014-02-16 14:16:13 +00:00
|
|
|
return;
|
2014-05-01 14:51:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Kill remainder if no retrys.
|
|
|
|
*/
|
|
|
|
if (error && scsi_noretry_cmd(cmd)) {
|
2014-02-16 14:16:13 +00:00
|
|
|
if (scsi_end_request(req, error, blk_rq_bytes(req), 0))
|
|
|
|
BUG();
|
|
|
|
return;
|
2014-05-01 14:51:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there had been no error, but we have leftover bytes in the
|
|
|
|
* requeues just queue the command up again.
|
2006-07-02 15:06:28 +00:00
|
|
|
*/
|
2014-05-01 14:51:03 +00:00
|
|
|
if (result == 0)
|
|
|
|
goto requeue;
|
2006-06-23 16:39:09 +00:00
|
|
|
|
2011-01-18 09:13:11 +00:00
|
|
|
error = __scsi_error_from_host_byte(cmd, result);
|
2009-01-04 08:04:31 +00:00
|
|
|
|
2008-11-03 20:56:47 +00:00
|
|
|
if (host_byte(result) == DID_RESET) {
|
|
|
|
/* Third party bus reset or reset for error recovery
|
|
|
|
* reasons. Just retry the command and see what
|
|
|
|
* happens.
|
|
|
|
*/
|
|
|
|
action = ACTION_RETRY;
|
|
|
|
} else if (sense_valid && !sense_deferred) {
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (sshdr.sense_key) {
|
|
|
|
case UNIT_ATTENTION:
|
|
|
|
if (cmd->device->removable) {
|
2006-06-23 16:39:09 +00:00
|
|
|
/* Detected disc change. Set a bit
|
2005-04-16 22:20:36 +00:00
|
|
|
* and quietly refuse further access.
|
|
|
|
*/
|
|
|
|
cmd->device->changed = 1;
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_FAIL;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2006-06-23 16:39:09 +00:00
|
|
|
/* Must have been a power glitch, or a
|
|
|
|
* bus reset. Could not have been a
|
|
|
|
* media change, so we just retry the
|
2008-11-03 20:56:47 +00:00
|
|
|
* command and see what happens.
|
2006-06-23 16:39:09 +00:00
|
|
|
*/
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_RETRY;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ILLEGAL_REQUEST:
|
2006-06-23 16:39:09 +00:00
|
|
|
/* If we had an ILLEGAL REQUEST returned, then
|
|
|
|
* we may have performed an unsupported
|
|
|
|
* command. The only thing this should be
|
|
|
|
* would be a ten byte read where only a six
|
|
|
|
* byte read was supported. Also, on a system
|
|
|
|
* where READ CAPACITY failed, we may have
|
|
|
|
* read past the end of the disk.
|
|
|
|
*/
|
2005-11-29 20:03:34 +00:00
|
|
|
if ((cmd->device->use_10_for_rw &&
|
|
|
|
sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
(cmd->cmnd[0] == READ_10 ||
|
|
|
|
cmd->cmnd[0] == WRITE_10)) {
|
2008-11-03 20:56:47 +00:00
|
|
|
/* This will issue a new 6-byte command. */
|
2005-04-16 22:20:36 +00:00
|
|
|
cmd->device->use_10_for_rw = 0;
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_REPREP;
|
2009-01-04 08:04:31 +00:00
|
|
|
} else if (sshdr.asc == 0x10) /* DIX */ {
|
|
|
|
action = ACTION_FAIL;
|
2017-06-03 07:38:04 +00:00
|
|
|
error = BLK_STS_PROTECTION;
|
2011-03-08 07:07:15 +00:00
|
|
|
/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
|
2012-09-18 16:19:32 +00:00
|
|
|
} else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
|
2011-03-08 07:07:15 +00:00
|
|
|
action = ACTION_FAIL;
|
2017-06-03 07:38:04 +00:00
|
|
|
error = BLK_STS_TARGET;
|
2008-11-03 20:56:47 +00:00
|
|
|
} else
|
|
|
|
action = ACTION_FAIL;
|
|
|
|
break;
|
2008-07-17 08:28:33 +00:00
|
|
|
case ABORTED_COMMAND:
|
2009-02-19 21:48:54 +00:00
|
|
|
action = ACTION_FAIL;
|
2014-07-10 07:41:53 +00:00
|
|
|
if (sshdr.asc == 0x10) /* DIF */
|
2017-06-03 07:38:04 +00:00
|
|
|
error = BLK_STS_PROTECTION;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case NOT_READY:
|
2006-06-23 16:39:09 +00:00
|
|
|
/* If the device is in the process of becoming
|
2006-04-25 21:48:30 +00:00
|
|
|
* ready, or has a temporary blockage, retry.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-04-25 21:48:30 +00:00
|
|
|
if (sshdr.asc == 0x04) {
|
|
|
|
switch (sshdr.ascq) {
|
|
|
|
case 0x01: /* becoming ready */
|
|
|
|
case 0x04: /* format in progress */
|
|
|
|
case 0x05: /* rebuild in progress */
|
|
|
|
case 0x06: /* recalculation in progress */
|
|
|
|
case 0x07: /* operation in progress */
|
|
|
|
case 0x08: /* Long write in progress */
|
|
|
|
case 0x09: /* self test in progress */
|
2009-11-26 17:00:41 +00:00
|
|
|
case 0x14: /* space allocation in progress */
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_DELAYED_RETRY;
|
2006-04-25 21:48:30 +00:00
|
|
|
break;
|
2008-12-15 15:31:28 +00:00
|
|
|
default:
|
|
|
|
action = ACTION_FAIL;
|
|
|
|
break;
|
2006-04-25 21:48:30 +00:00
|
|
|
}
|
2014-07-10 07:41:53 +00:00
|
|
|
} else
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_FAIL;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case VOLUME_OVERFLOW:
|
2006-06-23 16:39:09 +00:00
|
|
|
/* See SSC3rXX or current. */
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_FAIL;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_FAIL;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-07-10 07:41:53 +00:00
|
|
|
} else
|
2008-11-03 20:56:47 +00:00
|
|
|
action = ACTION_FAIL;
|
|
|
|
|
2014-02-11 05:29:52 +00:00
|
|
|
if (action != ACTION_FAIL &&
|
2014-07-10 07:41:53 +00:00
|
|
|
time_before(cmd->jiffies_at_alloc + wait_for, jiffies))
|
2014-02-11 05:29:52 +00:00
|
|
|
action = ACTION_FAIL;
|
|
|
|
|
2008-11-03 20:56:47 +00:00
|
|
|
switch (action) {
|
|
|
|
case ACTION_FAIL:
|
|
|
|
/* Give up and fail the remainder of the request */
|
2016-10-20 13:12:13 +00:00
|
|
|
if (!(req->rq_flags & RQF_QUIET)) {
|
2014-10-24 12:27:07 +00:00
|
|
|
static DEFINE_RATELIMIT_STATE(_rs,
|
|
|
|
DEFAULT_RATELIMIT_INTERVAL,
|
|
|
|
DEFAULT_RATELIMIT_BURST);
|
|
|
|
|
|
|
|
if (unlikely(scsi_logging_level))
|
|
|
|
level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
|
|
|
|
SCSI_LOG_MLCOMPLETE_BITS);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if logging is enabled the failure will be printed
|
|
|
|
* in scsi_log_completion(), so avoid duplicate messages
|
|
|
|
*/
|
|
|
|
if (!level && __ratelimit(&_rs)) {
|
|
|
|
scsi_print_result(cmd, NULL, FAILED);
|
|
|
|
if (driver_byte(result) & DRIVER_SENSE)
|
|
|
|
scsi_print_sense(cmd);
|
|
|
|
scsi_print_command(cmd);
|
|
|
|
}
|
2005-09-04 16:32:05 +00:00
|
|
|
}
|
2014-02-16 14:16:13 +00:00
|
|
|
if (!scsi_end_request(req, error, blk_rq_err_bytes(req), 0))
|
|
|
|
return;
|
2014-05-01 14:51:03 +00:00
|
|
|
/*FALLTHRU*/
|
2008-11-03 20:56:47 +00:00
|
|
|
case ACTION_REPREP:
|
2014-05-01 14:51:03 +00:00
|
|
|
requeue:
|
2008-11-03 20:56:47 +00:00
|
|
|
/* Unprep the request and put it back at the head of the queue.
|
|
|
|
* A new command will be prepared and issued.
|
|
|
|
*/
|
2014-01-17 11:06:53 +00:00
|
|
|
if (q->mq_ops) {
|
|
|
|
scsi_mq_requeue_cmd(cmd);
|
|
|
|
} else {
|
|
|
|
scsi_release_buffers(cmd);
|
|
|
|
scsi_requeue_command(q, cmd);
|
|
|
|
}
|
2008-11-03 20:56:47 +00:00
|
|
|
break;
|
|
|
|
case ACTION_RETRY:
|
|
|
|
/* Retry the same command immediately */
|
2009-01-02 16:42:21 +00:00
|
|
|
__scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);
|
2008-11-03 20:56:47 +00:00
|
|
|
break;
|
|
|
|
case ACTION_DELAYED_RETRY:
|
|
|
|
/* Retry the same command after a delay */
|
2009-01-02 16:42:21 +00:00
|
|
|
__scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);
|
2008-11-03 20:56:47 +00:00
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-06 01:20:23 +00:00
|
|
|
static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-12-13 11:50:53 +00:00
|
|
|
int count;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2006-11-04 19:10:55 +00:00
|
|
|
* If sg table allocation fails, requeue request later.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2016-12-08 22:20:32 +00:00
|
|
|
if (unlikely(sg_alloc_table_chained(&sdb->table,
|
|
|
|
blk_rq_nr_phys_segments(req), sdb->table.sgl)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return BLKPREP_DEFER;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Next, walk the list, and fill in the addresses and sizes of
|
|
|
|
* each segment.
|
|
|
|
*/
|
2007-12-13 11:47:40 +00:00
|
|
|
count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
|
|
|
|
BUG_ON(count > sdb->table.nents);
|
|
|
|
sdb->table.nents = count;
|
2017-01-13 11:29:11 +00:00
|
|
|
sdb->length = blk_rq_payload_bytes(req);
|
2007-11-19 00:28:48 +00:00
|
|
|
return BLKPREP_OK;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-12-13 11:50:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_init_io()
|
|
|
|
*
|
|
|
|
* Purpose: SCSI I/O initialize function.
|
|
|
|
*
|
|
|
|
* Arguments: cmd - Command descriptor we wish to initialize
|
|
|
|
*
|
|
|
|
* Returns: 0 on success
|
|
|
|
* BLKPREP_DEFER if the failure is retryable
|
|
|
|
* BLKPREP_KILL if the failure is fatal
|
|
|
|
*/
|
2014-09-06 01:20:23 +00:00
|
|
|
int scsi_init_io(struct scsi_cmnd *cmd)
|
2007-12-13 11:50:53 +00:00
|
|
|
{
|
2014-04-15 10:24:55 +00:00
|
|
|
struct scsi_device *sdev = cmd->device;
|
2010-09-10 18:50:10 +00:00
|
|
|
struct request *rq = cmd->request;
|
2014-01-17 11:06:53 +00:00
|
|
|
bool is_mq = (rq->mq_ctx != NULL);
|
2017-04-12 07:21:19 +00:00
|
|
|
int error = BLKPREP_KILL;
|
2010-09-10 18:50:10 +00:00
|
|
|
|
2017-01-31 09:16:00 +00:00
|
|
|
if (WARN_ON_ONCE(!blk_rq_nr_phys_segments(rq)))
|
2017-04-12 07:21:19 +00:00
|
|
|
goto err_exit;
|
2014-06-28 09:51:01 +00:00
|
|
|
|
2014-09-06 01:20:23 +00:00
|
|
|
error = scsi_init_sgtable(rq, &cmd->sdb);
|
2007-12-13 11:50:53 +00:00
|
|
|
if (error)
|
|
|
|
goto err_exit;
|
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
if (blk_bidi_rq(rq)) {
|
2014-01-17 11:06:53 +00:00
|
|
|
if (!rq->q->mq_ops) {
|
|
|
|
struct scsi_data_buffer *bidi_sdb =
|
|
|
|
kmem_cache_zalloc(scsi_sdb_cache, GFP_ATOMIC);
|
|
|
|
if (!bidi_sdb) {
|
|
|
|
error = BLKPREP_DEFER;
|
|
|
|
goto err_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
rq->next_rq->special = bidi_sdb;
|
2007-12-13 11:50:53 +00:00
|
|
|
}
|
|
|
|
|
2014-09-06 01:20:23 +00:00
|
|
|
error = scsi_init_sgtable(rq->next_rq, rq->next_rq->special);
|
2007-12-13 11:50:53 +00:00
|
|
|
if (error)
|
|
|
|
goto err_exit;
|
|
|
|
}
|
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
if (blk_integrity_rq(rq)) {
|
2008-07-17 21:08:48 +00:00
|
|
|
struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
|
|
|
|
int ivecs, count;
|
|
|
|
|
2015-01-15 15:02:12 +00:00
|
|
|
if (prot_sdb == NULL) {
|
|
|
|
/*
|
|
|
|
* This can happen if someone (e.g. multipath)
|
|
|
|
* queues a command to a device on an adapter
|
|
|
|
* that does not support DIX.
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
error = BLKPREP_KILL;
|
|
|
|
goto err_exit;
|
|
|
|
}
|
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
|
2008-07-17 21:08:48 +00:00
|
|
|
|
2016-04-04 21:48:09 +00:00
|
|
|
if (sg_alloc_table_chained(&prot_sdb->table, ivecs,
|
2016-04-04 21:48:08 +00:00
|
|
|
prot_sdb->table.sgl)) {
|
2008-07-17 21:08:48 +00:00
|
|
|
error = BLKPREP_DEFER;
|
|
|
|
goto err_exit;
|
|
|
|
}
|
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
count = blk_rq_map_integrity_sg(rq->q, rq->bio,
|
2008-07-17 21:08:48 +00:00
|
|
|
prot_sdb->table.sgl);
|
|
|
|
BUG_ON(unlikely(count > ivecs));
|
2010-09-10 18:50:10 +00:00
|
|
|
BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));
|
2008-07-17 21:08:48 +00:00
|
|
|
|
|
|
|
cmd->prot_sdb = prot_sdb;
|
|
|
|
cmd->prot_sdb->table.nents = count;
|
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
return BLKPREP_OK;
|
2007-12-13 11:50:53 +00:00
|
|
|
err_exit:
|
2014-01-17 11:06:53 +00:00
|
|
|
if (is_mq) {
|
|
|
|
scsi_mq_free_sgtables(cmd);
|
|
|
|
} else {
|
|
|
|
scsi_release_buffers(cmd);
|
|
|
|
cmd->request->special = NULL;
|
|
|
|
scsi_put_command(cmd);
|
|
|
|
put_device(&sdev->sdev_gendev);
|
|
|
|
}
|
2007-12-13 11:50:53 +00:00
|
|
|
return error;
|
|
|
|
}
|
2007-12-14 00:14:27 +00:00
|
|
|
EXPORT_SYMBOL(scsi_init_io);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-20 18:15:41 +00:00
|
|
|
/**
|
2017-08-30 23:58:40 +00:00
|
|
|
* scsi_initialize_rq - initialize struct scsi_cmnd partially
|
2017-08-24 22:11:09 +00:00
|
|
|
* @rq: Request associated with the SCSI command to be initialized.
|
2017-06-20 18:15:41 +00:00
|
|
|
*
|
2017-08-30 23:58:40 +00:00
|
|
|
* This function initializes the members of struct scsi_cmnd that must be
|
|
|
|
* initialized before request processing starts and that won't be
|
|
|
|
* reinitialized if a SCSI command is requeued.
|
|
|
|
*
|
2017-08-30 23:58:39 +00:00
|
|
|
* Called from inside blk_get_request() for pass-through requests and from
|
|
|
|
* inside scsi_init_command() for filesystem requests.
|
2017-06-20 18:15:41 +00:00
|
|
|
*/
|
|
|
|
void scsi_initialize_rq(struct request *rq)
|
|
|
|
{
|
2017-06-20 18:15:42 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
|
|
|
|
|
|
|
scsi_req_init(&cmd->req);
|
2017-08-30 23:58:40 +00:00
|
|
|
cmd->jiffies_at_alloc = jiffies;
|
|
|
|
cmd->retries = 0;
|
2017-06-20 18:15:41 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_initialize_rq);
|
|
|
|
|
2017-06-02 21:21:58 +00:00
|
|
|
/* Add a command to the list used by the aacraid and dpt_i2o drivers */
|
|
|
|
void scsi_add_cmd_to_list(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = cmd->device;
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (shost->use_cmd_list) {
|
|
|
|
spin_lock_irqsave(&sdev->list_lock, flags);
|
|
|
|
list_add_tail(&cmd->list, &sdev->cmd_list);
|
|
|
|
spin_unlock_irqrestore(&sdev->list_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove a command from the list used by the aacraid and dpt_i2o drivers */
|
|
|
|
void scsi_del_cmd_from_list(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = cmd->device;
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (shost->use_cmd_list) {
|
|
|
|
spin_lock_irqsave(&sdev->list_lock, flags);
|
|
|
|
BUG_ON(list_empty(&cmd->list));
|
|
|
|
list_del_init(&cmd->list);
|
|
|
|
spin_unlock_irqrestore(&sdev->list_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 18:15:41 +00:00
|
|
|
/* Called after a request has been started. */
|
2017-01-02 18:55:26 +00:00
|
|
|
void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd)
|
2006-11-04 19:10:55 +00:00
|
|
|
{
|
2017-01-02 18:55:26 +00:00
|
|
|
void *buf = cmd->sense_buffer;
|
|
|
|
void *prot = cmd->prot_sdb;
|
2017-08-30 23:58:39 +00:00
|
|
|
struct request *rq = blk_mq_rq_from_pdu(cmd);
|
|
|
|
unsigned int flags = cmd->flags & SCMD_PRESERVED_FLAGS;
|
2017-08-30 23:58:40 +00:00
|
|
|
unsigned long jiffies_at_alloc;
|
|
|
|
int retries;
|
2017-08-30 23:58:39 +00:00
|
|
|
|
|
|
|
if (!blk_rq_is_scsi(rq) && !(flags & SCMD_INITIALIZED)) {
|
|
|
|
flags |= SCMD_INITIALIZED;
|
|
|
|
scsi_initialize_rq(rq);
|
|
|
|
}
|
2006-11-04 19:10:55 +00:00
|
|
|
|
2017-08-30 23:58:40 +00:00
|
|
|
jiffies_at_alloc = cmd->jiffies_at_alloc;
|
|
|
|
retries = cmd->retries;
|
2017-01-27 08:46:29 +00:00
|
|
|
/* zero out the cmd, except for the embedded scsi_request */
|
|
|
|
memset((char *)cmd + sizeof(cmd->req), 0,
|
2017-02-21 09:04:55 +00:00
|
|
|
sizeof(*cmd) - sizeof(cmd->req) + dev->host->hostt->cmd_size);
|
2006-11-04 19:10:55 +00:00
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
cmd->device = dev;
|
|
|
|
cmd->sense_buffer = buf;
|
|
|
|
cmd->prot_sdb = prot;
|
2017-08-30 23:58:39 +00:00
|
|
|
cmd->flags = flags;
|
2017-01-02 18:55:26 +00:00
|
|
|
INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
|
2017-08-30 23:58:40 +00:00
|
|
|
cmd->jiffies_at_alloc = jiffies_at_alloc;
|
|
|
|
cmd->retries = retries;
|
2008-04-30 08:19:47 +00:00
|
|
|
|
2017-06-02 21:21:58 +00:00
|
|
|
scsi_add_cmd_to_list(cmd);
|
2006-11-04 19:10:55 +00:00
|
|
|
}
|
|
|
|
|
2017-01-31 15:57:31 +00:00
|
|
|
static int scsi_setup_scsi_cmnd(struct scsi_device *sdev, struct request *req)
|
2005-12-16 02:17:02 +00:00
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2006-11-04 19:10:55 +00:00
|
|
|
|
|
|
|
/*
|
2017-01-31 15:57:31 +00:00
|
|
|
* Passthrough requests may transfer data, in which case they must
|
2006-11-04 19:10:55 +00:00
|
|
|
* a bio attached to them. Or they might contain a SCSI command
|
|
|
|
* that does not transfer data, in which case they may optionally
|
|
|
|
* submit a request without an attached bio.
|
|
|
|
*/
|
|
|
|
if (req->bio) {
|
2014-09-06 01:20:23 +00:00
|
|
|
int ret = scsi_init_io(cmd);
|
2006-11-04 19:10:55 +00:00
|
|
|
if (unlikely(ret))
|
|
|
|
return ret;
|
|
|
|
} else {
|
2009-05-07 13:24:42 +00:00
|
|
|
BUG_ON(blk_rq_bytes(req));
|
2006-11-04 19:10:55 +00:00
|
|
|
|
2007-12-13 11:47:40 +00:00
|
|
|
memset(&cmd->sdb, 0, sizeof(cmd->sdb));
|
2006-11-04 19:10:55 +00:00
|
|
|
}
|
2005-12-16 02:17:02 +00:00
|
|
|
|
2017-01-27 08:46:29 +00:00
|
|
|
cmd->cmd_len = scsi_req(req)->cmd_len;
|
|
|
|
cmd->cmnd = scsi_req(req)->cmd;
|
2009-05-07 13:24:42 +00:00
|
|
|
cmd->transfersize = blk_rq_bytes(req);
|
2017-04-05 17:18:12 +00:00
|
|
|
cmd->allowed = scsi_req(req)->retries;
|
2006-11-04 19:10:55 +00:00
|
|
|
return BLKPREP_OK;
|
2005-12-16 02:17:02 +00:00
|
|
|
}
|
|
|
|
|
2006-11-04 19:10:55 +00:00
|
|
|
/*
|
2017-01-31 15:57:31 +00:00
|
|
|
* Setup a normal block command. These are simple request from filesystems
|
2014-06-28 09:58:42 +00:00
|
|
|
* that still need to be translated to SCSI CDBs from the ULD.
|
2006-11-04 19:10:55 +00:00
|
|
|
*/
|
2014-06-28 09:58:42 +00:00
|
|
|
static int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2008-05-01 21:49:46 +00:00
|
|
|
|
2015-08-27 12:16:59 +00:00
|
|
|
if (unlikely(sdev->handler && sdev->handler->prep_fn)) {
|
|
|
|
int ret = sdev->handler->prep_fn(sdev, req);
|
2008-05-01 21:49:46 +00:00
|
|
|
if (ret != BLKPREP_OK)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-27 08:46:29 +00:00
|
|
|
cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd;
|
2008-04-30 08:19:47 +00:00
|
|
|
memset(cmd->cmnd, 0, BLK_MAX_CDB);
|
2014-06-28 09:58:42 +00:00
|
|
|
return scsi_cmd_to_driver(cmd)->init_command(cmd);
|
2006-11-04 19:10:55 +00:00
|
|
|
}
|
|
|
|
|
2014-07-08 11:16:17 +00:00
|
|
|
static int scsi_setup_cmnd(struct scsi_device *sdev, struct request *req)
|
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2014-07-08 11:16:17 +00:00
|
|
|
|
|
|
|
if (!blk_rq_bytes(req))
|
|
|
|
cmd->sc_data_direction = DMA_NONE;
|
|
|
|
else if (rq_data_dir(req) == WRITE)
|
|
|
|
cmd->sc_data_direction = DMA_TO_DEVICE;
|
|
|
|
else
|
|
|
|
cmd->sc_data_direction = DMA_FROM_DEVICE;
|
|
|
|
|
2017-01-31 15:57:31 +00:00
|
|
|
if (blk_rq_is_scsi(req))
|
|
|
|
return scsi_setup_scsi_cmnd(sdev, req);
|
|
|
|
else
|
2014-07-08 11:16:17 +00:00
|
|
|
return scsi_setup_fs_cmnd(sdev, req);
|
|
|
|
}
|
|
|
|
|
2014-05-01 14:51:04 +00:00
|
|
|
static int
|
|
|
|
scsi_prep_state_check(struct scsi_device *sdev, struct request *req)
|
2006-11-04 19:10:55 +00:00
|
|
|
{
|
|
|
|
int ret = BLKPREP_OK;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-11-04 19:10:55 +00:00
|
|
|
* If the device is not in running state we will reject some
|
|
|
|
* or all commands.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-11-04 19:10:55 +00:00
|
|
|
if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
|
|
|
|
switch (sdev->sdev_state) {
|
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2006-11-04 19:10:55 +00:00
|
|
|
/*
|
|
|
|
* If the device is offline we refuse to process any
|
|
|
|
* commands. The device must be brought online
|
|
|
|
* before trying any recovery commands.
|
|
|
|
*/
|
|
|
|
sdev_printk(KERN_ERR, sdev,
|
|
|
|
"rejecting I/O to offline device\n");
|
|
|
|
ret = BLKPREP_KILL;
|
|
|
|
break;
|
|
|
|
case SDEV_DEL:
|
|
|
|
/*
|
|
|
|
* If the device is fully deleted, we refuse to
|
|
|
|
* process any commands as well.
|
|
|
|
*/
|
2005-10-02 16:45:08 +00:00
|
|
|
sdev_printk(KERN_ERR, sdev,
|
2006-11-04 19:10:55 +00:00
|
|
|
"rejecting I/O to dead device\n");
|
|
|
|
ret = BLKPREP_KILL;
|
|
|
|
break;
|
|
|
|
case SDEV_BLOCK:
|
2008-08-22 21:53:31 +00:00
|
|
|
case SDEV_CREATED_BLOCK:
|
2015-03-04 09:31:47 +00:00
|
|
|
ret = BLKPREP_DEFER;
|
|
|
|
break;
|
|
|
|
case SDEV_QUIESCE:
|
2006-11-04 19:10:55 +00:00
|
|
|
/*
|
|
|
|
* If the devices is blocked we defer normal commands.
|
|
|
|
*/
|
2017-10-14 09:22:31 +00:00
|
|
|
if (req && !(req->rq_flags & RQF_PREEMPT))
|
2006-11-04 19:10:55 +00:00
|
|
|
ret = BLKPREP_DEFER;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* For any other not fully online state we only allow
|
|
|
|
* special commands. In particular any user initiated
|
|
|
|
* command is not allowed.
|
|
|
|
*/
|
2017-10-14 09:22:31 +00:00
|
|
|
if (req && !(req->rq_flags & RQF_PREEMPT))
|
2006-11-04 19:10:55 +00:00
|
|
|
ret = BLKPREP_KILL;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2007-08-04 15:06:25 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-01 14:51:04 +00:00
|
|
|
static int
|
|
|
|
scsi_prep_return(struct request_queue *q, struct request *req, int ret)
|
2007-08-04 15:06:25 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-11-04 19:10:55 +00:00
|
|
|
switch (ret) {
|
|
|
|
case BLKPREP_KILL:
|
2016-02-16 12:14:13 +00:00
|
|
|
case BLKPREP_INVALID:
|
2017-04-20 14:03:01 +00:00
|
|
|
scsi_req(req)->result = DID_NO_CONNECT << 16;
|
2007-08-04 15:06:25 +00:00
|
|
|
/* release the command and kill it */
|
|
|
|
if (req->special) {
|
|
|
|
struct scsi_cmnd *cmd = req->special;
|
|
|
|
scsi_release_buffers(cmd);
|
|
|
|
scsi_put_command(cmd);
|
2014-04-15 10:24:56 +00:00
|
|
|
put_device(&sdev->sdev_gendev);
|
2007-08-04 15:06:25 +00:00
|
|
|
req->special = NULL;
|
|
|
|
}
|
2006-11-04 19:10:55 +00:00
|
|
|
break;
|
|
|
|
case BLKPREP_DEFER:
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-05-08 02:54:16 +00:00
|
|
|
* If we defer, the blk_peek_request() returns NULL, but the
|
2010-04-16 19:13:15 +00:00
|
|
|
* queue must be restarted, so we schedule a callback to happen
|
|
|
|
* shortly.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-04-11 17:07:01 +00:00
|
|
|
if (atomic_read(&sdev->device_busy) == 0)
|
2010-04-16 19:13:15 +00:00
|
|
|
blk_delay_queue(q, SCSI_QUEUE_DELAY);
|
2006-11-04 19:10:55 +00:00
|
|
|
break;
|
|
|
|
default:
|
2016-10-20 13:12:13 +00:00
|
|
|
req->rq_flags |= RQF_DONTPREP;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-11-04 19:10:55 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-08-04 15:06:25 +00:00
|
|
|
|
2014-05-01 14:51:04 +00:00
|
|
|
static int scsi_prep_fn(struct request_queue *q, struct request *req)
|
2007-08-04 15:06:25 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
2017-01-02 18:55:26 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2014-05-01 14:51:04 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = scsi_prep_state_check(sdev, req);
|
|
|
|
if (ret != BLKPREP_OK)
|
|
|
|
goto out;
|
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
if (!req->special) {
|
|
|
|
/* Bail if we can't get a reference to the device */
|
|
|
|
if (unlikely(!get_device(&sdev->sdev_gendev))) {
|
|
|
|
ret = BLKPREP_DEFER;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
scsi_init_command(sdev, cmd);
|
|
|
|
req->special = cmd;
|
2014-05-01 14:51:04 +00:00
|
|
|
}
|
2007-08-04 15:06:25 +00:00
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
cmd->tag = req->tag;
|
|
|
|
cmd->request = req;
|
|
|
|
cmd->prot_op = SCSI_PROT_NORMAL;
|
|
|
|
|
2014-07-08 11:16:17 +00:00
|
|
|
ret = scsi_setup_cmnd(sdev, req);
|
2014-05-01 14:51:04 +00:00
|
|
|
out:
|
2017-08-30 23:58:39 +00:00
|
|
|
if (ret != BLKPREP_OK)
|
|
|
|
cmd->flags &= ~SCMD_INITIALIZED;
|
2007-08-04 15:06:25 +00:00
|
|
|
return scsi_prep_return(q, req, ret);
|
|
|
|
}
|
2014-05-01 14:51:04 +00:00
|
|
|
|
|
|
|
static void scsi_unprep_fn(struct request_queue *q, struct request *req)
|
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
scsi_uninit_cmd(blk_mq_rq_to_pdu(req));
|
2014-05-01 14:51:04 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
|
|
|
|
* return 0.
|
|
|
|
*
|
|
|
|
* Called with the queue_lock held.
|
|
|
|
*/
|
|
|
|
static inline int scsi_dev_queue_ready(struct request_queue *q,
|
|
|
|
struct scsi_device *sdev)
|
|
|
|
{
|
2014-04-11 17:07:01 +00:00
|
|
|
unsigned int busy;
|
|
|
|
|
|
|
|
busy = atomic_inc_return(&sdev->device_busy) - 1;
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_read(&sdev->device_blocked)) {
|
2014-04-11 17:07:01 +00:00
|
|
|
if (busy)
|
|
|
|
goto out_dec;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* unblock after device_blocked iterates to zero
|
|
|
|
*/
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_dec_return(&sdev->device_blocked) > 0) {
|
2014-01-17 11:06:53 +00:00
|
|
|
/*
|
|
|
|
* For the MQ case we take care of this in the caller.
|
|
|
|
*/
|
|
|
|
if (!q->mq_ops)
|
|
|
|
blk_delay_queue(q, SCSI_QUEUE_DELAY);
|
2014-04-11 17:07:01 +00:00
|
|
|
goto out_dec;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-04-11 17:07:01 +00:00
|
|
|
SCSI_LOG_MLQUEUE(3, sdev_printk(KERN_INFO, sdev,
|
|
|
|
"unblocking device at zero depth\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-04-11 17:07:01 +00:00
|
|
|
|
|
|
|
if (busy >= sdev->queue_depth)
|
|
|
|
goto out_dec;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 1;
|
2014-04-11 17:07:01 +00:00
|
|
|
out_dec:
|
|
|
|
atomic_dec(&sdev->device_busy);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
/*
|
|
|
|
* scsi_target_queue_ready: checks if there we can send commands to target
|
|
|
|
* @sdev: scsi device on starget to check.
|
|
|
|
*/
|
|
|
|
static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
|
|
|
|
struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct scsi_target *starget = scsi_target(sdev);
|
2014-01-22 13:49:41 +00:00
|
|
|
unsigned int busy;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
|
|
|
|
if (starget->single_lun) {
|
2014-01-22 13:49:41 +00:00
|
|
|
spin_lock_irq(shost->host_lock);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
if (starget->starget_sdev_user &&
|
2014-01-22 13:49:41 +00:00
|
|
|
starget->starget_sdev_user != sdev) {
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
starget->starget_sdev_user = sdev;
|
2014-01-22 13:49:41 +00:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
}
|
|
|
|
|
2014-03-26 09:35:00 +00:00
|
|
|
if (starget->can_queue <= 0)
|
|
|
|
return 1;
|
|
|
|
|
2014-01-22 13:49:41 +00:00
|
|
|
busy = atomic_inc_return(&starget->target_busy) - 1;
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_read(&starget->target_blocked) > 0) {
|
2014-01-22 13:49:41 +00:00
|
|
|
if (busy)
|
|
|
|
goto starved;
|
|
|
|
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
/*
|
|
|
|
* unblock after target_blocked iterates to zero
|
|
|
|
*/
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_dec_return(&starget->target_blocked) > 0)
|
2014-01-22 13:49:41 +00:00
|
|
|
goto out_dec;
|
2014-01-22 13:36:32 +00:00
|
|
|
|
|
|
|
SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,
|
|
|
|
"unblocking target at zero depth\n"));
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
}
|
|
|
|
|
2014-03-26 09:35:00 +00:00
|
|
|
if (busy >= starget->can_queue)
|
2014-01-22 13:49:41 +00:00
|
|
|
goto starved;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
|
2014-01-22 13:49:41 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
starved:
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
list_move_tail(&sdev->starved_entry, &shost->starved_list);
|
2014-01-22 13:36:32 +00:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2014-01-22 13:49:41 +00:00
|
|
|
out_dec:
|
2014-03-26 09:35:00 +00:00
|
|
|
if (starget->can_queue > 0)
|
|
|
|
atomic_dec(&starget->target_busy);
|
2014-01-22 13:49:41 +00:00
|
|
|
return 0;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* scsi_host_queue_ready: if we can send requests to shost, return 1 else
|
|
|
|
* return 0. We must end up running the queue again whenever 0 is
|
|
|
|
* returned, else IO can hang.
|
|
|
|
*/
|
|
|
|
static inline int scsi_host_queue_ready(struct request_queue *q,
|
|
|
|
struct Scsi_Host *shost,
|
|
|
|
struct scsi_device *sdev)
|
|
|
|
{
|
2014-01-22 14:29:29 +00:00
|
|
|
unsigned int busy;
|
2014-01-22 13:36:32 +00:00
|
|
|
|
2005-09-18 20:05:20 +00:00
|
|
|
if (scsi_host_in_recovery(shost))
|
2014-01-22 14:29:29 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
busy = atomic_inc_return(&shost->host_busy) - 1;
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_read(&shost->host_blocked) > 0) {
|
2014-01-22 14:29:29 +00:00
|
|
|
if (busy)
|
|
|
|
goto starved;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* unblock after host_blocked iterates to zero
|
|
|
|
*/
|
2014-01-23 11:07:41 +00:00
|
|
|
if (atomic_dec_return(&shost->host_blocked) > 0)
|
2014-01-22 14:29:29 +00:00
|
|
|
goto out_dec;
|
2014-01-22 13:36:32 +00:00
|
|
|
|
|
|
|
SCSI_LOG_MLQUEUE(3,
|
|
|
|
shost_printk(KERN_INFO, shost,
|
|
|
|
"unblocking host at zero depth\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-01-22 14:29:29 +00:00
|
|
|
|
|
|
|
if (shost->can_queue > 0 && busy >= shost->can_queue)
|
|
|
|
goto starved;
|
|
|
|
if (shost->host_self_blocked)
|
|
|
|
goto starved;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* We're OK to process the command, so we can't be starved */
|
2014-01-22 14:29:29 +00:00
|
|
|
if (!list_empty(&sdev->starved_entry)) {
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
if (!list_empty(&sdev->starved_entry))
|
|
|
|
list_del_init(&sdev->starved_entry);
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-01-22 14:29:29 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
starved:
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
if (list_empty(&sdev->starved_entry))
|
|
|
|
list_add_tail(&sdev->starved_entry, &shost->starved_list);
|
2014-01-22 13:36:32 +00:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2014-01-22 14:29:29 +00:00
|
|
|
out_dec:
|
|
|
|
atomic_dec(&shost->host_busy);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-10-04 18:11:35 +00:00
|
|
|
/*
|
|
|
|
* Busy state exporting function for request stacking drivers.
|
|
|
|
*
|
|
|
|
* For efficiency, no lock is taken to check the busy state of
|
|
|
|
* shost/starget/sdev, since the returned value is not guaranteed and
|
|
|
|
* may be changed after request stacking drivers call the function,
|
|
|
|
* regardless of taking lock or not.
|
|
|
|
*
|
2012-06-29 15:33:22 +00:00
|
|
|
* When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi
|
|
|
|
* needs to return 'not busy'. Otherwise, request stacking drivers
|
|
|
|
* may hold requests forever.
|
2008-10-04 18:11:35 +00:00
|
|
|
*/
|
|
|
|
static int scsi_lld_busy(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
|
2012-11-28 12:42:38 +00:00
|
|
|
if (blk_queue_dying(q))
|
2008-10-04 18:11:35 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
shost = sdev->host;
|
|
|
|
|
2012-05-22 09:57:17 +00:00
|
|
|
/*
|
|
|
|
* Ignore host/starget busy state.
|
|
|
|
* Since block layer does not have a concept of fairness across
|
|
|
|
* multiple queues, congestion of host/starget needs to be handled
|
|
|
|
* in SCSI layer.
|
|
|
|
*/
|
|
|
|
if (scsi_host_in_recovery(shost) || scsi_device_is_busy(sdev))
|
2008-10-04 18:11:35 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-09-09 15:44:16 +00:00
|
|
|
* Kill a request for a dead device
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-07-24 07:28:11 +00:00
|
|
|
static void scsi_kill_request(struct request *req, struct request_queue *q)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2009-09-23 14:15:35 +00:00
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct scsi_target *starget;
|
|
|
|
struct Scsi_Host *shost;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-05-08 02:54:16 +00:00
|
|
|
blk_start_request(req);
|
2005-09-09 18:40:23 +00:00
|
|
|
|
2011-11-09 07:39:24 +00:00
|
|
|
scmd_printk(KERN_INFO, cmd, "killing request\n");
|
|
|
|
|
2009-09-23 14:15:35 +00:00
|
|
|
sdev = cmd->device;
|
|
|
|
starget = scsi_target(sdev);
|
|
|
|
shost = sdev->host;
|
2005-09-09 15:44:16 +00:00
|
|
|
scsi_init_cmd_errh(cmd);
|
|
|
|
cmd->result = DID_NO_CONNECT << 16;
|
|
|
|
atomic_inc(&cmd->device->iorequest_cnt);
|
2006-04-11 08:27:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SCSI request completion path will do scsi_device_unbusy(),
|
|
|
|
* bump busy counts. To bump the counters, we need to dance
|
|
|
|
* with the locks as normal issue path does.
|
|
|
|
*/
|
2014-04-11 17:07:01 +00:00
|
|
|
atomic_inc(&sdev->device_busy);
|
2014-01-22 14:29:29 +00:00
|
|
|
atomic_inc(&shost->host_busy);
|
2014-03-26 09:35:00 +00:00
|
|
|
if (starget->can_queue > 0)
|
|
|
|
atomic_inc(&starget->target_busy);
|
2006-04-11 08:27:53 +00:00
|
|
|
|
2008-09-14 12:55:09 +00:00
|
|
|
blk_complete_request(req);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-09 15:03:03 +00:00
|
|
|
static void scsi_softirq_done(struct request *rq)
|
|
|
|
{
|
2017-08-25 20:46:32 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
2008-09-14 12:55:09 +00:00
|
|
|
unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
|
2006-01-09 15:03:03 +00:00
|
|
|
int disposition;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&cmd->eh_entry);
|
|
|
|
|
2008-09-14 12:55:09 +00:00
|
|
|
atomic_inc(&cmd->device->iodone_cnt);
|
|
|
|
if (cmd->result)
|
|
|
|
atomic_inc(&cmd->device->ioerr_cnt);
|
|
|
|
|
2006-01-09 15:03:03 +00:00
|
|
|
disposition = scsi_decide_disposition(cmd);
|
|
|
|
if (disposition != SUCCESS &&
|
|
|
|
time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
|
|
|
|
sdev_printk(KERN_ERR, cmd->device,
|
|
|
|
"timing out command, waited %lus\n",
|
|
|
|
wait_for/HZ);
|
|
|
|
disposition = SUCCESS;
|
|
|
|
}
|
2014-06-25 14:39:59 +00:00
|
|
|
|
2006-01-09 15:03:03 +00:00
|
|
|
scsi_log_completion(cmd, disposition);
|
|
|
|
|
|
|
|
switch (disposition) {
|
|
|
|
case SUCCESS:
|
|
|
|
scsi_finish_command(cmd);
|
|
|
|
break;
|
|
|
|
case NEEDS_RETRY:
|
2007-01-02 11:56:00 +00:00
|
|
|
scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
|
2006-01-09 15:03:03 +00:00
|
|
|
break;
|
|
|
|
case ADD_TO_MLQUEUE:
|
|
|
|
scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
|
|
|
|
break;
|
|
|
|
default:
|
2017-04-06 13:36:35 +00:00
|
|
|
scsi_eh_scmd_add(cmd);
|
2017-04-06 13:36:34 +00:00
|
|
|
break;
|
2006-01-09 15:03:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-06 01:23:07 +00:00
|
|
|
/**
|
|
|
|
* scsi_dispatch_command - Dispatch a command to the low-level driver.
|
|
|
|
* @cmd: command block we are dispatching.
|
|
|
|
*
|
|
|
|
* Return: nonzero return request was rejected and device's queue needs to be
|
|
|
|
* plugged.
|
|
|
|
*/
|
|
|
|
static int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
|
|
|
int rtn = 0;
|
|
|
|
|
|
|
|
atomic_inc(&cmd->device->iorequest_cnt);
|
|
|
|
|
|
|
|
/* check if the device is still usable */
|
|
|
|
if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
|
|
|
|
/* in SDEV_DEL we error all commands. DID_NO_CONNECT
|
|
|
|
* returns an immediate error upwards, and signals
|
|
|
|
* that the device is no longer present */
|
|
|
|
cmd->result = DID_NO_CONNECT << 16;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check to see if the scsi lld made this device blocked. */
|
|
|
|
if (unlikely(scsi_device_blocked(cmd->device))) {
|
|
|
|
/*
|
|
|
|
* in blocked state, the command is just put back on
|
|
|
|
* the device queue. The suspend state has already
|
|
|
|
* blocked the queue so future requests should not
|
|
|
|
* occur until the device transitions out of the
|
|
|
|
* suspend state.
|
|
|
|
*/
|
|
|
|
SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
|
|
|
|
"queuecommand : device blocked\n"));
|
|
|
|
return SCSI_MLQUEUE_DEVICE_BUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Store the LUN value in cmnd, if needed. */
|
|
|
|
if (cmd->device->lun_in_cdb)
|
|
|
|
cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
|
|
|
|
(cmd->device->lun << 5 & 0xe0);
|
|
|
|
|
|
|
|
scsi_log_send(cmd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Before we queue this command, check if the command
|
|
|
|
* length exceeds what the host adapter can handle.
|
|
|
|
*/
|
|
|
|
if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
|
|
|
|
SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
|
|
|
|
"queuecommand : command too long. "
|
|
|
|
"cdb_size=%d host->max_cmd_len=%d\n",
|
|
|
|
cmd->cmd_len, cmd->device->host->max_cmd_len));
|
|
|
|
cmd->result = (DID_ABORT << 16);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(host->shost_state == SHOST_DEL)) {
|
|
|
|
cmd->result = (DID_NO_CONNECT << 16);
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_scsi_dispatch_cmd_start(cmd);
|
|
|
|
rtn = host->hostt->queuecommand(host, cmd);
|
|
|
|
if (rtn) {
|
|
|
|
trace_scsi_dispatch_cmd_error(cmd, rtn);
|
|
|
|
if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
|
|
|
|
rtn != SCSI_MLQUEUE_TARGET_BUSY)
|
|
|
|
rtn = SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
|
|
|
|
SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
|
|
|
|
"queuecommand : request rejected\n"));
|
|
|
|
}
|
|
|
|
|
|
|
|
return rtn;
|
|
|
|
done:
|
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-06 10:25:40 +00:00
|
|
|
/**
|
|
|
|
* scsi_done - Invoke completion on finished SCSI command.
|
|
|
|
* @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
|
|
|
|
* ownership back to SCSI Core -- i.e. the LLDD has finished with it.
|
|
|
|
*
|
|
|
|
* Description: This function is the mid-level's (SCSI Core) interrupt routine,
|
|
|
|
* which regains ownership of the SCSI command (de facto) from a LLDD, and
|
|
|
|
* calls blk_complete_request() for further processing.
|
|
|
|
*
|
|
|
|
* This function is interrupt context safe.
|
|
|
|
*/
|
|
|
|
static void scsi_done(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
trace_scsi_dispatch_cmd_done(cmd);
|
|
|
|
blk_complete_request(cmd->request);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_request_fn()
|
|
|
|
*
|
|
|
|
* Purpose: Main strategy routine for SCSI.
|
|
|
|
*
|
|
|
|
* Arguments: q - Pointer to actual queue.
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Lock status: IO request lock assumed to be held when called.
|
|
|
|
*/
|
|
|
|
static void scsi_request_fn(struct request_queue *q)
|
2014-02-20 22:20:56 +00:00
|
|
|
__releases(q->queue_lock)
|
|
|
|
__acquires(q->queue_lock)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct scsi_cmnd *cmd;
|
|
|
|
struct request *req;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To start with, we keep looping until the queue is empty, or until
|
|
|
|
* the host is no longer able to accept any more requests.
|
|
|
|
*/
|
|
|
|
shost = sdev->host;
|
2010-04-16 19:13:15 +00:00
|
|
|
for (;;) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int rtn;
|
|
|
|
/*
|
|
|
|
* get next queueable request. We do this early to make sure
|
2014-06-25 14:39:59 +00:00
|
|
|
* that the request is fully prepared even if we cannot
|
2005-04-16 22:20:36 +00:00
|
|
|
* accept it.
|
|
|
|
*/
|
2009-05-08 02:54:16 +00:00
|
|
|
req = blk_peek_request(q);
|
2014-04-11 17:07:01 +00:00
|
|
|
if (!req)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (unlikely(!scsi_device_online(sdev))) {
|
2005-10-02 16:45:08 +00:00
|
|
|
sdev_printk(KERN_ERR, sdev,
|
|
|
|
"rejecting I/O to offline device\n");
|
2005-09-09 15:44:16 +00:00
|
|
|
scsi_kill_request(req, q);
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-04-11 17:07:01 +00:00
|
|
|
if (!scsi_dev_queue_ready(q, sdev))
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the request from the request list.
|
|
|
|
*/
|
|
|
|
if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
|
2009-05-08 02:54:16 +00:00
|
|
|
blk_start_request(req);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-01-22 13:36:32 +00:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
2017-08-25 20:46:32 +00:00
|
|
|
cmd = blk_mq_rq_to_pdu(req);
|
|
|
|
if (cmd != req->special) {
|
2005-09-09 15:44:16 +00:00
|
|
|
printk(KERN_CRIT "impossible request in %s.\n"
|
|
|
|
"please mail a stack trace to "
|
2006-08-10 06:44:47 +00:00
|
|
|
"linux-scsi@vger.kernel.org\n",
|
2008-07-04 06:47:27 +00:00
|
|
|
__func__);
|
2006-08-10 06:44:47 +00:00
|
|
|
blk_dump_rq_flags(req, "foo");
|
2005-09-09 15:44:16 +00:00
|
|
|
BUG();
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-12 00:50:35 +00:00
|
|
|
/*
|
|
|
|
* We hit this when the driver is using a host wide
|
|
|
|
* tag map. For device level tag maps the queue_depth check
|
|
|
|
* in the device ready fn would prevent us from trying
|
|
|
|
* to allocate a tag. Since the map is a shared host resource
|
|
|
|
* we add the dev to the starved list so it eventually gets
|
|
|
|
* a run when a tag is freed.
|
|
|
|
*/
|
2016-10-20 13:12:13 +00:00
|
|
|
if (blk_queue_tagged(q) && !(req->rq_flags & RQF_QUEUED)) {
|
2014-01-22 13:36:32 +00:00
|
|
|
spin_lock_irq(shost->host_lock);
|
2008-07-12 00:50:35 +00:00
|
|
|
if (list_empty(&sdev->starved_entry))
|
|
|
|
list_add_tail(&sdev->starved_entry,
|
|
|
|
&shost->starved_list);
|
2014-01-22 13:36:32 +00:00
|
|
|
spin_unlock_irq(shost->host_lock);
|
2008-07-12 00:50:35 +00:00
|
|
|
goto not_ready;
|
|
|
|
}
|
|
|
|
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
if (!scsi_target_queue_ready(shost, sdev))
|
|
|
|
goto not_ready;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!scsi_host_queue_ready(q, shost, sdev))
|
2014-01-22 13:36:32 +00:00
|
|
|
goto host_not_ready;
|
2014-11-03 11:47:47 +00:00
|
|
|
|
|
|
|
if (sdev->simple_tags)
|
|
|
|
cmd->flags |= SCMD_TAGGED;
|
|
|
|
else
|
|
|
|
cmd->flags &= ~SCMD_TAGGED;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Finally, initialize any error handling parameters, and set up
|
|
|
|
* the timers for timeouts.
|
|
|
|
*/
|
|
|
|
scsi_init_cmd_errh(cmd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dispatch the command to the low-level driver.
|
|
|
|
*/
|
2014-05-06 10:25:40 +00:00
|
|
|
cmd->scsi_done = scsi_done;
|
2005-04-16 22:20:36 +00:00
|
|
|
rtn = scsi_dispatch_cmd(cmd);
|
2014-01-22 17:39:04 +00:00
|
|
|
if (rtn) {
|
|
|
|
scsi_queue_insert(cmd, rtn);
|
|
|
|
spin_lock_irq(q->queue_lock);
|
2010-04-16 19:13:15 +00:00
|
|
|
goto out_delay;
|
2014-01-22 17:39:04 +00:00
|
|
|
}
|
|
|
|
spin_lock_irq(q->queue_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-02-20 22:20:56 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-01-22 13:36:32 +00:00
|
|
|
host_not_ready:
|
2014-03-26 09:35:00 +00:00
|
|
|
if (scsi_target(sdev)->can_queue > 0)
|
|
|
|
atomic_dec(&scsi_target(sdev)->target_busy);
|
2014-01-22 13:36:32 +00:00
|
|
|
not_ready:
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* lock q, handle tag, requeue req, and decrement device_busy. We
|
|
|
|
* must return with queue_lock held.
|
|
|
|
*
|
|
|
|
* Decrementing device_busy without checking it is OK, as all such
|
|
|
|
* cases (host limits or settings) should run the queue at some
|
|
|
|
* later time.
|
|
|
|
*/
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
blk_requeue_request(q, req);
|
2014-04-11 17:07:01 +00:00
|
|
|
atomic_dec(&sdev->device_busy);
|
2010-04-16 19:13:15 +00:00
|
|
|
out_delay:
|
2014-08-10 12:54:25 +00:00
|
|
|
if (!atomic_read(&sdev->device_busy) && !scsi_device_blocked(sdev))
|
2010-04-16 19:13:15 +00:00
|
|
|
blk_delay_queue(q, SCSI_QUEUE_DELAY);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-03 07:38:05 +00:00
|
|
|
static inline blk_status_t prep_to_mq(int ret)
|
2014-01-17 11:06:53 +00:00
|
|
|
{
|
|
|
|
switch (ret) {
|
|
|
|
case BLKPREP_OK:
|
2017-06-03 07:38:05 +00:00
|
|
|
return BLK_STS_OK;
|
2014-01-17 11:06:53 +00:00
|
|
|
case BLKPREP_DEFER:
|
2017-06-03 07:38:05 +00:00
|
|
|
return BLK_STS_RESOURCE;
|
2014-01-17 11:06:53 +00:00
|
|
|
default:
|
2017-06-03 07:38:05 +00:00
|
|
|
return BLK_STS_IOERR;
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-02 21:21:59 +00:00
|
|
|
/* Size in bytes of the sg-list stored in the scsi-mq command-private data. */
|
|
|
|
static unsigned int scsi_mq_sgl_size(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
return min_t(unsigned int, shost->sg_tablesize, SG_CHUNK_SIZE) *
|
|
|
|
sizeof(struct scatterlist);
|
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
static int scsi_mq_prep_fn(struct request *req)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
|
|
|
struct scsi_device *sdev = req->q->queuedata;
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
|
|
|
struct scatterlist *sg;
|
2017-08-30 23:58:39 +00:00
|
|
|
int ret;
|
2014-01-17 11:06:53 +00:00
|
|
|
|
2017-06-02 21:22:00 +00:00
|
|
|
scsi_init_command(sdev, cmd);
|
2014-01-17 11:06:53 +00:00
|
|
|
|
|
|
|
req->special = cmd;
|
|
|
|
|
|
|
|
cmd->request = req;
|
|
|
|
|
|
|
|
cmd->tag = req->tag;
|
|
|
|
cmd->prot_op = SCSI_PROT_NORMAL;
|
|
|
|
|
|
|
|
sg = (void *)cmd + sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
|
|
|
|
cmd->sdb.table.sgl = sg;
|
|
|
|
|
|
|
|
if (scsi_host_get_prot(shost)) {
|
|
|
|
memset(cmd->prot_sdb, 0, sizeof(struct scsi_data_buffer));
|
|
|
|
|
|
|
|
cmd->prot_sdb->table.sgl =
|
|
|
|
(struct scatterlist *)(cmd->prot_sdb + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (blk_bidi_rq(req)) {
|
|
|
|
struct request *next_rq = req->next_rq;
|
|
|
|
struct scsi_data_buffer *bidi_sdb = blk_mq_rq_to_pdu(next_rq);
|
|
|
|
|
|
|
|
memset(bidi_sdb, 0, sizeof(struct scsi_data_buffer));
|
|
|
|
bidi_sdb->table.sgl =
|
|
|
|
(struct scatterlist *)(bidi_sdb + 1);
|
|
|
|
|
|
|
|
next_rq->special = bidi_sdb;
|
|
|
|
}
|
|
|
|
|
2014-09-22 13:59:31 +00:00
|
|
|
blk_mq_start_request(req);
|
|
|
|
|
2017-08-30 23:58:39 +00:00
|
|
|
ret = scsi_setup_cmnd(sdev, req);
|
|
|
|
if (ret != BLK_STS_OK)
|
|
|
|
cmd->flags &= ~SCMD_INITIALIZED;
|
|
|
|
return ret;
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_mq_done(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
trace_scsi_dispatch_cmd_done(cmd);
|
2017-04-20 14:03:09 +00:00
|
|
|
blk_mq_complete_request(cmd->request);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
2017-06-03 07:38:05 +00:00
|
|
|
static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
|
2014-10-29 17:14:52 +00:00
|
|
|
const struct blk_mq_queue_data *bd)
|
2014-01-17 11:06:53 +00:00
|
|
|
{
|
2014-10-29 17:14:52 +00:00
|
|
|
struct request *req = bd->rq;
|
2014-01-17 11:06:53 +00:00
|
|
|
struct request_queue *q = req->q;
|
|
|
|
struct scsi_device *sdev = q->queuedata;
|
|
|
|
struct Scsi_Host *shost = sdev->host;
|
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
|
2017-06-03 07:38:05 +00:00
|
|
|
blk_status_t ret;
|
2014-01-17 11:06:53 +00:00
|
|
|
int reason;
|
|
|
|
|
|
|
|
ret = prep_to_mq(scsi_prep_state_check(sdev, req));
|
2017-06-03 07:38:05 +00:00
|
|
|
if (ret != BLK_STS_OK)
|
2014-01-17 11:06:53 +00:00
|
|
|
goto out;
|
|
|
|
|
2017-06-03 07:38:05 +00:00
|
|
|
ret = BLK_STS_RESOURCE;
|
2014-01-17 11:06:53 +00:00
|
|
|
if (!get_device(&sdev->sdev_gendev))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!scsi_dev_queue_ready(q, sdev))
|
|
|
|
goto out_put_device;
|
|
|
|
if (!scsi_target_queue_ready(shost, sdev))
|
|
|
|
goto out_dec_device_busy;
|
|
|
|
if (!scsi_host_queue_ready(q, shost, sdev))
|
|
|
|
goto out_dec_target_busy;
|
|
|
|
|
2016-10-20 13:12:13 +00:00
|
|
|
if (!(req->rq_flags & RQF_DONTPREP)) {
|
2014-01-17 11:06:53 +00:00
|
|
|
ret = prep_to_mq(scsi_mq_prep_fn(req));
|
2017-06-03 07:38:05 +00:00
|
|
|
if (ret != BLK_STS_OK)
|
2014-01-17 11:06:53 +00:00
|
|
|
goto out_dec_host_busy;
|
2016-10-20 13:12:13 +00:00
|
|
|
req->rq_flags |= RQF_DONTPREP;
|
2014-09-22 13:59:31 +00:00
|
|
|
} else {
|
|
|
|
blk_mq_start_request(req);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
2014-11-03 11:47:47 +00:00
|
|
|
if (sdev->simple_tags)
|
|
|
|
cmd->flags |= SCMD_TAGGED;
|
2014-10-19 15:13:58 +00:00
|
|
|
else
|
2014-11-03 11:47:47 +00:00
|
|
|
cmd->flags &= ~SCMD_TAGGED;
|
2014-10-19 15:13:58 +00:00
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
scsi_init_cmd_errh(cmd);
|
|
|
|
cmd->scsi_done = scsi_mq_done;
|
|
|
|
|
|
|
|
reason = scsi_dispatch_cmd(cmd);
|
|
|
|
if (reason) {
|
|
|
|
scsi_set_blocked(cmd, reason);
|
2017-06-03 07:38:05 +00:00
|
|
|
ret = BLK_STS_RESOURCE;
|
2014-01-17 11:06:53 +00:00
|
|
|
goto out_dec_host_busy;
|
|
|
|
}
|
|
|
|
|
2017-06-03 07:38:05 +00:00
|
|
|
return BLK_STS_OK;
|
2014-01-17 11:06:53 +00:00
|
|
|
|
|
|
|
out_dec_host_busy:
|
|
|
|
atomic_dec(&shost->host_busy);
|
|
|
|
out_dec_target_busy:
|
|
|
|
if (scsi_target(sdev)->can_queue > 0)
|
|
|
|
atomic_dec(&scsi_target(sdev)->target_busy);
|
|
|
|
out_dec_device_busy:
|
|
|
|
atomic_dec(&sdev->device_busy);
|
|
|
|
out_put_device:
|
|
|
|
put_device(&sdev->sdev_gendev);
|
|
|
|
out:
|
|
|
|
switch (ret) {
|
2017-06-03 07:38:05 +00:00
|
|
|
case BLK_STS_OK:
|
|
|
|
break;
|
|
|
|
case BLK_STS_RESOURCE:
|
2014-01-17 11:06:53 +00:00
|
|
|
if (atomic_read(&sdev->device_busy) == 0 &&
|
|
|
|
!scsi_device_blocked(sdev))
|
2017-04-07 18:16:53 +00:00
|
|
|
blk_mq_delay_run_hw_queue(hctx, SCSI_QUEUE_DELAY);
|
2014-01-17 11:06:53 +00:00
|
|
|
break;
|
2017-06-03 07:38:05 +00:00
|
|
|
default:
|
2014-01-17 11:06:53 +00:00
|
|
|
/*
|
|
|
|
* Make sure to release all allocated ressources when
|
|
|
|
* we hit an error, as we will never see this command
|
|
|
|
* again.
|
|
|
|
*/
|
2016-10-20 13:12:13 +00:00
|
|
|
if (req->rq_flags & RQF_DONTPREP)
|
2014-01-17 11:06:53 +00:00
|
|
|
scsi_mq_uninit_cmd(cmd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-13 23:40:13 +00:00
|
|
|
static enum blk_eh_timer_return scsi_timeout(struct request *req,
|
|
|
|
bool reserved)
|
|
|
|
{
|
|
|
|
if (reserved)
|
|
|
|
return BLK_EH_RESET_TIMER;
|
|
|
|
return scsi_times_out(req);
|
|
|
|
}
|
|
|
|
|
2017-08-25 20:46:31 +00:00
|
|
|
static int scsi_mq_init_request(struct blk_mq_tag_set *set, struct request *rq,
|
|
|
|
unsigned int hctx_idx, unsigned int numa_node)
|
2014-01-17 11:06:53 +00:00
|
|
|
{
|
2017-05-01 16:19:08 +00:00
|
|
|
struct Scsi_Host *shost = set->driver_data;
|
2017-06-02 21:21:52 +00:00
|
|
|
const bool unchecked_isa_dma = shost->unchecked_isa_dma;
|
2014-01-17 11:06:53 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
2017-06-02 21:22:00 +00:00
|
|
|
struct scatterlist *sg;
|
2014-01-17 11:06:53 +00:00
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
if (unchecked_isa_dma)
|
|
|
|
cmd->flags |= SCMD_UNCHECKED_ISA_DMA;
|
|
|
|
cmd->sense_buffer = scsi_alloc_sense_buffer(unchecked_isa_dma,
|
|
|
|
GFP_KERNEL, numa_node);
|
2014-01-17 11:06:53 +00:00
|
|
|
if (!cmd->sense_buffer)
|
|
|
|
return -ENOMEM;
|
2017-01-27 08:46:29 +00:00
|
|
|
cmd->req.sense = cmd->sense_buffer;
|
2017-06-02 21:22:00 +00:00
|
|
|
|
|
|
|
if (scsi_host_get_prot(shost)) {
|
|
|
|
sg = (void *)cmd + sizeof(struct scsi_cmnd) +
|
|
|
|
shost->hostt->cmd_size;
|
|
|
|
cmd->prot_sdb = (void *)sg + scsi_mq_sgl_size(shost);
|
|
|
|
}
|
|
|
|
|
2014-01-17 11:06:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-08-25 20:46:31 +00:00
|
|
|
static void scsi_mq_exit_request(struct blk_mq_tag_set *set, struct request *rq,
|
|
|
|
unsigned int hctx_idx)
|
2014-01-17 11:06:53 +00:00
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
scsi_free_sense_buffer(cmd->flags & SCMD_UNCHECKED_ISA_DMA,
|
|
|
|
cmd->sense_buffer);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
|
|
|
|
2016-11-01 14:12:48 +00:00
|
|
|
static int scsi_map_queues(struct blk_mq_tag_set *set)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = container_of(set, struct Scsi_Host, tag_set);
|
|
|
|
|
|
|
|
if (shost->hostt->map_queues)
|
|
|
|
return shost->hostt->map_queues(shost);
|
|
|
|
return blk_mq_map_queues(set);
|
|
|
|
}
|
|
|
|
|
2014-04-15 10:26:54 +00:00
|
|
|
static u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct device *host_dev;
|
|
|
|
u64 bounce_limit = 0xffffffff;
|
|
|
|
|
|
|
|
if (shost->unchecked_isa_dma)
|
|
|
|
return BLK_BOUNCE_ISA;
|
|
|
|
/*
|
|
|
|
* Platforms with virtual-DMA translation
|
|
|
|
* hardware have no practical limit.
|
|
|
|
*/
|
|
|
|
if (!PCI_DMA_BUS_IS_PHYS)
|
|
|
|
return BLK_BOUNCE_ANY;
|
|
|
|
|
|
|
|
host_dev = scsi_get_device(shost);
|
|
|
|
if (host_dev && host_dev->dma_mask)
|
2014-02-11 17:11:04 +00:00
|
|
|
bounce_limit = (u64)dma_max_pfn(host_dev) << PAGE_SHIFT;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return bounce_limit;
|
|
|
|
}
|
|
|
|
|
2017-01-02 18:52:10 +00:00
|
|
|
void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-04-12 05:50:38 +00:00
|
|
|
struct device *dev = shost->dma_dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-31 21:43:46 +00:00
|
|
|
queue_flag_set_unlocked(QUEUE_FLAG_SCSI_PASSTHROUGH, q);
|
|
|
|
|
2007-08-07 07:02:51 +00:00
|
|
|
/*
|
|
|
|
* this limit is imposed by hardware restrictions
|
|
|
|
*/
|
2010-02-26 05:20:39 +00:00
|
|
|
blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
|
2016-04-04 21:48:10 +00:00
|
|
|
SG_MAX_SEGMENTS));
|
2007-08-07 07:02:51 +00:00
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
if (scsi_host_prot_dma(shost)) {
|
|
|
|
shost->sg_prot_tablesize =
|
|
|
|
min_not_zero(shost->sg_prot_tablesize,
|
|
|
|
(unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);
|
|
|
|
BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);
|
|
|
|
blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);
|
|
|
|
}
|
|
|
|
|
2010-02-26 05:20:38 +00:00
|
|
|
blk_queue_max_hw_sectors(q, shost->max_sectors);
|
2005-04-16 22:20:36 +00:00
|
|
|
blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
|
|
|
|
blk_queue_segment_boundary(q, shost->dma_boundary);
|
2008-02-05 06:28:17 +00:00
|
|
|
dma_set_seg_boundary(dev, shost->dma_boundary);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-05 06:28:05 +00:00
|
|
|
blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!shost->use_clustering)
|
2010-12-01 18:41:49 +00:00
|
|
|
q->limits.cluster = 0;
|
2008-01-01 16:00:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* set a reasonable default alignment on word boundaries: the
|
|
|
|
* host and device may alter it using
|
|
|
|
* blk_queue_update_dma_alignment() later.
|
|
|
|
*/
|
|
|
|
blk_queue_dma_alignment(q, 0x03);
|
2014-01-17 11:06:53 +00:00
|
|
|
}
|
2017-01-02 18:52:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(__scsi_init_queue);
|
2008-01-01 16:00:10 +00:00
|
|
|
|
2017-08-25 20:46:31 +00:00
|
|
|
static int scsi_old_init_rq(struct request_queue *q, struct request *rq,
|
|
|
|
gfp_t gfp)
|
2014-01-17 11:06:53 +00:00
|
|
|
{
|
2017-01-02 18:55:26 +00:00
|
|
|
struct Scsi_Host *shost = q->rq_alloc_data;
|
2017-06-02 21:21:52 +00:00
|
|
|
const bool unchecked_isa_dma = shost->unchecked_isa_dma;
|
2017-01-02 18:55:26 +00:00
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
2014-01-17 11:06:53 +00:00
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
|
|
|
2017-06-02 21:21:52 +00:00
|
|
|
if (unchecked_isa_dma)
|
|
|
|
cmd->flags |= SCMD_UNCHECKED_ISA_DMA;
|
|
|
|
cmd->sense_buffer = scsi_alloc_sense_buffer(unchecked_isa_dma, gfp,
|
|
|
|
NUMA_NO_NODE);
|
2017-01-02 18:55:26 +00:00
|
|
|
if (!cmd->sense_buffer)
|
|
|
|
goto fail;
|
2017-01-27 08:46:29 +00:00
|
|
|
cmd->req.sense = cmd->sense_buffer;
|
2017-01-02 18:55:26 +00:00
|
|
|
|
|
|
|
if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
|
|
|
|
cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp);
|
|
|
|
if (!cmd->prot_sdb)
|
|
|
|
goto fail_free_sense;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail_free_sense:
|
2017-06-02 21:21:52 +00:00
|
|
|
scsi_free_sense_buffer(unchecked_isa_dma, cmd->sense_buffer);
|
2017-01-02 18:55:26 +00:00
|
|
|
fail:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2017-08-25 20:46:31 +00:00
|
|
|
static void scsi_old_exit_rq(struct request_queue *q, struct request *rq)
|
2017-01-02 18:55:26 +00:00
|
|
|
{
|
|
|
|
struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
|
|
|
|
|
|
|
|
if (cmd->prot_sdb)
|
|
|
|
kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
|
2017-06-02 21:21:52 +00:00
|
|
|
scsi_free_sense_buffer(cmd->flags & SCMD_UNCHECKED_ISA_DMA,
|
|
|
|
cmd->sense_buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-11-16 10:24:10 +00:00
|
|
|
|
2017-08-25 20:46:31 +00:00
|
|
|
struct request_queue *scsi_old_alloc_queue(struct scsi_device *sdev)
|
2006-11-16 10:24:10 +00:00
|
|
|
{
|
2017-01-02 18:55:26 +00:00
|
|
|
struct Scsi_Host *shost = sdev->host;
|
2006-11-16 10:24:10 +00:00
|
|
|
struct request_queue *q;
|
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
q = blk_alloc_queue_node(GFP_KERNEL, NUMA_NO_NODE);
|
2006-11-16 10:24:10 +00:00
|
|
|
if (!q)
|
|
|
|
return NULL;
|
2017-01-02 18:55:26 +00:00
|
|
|
q->cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
|
|
|
|
q->rq_alloc_data = shost;
|
|
|
|
q->request_fn = scsi_request_fn;
|
2017-08-25 20:46:31 +00:00
|
|
|
q->init_rq_fn = scsi_old_init_rq;
|
|
|
|
q->exit_rq_fn = scsi_old_exit_rq;
|
2017-06-20 18:15:41 +00:00
|
|
|
q->initialize_rq_fn = scsi_initialize_rq;
|
2017-01-02 18:55:26 +00:00
|
|
|
|
|
|
|
if (blk_init_allocated_queue(q) < 0) {
|
|
|
|
blk_cleanup_queue(q);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-11-16 10:24:10 +00:00
|
|
|
|
2017-01-02 18:55:26 +00:00
|
|
|
__scsi_init_queue(shost, q);
|
2006-11-16 10:24:10 +00:00
|
|
|
blk_queue_prep_rq(q, scsi_prep_fn);
|
2014-05-01 14:51:04 +00:00
|
|
|
blk_queue_unprep_rq(q, scsi_unprep_fn);
|
2006-11-16 10:24:10 +00:00
|
|
|
blk_queue_softirq_done(q, scsi_softirq_done);
|
2008-09-14 12:55:09 +00:00
|
|
|
blk_queue_rq_timed_out(q, scsi_times_out);
|
2008-10-04 18:11:35 +00:00
|
|
|
blk_queue_lld_busy(q, scsi_lld_busy);
|
2006-11-16 10:24:10 +00:00
|
|
|
return q;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-03-30 20:39:16 +00:00
|
|
|
static const struct blk_mq_ops scsi_mq_ops = {
|
2014-01-17 11:06:53 +00:00
|
|
|
.queue_rq = scsi_queue_rq,
|
|
|
|
.complete = scsi_softirq_done,
|
2014-09-13 23:40:13 +00:00
|
|
|
.timeout = scsi_timeout,
|
2017-04-26 20:47:57 +00:00
|
|
|
#ifdef CONFIG_BLK_DEBUG_FS
|
|
|
|
.show_rq = scsi_show_rq,
|
|
|
|
#endif
|
2017-08-25 20:46:31 +00:00
|
|
|
.init_request = scsi_mq_init_request,
|
|
|
|
.exit_request = scsi_mq_exit_request,
|
2017-06-20 18:15:41 +00:00
|
|
|
.initialize_rq_fn = scsi_initialize_rq,
|
2016-11-01 14:12:48 +00:00
|
|
|
.map_queues = scsi_map_queues,
|
2014-01-17 11:06:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct request_queue *scsi_mq_alloc_queue(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
sdev->request_queue = blk_mq_init_queue(&sdev->host->tag_set);
|
|
|
|
if (IS_ERR(sdev->request_queue))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sdev->request_queue->queuedata = sdev;
|
|
|
|
__scsi_init_queue(sdev->host, sdev->request_queue);
|
|
|
|
return sdev->request_queue;
|
|
|
|
}
|
|
|
|
|
|
|
|
int scsi_mq_setup_tags(struct Scsi_Host *shost)
|
|
|
|
{
|
2017-06-02 21:21:59 +00:00
|
|
|
unsigned int cmd_size, sgl_size;
|
2014-01-17 11:06:53 +00:00
|
|
|
|
2017-06-02 21:21:59 +00:00
|
|
|
sgl_size = scsi_mq_sgl_size(shost);
|
2014-01-17 11:06:53 +00:00
|
|
|
cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size + sgl_size;
|
|
|
|
if (scsi_host_get_prot(shost))
|
|
|
|
cmd_size += sizeof(struct scsi_data_buffer) + sgl_size;
|
|
|
|
|
|
|
|
memset(&shost->tag_set, 0, sizeof(shost->tag_set));
|
|
|
|
shost->tag_set.ops = &scsi_mq_ops;
|
2014-10-30 13:45:36 +00:00
|
|
|
shost->tag_set.nr_hw_queues = shost->nr_hw_queues ? : 1;
|
2014-01-17 11:06:53 +00:00
|
|
|
shost->tag_set.queue_depth = shost->can_queue;
|
|
|
|
shost->tag_set.cmd_size = cmd_size;
|
|
|
|
shost->tag_set.numa_node = NUMA_NO_NODE;
|
|
|
|
shost->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
|
2015-01-23 21:18:00 +00:00
|
|
|
shost->tag_set.flags |=
|
|
|
|
BLK_ALLOC_POLICY_TO_MQ_FLAG(shost->hostt->tag_alloc_policy);
|
2014-01-17 11:06:53 +00:00
|
|
|
shost->tag_set.driver_data = shost;
|
|
|
|
|
|
|
|
return blk_mq_alloc_tag_set(&shost->tag_set);
|
|
|
|
}
|
|
|
|
|
|
|
|
void scsi_mq_destroy_tags(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
blk_mq_free_tag_set(&shost->tag_set);
|
|
|
|
}
|
|
|
|
|
2017-02-17 08:02:45 +00:00
|
|
|
/**
|
|
|
|
* scsi_device_from_queue - return sdev associated with a request_queue
|
|
|
|
* @q: The request queue to return the sdev from
|
|
|
|
*
|
|
|
|
* Return the sdev associated with a request queue or NULL if the
|
|
|
|
* request_queue does not reference a SCSI device.
|
|
|
|
*/
|
|
|
|
struct scsi_device *scsi_device_from_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = NULL;
|
|
|
|
|
|
|
|
if (q->mq_ops) {
|
|
|
|
if (q->mq_ops == &scsi_mq_ops)
|
|
|
|
sdev = q->queuedata;
|
|
|
|
} else if (q->request_fn == scsi_request_fn)
|
|
|
|
sdev = q->queuedata;
|
|
|
|
if (!sdev || !get_device(&sdev->sdev_gendev))
|
|
|
|
sdev = NULL;
|
|
|
|
|
|
|
|
return sdev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_device_from_queue);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Function: scsi_block_requests()
|
|
|
|
*
|
|
|
|
* Purpose: Utility function used by low-level drivers to prevent further
|
|
|
|
* commands from being queued to the device.
|
|
|
|
*
|
|
|
|
* Arguments: shost - Host in question
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Lock status: No locks are assumed held.
|
|
|
|
*
|
|
|
|
* Notes: There is no timer nor any other means by which the requests
|
|
|
|
* get unblocked other than the low-level driver calling
|
|
|
|
* scsi_unblock_requests().
|
|
|
|
*/
|
|
|
|
void scsi_block_requests(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
shost->host_self_blocked = 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_block_requests);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function: scsi_unblock_requests()
|
|
|
|
*
|
|
|
|
* Purpose: Utility function used by low-level drivers to allow further
|
|
|
|
* commands from being queued to the device.
|
|
|
|
*
|
|
|
|
* Arguments: shost - Host in question
|
|
|
|
*
|
|
|
|
* Returns: Nothing
|
|
|
|
*
|
|
|
|
* Lock status: No locks are assumed held.
|
|
|
|
*
|
|
|
|
* Notes: There is no timer nor any other means by which the requests
|
|
|
|
* get unblocked other than the low-level driver calling
|
|
|
|
* scsi_unblock_requests().
|
|
|
|
*
|
|
|
|
* This is done as an API function so that changes to the
|
|
|
|
* internals of the scsi mid-layer won't require wholesale
|
|
|
|
* changes to drivers that use this feature.
|
|
|
|
*/
|
|
|
|
void scsi_unblock_requests(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
shost->host_self_blocked = 0;
|
|
|
|
scsi_run_host_queues(shost);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_unblock_requests);
|
|
|
|
|
|
|
|
int __init scsi_init_queue(void)
|
|
|
|
{
|
2008-06-06 03:30:03 +00:00
|
|
|
scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
|
|
|
|
sizeof(struct scsi_data_buffer),
|
|
|
|
0, 0, NULL);
|
|
|
|
if (!scsi_sdb_cache) {
|
|
|
|
printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
|
2008-12-13 16:23:45 +00:00
|
|
|
return -ENOMEM;
|
2007-12-13 11:50:53 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void scsi_exit_queue(void)
|
|
|
|
{
|
2017-01-03 05:28:41 +00:00
|
|
|
kmem_cache_destroy(scsi_sense_cache);
|
|
|
|
kmem_cache_destroy(scsi_sense_isadma_cache);
|
2008-06-06 03:30:03 +00:00
|
|
|
kmem_cache_destroy(scsi_sdb_cache);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-03-18 20:10:35 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_mode_select - issue a mode select
|
|
|
|
* @sdev: SCSI device to be queried
|
|
|
|
* @pf: Page format bit (1 == standard, 0 == vendor specific)
|
|
|
|
* @sp: Save page bit (0 == don't save, 1 == save)
|
|
|
|
* @modepage: mode page being requested
|
|
|
|
* @buffer: request buffer (may not be smaller than eight bytes)
|
|
|
|
* @len: length of request buffer.
|
|
|
|
* @timeout: command timeout
|
|
|
|
* @retries: number of retries before failing
|
|
|
|
* @data: returns a structure abstracting the mode header data
|
2007-11-03 18:30:39 +00:00
|
|
|
* @sshdr: place to put sense data (or NULL if no sense to be collected).
|
2006-03-18 20:10:35 +00:00
|
|
|
* must be SCSI_SENSE_BUFFERSIZE big.
|
|
|
|
*
|
|
|
|
* Returns zero if successful; negative error number or scsi
|
|
|
|
* status on error
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage,
|
|
|
|
unsigned char *buffer, int len, int timeout, int retries,
|
|
|
|
struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
|
|
|
unsigned char cmd[10];
|
|
|
|
unsigned char *real_buffer;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(cmd, 0, sizeof(cmd));
|
|
|
|
cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0);
|
|
|
|
|
|
|
|
if (sdev->use_10_for_ms) {
|
|
|
|
if (len > 65535)
|
|
|
|
return -EINVAL;
|
|
|
|
real_buffer = kmalloc(8 + len, GFP_KERNEL);
|
|
|
|
if (!real_buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
memcpy(real_buffer + 8, buffer, len);
|
|
|
|
len += 8;
|
|
|
|
real_buffer[0] = 0;
|
|
|
|
real_buffer[1] = 0;
|
|
|
|
real_buffer[2] = data->medium_type;
|
|
|
|
real_buffer[3] = data->device_specific;
|
|
|
|
real_buffer[4] = data->longlba ? 0x01 : 0;
|
|
|
|
real_buffer[5] = 0;
|
|
|
|
real_buffer[6] = data->block_descriptor_length >> 8;
|
|
|
|
real_buffer[7] = data->block_descriptor_length;
|
|
|
|
|
|
|
|
cmd[0] = MODE_SELECT_10;
|
|
|
|
cmd[7] = len >> 8;
|
|
|
|
cmd[8] = len;
|
|
|
|
} else {
|
|
|
|
if (len > 255 || data->block_descriptor_length > 255 ||
|
|
|
|
data->longlba)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
real_buffer = kmalloc(4 + len, GFP_KERNEL);
|
|
|
|
if (!real_buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
memcpy(real_buffer + 4, buffer, len);
|
|
|
|
len += 4;
|
|
|
|
real_buffer[0] = 0;
|
|
|
|
real_buffer[1] = data->medium_type;
|
|
|
|
real_buffer[2] = data->device_specific;
|
|
|
|
real_buffer[3] = data->block_descriptor_length;
|
|
|
|
|
|
|
|
|
|
|
|
cmd[0] = MODE_SELECT;
|
|
|
|
cmd[4] = len;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
|
2008-12-04 05:24:39 +00:00
|
|
|
sshdr, timeout, retries, NULL);
|
2006-03-18 20:10:35 +00:00
|
|
|
kfree(real_buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_mode_select);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2007-11-03 18:30:39 +00:00
|
|
|
* scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.
|
2005-08-28 16:27:01 +00:00
|
|
|
* @sdev: SCSI device to be queried
|
2005-04-16 22:20:36 +00:00
|
|
|
* @dbd: set if mode sense will allow block descriptors to be returned
|
|
|
|
* @modepage: mode page being requested
|
|
|
|
* @buffer: request buffer (may not be smaller than eight bytes)
|
|
|
|
* @len: length of request buffer.
|
|
|
|
* @timeout: command timeout
|
|
|
|
* @retries: number of retries before failing
|
|
|
|
* @data: returns a structure abstracting the mode header data
|
2007-11-03 18:30:39 +00:00
|
|
|
* @sshdr: place to put sense data (or NULL if no sense to be collected).
|
2005-08-28 16:27:01 +00:00
|
|
|
* must be SCSI_SENSE_BUFFERSIZE big.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Returns zero if unsuccessful, or the header offset (either 4
|
|
|
|
* or 8 depending on whether a six or ten byte command was
|
|
|
|
* issued) if successful.
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
2005-08-28 16:27:01 +00:00
|
|
|
scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char *buffer, int len, int timeout, int retries,
|
2006-03-18 20:10:35 +00:00
|
|
|
struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char cmd[12];
|
|
|
|
int use_10_for_ms;
|
|
|
|
int header_length;
|
2015-06-12 14:12:48 +00:00
|
|
|
int result, retry_count = retries;
|
2005-08-28 16:33:52 +00:00
|
|
|
struct scsi_sense_hdr my_sshdr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
memset(data, 0, sizeof(*data));
|
|
|
|
memset(&cmd[0], 0, 12);
|
|
|
|
cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */
|
|
|
|
cmd[2] = modepage;
|
|
|
|
|
2005-08-28 16:33:52 +00:00
|
|
|
/* caller might not be interested in sense, but we need it */
|
|
|
|
if (!sshdr)
|
|
|
|
sshdr = &my_sshdr;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
retry:
|
2005-08-28 16:27:01 +00:00
|
|
|
use_10_for_ms = sdev->use_10_for_ms;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (use_10_for_ms) {
|
|
|
|
if (len < 8)
|
|
|
|
len = 8;
|
|
|
|
|
|
|
|
cmd[0] = MODE_SENSE_10;
|
|
|
|
cmd[8] = len;
|
|
|
|
header_length = 8;
|
|
|
|
} else {
|
|
|
|
if (len < 4)
|
|
|
|
len = 4;
|
|
|
|
|
|
|
|
cmd[0] = MODE_SENSE;
|
|
|
|
cmd[4] = len;
|
|
|
|
header_length = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(buffer, 0, len);
|
|
|
|
|
2005-08-28 16:27:01 +00:00
|
|
|
result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
|
2008-12-04 05:24:39 +00:00
|
|
|
sshdr, timeout, retries, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* This code looks awful: what it's doing is making sure an
|
|
|
|
* ILLEGAL REQUEST sense return identifies the actual command
|
|
|
|
* byte as the problem. MODE_SENSE commands can return
|
|
|
|
* ILLEGAL REQUEST if the code page isn't supported */
|
|
|
|
|
2005-08-28 16:27:01 +00:00
|
|
|
if (use_10_for_ms && !scsi_status_is_good(result) &&
|
|
|
|
(driver_byte(result) & DRIVER_SENSE)) {
|
2005-08-28 16:33:52 +00:00
|
|
|
if (scsi_sense_valid(sshdr)) {
|
|
|
|
if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
|
|
|
|
(sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Invalid command operation code
|
|
|
|
*/
|
2005-08-28 16:27:01 +00:00
|
|
|
sdev->use_10_for_ms = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-28 16:27:01 +00:00
|
|
|
if(scsi_status_is_good(result)) {
|
2006-02-23 01:03:16 +00:00
|
|
|
if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&
|
|
|
|
(modepage == 6 || modepage == 8))) {
|
|
|
|
/* Initio breakage? */
|
|
|
|
header_length = 0;
|
|
|
|
data->length = 13;
|
|
|
|
data->medium_type = 0;
|
|
|
|
data->device_specific = 0;
|
|
|
|
data->longlba = 0;
|
|
|
|
data->block_descriptor_length = 0;
|
|
|
|
} else if(use_10_for_ms) {
|
2005-04-16 22:20:36 +00:00
|
|
|
data->length = buffer[0]*256 + buffer[1] + 2;
|
|
|
|
data->medium_type = buffer[2];
|
|
|
|
data->device_specific = buffer[3];
|
|
|
|
data->longlba = buffer[4] & 0x01;
|
|
|
|
data->block_descriptor_length = buffer[6]*256
|
|
|
|
+ buffer[7];
|
|
|
|
} else {
|
|
|
|
data->length = buffer[0] + 1;
|
|
|
|
data->medium_type = buffer[1];
|
|
|
|
data->device_specific = buffer[2];
|
|
|
|
data->block_descriptor_length = buffer[3];
|
|
|
|
}
|
2006-02-23 01:03:16 +00:00
|
|
|
data->header_length = header_length;
|
2015-06-12 14:12:48 +00:00
|
|
|
} else if ((status_byte(result) == CHECK_CONDITION) &&
|
|
|
|
scsi_sense_valid(sshdr) &&
|
|
|
|
sshdr->sense_key == UNIT_ATTENTION && retry_count) {
|
|
|
|
retry_count--;
|
|
|
|
goto retry;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-28 16:27:01 +00:00
|
|
|
return result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_mode_sense);
|
|
|
|
|
2007-12-02 17:10:40 +00:00
|
|
|
/**
|
|
|
|
* scsi_test_unit_ready - test if unit is ready
|
|
|
|
* @sdev: scsi device to change the state of.
|
|
|
|
* @timeout: command timeout
|
|
|
|
* @retries: number of retries before failing
|
2017-02-14 19:15:57 +00:00
|
|
|
* @sshdr: outpout pointer for decoded sense information.
|
2007-12-02 17:10:40 +00:00
|
|
|
*
|
|
|
|
* Returns zero if unsuccessful or an error if TUR failed. For
|
2010-12-08 19:57:40 +00:00
|
|
|
* removable media, UNIT_ATTENTION sets ->changed flag.
|
2007-12-02 17:10:40 +00:00
|
|
|
**/
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
2007-12-02 17:10:40 +00:00
|
|
|
scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
|
2017-02-14 19:15:57 +00:00
|
|
|
struct scsi_sense_hdr *sshdr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char cmd[] = {
|
|
|
|
TEST_UNIT_READY, 0, 0, 0, 0, 0,
|
|
|
|
};
|
|
|
|
int result;
|
2007-12-02 17:10:40 +00:00
|
|
|
|
|
|
|
/* try to eat the UNIT_ATTENTION if there are enough retries */
|
|
|
|
do {
|
|
|
|
result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,
|
2008-12-04 05:24:39 +00:00
|
|
|
timeout, retries, NULL);
|
2008-08-19 22:58:13 +00:00
|
|
|
if (sdev->removable && scsi_sense_valid(sshdr) &&
|
|
|
|
sshdr->sense_key == UNIT_ATTENTION)
|
|
|
|
sdev->changed = 1;
|
|
|
|
} while (scsi_sense_valid(sshdr) &&
|
|
|
|
sshdr->sense_key == UNIT_ATTENTION && --retries);
|
2007-12-02 17:10:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_test_unit_ready);
|
|
|
|
|
|
|
|
/**
|
2007-11-03 18:30:39 +00:00
|
|
|
* scsi_device_set_state - Take the given device through the device state model.
|
2005-04-16 22:20:36 +00:00
|
|
|
* @sdev: scsi device to change the state of.
|
|
|
|
* @state: state to change to.
|
|
|
|
*
|
2017-08-25 11:56:56 +00:00
|
|
|
* Returns zero if successful or an error if the requested
|
2005-04-16 22:20:36 +00:00
|
|
|
* transition is illegal.
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
|
|
|
scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
|
|
|
|
{
|
|
|
|
enum scsi_device_state oldstate = sdev->sdev_state;
|
|
|
|
|
|
|
|
if (state == oldstate)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case SDEV_CREATED:
|
2008-08-22 21:53:31 +00:00
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_CREATED_BLOCK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
case SDEV_RUNNING:
|
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_CREATED:
|
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2005-04-16 22:20:36 +00:00
|
|
|
case SDEV_QUIESCE:
|
|
|
|
case SDEV_BLOCK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_QUIESCE:
|
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_RUNNING:
|
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_CREATED:
|
|
|
|
case SDEV_RUNNING:
|
|
|
|
case SDEV_QUIESCE:
|
|
|
|
case SDEV_BLOCK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_BLOCK:
|
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_RUNNING:
|
2008-08-22 21:53:31 +00:00
|
|
|
case SDEV_CREATED_BLOCK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_CREATED_BLOCK:
|
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_CREATED:
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_CANCEL:
|
|
|
|
switch (oldstate) {
|
|
|
|
case SDEV_CREATED:
|
|
|
|
case SDEV_RUNNING:
|
2006-06-23 18:25:34 +00:00
|
|
|
case SDEV_QUIESCE:
|
2005-04-16 22:20:36 +00:00
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SDEV_DEL:
|
|
|
|
switch (oldstate) {
|
[SCSI] scsi: Device scanning oops for offlined devices (resend)
If a device gets offlined as a result of the Inquiry sent
during scanning, the following oops can occur. After the
disk gets put into the SDEV_OFFLINE state, the error handler
sends back the failed inquiry, which wakes the thread doing
the scan. This starts a race between the scanning thread
freeing the scsi device and the error handler calling
scsi_run_host_queues to restart the host. Since the disk
is in the SDEV_OFFLINE state, scsi_device_get will still
work, which results in __scsi_iterate_devices getting
a reference to the scsi disk when it shouldn't.
The following execution thread causes the oops:
CPU 0 (scan) CPU 1 (eh)
---------------------------------------------------------
scsi_probe_and_add_lun
....
scsi_eh_offline_sdevs
scsi_eh_flush_done_q
scsi_destroy_sdev
scsi_device_dev_release
scsi_restart_operations
scsi_run_host_queues
__scsi_iterate_devices
get_device
scsi_device_dev_release_usercontext
scsi_run_queue
<---OOPS--->
The patch fixes this by changing the state of the sdev to SDEV_DEL
before doing the final put_device, which should prevent the race
from occurring.
Original oops follows:
Badness in kref_get at lib/kref.c:32
Call Trace:
[C00000002F4476D0] [C00000000000EE20] .show_stack+0x68/0x1b0 (unreliable)
[C00000002F447770] [C00000000037515C] .program_check_exception+0x1cc/0x5a8
[C00000002F447840] [C00000000000446C] program_check_common+0xec/0x100
Exception: 700 at .kref_get+0x10/0x28
LR = .kobject_get+0x20/0x3c
[C00000002F447B30] [C00000002F447BC0] 0xc00000002f447bc0 (unreliable)
[C00000002F447BB0] [C000000000254BDC] .get_device+0x20/0x3c
[C00000002F447C30] [D000000000063188] .scsi_device_get+0x34/0xdc [scsi_mod]
[C00000002F447CC0] [D0000000000633EC] .__scsi_iterate_devices+0x50/0xbc [scsi_mod]
[C00000002F447D60] [D00000000006A910] .scsi_run_host_queues+0x34/0x5c [scsi_mod]
[C00000002F447DF0] [D000000000069054] .scsi_error_handler+0xdb4/0xe44 [scsi_mod]
[C00000002F447EE0] [C00000000007B4E0] .kthread+0x128/0x178
[C00000002F447F90] [C000000000025E84] .kernel_thread+0x4c/0x68
Unable to handle kernel paging request for <7>PCI: Enabling device: (0002:41:01.1), cmd 143
data at address 0x000001b8
Faulting instruction address: 0xd0000000000698e4
sym1: <1010-66> rev 0x1 at pci 0002:41:01.1 irq 216
sym1: No NVRAM, ID 7, Fast-80, LVD, parity checking
sym1: SCSI BUS has been reset.
scsi2 : sym-2.2.2
cpu 0x0: Vector: 300 (Data Access) at [c00000002f447a30]
pc: d0000000000698e4: .scsi_run_queue+0x2c/0x218 [scsi_mod]
lr: d00000000006a904: .scsi_run_host_queues+0x28/0x5c [scsi_mod]
sp: c00000002f447cb0
msr: 9000000000009032
dar: 1b8
dsisr: 40000000
current = 0xc0000000045fecd0
paca = 0xc00000000048ee80
pid = 1123, comm = scsi_eh_1
enter ? for help
[c00000002f447d60] d00000000006a904 .scsi_run_host_queues+0x28/0x5c [scsi_mod]
[c00000002f447df0] d000000000069054 .scsi_error_handler+0xdb4/0xe44 [scsi_mod]
[c00000002f447ee0] c00000000007b4e0 .kthread+0x128/0x178
[c00000002f447f90] c000000000025e84 .kernel_thread+0x4c/0x68
Signed-off-by: Brian King <brking@us.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-27 16:10:43 +00:00
|
|
|
case SDEV_CREATED:
|
|
|
|
case SDEV_RUNNING:
|
|
|
|
case SDEV_OFFLINE:
|
2012-05-18 04:56:56 +00:00
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2005-04-16 22:20:36 +00:00
|
|
|
case SDEV_CANCEL:
|
2017-06-02 21:21:57 +00:00
|
|
|
case SDEV_BLOCK:
|
2013-07-02 13:06:33 +00:00
|
|
|
case SDEV_CREATED_BLOCK:
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto illegal;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
sdev->sdev_state = state;
|
2017-08-11 06:53:47 +00:00
|
|
|
sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
illegal:
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_ERROR_RECOVERY(1,
|
2005-10-02 16:45:08 +00:00
|
|
|
sdev_printk(KERN_ERR, sdev,
|
2014-06-25 14:39:59 +00:00
|
|
|
"Illegal state transition %s->%s",
|
2005-10-02 16:45:08 +00:00
|
|
|
scsi_device_state_name(oldstate),
|
|
|
|
scsi_device_state_name(state))
|
2005-04-16 22:20:36 +00:00
|
|
|
);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_device_set_state);
|
|
|
|
|
2007-10-29 21:15:22 +00:00
|
|
|
/**
|
|
|
|
* sdev_evt_emit - emit a single SCSI device uevent
|
|
|
|
* @sdev: associated SCSI device
|
|
|
|
* @evt: event to emit
|
|
|
|
*
|
|
|
|
* Send a single uevent (scsi_event) to the associated scsi_device.
|
|
|
|
*/
|
|
|
|
static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
|
|
|
|
{
|
|
|
|
int idx = 0;
|
|
|
|
char *envp[3];
|
|
|
|
|
|
|
|
switch (evt->evt_type) {
|
|
|
|
case SDEV_EVT_MEDIA_CHANGE:
|
|
|
|
envp[idx++] = "SDEV_MEDIA_CHANGE=1";
|
|
|
|
break;
|
2013-08-08 19:07:48 +00:00
|
|
|
case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
|
2016-02-19 08:17:16 +00:00
|
|
|
scsi_rescan_device(&sdev->sdev_gendev);
|
2013-08-08 19:07:48 +00:00
|
|
|
envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";
|
|
|
|
break;
|
|
|
|
case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
|
|
|
|
envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";
|
|
|
|
break;
|
|
|
|
case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
|
|
|
|
envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";
|
|
|
|
break;
|
|
|
|
case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
|
|
|
|
envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";
|
|
|
|
break;
|
|
|
|
case SDEV_EVT_LUN_CHANGE_REPORTED:
|
|
|
|
envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";
|
|
|
|
break;
|
2015-07-06 11:41:53 +00:00
|
|
|
case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED:
|
|
|
|
envp[idx++] = "SDEV_UA=ASYMMETRIC_ACCESS_STATE_CHANGED";
|
|
|
|
break;
|
2007-10-29 21:15:22 +00:00
|
|
|
default:
|
|
|
|
/* do nothing */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
envp[idx++] = NULL;
|
|
|
|
|
|
|
|
kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sdev_evt_thread - send a uevent for each scsi event
|
|
|
|
* @work: work struct for scsi_device
|
|
|
|
*
|
|
|
|
* Dispatch queued events to their associated scsi_device kobjects
|
|
|
|
* as uevents.
|
|
|
|
*/
|
|
|
|
void scsi_evt_thread(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
2013-08-08 19:07:48 +00:00
|
|
|
enum scsi_device_event evt_type;
|
2007-10-29 21:15:22 +00:00
|
|
|
LIST_HEAD(event_list);
|
|
|
|
|
|
|
|
sdev = container_of(work, struct scsi_device, event_work);
|
|
|
|
|
2013-08-08 19:07:48 +00:00
|
|
|
for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)
|
|
|
|
if (test_and_clear_bit(evt_type, sdev->pending_events))
|
|
|
|
sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);
|
|
|
|
|
2007-10-29 21:15:22 +00:00
|
|
|
while (1) {
|
|
|
|
struct scsi_event *evt;
|
|
|
|
struct list_head *this, *tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&sdev->list_lock, flags);
|
|
|
|
list_splice_init(&sdev->event_list, &event_list);
|
|
|
|
spin_unlock_irqrestore(&sdev->list_lock, flags);
|
|
|
|
|
|
|
|
if (list_empty(&event_list))
|
|
|
|
break;
|
|
|
|
|
|
|
|
list_for_each_safe(this, tmp, &event_list) {
|
|
|
|
evt = list_entry(this, struct scsi_event, node);
|
|
|
|
list_del(&evt->node);
|
|
|
|
scsi_evt_emit(sdev, evt);
|
|
|
|
kfree(evt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sdev_evt_send - send asserted event to uevent thread
|
|
|
|
* @sdev: scsi_device event occurred on
|
|
|
|
* @evt: event to send
|
|
|
|
*
|
|
|
|
* Assert scsi device event asynchronously.
|
|
|
|
*/
|
|
|
|
void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-19 12:04:47 +00:00
|
|
|
#if 0
|
|
|
|
/* FIXME: currently this check eliminates all media change events
|
|
|
|
* for polled devices. Need to update to discriminate between AN
|
|
|
|
* and polled events */
|
2007-10-29 21:15:22 +00:00
|
|
|
if (!test_bit(evt->evt_type, sdev->supported_events)) {
|
|
|
|
kfree(evt);
|
|
|
|
return;
|
|
|
|
}
|
2008-03-19 12:04:47 +00:00
|
|
|
#endif
|
2007-10-29 21:15:22 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&sdev->list_lock, flags);
|
|
|
|
list_add_tail(&evt->node, &sdev->event_list);
|
|
|
|
schedule_work(&sdev->event_work);
|
|
|
|
spin_unlock_irqrestore(&sdev->list_lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sdev_evt_send);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sdev_evt_alloc - allocate a new scsi event
|
|
|
|
* @evt_type: type of event to allocate
|
|
|
|
* @gfpflags: GFP flags for allocation
|
|
|
|
*
|
|
|
|
* Allocates and returns a new scsi_event.
|
|
|
|
*/
|
|
|
|
struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
|
|
|
|
gfp_t gfpflags)
|
|
|
|
{
|
|
|
|
struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);
|
|
|
|
if (!evt)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
evt->evt_type = evt_type;
|
|
|
|
INIT_LIST_HEAD(&evt->node);
|
|
|
|
|
|
|
|
/* evt_type-specific initialization, if any */
|
|
|
|
switch (evt_type) {
|
|
|
|
case SDEV_EVT_MEDIA_CHANGE:
|
2013-08-08 19:07:48 +00:00
|
|
|
case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
|
|
|
|
case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
|
|
|
|
case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
|
|
|
|
case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
|
|
|
|
case SDEV_EVT_LUN_CHANGE_REPORTED:
|
2015-07-06 11:41:53 +00:00
|
|
|
case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED:
|
2007-10-29 21:15:22 +00:00
|
|
|
default:
|
|
|
|
/* do nothing */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return evt;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sdev_evt_alloc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sdev_evt_send_simple - send asserted event to uevent thread
|
|
|
|
* @sdev: scsi_device event occurred on
|
|
|
|
* @evt_type: type of event to send
|
|
|
|
* @gfpflags: GFP flags for allocation
|
|
|
|
*
|
|
|
|
* Assert scsi device event asynchronously, given an event type.
|
|
|
|
*/
|
|
|
|
void sdev_evt_send_simple(struct scsi_device *sdev,
|
|
|
|
enum scsi_device_event evt_type, gfp_t gfpflags)
|
|
|
|
{
|
|
|
|
struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);
|
|
|
|
if (!evt) {
|
|
|
|
sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",
|
|
|
|
evt_type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sdev_evt_send(sdev, evt);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(sdev_evt_send_simple);
|
|
|
|
|
2016-11-23 00:17:13 +00:00
|
|
|
/**
|
|
|
|
* scsi_request_fn_active() - number of kernel threads inside scsi_request_fn()
|
|
|
|
* @sdev: SCSI device to count the number of scsi_request_fn() callers for.
|
|
|
|
*/
|
|
|
|
static int scsi_request_fn_active(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct request_queue *q = sdev->request_queue;
|
|
|
|
int request_fn_active;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(sdev->host->use_blk_mq);
|
|
|
|
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
request_fn_active = q->request_fn_active;
|
|
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
|
|
|
|
return request_fn_active;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_wait_for_queuecommand() - wait for ongoing queuecommand() calls
|
|
|
|
* @sdev: SCSI device pointer.
|
|
|
|
*
|
|
|
|
* Wait until the ongoing shost->hostt->queuecommand() calls that are
|
|
|
|
* invoked from scsi_request_fn() have finished.
|
|
|
|
*/
|
|
|
|
static void scsi_wait_for_queuecommand(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(sdev->host->use_blk_mq);
|
|
|
|
|
|
|
|
while (scsi_request_fn_active(sdev))
|
|
|
|
msleep(20);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_device_quiesce - Block user issued commands.
|
|
|
|
* @sdev: scsi device to quiesce.
|
|
|
|
*
|
|
|
|
* This works by trying to transition to the SDEV_QUIESCE state
|
|
|
|
* (which must be a legal transition). When the device is in this
|
|
|
|
* state, only special requests will be accepted, all others will
|
|
|
|
* be deferred. Since special requests may also be requeued requests,
|
|
|
|
* a successful return doesn't guarantee the device will be
|
|
|
|
* totally quiescent.
|
|
|
|
*
|
|
|
|
* Must be called with user context, may sleep.
|
|
|
|
*
|
|
|
|
* Returns zero if unsuccessful or an error if not.
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
|
|
|
scsi_device_quiesce(struct scsi_device *sdev)
|
|
|
|
{
|
2017-06-02 21:21:55 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
mutex_lock(&sdev->state_mutex);
|
|
|
|
err = scsi_device_set_state(sdev, SDEV_QUIESCE);
|
|
|
|
mutex_unlock(&sdev->state_mutex);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
scsi_run_queue(sdev->request_queue);
|
2014-04-11 17:07:01 +00:00
|
|
|
while (atomic_read(&sdev->device_busy)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
msleep_interruptible(200);
|
|
|
|
scsi_run_queue(sdev->request_queue);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_device_quiesce);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_device_resume - Restart user issued commands to a quiesced device.
|
|
|
|
* @sdev: scsi device to resume.
|
|
|
|
*
|
|
|
|
* Moves the device from quiesced back to running and restarts the
|
|
|
|
* queues.
|
|
|
|
*
|
|
|
|
* Must be called with user context, may sleep.
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2012-03-23 00:05:11 +00:00
|
|
|
void scsi_device_resume(struct scsi_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-03-23 00:05:11 +00:00
|
|
|
/* check if the device state was mutated prior to resume, and if
|
|
|
|
* so assume the state is being managed elsewhere (for example
|
|
|
|
* device deleted during suspend)
|
|
|
|
*/
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_lock(&sdev->state_mutex);
|
|
|
|
if (sdev->sdev_state == SDEV_QUIESCE &&
|
|
|
|
scsi_device_set_state(sdev, SDEV_RUNNING) == 0)
|
|
|
|
scsi_run_queue(sdev->request_queue);
|
|
|
|
mutex_unlock(&sdev->state_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_device_resume);
|
|
|
|
|
|
|
|
static void
|
|
|
|
device_quiesce_fn(struct scsi_device *sdev, void *data)
|
|
|
|
{
|
|
|
|
scsi_device_quiesce(sdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
scsi_target_quiesce(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
starget_for_each_device(starget, NULL, device_quiesce_fn);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_target_quiesce);
|
|
|
|
|
|
|
|
static void
|
|
|
|
device_resume_fn(struct scsi_device *sdev, void *data)
|
|
|
|
{
|
|
|
|
scsi_device_resume(sdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
scsi_target_resume(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
starget_for_each_device(starget, NULL, device_resume_fn);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_target_resume);
|
|
|
|
|
|
|
|
/**
|
2017-06-02 21:21:53 +00:00
|
|
|
* scsi_internal_device_block_nowait - try to transition to the SDEV_BLOCK state
|
|
|
|
* @sdev: device to block
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* Pause SCSI command processing on the specified device. Does not sleep.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* Returns zero if successful or a negative error code upon failure.
|
2016-11-23 00:17:13 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* Notes:
|
|
|
|
* This routine transitions the device to the SDEV_BLOCK state (which must be
|
|
|
|
* a legal transition). When the device is in this state, command processing
|
|
|
|
* is paused until the device leaves the SDEV_BLOCK state. See also
|
|
|
|
* scsi_internal_device_unblock_nowait().
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2017-06-02 21:21:53 +00:00
|
|
|
int scsi_internal_device_block_nowait(struct scsi_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-07-24 07:28:11 +00:00
|
|
|
struct request_queue *q = sdev->request_queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
err = scsi_device_set_state(sdev, SDEV_BLOCK);
|
2008-08-22 21:53:31 +00:00
|
|
|
if (err) {
|
|
|
|
err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The device has transitioned to SDEV_BLOCK. Stop the
|
|
|
|
* block layer from calling the midlayer with this device's
|
|
|
|
* request queue.
|
|
|
|
*/
|
2014-01-17 11:06:53 +00:00
|
|
|
if (q->mq_ops) {
|
SCSI misc on 20170704
This is mostly updates of the usual suspects: lpfc, qla2xxx, bnx2fc,
qedf, hpsa, hisi_sas, smartpqi, cxlflash, aacraid, csiostor along with
a host of minor and miscellaneous changes.
Signed-off-by: James E.J. Bottomley <jejb@linux.vnet.ibm.com>
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAABAgAGBQJZW7JMAAoJEAVr7HOZEZN4IM4P/AqBtvH+6Lo1Eb+3A/HnHskK
hIxVxgBxaw3fhW5AegDfVCvrdVTTEkCB/g5CIKN8NCWEx6OGmCX0Lu6lnjld9BOZ
cTlPtzNwFGlgHrz34LwCc3vlc5ovMpTQBrpGAQpGGWoAZIP+c3ilEihIYTEMNCsN
dmjI71AigDE5g6X1OT361IJ1gydkjfG41IcRe/jlMtEgRNdy3B2JVIdATL89Pw4b
0uZO3uUTn8EGEKUdyJZCNpie7sGZv8u2LhA+Znby2C4h3bwWNV/d0p7ped4xrQY5
yVpZEUbYVdcOOYBgeBJlfwOhvjRQTdxeK4d7W9XTb+AQf30F3DgSepdMCdf3BjVt
KnQvBOTxyidB8xsCL46wlxxNew3qoUtaKoY88WUOOnnJwU5U7hlRtPkf/eO2i5QF
+k7fxUpFfkBTS4I2gXnyGWpmSoxwJerd0knojSOjrjJcAlcgM65+pocUAea/0Dpr
SsfL2sTb12gk6bkF9UlRv8/4aSsWYb92WW1nbTt2nFRXncPNN5Qzc3lGj//36O+b
2bka+aSKVAFoNAnQ1pUE8EJxSboy5q7y4509iZzO/Fom+pVuzBROm5fmrpcOE5dP
IjW7gqSFB6578tnNiK049rrrPja5wkUa+Ptc8s0FjPAVyIDrp2RN+f2nljOBBhW8
3Z1nXMG0eFqvb5taLtfZ
=D9QX
-----END PGP SIGNATURE-----
Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI updates from James Bottomley:
"This is mostly updates of the usual suspects: lpfc, qla2xxx, bnx2fc,
qedf, hpsa, hisi_sas, smartpqi, cxlflash, aacraid, csiostor along with
a host of minor and miscellaneous changes"
* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (276 commits)
qla2xxx: Fix NVMe entry_type for iocb packet on BE system
scsi: qla2xxx: avoid unused-function warning
scsi: snic: fix a couple of spelling mistakes/typos
scsi: qla2xxx: fix a bunch of typos and spelling mistakes
scsi: lpfc: don't double count abort errors
scsi: lpfc: spin_lock_irq() is not nestable
scsi: hisi_sas: optimise DMA slot memory
scsi: ibmvfc: constify dev_pm_ops structures.
scsi: ibmvscsi: constify dev_pm_ops structures.
scsi: cxlflash: Update debug prints in reset handlers
scsi: cxlflash: Update send_tmf() parameters
scsi: cxlflash: Avoid double free of character device
scsi: Add STARGET_CREATED_REMOVE state to scsi_target_state
scsi: ses: do not add a device to an enclosure if enclosure_add_links() fails.
scsi: ufs: flush eh_work when eh_work scheduled.
scsi: qla2xxx: Protect access to qpair members with qpair->qp_lock
scsi: sun_esp: fix device reference leaks
scsi: fnic: changing queue command to return result DID_IMM_RETRY when rport is init
scsi: fnic: correct speed display and add support for 25,40 and 100G
scsi: fnic: added timestamp reporting in fnic debug stats
...
2017-07-06 19:10:33 +00:00
|
|
|
blk_mq_quiesce_queue_nowait(q);
|
2014-01-17 11:06:53 +00:00
|
|
|
} else {
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
blk_stop_queue(q);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-06-02 21:21:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2017-06-02 21:21:53 +00:00
|
|
|
* scsi_internal_device_block - try to transition to the SDEV_BLOCK state
|
|
|
|
* @sdev: device to block
|
|
|
|
*
|
|
|
|
* Pause SCSI command processing on the specified device and wait until all
|
|
|
|
* ongoing scsi_request_fn() / scsi_queue_rq() calls have finished. May sleep.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* Returns zero if successful or a negative error code upon failure.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* Note:
|
|
|
|
* This routine transitions the device to the SDEV_BLOCK state (which must be
|
|
|
|
* a legal transition). When the device is in this state, command processing
|
|
|
|
* is paused until the device leaves the SDEV_BLOCK state. See also
|
|
|
|
* scsi_internal_device_unblock().
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:53 +00:00
|
|
|
* To do: avoid that scsi_send_eh_cmnd() calls queuecommand() after
|
|
|
|
* scsi_internal_device_block() has blocked a SCSI device and also
|
|
|
|
* remove the rport mutex lock and unlock calls from srp_queuecommand().
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2017-06-02 21:21:53 +00:00
|
|
|
static int scsi_internal_device_block(struct scsi_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-06-02 21:21:53 +00:00
|
|
|
struct request_queue *q = sdev->request_queue;
|
|
|
|
int err;
|
|
|
|
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_lock(&sdev->state_mutex);
|
2017-06-02 21:21:53 +00:00
|
|
|
err = scsi_internal_device_block_nowait(sdev);
|
|
|
|
if (err == 0) {
|
|
|
|
if (q->mq_ops)
|
|
|
|
blk_mq_quiesce_queue(q);
|
|
|
|
else
|
|
|
|
scsi_wait_for_queuecommand(sdev);
|
|
|
|
}
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_unlock(&sdev->state_mutex);
|
|
|
|
|
2017-06-02 21:21:53 +00:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-02 21:21:56 +00:00
|
|
|
void scsi_start_queue(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct request_queue *q = sdev->request_queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2012-05-18 04:56:57 +00:00
|
|
|
|
2017-06-02 21:21:56 +00:00
|
|
|
if (q->mq_ops) {
|
SCSI misc on 20170704
This is mostly updates of the usual suspects: lpfc, qla2xxx, bnx2fc,
qedf, hpsa, hisi_sas, smartpqi, cxlflash, aacraid, csiostor along with
a host of minor and miscellaneous changes.
Signed-off-by: James E.J. Bottomley <jejb@linux.vnet.ibm.com>
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAABAgAGBQJZW7JMAAoJEAVr7HOZEZN4IM4P/AqBtvH+6Lo1Eb+3A/HnHskK
hIxVxgBxaw3fhW5AegDfVCvrdVTTEkCB/g5CIKN8NCWEx6OGmCX0Lu6lnjld9BOZ
cTlPtzNwFGlgHrz34LwCc3vlc5ovMpTQBrpGAQpGGWoAZIP+c3ilEihIYTEMNCsN
dmjI71AigDE5g6X1OT361IJ1gydkjfG41IcRe/jlMtEgRNdy3B2JVIdATL89Pw4b
0uZO3uUTn8EGEKUdyJZCNpie7sGZv8u2LhA+Znby2C4h3bwWNV/d0p7ped4xrQY5
yVpZEUbYVdcOOYBgeBJlfwOhvjRQTdxeK4d7W9XTb+AQf30F3DgSepdMCdf3BjVt
KnQvBOTxyidB8xsCL46wlxxNew3qoUtaKoY88WUOOnnJwU5U7hlRtPkf/eO2i5QF
+k7fxUpFfkBTS4I2gXnyGWpmSoxwJerd0knojSOjrjJcAlcgM65+pocUAea/0Dpr
SsfL2sTb12gk6bkF9UlRv8/4aSsWYb92WW1nbTt2nFRXncPNN5Qzc3lGj//36O+b
2bka+aSKVAFoNAnQ1pUE8EJxSboy5q7y4509iZzO/Fom+pVuzBROm5fmrpcOE5dP
IjW7gqSFB6578tnNiK049rrrPja5wkUa+Ptc8s0FjPAVyIDrp2RN+f2nljOBBhW8
3Z1nXMG0eFqvb5taLtfZ
=D9QX
-----END PGP SIGNATURE-----
Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI updates from James Bottomley:
"This is mostly updates of the usual suspects: lpfc, qla2xxx, bnx2fc,
qedf, hpsa, hisi_sas, smartpqi, cxlflash, aacraid, csiostor along with
a host of minor and miscellaneous changes"
* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (276 commits)
qla2xxx: Fix NVMe entry_type for iocb packet on BE system
scsi: qla2xxx: avoid unused-function warning
scsi: snic: fix a couple of spelling mistakes/typos
scsi: qla2xxx: fix a bunch of typos and spelling mistakes
scsi: lpfc: don't double count abort errors
scsi: lpfc: spin_lock_irq() is not nestable
scsi: hisi_sas: optimise DMA slot memory
scsi: ibmvfc: constify dev_pm_ops structures.
scsi: ibmvscsi: constify dev_pm_ops structures.
scsi: cxlflash: Update debug prints in reset handlers
scsi: cxlflash: Update send_tmf() parameters
scsi: cxlflash: Avoid double free of character device
scsi: Add STARGET_CREATED_REMOVE state to scsi_target_state
scsi: ses: do not add a device to an enclosure if enclosure_add_links() fails.
scsi: ufs: flush eh_work when eh_work scheduled.
scsi: qla2xxx: Protect access to qpair members with qpair->qp_lock
scsi: sun_esp: fix device reference leaks
scsi: fnic: changing queue command to return result DID_IMM_RETRY when rport is init
scsi: fnic: correct speed display and add support for 25,40 and 100G
scsi: fnic: added timestamp reporting in fnic debug stats
...
2017-07-06 19:10:33 +00:00
|
|
|
blk_mq_unquiesce_queue(q);
|
2017-06-02 21:21:56 +00:00
|
|
|
} else {
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
blk_start_queue(q);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2017-06-02 21:21:54 +00:00
|
|
|
* scsi_internal_device_unblock_nowait - resume a device after a block request
|
2005-04-16 22:20:36 +00:00
|
|
|
* @sdev: device to resume
|
2017-06-02 21:21:54 +00:00
|
|
|
* @new_state: state to set the device to after unblocking
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:54 +00:00
|
|
|
* Restart the device queue for a previously suspended SCSI device. Does not
|
|
|
|
* sleep.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:54 +00:00
|
|
|
* Returns zero if successful or a negative error code upon failure.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2017-06-02 21:21:54 +00:00
|
|
|
* Notes:
|
|
|
|
* This routine transitions the device to the SDEV_RUNNING state or to one of
|
|
|
|
* the offline states (which must be a legal transition) allowing the midlayer
|
|
|
|
* to goose the queue for this device.
|
2007-11-03 18:30:39 +00:00
|
|
|
*/
|
2017-06-02 21:21:54 +00:00
|
|
|
int scsi_internal_device_unblock_nowait(struct scsi_device *sdev,
|
|
|
|
enum scsi_device_state new_state)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-05-18 04:56:57 +00:00
|
|
|
/*
|
|
|
|
* Try to transition the scsi device to SDEV_RUNNING or one of the
|
|
|
|
* offlined states and goose the device queue if successful.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2017-08-11 06:53:46 +00:00
|
|
|
switch (sdev->sdev_state) {
|
|
|
|
case SDEV_BLOCK:
|
|
|
|
case SDEV_TRANSPORT_OFFLINE:
|
2012-05-18 04:56:57 +00:00
|
|
|
sdev->sdev_state = new_state;
|
2017-08-11 06:53:47 +00:00
|
|
|
sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
|
2017-08-11 06:53:46 +00:00
|
|
|
break;
|
|
|
|
case SDEV_CREATED_BLOCK:
|
2012-05-18 04:56:57 +00:00
|
|
|
if (new_state == SDEV_TRANSPORT_OFFLINE ||
|
|
|
|
new_state == SDEV_OFFLINE)
|
|
|
|
sdev->sdev_state = new_state;
|
|
|
|
else
|
|
|
|
sdev->sdev_state = SDEV_CREATED;
|
2017-08-11 06:53:47 +00:00
|
|
|
sysfs_notify(&sdev->sdev_gendev.kobj, NULL, "state");
|
2017-08-11 06:53:46 +00:00
|
|
|
break;
|
|
|
|
case SDEV_CANCEL:
|
|
|
|
case SDEV_OFFLINE:
|
|
|
|
break;
|
|
|
|
default:
|
2009-04-29 16:13:02 +00:00
|
|
|
return -EINVAL;
|
2017-08-11 06:53:46 +00:00
|
|
|
}
|
2017-06-02 21:21:56 +00:00
|
|
|
scsi_start_queue(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-06-02 21:21:54 +00:00
|
|
|
EXPORT_SYMBOL_GPL(scsi_internal_device_unblock_nowait);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_internal_device_unblock - resume a device after a block request
|
|
|
|
* @sdev: device to resume
|
|
|
|
* @new_state: state to set the device to after unblocking
|
|
|
|
*
|
|
|
|
* Restart the device queue for a previously suspended SCSI device. May sleep.
|
|
|
|
*
|
|
|
|
* Returns zero if successful or a negative error code upon failure.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* This routine transitions the device to the SDEV_RUNNING state or to one of
|
|
|
|
* the offline states (which must be a legal transition) allowing the midlayer
|
|
|
|
* to goose the queue for this device.
|
|
|
|
*/
|
|
|
|
static int scsi_internal_device_unblock(struct scsi_device *sdev,
|
|
|
|
enum scsi_device_state new_state)
|
|
|
|
{
|
2017-06-02 21:21:55 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&sdev->state_mutex);
|
|
|
|
ret = scsi_internal_device_unblock_nowait(sdev, new_state);
|
|
|
|
mutex_unlock(&sdev->state_mutex);
|
|
|
|
|
|
|
|
return ret;
|
2017-06-02 21:21:54 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
device_block(struct scsi_device *sdev, void *data)
|
|
|
|
{
|
2017-06-02 21:21:53 +00:00
|
|
|
scsi_internal_device_block(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
target_block(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
if (scsi_is_target_device(dev))
|
|
|
|
starget_for_each_device(to_scsi_target(dev), NULL,
|
|
|
|
device_block);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
scsi_target_block(struct device *dev)
|
|
|
|
{
|
|
|
|
if (scsi_is_target_device(dev))
|
|
|
|
starget_for_each_device(to_scsi_target(dev), NULL,
|
|
|
|
device_block);
|
|
|
|
else
|
|
|
|
device_for_each_child(dev, NULL, target_block);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_target_block);
|
|
|
|
|
|
|
|
static void
|
|
|
|
device_unblock(struct scsi_device *sdev, void *data)
|
|
|
|
{
|
2012-05-18 04:56:57 +00:00
|
|
|
scsi_internal_device_unblock(sdev, *(enum scsi_device_state *)data);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
target_unblock(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
if (scsi_is_target_device(dev))
|
2012-05-18 04:56:57 +00:00
|
|
|
starget_for_each_device(to_scsi_target(dev), data,
|
2005-04-16 22:20:36 +00:00
|
|
|
device_unblock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-05-18 04:56:57 +00:00
|
|
|
scsi_target_unblock(struct device *dev, enum scsi_device_state new_state)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (scsi_is_target_device(dev))
|
2012-05-18 04:56:57 +00:00
|
|
|
starget_for_each_device(to_scsi_target(dev), &new_state,
|
2005-04-16 22:20:36 +00:00
|
|
|
device_unblock);
|
|
|
|
else
|
2012-05-18 04:56:57 +00:00
|
|
|
device_for_each_child(dev, &new_state, target_unblock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_target_unblock);
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_kmap_atomic_sg - find and atomically map an sg-elemnt
|
2007-11-03 18:30:39 +00:00
|
|
|
* @sgl: scatter-gather list
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
* @sg_count: number of segments in sg
|
|
|
|
* @offset: offset in bytes into sg, on return offset into the mapped area
|
|
|
|
* @len: bytes to map, on return number of bytes mapped
|
|
|
|
*
|
|
|
|
* Returns virtual address of the start of the mapped page
|
|
|
|
*/
|
2007-10-16 09:08:49 +00:00
|
|
|
void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count,
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
size_t *offset, size_t *len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t sg_len = 0, len_complete = 0;
|
2007-10-16 09:08:49 +00:00
|
|
|
struct scatterlist *sg;
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
struct page *page;
|
|
|
|
|
2007-02-06 00:39:03 +00:00
|
|
|
WARN_ON(!irqs_disabled());
|
|
|
|
|
2007-10-16 09:08:49 +00:00
|
|
|
for_each_sg(sgl, sg, sg_count, i) {
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
len_complete = sg_len; /* Complete sg-entries */
|
2007-10-16 09:08:49 +00:00
|
|
|
sg_len += sg->length;
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
if (sg_len > *offset)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(i == sg_count)) {
|
2006-04-19 04:09:08 +00:00
|
|
|
printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, "
|
|
|
|
"elements %d\n",
|
2008-07-04 06:47:27 +00:00
|
|
|
__func__, sg_len, *offset, sg_count);
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
WARN_ON(1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Offset starting from the beginning of first page in this sg-entry */
|
2007-10-16 09:08:49 +00:00
|
|
|
*offset = *offset - len_complete + sg->offset;
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
|
|
|
|
/* Assumption: contiguous pages can be accessed as "page + i" */
|
2007-10-22 19:19:53 +00:00
|
|
|
page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT));
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
*offset &= ~PAGE_MASK;
|
|
|
|
|
|
|
|
/* Bytes in this sg-entry from *offset to the end of the page */
|
|
|
|
sg_len = PAGE_SIZE - *offset;
|
|
|
|
if (*len > sg_len)
|
|
|
|
*len = sg_len;
|
|
|
|
|
2011-11-25 15:14:23 +00:00
|
|
|
return kmap_atomic(page);
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_kmap_atomic_sg);
|
|
|
|
|
|
|
|
/**
|
2007-11-03 18:30:39 +00:00
|
|
|
* scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
* @virt: virtual address to be unmapped
|
|
|
|
*/
|
|
|
|
void scsi_kunmap_atomic_sg(void *virt)
|
|
|
|
{
|
2011-11-25 15:14:23 +00:00
|
|
|
kunmap_atomic(virt);
|
[SCSI] dc395x: dynamically map scatter-gather for PIO
The current dc395x driver uses PIO to transfer up to 4 bytes which do not
get transferred by DMA (under unclear circumstances). For this the driver
uses page_address() which is broken on highmem. Apart from this the
actual calculation of the virtual address is wrong (even without highmem).
So, e.g., for reading it reads bytes from the driver to a wrong address
and returns wrong data, I guess, for writing it would just output random
data to the device.
The proper fix, as suggested by many, is to dynamically map data using
kmap_atomic(page, KM_BIO_SRC_IRQ) / kunmap_atomic(virt). The reason why it
has not been done until now, although I've done some preliminary patches
more than a year ago was that nobody interested in fixing this problem was
able to reliably reproduce it. Now it changed - with the help from
Sebastian Frei (CC'ed) I was able to trigger the PIO path. Thus, I was
also able to test and debug it.
There are 4 cases when PIO is used in dc395x - data-in / -out with and
without scatter-gather. I was able to reproduce and test only data-in with
and without SG. So, the data-out path is still untested, but it is also
somewhat simpler than the data-in. Fredrik Roubert (also CC'ed) also had
PIO triggering on his system, and in his case it was data-out without SG.
It would be great if he could test the attached patch on his system, but
even if he cannot, I would still request to apply the patch and just wait
if anybody cries...
Implementation: I put 2 new functions in scsi_lib.c and their declarations
in scsi_cmnd.h. I exported them without _GPL, although, I don't feel
strongly about that - not many drivers are likely to use them. But there
is at least one more - I want to use them in tmscsim.c. Whether these are
the right files for the functions and their declarations - not sure
either. Actually, they are not scsi-specific, so, might go somewhere
around other scattergather magic? They are not platform specific either,
and most SG functions are defined under arch/*/... As these issues were
discussed previously there were some more routines suggested to manipulate
scattergather buffers, I think, some of them were needed around
crypto code... So, might be a common place reasonable, like
lib/scattergather.c? I am open here.
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-04-02 19:57:43 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_kunmap_atomic_sg);
|
2013-01-23 07:09:32 +00:00
|
|
|
|
|
|
|
void sdev_disable_disk_events(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
atomic_inc(&sdev->disk_events_disable_depth);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sdev_disable_disk_events);
|
|
|
|
|
|
|
|
void sdev_enable_disk_events(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(atomic_read(&sdev->disk_events_disable_depth) <= 0))
|
|
|
|
return;
|
|
|
|
atomic_dec(&sdev->disk_events_disable_depth);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sdev_enable_disk_events);
|
2015-12-01 09:16:55 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_vpd_lun_id - return a unique device identification
|
|
|
|
* @sdev: SCSI device
|
|
|
|
* @id: buffer for the identification
|
|
|
|
* @id_len: length of the buffer
|
|
|
|
*
|
|
|
|
* Copies a unique device identification into @id based
|
|
|
|
* on the information in the VPD page 0x83 of the device.
|
|
|
|
* The string will be formatted as a SCSI name string.
|
|
|
|
*
|
|
|
|
* Returns the length of the identification or error on failure.
|
|
|
|
* If the identifier is longer than the supplied buffer the actual
|
|
|
|
* identifier length is returned and the buffer is not zero-padded.
|
|
|
|
*/
|
|
|
|
int scsi_vpd_lun_id(struct scsi_device *sdev, char *id, size_t id_len)
|
|
|
|
{
|
|
|
|
u8 cur_id_type = 0xff;
|
|
|
|
u8 cur_id_size = 0;
|
2017-08-29 15:50:13 +00:00
|
|
|
const unsigned char *d, *cur_id_str;
|
|
|
|
const struct scsi_vpd *vpd_pg83;
|
2015-12-01 09:16:55 +00:00
|
|
|
int id_size = -EINVAL;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
vpd_pg83 = rcu_dereference(sdev->vpd_pg83);
|
|
|
|
if (!vpd_pg83) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look for the correct descriptor.
|
|
|
|
* Order of preference for lun descriptor:
|
|
|
|
* - SCSI name string
|
|
|
|
* - NAA IEEE Registered Extended
|
|
|
|
* - EUI-64 based 16-byte
|
|
|
|
* - EUI-64 based 12-byte
|
|
|
|
* - NAA IEEE Registered
|
|
|
|
* - NAA IEEE Extended
|
2016-05-09 07:14:29 +00:00
|
|
|
* - T10 Vendor ID
|
2015-12-01 09:16:55 +00:00
|
|
|
* as longer descriptors reduce the likelyhood
|
|
|
|
* of identification clashes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* The id string must be at least 20 bytes + terminating NULL byte */
|
|
|
|
if (id_len < 21) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(id, 0, id_len);
|
2017-08-29 15:50:13 +00:00
|
|
|
d = vpd_pg83->data + 4;
|
|
|
|
while (d < vpd_pg83->data + vpd_pg83->len) {
|
2015-12-01 09:16:55 +00:00
|
|
|
/* Skip designators not referring to the LUN */
|
|
|
|
if ((d[1] & 0x30) != 0x00)
|
|
|
|
goto next_desig;
|
|
|
|
|
|
|
|
switch (d[1] & 0xf) {
|
2016-05-09 07:14:29 +00:00
|
|
|
case 0x1:
|
|
|
|
/* T10 Vendor ID */
|
|
|
|
if (cur_id_size > d[3])
|
|
|
|
break;
|
|
|
|
/* Prefer anything */
|
|
|
|
if (cur_id_type > 0x01 && cur_id_type != 0xff)
|
|
|
|
break;
|
|
|
|
cur_id_size = d[3];
|
|
|
|
if (cur_id_size + 4 > id_len)
|
|
|
|
cur_id_size = id_len - 4;
|
|
|
|
cur_id_str = d + 4;
|
|
|
|
cur_id_type = d[1] & 0xf;
|
|
|
|
id_size = snprintf(id, id_len, "t10.%*pE",
|
|
|
|
cur_id_size, cur_id_str);
|
|
|
|
break;
|
2015-12-01 09:16:55 +00:00
|
|
|
case 0x2:
|
|
|
|
/* EUI-64 */
|
|
|
|
if (cur_id_size > d[3])
|
|
|
|
break;
|
|
|
|
/* Prefer NAA IEEE Registered Extended */
|
|
|
|
if (cur_id_type == 0x3 &&
|
|
|
|
cur_id_size == d[3])
|
|
|
|
break;
|
|
|
|
cur_id_size = d[3];
|
|
|
|
cur_id_str = d + 4;
|
|
|
|
cur_id_type = d[1] & 0xf;
|
|
|
|
switch (cur_id_size) {
|
|
|
|
case 8:
|
|
|
|
id_size = snprintf(id, id_len,
|
|
|
|
"eui.%8phN",
|
|
|
|
cur_id_str);
|
|
|
|
break;
|
|
|
|
case 12:
|
|
|
|
id_size = snprintf(id, id_len,
|
|
|
|
"eui.%12phN",
|
|
|
|
cur_id_str);
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
id_size = snprintf(id, id_len,
|
|
|
|
"eui.%16phN",
|
|
|
|
cur_id_str);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cur_id_size = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x3:
|
|
|
|
/* NAA */
|
|
|
|
if (cur_id_size > d[3])
|
|
|
|
break;
|
|
|
|
cur_id_size = d[3];
|
|
|
|
cur_id_str = d + 4;
|
|
|
|
cur_id_type = d[1] & 0xf;
|
|
|
|
switch (cur_id_size) {
|
|
|
|
case 8:
|
|
|
|
id_size = snprintf(id, id_len,
|
|
|
|
"naa.%8phN",
|
|
|
|
cur_id_str);
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
id_size = snprintf(id, id_len,
|
|
|
|
"naa.%16phN",
|
|
|
|
cur_id_str);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cur_id_size = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x8:
|
|
|
|
/* SCSI name string */
|
|
|
|
if (cur_id_size + 4 > d[3])
|
|
|
|
break;
|
|
|
|
/* Prefer others for truncated descriptor */
|
|
|
|
if (cur_id_size && d[3] > id_len)
|
|
|
|
break;
|
|
|
|
cur_id_size = id_size = d[3];
|
|
|
|
cur_id_str = d + 4;
|
|
|
|
cur_id_type = d[1] & 0xf;
|
|
|
|
if (cur_id_size >= id_len)
|
|
|
|
cur_id_size = id_len - 1;
|
|
|
|
memcpy(id, cur_id_str, cur_id_size);
|
|
|
|
/* Decrease priority for truncated descriptor */
|
|
|
|
if (cur_id_size != id_size)
|
|
|
|
cur_id_size = 6;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next_desig:
|
|
|
|
d += d[3] + 4;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return id_size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_vpd_lun_id);
|
2015-12-01 09:16:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* scsi_vpd_tpg_id - return a target port group identifier
|
|
|
|
* @sdev: SCSI device
|
|
|
|
*
|
|
|
|
* Returns the Target Port Group identifier from the information
|
|
|
|
* froom VPD page 0x83 of the device.
|
|
|
|
*
|
|
|
|
* Returns the identifier or error on failure.
|
|
|
|
*/
|
|
|
|
int scsi_vpd_tpg_id(struct scsi_device *sdev, int *rel_id)
|
|
|
|
{
|
2017-08-29 15:50:13 +00:00
|
|
|
const unsigned char *d;
|
|
|
|
const struct scsi_vpd *vpd_pg83;
|
2015-12-01 09:16:57 +00:00
|
|
|
int group_id = -EAGAIN, rel_port = -1;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
vpd_pg83 = rcu_dereference(sdev->vpd_pg83);
|
|
|
|
if (!vpd_pg83) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
2017-08-29 15:50:13 +00:00
|
|
|
d = vpd_pg83->data + 4;
|
|
|
|
while (d < vpd_pg83->data + vpd_pg83->len) {
|
2015-12-01 09:16:57 +00:00
|
|
|
switch (d[1] & 0xf) {
|
|
|
|
case 0x4:
|
|
|
|
/* Relative target port */
|
|
|
|
rel_port = get_unaligned_be16(&d[6]);
|
|
|
|
break;
|
|
|
|
case 0x5:
|
|
|
|
/* Target port group */
|
|
|
|
group_id = get_unaligned_be16(&d[6]);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
d += d[3] + 4;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (group_id >= 0 && rel_id && rel_port != -1)
|
|
|
|
*rel_id = rel_port;
|
|
|
|
|
|
|
|
return group_id;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_vpd_tpg_id);
|